arkanalyzer 1.0.90 → 1.0.91

package/lib/frontend/common/ModuleAnalysisConfig.d.ts

@@ -0,0 +1,92 @@
+import { SparseBitVector } from '../../utils/SparseBitVector';
+import { ModuleType } from '../../core/model/ArkModule';
+import { ModuleDepthLevel } from './ModuleDepth';
+import type { ModuleID } from '../../core/model/ArkModule';
+import type { ArkModule } from '../../core/model/ArkModule';
+import type { Scene } from '../../Scene';
+/**
+ * Callback invoked for each analyzed {@link ArkModule} within a {@link Scene}.
+ */
+export type ModuleAnalysisCallback = (module: ArkModule, scene: Scene) => void;
+/**
+ * ModuleAnalysisConfig configures target module selection and load levels
+ * for module-level analysis.
+ *
+ * Target module selection uses three dimensions combined as:
+ * ```
+ * module is target ⟺ !excludedModuleIds.has(id)
+ *                    && (includedTypes.has(type) || targetModuleIds.has(id))
+ * ```
+ * Priority: exclude > type filter / ID include (union).
+ *
+ * All three dimensions use {@link SparseBitVector} for efficient O(1) membership tests.
+ * Bit indices are {@link ModuleID} (for ID include/exclude) or {@link ModuleType} enum values
+ * (for type filter).
+ *
+ * Load levels ({@link ModuleDepthLevel}) control how much data is built for ArkFile objects:
+ * - {@link loadLevel} applies to target modules (default {@link ModuleDepthLevel.BODIES}).
+ * - {@link dependencyLoadLevel} applies to dependency modules — modules in the closure but
+ *   not targets (default {@link ModuleDepthLevel.SIGNATURES}).
+ *
+ * @category core/model
+ */
+export declare class ModuleAnalysisConfig {
+    /** Type filter: bit index = ModuleType enum value (0=PROJECT, 1=SDK, 2=OH_MODULES). */
+    private includedTypes;
+    /** Explicit include IDs: bit index = ModuleID (additive to type filter). */
+    private targetModuleIds;
+    /** Explicit exclude IDs: bit index = ModuleID (highest priority, overrides everything). */
+    private excludedModuleIds;
+    /** Load level for target modules. Default BODIES. */
+    private loadLevel;
+    /** Load level for dependency modules (in closure but not targets). Default SIGNATURES. */
+    private dependencyLoadLevel;
+    constructor();
+    /**
+     * Set whether all modules of the given type are included as targets.
+     * Returns this config to allow chaining.
+     */
+    setIncludeType(type: ModuleType, include: boolean): ModuleAnalysisConfig;
+    /** Check whether modules of the given type are included by the type filter. */
+    isTypeIncluded(type: ModuleType): boolean;
+    /**
+     * Replace the current explicit include ID set with the given IDs.
+     * Returns this config to allow chaining.
+     */
+    setTargetModuleIds(ids: ModuleID[]): ModuleAnalysisConfig;
+    /**
+     * Add a single module ID to the explicit include set.
+     * Returns this config to allow chaining.
+     */
+    addTargetModuleId(id: ModuleID): ModuleAnalysisConfig;
+    /** Returns the explicit include ID set as a {@link SparseBitVector} (read-only, do not modify). */
+    getTargetModuleIds(): SparseBitVector;
+    /**
+     * Replace the current explicit exclude ID set with the given IDs.
+     * Returns this config to allow chaining.
+     */
+    setExcludedModuleIds(ids: ModuleID[]): ModuleAnalysisConfig;
+    /**
+     * Add a single module ID to the explicit exclude set.
+     * Excluded modules are never targets, regardless of type filter or explicit include.
+     * Returns this config to allow chaining.
+     */
+    excludeModuleId(id: ModuleID): ModuleAnalysisConfig;
+    /** Returns the explicit exclude ID set as a {@link SparseBitVector} (read-only, do not modify). */
+    getExcludedModuleIds(): SparseBitVector;
+    /**
+     * Set the {@link ModuleDepthLevel} for target modules.
+     * Returns this config to allow chaining.
+     */
+    setLoadLevel(level: ModuleDepthLevel): ModuleAnalysisConfig;
+    /** Get the {@link ModuleDepthLevel} for target modules. Default {@link ModuleDepthLevel.BODIES}. */
+    getLoadLevel(): ModuleDepthLevel;
+    /**
+     * Set the {@link ModuleDepthLevel} for dependency modules (in closure but not targets).
+     * Returns this config to allow chaining.
+     */
+    setDependencyLoadLevel(level: ModuleDepthLevel): ModuleAnalysisConfig;
+    /** Get the {@link ModuleDepthLevel} for dependency modules. Default {@link ModuleDepthLevel.SIGNATURES}. */
+    getDependencyLoadLevel(): ModuleDepthLevel;
+}
+//# sourceMappingURL=ModuleAnalysisConfig.d.ts.map

