arkanalyzer 1.0.90 → 1.0.91

package/lib/utils/Canonicalizer.js

@@ -0,0 +1,520 @@
+"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.Canonicalizer = void 0;
+const MIN_TABLE_CAPACITY = 16;
+const DEFAULT_LOAD_FACTOR = 0.7;
+const MAX_TABLE_CAPACITY = 0x40000000;
+function nextPowerOfTwoAtLeast(value) {
+    let capacity = MIN_TABLE_CAPACITY;
+    while (capacity < value) {
+        capacity *= 2;
+        if (capacity > MAX_TABLE_CAPACITY) {
+            throw new Error(`Canonicalizer table capacity ${value} exceeds supported capacity`);
+        }
+    }
+    return capacity;
+}
+function mixNumber(value) {
+    let hash = Math.imul(value ^ 0x9e3779b9, 0x85ebca6b);
+    hash ^= hash >>> 16;
+    hash = Math.imul(hash, 0x7feb352d);
+    hash ^= hash >>> 15;
+    return hash;
+}
+function hashString(value) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < value.length; i++) {
+        hash ^= value.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    hash ^= hash >>> 16;
+    return hash;
+}
+/**
+ * Utility class to map objects to dense integer IDs.
+ * Used for performance optimization to replace object-based maps/sets with array-based structures.
+ *
+ * @template T - The type of items to canonicalize
+ */
+class Canonicalizer {
+    /**
+     * @param keyExtractor - Function to extract a unique key from an item.
+     *                       Defaults to identity (using the item itself as key).
+     */
+    constructor(keyExtractor, equalityComparer) {
+        // Array from integer ID to Item
+        this.list = [];
+        this.strategy = 'uninitialized';
+        this.objectIdSymbol = Symbol('HomeFlowCanonicalizerId');
+        this.numberKeys = new Int32Array(0);
+        this.numberHeads = new Int32Array(0);
+        this.numberOccupied = new Uint8Array(0);
+        this.stringHashes = new Int32Array(0);
+        this.stringHeads = new Int32Array(0);
+        this.stringOccupied = new Uint8Array(0);
+        this.nextById = new Int32Array(0);
+        this.bucketCount = 0;
+        this.threshold = 0;
+        this.mask = 0;
+        this.collisionCount = 0;
+        this.maxChainLength = 0;
+        this.unsupportedKeyFailures = 0;
+        this.scratchFoundStored = undefined;
+        this.usesDefaultKeyExtractor = keyExtractor === undefined;
+        this.keyExtractor = keyExtractor !== null && keyExtractor !== void 0 ? keyExtractor : ((i) => i);
+        this.equalityComparer = equalityComparer;
+    }
+    /**
+     * Get the unique integer ID for an item.
+     * If the item (or its key) has been seen before, returns the existing ID.
+     * Otherwise, assigns a new ID.
+     */
+    getId(item) {
+        const key = this.keyExtractor(item);
+        this.ensureStrategy(key, item);
+        if (this.strategy === 'objectIdentity') {
+            return this.getObjectIdentityId(item, key);
+        }
+        if (this.strategy === 'numberWithEquality') {
+            return this.getNumberKeyId(key, item);
+        }
+        if (this.strategy === 'stringIdentity') {
+            return this.getStringKeyId(key, item);
+        }
+        return this.failUnsupportedKey(key);
+    }
+    hasDuplicateKeyResolver(item) {
+        return (item !== null &&
+            item !== undefined &&
+            typeof item
+                .preferCanonicalRepresentative === 'function');
+    }
+    maybeUpdateRepresentative(id, incoming, stored) {
+        if (this.hasDuplicateKeyResolver(incoming)) {
+            this.list[id] = incoming.preferCanonicalRepresentative(stored);
+        }
+    }
+    /**
+     * Get the integer ID of an item if it already exists.
+     * Returns -1 if the item has not been canonicalized.
+     */
+    getExistingId(item) {
+        const key = this.keyExtractor(item);
+        this.ensureStrategy(key, item);
+        if (this.strategy === 'objectIdentity') {
+            return this.getExistingObjectIdentityId(item, key);
+        }
+        if (this.strategy === 'numberWithEquality') {
+            return this.getExistingNumberKeyId(key, item);
+        }
+        if (this.strategy === 'stringIdentity') {
+            return this.getExistingStringKeyId(key, item);
+        }
+        return this.failUnsupportedKey(key);
+    }
+    /**
+     * Get the item associated with an integer ID.
+     */
+    get(id) {
+        return this.list[id];
+    }
+    /**
+     * Get the total number of unique items seen so far.
+     */
+    size() {
+        return this.list.length;
+    }
+    getStats() {
+        return {
+            strategy: this.strategy,
+            size: this.list.length,
+            bucketCount: this.bucketCount,
+            collisionCount: this.collisionCount,
+            maxChainLength: this.maxChainLength,
+            unsupportedKeyFailures: this.unsupportedKeyFailures,
+        };
+    }
+    /**
+     * Clear all mappings.
+     */
+    clear() {
+        if (this.strategy === 'objectIdentity') {
+            for (const item of this.list) {
+                const candidate = item;
+                if ((typeof candidate === 'object' && candidate !== null) || typeof candidate === 'function') {
+                    delete candidate[this.objectIdSymbol];
+                }
+            }
+        }
+        this.list = [];
+        this.strategy = 'uninitialized';
+        this.objectIdSymbol = Symbol('HomeFlowCanonicalizerId');
+        this.numberKeys = new Int32Array(0);
+        this.numberHeads = new Int32Array(0);
+        this.numberOccupied = new Uint8Array(0);
+        this.stringHashes = new Int32Array(0);
+        this.stringHeads = new Int32Array(0);
+        this.stringOccupied = new Uint8Array(0);
+        this.nextById = new Int32Array(0);
+        this.bucketCount = 0;
+        this.threshold = 0;
+        this.mask = 0;
+        this.collisionCount = 0;
+        this.maxChainLength = 0;
+        this.unsupportedKeyFailures = 0;
+    }
+    ensureStrategy(key, item) {
+        if (this.strategy !== 'uninitialized') {
+            return;
+        }
+        if (!this.equalityComparer && this.usesDefaultKeyExtractor && this.isObjectLike(key) && key === item) {
+            this.strategy = 'objectIdentity';
+            return;
+        }
+        if (!this.equalityComparer && this.usesDefaultKeyExtractor && typeof key === 'string') {
+            this.strategy = 'stringIdentity';
+            this.initializeStringTable();
+            return;
+        }
+        if (this.equalityComparer && typeof key === 'number' && Number.isInteger(key)) {
+            this.strategy = 'numberWithEquality';
+            this.initializeNumberTable();
+            return;
+        }
+        this.failUnsupportedKey(key);
+    }
+    getObjectIdentityId(item, key) {
+        if (!this.isObjectLike(key) || key !== item) {
+            return this.failUnsupportedKey(key);
+        }
+        const objectKey = key;
+        const existing = objectKey[this.objectIdSymbol];
+        if (existing !== undefined) {
+            return existing;
+        }
+        if (!Object.isExtensible(key)) {
+            throw new Error('Canonicalizer objectIdentity strategy requires extensible objects');
+        }
+        const id = this.list.length;
+        objectKey[this.objectIdSymbol] = id;
+        this.list.push(item);
+        return id;
+    }
+    getExistingObjectIdentityId(item, key) {
+        if (!this.isObjectLike(key) || key !== item) {
+            return this.failUnsupportedKey(key);
+        }
+        const existing = key[this.objectIdSymbol];
+        return existing === undefined ? -1 : existing;
+    }
+    getNumberKeyId(key, item) {
+        if (!Number.isInteger(key)) {
+            return this.failUnsupportedKey(key);
+        }
+        const slot = this.findNumberSlot(key);
+        if (this.numberOccupied[slot] !== 0) {
+            let chainLength = 0;
+            let id = this.numberHeads[slot];
+            while (id !== -1) {
+                chainLength++;
+                const stored = this.list[id];
+                if (this.equalityComparer(item, stored)) {
+                    this.scratchFoundStored = stored;
+                    this.maybeUpdateRepresentative(id, item, stored);
+                    this.updateMaxChainLength(chainLength);
+                    return id;
+                }
+                id = this.nextById[id];
+            }
+            this.collisionCount++;
+            this.updateMaxChainLength(chainLength + 1);
+            return this.appendNumberId(slot, key, item);
+        }
+        return this.appendNumberBucket(slot, key, item);
+    }
+    getExistingNumberKeyId(key, item) {
+        if (!Number.isInteger(key)) {
+            return this.failUnsupportedKey(key);
+        }
+        const slot = this.findExistingNumberSlot(key);
+        if (slot < 0) {
+            return -1;
+        }
+        let id = this.numberHeads[slot];
+        while (id !== -1) {
+            if (this.equalityComparer(item, this.list[id])) {
+                return id;
+            }
+            id = this.nextById[id];
+        }
+        return -1;
+    }
+    getStringKeyId(key, item) {
+        const hash = hashString(key);
+        const slot = this.findStringSlot(hash, key);
+        if (this.stringOccupied[slot] !== 0) {
+            return this.findStringIdOrAppend(slot, key, item);
+        }
+        return this.appendStringBucket(slot, hash, item);
+    }
+    getExistingStringKeyId(key, item) {
+        if (!this.usesDefaultKeyExtractor || item !== key) {
+            return this.failUnsupportedKey(key);
+        }
+        const hash = hashString(key);
+        const slot = this.findExistingStringSlot(hash, key);
+        if (slot < 0) {
+            return -1;
+        }
+        let id = this.stringHeads[slot];
+        while (id !== -1) {
+            if (this.list[id] === key) {
+                return id;
+            }
+            id = this.nextById[id];
+        }
+        return -1;
+    }
+    findStringIdOrAppend(slot, key, item) {
+        if (!this.usesDefaultKeyExtractor || item !== key) {
+            return this.failUnsupportedKey(key);
+        }
+        let chainLength = 0;
+        let id = this.stringHeads[slot];
+        while (id !== -1) {
+            chainLength++;
+            if (this.list[id] === key) {
+                this.updateMaxChainLength(chainLength);
+                return id;
+            }
+            id = this.nextById[id];
+        }
+        this.collisionCount++;
+        this.updateMaxChainLength(chainLength + 1);
+        return this.appendStringId(slot, item);
+    }
+    appendNumberBucket(slot, key, item) {
+        this.ensureBucketCapacityForInsert('numberWithEquality');
+        const insertSlot = this.findNumberSlot(key);
+        const id = this.list.length;
+        this.ensureNextCapacity(id + 1);
+        this.numberKeys[insertSlot] = key | 0;
+        this.numberHeads[insertSlot] = id;
+        this.numberOccupied[insertSlot] = 1;
+        this.nextById[id] = -1;
+        this.bucketCount++;
+        this.updateMaxChainLength(1);
+        this.list.push(item);
+        return id;
+    }
+    appendNumberId(slot, key, item) {
+        const id = this.list.length;
+        this.ensureNextCapacity(id + 1);
+        this.nextById[id] = this.numberHeads[slot];
+        this.numberHeads[slot] = id;
+        this.list.push(item);
+        return id;
+    }
+    appendStringBucket(slot, hash, item) {
+        this.ensureBucketCapacityForInsert('stringIdentity');
+        const insertSlot = this.findStringSlot(hash, item);
+        const id = this.list.length;
+        this.ensureNextCapacity(id + 1);
+        this.stringHashes[insertSlot] = hash;
+        this.stringHeads[insertSlot] = id;
+        this.stringOccupied[insertSlot] = 1;
+        this.nextById[id] = -1;
+        this.bucketCount++;
+        this.updateMaxChainLength(1);
+        this.list.push(item);
+        return id;
+    }
+    appendStringId(slot, item) {
+        const id = this.list.length;
+        this.ensureNextCapacity(id + 1);
+        this.nextById[id] = this.stringHeads[slot];
+        this.stringHeads[slot] = id;
+        this.list.push(item);
+        return id;
+    }
+    initializeNumberTable(expectedEntries = 1024) {
+        const capacity = nextPowerOfTwoAtLeast(Math.ceil(expectedEntries / DEFAULT_LOAD_FACTOR));
+        this.numberKeys = new Int32Array(capacity);
+        this.numberHeads = new Int32Array(capacity).fill(-1);
+        this.numberOccupied = new Uint8Array(capacity);
+        this.nextById = new Int32Array(Math.max(16, expectedEntries)).fill(-1);
+        this.mask = capacity - 1;
+        this.threshold = Math.max(1, Math.floor(capacity * DEFAULT_LOAD_FACTOR));
+    }
+    initializeStringTable(expectedEntries = 1024) {
+        const capacity = nextPowerOfTwoAtLeast(Math.ceil(expectedEntries / DEFAULT_LOAD_FACTOR));
+        this.stringHashes = new Int32Array(capacity);
+        this.stringHeads = new Int32Array(capacity).fill(-1);
+        this.stringOccupied = new Uint8Array(capacity);
+        this.nextById = new Int32Array(Math.max(16, expectedEntries)).fill(-1);
+        this.mask = capacity - 1;
+        this.threshold = Math.max(1, Math.floor(capacity * DEFAULT_LOAD_FACTOR));
+    }
+    ensureBucketCapacityForInsert(strategy) {
+        if (this.bucketCount + 1 <= this.threshold) {
+            return;
+        }
+        if (strategy === 'numberWithEquality') {
+            this.rehashNumberTable(this.numberKeys.length * 2);
+        }
+        else {
+            this.rehashStringTable(this.stringHashes.length * 2);
+        }
+    }
+    ensureNextCapacity(required) {
+        if (required <= this.nextById.length) {
+            return;
+        }
+        let newCapacity = this.nextById.length === 0 ? 16 : this.nextById.length;
+        while (newCapacity < required) {
+            newCapacity *= 2;
+        }
+        const next = new Int32Array(newCapacity).fill(-1);
+        next.set(this.nextById);
+        this.nextById = next;
+    }
+    findNumberSlot(key) {
+        let slot = mixNumber(key | 0) & this.mask;
+        while (this.numberOccupied[slot] !== 0 && this.numberKeys[slot] !== (key | 0)) {
+            slot = (slot + 1) & this.mask;
+        }
+        return slot;
+    }
+    findExistingNumberSlot(key) {
+        let slot = mixNumber(key | 0) & this.mask;
+        while (this.numberOccupied[slot] !== 0) {
+            if (this.numberKeys[slot] === (key | 0)) {
+                return slot;
+            }
+            slot = (slot + 1) & this.mask;
+        }
+        return -1;
+    }
+    findStringSlot(hash, key) {
+        let slot = mixNumber(hash) & this.mask;
+        while (this.stringOccupied[slot] !== 0) {
+            if (this.stringHashes[slot] === hash && this.stringBucketContainsKey(slot, key)) {
+                return slot;
+            }
+            slot = (slot + 1) & this.mask;
+        }
+        return slot;
+    }
+    findExistingStringSlot(hash, key) {
+        let slot = mixNumber(hash) & this.mask;
+        while (this.stringOccupied[slot] !== 0) {
+            if (this.stringHashes[slot] === hash && this.stringBucketContainsKey(slot, key)) {
+                return slot;
+            }
+            slot = (slot + 1) & this.mask;
+        }
+        return -1;
+    }
+    stringBucketContainsKey(slot, key) {
+        let id = this.stringHeads[slot];
+        while (id !== -1) {
+            if (this.list[id] === key) {
+                return true;
+            }
+            id = this.nextById[id];
+        }
+        return false;
+    }
+    rehashNumberTable(newCapacity) {
+        this.initializeNumberTableWithCapacity(newCapacity);
+        const items = this.list;
+        this.list = [];
+        for (const item of items) {
+            const key = this.keyExtractor(item);
+            const slot = this.findNumberSlot(key);
+            if (this.numberOccupied[slot] === 0) {
+                this.appendNumberBucket(slot, key, item);
+            }
+            else {
+                this.appendNumberId(slot, key, item);
+            }
+        }
+    }
+    rehashStringTable(newCapacity) {
+        this.initializeStringTableWithCapacity(newCapacity);
+        const items = this.list;
+        this.list = [];
+        for (const item of items) {
+            const key = this.keyExtractor(item);
+            const hash = hashString(key);
+            const slot = this.findStringSlot(hash, key);
+            if (this.stringOccupied[slot] === 0) {
+                this.appendStringBucket(slot, hash, item);
+            }
+            else {
+                this.appendStringId(slot, item);
+            }
+        }
+    }
+    initializeNumberTableWithCapacity(capacity) {
+        if (capacity > MAX_TABLE_CAPACITY) {
+            throw new Error(`Canonicalizer number table capacity ${capacity} exceeds supported capacity`);
+        }
+        this.numberKeys = new Int32Array(capacity);
+        this.numberHeads = new Int32Array(capacity).fill(-1);
+        this.numberOccupied = new Uint8Array(capacity);
+        this.nextById = new Int32Array(Math.max(16, this.list.length * 2)).fill(-1);
+        this.mask = capacity - 1;
+        this.threshold = Math.max(1, Math.floor(capacity * DEFAULT_LOAD_FACTOR));
+        this.bucketCount = 0;
+    }
+    initializeStringTableWithCapacity(capacity) {
+        if (capacity > MAX_TABLE_CAPACITY) {
+            throw new Error(`Canonicalizer string table capacity ${capacity} exceeds supported capacity`);
+        }
+        this.stringHashes = new Int32Array(capacity);
+        this.stringHeads = new Int32Array(capacity).fill(-1);
+        this.stringOccupied = new Uint8Array(capacity);
+        this.nextById = new Int32Array(Math.max(16, this.list.length * 2)).fill(-1);
+        this.mask = capacity - 1;
+        this.threshold = Math.max(1, Math.floor(capacity * DEFAULT_LOAD_FACTOR));
+        this.bucketCount = 0;
+    }
+    updateMaxChainLength(length) {
+        if (length > this.maxChainLength) {
+            this.maxChainLength = length;
+        }
+    }
+    isObjectLike(value) {
+        return (typeof value === 'object' && value !== null) || typeof value === 'function';
+    }
+    failUnsupportedKey(key) {
+        this.unsupportedKeyFailures++;
+        const keyType = key === null ? 'null' : typeof key;
+        throw new Error(`Canonicalizer does not support key type '${keyType}' without an explicit optimized strategy`);
+    }
+    /**
+     * Returns the stored item that was found during the last successful
+     * {@link getNumberKeyId} lookup, or `undefined` if no such lookup has
+     * occurred. This is a scratch field carried over from the homeflow
+     * implementation.
+     */
+    getScratchFoundStored() {
+        return this.scratchFoundStored;
+    }
+}
+exports.Canonicalizer = Canonicalizer;

