wip

src/WebView.android.tsx

 import invariant from 'invariant';
 
 import {
-  defaultOriginWhitelist,
   createOnShouldStartLoadWithRequest,
   getViewManagerConfig,
 } from './WebViewShared';
     saveFormDataDisabled: false,
     cacheEnabled: true,
     androidHardwareAccelerationDisabled: false,
-    originWhitelist: defaultOriginWhitelist,
   };
 
   static isFileUploadSupported = async () => {
     shouldStart: boolean,
     url: string,
   ) => {
-    if (shouldStart) {
-      UIManager.dispatchViewManagerCommand(
-        this.getWebViewHandle(),
-        this.getCommands().loadUrl,
-        [String(url)],
-      );
+    if (!shouldStart) {
+      return;
     }
+    UIManager.dispatchViewManagerCommand(
+      this.getWebViewHandle(),
+      this.getCommands().loadUrl,
+      [String(url)],
+    );
   };
 
   render() {
     const {
       onMessage,
       onShouldStartLoadWithRequest: onShouldStartLoadWithRequestProp,
-      originWhitelist,
       renderError,
       renderLoading,
       source,
 
     const onShouldStartLoadWithRequest = createOnShouldStartLoadWithRequest(
       this.onShouldStartLoadWithRequestCallback,
-      // casting cause it's in the default props
-      originWhitelist as ReadonlyArray<string>,
       onShouldStartLoadWithRequestProp,
     );
 

src/WebView.ios.tsx

 import invariant from 'invariant';
 
 import {
-  defaultOriginWhitelist,
   createOnShouldStartLoadWithRequest,
   getViewManagerConfig,
 } from './WebViewShared';
   static defaultProps = {
     useWebKit: true,
     cacheEnabled: true,
-    originWhitelist: defaultOriginWhitelist,
     useSharedProcessPool: true,
   };
 
       viewManager = viewManager || RNCUIWebViewManager;
     }
     invariant(viewManager != null, 'viewManager expected to be non-null');
-    viewManager.startLoadWithResult(!!shouldStart, lockIdentifier);
+    viewManager.startLoadWithResult(shouldStart, lockIdentifier);
   };
 
   componentDidUpdate(prevProps: IOSWebViewProps) {
       nativeConfig = {},
       onMessage,
       onShouldStartLoadWithRequest: onShouldStartLoadWithRequestProp,
-      originWhitelist,
       renderError,
       renderLoading,
       scalesPageToFit = this.props.useWebKit ? undefined : true,
 
     const onShouldStartLoadWithRequest = createOnShouldStartLoadWithRequest(
       this.onShouldStartLoadWithRequestCallback,
-      // casting cause it's in the default props
-      originWhitelist as ReadonlyArray<string>,
       onShouldStartLoadWithRequestProp,
     );
 

src/WebViewShared.ts

-import escapeStringRegexp from 'escape-string-regexp';
-import { Linking, UIManager as NotTypedUIManager } from 'react-native';
+import { UIManager as NotTypedUIManager } from 'react-native';
 import {
   WebViewNavigationEvent,
   OnShouldStartLoadWithRequest,
 
 const UIManager = NotTypedUIManager as CustomUIManager;
 
-const defaultOriginWhitelist = ['http://*', 'https://*'];
-
-const extractOrigin = (url: string): string => {
-  const result = /^[A-Za-z][A-Za-z0-9+\-.]+:(\/\/)?[^/]*/.exec(url);
-  return result === null ? '' : result[0];
-};
-
-const originWhitelistToRegex = (originWhitelist: string): string =>
-  `^${escapeStringRegexp(originWhitelist).replace(/\\\*/g, '.*')}`;
-
-const passesWhitelist = (
-  compiledWhitelist: ReadonlyArray<string>,
-  url: string,
-) => {
-  const origin = extractOrigin(url);
-  return compiledWhitelist.some(x => new RegExp(x).test(origin));
-};
-
-const compileWhitelist = (
-  originWhitelist: ReadonlyArray<string>,
-): ReadonlyArray<string> =>
-  ['about:blank', ...(originWhitelist || [])].map(originWhitelistToRegex);
-
 const createOnShouldStartLoadWithRequest = (
   loadRequest: (
     shouldStart: boolean,
     url: string,
     lockIdentifier: number,
   ) => void,
-  originWhitelist: ReadonlyArray<string>,
   onShouldStartLoadWithRequest?: OnShouldStartLoadWithRequest,
 ) => {
   return ({ nativeEvent }: WebViewNavigationEvent) => {
-    let shouldStart = true;
     const { url, lockIdentifier } = nativeEvent;
 
-    if (!passesWhitelist(compileWhitelist(originWhitelist), url)) {
-      Linking.openURL(url);
-      shouldStart = false;
-    }
-
-    if (onShouldStartLoadWithRequest) {
-      shouldStart = onShouldStartLoadWithRequest(nativeEvent);
+    if (
+      onShouldStartLoadWithRequest
+      && !onShouldStartLoadWithRequest(nativeEvent)
+    ) {
+      loadRequest(false, url, lockIdentifier);
     }
-
-    loadRequest(shouldStart, url, lockIdentifier);
+    loadRequest(true, url, lockIdentifier);
   };
 };
 
   return UIManager.getViewManagerConfig(viewManagerName);
 };
 
-export {
-  defaultOriginWhitelist,
-  createOnShouldStartLoadWithRequest,
-  getViewManagerConfig,
-};
+export { createOnShouldStartLoadWithRequest, getViewManagerConfig };

src/WebViewTypes.ts

 export type WebViewSource = WebViewSourceUri | WebViewSourceHtml;
 
 export interface ViewManager {
-  startLoadWithResult: Function;
+  startLoadWithResult: (shouldStart: boolean, lockIdentifier: number) => void;
 }
 
 export interface WebViewNativeConfig {
    */
   mediaPlaybackRequiresUserAction?: boolean;
 
-  /**
-   * List of origin strings to allow being navigated to. The strings allow
-   * wildcards and get matched against *just* the origin (not the full URL).
-   * If the user taps to navigate to a new page but the new page is not in
-   * this whitelist, we will open the URL in Safari.
-   * The default whitelisted origins are "http://*" and "https://*".
-   */
-  originWhitelist?: ReadonlyArray<string>;
-
   /**
    * Function that allows custom handling of any web view requests. Return
    * `true` from the function to continue loading the request and `false`