package/lib/frontend/common/ModuleAnalysisConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleAnalysisConfig.d.ts","sourceRoot":"","sources":["../../../src/frontend/common/ModuleAnalysisConfig.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;AAE/E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,oBAAoB;IAC7B,uFAAuF;IACvF,OAAO,CAAC,aAAa,CAA0C;IAC/D,4EAA4E;IAC5E,OAAO,CAAC,eAAe,CAA0C;IACjE,2FAA2F;IAC3F,OAAO,CAAC,iBAAiB,CAA0C;IACnE,qDAAqD;IACrD,OAAO,CAAC,SAAS,CAA6C;IAC9D,0FAA0F;IAC1F,OAAO,CAAC,mBAAmB,CAAiD;;IAM5E;;;OAGG;IACI,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,oBAAoB;IAS/E,+EAA+E;IACxE,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO;IAMhD;;;OAGG;IACI,kBAAkB,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,oBAAoB;IAMhE;;;OAGG;IACI,iBAAiB,CAAC,EAAE,EAAE,QAAQ,GAAG,oBAAoB;IAK5D,mGAAmG;IAC5F,kBAAkB,IAAI,eAAe;IAM5C;;;OAGG;IACI,oBAAoB,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,oBAAoB;IAMlE;;;;OAIG;IACI,eAAe,CAAC,EAAE,EAAE,QAAQ,GAAG,oBAAoB;IAK1D,mGAAmG;IAC5F,oBAAoB,IAAI,eAAe;IAM9C;;;OAGG;IACI,YAAY,CAAC,KAAK,EAAE,gBAAgB,GAAG,oBAAoB;IAKlE,oGAAoG;IAC7F,YAAY,IAAI,gBAAgB;IAIvC;;;OAGG;IACI,sBAAsB,CAAC,KAAK,EAAE,gBAAgB,GAAG,oBAAoB;IAK5E,4GAA4G;IACrG,sBAAsB,IAAI,gBAAgB;CAGpD"}

package/lib/frontend/common/ModuleAnalysisConfig.js

