arkanalyzer 1.0.81 → 1.0.83

package/lib/save/source/SourceStmt.js

@@ -537,21 +537,64 @@ class SourceWhileStmt extends SourceStmt {
         code += `${this.valueToString(expr.getOp2())}) {`;
         this.setText(code);
     }
+    handlePrefixIncrementAndDecrement(stmt, value) {
+        const stmtLeftOp = stmt.getLeftOp();
+        if (stmtLeftOp.getName() === value.getName()) {
+            if (PrinterUtils_1.PrinterUtils.isDeIncrementStmt(stmt, Expr_1.NormalBinaryOperator.Addition)) {
+                this.context.setSkipStmt(stmt);
+                return `++${value.getName()}`;
+            }
+            else if (PrinterUtils_1.PrinterUtils.isDeIncrementStmt(stmt, Expr_1.NormalBinaryOperator.Subtraction)) {
+                this.context.setSkipStmt(stmt);
+                return `--${value.getName()}`;
+            }
+        }
+        return null;
+    }
+    handlePostfixIncrementAndDecrement(index, value, stmts) {
+        const stmt = stmts[index];
+        const stmtLeftOp = stmt.getLeftOp();
+        if (index <= 0 ||
+            index >= stmts.length - 1 ||
+            !(stmts[index - 1] instanceof Stmt_1.ArkAssignStmt) ||
+            !(stmts[stmts.length - 1] instanceof Stmt_1.ArkIfStmt)) {
+            return null;
+        }
+        const preStmt = stmts[index - 1];
+        const succesStmt = stmts[stmts.length - 1];
+        if (preStmt.getLeftOp() === succesStmt.getConditionExpr().getOp1() &&
+            preStmt.getRightOp() === stmtLeftOp &&
+            preStmt.getLeftOp() === value) {
+            if (PrinterUtils_1.PrinterUtils.isDeIncrementStmt(stmt, Expr_1.NormalBinaryOperator.Subtraction)) {
+                this.context.setSkipStmt(stmts[index - 1]);
+                this.context.setSkipStmt(stmt);
+                return `${stmtLeftOp.getName()}--`;
+            }
+            else if (PrinterUtils_1.PrinterUtils.isDeIncrementStmt(stmt, Expr_1.NormalBinaryOperator.Addition)) {
+                this.context.setSkipStmt(stmts[index - 1]);
+                this.context.setSkipStmt(stmt);
+                return `${stmtLeftOp.getName()}++`;
+            }
+        }
+        return null;
+    }
     valueToString(value) {
         if (!(value instanceof Local_1.Local)) {
             return this.transformer.valueToString(value);
         }
-        for (const stmt of this.block.getStmts()) {
-            if (!(stmt instanceof Stmt_1.ArkAssignStmt)) {
+        const stmts = this.block.getStmts();
+        for (let i = 0; i < stmts.length; ++i) {
+            if (!(stmts[i] instanceof Stmt_1.ArkAssignStmt)) {
                 continue;
             }
-            if (PrinterUtils_1.PrinterUtils.isDeIncrementStmt(stmt, Expr_1.NormalBinaryOperator.Addition) && stmt.getLeftOp().getName() === value.getName()) {
-                this.context.setSkipStmt(stmt);
-                return `${value.getName()}++`;
+            const stmt = stmts[i];
+            const prefixStr = this.handlePrefixIncrementAndDecrement(stmt, value);
+            if (prefixStr) {
+                return prefixStr;
             }
-            if (PrinterUtils_1.PrinterUtils.isDeIncrementStmt(stmt, Expr_1.NormalBinaryOperator.Subtraction) && stmt.getLeftOp().getName() === value.getName()) {
-                this.context.setSkipStmt(stmt);
-                return `${value.getName()}--`;
+            const postfixStr = this.handlePostfixIncrementAndDecrement(i, value, stmts);
+            if (postfixStr) {
+                return postfixStr;
             }
         }
         return this.transformer.valueToString(value);

package/lib/utils/IntMap.d.ts

@@ -0,0 +1,48 @@
+/**
+ * A memory-efficient Map-like structure where keys are integers and values are lists of integers.
+ * Uses a static linked list approach based on TypedArrays (SoA) to avoid JS object overhead.
+ *
+ * Memory per entry: 8 bytes (value + next pointer).
+ * Memory per key: 4 bytes (head pointer).
+ */
+export declare class IntMap {
+    private heads;
+    private values;
+    private nexts;
+    private count;
+    private capacity;
+    private keyRange;
+    /**
+     * @param keyRange - The maximum value of keys (nodeCapacity).
+     * @param initialCapacity - The initial total number of values across all keys.
+     */
+    constructor(keyRange: number, initialCapacity?: number);
+    /**
+     * Add a value to the list associated with the key.
+     */
+    add(key: number, value: number): void;
+    /**
+     * Check if the list for a key contains a value.
+     */
+    contains(key: number, value: number): boolean;
+    /**
+     * Add a value only if it doesn't already exist in the key's list.
+     */
+    addUnique(key: number, value: number): boolean;
+    /**
+     * Get an iterator for the values associated with a key.
+     * Efficient for loops: for (const v of map.getValues(key)) { ... }
+     */
+    getValues(key: number): IterableIterator<number>;
+    /**
+     * Get all values as an array (less efficient due to allocation).
+     */
+    getAsArray(key: number): number[];
+    /**
+     * Check if a key has any values.
+     */
+    has(key: number): boolean;
+    private resizeHeads;
+    private resizeCapacity;
+}
+//# sourceMappingURL=IntMap.d.ts.map

package/lib/utils/IntMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntMap.d.ts","sourceRoot":"","sources":["../../src/utils/IntMap.ts"],"names":[],"mappings":"AAeA;;;;;;GAMG;AACH,qBAAa,MAAM;IACf,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAS;IAEzB;;;OAGG;gBACS,QAAQ,EAAE,MAAM,EAAE,eAAe,GAAE,MAAa;IAQ5D;;OAEG;IACI,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAe5C;;OAEG;IACI,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IAcpD;;OAEG;IACI,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IAQrD;;;OAGG;IACK,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAAC,MAAM,CAAC;IAWxD;;OAEG;IACI,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;IAaxC;;OAEG;IACI,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAOhC,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,cAAc;CAUzB"}

package/lib/utils/IntMap.js

@@ -0,0 +1,134 @@
+"use strict";
+/*
+ * Copyright (c) 2026 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntMap = void 0;
+/**
+ * A memory-efficient Map-like structure where keys are integers and values are lists of integers.
+ * Uses a static linked list approach based on TypedArrays (SoA) to avoid JS object overhead.
+ *
+ * Memory per entry: 8 bytes (value + next pointer).
+ * Memory per key: 4 bytes (head pointer).
+ */
+class IntMap {
+    /**
+     * @param keyRange - The maximum value of keys (nodeCapacity).
+     * @param initialCapacity - The initial total number of values across all keys.
+     */
+    constructor(keyRange, initialCapacity = 1024) {
+        this.count = 0;
+        this.keyRange = keyRange;
+        this.capacity = initialCapacity;
+        this.heads = new Int32Array(keyRange).fill(-1);
+        this.values = new Int32Array(initialCapacity);
+        this.nexts = new Int32Array(initialCapacity);
+    }
+    /**
+     * Add a value to the list associated with the key.
+     */
+    add(key, value) {
+        if (key >= this.keyRange) {
+            this.resizeHeads(key + 1);
+        }
+        if (this.count >= this.capacity) {
+            this.resizeCapacity();
+        }
+        const idx = this.count++;
+        this.values[idx] = value;
+        this.nexts[idx] = this.heads[key];
+        this.heads[key] = idx;
+    }
+    /**
+     * Check if the list for a key contains a value.
+     */
+    contains(key, value) {
+        if (key >= this.keyRange) {
+            return false;
+        }
+        let curr = this.heads[key];
+        while (curr !== -1) {
+            if (this.values[curr] === value) {
+                return true;
+            }
+            curr = this.nexts[curr];
+        }
+        return false;
+    }
+    /**
+     * Add a value only if it doesn't already exist in the key's list.
+     */
+    addUnique(key, value) {
+        if (this.contains(key, value)) {
+            return false;
+        }
+        this.add(key, value);
+        return true;
+    }
+    /**
+     * Get an iterator for the values associated with a key.
+     * Efficient for loops: for (const v of map.getValues(key)) { ... }
+     */
+    *getValues(key) {
+        if (key >= this.keyRange) {
+            return;
+        }
+        let curr = this.heads[key];
+        while (curr !== -1) {
+            yield this.values[curr];
+            curr = this.nexts[curr];
+        }
+    }
+    /**
+     * Get all values as an array (less efficient due to allocation).
+     */
+    getAsArray(key) {
+        const result = [];
+        if (key >= this.keyRange) {
+            return result;
+        }
+        let curr = this.heads[key];
+        while (curr !== -1) {
+            result.push(this.values[curr]);
+            curr = this.nexts[curr];
+        }
+        return result;
+    }
+    /**
+     * Check if a key has any values.
+     */
+    has(key) {
+        if (key >= this.keyRange) {
+            return false;
+        }
+        return this.heads[key] !== -1;
+    }
+    resizeHeads(newRange) {
+        const newHeads = new Int32Array(newRange * 2).fill(-1);
+        newHeads.set(this.heads);
+        this.heads = newHeads;
+        this.keyRange = newHeads.length;
+    }
+    resizeCapacity() {
+        const newCapacity = this.capacity * 2;
+        const newValues = new Int32Array(newCapacity);
+        const newNexts = new Int32Array(newCapacity);
+        newValues.set(this.values);
+        newNexts.set(this.nexts);
+        this.values = newValues;
+        this.nexts = newNexts;
+        this.capacity = newCapacity;
+    }
+}
+exports.IntMap = IntMap;

package/lib/utils/IntWorkList.d.ts

@@ -0,0 +1,35 @@
+/**
+ * High-performance circular buffer worklist for integer IDs.
+ * Uses Int32Array to avoid object allocation and GC overhead.
+ */
+export declare class IntWorkList {
+    private buffer;
+    private head;
+    private tail;
+    private count;
+    private capacity;
+    private mask;
+    constructor(initialCapacity?: number);
+    /**
+     * Add a value to the end of the worklist.
+     */
+    push(value: number): void;
+    /**
+     * Remove and return the value from the front of the worklist.
+     * Returns undefined if empty.
+     */
+    pop(): number | undefined;
+    /**
+     * Check if the worklist is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Get the number of elements in the worklist.
+     */
+    size(): number;
+    /**
+     * Double the capacity of the buffer.
+     */
+    private resize;
+}
+//# sourceMappingURL=IntWorkList.d.ts.map

package/lib/utils/IntWorkList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntWorkList.d.ts","sourceRoot":"","sources":["../../src/utils/IntWorkList.ts"],"names":[],"mappings":"AAeA;;;GAGG;AACH,qBAAa,WAAW;IACpB,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,IAAI,CAAS;gBAGT,eAAe,GAAE,MAAa;IAU1C;;OAEG;IACI,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAShC;;;OAGG;IACI,GAAG,IAAI,MAAM,GAAG,SAAS;IAUhC;;OAEG;IACI,OAAO,IAAI,OAAO;IAIzB;;OAEG;IACI,IAAI,IAAI,MAAM;IAIrB;;OAEG;IACH,OAAO,CAAC,MAAM;CAsBjB"}

package/lib/utils/IntWorkList.js

@@ -0,0 +1,97 @@
+"use strict";
+/*
+ * Copyright (c) 2026 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntWorkList = void 0;
+/**
+ * High-performance circular buffer worklist for integer IDs.
+ * Uses Int32Array to avoid object allocation and GC overhead.
+ */
+class IntWorkList {
+    // Default start with 1K capacity 
+    constructor(initialCapacity = 1024) {
+        this.head = 0;
+        this.tail = 0;
+        this.count = 0;
+        // Ensure power of 2 capacity for efficient masking
+        this.capacity = 1;
+        while (this.capacity < initialCapacity) {
+            this.capacity <<= 1;
+        }
+        this.mask = this.capacity - 1;
+        this.buffer = new Int32Array(this.capacity);
+    }
+    /**
+     * Add a value to the end of the worklist.
+     */
+    push(value) {
+        if (this.count === this.capacity) {
+            this.resize();
+        }
+        this.buffer[this.tail] = value;
+        this.tail = (this.tail + 1) & this.mask;
+        this.count++;
+    }
+    /**
+     * Remove and return the value from the front of the worklist.
+     * Returns undefined if empty.
+     */
+    pop() {
+        if (this.count === 0) {
+            return undefined;
+        }
+        const value = this.buffer[this.head];
+        this.head = (this.head + 1) & this.mask;
+        this.count--;
+        return value;
+    }
+    /**
+     * Check if the worklist is empty.
+     */
+    isEmpty() {
+        return this.count === 0;
+    }
+    /**
+     * Get the number of elements in the worklist.
+     */
+    size() {
+        return this.count;
+    }
+    /**
+     * Double the capacity of the buffer.
+     */
+    resize() {
+        const oldCapacity = this.capacity;
+        const newCapacity = oldCapacity << 1;
+        const newBuffer = new Int32Array(newCapacity);
+        // Copy data to the beginning of the new buffer to linearize it
+        if (this.count > 0) {
+            if (this.head < this.tail) {
+                newBuffer.set(this.buffer.subarray(this.head, this.tail), 0);
+            }
+            else {
+                const firstPartLen = oldCapacity - this.head;
+                newBuffer.set(this.buffer.subarray(this.head, oldCapacity), 0);
+                newBuffer.set(this.buffer.subarray(0, this.tail), firstPartLen);
+            }
+        }
+        this.buffer = newBuffer;
+        this.capacity = newCapacity;
+        this.mask = newCapacity - 1;
+        this.head = 0;
+        this.tail = this.count;
+    }
+}
+exports.IntWorkList = IntWorkList;

package/lib/utils/PackedSparseMap.d.ts

@@ -0,0 +1,26 @@
+/**
+ * PackedSparseMap - A memory-efficient sparse index with packed storage.
+ *
+ * Implements a two-level indexing structure:
+ * - First level: Owner-based segmentation (sparse)
+ * - Second level: Sorted key-value pairs within each owner (packed)
+ *
+ */
+export declare class PackedSparseMap {
+    private offsets;
+    private lengths;
+    private capacities;
+    private keys;
+    private values;
+    private poolSize;
+    private poolCapacity;
+    constructor(initialOwnerCapacity: number, initialPoolCapacity: number);
+    getOrInsert(owner: number, key: number, createValue: () => number): number;
+    private binarySearch;
+    private binarySearchInsertPosition;
+    private ensureOwnerCapacity;
+    private ensureOwnerListCapacity;
+    private ensurePoolCapacity;
+    private resizeOwners;
+}
+//# sourceMappingURL=PackedSparseMap.d.ts.map

package/lib/utils/PackedSparseMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PackedSparseMap.d.ts","sourceRoot":"","sources":["../../src/utils/PackedSparseMap.ts"],"names":[],"mappings":"AAeA;;;;;;;GAOG;AACH,qBAAa,eAAe;IACxB,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,YAAY,CAAS;gBAEjB,oBAAoB,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM;IAU9D,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,MAAM,GAAG,MAAM;IA4BjF,OAAO,CAAC,YAAY;IAoBpB,OAAO,CAAC,0BAA0B;IAIlC,OAAO,CAAC,mBAAmB;IAc3B,OAAO,CAAC,uBAAuB;IAuB/B,OAAO,CAAC,kBAAkB;IAoB1B,OAAO,CAAC,YAAY;CAWvB"}

package/lib/utils/PackedSparseMap.js

@@ -0,0 +1,140 @@
+"use strict";
+/*
+ * Copyright (c) 2026 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackedSparseMap = void 0;
+/**
+ * PackedSparseMap - A memory-efficient sparse index with packed storage.
+ *
+ * Implements a two-level indexing structure:
+ * - First level: Owner-based segmentation (sparse)
+ * - Second level: Sorted key-value pairs within each owner (packed)
+ *
+ */
+class PackedSparseMap {
+    constructor(initialOwnerCapacity, initialPoolCapacity) {
+        this.poolSize = 0;
+        const ownerSize = Math.max(1, initialOwnerCapacity);
+        this.offsets = new Int32Array(ownerSize).fill(0);
+        this.lengths = new Int32Array(ownerSize).fill(0);
+        this.capacities = new Int32Array(ownerSize).fill(0);
+        this.poolCapacity = Math.max(1024, initialPoolCapacity);
+        this.keys = new Int32Array(this.poolCapacity);
+        this.values = new Int32Array(this.poolCapacity);
+    }
+    getOrInsert(owner, key, createValue) {
+        this.ensureOwnerCapacity(owner);
+        const offset = this.offsets[owner];
+        const length = this.lengths[owner];
+        const searchResult = this.binarySearch(offset, length, key);
+        if (searchResult.found) {
+            return this.values[offset + searchResult.index];
+        }
+        this.ensureOwnerListCapacity(owner, length + 1);
+        const updatedOffset = this.offsets[owner];
+        const updatedLength = this.lengths[owner];
+        const insertPos = this.binarySearchInsertPosition(updatedOffset, updatedLength, key);
+        for (let i = updatedLength; i > insertPos; i--) {
+            this.keys[updatedOffset + i] = this.keys[updatedOffset + i - 1];
+            this.values[updatedOffset + i] = this.values[updatedOffset + i - 1];
+        }
+        const value = createValue();
+        this.keys[updatedOffset + insertPos] = key;
+        this.values[updatedOffset + insertPos] = value;
+        this.lengths[owner] = updatedLength + 1;
+        return value;
+    }
+    binarySearch(offset, length, key) {
+        let low = 0;
+        let high = length - 1;
+        while (low <= high) {
+            const mid = (low + high) >>> 1;
+            const current = this.keys[offset + mid];
+            if (current === key) {
+                return { found: true, index: mid };
+            }
+            if (current < key) {
+                low = mid + 1;
+            }
+            else {
+                high = mid - 1;
+            }
+        }
+        return { found: false, index: low };
+    }
+    binarySearchInsertPosition(offset, length, key) {
+        return this.binarySearch(offset, length, key).index;
+    }
+    ensureOwnerCapacity(owner) {
+        if (owner < this.offsets.length) {
+            return;
+        }
+        let newSize = this.offsets.length;
+        if (newSize === 0) {
+            newSize = 1;
+        }
+        while (newSize <= owner) {
+            newSize <<= 1;
+        }
+        this.resizeOwners(newSize);
+    }
+    ensureOwnerListCapacity(owner, required) {
+        const cap = this.capacities[owner];
+        if (cap >= required) {
+            return;
+        }
+        const newCap = cap === 0 ? Math.max(4, required) : Math.max(cap << 1, required);
+        this.ensurePoolCapacity(newCap);
+        const oldOffset = this.offsets[owner];
+        const len = this.lengths[owner];
+        const newOffset = this.poolSize;
+        for (let i = 0; i < len; i++) {
+            this.keys[newOffset + i] = this.keys[oldOffset + i];
+            this.values[newOffset + i] = this.values[oldOffset + i];
+        }
+        this.offsets[owner] = newOffset;
+        this.capacities[owner] = newCap;
+        this.poolSize += newCap;
+    }
+    ensurePoolCapacity(additional) {
+        const required = this.poolSize + additional;
+        if (required <= this.poolCapacity) {
+            return;
+        }
+        let newCapacity = Math.max(this.poolCapacity << 1, 1024);
+        while (newCapacity < required) {
+            newCapacity <<= 1;
+        }
+        const newKeys = new Int32Array(newCapacity);
+        const newValues = new Int32Array(newCapacity);
+        newKeys.set(this.keys);
+        newValues.set(this.values);
+        this.keys = newKeys;
+        this.values = newValues;
+        this.poolCapacity = newCapacity;
+    }
+    resizeOwners(newSize) {
+        const newOffsets = new Int32Array(newSize);
+        const newLengths = new Int32Array(newSize);
+        const newCaps = new Int32Array(newSize);
+        newOffsets.set(this.offsets);
+        newLengths.set(this.lengths);
+        newCaps.set(this.capacities);
+        this.offsets = newOffsets;
+        this.lengths = newLengths;
+        this.capacities = newCaps;
+    }
+}
+exports.PackedSparseMap = PackedSparseMap;

package/lib/utils/entryMethodUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entryMethodUtils.d.ts","sourceRoot":"","sources":["../../src/utils/entryMethodUtils.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAGzC,eAAO,MAAM,qBAAqB,EAAE,MAAM,EA2BzC,CAAC;AACF,eAAO,MAAM,oBAAoB,EAAE,MAAM,EAiBxC,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,MAAM,EAkBnD,CAAC;AAEF,MAAM,WAAW,cAAc;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,GAAG,SAAS,GAAG,IAAI,CAoBpF;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CASnD"}
+{"version":3,"file":"entryMethodUtils.d.ts","sourceRoot":"","sources":["../../src/utils/entryMethodUtils.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAGzC,eAAO,MAAM,qBAAqB,EAAE,MAAM,EAmCzC,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,MAAM,EAiBxC,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,MAAM,EAmBnD,CAAC;AAEF,MAAM,WAAW,cAAc;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,GAAG,SAAS,GAAG,IAAI,CAoBpF;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CASnD"}

package/lib/utils/entryMethodUtils.js

@@ -18,22 +18,31 @@ exports.addCfg2Stmt = exports.getCallbackMethodFromStmt = exports.COMPONENT_LIFE
 const Type_1 = require("../core/base/Type");
 exports.LIFECYCLE_METHOD_NAME = [
     'onCreate',
-    'onDestroy',
     'onWindowStageCreate',
+    'onWindowStageWillDestroy',
     'onWindowStageDestroy',
+    'onWindowStageRestore',
+    'onDestroy',
+    'onWillForeground',
     'onForeground',
+    'onDidForeground',
+    'onWillBackground',
     'onBackground',
-    'onBackup',
-    'onRestore',
+    'onDidBackground',
     'onContinue',
     'onNewWant',
     'onDump',
     'onSaveState',
+    'onSaveStateAsync',
     'onShare',
     'onPrepareToTerminate',
+    'onPrepareToTerminateAsync',
     'onBackPressed',
+    'onCollaborate',
     'onSessionCreate',
     'onSessionDestory',
+    'onBackup',
+    'onRestore',
     'onAddForm',
     'onCastToNormalForm',
     'onUpdateForm',
@@ -42,7 +51,6 @@ exports.LIFECYCLE_METHOD_NAME = [
     'onRemoveForm',
     'onConfigurationUpdate',
     'onAcquireFormState',
-    'onWindowStageWillDestroy',
 ];
 exports.CALLBACK_METHOD_NAME = [
     'onClick',
@@ -65,21 +73,22 @@ exports.CALLBACK_METHOD_NAME = [
 exports.COMPONENT_LIFECYCLE_METHOD_NAME = [
     'build',
     'aboutToAppear',
+    'onDidBuild',
     'aboutToDisappear',
+    'onPageShow',
+    'onPageHide',
+    'onBackPress',
+    'onNewParam',
     'aboutToReuse',
     'aboutToRecycle',
     'onWillApplyTheme',
+    'pageTransition',
+    'onFormRecycle',
+    'onFormRecover',
     'onLayout',
     'onPlaceChildren',
     'onMeasure',
     'onMeasureSize',
-    'onPageShow',
-    'onPageHide',
-    'onFormRecycle',
-    'onFormRecover',
-    'onBackPress',
-    'pageTransition',
-    'onDidBuild',
 ];
 function getCallbackMethodFromStmt(stmt, scene) {
     const invokeExpr = stmt.getInvokeExpr();

package/lib/utils/logger.d.ts

@@ -10,6 +10,7 @@ export declare enum LOG_MODULE_TYPE {
     DEFAULT = "default",
     ARKANALYZER = "ArkAnalyzer",
     HOMECHECK = "HomeCheck",
+    HOMEFLOW = "HomeFlow",
     TOOL = "Tool"
 }
 export default class ConsoleLogger {

package/lib/utils/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGrC,oBAAY,SAAS;IACjB,KAAK,UAAU;IACf,IAAI,SAAS;IACb,IAAI,SAAS;IACb,KAAK,UAAU;IACf,KAAK,UAAU;CAClB;AAED,oBAAY,eAAe;IACvB,OAAO,YAAY;IACnB,WAAW,gBAAgB;IAC3B,SAAS,cAAc;IACvB,IAAI,SAAS;CAChB;AAED,MAAM,CAAC,OAAO,OAAO,aAAa;WAChB,SAAS,CACnB,WAAW,EAAE,MAAM,EACnB,iBAAiB,GAAE,SAA2B,EAC9C,UAAU,GAAE,SAA0B,EACtC,WAAW,GAAE,OAAe,GAC7B,IAAI;WAkDO,SAAS,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,GAAE,MAAY,GAAG,MAAM;CAWhF"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGrC,oBAAY,SAAS;IACjB,KAAK,UAAU;IACf,IAAI,SAAS;IACb,IAAI,SAAS;IACb,KAAK,UAAU;IACf,KAAK,UAAU;CAClB;AAED,oBAAY,eAAe;IACvB,OAAO,YAAY;IACnB,WAAW,gBAAgB;IAC3B,SAAS,cAAc;IACvB,QAAQ,aAAa;IACrB,IAAI,SAAS;CAChB;AAED,MAAM,CAAC,OAAO,OAAO,aAAa;WAChB,SAAS,CACnB,WAAW,EAAE,MAAM,EACnB,iBAAiB,GAAE,SAA2B,EAC9C,UAAU,GAAE,SAA0B,EACtC,WAAW,GAAE,OAAe,GAC7B,IAAI;WAkDO,SAAS,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,GAAE,MAAY,GAAG,MAAM;CAWhF"}

package/lib/utils/logger.js

@@ -29,6 +29,7 @@ var LOG_MODULE_TYPE;
     LOG_MODULE_TYPE["DEFAULT"] = "default";
     LOG_MODULE_TYPE["ARKANALYZER"] = "ArkAnalyzer";
     LOG_MODULE_TYPE["HOMECHECK"] = "HomeCheck";
+    LOG_MODULE_TYPE["HOMEFLOW"] = "HomeFlow";
     LOG_MODULE_TYPE["TOOL"] = "Tool";
 })(LOG_MODULE_TYPE = exports.LOG_MODULE_TYPE || (exports.LOG_MODULE_TYPE = {}));
 class ConsoleLogger {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "arkanalyzer",
-  "version": "1.0.81",
-"commit_id": "32732a4b",
+  "version": "1.0.83",
+"commit_id": "cf99dea1",
   "files": [
     "docs",
     "lib",