@quicktvui/ai 1.0.5 → 1.0.7

package/rules/.source/quicktvui/src/x5webview/QTX5WebView.ts

@@ -0,0 +1,1014 @@
+import { ESApp, Native } from "@extscreen/es3-vue";
+import { defineComponent, h, onMounted, ref } from "vue";
+import useBaseView from "../base/useBaseView";
+import { QTX5WebViewParams } from "./QTIX5WebView";
+import { QTX5WebViewLayerType } from "./QTX5WebViewLayerType";
+import { QTX5WebViewSniffingRule } from "./QTX5WebViewSniffingRule";
+import { QTX5WebViewInterceptRule } from "./QTX5WebViewInterceptRule";
+
+function registerQTX5WebView(app: ESApp) {
+  const WebViewImpl = defineComponent({
+    name: "X5WebView",
+    emits: [
+      "onCanGoBack",
+      "onCanGoForward",
+      "onCanGoBackOrForward",
+      "onPageStarted",
+      "onPageFinished",
+      "onLoadResource",
+      "onReceivedSslError",
+      "onReceivedError",
+      "shouldOverrideUrlLoading",
+      "onJs2Vue",
+      "onJsRewardCall",
+      "onJsFinishGame",
+      "onProgressChanged",
+      "onConsoleMessage",
+      "onSniffingResult",
+    ],
+    setup(props, context) {
+      const webViewRef = ref();
+
+      onMounted(() => {
+        setJavaScriptEnabled(true);
+        setJavaScriptCanOpenWindowsAutomatically(true);
+        setAllowFileAccess(true);
+        setSupportZoom(true);
+        setBuiltInZoomControls(true);
+        setUseWideViewPort(true);
+        setSupportMultipleWindows(true);
+        setAppCacheEnabled(true);
+        setDomStorageEnabled(true);
+        setGeolocationEnabled(true);
+        setPluginState(1);
+        setCacheMode(2);
+      });
+
+      const initWebView = (params?: QTX5WebViewParams) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "initWebView",
+          [params],
+          (res) => {},
+        );
+      };
+
+      const loadUrl = (url: string) => {
+        Native.callUIFunction(webViewRef.value, "loadUrl", [url], (res) => {});
+      };
+
+      //--------------------------------------------------------------------------
+      const reload = () => {
+        Native.callUIFunction(webViewRef.value, "reload", [], (res) => {});
+      };
+      const clearCache = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "clearCache",
+          [value],
+          (res) => {},
+        );
+      };
+      const getUrl = () => {
+        return new Promise((resolve, reject) => {
+          Native.callUIFunction(webViewRef.value, "getUrl", [], (res) => {
+            resolve(res);
+          });
+        });
+      };
+      const getOriginalUrl = () => {
+        return new Promise((resolve, reject) => {
+          Native.callUIFunction(webViewRef.value, "getUrl", [], (res) => {
+            resolve(res);
+          });
+        });
+      };
+      const setLayerType = (layerType: QTX5WebViewLayerType) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setLayerType",
+          [layerType],
+          (res) => {},
+        );
+      };
+
+      const setIgnoreCA = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setIgnoreCA",
+          [value],
+          (res) => {},
+        );
+      };
+
+      const setIgnoreAllKeyEvent = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setIgnoreAllKeyEvent",
+          [value],
+          (res) => {},
+        );
+      };
+
+      const getBackForwardList = () => {
+        return new Promise((resolve, reject) => {
+          Native.callUIFunction(
+            webViewRef.value,
+            "getBackForwardList",
+            [],
+            (res) => {
+              resolve(res);
+            },
+          );
+        });
+      };
+
+      const getCurrentIndexWithBackForwardList = () => {
+        return new Promise((resolve, reject) => {
+          Native.callUIFunction(
+            webViewRef.value,
+            "getCurrentIndexWithBackForwardList",
+            [],
+            (res) => {
+              resolve(res);
+            },
+          );
+        });
+      };
+
+      const getScreenStatus = () => {
+        return new Promise((resolve, reject) => {
+          Native.callUIFunction(
+            webViewRef.value,
+            "getScreenStatus",
+            [],
+            (res) => {
+              resolve(res);
+            },
+          );
+        });
+      };
+
+      const autoClickPosition = (x: number, y: number) => {
+        return new Promise((resolve, reject) => {
+          Native.callUIFunction(
+            webViewRef.value,
+            "autoClickPosition",
+            [x, y],
+            (res) => {
+              resolve(res);
+            },
+          );
+        });
+      };
+
+      const enableImageDisplay = () => {
+        return new Promise((resolve, reject) => {
+          Native.callUIFunction(
+            webViewRef.value,
+            "enableImageDisplay",
+            [],
+            (res) => {
+              resolve(res);
+            },
+          );
+        });
+      };
+
+      const disableImageDisplay = () => {
+        return new Promise((resolve, reject) => {
+          Native.callUIFunction(
+            webViewRef.value,
+            "disableImageDisplay",
+            [],
+            (res) => {
+              resolve(res);
+            },
+          );
+        });
+      };
+
+      const stopLoading = () => {
+        return new Promise((resolve, reject) => {
+          Native.callUIFunction(webViewRef.value, "stopLoading", [], (res) => {
+            resolve(res);
+          });
+        });
+      };
+
+      const clearView = () => {
+        return new Promise((resolve, reject) => {
+          Native.callUIFunction(webViewRef.value, "clearView", [], (res) => {
+            resolve(res);
+          });
+        });
+      };
+
+      const setListenEvents = (value: string) => {
+        return new Promise((resolve, reject) => {
+          Native.callUIFunction(
+            webViewRef.value,
+            "setListenEvents",
+            [value],
+            (res) => {
+              resolve(res);
+            },
+          );
+        });
+      };
+
+      const sendKeyCodeEvent = (keyCode: number, action: number) => {
+        return new Promise((resolve, reject) => {
+          Native.callUIFunction(
+            webViewRef.value,
+            "sendKeyCodeEvent",
+            [keyCode, action],
+            (res) => {
+              resolve(res);
+            },
+          );
+        });
+      };
+
+      const autoClickPositionWithDuration = (
+        keyCode: number,
+        action: number,
+        duration: number,
+      ) => {
+        return new Promise((resolve, reject) => {
+          Native.callUIFunction(
+            webViewRef.value,
+            "autoClickPositionWithDuration",
+            [keyCode, action, duration],
+            (res) => {
+              resolve(res);
+            },
+          );
+        });
+      };
+
+      //--------------------------------------------------------------------------
+
+      const evaluateJavascript = (value: string) => {
+        return new Promise((resolve, reject) => {
+          Native.callUIFunction(
+            webViewRef.value,
+            "evaluateJavascript",
+            [value],
+            (res) => {
+              resolve(res);
+            },
+          );
+        });
+      };
+
+      const setSniffingEnabled = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setSniffingEnabled",
+          [value],
+          (res) => {},
+        );
+      };
+
+      const setSniffingRule = (value: QTX5WebViewSniffingRule) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setSniffingRule",
+          [value],
+          (res) => {},
+        );
+      };
+
+      const resetSniffingRule = () => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "resetSniffingRule",
+          [],
+          (res) => {},
+        );
+      };
+
+      const setInterceptEnabled = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setInterceptEnabled",
+          [value],
+          (res) => {},
+        );
+      };
+
+      const setInterceptRule = (value: QTX5WebViewInterceptRule) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setInterceptRule",
+          [value],
+          (res) => {},
+        );
+      };
+
+      const resetInterceptRule = () => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "resetInterceptRule",
+          [],
+          (res) => {},
+        );
+      };
+
+      const shouldOverrideUrlLoading = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "shouldOverrideUrlLoading",
+          [value],
+          (res) => {},
+        );
+      };
+
+      const canGoBack = () => {
+        return new Promise((resolve, reject) => {
+          Native.callUIFunction(webViewRef.value, "canGoBack", [], (res) => {
+            context.emit("onCanGoBack", res);
+            resolve(res);
+          });
+        });
+      };
+      const goBack = () => {
+        Native.callUIFunction(webViewRef.value, "goBack", [], (res) => {});
+      };
+      const canGoForward = () => {
+        return new Promise((resolve, reject) => {
+          Native.callUIFunction(webViewRef.value, "canGoForward", [], (res) => {
+            context.emit("onCanGoForward", res);
+            resolve(res);
+          });
+        });
+      };
+      const goForward = () => {
+        Native.callUIFunction(webViewRef.value, "goForward", [], (res) => {});
+      };
+      const canGoBackOrForward = (steps: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "canGoBackOrForward",
+          [steps],
+          (res) => {
+            context.emit("onCanGoBackOrForward", res);
+          },
+        );
+      };
+      const goBackOrForward = (steps: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "goBackOrForward",
+          [steps],
+          (res) => {},
+        );
+      };
+      const onResume = () => {
+        Native.callUIFunction(webViewRef.value, "onResume", [], (res) => {});
+      };
+      const onPause = () => {
+        Native.callUIFunction(webViewRef.value, "onPause", [], (res) => {});
+      };
+      const pauseTimers = () => {
+        Native.callUIFunction(webViewRef.value, "pauseTimers", [], (res) => {});
+      };
+      const resumeTimers = () => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "resumeTimers",
+          [],
+          (res) => {},
+        );
+      };
+      const destroy = () => {
+        Native.callUIFunction(webViewRef.value, "destroy", [], (res) => {});
+      };
+      const setJavaScriptEnabled = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setJavaScriptEnabled",
+          [value],
+          (res) => {},
+        );
+      };
+      const setPluginState = (value: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setPluginState",
+          [value],
+          (res) => {},
+        );
+      };
+      const setJavaScriptCanOpenWindowsAutomatically = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setJavaScriptCanOpenWindowsAutomatically",
+          [value],
+          (res) => {},
+        );
+      };
+      const setUseWideViewPort = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setUseWideViewPort",
+          [value],
+          (res) => {},
+        );
+      };
+      const setLoadWithOverviewMode = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setLoadWithOverviewMode",
+          [value],
+          (res) => {},
+        );
+      };
+      const setSupportZoom = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setSupportZoom",
+          [value],
+          (res) => {},
+        );
+      };
+      const setBuiltInZoomControls = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setBuiltInZoomControls",
+          [value],
+          (res) => {},
+        );
+      };
+      const setDisplayZoomControls = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setDisplayZoomControls",
+          [value],
+          (res) => {},
+        );
+      };
+      const setAllowFileAccess = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setAllowFileAccess",
+          [value],
+          (res) => {},
+        );
+      };
+      const setDomStorageEnabled = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setDomStorageEnabled",
+          [value],
+          (res) => {},
+        );
+      };
+      const setDatabaseEnabled = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setDatabaseEnabled",
+          [value],
+          (res) => {},
+        );
+      };
+      const setAppCacheEnabled = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setAppCacheEnabled",
+          [value],
+          (res) => {},
+        );
+      };
+      const setAppCachePath = (value: string) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setAppCachePath",
+          [value],
+          (res) => {},
+        );
+      };
+      const setMediaPlaybackRequiresUserGesture = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setMediaPlaybackRequiresUserGesture",
+          [value],
+          (res) => {},
+        );
+      };
+      const setStandardFontFamily = (value: string) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setStandardFontFamily",
+          [value],
+          (res) => {},
+        );
+      };
+      const setFixedFontFamily = (value: string) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setFixedFontFamily",
+          [value],
+          (res) => {},
+        );
+      };
+      const setSansSerifFontFamily = (value: string) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setSansSerifFontFamily",
+          [value],
+          (res) => {},
+        );
+      };
+      const setSerifFontFamily = (value: string) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setSerifFontFamily",
+          [value],
+          (res) => {},
+        );
+      };
+      const setCursiveFontFamily = (value: string) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setCursiveFontFamily",
+          [value],
+          (res) => {},
+        );
+      };
+      const setFantasyFontFamily = (value: string) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setFantasyFontFamily",
+          [value],
+          (res) => {},
+        );
+      };
+      const setTextZoom = (value: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setTextZoom",
+          [value],
+          (res) => {},
+        );
+      };
+      const setInitialScale = (value: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setInitialScale",
+          [value],
+          (res) => {},
+        );
+      };
+      const setMinimumFontSize = (value: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setMinimumFontSize",
+          [value],
+          (res) => {},
+        );
+      };
+      const setDefaultFontSize = (value: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setDefaultFontSize",
+          [value],
+          (res) => {},
+        );
+      };
+      const setLayoutAlgorithm = (value: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setLayoutAlgorithm",
+          [value],
+          (res) => {},
+        );
+      };
+      const setLoadsImagesAutomatically = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setLoadsImagesAutomatically",
+          [value],
+          (res) => {},
+        );
+      };
+      const setDefaultTextEncodingName = (value: string) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setDefaultTextEncodingName",
+          [value],
+          (res) => {},
+        );
+      };
+      const setNeedInitialFocus = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setNeedInitialFocus",
+          [value],
+          (res) => {},
+        );
+      };
+      const setGeolocationEnabled = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setGeolocationEnabled",
+          [value],
+          (res) => {},
+        );
+      };
+      const setBlockNetworkLoads = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setBlockNetworkLoads",
+          [value],
+          (res) => {},
+        );
+      };
+      const setSupportMultipleWindows = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setSupportMultipleWindows",
+          [value],
+          (res) => {},
+        );
+      };
+      const setAppCacheMaxSize = (value: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setAppCacheMaxSize",
+          [value],
+          (res) => {},
+        );
+      };
+      const setRenderPriority = (value: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setRenderPriority",
+          [value],
+          (res) => {},
+        );
+      };
+      const setCacheMode = (value: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setCacheMode",
+          [value],
+          (res) => {},
+        );
+      };
+      //-----------------------------------------------
+      const setAllowContentAccess = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setAllowContentAccess",
+          [value],
+          (res) => {},
+        );
+      };
+      const setEnableSmoothTransition = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setEnableSmoothTransition",
+          [value],
+          (res) => {},
+        );
+      };
+      const setSaveFormData = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setSaveFormData",
+          [value],
+          (res) => {},
+        );
+      };
+      const setSavePassword = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setSavePassword",
+          [value],
+          (res) => {},
+        );
+      };
+      const setTextSize = (value: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setTextSize",
+          [value],
+          (res) => {},
+        );
+      };
+      const setDefaultZoom = (value: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setDefaultZoom",
+          [value],
+          (res) => {},
+        );
+      };
+      const setLightTouchEnabled = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setLightTouchEnabled",
+          [value],
+          (res) => {},
+        );
+      };
+      const setMinimumLogicalFontSize = (value: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setMinimumLogicalFontSize",
+          [value],
+          (res) => {},
+        );
+      };
+      const setDefaultFixedFontSize = (value: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setDefaultFixedFontSize",
+          [value],
+          (res) => {},
+        );
+      };
+      const setBlockNetworkImage = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setBlockNetworkImage",
+          [value],
+          (res) => {},
+        );
+      };
+      const setAllowUniversalAccessFromFileURLs = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setAllowUniversalAccessFromFileURLs",
+          [value],
+          (res) => {},
+        );
+      };
+      const setAllowFileAccessFromFileURLs = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setAllowFileAccessFromFileURLs",
+          [value],
+          (res) => {},
+        );
+      };
+      const setDatabasePath = (value: string) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setDatabasePath",
+          [value],
+          (res) => {},
+        );
+      };
+      const setGeolocationDatabasePath = (value: string) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setGeolocationDatabasePath",
+          [value],
+          (res) => {},
+        );
+      };
+      const setUserAgentString = (value: string) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setUserAgentString",
+          [value],
+          (res) => {},
+        );
+      };
+      const setMixedContentMode = (value: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setMixedContentMode",
+          [value],
+          (res) => {},
+        );
+      };
+      const setOffscreenPreRaster = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setOffscreenPreRaster",
+          [value],
+          (res) => {},
+        );
+      };
+      const setSafeBrowsingEnabled = (value: boolean) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setSafeBrowsingEnabled",
+          [value],
+          (res) => {},
+        );
+      };
+      const setForceDark = (value: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setForceDark",
+          [value],
+          (res) => {},
+        );
+      };
+      const setDisabledActionModeMenuItems = (value: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "setDisabledActionModeMenuItems",
+          [value],
+          (res) => {},
+        );
+      };
+      const initJavaScriptInterface = () => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "initJavaScriptInterface",
+          [],
+          (res) => {},
+        );
+      };
+      const removeJavaScriptInterface = () => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "removeJavaScriptInterface",
+          [],
+          (res) => {},
+        );
+      };
+      const initWebViewFocus = (delayTime: number, x: number, y: number) => {
+        Native.callUIFunction(
+          webViewRef.value,
+          "initWebViewFocus",
+          [delayTime, x, y],
+          (res) => {},
+        );
+      };
+      context.expose({
+        reload,
+        clearCache,
+        getUrl,
+        getOriginalUrl,
+        setLayerType,
+        setIgnoreCA,
+        setIgnoreAllKeyEvent,
+        getBackForwardList,
+        getCurrentIndexWithBackForwardList,
+        getScreenStatus,
+        autoClickPosition,
+        enableImageDisplay,
+        disableImageDisplay,
+        clearView,
+        stopLoading,
+        setListenEvents,
+        sendKeyCodeEvent,
+        autoClickPositionWithDuration,
+        //---------------------------------------------------------
+        initWebView,
+        loadUrl,
+        evaluateJavascript,
+        setSniffingEnabled,
+        setSniffingRule,
+        resetSniffingRule,
+        setInterceptEnabled,
+        setInterceptRule,
+        resetInterceptRule,
+        shouldOverrideUrlLoading,
+        canGoBack,
+        goBack,
+        canGoForward,
+        goForward,
+        canGoBackOrForward,
+        goBackOrForward,
+        onResume,
+        onPause,
+        pauseTimers,
+        resumeTimers,
+        destroy,
+        setJavaScriptEnabled,
+        setPluginState,
+        setJavaScriptCanOpenWindowsAutomatically,
+        setUseWideViewPort,
+        setLoadWithOverviewMode,
+        setSupportZoom,
+        setBuiltInZoomControls,
+        setDisplayZoomControls,
+        setAllowFileAccess,
+        setDomStorageEnabled,
+        setDatabaseEnabled,
+        setAppCacheEnabled,
+        setAppCachePath,
+        setMediaPlaybackRequiresUserGesture,
+        setStandardFontFamily,
+        setFixedFontFamily,
+        setSansSerifFontFamily,
+        setSerifFontFamily,
+        setCursiveFontFamily,
+        setFantasyFontFamily,
+        setTextZoom,
+        setMinimumFontSize,
+        setDefaultFontSize,
+        setLayoutAlgorithm,
+        setLoadsImagesAutomatically,
+        setDefaultTextEncodingName,
+        setNeedInitialFocus,
+        setGeolocationEnabled,
+        setBlockNetworkLoads,
+        setSupportMultipleWindows,
+        setAppCacheMaxSize,
+        setRenderPriority,
+        setCacheMode,
+        setAllowContentAccess,
+        setEnableSmoothTransition,
+        setSaveFormData,
+        setSavePassword,
+        setTextSize,
+        setInitialScale,
+        setDefaultZoom,
+        setLightTouchEnabled,
+        setMinimumLogicalFontSize,
+        setDefaultFixedFontSize,
+        setBlockNetworkImage,
+        setAllowUniversalAccessFromFileURLs,
+        setAllowFileAccessFromFileURLs,
+        setDatabasePath,
+        setGeolocationDatabasePath,
+        setUserAgentString,
+        setMixedContentMode,
+        setOffscreenPreRaster,
+        setSafeBrowsingEnabled,
+        setForceDark,
+        setDisabledActionModeMenuItems,
+        initJavaScriptInterface,
+        removeJavaScriptInterface,
+        initWebViewFocus,
+        ...useBaseView(webViewRef),
+      });
+      return () => {
+        return h("ESX5WebViewComponent", {
+          onPageStarted: (evt) => {
+            let url = evt.url;
+            context.emit("onPageStarted", url);
+          },
+          onPageFinished: (evt) => {
+            let url = evt.url;
+            context.emit("onPageFinished", url);
+          },
+          onLoadResource: (evt) => {
+            let url = evt.url;
+            context.emit("onLoadResource", url);
+          },
+          onReceivedSslError: (evt) => {
+            context.emit("onReceivedSslError", evt);
+          },
+          onReceivedError: (evt) => {
+            let errorCode = evt.errorCode;
+            let description = evt.description;
+            let failingUrl = evt.failingUrl;
+            context.emit("onReceivedError", errorCode, description, failingUrl);
+          },
+          onShouldOverrideUrlLoading: (evt) => {
+            let url = evt.url;
+            context.emit("shouldOverrideUrlLoading", url);
+          },
+          onJs2Vue: (evt) => {
+            let value = evt.js2VueValue;
+            context.emit("onJs2Vue", value);
+          },
+          onJsRewardCall: (evt) => {
+            let value = evt.jsRewardCallValue;
+            context.emit("onJsRewardCall", value);
+          },
+          onJsFinishGame: (evt) => {
+            let value = evt.jsFinishGameValue;
+            context.emit("onJsFinishGame", value);
+          },
+          onProgressChanged: (evt) => {
+            let value = evt.progress;
+            context.emit("onProgressChanged", value);
+          },
+          onConsoleMessage: (evt) => {
+            let message = evt.message;
+            let messageLevel = evt.messageLevel;
+            let sourceId = evt.sourceId;
+            let lineNumber = evt.lineNumber;
+            context.emit(
+              "onConsoleMessage",
+              message,
+              messageLevel,
+              sourceId,
+              lineNumber,
+            );
+          },
+          onSniffingResult: (evt) => {
+            let url = evt.url;
+            let headers = evt.headers;
+            context.emit("onSniffingResult", url, headers);
+          },
+          ref: webViewRef,
+        });
+      };
+    },
+  });
+  app.component("qt-x5web-view", WebViewImpl);
+}
+
+export default registerQTX5WebView;