package/lib/utils/ModuleUtils.js

@@ -183,8 +183,10 @@ class ModuleUtils {
             const main = this.getFileRealPath(path_1.default.resolve(modulePath, entry));
             ret.set(moduleName, new ModulePath(modulePath, main));
         }
-        // process dependency items
-        this.OH_PACKAGE_DEPENDENCY_KEYS.forEach((dependencyKey) => this.processDependency(content[dependencyKey], modulePath, ret, override, projectDir));
+        // process dependency items when not override
+        if (!override) {
+            this.OH_PACKAGE_DEPENDENCY_KEYS.forEach((dependencyKey) => this.processDependency(content[dependencyKey], modulePath, ret, override, projectDir));
+        }
     }
     static processDependency(dependencies, modulePath, ret, override, projectDir) {
         if (!dependencies) {

package/lib/utils/entryMethodUtils.d.ts

@@ -4,6 +4,29 @@ import { Stmt } from '../core/base/Stmt';
 export declare const LIFECYCLE_METHOD_NAME: string[];
 export declare const CALLBACK_METHOD_NAME: string[];
 export declare const COMPONENT_LIFECYCLE_METHOD_NAME: string[];
+/**
+ * 首块方法：创建阶段一次性执行、不可重复触发。
+ * 列表顺序严格遵循系统调度时序。
+ * Ability 创建 → 窗口/会话创建 → Component 创建
+ */
+export declare const LIFECYCLE_START_METHODS: string[];
+/**
+ * 尾块方法：销毁阶段一次性执行、不可重复触发。
+ * 列表顺序严格遵循系统调度时序。
+ * 窗口开始销毁 → 组件清理 → 窗口销毁完成 → Ability 销毁
+ */
+export declare const LIFECYCLE_END_METHODS: string[];
+/**
+ * 成对/成组出现的生命周期方法。
+ * 同一组中的方法在运行时交替循环出现，放入同一 basic block。
+ * 组内顺序严格遵循系统调度时序。
+ * 配对原则：交替循环出现 + 存在数据流依赖。
+ */
+export declare const LIFECYCLE_PAIRED_METHOD_GROUPS: string[][];
+/**
+ * 返回方法名所属的配对组索引，不属于任何配对组则返回 -1。
+ */
+export declare function getPairedMethodGroupIndex(methodName: string): number;
 export interface AbilityMessage {
     srcEntry: string;
     name: string;

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,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"}
+{"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;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,EAK3C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAM,EAOzC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,EAAE,MAAM,EAAE,EASpD,CAAC;AAEF;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAOpE;AAED,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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addCfg2Stmt = exports.getCallbackMethodFromStmt = exports.COMPONENT_LIFECYCLE_METHOD_NAME = exports.CALLBACK_METHOD_NAME = exports.LIFECYCLE_METHOD_NAME = void 0;
+exports.addCfg2Stmt = exports.getCallbackMethodFromStmt = exports.getPairedMethodGroupIndex = exports.LIFECYCLE_PAIRED_METHOD_GROUPS = exports.LIFECYCLE_END_METHODS = exports.LIFECYCLE_START_METHODS = exports.COMPONENT_LIFECYCLE_METHOD_NAME = exports.CALLBACK_METHOD_NAME = exports.LIFECYCLE_METHOD_NAME = void 0;
 const Type_1 = require("../core/base/Type");
 exports.LIFECYCLE_METHOD_NAME = [
     'onCreate',
@@ -90,6 +90,58 @@ exports.COMPONENT_LIFECYCLE_METHOD_NAME = [
     'onMeasure',
     'onMeasureSize',
 ];
+/**
+ * 首块方法：创建阶段一次性执行、不可重复触发。
+ * 列表顺序严格遵循系统调度时序。
+ * Ability 创建 → 窗口/会话创建 → Component 创建
+ */
+exports.LIFECYCLE_START_METHODS = [
+    'onCreate',
+    'onWindowStageCreate',
+    'onSessionCreate',
+    'aboutToAppear', // Component 实例创建后、build() 前调用
+];
+/**
+ * 尾块方法：销毁阶段一次性执行、不可重复触发。
+ * 列表顺序严格遵循系统调度时序。
+ * 窗口开始销毁 → 组件清理 → 窗口销毁完成 → Ability 销毁
+ */
+exports.LIFECYCLE_END_METHODS = [
+    'onWindowStageWillDestroy',
+    'aboutToDisappear',
+    'onDetached',
+    'onWindowStageDestroy',
+    'onSessionDestory',
+    'onDestroy', // Ability 最终销毁
+];
+/**
+ * 成对/成组出现的生命周期方法。
+ * 同一组中的方法在运行时交替循环出现，放入同一 basic block。
+ * 组内顺序严格遵循系统调度时序。
+ * 配对原则：交替循环出现 + 存在数据流依赖。
+ */
+exports.LIFECYCLE_PAIRED_METHOD_GROUPS = [
+    // 组件复用：recycle（加入复用池）→ reuse（从池取出），交替循环
+    ['aboutToRecycle', 'aboutToReuse'],
+    // 页面显示/隐藏：交替循环
+    ['onPageShow', 'onPageHide'],
+    // 前台/后台切换：前台序列 → 后台序列，交替循环
+    ['onWillForeground', 'onForeground', 'onDidForeground', 'onWillBackground', 'onBackground', 'onDidBackground'],
+    // 卡片回收/恢复：交替循环
+    ['onFormRecycle', 'onFormRecover'],
+];
+/**
+ * 返回方法名所属的配对组索引，不属于任何配对组则返回 -1。
+ */
+function getPairedMethodGroupIndex(methodName) {
+    for (let i = 0; i < exports.LIFECYCLE_PAIRED_METHOD_GROUPS.length; i++) {
+        if (exports.LIFECYCLE_PAIRED_METHOD_GROUPS[i].includes(methodName)) {
+            return i;
+        }
+    }
+    return -1;
+}
+exports.getPairedMethodGroupIndex = getPairedMethodGroupIndex;
 function getCallbackMethodFromStmt(stmt, scene) {
     const invokeExpr = stmt.getInvokeExpr();
     if (invokeExpr === undefined ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arkanalyzer",
-  "version": "1.0.90",
+  "version": "1.0.91",
   "files": [
     "lib",
     "config"