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

package/src/main/ets/common/PLVUtils.js

@@ -12,230 +12,230 @@ const TAG = '[PLVUtils]';
 export default class PLVUtils {
     constructor() {
     }
-    static init(context, windowStage) {
-        AppUtil.init(context, windowStage);
+    static init(f11, g11) {
+        AppUtil.init(f11, g11);
     }
-    static getClassTag(tag, d6 = true) {
-        let key = d6 ? '[Anonymous]' : undefined;
-        if (typeof tag == 'string') {
-            key = tag;
+    static getClassTag(c11, d11 = true) {
+        let e11 = d11 ? '[Anonymous]' : undefined;
+        if (typeof c11 == 'string') {
+            e11 = c11;
         }
         else {
-            if (tag && tag.constructor) {
-                key = `[${tag.constructor.name}]`;
+            if (c11 && c11.constructor) {
+                e11 = `[${c11.constructor.name}]`;
             }
         }
-        return key;
+        return e11;
     }
-    static retryWhen(when, retry) {
+    static retryWhen(y10, z10) {
         try {
-            return Promise.resolve(when());
+            return Promise.resolve(y10());
         }
-        catch (err) {
-            PLVLogger.printWarn(TAG, 'retryWhen catch error', err);
+        catch (a11) {
+            PLVLogger.printWarn(TAG, 'retryWhen catch error', a11);
             try {
-                return Promise.resolve(retry());
+                return Promise.resolve(z10());
             }
-            catch (err) {
-                PLVLogger.printWarn(TAG, 'retryWhen catch error while retry', err);
-                return Promise.reject(err);
+            catch (b11) {
+                PLVLogger.printWarn(TAG, 'retryWhen catch error while retry', b11);
+                return Promise.reject(b11);
             }
         }
     }
-    static async disposablePromise(promise, c6) {
+    static async disposablePromise(v10, w10) {
         try {
-            await promise;
+            await v10;
         }
-        catch (error) {
-            return Promise.reject(error);
+        catch (x10) {
+            return Promise.reject(x10);
         }
-        if (c6?.isDispose()) {
+        if (w10?.isDispose()) {
             return Promise.reject(new Error('error'));
         }
-        return promise;
+        return v10;
     }
-    static safePromise(callback, a6) {
-        const promise = new Promise(async (b6, reject) => {
+    static safePromise(p10, q10) {
+        const r10 = new Promise(async (s10, t10) => {
             try {
-                await callback(b6, reject);
+                await p10(s10, t10);
             }
-            catch (err) {
-                PLVLogger.printWarn(TAG, 'safePromise catch error', err);
-                reject(err);
+            catch (u10) {
+                PLVLogger.printWarn(TAG, 'safePromise catch error', u10);
+                t10(u10);
             }
         });
-        return PLVUtils.disposablePromise(promise, a6);
+        return PLVUtils.disposablePromise(r10, q10);
     }
-    static async retryPromise(w5, x5, promise, y5) {
-        let z5 = 0;
-        let error = new Error('error');
-        while (z5 <= w5) {
+    static async retryPromise(h10, i10, j10, k10) {
+        let l10 = 0;
+        let m10 = new Error('error');
+        while (l10 <= h10) {
             try {
-                const result = await promise;
-                if (!y5?.isDispose()) {
-                    return result;
+                const o10 = await j10;
+                if (!k10?.isDispose()) {
+                    return o10;
                 }
             }
-            catch (err) {
-                error = err;
-                PLVLogger.printWarn(TAG, `retryPromise retryCount=${z5} catch error`, err);
+            catch (n10) {
+                m10 = n10;
+                PLVLogger.printWarn(TAG, `retryPromise retryCount=${l10} catch error`, n10);
             }
-            if (++z5 > w5) {
+            if (++l10 > h10) {
                 break;
             }
-            if (y5?.isDispose()) {
-                return Promise.reject(error);
+            if (k10?.isDispose()) {
+                return Promise.reject(m10);
             }
-            await PLVUtils.delay(x5);
+            await PLVUtils.delay(i10);
         }
-        return Promise.reject(error);
+        return Promise.reject(m10);
     }
-    static async delay(delay) {
-        return PLVUtils.safePromise((v5) => {
-            setTimeout(v5, delay);
+    static async delay(f10) {
+        return PLVUtils.safePromise((g10) => {
+            setTimeout(g10, f10);
         });
     }
-    static validCallback(callback) {
-        return '/' != callback;
+    static validCallback(e10) {
+        return '/' != e10;
     }
     static getPid() {
-        const current = Date.now();
-        const random = Math.floor(Math.random() * 1000000) + 1000000;
-        return current + "X" + random;
+        const c10 = Date.now();
+        const d10 = Math.floor(Math.random() * 1000000) + 1000000;
+        return c10 + "X" + d10;
     }
     static getDeviceId() {
         return DeviceUtil.getDeviceId();
     }
-    static undefinedToValue(data, callback, delay) {
+    static undefinedToValue(z9, a10, b10) {
         setTimeout(() => {
-            callback(data);
-        }, delay ? delay : PLVCommonConstants.DELAY_TIME_S);
+            a10(z9);
+        }, b10 ? b10 : PLVCommonConstants.DELAY_TIME_S);
         return undefined;
     }
-    static copyText(text) {
-        return PasteboardUtil.setDataText(text);
+    static copyText(y9) {
+        return PasteboardUtil.setDataText(y9);
     }
-    static listenerOrientation(callback) {
-        const listener = mediaquery.matchMediaSync('(orientation: landscape)');
-        listener.on('change', callback);
-        return new PLVMediaQueryListener(listener, callback);
+    static listenerOrientation(w9) {
+        const x9 = mediaquery.matchMediaSync('(orientation: landscape)');
+        x9.on('change', w9);
+        return new PLVMediaQueryListener(x9, w9);
     }
-    static listenerAvoidAreaChange(callback) {
-        const t5 = AppUtil.getMainWindow();
+    static listenerAvoidAreaChange(t9) {
+        const u9 = AppUtil.getMainWindow();
         try {
-            t5.on('avoidAreaChange', callback);
+            u9.on('avoidAreaChange', t9);
         }
-        catch (u5) {
-            PLVLogger.error(TAG, `Failed to enable the listener for system avoid area changes. Cause code: ${u5.code}, message: ${u5.message}`);
+        catch (v9) {
+            PLVLogger.error(TAG, `Failed to enable the listener for system avoid area changes. Cause code: ${v9.code}, message: ${v9.message}`);
         }
-        return new PLVAvoidAreaChangeListener(t5, callback);
+        return new PLVAvoidAreaChangeListener(u9, t9);
     }
-    static changeOrientation(o5, component, p5) {
-        let context = getContext(component);
-        let q5 = (s5) => {
-            s5.setPreferredOrientation(o5 ? window.Orientation.LANDSCAPE : window.Orientation.PORTRAIT);
+    static changeOrientation(m9, n9, o9) {
+        let p9 = getContext(n9);
+        let q9 = (s9) => {
+            s9.setPreferredOrientation(m9 ? window.Orientation.LANDSCAPE : window.Orientation.PORTRAIT);
         };
-        p5 ? q5(p5) :
-            window.getLastWindow(context).then((r5) => {
-                q5(r5);
+        o9 ? q9(o9) :
+            window.getLastWindow(p9).then((r9) => {
+                q9(r9);
             });
     }
-    static isLandscape(component) {
-        let context = getContext(component);
-        return context.config.direction === ConfigurationConstant.Direction.DIRECTION_HORIZONTAL;
-    }
-    static setWindowFullScreen(isLayoutFullScreen = false, isFullScreen = false, component, h5) {
-        return new Promise((i5) => {
-            let context = getContext(component);
-            let j5 = (l5) => {
-                let m5 = l5.getWindowProperties().isLayoutFullScreen;
-                let n5 = l5.getWindowProperties().isFullScreen;
-                l5.setWindowLayoutFullScreen(isLayoutFullScreen);
+    static isLandscape(k9) {
+        let l9 = getContext(k9);
+        return l9.config.direction === ConfigurationConstant.Direction.DIRECTION_HORIZONTAL;
+    }
+    static setWindowFullScreen(z8 = false, a9 = false, b9, c9) {
+        return new Promise((d9) => {
+            let e9 = getContext(b9);
+            let f9 = (h9) => {
+                let i9 = h9.getWindowProperties().isLayoutFullScreen;
+                let j9 = h9.getWindowProperties().isFullScreen;
+                h9.setWindowLayoutFullScreen(z8);
                 if (canIUse("SystemCapability.Window.SessionManager")) {
-                    l5.setSpecificSystemBarEnabled('status', !isFullScreen);
-                    i5([m5, n5]);
+                    h9.setSpecificSystemBarEnabled('status', !a9);
+                    d9([i9, j9]);
                 }
             };
-            h5 ? j5(h5) :
-                window.getLastWindow(context).then((k5) => {
-                    j5(k5);
+            c9 ? f9(c9) :
+                window.getLastWindow(e9).then((g9) => {
+                    f9(g9);
                 });
         });
     }
-    static setWindowSystemBarProperties(systemBarProperties) {
-        PLVDeviceUtils.setWindowSystemBarProperties(systemBarProperties);
+    static setWindowSystemBarProperties(y8) {
+        PLVDeviceUtils.setWindowSystemBarProperties(y8);
     }
-    static startScan(component) {
-        return new Promise((g5) => {
+    static startScan(s8) {
+        return new Promise((t8) => {
             if (canIUse('SystemCapability.Multimedia.Scan.Core') && canIUse('SystemCapability.Multimedia.Scan.ScanBarcode')) {
-                let options = {
+                let u8 = {
                     scanTypes: [scanCore.ScanType.ALL],
                     enableMultiMode: true,
                     enableAlbum: true
                 };
                 try {
-                    scanBarcode.startScanForResult(getContext(component), options).then((result) => {
-                        PLVLogger.info(TAG, 'Promise scan result: ' + JSON.stringify(result));
-                        g5(result.originalValue);
-                    }).catch((error) => {
-                        PLVLogger.error(TAG, 'Promise error: ' + JSON.stringify(error));
+                    scanBarcode.startScanForResult(getContext(s8), u8).then((x8) => {
+                        PLVLogger.info(TAG, 'Promise scan result: ' + JSON.stringify(x8));
+                        t8(x8.originalValue);
+                    }).catch((w8) => {
+                        PLVLogger.error(TAG, 'Promise error: ' + JSON.stringify(w8));
                     });
                 }
-                catch (error) {
-                    PLVLogger.error(TAG, 'failReason: ' + JSON.stringify(error));
+                catch (v8) {
+                    PLVLogger.error(TAG, 'failReason: ' + JSON.stringify(v8));
                 }
             }
         });
     }
-    static getVideoRectJS(e5) {
-        let f5 = "function getVideoRect() {";
+    static getVideoRectJS(q8) {
+        let r8 = "function getVideoRect() {";
         {
-            f5 += "let tags = document.getElementsByTagName('video');";
-            f5 += "if (tags.length > 0) {";
+            r8 += "let tags = document.getElementsByTagName('video');";
+            r8 += "if (tags.length > 0) {";
             {
-                f5 += "let video = tags[0];";
-                f5 += "return {";
+                r8 += "let video = tags[0];";
+                r8 += "return {";
                 {
-                    f5 += "'width': video.videoWidth,";
-                    f5 += "'height': video.videoHeight";
+                    r8 += "'width': video.videoWidth,";
+                    r8 += "'height': video.videoHeight";
                 }
-                f5 += "};";
+                r8 += "};";
             }
-            f5 += "}";
-            f5 += "return {};";
+            r8 += "}";
+            r8 += "return {};";
         }
-        f5 += "}";
-        f5 += "getVideoRect();";
-        return e5 ? PLVCommonConstants.JS_PRE + f5 : f5;
-    }
-    static getExitFullScreenJS(c5) {
-        let d5 = "function exitFullScreen() {";
-        d5 += "document.getElementsByTagName('video')[0].webkitExitFullScreen()";
-        d5 += "}";
-        d5 += "exitFullScreen();";
-        return c5 ? PLVCommonConstants.JS_PRE + d5 : d5;
-    }
-    static colorResourceToHex(resource) {
-        return PLVUtils.colorIntToHex(getContext().resourceManager.getColorSync(resource));
-    }
-    static colorIntToHex(z4, a5 = false) {
-        const b5 = z4.toString(16).padStart(8, '0');
-        if (a5) {
-            return `#${b5.toUpperCase()}`;
+        r8 += "}";
+        r8 += "getVideoRect();";
+        return q8 ? PLVCommonConstants.JS_PRE + r8 : r8;
+    }
+    static getExitFullScreenJS(o8) {
+        let p8 = "function exitFullScreen() {";
+        p8 += "document.getElementsByTagName('video')[0].webkitExitFullScreen()";
+        p8 += "}";
+        p8 += "exitFullScreen();";
+        return o8 ? PLVCommonConstants.JS_PRE + p8 : p8;
+    }
+    static colorResourceToHex(n8) {
+        return PLVUtils.colorIntToHex(getContext().resourceManager.getColorSync(n8));
+    }
+    static colorIntToHex(k8, l8 = false) {
+        const m8 = k8.toString(16).padStart(8, '0');
+        if (l8) {
+            return `#${m8.toUpperCase()}`;
         }
         else {
-            return `#${b5.substring(2).toUpperCase()}`;
+            return `#${m8.substring(2).toUpperCase()}`;
         }
     }
-    static debounce(func, delay = 500, key = 'default') {
-        if (PLVUtils.TIMES.has(key)) {
-            clearTimeout(PLVUtils.TIMES.get(key));
+    static debounce(g8, h8 = 500, i8 = 'default') {
+        if (PLVUtils.TIMES.has(i8)) {
+            clearTimeout(PLVUtils.TIMES.get(i8));
         }
-        const timer = setTimeout(() => {
-            func();
-            PLVUtils.TIMES.delete(key);
-        }, delay);
-        PLVUtils.TIMES.set(key, timer);
+        const j8 = setTimeout(() => {
+            g8();
+            PLVUtils.TIMES.delete(i8);
+        }, h8);
+        PLVUtils.TIMES.set(i8, j8);
     }
 }
 PLVUtils.TIMES = new Map();

package/src/main/ets/common/PLVWebUtils.d.ets

@@ -1,6 +1,6 @@
 export declare class PLVWebUtils {
-    static toWebViewContent(content?: string, color?: string): string;
-    static toRGBA(g6: string): string;
-    static cleanHTML(input: string): string;
-    static openWebLink(url?: string, component?: object): void;
+    static toWebViewContent(v11?: string, w11?: string): string;
+    static toRGBA(q11: string): string;
+    static cleanHTML(m11: string): string;
+    static openWebLink(h11?: string, i11?: object): void;
 }

package/src/main/ets/common/PLVWebUtils.js

@@ -2,27 +2,27 @@ import { PLVTextUtils } from './PLVTextUtils';
 import PLVLogger from '../modules/log/PLVLogger';
 const TAG = '[PLVWebUtils]';
 export class PLVWebUtils {
-    static toWebViewContent(content, color) {
-        if (!content) {
-            return content;
+    static toWebViewContent(v11, w11) {
+        if (!v11) {
+            return v11;
         }
-        if (!color) {
-            color = "rgba(0, 0, 0, 1)";
+        if (!w11) {
+            w11 = "rgba(0, 0, 0, 1)";
         }
-        const style = "style=\" width:100%;\"";
-        const h6 = "word-break:break-all;";
-        const i6 = "color: " + color + ";";
-        content = content.replace(/src=\"\/\//g, "src=\"https://");
-        content = content.replace(/<img /g, "<img " + style + " ");
-        content = content.replace(/<li>/g, "<li style=\"" + i6 + "\">");
-        content = content.replace(/<p>/g, "<p style=\"" + h6 + i6 + "\">");
-        content = content.replace(/<div>/g, "<div style=\"" + h6 + i6 + "\">");
-        content = content.replace(/<table>/g, "<table border='1' rules=all style=\"" + i6 + "\">");
-        content = content.replace(/<td>/g, "<td width=\"36\">");
-        content = content.replace(/color: (#([0-9a-fA-F]{6}|[0-9a-fA-F]{8}));/g, (j6, k6) => {
-            return `color: ${PLVWebUtils.toRGBA(k6)};`;
+        const x11 = "style=\" width:100%;\"";
+        const y11 = "word-break:break-all;";
+        const z11 = "color: " + w11 + ";";
+        v11 = v11.replace(/src=\"\/\//g, "src=\"https://");
+        v11 = v11.replace(/<img /g, "<img " + x11 + " ");
+        v11 = v11.replace(/<li>/g, "<li style=\"" + z11 + "\">");
+        v11 = v11.replace(/<p>/g, "<p style=\"" + y11 + z11 + "\">");
+        v11 = v11.replace(/<div>/g, "<div style=\"" + y11 + z11 + "\">");
+        v11 = v11.replace(/<table>/g, "<table border='1' rules=all style=\"" + z11 + "\">");
+        v11 = v11.replace(/<td>/g, "<td width=\"36\">");
+        v11 = v11.replace(/color: (#([0-9a-fA-F]{6}|[0-9a-fA-F]{8}));/g, (a12, b12) => {
+            return `color: ${PLVWebUtils.toRGBA(b12)};`;
         });
-        content = "<!DOCTYPE html>\n" +
+        v11 = "<!DOCTYPE html>\n" +
             "<html lang=\"en\">\n" +
             "<head>\n" +
             "        <meta charset=\"UTF-8\">\n" +
@@ -30,46 +30,45 @@ export class PLVWebUtils {
             "        <meta http-equiv=\"X-UA-Compatible\" content=\"ie=edge\">\n" +
             "        <title>Document</title>\n" +
             "</head>\n" +
-            "<body style=\" color: " + color + ";margin:0;padding:0\">" +
-            content + "</body>\n" +
+            "<body style=\" color: " + w11 + ";margin:0;padding:0\">" + v11 + "</body>\n" +
             "</html>";
-        return content;
+        return v11;
     }
-    static toRGBA(g6) {
-        let alpha = 1;
-        if (g6.length > 7) {
-            alpha = parseInt(g6.substring(1, 3), 16) / 255;
-            g6 = `#${g6.substring(3)}`;
+    static toRGBA(q11) {
+        let r11 = 1;
+        if (q11.length > 7) {
+            r11 = parseInt(q11.substring(1, 3), 16) / 255;
+            q11 = `#${q11.substring(3)}`;
         }
-        const red = parseInt(g6.substring(1, 3), 16);
-        const green = parseInt(g6.substring(3, 5), 16);
-        const blue = parseInt(g6.substring(5, 7), 16);
-        return `rgba(${red}, ${green}, ${blue}, ${alpha})`;
+        const s11 = parseInt(q11.substring(1, 3), 16);
+        const t11 = parseInt(q11.substring(3, 5), 16);
+        const u11 = parseInt(q11.substring(5, 7), 16);
+        return `rgba(${s11}, ${t11}, ${u11}, ${r11})`;
     }
-    static cleanHTML(input) {
-        let e6 = input.replace(/<p>((?:<img[^>]*>)+)<\/p>/g, (match, f6) => {
-            return f6.replace(/<img[^>]*>/g, '[图片]');
+    static cleanHTML(m11) {
+        let n11 = m11.replace(/<p>((?:<img[^>]*>)+)<\/p>/g, (o11, p11) => {
+            return p11.replace(/<img[^>]*>/g, '[图片]');
         });
-        e6 = e6.replace(/<p><a[^>]*>(.*?)<\/a><\/p>/g, '$1');
-        e6 = e6.replace(/<p>(.*?)<\/p>/g, '$1');
-        e6 = e6.replace(/\n/g, ' ');
-        e6 = PLVTextUtils.convertSpecialString(e6);
-        return e6;
+        n11 = n11.replace(/<p><a[^>]*>(.*?)<\/a><\/p>/g, '$1');
+        n11 = n11.replace(/<p>(.*?)<\/p>/g, '$1');
+        n11 = n11.replace(/\n/g, ' ');
+        n11 = PLVTextUtils.convertSpecialString(n11);
+        return n11;
     }
-    static openWebLink(url, component) {
-        let want = {
+    static openWebLink(h11, i11) {
+        let j11 = {
             action: 'ohos.want.action.viewData',
             entities: ['entity.system.browsable'],
-            uri: url
+            uri: h11
         };
-        const context = getContext(component);
-        if (context) {
-            context.startAbility(want)
+        const k11 = getContext(i11);
+        if (k11) {
+            k11.startAbility(j11)
                 .then(() => {
-                PLVLogger.info(TAG, `openWebLink success, url: ${url}`);
+                PLVLogger.info(TAG, `openWebLink success, url: ${h11}`);
             })
-                .catch((err) => {
-                PLVLogger.error(TAG, `openWebLink error, url: ${url}, code: ${err.code}, message: ${err.message}`);
+                .catch((l11) => {
+                PLVLogger.error(TAG, `openWebLink error, url: ${h11}, code: ${l11.code}, message: ${l11.message}`);
             });
         }
         else {

package/src/main/ets/common/ui/PLVNodeController.d.ets

@@ -1,12 +1,14 @@
-import { BuilderNode, NodeController, UIContext } from '@kit.ArkUI';
+import { BuilderNode as BuilderNode } from "@ohos.arkui.node";
+import { NodeController as NodeController } from "@ohos.arkui.node";
+import { UIContext as UIContext } from "@ohos.arkui.UIContext";
 import { PLVPromiseValue } from '../PLVCallback';
 export declare class PLVNodeControllerManager {
     private static controllerManagers;
     private controllers;
     private constructor();
-    static get(id?: number): PLVNodeControllerManager;
-    static delete(id: number): void;
-    getOrCreate(config: string | NodeControllerConfig): PLVNodeController;
+    static get(q12?: number): PLVNodeControllerManager;
+    static delete(p12: number): void;
+    getOrCreate(m12: string | NodeControllerConfig): PLVNodeController;
     private destroy;
 }
 export declare class PLVNodeController extends NodeController {
@@ -22,12 +24,12 @@ export declare class PLVNodeController extends NodeController {
     isShowPromise: PLVPromiseValue<boolean>;
     private uiContext;
     private environmentCallback?;
-    constructor(config: NodeControllerConfig);
-    makeNode(uiContext: UIContext): FrameNode | null;
-    fill(wrapBuilder: WrappedBuilder<[
+    constructor(j12: NodeControllerConfig);
+    makeNode(i12: UIContext): FrameNode | null;
+    fill(g12: WrappedBuilder<[
         ESObject
-    ]>, params: ESObject): PLVNodeController;
-    show(isShow?: boolean): void;
+    ]>, h12: ESObject): PLVNodeController;
+    show(f12?: boolean): void;
     destroy(): void;
     private onEnvironment;
 }