@@ -0,0 +1,144 @@
+"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.ModuleAnalysisConfig = void 0;
+const SparseBitVector_1 = require("../../utils/SparseBitVector");
+const ModuleDepth_1 = require("./ModuleDepth");
+/**
+ * ModuleAnalysisConfig configures target module selection and load levels
+ * for module-level analysis.
+ *
+ * Target module selection uses three dimensions combined as:
+ * ```
+ * module is target ⟺ !excludedModuleIds.has(id)
+ *                    && (includedTypes.has(type) || targetModuleIds.has(id))
+ * ```
+ * Priority: exclude > type filter / ID include (union).
+ *
+ * All three dimensions use {@link SparseBitVector} for efficient O(1) membership tests.
+ * Bit indices are {@link ModuleID} (for ID include/exclude) or {@link ModuleType} enum values
+ * (for type filter).
+ *
+ * Load levels ({@link ModuleDepthLevel}) control how much data is built for ArkFile objects:
+ * - {@link loadLevel} applies to target modules (default {@link ModuleDepthLevel.BODIES}).
+ * - {@link dependencyLoadLevel} applies to dependency modules — modules in the closure but
+ *   not targets (default {@link ModuleDepthLevel.SIGNATURES}).
+ *
+ * @category core/model
+ */
+class ModuleAnalysisConfig {
+    constructor() {
+        /** Type filter: bit index = ModuleType enum value (0=PROJECT, 1=SDK, 2=OH_MODULES). */
+        this.includedTypes = new SparseBitVector_1.SparseBitVector();
+        /** Explicit include IDs: bit index = ModuleID (additive to type filter). */
+        this.targetModuleIds = new SparseBitVector_1.SparseBitVector();
+        /** Explicit exclude IDs: bit index = ModuleID (highest priority, overrides everything). */
+        this.excludedModuleIds = new SparseBitVector_1.SparseBitVector();
+        /** Load level for target modules. Default BODIES. */
+        this.loadLevel = ModuleDepth_1.ModuleDepthLevel.BODIES;
+        /** Load level for dependency modules (in closure but not targets). Default SIGNATURES. */
+        this.dependencyLoadLevel = ModuleDepth_1.ModuleDepthLevel.SIGNATURES;
+    }
+    // --- Type filter ---
+    /**
+     * Set whether all modules of the given type are included as targets.
+     * Returns this config to allow chaining.
+     */
+    setIncludeType(type, include) {
+        if (include) {
+            this.includedTypes.set(type);
+        }
+        else {
+            this.includedTypes.reset(type);
+        }
+        return this;
+    }
+    /** Check whether modules of the given type are included by the type filter. */
+    isTypeIncluded(type) {
+        return this.includedTypes.test(type);
+    }
+    // --- ID include (additive to type filter) ---
+    /**
+     * Replace the current explicit include ID set with the given IDs.
+     * Returns this config to allow chaining.
+     */
+    setTargetModuleIds(ids) {
+        this.targetModuleIds.clear();
+        ids.forEach(id => this.targetModuleIds.set(id));
+        return this;
+    }
+    /**
+     * Add a single module ID to the explicit include set.
+     * Returns this config to allow chaining.
+     */
+    addTargetModuleId(id) {
+        this.targetModuleIds.set(id);
+        return this;
+    }
+    /** Returns the explicit include ID set as a {@link SparseBitVector} (read-only, do not modify). */
+    getTargetModuleIds() {
+        return this.targetModuleIds;
+    }
+    // --- ID exclude (highest priority) ---
+    /**
+     * Replace the current explicit exclude ID set with the given IDs.
+     * Returns this config to allow chaining.
+     */
+    setExcludedModuleIds(ids) {
+        this.excludedModuleIds.clear();
+        ids.forEach(id => this.excludedModuleIds.set(id));
+        return this;
+    }
+    /**
+     * Add a single module ID to the explicit exclude set.
+     * Excluded modules are never targets, regardless of type filter or explicit include.
+     * Returns this config to allow chaining.
+     */
+    excludeModuleId(id) {
+        this.excludedModuleIds.set(id);
+        return this;
+    }
+    /** Returns the explicit exclude ID set as a {@link SparseBitVector} (read-only, do not modify). */
+    getExcludedModuleIds() {
+        return this.excludedModuleIds;
+    }
+    // --- Load levels ---
+    /**
+     * Set the {@link ModuleDepthLevel} for target modules.
+     * Returns this config to allow chaining.
+     */
+    setLoadLevel(level) {
+        this.loadLevel = level;
+        return this;
+    }
+    /** Get the {@link ModuleDepthLevel} for target modules. Default {@link ModuleDepthLevel.BODIES}. */
+    getLoadLevel() {
+        return this.loadLevel;
+    }
+    /**
+     * Set the {@link ModuleDepthLevel} for dependency modules (in closure but not targets).
+     * Returns this config to allow chaining.
+     */
+    setDependencyLoadLevel(level) {
+        this.dependencyLoadLevel = level;
+        return this;
+    }
+    /** Get the {@link ModuleDepthLevel} for dependency modules. Default {@link ModuleDepthLevel.SIGNATURES}. */
+    getDependencyLoadLevel() {
+        return this.dependencyLoadLevel;
+    }
+}
+exports.ModuleAnalysisConfig = ModuleAnalysisConfig;