@exodus/react-native-webview 11.26.1-exodus.2 → 11.26.1-exodus.21

package/lib/WebView.ios.js

@@ -1,16 +1,15 @@
 import React, { forwardRef, useCallback, useImperativeHandle, useRef } from 'react';
-import { Image, View, NativeModules, } from 'react-native';
+import { Text, View, NativeModules, Platform, } from 'react-native';
 import invariant from 'invariant';
 // @ts-expect-error react-native doesn't have this type
 import codegenNativeCommandsUntyped from 'react-native/Libraries/Utilities/codegenNativeCommands';
 import RNCWebView from "./WebViewNativeComponent.ios";
-import { defaultOriginWhitelist, defaultRenderError, defaultRenderLoading, useWebWiewLogic, } from './WebViewShared';
+import { defaultOriginWhitelist, defaultDeeplinkWhitelist, defaultRenderError, defaultRenderLoading, useWebWiewLogic, versionPasses, } from './WebViewShared';
 import styles from './WebView.styles';
 const codegenNativeCommands = codegenNativeCommandsUntyped;
 const Commands = codegenNativeCommands({
     supportedCommands: ['goBack', 'goForward', 'reload', 'stopLoading', /* 'injectJavaScript', */ 'requestFocus', 'postMessage', 'loadUrl'],
 });
