react-native-webview-bootpay 11.26.19 → 13.6.0

package/package.json

@@ -1,20 +1,21 @@
 {
   "name": "react-native-webview-bootpay",
-  "description": "React Native WebView 를 포크떠서 만든 Bootpay WebViewfor iOS, Android, macOS, and Windows",
+  "description": "React Native WebView 를 포크떠서 만든 Bootpay WebView for iOS, Android, macOS, and Windows",
   "main": "index.js",
-  "main-internal": "index.js",
+  "main-internal": "src/index.ts",
   "typings": "index.d.ts",
-  "author": "bootpay <bootpay.co.kr@gmail.com>",
+  "author": "Jamon Holmgren <jamon@infinite.red>",
   "contributors": [
-    "bootpay <bootpay.co.kr@gmail.com>",
     "Thibault Malbranche <malbranche.thibault@gmail.com>"
   ],
   "license": "MIT",
-  "version": "11.26.19",
+  "version": "13.6.0",
   "homepage": "https://github.com/bootpay/react-native-webview-bootpay",
   "scripts": {
     "android": "react-native run-android",
-    "ios": "react-native run-ios --project-path example/ios",
+    "ios": "react-native run-ios",
+    "build:ios": "react-native bundle --entry-file='./index.js' --bundle-output='./example/ios/main.jsbundle' --dev=false --platform='ios'",  
+    
     "macos": "react-native run-macos --scheme WebviewExample --project-path example/macos",
     "start": "cd example && react-native start",
     "windows": "install-windows-test-app --project-directory example/windows && react-native run-windows --root example --arch x64",
@@ -24,8 +25,10 @@
     "build": "yarn tsc",
     "prepare": "yarn build",
     "appium": "appium",
-    "test:windows": "yarn jest --setupFiles=./jest-setups/jest.setup.js"
+    "test:windows": "yarn jest --setupFiles=./jest-setups/jest.setup.js",
+    "add:macos": "yarn add react-native-macos@0.71.33"
   },
+  
   "rn-docs": {
     "title": "Webview",
     "type": "Component"
@@ -43,9 +46,8 @@
     "@babel/runtime": "^7.0.0",
     "@semantic-release/git": "7.0.16",
     "@types/invariant": "^2.2.30",
-    "@types/jest": "^26.0.0",
-    "@types/react": "^17.0.0",
-    "@types/react-native": "^0.67.3",
+    "@types/jest": "^29.4.0",
+    "@types/react": "18.0.27",
     "@types/selenium-webdriver": "4.0.9",
     "@typescript-eslint/eslint-plugin": "2.1.0",
     "@typescript-eslint/parser": "2.1.0",
@@ -58,13 +60,13 @@
     "eslint-plugin-react": "7.14.3",
     "eslint-plugin-react-hooks": "^4.5.0",
     "eslint-plugin-react-native": "3.7.0",
-    "jest": "^26.6.3",
-    "metro-react-native-babel-preset": "^0.67.0",
-    "react": "17.0.2",
-    "react-native": "0.68.5",
-    "react-native-macos": "0.68.62",
-    "react-native-test-app": "2.3.2",
-    "react-native-windows": "0.68.4",
+    "jest": "^29.4.1",
+    "metro-react-native-babel-preset": "0.73.7",
+    "react": "18.2.0",
+    "react-native": "0.71.12",
+    "react-native-macos": "0.71.33",
+    "react-native-test-app": "2.5.15",
+    "react-native-windows": "0.71.30",
     "selenium-appium": "1.0.2",
     "selenium-webdriver": "4.0.0-alpha.7",
     "semantic-release": "15.13.24",
@@ -73,18 +75,34 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/bootpay/react-native-webview-bootpay.git"
+    "url": "https://github.com/react-native-webview-bootpay/react-native-webview-bootpay.git"
   },
   "files": [
-    "android",
+    "android/src",
+    "android/build.gradle",
+    "android/gradle.properties",
     "apple",
     "ios",
     "macos",
     "windows",
     "lib",
+    "src",
     "index.js",
     "index.d.ts",
     "react-native-webview-bootpay.podspec",
     "react-native.config.js"
-  ]
+  ],
+  "resolutions": {
+    "@react-native-community/cli": "10.2.4",
+    "@react-native-community/cli-platform-android": "10.2.0",
+    "@react-native-community/cli-platform-ios": "10.2.4"
+  },
+  "codegenConfig": {
+    "name": "BPCWebViewSpec",
+    "type": "all",
+    "jsSrcsDir": "./src",
+    "android": {
+      "javaPackageName": "kr.co.bootpay.webview"
+    }
+  }
 }

