@polyvharmony/live-scenes-foundation 1.3.0-rc.3 → 1.3.1

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

@@ -1,62 +1,62 @@
-var u1 = (this && this.u1) || function (j2, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.v1 === "function")
-        r = Reflect.v1(j2, target, key, desc);
+var __decorate = (this && this.__decorate) || function (x2, y2, z2, a3) {
+    var b3 = arguments.length, c3 = b3 < 3 ? y2 : a3 === null ? a3 = Object.getOwnPropertyDescriptor(y2, z2) : a3, d3;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+        c3 = Reflect.decorate(x2, y2, z2, a3);
     else
-        for (var k2 = j2.length - 1; k2 >= 0; k2--)
-            if (d = j2[k2])
-                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+        for (var e3 = x2.length - 1; e3 >= 0; e3--)
+            if (d3 = x2[e3])
+                c3 = (b3 < 3 ? d3(c3) : b3 > 3 ? d3(y2, z2, c3) : d3(y2, z2)) || c3;
+    return b3 > 3 && c3 && Object.defineProperty(y2, z2, c3), c3;
 };
 import PLVLogger from '../modules/log/PLVLogger';
 import PLVUtils from './PLVUtils';
-export function PLVCustomBuilder(data, parent = null) {
-    const i2 = data;
+export function PLVCustomBuilder(u2, v2 = null) {
+    const w2 = u2;
 }
 export class PLVMediaQueryListener {
-    constructor(listener, callback) {
-        this.listener = listener;
-        this.callback = callback;
+    constructor(s2, t2) {
+        this.listener = s2;
+        this.callback = t2;
     }
     off() {
         this.listener?.off("change", this.callback);
     }
 }
 export class PLVAvoidAreaChangeListener {
-    constructor(h2, callback) {
-        this.windowClass = h2;
-        this.callback = callback;
+    constructor(q2, r2) {
+        this.windowClass = q2;
+        this.callback = r2;
     }
     off() {
         try {
             this.windowClass?.off("avoidAreaChange", this.callback);
         }
-        catch (e) {
+        catch (p2) {
         }
     }
 }
 export class PLVStateData {
-    constructor(data) {
-        this.data = data;
+    constructor(o2) {
+        this.data = o2;
     }
     copy() {
         return this.copyValue(this.data);
     }
-    copyValue(data) {
-        return new PLVStateData(data);
+    copyValue(n2) {
+        return new PLVStateData(n2);
     }
 }
 export class PLVStatefulData extends PLVStateData {
-    constructor(data, isSuccess = true, error) {
-        super(data);
-        this.isSuccess = isSuccess;
-        this.error = error;
+    constructor(k2, l2 = true, m2) {
+        super(k2);
+        this.isSuccess = l2;
+        this.error = m2;
     }
-    static success(data) {
-        return new PLVStatefulData(data, true);
+    static success(j2) {
+        return new PLVStatefulData(j2, true);
     }
-    static error(error) {
-        return new PLVStatefulData(undefined, false, error);
+    static error(i2) {
+        return new PLVStatefulData(undefined, false, i2);
     }
 }
 export class PLVDisposable {
@@ -74,32 +74,32 @@ export class PLVPromiseValue {
     constructor() {
         this.callbacks = [];
     }
-    set(value) {
+    set(g2) {
         if (this.value == undefined) {
-            this.resolve?.(value);
+            this.resolve?.(g2);
         }
-        if (this.value != value) {
-            this.callbacks.forEach(callback => {
-                callback(value);
+        if (this.value != g2) {
+            this.callbacks.forEach(h2 => {
+                h2(g2);
             });
         }
-        this.value = value;
+        this.value = g2;
     }
-    observe(callback) {
+    observe(f2) {
         if (this.value != undefined) {
-            callback(this.value);
+            f2(this.value);
         }
-        this.callbacks.push(callback);
+        this.callbacks.push(f2);
     }
     get() {
         if (this.value != undefined) {
             return this.value;
         }
         if (!this.promise) {
-            this.promise = PLVUtils.safePromise((g2, reject) => {
-                this.resolve = g2;
+            this.promise = PLVUtils.safePromise((d2, e2) => {
+                this.resolve = d2;
                 if (this.value != undefined) {
-                    g2(this.value);
+                    d2(this.value);
                 }
             });
         }
@@ -110,73 +110,73 @@ export class PLVPromiseValue {
     }
 }
 let PLVLazyValue = class PLVLazyValue {
-    constructor(f2) {
-        this._callback = f2;
+    constructor(c2) {
+        this._callback = c2;
     }
-    get(param) {
+    get(b2) {
         if (this._value == undefined) {
-            this._value = this._callback(param);
+            this._value = this._callback(b2);
         }
         return this._value;
     }
 };
-PLVLazyValue = u1([
+PLVLazyValue = __decorate([
     Observed
 ], PLVLazyValue);
 export { PLVLazyValue };
 let PLVAsyncLazyValue = class PLVAsyncLazyValue {
-    constructor(e2) {
-        this._callback = e2;
+    constructor(a2) {
+        this._callback = a2;
     }
-    get(callback, param) {
+    get(x1, y1) {
         if (this._value === undefined) {
-            this._callback(param, (value) => {
-                this._value = value;
-                callback(this._value);
+            this._callback(y1, (z1) => {
+                this._value = z1;
+                x1(this._value);
             });
         }
         else {
-            callback(this._value);
+            x1(this._value);
         }
     }
 };
-PLVAsyncLazyValue = u1([
+PLVAsyncLazyValue = __decorate([
     Observed
 ], PLVAsyncLazyValue);
 export { PLVAsyncLazyValue };
 export class PLVEventNotify {
-    constructor(c2, d2 = true) {
+    constructor(v1, w1 = true) {
         this.tag = '[PLVEventNotify]';
         this.events = new Map();
         this.emitLogToFile = true;
-        this.tag = PLVUtils.getClassTag(c2) || this.tag;
-        this.emitLogToFile = d2;
-    }
-    on(event, callback, a2) {
-        PLVLogger.info(PLVUtils.getClassTag(a2) || this.tag, `on event: ${event}`);
-        const b2 = this.events.get(event) || [];
-        b2.push(callback);
-        this.events.set(event, b2);
-    }
-    off(event, callback, w1) {
-        PLVLogger.info(PLVUtils.getClassTag(w1) || this.tag, `off event: ${event}`);
-        if (callback) {
-            const z1 = this.events.get(event) || [];
-            const index = z1.indexOf(callback);
-            if (index !== -1) {
-                z1.splice(index, 1);
+        this.tag = PLVUtils.getClassTag(v1) || this.tag;
+        this.emitLogToFile = w1;
+    }
+    on(r1, s1, t1) {
+        PLVLogger.info(PLVUtils.getClassTag(t1) || this.tag, `on event: ${r1}`);
+        const u1 = this.events.get(r1) || [];
+        u1.push(s1);
+        this.events.set(r1, u1);
+    }
+    off(m1, n1, o1) {
+        PLVLogger.info(PLVUtils.getClassTag(o1) || this.tag, `off event: ${m1}`);
+        if (n1) {
+            const p1 = this.events.get(m1) || [];
+            const q1 = p1.indexOf(n1);
+            if (q1 !== -1) {
+                p1.splice(q1, 1);
             }
-            this.events.set(event, z1);
+            this.events.set(m1, p1);
         }
         else {
-            this.events.delete(event);
+            this.events.delete(m1);
         }
     }
-    emit(event, ...args) {
-        PLVLogger.info(this.tag, `emit event: ${event}, args: ${args}`, this.emitLogToFile);
-        const v1 = this.events.get(event) || [];
-        v1.forEach(callback => {
-            callback(...args);
+    emit(i1, ...j1) {
+        PLVLogger.info(this.tag, `emit event: ${i1}, args: ${j1}`, this.emitLogToFile);
+        const k1 = this.events.get(i1) || [];
+        k1.forEach(l1 => {
+            l1(...j1);
         });
     }
     clear() {

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

@@ -1,22 +1,22 @@
 export var PLVWebpageStatus;
-(function (n2) {
-    n2["INIT"] = "init";
-    n2["ERROR"] = "error";
-    n2["FINISHED"] = "finished";
+(function (h3) {
+    h3["INIT"] = "init";
+    h3["ERROR"] = "error";
+    h3["FINISHED"] = "finished";
 })(PLVWebpageStatus || (PLVWebpageStatus = {}));
 export var PLVFullScreenStatus;
-(function (m2) {
-    m2["IDLE"] = "idle";
-    m2["ENTER"] = "enter";
-    m2["EXIT"] = "exit";
+(function (g3) {
+    g3["IDLE"] = "idle";
+    g3["ENTER"] = "enter";
+    g3["EXIT"] = "exit";
 })(PLVFullScreenStatus || (PLVFullScreenStatus = {}));
 export var PLVPrintLogLevel;
-(function (l2) {
-    l2[l2["ALL"] = 0] = "ALL";
-    l2[l2["VERBOSE"] = 2] = "VERBOSE";
-    l2[l2["DEBUG"] = 3] = "DEBUG";
-    l2[l2["INFO"] = 4] = "INFO";
-    l2[l2["WARN"] = 5] = "WARN";
-    l2[l2["ERROR"] = 6] = "ERROR";
-    l2[l2["NONE"] = 99] = "NONE";
+(function (f3) {
+    f3[f3["ALL"] = 0] = "ALL";
+    f3[f3["VERBOSE"] = 2] = "VERBOSE";
+    f3[f3["DEBUG"] = 3] = "DEBUG";
+    f3[f3["INFO"] = 4] = "INFO";
+    f3[f3["WARN"] = 5] = "WARN";
+    f3[f3["ERROR"] = 6] = "ERROR";
+    f3[f3["NONE"] = 99] = "NONE";
 })(PLVPrintLogLevel || (PLVPrintLogLevel = {}));

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

@@ -1,11 +1,11 @@
-import { ConfigurationConstant } from '@kit.AbilityKit';
-import { window } from '@kit.ArkUI';
+import ConfigurationConstant from "@ohos.app.ability.ConfigurationConstant";
+import window from "@ohos.window";
 export declare class PLVDeviceUtils {
     static getNavigationIndicatorHeight(): number;
     static getStatusBarHeight(): number;
     static getWidth(): number;
     static getHeight(): number;
     static getMinDisplaySide(): number;
-    static setColorMode(colorMode: ConfigurationConstant.ColorMode): void;
-    static setWindowSystemBarProperties(systemBarProperties?: window.SystemBarProperties): void;
+    static setColorMode(m3: ConfigurationConstant.ColorMode): void;
+    static setWindowSystemBarProperties(i3?: window.SystemBarProperties): void;
 }

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

@@ -17,20 +17,20 @@ export class PLVDeviceUtils {
     static getMinDisplaySide() {
         return Math.min(PLVDeviceUtils.getWidth(), PLVDeviceUtils.getHeight());
     }
-    static setColorMode(colorMode) {
-        AppUtil.getContext().getApplicationContext().setColorMode(colorMode);
+    static setColorMode(m3) {
+        AppUtil.getContext().getApplicationContext().setColorMode(m3);
     }
-    static setWindowSystemBarProperties(systemBarProperties) {
+    static setWindowSystemBarProperties(i3) {
         try {
-            let o2 = AppUtil.getMainWindow();
-            if (systemBarProperties) {
-                o2.setWindowSystemBarProperties(systemBarProperties).catch((error) => {
-                    PLVLogger.error(TAG, `setWindowSystemBarProperties-error ~ code: ${error.code} -·- message: ${error.message}`);
+            let k3 = AppUtil.getMainWindow();
+            if (i3) {
+                k3.setWindowSystemBarProperties(i3).catch((l3) => {
+                    PLVLogger.error(TAG, `setWindowSystemBarProperties-error ~ code: ${l3.code} -·- message: ${l3.message}`);
                 });
             }
         }
-        catch (err) {
-            PLVLogger.error(TAG, JSON.stringify(err));
+        catch (j3) {
+            PLVLogger.error(TAG, JSON.stringify(j3));
         }
     }
 }

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

@@ -1,4 +1,4 @@
-import { HashMap } from '@kit.ArkTS';
+import HashMap from "@ohos.util.HashMap";
 export declare class PLVHashMap<K, V> extends HashMap<K, V> {
-    set(key: K, value: V): PLVHashMap<K, V>;
+    set(n3: K, o3: V): PLVHashMap<K, V>;
 }

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

@@ -1,7 +1,7 @@
 import HashMap from "@ohos.util.HashMap";
 export class PLVHashMap extends HashMap {
-    set(key, value) {
-        super.set(key, value);
+    set(n3, o3) {
+        super.set(n3, o3);
         return this;
     }
 }

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

@@ -2,20 +2,20 @@ import { ClassConstructor } from 'class-transformer';
 import { PLVHttpData } from '../modules/net/PLVHttpData';
 import { PLVJSONObject } from './PLVType';
 export default class PLVJSONUtils {
-    static safeStringify(value?: Object, replacer?: (this: object, key: string, value: object) => object | undefined): string;
-    static safeParse(text?: string): object | undefined;
-    static json2Bean<T>(z2: ClassConstructor<T>, a3: string): T | undefined;
-    static bean2Json(data: Object | Array<Object | String | Number | Boolean> | null | undefined): string;
-    static bean2Bean<T, V>(w2: T, plain: V): T | undefined;
-    static httpData2Bean<T>(v2: T, plain: PLVHttpData<T>): T | undefined;
-    static json2Map(u2: string): Map<string, Object>;
-    static object2Map(object: PLVJSONObject): Map<string, Object | undefined>;
-    static map2json(map: Map<string, Object | undefined>): Record<string, Object>;
-    static map2jsonStr(map: Map<string, Object>, replacer?: (this: object, key: string, value: object) => object | undefined): string;
-    static toUnescapedData(t2: string): string;
-    static toFillData<T extends v8>(q2: ClassConstructor<T> | T, r2: string | Object | undefined): T | undefined;
+    static safeStringify(p4?: Object, q4?: (this: object, key: string, value: object) => object | undefined): string;
+    static safeParse(n4?: string): object | undefined;
+    static json2Bean<a24>(k4: ClassConstructor<a24>, l4: string): a24 | undefined;
+    static bean2Json(i4: Object | Array<Object | String | Number | Boolean> | null | undefined): string;
+    static bean2Bean<y23, z23>(f4: y23, g4: z23): y23 | undefined;
+    static httpData2Bean<x23>(b4: x23, c4: PLVHttpData<x23>): x23 | undefined;
+    static json2Map(a4: string): Map<string, Object>;
+    static object2Map(z3: PLVJSONObject): Map<string, Object | undefined>;
+    static map2json(v3: Map<string, Object | undefined>): Record<string, Object>;
+    static map2jsonStr(t3: Map<string, Object>, u3?: (this: object, key: string, value: object) => object | undefined): string;
+    static toUnescapedData(s3: string): string;
+    static toFillData<w23 extends FillData>(p3: ClassConstructor<w23> | w23, q3: string | Object | undefined): w23 | undefined;
 }
-interface v8 {
+interface FillData {
     fill(): void;
 }
 export {};

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

@@ -1,103 +1,103 @@
 import { instanceToPlain, plainToClass, plainToClassFromExist } from 'class-transformer';
 export default class PLVJSONUtils {
-    static safeStringify(value, replacer) {
+    static safeStringify(p4, q4) {
         try {
-            return JSON.stringify(value || new Object(), replacer);
+            return JSON.stringify(p4 || new Object(), q4);
         }
-        catch (e) {
+        catch (r4) {
             return '';
         }
     }
-    static safeParse(text) {
+    static safeParse(n4) {
         try {
-            return JSON.parse(text || '');
+            return JSON.parse(n4 || '');
         }
-        catch (e) {
+        catch (o4) {
             return undefined;
         }
     }
-    static json2Bean(z2, a3) {
+    static json2Bean(k4, l4) {
         try {
-            return plainToClass(z2, JSON.parse(a3), {
+            return plainToClass(k4, JSON.parse(l4), {
                 enableImplicitConversion: false, exposeDefaultValues: true
             });
         }
-        catch (e) {
+        catch (m4) {
             return undefined;
         }
     }
-    static bean2Json(data) {
+    static bean2Json(i4) {
         try {
-            if (data == null || data == undefined) {
+            if (i4 == null || i4 == undefined) {
                 return '';
             }
-            return JSON.stringify(instanceToPlain(data));
+            return JSON.stringify(instanceToPlain(i4));
         }
-        catch (e) {
+        catch (j4) {
             return "";
         }
     }
-    static bean2Bean(w2, plain) {
+    static bean2Bean(f4, g4) {
         try {
-            return plainToClassFromExist(w2, plain, {
+            return plainToClassFromExist(f4, g4, {
                 enableImplicitConversion: false, exposeDefaultValues: true
             });
         }
-        catch (e) {
+        catch (h4) {
             return undefined;
         }
     }
-    static httpData2Bean(v2, plain) {
+    static httpData2Bean(b4, c4) {
         try {
-            plain.data = plainToClassFromExist(v2, plain.data, {
+            c4.data = plainToClassFromExist(b4, c4.data, {
                 enableImplicitConversion: false, exposeDefaultValues: true
             });
             try {
-                plain.data.fill();
+                c4.data.fill();
             }
-            catch (err) {
+            catch (e4) {
             }
-            return plain.data;
+            return c4.data;
         }
-        catch (e) {
+        catch (d4) {
             return undefined;
         }
     }
-    static json2Map(u2) {
-        return new Map(Object.entries(JSON.parse(u2)));
+    static json2Map(a4) {
+        return new Map(Object.entries(JSON.parse(a4)));
     }
-    static object2Map(object) {
-        return new Map(Object.entries(object));
+    static object2Map(z3) {
+        return new Map(Object.entries(z3));
     }
-    static map2json(map) {
-        const obj = {};
-        map.forEach((value, key) => {
-            if (key && value) {
-                obj[key] = value;
+    static map2json(v3) {
+        const w3 = {};
+        v3.forEach((x3, y3) => {
+            if (y3 && x3) {
+                w3[y3] = x3;
             }
         });
-        return obj;
+        return w3;
     }
-    static map2jsonStr(map, replacer) {
-        return PLVJSONUtils.safeStringify(PLVJSONUtils.map2json(map), replacer);
+    static map2jsonStr(t3, u3) {
+        return PLVJSONUtils.safeStringify(PLVJSONUtils.map2json(t3), u3);
     }
-    static toUnescapedData(t2) {
-        if (!t2.includes('\\')) {
-            return t2;
+    static toUnescapedData(s3) {
+        if (!s3.includes('\\')) {
+            return s3;
         }
-        return t2.substring(1, t2.length - 1)
+        return s3.substring(1, s3.length - 1)
             .replace(/\\"/g, '"')
             .replace(/\\\\/g, '\\');
     }
-    static toFillData(q2, r2) {
-        let s2 = undefined;
-        if (typeof r2 === 'string') {
-            s2 = PLVJSONUtils.json2Bean(q2, r2);
+    static toFillData(p3, q3) {
+        let r3 = undefined;
+        if (typeof q3 === 'string') {
+            r3 = PLVJSONUtils.json2Bean(p3, q3);
         }
-        else if (typeof r2 === 'object') {
-            s2 = PLVJSONUtils.bean2Bean(q2, r2);
+        else if (typeof q3 === 'object') {
+            r3 = PLVJSONUtils.bean2Bean(p3, q3);
         }
-        s2?.fill();
-        return s2;
+        r3?.fill();
+        return r3;
     }
 }

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

@@ -1,6 +1,6 @@
 export declare class PLVNetUtils {
-    static replaceUrl(h3: string, i3: Map<string, string | undefined>): string;
-    static formatUrl(g3: string, record: Record<string, string | undefined>): string;
-    static formatParams(params?: Record<string, string>, d3?: boolean): string;
-    static appendParams(b3: string, params?: Record<string, string>): string;
+    static replaceUrl(d5: string, e5: Map<string, string | undefined>): string;
+    static formatUrl(b5: string, c5: Record<string, string | undefined>): string;
+    static formatParams(v4?: Record<string, string>, w4?: boolean): string;
+    static appendParams(s4: string, t4?: Record<string, string>): string;
 }

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

@@ -1,35 +1,35 @@
 export class PLVNetUtils {
-    static replaceUrl(h3, i3) {
-        const j3 = /{(\w+?)}/g;
-        let match;
-        let k3 = h3;
-        while ((match = j3.exec(h3)) !== null) {
-            const key = match[1];
-            const l3 = i3.get(key);
-            if (l3 !== undefined) {
-                k3 = k3.replace(match[0], l3);
+    static replaceUrl(d5, e5) {
+        const f5 = /{(\w+?)}/g;
+        let g5;
+        let h5 = d5;
+        while ((g5 = f5.exec(d5)) !== null) {
+            const i5 = g5[1];
+            const j5 = e5.get(i5);
+            if (j5 !== undefined) {
+                h5 = h5.replace(g5[0], j5);
             }
         }
-        return k3;
+        return h5;
     }
-    static formatUrl(g3, record) {
-        return PLVNetUtils.replaceUrl(g3, new Map(Object.entries(record)));
+    static formatUrl(b5, c5) {
+        return PLVNetUtils.replaceUrl(b5, new Map(Object.entries(c5)));
     }
-    static formatParams(params, d3) {
-        let e3 = '';
-        if (params) {
-            let f3 = true;
-            Object.entries(params).forEach((value, index) => {
-                if (value?.[0] && value?.[1]) {
-                    e3 += (f3 && !d3 ? '?' : '&') + value?.[0] + '=' + value?.[1];
-                    f3 = false;
+    static formatParams(v4, w4) {
+        let x4 = '';
+        if (v4) {
+            let y4 = true;
+            Object.entries(v4).forEach((z4, a5) => {
+                if (z4?.[0] && z4?.[1]) {
+                    x4 += (y4 && !w4 ? '?' : '&') + z4?.[0] + '=' + z4?.[1];
+                    y4 = false;
                 }
             });
         }
-        return e3;
+        return x4;
     }
-    static appendParams(b3, params) {
-        const c3 = b3.includes('?');
-        return b3 + PLVNetUtils.formatParams(params, c3);
+    static appendParams(s4, t4) {
+        const u4 = s4.includes('?');
+        return s4 + PLVNetUtils.formatParams(t4, u4);
     }
 }