-const { resolveAssetSource } = Image;
 const processDecelerationRate = (decelerationRate) => {
     let newDecelerationRate = decelerationRate;
     if (newDecelerationRate === 'normal') {
@@ -32,57 +31,63 @@ const useWarnIfChanges = (value, name) => {
 /**
  * Harcoded defaults for security.
  */
-const allowFileAccessFromFileURLs = false;
-const allowUniversalAccessFromFileURLs = false;
-const injectedJavaScriptForMainFrameOnly = true;
-const injectedJavaScriptBeforeContentLoadedForMainFrameOnly = true;
 const mediaPlaybackRequiresUserAction = true;
 // iOS only configs
 const allowsInlineMediaPlayback = true;
-const allowsAirPlayForMediaPlayback = false;
 const useSharedProcessPool = false;
 const sharedCookiesEnabled = false;
 const enableApplePay = false;
-const onFileDownload = () => console.error('tried to download file');
 const dataDetectorTypes = 'none';
-const WebViewComponent = forwardRef(({ javaScriptEnabled = true, cacheEnabled = true, originWhitelist = defaultOriginWhitelist, textInteractionEnabled = true, injectedJavaScript, injectedJavaScriptBeforeContentLoaded, startInLoadingState, onNavigationStateChange, onLoadStart, onError, onLoad, onLoadEnd, onLoadProgress, onContentProcessDidTerminate: onContentProcessDidTerminateProp, onHttpError: onHttpErrorProp, onMessage: onMessageProp, renderLoading, renderError, style, containerStyle, source, incognito, decelerationRate: decelerationRateProp, onShouldStartLoadWithRequest: onShouldStartLoadWithRequestProp, ...otherProps }, ref) => {
+const hardMinimumIOSVersion = '12.5.6 <13, 13.6.1 <14, 14.8.1 <15, 15.7.1';
+const WebViewComponent = forwardRef(({ javaScriptEnabled = true, cacheEnabled = true, originWhitelist = defaultOriginWhitelist, deeplinkWhitelist = defaultDeeplinkWhitelist, textInteractionEnabled = true, injectedJavaScript, injectedJavaScriptBeforeContentLoaded, startInLoadingState, onLoadStart, onError, onLoad, onLoadEnd, onMessage: onMessageProp, renderLoading, renderError, style, containerStyle, source, incognito, validateMeta, validateData, decelerationRate: decelerationRateProp, onShouldStartLoadWithRequest: onShouldStartLoadWithRequestProp, minimumIOSVersion, unsupportedVersionComponent: UnsupportedVersionComponent, ...otherProps }, ref) => {
     const webViewRef = useRef(null);
     const onShouldStartLoadWithRequestCallback = useCallback((shouldStart, _url, lockIdentifier = 0) => {
         const viewManager = RNCWebViewManager;
         viewManager.startLoadWithResult(!!shouldStart, lockIdentifier);
     }, []);
-    const { onLoadingStart, onShouldStartLoadWithRequest, onMessage, viewState, setViewState, lastErrorEvent, onHttpError, onLoadingError, onLoadingFinish, onLoadingProgress, onContentProcessDidTerminate } = useWebWiewLogic({
-        onNavigationStateChange,
+    const { onLoadingStart, onShouldStartLoadWithRequest, onMessage, viewState, setViewState, lastErrorEvent, onLoadingError, onLoadingFinish, onLoadingProgress } = useWebWiewLogic({
         onLoad,
         onError,
-        onHttpErrorProp,
         onLoadEnd,
-        onLoadProgress,
         onLoadStart,
         onMessageProp,
         startInLoadingState,
         originWhitelist,
+        deeplinkWhitelist,
         onShouldStartLoadWithRequestProp,
         onShouldStartLoadWithRequestCallback,
-        onContentProcessDidTerminateProp,
+        validateMeta,
+        validateData,
     });
     useImperativeHandle(ref, () => ({
-        goForward: () => Commands.goForward(webViewRef.current),
-        goBack: () => Commands.goBack(webViewRef.current),
+        goForward: () => webViewRef.current && Commands.goForward(webViewRef.current),
+        goBack: () => webViewRef.current && Commands.goBack(webViewRef.current),
         reload: () => {
             setViewState('LOADING');
-            Commands.reload(webViewRef.current);
+            if (webViewRef.current) {
+                Commands.reload(webViewRef.current);
+            }
         },
-        stopLoading: () => Commands.stopLoading(webViewRef.current),
-        postMessage: (data) => Commands.postMessage(webViewRef.current, data),
+        stopLoading: () => webViewRef.current && Commands.stopLoading(webViewRef.current),
+        postMessage: (data) => webViewRef.current && Commands.postMessage(webViewRef.current, data),
         // injectJavaScript: (data: string) => Commands.injectJavaScript(webViewRef.current, data),
-        requestFocus: () => Commands.requestFocus(webViewRef.current),
+        requestFocus: () => webViewRef.current && Commands.requestFocus(webViewRef.current),
     }), [setViewState, webViewRef]);
     useWarnIfChanges(allowsInlineMediaPlayback, 'allowsInlineMediaPlayback');
-    useWarnIfChanges(allowsAirPlayForMediaPlayback, 'allowsAirPlayForMediaPlayback');
     useWarnIfChanges(incognito, 'incognito');
     useWarnIfChanges(mediaPlaybackRequiresUserAction, 'mediaPlaybackRequiresUserAction');
     useWarnIfChanges(dataDetectorTypes, 'dataDetectorTypes');
+    const version = String(Platform.Version);
+    if (!(versionPasses(version, minimumIOSVersion) && versionPasses(version, hardMinimumIOSVersion))) {
+        if (UnsupportedVersionComponent) {
+            return <UnsupportedVersionComponent />;
+        }
+        return (<View style={{ alignSelf: 'flex-start' }}>
+        <Text style={{ color: 'red' }}>
+          iOS version is outdated and insecure. Update it to continue.
+        </Text>
+      </View>);
+    }
     let otherView = null;
     if (viewState === 'LOADING') {
         otherView = (renderLoading || defaultRenderLoading)();
@@ -98,9 +103,9 @@ const WebViewComponent = forwardRef(({ javaScriptEnabled = true, cacheEnabled =
     const webViewContainerStyle = [styles.container, containerStyle];
     const decelerationRate = processDecelerationRate(decelerationRateProp);
     const NativeWebView = RNCWebView;
-    const webView = (<NativeWebView key="webViewKey" {...otherProps} allowFileAccessFromFileURLs={allowFileAccessFromFileURLs} allowUniversalAccessFromFileURLs={allowUniversalAccessFromFileURLs} enableApplePay={enableApplePay} javaScriptEnabled={javaScriptEnabled} cacheEnabled={cacheEnabled} dataDetectorTypes={dataDetectorTypes} useSharedProcessPool={useSharedProcessPool} textInteractionEnabled={textInteractionEnabled} decelerationRate={decelerationRate} messagingEnabled={typeof onMessageProp === 'function'} onLoadingError={onLoadingError} onLoadingFinish={onLoadingFinish} onLoadingProgress={onLoadingProgress} onFileDownload={onFileDownload} onLoadingStart={onLoadingStart} onHttpError={onHttpError} onMessage={onMessage} onShouldStartLoadWithRequest={onShouldStartLoadWithRequest} onContentProcessDidTerminate={onContentProcessDidTerminate} injectedJavaScript={injectedJavaScript} injectedJavaScriptBeforeContentLoaded={injectedJavaScriptBeforeContentLoaded} injectedJavaScriptForMainFrameOnly={injectedJavaScriptForMainFrameOnly} injectedJavaScriptBeforeContentLoadedForMainFrameOnly={injectedJavaScriptBeforeContentLoadedForMainFrameOnly} allowsAirPlayForMediaPlayback={allowsAirPlayForMediaPlayback} allowsInlineMediaPlayback={allowsInlineMediaPlayback} incognito={incognito} mediaPlaybackRequiresUserAction={mediaPlaybackRequiresUserAction} ref={webViewRef} sharedCookiesEnabled={sharedCookiesEnabled} 
+    const webView = (<NativeWebView key="webViewKey" {...otherProps} enableApplePay={enableApplePay} javaScriptEnabled={javaScriptEnabled} cacheEnabled={cacheEnabled} dataDetectorTypes={dataDetectorTypes} useSharedProcessPool={useSharedProcessPool} textInteractionEnabled={textInteractionEnabled} decelerationRate={decelerationRate} messagingEnabled={typeof onMessageProp === 'function'} onLoadingError={onLoadingError} onLoadingFinish={onLoadingFinish} onLoadingProgress={onLoadingProgress} onLoadingStart={onLoadingStart} onMessage={onMessage} onShouldStartLoadWithRequest={onShouldStartLoadWithRequest} injectedJavaScript={injectedJavaScript} injectedJavaScriptBeforeContentLoaded={injectedJavaScriptBeforeContentLoaded} allowsInlineMediaPlayback={allowsInlineMediaPlayback} incognito={incognito} mediaPlaybackRequiresUserAction={mediaPlaybackRequiresUserAction} ref={webViewRef} sharedCookiesEnabled={sharedCookiesEnabled} 
     // TODO: find a better way to type this.
-    source={resolveAssetSource(source)} style={webViewStyles}/>);
+    source={source} style={webViewStyles}/>);
     return (<View style={webViewContainerStyle}>
       {webView}
       {otherView}

package/lib/WebViewShared.d.ts

@@ -1,37 +1,37 @@
 import React from 'react';
-import { OnShouldStartLoadWithRequest, ShouldStartLoadRequestEvent, WebViewError, WebViewErrorEvent, WebViewHttpErrorEvent, WebViewMessageEvent, WebViewNavigation, WebViewNavigationEvent, WebViewProgressEvent, WebViewRenderProcessGoneEvent, WebViewTerminatedEvent } from './WebViewTypes';
-declare const defaultOriginWhitelist: readonly ["http://*", "https://*"];
-declare const createOnShouldStartLoadWithRequest: (loadRequest: (shouldStart: boolean, url: string, lockIdentifier: number) => void, originWhitelist: readonly string[], onShouldStartLoadWithRequest?: OnShouldStartLoadWithRequest | undefined) => ({ nativeEvent }: ShouldStartLoadRequestEvent) => void;
+import { OnShouldStartLoadWithRequest, ShouldStartLoadRequestEvent, WebViewError, WebViewErrorEvent, WebViewMessageEvent, WebViewMessage, WebViewNavigationEvent, WebViewOpenWindowEvent, WebViewProgressEvent, WebViewNativeEvent } from './WebViewTypes';
+declare const defaultOriginWhitelist: readonly ["https://*"];
+declare const defaultDeeplinkWhitelist: readonly ["https://"];
+declare const createOnShouldStartLoadWithRequest: (loadRequest: (shouldStart: boolean, url: string, lockIdentifier: number) => void, originWhitelist: readonly string[], deepLinkWhitelist: readonly string[], onShouldStartLoadWithRequest?: OnShouldStartLoadWithRequest | undefined) => ({ nativeEvent }: ShouldStartLoadRequestEvent) => void;
 declare const defaultRenderLoading: () => JSX.Element;
 declare const defaultRenderError: (errorDomain: string | undefined, errorCode: number, errorDesc: string) => JSX.Element;
-export { defaultOriginWhitelist, createOnShouldStartLoadWithRequest, defaultRenderLoading, defaultRenderError, };
-export declare const useWebWiewLogic: ({ startInLoadingState, onNavigationStateChange, onLoadStart, onLoad, onLoadProgress, onLoadEnd, onError, onHttpErrorProp, onMessageProp, onRenderProcessGoneProp, onContentProcessDidTerminateProp, originWhitelist, onShouldStartLoadWithRequestProp, onShouldStartLoadWithRequestCallback, }: {
+export { defaultOriginWhitelist, defaultDeeplinkWhitelist, createOnShouldStartLoadWithRequest, defaultRenderLoading, defaultRenderError, };
+export declare const useWebWiewLogic: ({ startInLoadingState, onLoadStart, onLoad, onLoadEnd, onError, onMessageProp, onOpenWindowProp, originWhitelist, deeplinkWhitelist, onShouldStartLoadWithRequestProp, onShouldStartLoadWithRequestCallback, validateMeta, validateData, }: {
     startInLoadingState?: boolean | undefined;
-    onNavigationStateChange?: ((event: WebViewNavigation) => void) | undefined;
     onLoadStart?: ((event: WebViewNavigationEvent) => void) | undefined;
     onLoad?: ((event: WebViewNavigationEvent) => void) | undefined;
-    onLoadProgress?: ((event: WebViewProgressEvent) => void) | undefined;
     onLoadEnd?: ((event: WebViewNavigationEvent | WebViewErrorEvent) => void) | undefined;
     onError?: ((event: WebViewErrorEvent) => void) | undefined;
-    onHttpErrorProp?: ((event: WebViewHttpErrorEvent) => void) | undefined;
-    onMessageProp?: ((event: WebViewMessageEvent) => void) | undefined;
-    onRenderProcessGoneProp?: ((event: WebViewRenderProcessGoneEvent) => void) | undefined;
-    onContentProcessDidTerminateProp?: ((event: WebViewTerminatedEvent) => void) | undefined;
+    onMessageProp?: ((event: WebViewMessage) => void) | undefined;
+    onOpenWindowProp?: ((event: WebViewOpenWindowEvent) => void) | undefined;
     originWhitelist: readonly string[];
+    deeplinkWhitelist: readonly string[];
     onShouldStartLoadWithRequestProp?: OnShouldStartLoadWithRequest | undefined;
     onShouldStartLoadWithRequestCallback: (shouldStart: boolean, url: string, lockIdentifier?: number | undefined) => void;
+    validateMeta: (event: WebViewNativeEvent) => WebViewNativeEvent;
+    validateData: (data: object) => object;
 }) => {
     onShouldStartLoadWithRequest: ({ nativeEvent }: ShouldStartLoadRequestEvent) => void;
     onLoadingStart: (event: WebViewNavigationEvent) => void;
     onLoadingProgress: (event: WebViewProgressEvent) => void;
     onLoadingError: (event: WebViewErrorEvent) => void;
     onLoadingFinish: (event: WebViewNavigationEvent) => void;
-    onHttpError: (event: WebViewHttpErrorEvent) => void;
-    onRenderProcessGone: (event: WebViewRenderProcessGoneEvent) => void;
-    onContentProcessDidTerminate: (event: WebViewTerminatedEvent) => void;
     onMessage: (event: WebViewMessageEvent) => void;
+    onOpenWindow: (event: WebViewOpenWindowEvent) => void;
+    passesWhitelist: (url: string) => boolean | null;
     viewState: "IDLE" | "LOADING" | "ERROR";
     setViewState: React.Dispatch<React.SetStateAction<"IDLE" | "LOADING" | "ERROR">>;
     lastErrorEvent: WebViewError | null;
 };
+export declare const versionPasses: (version: string | undefined, minimum: string | undefined) => boolean;
 //# sourceMappingURL=WebViewShared.d.ts.map

package/lib/WebViewShared.js

@@ -2,31 +2,58 @@ import escapeStringRegexp from 'escape-string-regexp';
 import React, { useCallback, useMemo, useRef, useState } from 'react';
 import { Linking, View, ActivityIndicator, Text, Platform } from 'react-native';
 import styles from './WebView.styles';
-const defaultOriginWhitelist = ['http://*', 'https://*'];
+const defaultOriginWhitelist = ['https://*'];
+const defaultDeeplinkWhitelist = ['https://'];
+const defaultDeeplinkBlocklist = [/^http:/i, /^file:/i, /^javascript:/i];
 const extractOrigin = (url) => {
     const result = /^[A-Za-z][A-Za-z0-9+\-.]+:(\/\/)?[^/]*/.exec(url);
     return result === null ? '' : result[0];
 };
-const originWhitelistToRegex = (originWhitelist) => `^${escapeStringRegexp(originWhitelist).replace(/\\\*/g, '.*')}`;
-const passesWhitelist = (compiledWhitelist, url) => {
+const stringWhitelistToRegex = (originWhitelist) => new RegExp(`^${escapeStringRegexp(originWhitelist).replace(/\\\*/g, '.*')}$`);
+const matchWithRegexList = (compiledRegexList, value) => {
+    return compiledRegexList.some(x => x.test(value));
+};
+const matchWithPrefixStringList = (prefixes, value) => {
+    if (typeof value !== 'string')
+        throw new Error(`value was not a string`);
+    return prefixes.some(x => String(x).length && String.prototype.startsWith.call(value, x));
+};
+const _passesWhitelist = (compiledWhitelist, url) => {
     const origin = extractOrigin(url);
-    return compiledWhitelist.some(x => new RegExp(x).test(origin));
+    if (!origin)
+        return false;
+    if (origin !== new URL(url).origin)
+        return null;
+    return matchWithRegexList(compiledWhitelist, origin);
 };
-const compileWhitelist = (originWhitelist) => ['about:blank', ...(originWhitelist || [])].map(originWhitelistToRegex);
-const createOnShouldStartLoadWithRequest = (loadRequest, originWhitelist, onShouldStartLoadWithRequest) => {
+const compileWhitelist = (originWhitelist) => ['about:blank', ...(originWhitelist || [])].map(stringWhitelistToRegex);
+const createOnShouldStartLoadWithRequest = (loadRequest, originWhitelist, deepLinkWhitelist, onShouldStartLoadWithRequest) => {
+    const compiledWhiteList = compileWhitelist(originWhitelist);
     return ({ nativeEvent }) => {
         let shouldStart = true;
-        const { url, lockIdentifier } = nativeEvent;
-        if (!passesWhitelist(compileWhitelist(originWhitelist), url)) {
-            Linking.canOpenURL(url).then((supported) => {
-                if (supported) {
-                    return Linking.openURL(url);
+        const { url, lockIdentifier, isTopFrame } = nativeEvent;
+        /** Check if the url passes the origin whitelist */
+        if (!_passesWhitelist(compiledWhiteList, url)) {
+            /** Check if the url passes the hardcoded deeplink blocklist */
+            const foundMatchInBlocklist = matchWithRegexList(defaultDeeplinkBlocklist, url);
+            if (!foundMatchInBlocklist) {
+                /** Check if the url passes the dynamic deeplink allow list */
+                const foundMatchInAllowlist = matchWithPrefixStringList(deepLinkWhitelist, url);
+                if (foundMatchInAllowlist) {
+                    Linking.canOpenURL(url).then((supported) => {
+                        if (supported && isTopFrame) {
+                            return Linking.openURL(url);
+                        }
+                        console.warn(`Can't open url: ${url}`);
+                        return undefined;
+                    }).catch(e => {
+                        console.warn('Error opening URL: ', e);
+                    });
+                }
+                else {
+                    console.warn(`Failed to pass default block list or whitelist deep link url: ${url}`);
                 }
-                console.warn(`Can't open url: ${url}`);
-                return undefined;
-            }).catch(e => {
-                console.warn('Error opening URL: ', e);
-            });
+            }
             shouldStart = false;
         }
         else if (onShouldStartLoadWithRequest) {
@@ -44,21 +71,31 @@ const defaultRenderError = (errorDomain, errorCode, errorDesc) => (<View style={
     <Text style={styles.errorText}>{`Error Code: ${errorCode}`}</Text>
     <Text style={styles.errorText}>{`Description: ${errorDesc}`}</Text>
   </View>);
-export { defaultOriginWhitelist, createOnShouldStartLoadWithRequest, defaultRenderLoading, defaultRenderError, };
-export const useWebWiewLogic = ({ startInLoadingState, onNavigationStateChange, onLoadStart, onLoad, onLoadProgress, onLoadEnd, onError, onHttpErrorProp, onMessageProp, onRenderProcessGoneProp, onContentProcessDidTerminateProp, originWhitelist, onShouldStartLoadWithRequestProp, onShouldStartLoadWithRequestCallback, }) => {
+export { defaultOriginWhitelist, defaultDeeplinkWhitelist, createOnShouldStartLoadWithRequest, defaultRenderLoading, defaultRenderError, };
+export const useWebWiewLogic = ({ startInLoadingState, onLoadStart, onLoad, onLoadEnd, onError, onMessageProp, onOpenWindowProp, originWhitelist, deeplinkWhitelist, onShouldStartLoadWithRequestProp, onShouldStartLoadWithRequestCallback, validateMeta, validateData, }) => {
     const [viewState, setViewState] = useState(startInLoadingState ? "LOADING" : "IDLE");
     const [lastErrorEvent, setLastErrorEvent] = useState(null);
     const startUrl = useRef(null);
-    const updateNavigationState = useCallback((event) => {
-        onNavigationStateChange === null || onNavigationStateChange === void 0 ? void 0 : onNavigationStateChange(event.nativeEvent);
-    }, [onNavigationStateChange]);
+    const passesWhitelist = (url) => {
+        if (!url || typeof url !== 'string')
+            return false;
+        return _passesWhitelist(compileWhitelist(originWhitelist), url);
+    };
+    const passesWhitelistUse = useCallback(passesWhitelist, [originWhitelist]);
+    const extractMeta = (nativeEvent) => ({
+        url: String(nativeEvent.url),
+        loading: Boolean(nativeEvent.loading),
+        title: String(nativeEvent.title),
+        canGoBack: Boolean(nativeEvent.canGoBack),
+        canGoForward: Boolean(nativeEvent.canGoForward),
+        lockIdentifier: Number(nativeEvent.lockIdentifier),
+    });
     const onLoadingStart = useCallback((event) => {
         // Needed for android
         startUrl.current = event.nativeEvent.url;
         // !Needed for android
         onLoadStart === null || onLoadStart === void 0 ? void 0 : onLoadStart(event);
-        updateNavigationState(event);
-    }, [onLoadStart, updateNavigationState]);
+    }, [onLoadStart]);
     const onLoadingError = useCallback((event) => {
         event.persist();
         if (onError) {
@@ -75,55 +112,92 @@ export const useWebWiewLogic = ({ startInLoadingState, onNavigationStateChange,
         setViewState('ERROR');
         setLastErrorEvent(event.nativeEvent);
     }, [onError, onLoadEnd]);
-    const onHttpError = useCallback((event) => {
-        onHttpErrorProp === null || onHttpErrorProp === void 0 ? void 0 : onHttpErrorProp(event);
-    }, [onHttpErrorProp]);
-    // Android Only
-    const onRenderProcessGone = useCallback((event) => {
-        onRenderProcessGoneProp === null || onRenderProcessGoneProp === void 0 ? void 0 : onRenderProcessGoneProp(event);
-    }, [onRenderProcessGoneProp]);
-    // !Android Only
-    // iOS Only
-    const onContentProcessDidTerminate = useCallback((event) => {
-        onContentProcessDidTerminateProp === null || onContentProcessDidTerminateProp === void 0 ? void 0 : onContentProcessDidTerminateProp(event);
-    }, [onContentProcessDidTerminateProp]);
-    // !iOS Only
     const onLoadingFinish = useCallback((event) => {
         onLoad === null || onLoad === void 0 ? void 0 : onLoad(event);
         onLoadEnd === null || onLoadEnd === void 0 ? void 0 : onLoadEnd(event);
         const { nativeEvent: { url } } = event;
+        if (!passesWhitelistUse(url))
+            return;
         // on Android, only if url === startUrl
         if (Platform.OS !== "android" || url === startUrl.current) {
             setViewState('IDLE');
         }
         // !on Android, only if url === startUrl
-        updateNavigationState(event);
-    }, [onLoad, onLoadEnd, updateNavigationState]);
+        // REMOVED: updateNavigationState(event);
+    }, [onLoad, onLoadEnd, passesWhitelistUse]);
     const onMessage = useCallback((event) => {
-        onMessageProp === null || onMessageProp === void 0 ? void 0 : onMessageProp(event);
-    }, [onMessageProp]);
+        const { nativeEvent } = event;
+        if (!passesWhitelistUse(nativeEvent.url))
+            return;
+        // TODO: can/should we perform any other validation?
+        const data = JSON.stringify(validateData(JSON.parse(nativeEvent.data)));
+        const meta = validateMeta(extractMeta(nativeEvent));
+        onMessageProp === null || onMessageProp === void 0 ? void 0 : onMessageProp({ ...meta, data });
+    }, [onMessageProp, passesWhitelistUse, validateData, validateMeta]);
     const onLoadingProgress = useCallback((event) => {
         const { nativeEvent: { progress } } = event;
+        if (!passesWhitelistUse(event.nativeEvent.url))
+            return;
         // patch for Android only
         if (Platform.OS === "android" && progress === 1) {
             setViewState(prevViewState => prevViewState === 'LOADING' ? 'IDLE' : prevViewState);
         }
         // !patch for Android only
-        onLoadProgress === null || onLoadProgress === void 0 ? void 0 : onLoadProgress(event);
-    }, [onLoadProgress]);
-    const onShouldStartLoadWithRequest = useMemo(() => createOnShouldStartLoadWithRequest(onShouldStartLoadWithRequestCallback, originWhitelist, onShouldStartLoadWithRequestProp), [originWhitelist, onShouldStartLoadWithRequestProp, onShouldStartLoadWithRequestCallback]);
+        // REMOVED: onLoadProgress?.(event);
+    }, [passesWhitelistUse]);
+    const onShouldStartLoadWithRequest = useMemo(() => createOnShouldStartLoadWithRequest(onShouldStartLoadWithRequestCallback, originWhitelist, deeplinkWhitelist, onShouldStartLoadWithRequestProp), [originWhitelist, deeplinkWhitelist, onShouldStartLoadWithRequestProp, onShouldStartLoadWithRequestCallback]);
+    // Android Only
+    const onOpenWindow = useCallback((event) => {
+        onOpenWindowProp === null || onOpenWindowProp === void 0 ? void 0 : onOpenWindowProp(event);
+    }, [onOpenWindowProp]);
+    // !Android Only
     return {
         onShouldStartLoadWithRequest,
         onLoadingStart,
         onLoadingProgress,
         onLoadingError,
         onLoadingFinish,
-        onHttpError,
-        onRenderProcessGone,
-        onContentProcessDidTerminate,
         onMessage,
+        onOpenWindow,
+        passesWhitelist,
         viewState,
         setViewState,
         lastErrorEvent,
     };
 };
+export const versionPasses = (version, minimum) => {
+    if (!version || !minimum)
+        return false;
+    if (typeof version !== 'string' || typeof minimum !== 'string')
+        return false;
+    if (minimum.includes(', ')) {
+        // We have a set of possible versions
+        const variants = minimum.split(', ');
+        // Every entry but the last one should be with an upper bound
+        if (!variants.slice(0, -1).every(x => x.includes(' <')))
+            return false;
+        return variants.some(x => versionPasses(version, x)); // Any match passes
+    }
+    if (minimum.includes(' <')) {
+        const [min, max, ...rest] = minimum.split(' <');
+        if (rest.length > 0)
+            return false;
+        // Last check is required for correctness/formatting validation
+        return versionPasses(version, min) && !versionPasses(version, max) && versionPasses(max, version);
+    }
+    const versionRegex = /^[0-9]+(\.[0-9]+)*$/;
+    if (!versionRegex.test(version) || !versionRegex.test(minimum))
+        return false;
+    const versionParts = version.split('.').map(Number);
+    const minimumParts = minimum.split('.').map(Number);
+    const len = Math.max(versionParts.length, minimumParts.length);
+    for (let i = 0; i < len; i += 1) {
+        const ver = versionParts[i] || 0;
+        const min = minimumParts[i] || 0;
+        if (ver > min)
+            return true;
+        if (ver < min)
+            return false;
+    }
+    return true; // equals
+};