@polyvharmony/live-scenes-foundation 1.3.0 → 1.3.2-rc.1

package/src/main/ets/modules/web/PLVLoadingLayout.js

@@ -1,40 +1,39 @@
 if (!("finalizeConstruction" in ViewPU.prototype)) {
-    Reflect.set(ViewPU.prototype, "finalizeConstruction", () => {
-    });
+    Reflect.set(ViewPU.prototype, "finalizeConstruction", () => { });
 }
 import PLVCommonConstants from '../../common/PLVCommonConstants';
 export class PLVLoadingLayout extends ViewPU {
-    constructor(parent, params, __localStorage, elmtId = -1, paramsLambda = undefined, extraInfo) {
-        super(parent, __localStorage, elmtId, extraInfo);
-        if (typeof paramsLambda === "function") {
-            this.paramsGenerator_ = paramsLambda;
+    constructor(x18, y18, z18, a19 = -1, b19 = undefined, c19) {
+        super(x18, z18, a19, c19);
+        if (typeof b19 === "function") {
+            this.paramsGenerator_ = b19;
         }
-        this.setInitiallyProvidedValue(params);
+        this.setInitiallyProvidedValue(y18);
         this.finalizeConstruction();
     }
-    setInitiallyProvidedValue(params) {
+    setInitiallyProvidedValue(w18) {
     }
-    updateStateVars(params) {
+    updateStateVars(v18) {
     }
-    purgeVariableDependenciesOnElmtId(rmElmtId) {
+    purgeVariableDependenciesOnElmtId(u18) {
     }
     aboutToBeDeleted() {
         SubscriberManager.Get().delete(this.id__());
         this.aboutToBeDeletedInternal();
     }
     initialRender() {
-        this.observeComponentCreation2((elmtId, isInitialRender) => {
+        this.observeComponentCreation2((s18, t18) => {
             Column.create();
             Column.height(PLVCommonConstants.FULL_PERCENT);
             Column.width(PLVCommonConstants.FULL_PERCENT);
         }, Column);
-        this.observeComponentCreation2((elmtId, isInitialRender) => {
+        this.observeComponentCreation2((q18, r18) => {
             Column.create();
             Column.margin({ top: { "id": -1, "type": 10002, params: ["app.float.plv_web_loading_img_margin"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" } });
             Column.width({ "id": -1, "type": 10002, params: ["app.float.plv_web_loading_img_size"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
             Column.height({ "id": -1, "type": 10002, params: ["app.float.plv_web_loading_img_size"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
         }, Column);
-        this.observeComponentCreation2((elmtId, isInitialRender) => {
+        this.observeComponentCreation2((o18, p18) => {
             LoadingProgress.create();
         }, LoadingProgress);
         Column.pop();

package/src/main/ets/modules/web/PLVNewWindowLayout.js

@@ -1,47 +1,46 @@
 if (!("finalizeConstruction" in ViewPU.prototype)) {
-    Reflect.set(ViewPU.prototype, "finalizeConstruction", () => {
-    });
+    Reflect.set(ViewPU.prototype, "finalizeConstruction", () => { });
 }
 import webview from '@ohos.web.webview';
 import PLVLogger from '../log/PLVLogger';
 const TAG = "[PLVNewWindowLayout]";
 export class PLVNewWindowLayout extends ViewPU {
-    constructor(parent, params, __localStorage, elmtId = -1, paramsLambda = undefined, extraInfo) {
-        super(parent, __localStorage, elmtId, extraInfo);
-        if (typeof paramsLambda === "function") {
-            this.paramsGenerator_ = paramsLambda;
+    constructor(l19, m19, n19, o19 = -1, p19 = undefined, q19) {
+        super(l19, n19, o19, q19);
+        if (typeof p19 === "function") {
+            this.paramsGenerator_ = p19;
         }
         this.controller = undefined;
         this.webviewController = new webview.WebviewController();
-        this.setInitiallyProvidedValue(params);
+        this.setInitiallyProvidedValue(m19);
         this.finalizeConstruction();
     }
-    setInitiallyProvidedValue(params) {
-        if (params.controller !== undefined) {
-            this.controller = params.controller;
+    setInitiallyProvidedValue(k19) {
+        if (k19.controller !== undefined) {
+            this.controller = k19.controller;
         }
-        if (params.webviewController !== undefined) {
-            this.webviewController = params.webviewController;
+        if (k19.webviewController !== undefined) {
+            this.webviewController = k19.webviewController;
         }
     }
-    updateStateVars(params) {
+    updateStateVars(j19) {
     }
-    purgeVariableDependenciesOnElmtId(rmElmtId) {
+    purgeVariableDependenciesOnElmtId(i19) {
     }
     aboutToBeDeleted() {
         SubscriberManager.Get().delete(this.id__());
         this.aboutToBeDeletedInternal();
     }
-    setController(ctr) {
-        this.controller = ctr;
+    setController(h19) {
+        this.controller = h19;
     }
     aboutToAppear() {
     }
     initialRender() {
-        this.observeComponentCreation2((elmtId, isInitialRender) => {
+        this.observeComponentCreation2((f19, g19) => {
             Column.create();
         }, Column);
-        this.observeComponentCreation2((elmtId, isInitialRender) => {
+        this.observeComponentCreation2((d19, e19) => {
             Web.create({ src: "", controller: this.webviewController });
             Web.javaScriptAccess(true);
             Web.zoomAccess(true);

package/src/main/ets/modules/web/PLVSimpleWeb.js

@@ -1,6 +1,5 @@
 if (!("finalizeConstruction" in ViewPU.prototype)) {
-    Reflect.set(ViewPU.prototype, "finalizeConstruction", () => {
-    });
+    Reflect.set(ViewPU.prototype, "finalizeConstruction", () => { });
 }
 import PLVCommonConstants from '../../common/PLVCommonConstants';
 import { PLVFullScreenStatus, PLVWebpageStatus } from '../../common/PLVCommonEnums';
@@ -11,62 +10,62 @@ import { PLVNewWindowLayout } from './PLVNewWindowLayout';
 import { PLVWebController } from './PLVWebController';
 export const TAG = "[PLVSimpleWeb]";
 export class PLVSimpleWeb extends ViewPU {
-    constructor(parent, params, __localStorage, elmtId = -1, paramsLambda = undefined, extraInfo) {
-        super(parent, __localStorage, elmtId, extraInfo);
-        if (typeof paramsLambda === "function") {
-            this.paramsGenerator_ = paramsLambda;
+    constructor(b21, c21, d21, e21 = -1, f21 = undefined, g21) {
+        super(b21, d21, e21, g21);
+        if (typeof f21 === "function") {
+            this.paramsGenerator_ = f21;
         }
-        this.a2 = new ObservedPropertySimplePU(PLVWebpageStatus.INIT, this, "webStatus");
+        this.__webStatus = new ObservedPropertySimplePU(PLVWebpageStatus.INIT, this, "webStatus");
         this.controller = new PLVWebController();
         this.src = undefined;
         this.incognitoMode = undefined;
         this.showLoading = undefined;
-        this.setInitiallyProvidedValue(params);
+        this.setInitiallyProvidedValue(c21);
         this.finalizeConstruction();
     }
-    setInitiallyProvidedValue(params) {
-        if (params.webStatus !== undefined) {
-            this.webStatus = params.webStatus;
+    setInitiallyProvidedValue(a21) {
+        if (a21.webStatus !== undefined) {
+            this.webStatus = a21.webStatus;
         }
-        if (params.controller !== undefined) {
-            this.controller = params.controller;
+        if (a21.controller !== undefined) {
+            this.controller = a21.controller;
         }
-        if (params.src !== undefined) {
-            this.src = params.src;
+        if (a21.src !== undefined) {
+            this.src = a21.src;
         }
-        if (params.incognitoMode !== undefined) {
-            this.incognitoMode = params.incognitoMode;
+        if (a21.incognitoMode !== undefined) {
+            this.incognitoMode = a21.incognitoMode;
         }
-        if (params.showLoading !== undefined) {
-            this.showLoading = params.showLoading;
+        if (a21.showLoading !== undefined) {
+            this.showLoading = a21.showLoading;
         }
     }
-    updateStateVars(params) {
+    updateStateVars(z20) {
     }
-    purgeVariableDependenciesOnElmtId(rmElmtId) {
-        this.a2.purgeDependencyOnElmtId(rmElmtId);
+    purgeVariableDependenciesOnElmtId(y20) {
+        this.__webStatus.purgeDependencyOnElmtId(y20);
     }
     aboutToBeDeleted() {
-        this.a2.aboutToBeDeleted();
+        this.__webStatus.aboutToBeDeleted();
         SubscriberManager.Get().delete(this.id__());
         this.aboutToBeDeletedInternal();
     }
     get webStatus() {
-        return this.a2.get();
+        return this.__webStatus.get();
     }
-    set webStatus(newValue) {
-        this.a2.set(newValue);
+    set webStatus(x20) {
+        this.__webStatus.set(x20);
     }
     aboutToAppear() {
         PLVLogger.info(TAG, `load url: ${this.src}`);
     }
     initialRender() {
-        this.observeComponentCreation2((elmtId, isInitialRender) => {
+        this.observeComponentCreation2((v20, w20) => {
             Stack.create();
             Stack.width(PLVCommonConstants.FULL_PERCENT);
             Stack.height(PLVCommonConstants.FULL_PERCENT);
         }, Stack);
-        this.observeComponentCreation2((elmtId, isInitialRender) => {
+        this.observeComponentCreation2((h20, i20) => {
             Web.create({
                 controller: this.controller,
                 src: this.src,
@@ -91,45 +90,44 @@ export class PLVSimpleWeb extends ViewPU {
                 this.controller.handleControllerAttached();
                 this.controller._onControllerAttached?.();
             });
-            Web.onInterceptRequest((event) => {
+            Web.onInterceptRequest((u20) => {
                 if (this.controller._onInterceptRequest) {
-                    return this.controller._onInterceptRequest?.(event.request);
+                    return this.controller._onInterceptRequest?.(u20.request);
                 }
                 return null;
             });
-            Web.onLoadIntercept((event) => {
-                let result = false;
+            Web.onLoadIntercept((s20) => {
+                let t20 = false;
                 if (this.controller._onLoadIntercept) {
-                    result = this.controller._onLoadIntercept?.(event.data);
+                    t20 = this.controller._onLoadIntercept?.(s20.data);
                 }
-                result = result || this.controller.handleIsLoadIntercept(event.data);
-                return result;
+                t20 = t20 || this.controller.handleIsLoadIntercept(s20.data);
+                return t20;
             });
-            Web.onWindowNew((event) => {
-                if (this.controller._onWindowNew?.(event)) {
+            Web.onWindowNew((o20) => {
+                if (this.controller._onWindowNew?.(o20)) {
                     return;
                 }
-                this.controller.handleWindowNew(event, (j8) => {
+                this.controller.handleWindowNew(o20, (p20) => {
                     return new CustomDialogController({
                         builder: () => {
-                            let jsDialog = new PLVNewWindowLayout(this, { webviewController: j8 }, undefined, -1, () => {
-                            }, { page: "foundation/src/main/ets/modules/web/PLVSimpleWeb.ets", line: 72, b2: 24 });
-                            jsDialog.setController();
-                            ViewPU.create(jsDialog);
-                            let paramsLambda = () => {
+                            let q20 = new PLVNewWindowLayout(this, { webviewController: p20 }, undefined, -1, () => { }, { page: "foundation/src/main/ets/modules/web/PLVSimpleWeb.ets", line: 72, col: 24 });
+                            q20.setController();
+                            ViewPU.create(q20);
+                            let r20 = () => {
                                 return {
-                                    webviewController: j8
+                                    webviewController: p20
                                 };
                             };
-                            jsDialog.paramsGenerator_ = paramsLambda;
+                            q20.paramsGenerator_ = r20;
                         },
                         cornerRadius: 0
                     }, this);
                 });
             });
-            Web.onShowFileSelector((event) => {
+            Web.onShowFileSelector((n20) => {
                 if (this.controller._onShowFileSelector) {
-                    return this.controller._onShowFileSelector?.(event);
+                    return this.controller._onShowFileSelector?.(n20);
                 }
                 return true;
             });
@@ -149,50 +147,49 @@ export class PLVSimpleWeb extends ViewPU {
                 }
                 this.controller.handleFullScreenEnter();
             });
-            Web.onProgressChange((event) => {
-                PLVLogger.info(TAG, 'onProgressChange:' + event?.newProgress);
-                this.controller._onProgressChange?.(event);
+            Web.onProgressChange((m20) => {
+                PLVLogger.info(TAG, 'onProgressChange:' + m20?.newProgress);
+                this.controller._onProgressChange?.(m20);
             });
-            Web.onPageBegin((event) => {
+            Web.onPageBegin((l20) => {
                 PLVLogger.info(TAG, 'onPageBegin');
-                this.controller._onPageBegin?.(event);
+                this.controller._onPageBegin?.(l20);
             });
-            Web.onErrorReceive((event) => {
-                PLVLogger.info(TAG, "onErrorReceive:" + `{info:${event?.error.getErrorInfo()},code:${event?.error.getErrorCode()}}`);
+            Web.onErrorReceive((k20) => {
+                PLVLogger.info(TAG, "onErrorReceive:" + `{info:${k20?.error.getErrorInfo()},code:${k20?.error.getErrorCode()}}`);
                 this.controller.handleErrorReceive();
                 this.webStatus = PLVWebpageStatus.FINISHED;
-                this.controller._onErrorReceive?.(event);
+                this.controller._onErrorReceive?.(k20);
             });
-            Web.onPageEnd((event) => {
+            Web.onPageEnd((j20) => {
                 PLVLogger.info(TAG, 'onPageEnd');
-                this.controller.handlePageEnd(event);
+                this.controller.handlePageEnd(j20);
                 if (this.webStatus != PLVWebpageStatus.ERROR) {
                     this.webStatus = PLVWebpageStatus.FINISHED;
-                    this.controller._onPageEnd?.(event);
+                    this.controller._onPageEnd?.(j20);
                 }
             });
         }, Web);
-        this.observeComponentCreation2((elmtId, isInitialRender) => {
+        this.observeComponentCreation2((z19, a20) => {
             If.create();
             if (this.webStatus === PLVWebpageStatus.INIT && this.showLoading) {
                 this.ifElseBranchUpdateFunction(0, () => {
-                    this.observeComponentCreation2((elmtId, isInitialRender) => {
+                    this.observeComponentCreation2((f20, g20) => {
                         Column.create();
                         Column.backgroundColor(Color.White);
                     }, Column);
                     {
-                        this.observeComponentCreation2((elmtId, isInitialRender) => {
-                            if (isInitialRender) {
-                                let componentCall = new PLVLoadingLayout(this, {}, undefined, elmtId, () => {
-                                }, { page: "foundation/src/main/ets/modules/web/PLVSimpleWeb.ets", line: 124, b2: 11 });
-                                ViewPU.create(componentCall);
-                                let paramsLambda = () => {
+                        this.observeComponentCreation2((b20, c20) => {
+                            if (c20) {
+                                let d20 = new PLVLoadingLayout(this, {}, undefined, b20, () => { }, { page: "foundation/src/main/ets/modules/web/PLVSimpleWeb.ets", line: 124, col: 11 });
+                                ViewPU.create(d20);
+                                let e20 = () => {
                                     return {};
                                 };
-                                componentCall.paramsGenerator_ = paramsLambda;
+                                d20.paramsGenerator_ = e20;
                             }
                             else {
-                                this.updateStateVarsOfChildByElmtId(elmtId, {});
+                                this.updateStateVarsOfChildByElmtId(b20, {});
                             }
                         }, { name: "PLVLoadingLayout" });
                     }
@@ -205,11 +202,11 @@ export class PLVSimpleWeb extends ViewPU {
             }
         }, If);
         If.pop();
-        this.observeComponentCreation2((elmtId, isInitialRender) => {
+        this.observeComponentCreation2((r19, s19) => {
             If.create();
             if (this.webStatus === PLVWebpageStatus.ERROR && this.showLoading) {
                 this.ifElseBranchUpdateFunction(0, () => {
-                    this.observeComponentCreation2((elmtId, isInitialRender) => {
+                    this.observeComponentCreation2((x19, y19) => {
                         Column.create();
                         Column.justifyContent(FlexAlign.Center);
                         Column.alignItems(HorizontalAlign.Center);
@@ -218,17 +215,16 @@ export class PLVSimpleWeb extends ViewPU {
                         Column.height(PLVCommonConstants.FULL_PERCENT);
                     }, Column);
                     {
-                        this.observeComponentCreation2((elmtId, isInitialRender) => {
-                            if (isInitialRender) {
-                                let componentCall = new PLVFailureLayout(this, {
+                        this.observeComponentCreation2((t19, u19) => {
+                            if (u19) {
+                                let v19 = new PLVFailureLayout(this, {
                                     handleReload: () => {
                                         this.webStatus = PLVWebpageStatus.INIT;
                                         this.controller?.refresh();
                                     }
-                                }, undefined, elmtId, () => {
-                                }, { page: "foundation/src/main/ets/modules/web/PLVSimpleWeb.ets", line: 131, b2: 11 });
-                                ViewPU.create(componentCall);
-                                let paramsLambda = () => {
+                                }, undefined, t19, () => { }, { page: "foundation/src/main/ets/modules/web/PLVSimpleWeb.ets", line: 131, col: 11 });
+                                ViewPU.create(v19);
+                                let w19 = () => {
                                     return {
                                         handleReload: () => {
                                             this.webStatus = PLVWebpageStatus.INIT;
@@ -236,10 +232,10 @@ export class PLVSimpleWeb extends ViewPU {
                                         }
                                     };
                                 };
-                                componentCall.paramsGenerator_ = paramsLambda;
+                                v19.paramsGenerator_ = w19;
                             }
                             else {
-                                this.updateStateVarsOfChildByElmtId(elmtId, {});
+                                this.updateStateVarsOfChildByElmtId(t19, {});
                             }
                         }, { name: "PLVFailureLayout" });
                     }

package/src/main/ets/modules/web/PLVWebController.d.ets

@@ -1,7 +1,7 @@
-import { webview } from '@kit.ArkWeb';
+import webview from "@ohos.web.webview";
 import { PLVCallback, PLVCallback2 } from '../../common/PLVCallback';
 import { PLVFullScreenStatus, PLVWebpageStatus } from '../../common/PLVCommonEnums';
-import { common } from '@kit.AbilityKit';
+import common from "@ohos.app.ability.common";
 export declare class PLVWebController extends webview.WebviewController {
     static importSDKModuleContext: common.UIAbilityContext;
     _webStatus: PLVWebpageStatus;
@@ -41,48 +41,48 @@ export declare class PLVWebController extends webview.WebviewController {
     _overScrollMode: OverScrollMode;
     private dialogController;
     private jsBridge;
-    constructor(webTag?: string);
+    constructor(m23?: string);
     accessBackward(): boolean;
     backward(): void;
-    darkMode(darkMode: WebDarkMode): PLVWebController;
-    forceDarkAccess(forceDarkAccess: boolean): PLVWebController;
-    domStorageAccess(domStorageAccess: boolean): PLVWebController;
-    zoomAccess(zoomAccess: boolean): PLVWebController;
-    fileAccess(fileAccess: boolean): PLVWebController;
-    multiWindowAccess(multiWindowAccess: boolean): PLVWebController;
-    allowWindowOpenMethod(allowWindowOpenMethod: boolean): PLVWebController;
-    javaScriptAccess(javaScriptAccess: boolean): PLVWebController;
-    mixMode(mixedMode: MixedMode): PLVWebController;
-    cacheMode(cacheMode: CacheMode): PLVWebController;
-    onControllerAttached(callback: PLVCallback<void, void>): PLVWebController;
-    addOnControllerAttached(callback: PLVCallback<void, void>): PLVWebController;
-    onInterceptRequest(callback: PLVCallback<WebResourceRequest, WebResourceResponse>): PLVWebController;
-    onLoadIntercept(callback: PLVCallback<WebResourceRequest, boolean>): PLVWebController;
-    onWindowNew(callback: PLVCallback<OnWindowNewEvent, boolean>): PLVWebController;
-    onShowFileSelector(callback: PLVCallback<OnShowFileSelectorEvent, boolean>): PLVWebController;
-    onFullScreenEnter(callback: PLVCallback<void, boolean>): PLVWebController;
-    onFullScreenExit(callback: PLVCallback<void, boolean>): PLVWebController;
-    onProgressChange(callback: PLVCallback<OnProgressChangeEvent, void>): PLVWebController;
-    onPageBegin(callback: PLVCallback<OnPageBeginEvent, void>): PLVWebController;
-    onPageEnd(callback: PLVCallback<OnPageEndEvent, void>): PLVWebController;
-    addOnPageEnd(callback: PLVCallback<OnPageEndEvent, void>): PLVWebController;
-    onErrorReceive(callback: PLVCallback<OnErrorReceiveEvent, void>): PLVWebController;
-    backgroundColor(backgroundColor: ResourceColor): this;
-    verticalScrollBarAccess(verticalScrollBarAccess: boolean): this;
-    nestedScrollOptions(t8: NestedScrollOptions): this;
-    overScrollMode(overScrollMode: OverScrollMode): void;
-    userAgent(userAgent?: string): this;
-    addOnReloaded(callback: PLVCallback): this;
-    registerHandler(s8: string, handle: PLVCallback2<string, PLVCallback<string>>): this;
-    callHandle(q8: string, data: string, r8: PLVCallback<string>): this;
-    loadHtmlData(data?: string): this;
-    loadUrlCatch(url: string | Resource): void;
+    darkMode(k23: WebDarkMode): PLVWebController;
+    forceDarkAccess(j23: boolean): PLVWebController;
+    domStorageAccess(i23: boolean): PLVWebController;
+    zoomAccess(h23: boolean): PLVWebController;
+    fileAccess(g23: boolean): PLVWebController;
+    multiWindowAccess(f23: boolean): PLVWebController;
+    allowWindowOpenMethod(e23: boolean): PLVWebController;
+    javaScriptAccess(d23: boolean): PLVWebController;
+    mixMode(c23: MixedMode): PLVWebController;
+    cacheMode(b23: CacheMode): PLVWebController;
+    onControllerAttached(a23: PLVCallback<void, void>): PLVWebController;
+    addOnControllerAttached(z22: PLVCallback<void, void>): PLVWebController;
+    onInterceptRequest(y22: PLVCallback<WebResourceRequest, WebResourceResponse>): PLVWebController;
+    onLoadIntercept(x22: PLVCallback<WebResourceRequest, boolean>): PLVWebController;
+    onWindowNew(w22: PLVCallback<OnWindowNewEvent, boolean>): PLVWebController;
+    onShowFileSelector(v22: PLVCallback<OnShowFileSelectorEvent, boolean>): PLVWebController;
+    onFullScreenEnter(u22: PLVCallback<void, boolean>): PLVWebController;
+    onFullScreenExit(t22: PLVCallback<void, boolean>): PLVWebController;
+    onProgressChange(s22: PLVCallback<OnProgressChangeEvent, void>): PLVWebController;
+    onPageBegin(r22: PLVCallback<OnPageBeginEvent, void>): PLVWebController;
+    onPageEnd(q22: PLVCallback<OnPageEndEvent, void>): PLVWebController;
+    addOnPageEnd(p22: PLVCallback<OnPageEndEvent, void>): PLVWebController;
+    onErrorReceive(o22: PLVCallback<OnErrorReceiveEvent, void>): PLVWebController;
+    backgroundColor(n22: ResourceColor): this;
+    verticalScrollBarAccess(m22: boolean): this;
+    nestedScrollOptions(l22: NestedScrollOptions): this;
+    overScrollMode(k22: OverScrollMode): void;
+    userAgent(j22?: string): this;
+    addOnReloaded(i22: PLVCallback): this;
+    registerHandler(g22: string, h22: PLVCallback2<string, PLVCallback<string>>): this;
+    callHandle(d22: string, e22: string, f22: PLVCallback<string>): this;
+    loadHtmlData(a22?: string): this;
+    loadUrlCatch(w21: string | Resource): void;
     handleControllerAttached(): void;
     handleFullScreenExit(): void;
     handleFullScreenEnter(): void;
-    handleWindowNew(event: OnWindowNewEvent, builder: (webviewController: WebviewController) => CustomDialogController): void;
-    handleIsLoadIntercept(intercept: WebResourceRequest | undefined): boolean;
-    handlePageEnd(event: OnPageEndEvent): void;
+    handleWindowNew(s21: OnWindowNewEvent, t21: (webviewController: WebviewController) => CustomDialogController): void;
+    handleIsLoadIntercept(q21: WebResourceRequest | undefined): boolean;
+    handlePageEnd(n21: OnPageEndEvent): void;
     handleErrorReceive(): void;
     private getVideoWHEnterFullScreen;
 }