package/react-native-webview-bootpay.podspec

@@ -2,6 +2,8 @@ require 'json'
 
 package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
 
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+
 Pod::Spec.new do |s|
   s.name         = package['name']
   s.version      = package['version']
@@ -12,8 +14,25 @@ Pod::Spec.new do |s|
   s.homepage     = package['homepage']
   s.platforms    = { :ios => "9.0", :osx => "10.13" }
 
-  s.source       = { :git => "https://github.com/bootpay/react-native-webview-bootpay.git", :tag => "#{s.version}" }
-  s.source_files  = "apple/**/*.{h,m}"
+  s.source       = { :git => "https://github.com/react-native-webview-bootpay/react-native-webview-bootpay.git", :tag => "v#{s.version}" }
+
+  s.source_files    = "apple/**/*.{h,m,mm,swift}"
+
+  s.dependency "React-Core"
+
+  if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+    s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+    s.pod_target_xcconfig    = {
+        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+        "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+    }
 
-  s.dependency 'React-Core'
+    s.dependency "React-RCTFabric"
+    s.dependency "React-Codegen"
+    s.dependency "RCT-Folly"
+    s.dependency "RCTRequired"
+    s.dependency "RCTTypeSafety"
+    s.dependency "ReactCommon/turbomodule/core"
+  end
 end

package/react-native.config.js

@@ -4,7 +4,6 @@ const project = (() => {
   try {
     const {
       androidManifestPath,
-      iosProjectPath,
       windowsProjectPath,
     } = require('react-native-test-app');
     return {
@@ -15,7 +14,7 @@ const project = (() => {
         ),
       },
       ios: {
-        project: iosProjectPath('example/ios'),
+        sourceDir: 'example/ios',
       },
       windows: fs.existsSync('example/windows/WebviewExample.sln') && {
         sourceDir: path.join('example', 'windows'),

package/src/BPCWebViewNativeComponent.ts

@@ -0,0 +1,281 @@
+import type { HostComponent, ViewProps } from 'react-native';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import {DirectEventHandler,Double, Int32, WithDefault} from 'react-native/Libraries/Types/CodegenTypes';
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
+
+export type WebViewNativeEvent = Readonly<{
+  url: string;
+  loading: boolean;
+  title: string;
+  canGoBack: boolean;
+  canGoForward: boolean;
+  lockIdentifier: Double;
+}>
+export type WebViewCustomMenuSelectionEvent = Readonly<{
+  label: string;
+  key: string;
+  selectedText: string;
+}>
+export type WebViewMessageEvent = Readonly<{
+  url: string;
+  loading: boolean;
+  title: string;
+  canGoBack: boolean;
+  canGoForward: boolean;
+  lockIdentifier: Double;
+  data: string;
+}>
+export type WebViewOpenWindowEvent = Readonly<{
+  targetUrl: string;
+}>
+export type WebViewHttpErrorEvent = Readonly<{
+  url: string;
+  loading: boolean;
+  title: string;
+  canGoBack: boolean;
+  canGoForward: boolean;
+  lockIdentifier: Double;
+  description: string;
+  statusCode: Int32;
+}>
+
+export type WebViewErrorEvent = Readonly<{
+  url: string;
+  loading: boolean;
+  title: string;
+  canGoBack: boolean;
+  canGoForward: boolean;
+  lockIdentifier: Double;
+  domain?: string;
+  code: Int32;
+  description: string;
+}>
+
+export type WebViewNativeProgressEvent = Readonly< {
+  url: string;
+  loading: boolean;
+  title: string;
+  canGoBack: boolean;
+  canGoForward: boolean;
+  lockIdentifier: Double;
+  progress: Double;
+}>
+
+export type WebViewNavigationEvent = Readonly< {
+  url: string;
+  loading: boolean;
+  title: string;
+  canGoBack: boolean;
+  canGoForward: boolean;
+  lockIdentifier: Double;
+  navigationType:
+    | 'click'
+    | 'formsubmit'
+    | 'backforward'
+    | 'reload'
+    | 'formresubmit'
+    | 'other';
+  mainDocumentURL?: string;
+}>
+
+export type ShouldStartLoadRequestEvent  = Readonly<{
+  url: string;
+  loading: boolean;
+  title: string;
+  canGoBack: boolean;
+  canGoForward: boolean;
+  lockIdentifier: Double;
+  navigationType:
+    | 'click'
+    | 'formsubmit'
+    | 'backforward'
+    | 'reload'
+    | 'formresubmit'
+    | 'other';
+  mainDocumentURL?: string;
+  isTopFrame: boolean;
+}>
+
+type ScrollEvent = Readonly<{
+  contentInset: {
+    bottom: Double,
+    left: Double,
+    right: Double,
+    top: Double,
+  },
+  contentOffset: {
+    y: Double,
+    x: Double,
+  },
+  contentSize: {
+    height: Double,
+    width: Double,
+  },
+  layoutMeasurement: {
+    height: Double,
+    width: Double,
+  },
+  targetContentOffset?: {
+    y: Double,
+    x: Double,
+  },
+  velocity?: {
+    y: Double,
+    x: Double,
+  },
+  zoomScale?: Double,
+  responderIgnoreScroll?: boolean,
+}>
+
+type WebViewRenderProcessGoneEvent = Readonly<{
+  didCrash: boolean;
+}>
+
+type WebViewDownloadEvent = Readonly<{
+  downloadUrl: string;
+}>
+
+// type MenuItem = Readonly<{label: string, key: string}>;
+
+export interface NativeProps extends ViewProps {
+  // Android only
+  allowFileAccess?: boolean;
+  allowsProtectedMedia?: boolean;
+  allowsFullscreenVideo?: boolean;
+  androidLayerType?: WithDefault<'none' | 'software' | 'hardware', 'none'>;
+  cacheMode?: WithDefault<'LOAD_DEFAULT' | 'LOAD_CACHE_ELSE_NETWORK' | 'LOAD_NO_CACHE' | 'LOAD_CACHE_ONLY', 'LOAD_DEFAULT'>;
+  domStorageEnabled?: boolean;
+  downloadingMessage?: string;
+  forceDarkOn?: boolean;
+  geolocationEnabled?: boolean;
+  lackPermissionToDownloadMessage?: string;
+  messagingModuleName: string;
+  minimumFontSize?: Int32;
+  mixedContentMode?: WithDefault<'never' | 'always' | 'compatibility', 'never'>;
+  nestedScrollEnabled?: boolean;
+  onContentSizeChange?: DirectEventHandler<WebViewNativeEvent>;
+  onRenderProcessGone?: DirectEventHandler<WebViewRenderProcessGoneEvent>;
+  overScrollMode?: string;
+  saveFormDataDisabled?: boolean;
+  scalesPageToFit?: boolean;
+  setBuiltInZoomControls?: boolean;
+  setDisplayZoomControls?: boolean;
+  setSupportMultipleWindows?: boolean;
+  textZoom?: Int32;
+  thirdPartyCookiesEnabled?: boolean;
+  // Workaround to watch if listener if defined
+  hasOnScroll?: boolean;
+  injectedJavaScriptObject?: string;
+  // !Android only
+
+  // iOS only
+  allowingReadAccessToURL?: string;
+  allowsBackForwardNavigationGestures?: boolean;
+  allowsInlineMediaPlayback?: boolean;
+  allowsAirPlayForMediaPlayback?: boolean;
+  allowsLinkPreview?: boolean;
+  automaticallyAdjustContentInsets?: boolean;
+  autoManageStatusBarEnabled?: boolean;
+  bounces?: boolean;
+  contentInset?: Readonly<{
+    top?: Double;
+    left?: Double;
+    bottom?: Double;
+    right?: Double;
+  }>;
+  contentInsetAdjustmentBehavior?: WithDefault<'never' | 'automatic' | 'scrollableAxes' | 'always', 'never'>;
+  contentMode?: WithDefault<'recommended' | 'mobile' | 'desktop', 'recommended'>;
+  dataDetectorTypes?: WithDefault<
+    // eslint-disable-next-line @typescript-eslint/array-type
+    ReadonlyArray<'address' | 'link' | 'calendarEvent' | 'trackingNumber' | 'flightNumber' | 'lookupSuggestion' | 'phoneNumber' | 'all' | 'none'>,
+    'phoneNumber'
+  >;
+  decelerationRate?: Double;
+  directionalLockEnabled?: boolean;
+  enableApplePay?: boolean;
+  hideKeyboardAccessoryView?: boolean;
+  keyboardDisplayRequiresUserAction?: boolean;
+  limitsNavigationsToAppBoundDomains?: boolean;
+  mediaCapturePermissionGrantType?: WithDefault<'prompt' | 'grant' | 'deny' | 'grantIfSameHostElsePrompt' | 'grantIfSameHostElseDeny', 'prompt'>;
+  pagingEnabled?: boolean;
+  pullToRefreshEnabled?: boolean;
+  scrollEnabled?: boolean;
+  sharedCookiesEnabled?: boolean;
+  textInteractionEnabled?: boolean;
+  useSharedProcessPool?: boolean;
+  onContentProcessDidTerminate?: DirectEventHandler<WebViewNativeEvent>;
+  onCustomMenuSelection?: DirectEventHandler<WebViewCustomMenuSelectionEvent>;
+  onFileDownload?: DirectEventHandler<WebViewDownloadEvent>;
+  // eslint-disable-next-line @typescript-eslint/array-type
+  menuItems?: ReadonlyArray<Readonly<{label: string, key: string}>>;
+  suppressMenuItems?: Readonly<string>[];
+  // Workaround to watch if listener if defined
+  hasOnFileDownload?: boolean;
+  fraudulentWebsiteWarningEnabled?: boolean;
+  // !iOS only
+
+  allowFileAccessFromFileURLs?: boolean;
+  allowUniversalAccessFromFileURLs?: boolean;
+  applicationNameForUserAgent?: string;
+  basicAuthCredential?: Readonly<{
+    username: string;
+    password: string;
+  }>;
+  cacheEnabled?: boolean;
+  incognito?: boolean;
+  injectedJavaScript?: string;
+  injectedJavaScriptBeforeContentLoaded?: string;
+  injectedJavaScriptForMainFrameOnly?: boolean;
+  injectedJavaScriptBeforeContentLoadedForMainFrameOnly?: boolean;
+  javaScriptCanOpenWindowsAutomatically?: boolean;
+  javaScriptEnabled?: boolean;
+  webviewDebuggingEnabled?: boolean;
+  mediaPlaybackRequiresUserAction?: boolean;
+  messagingEnabled: boolean;
+  onLoadingError: DirectEventHandler<WebViewErrorEvent>;
+  onLoadingFinish: DirectEventHandler<WebViewNavigationEvent>;
+  onLoadingProgress: DirectEventHandler<WebViewNativeProgressEvent>;
+  onLoadingStart: DirectEventHandler<WebViewNavigationEvent>;
+  onHttpError: DirectEventHandler<WebViewHttpErrorEvent>;
+  onMessage: DirectEventHandler<WebViewMessageEvent>;
+  onOpenWindow?: DirectEventHandler<WebViewOpenWindowEvent>;
+  hasOnOpenWindowEvent?: boolean;
+  onScroll?: DirectEventHandler<ScrollEvent>;
+  onShouldStartLoadWithRequest: DirectEventHandler<ShouldStartLoadRequestEvent>;
+  showsHorizontalScrollIndicator?: boolean;
+  showsVerticalScrollIndicator?: boolean;
+  newSource: Readonly<{
+    uri?: string
+    method?: string;
+    body?: string;
+    // eslint-disable-next-line @typescript-eslint/array-type
+    headers?: ReadonlyArray<Readonly<{name: string, value: string}>>;
+    html?: string;
+    baseUrl?: string;
+  }>;
+  userAgent?: string;
+}
+
+export interface NativeCommands {
+  goBack: (viewRef: React.ElementRef<HostComponent<NativeProps>> ) => void;
+  goForward: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+  reload: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+  stopLoading: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+  injectJavaScript: (viewRef: React.ElementRef<HostComponent<NativeProps>>, javascript: string) => void;
+  requestFocus: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+  postMessage: (viewRef: React.ElementRef<HostComponent<NativeProps>>, data: string) => void;
+  // Android Only
+  loadUrl: (viewRef: React.ElementRef<HostComponent<NativeProps>>, url: string) => void;
+  clearFormData: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+  clearCache: (viewRef: React.ElementRef<HostComponent<NativeProps>>, includeDiskFiles: boolean) => void;
+  clearHistory: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+  // !Android Only
+}
+
+export const Commands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['goBack', 'goForward', 'reload', 'stopLoading', 'injectJavaScript', 'requestFocus', 'postMessage', 'loadUrl', 'clearFormData', 'clearCache', 'clearHistory'],
+});
+
+export default codegenNativeComponent<NativeProps>(
+  'BPCWebView'
+) as HostComponent<NativeProps>;

package/src/NativeBPCWebView.ts

@@ -0,0 +1,14 @@
+/* eslint-disable import/no-duplicates */
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+import {Int32} from 'react-native/Libraries/Types/CodegenTypes';
+
+export interface Spec extends TurboModule {
+  readonly getConstants: () => {};
+
+  // your module methods go here, for example:
+  isFileUploadSupported(): Promise<boolean>;
+  shouldStartLoadWithLockIdentifier(shouldStart: boolean, lockIdentifier: Int32): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('BPCWebView');

package/src/WebView.android.tsx

@@ -0,0 +1,229 @@
+import React, { forwardRef, ReactElement, useCallback, useEffect, useImperativeHandle, useMemo, useRef } from 'react';
+
+import {
+  Image,
+  View,
+  ImageSourcePropType,
+  HostComponent,
+} from 'react-native';
+
+import BatchedBridge from 'react-native/Libraries/BatchedBridge/BatchedBridge';
+
+import invariant from 'invariant';
+
+import BPCWebView, {Commands, NativeProps} from "./BPCWebViewNativeComponent";
+import BPCWebViewModule from "./NativeBPCWebView";
+import {
+  defaultOriginWhitelist,
+  defaultRenderError,
+  defaultRenderLoading,
+  useWebViewLogic,
+} from './WebViewShared';
+import {
+  AndroidWebViewProps, WebViewSourceUri,
+} from './WebViewTypes';
+
+import styles from './WebView.styles';
+
+const { resolveAssetSource } = Image;
+
+/**
+ * A simple counter to uniquely identify WebView instances. Do not use this for anything else.
+ */
+let uniqueRef = 0;
+
+const WebViewComponent = forwardRef<{}, AndroidWebViewProps>(({
+  overScrollMode = 'always',
+  javaScriptEnabled = true,
+  thirdPartyCookiesEnabled = true,
+  scalesPageToFit = true,
+  allowsFullscreenVideo = false,
+  allowFileAccess = false,
+  saveFormDataDisabled = false,
+  cacheEnabled = true,
+  androidLayerType = "none",
+  originWhitelist = defaultOriginWhitelist,
+  setSupportMultipleWindows = true,
+  setBuiltInZoomControls = true,
+  setDisplayZoomControls = false,
+  nestedScrollEnabled = false,
+  startInLoadingState,
+  onNavigationStateChange,
+  onLoadStart,
+  onError,
+  onLoad,
+  onLoadEnd,
+  onLoadProgress,
+  onHttpError: onHttpErrorProp,
+  onRenderProcessGone: onRenderProcessGoneProp,
+  onMessage: onMessageProp,
+  onOpenWindow: onOpenWindowProp,
+  renderLoading,
+  renderError,
+  style,
+  containerStyle,
+  source,
+  nativeConfig,
+  onShouldStartLoadWithRequest: onShouldStartLoadWithRequestProp,
+  injectedJavaScriptObject,
+  ...otherProps
+}, ref) => {
+  const messagingModuleName = useRef<string>(`WebViewMessageHandler${uniqueRef += 1}`).current;
+  const webViewRef = useRef<React.ComponentRef<HostComponent<NativeProps>> | null>(null);
+
+  const onShouldStartLoadWithRequestCallback = useCallback((shouldStart: boolean,
+    url: string,
+    lockIdentifier?: number) => {
+    if (lockIdentifier) {
+      BPCWebViewModule.shouldStartLoadWithLockIdentifier(shouldStart, lockIdentifier);
+    } else if (shouldStart && webViewRef.current) {
+      Commands.loadUrl(webViewRef.current, url);
+    }
+  }, []);
+
+  const { onLoadingStart, onShouldStartLoadWithRequest, onMessage, viewState, setViewState, lastErrorEvent, onHttpError, onLoadingError, onLoadingFinish, onLoadingProgress, onOpenWindow, onRenderProcessGone } = useWebViewLogic({
+    onNavigationStateChange,
+    onLoad,
+    onError,
+    onHttpErrorProp,
+    onLoadEnd,
+    onLoadProgress,
+    onLoadStart,
+    onRenderProcessGoneProp,
+    onMessageProp,
+    onOpenWindowProp,
+    startInLoadingState,
+    originWhitelist,
+    onShouldStartLoadWithRequestProp,
+    onShouldStartLoadWithRequestCallback,
+  })
+
+  useImperativeHandle(ref, () => ({
+    goForward: () => webViewRef.current && Commands.goForward(webViewRef.current),
+    goBack: () => webViewRef.current && Commands.goBack(webViewRef.current),
+    reload: () => {
+      setViewState(
+        'LOADING',
+      );
+      if (webViewRef.current) {
+        Commands.reload(webViewRef.current)
+      }
+    },
+    stopLoading: () => webViewRef.current && Commands.stopLoading(webViewRef.current),
+    postMessage: (data: string) => webViewRef.current && Commands.postMessage(webViewRef.current, data),
+    injectJavaScript: (data: string) => webViewRef.current && Commands.injectJavaScript(webViewRef.current, data),
+    requestFocus: () => webViewRef.current && Commands.requestFocus(webViewRef.current),
+    clearFormData: () => webViewRef.current && Commands.clearFormData(webViewRef.current),
+    clearCache: (includeDiskFiles: boolean) => webViewRef.current && Commands.clearCache(webViewRef.current, includeDiskFiles),
+    clearHistory: () => webViewRef.current && Commands.clearHistory(webViewRef.current),
+  }), [setViewState, webViewRef]);
+
+  const directEventCallbacks = useMemo(() => ({
+    onShouldStartLoadWithRequest,
+    onMessage,
+  }), [onMessage, onShouldStartLoadWithRequest]);
+
+  useEffect(() => {
+    BatchedBridge.registerCallableModule(messagingModuleName, directEventCallbacks);
+  }, [messagingModuleName, directEventCallbacks])
+
+  let otherView: ReactElement | undefined;
+  if (viewState === 'LOADING') {
+    otherView = (renderLoading || defaultRenderLoading)();
+  } else if (viewState === 'ERROR') {
+    invariant(lastErrorEvent != null, 'lastErrorEvent expected to be non-null');
+    if (lastErrorEvent) {
+      otherView = (renderError || defaultRenderError)(
+        lastErrorEvent.domain,
+        lastErrorEvent.code,
+        lastErrorEvent.description,
+      );
+    }
+  } else if (viewState !== 'IDLE') {
+    console.error(`BPCWebView invalid state encountered: ${viewState}`);
+  }
+
+  const webViewStyles = [styles.container, styles.webView, style];
+  const webViewContainerStyle = [styles.container, containerStyle];
+
+  if (typeof source !== "number" && source && 'method' in source) {
+    if (source.method === 'POST' && source.headers) {
+      console.warn(
+        'WebView: `source.headers` is not supported when using POST.',
+      );
+    } else if (source.method === 'GET' && source.body) {
+      console.warn('WebView: `source.body` is not supported when using GET.');
+    }
+  }
+
+  const NativeWebView
+    = (nativeConfig?.component as (typeof BPCWebView | undefined)) || BPCWebView;
+
+  const sourceResolved = resolveAssetSource(source as ImageSourcePropType)
+  const newSource = typeof sourceResolved === "object" ? Object.entries(sourceResolved as WebViewSourceUri).reduce((prev, [currKey, currValue]) => {
+    return {
+      ...prev,
+      [currKey]: currKey === "headers" && currValue && typeof currValue === "object" ? Object.entries(currValue).map(
+        ([key, value]) => {
+          return {
+            name: key,
+            value
+          }
+        }) : currValue
+    }
+  }, {}) : sourceResolved
+
+  const webView = <NativeWebView
+    key="webViewKey"
+    {...otherProps}
+    messagingEnabled={typeof onMessageProp === 'function'}
+    messagingModuleName={messagingModuleName}
+
+    hasOnScroll={!!otherProps.onScroll}
+    onLoadingError={onLoadingError}
+    onLoadingFinish={onLoadingFinish}
+    onLoadingProgress={onLoadingProgress}
+    onLoadingStart={onLoadingStart}
+    onHttpError={onHttpError}
+    onRenderProcessGone={onRenderProcessGone}
+    onMessage={onMessage}
+    onOpenWindow={onOpenWindow}
+    hasOnOpenWindowEvent={onOpenWindowProp !== undefined}
+    onShouldStartLoadWithRequest={onShouldStartLoadWithRequest}
+    ref={webViewRef}
+    // TODO: find a better way to type this.
+    // @ts-expect-error source is old arch
+    source={sourceResolved}
+    newSource={newSource}
+    style={webViewStyles}
+    overScrollMode={overScrollMode}
+    javaScriptEnabled={javaScriptEnabled}
+    thirdPartyCookiesEnabled={thirdPartyCookiesEnabled}
+    scalesPageToFit={scalesPageToFit}
+    allowsFullscreenVideo={allowsFullscreenVideo}
+    allowFileAccess={allowFileAccess}
+    saveFormDataDisabled={saveFormDataDisabled}
+    cacheEnabled={cacheEnabled}
+    androidLayerType={androidLayerType}
+    setSupportMultipleWindows={setSupportMultipleWindows}
+    setBuiltInZoomControls={setBuiltInZoomControls}
+    setDisplayZoomControls={setDisplayZoomControls}
+    nestedScrollEnabled={nestedScrollEnabled}
+    injectedJavaScriptObject={JSON.stringify(injectedJavaScriptObject)}
+    {...nativeConfig?.props}
+  />
+
+  return (
+    <View style={webViewContainerStyle}>
+      {webView}
+      {otherView}
+    </View>
+  );
+});
+
+// native implementation should return "true" only for Android 5+
+const { isFileUploadSupported } = BPCWebViewModule;
+
+const WebView = Object.assign(WebViewComponent, { isFileUploadSupported });
+
+export default WebView;