arkanalyzer 1.0.90 → 1.0.91

package/lib/core/graph/FileDepGraph.js

@@ -0,0 +1,170 @@
+"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.FileDepGraph = void 0;
+const BaseImplicitGraph_1 = require("./BaseImplicitGraph");
+const Scc_1 = require("./Scc");
+/**
+ * File dependency graph, based on BaseImplicitGraph.
+ * The node type is ArkFile, and edges represent dependency relationships between files.
+ *
+ * Similar to ModuleDepGraph but operates at file granularity:
+ * - The node is the ArkFile itself, identified by its Canonicalizer-assigned ID
+ * - Edge information is implicitly stored via succMap/predMap (Map<NodeID, NodeID[]>)
+ * - Works with Canonicalizer<ArkFile> to provide bidirectional ArkFile <-> NodeID mapping
+ *
+ * SCCDetection is used to compute a topological order of files (depended-on files first).
+ */
+class FileDepGraph extends BaseImplicitGraph_1.BaseImplicitGraph {
+    constructor(fileCanonicalizer) {
+        super();
+        /**
+         * Topological order of nodes after SCC computation, populated by computeTopoOrder.
+         * Depended-on files appear before their dependents.
+         */
+        this.topoOrder = [];
+        this.fileCanonicalizer = fileCanonicalizer;
+        this.nodeToIdMap = new Map();
+        this.idToNodeMap = new Map();
+        this.succMap = new Map();
+        this.predMap = new Map();
+    }
+    getGraphName() {
+        return 'FileDepGraph';
+    }
+    /**
+     * Add a file node to the graph.
+     * The node's NodeID directly uses the ID assigned by the Canonicalizer.
+     */
+    addFile(file) {
+        const id = this.fileCanonicalizer.getId(file);
+        this.nodeToIdMap.set(file, id);
+        this.idToNodeMap.set(id, file);
+        // Ensure the node has corresponding entries in succMap and predMap (empty arrays)
+        if (!this.succMap.has(id)) {
+            this.succMap.set(id, []);
+        }
+        if (!this.predMap.has(id)) {
+            this.predMap.set(id, []);
+        }
+    }
+    /**
+     * Add a dependency edge: src depends on dst (src -> dst).
+     * succMap stores successors (dependency targets), predMap stores predecessors (dependents).
+     */
+    addDependencyEdge(srcId, dstId) {
+        // Add successor
+        let succs = this.succMap.get(srcId);
+        if (!succs) {
+            succs = [];
+            this.succMap.set(srcId, succs);
+        }
+        if (!succs.includes(dstId)) {
+            succs.push(dstId);
+        }
+        // Add predecessor
+        let preds = this.predMap.get(dstId);
+        if (!preds) {
+            preds = [];
+            this.predMap.set(dstId, preds);
+        }
+        if (!preds.includes(srcId)) {
+            preds.push(srcId);
+        }
+    }
+    /**
+     * Remove a dependency edge.
+     */
+    removeDependencyEdge(srcId, dstId) {
+        this.removeFromAdjacencyList(this.succMap, srcId, dstId);
+        this.removeFromAdjacencyList(this.predMap, dstId, srcId);
+    }
+    /**
+     * Remove a node ID from an adjacency list entry.
+     */
+    removeFromAdjacencyList(adjMap, key, value) {
+        const list = adjMap.get(key);
+        if (!list) {
+            return;
+        }
+        const idx = list.indexOf(value);
+        if (idx >= 0) {
+            list.splice(idx, 1);
+        }
+    }
+    /**
+     * Get all successor (dependency target) file IDs of the specified file.
+     */
+    getSuccFileIds(fileId) {
+        var _a;
+        return (_a = this.succMap.get(fileId)) !== null && _a !== void 0 ? _a : [];
+    }
+    /**
+     * Get all predecessor (dependent) file IDs of the specified file.
+     */
+    getPredFileIds(fileId) {
+        var _a;
+        return (_a = this.predMap.get(fileId)) !== null && _a !== void 0 ? _a : [];
+    }
+    /**
+     * Check whether a dependency edge exists between two files.
+     */
+    hasDependencyEdge(srcId, dstId) {
+        const succs = this.succMap.get(srcId);
+        return succs !== undefined && succs.includes(dstId);
+    }
+    /**
+     * Get the total number of edges in the graph.
+     */
+    getEdgeCount() {
+        let count = 0;
+        this.succMap.forEach((succs) => {
+            count += succs.length;
+        });
+        return count;
+    }
+    /**
+     * Get the topological order produced by the last computeTopoOrder call.
+     * Depended-on files appear before their dependents.
+     */
+    getTopoOrder() {
+        return this.topoOrder;
+    }
+    /**
+     * Compute the topological order of all files using SCCDetection.
+     * Each SCC representative in the topological stack is expanded to its members,
+     * so every node appears exactly once. The result is stored in topoOrder and returned.
+     * Depended-on files appear before their dependents.
+     */
+    computeTopoOrder() {
+        const scc = new Scc_1.SCCDetection(this);
+        scc.find();
+        const topoStack = scc.getTopoAndCollapsedNodeStack();
+        this.topoOrder = [];
+        const added = new Set();
+        for (const repId of topoStack) {
+            const members = Array.from(scc.getMySCCNodes(repId));
+            for (const memberId of members) {
+                if (!added.has(memberId)) {
+                    added.add(memberId);
+                    this.topoOrder.push(memberId);
+                }
+            }
+        }
+        return this.topoOrder;
+    }
+}
+exports.FileDepGraph = FileDepGraph;

package/lib/core/graph/GraphTraits.d.ts

@@ -4,5 +4,7 @@ export interface GraphTraits<Node> {
     nodesItor(): IterableIterator<Node>;
     getGraphName(): string;
     getNode(id: NodeID): Node | undefined;
+    getNodeID(node: Node): NodeID;
+    succ(id: NodeID): NodeID[];
 }
 //# sourceMappingURL=GraphTraits.d.ts.map

package/lib/core/graph/GraphTraits.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GraphTraits.d.ts","sourceRoot":"","sources":["../../../src/core/graph/GraphTraits.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC;AAC5B,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC;AAE1B,MAAM,WAAW,WAAW,CAAC,IAAI;IAC7B,SAAS,IAAI,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACpC,YAAY,IAAI,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACzC"}
+{"version":3,"file":"GraphTraits.d.ts","sourceRoot":"","sources":["../../../src/core/graph/GraphTraits.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC;AAC5B,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC;AAE1B,MAAM,WAAW,WAAW,CAAC,IAAI;IAC7B,SAAS,IAAI,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACpC,YAAY,IAAI,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACtC,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC;IAC9B,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC9B"}

package/lib/core/graph/GraphTraits.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-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

package/lib/core/graph/ModuleDepGraph.d.ts

@@ -0,0 +1,175 @@
+import { BaseImplicitGraph, NodeID } from './BaseImplicitGraph';
+import { ArkModule, ModuleID } from '../model/ArkModule';
+import { Canonicalizer } from '../../utils/Canonicalizer';
+/**
+ * Dependency type enum, indicating the source of a dependency edge.
+ * Used during SCC post-processing to remove edges by priority when splitting oversized module groups.
+ *
+ * Priority (removal priority; higher value = removed first):
+ *   - DEV_DEPENDENCIES (devDependencies): only needed during development, removed first
+ *   - DYNAMIC (dynamicDependencies): runtime dynamic loading, removed next
+ *   - DEPENDENCIES (dependencies): core dependency, removed last
+ */
+export declare enum DependencyType {
+    DEPENDENCIES = 0,
+    DYNAMIC = 1,
+    DEV_DEPENDENCIES = 2
+}
+/**
+ * Module dependency graph, based on BaseImplicitGraph.
+ * The node type is ArkModule, and edges represent dependency relationships between modules.
+ *
+ * Differences from DependsGraph (BaseExplicitGraph):
+ * - No BaseNode/BaseEdge objects needed; the node is the ArkModule itself
+ * - Edge information is implicitly stored via succMap/predMap (Map<NodeID, NodeID[]>)
+ * - Works with Canonicalizer<ArkModule> to provide bidirectional ArkModule <-> NodeID mapping
+ *
+ * SCCDetection has been generalized to accept any graph implementing GraphTraits<any>,
+ * i.e. one providing nodesItor(), getNode(id), getNodeID(node), succ(id) methods.
+ * ModuleDepGraph satisfies these methods by inheriting from BaseImplicitGraph,
+ * without requiring nodes to have BaseNode methods like getID() or getOutgoingEdges().
+ */
+export declare class ModuleDepGraph extends BaseImplicitGraph<ArkModule> {
+    /**
+     * Module Canonicalizer for bidirectional ArkModule <-> ModuleID(NodeID) mapping.
+     * Shares the same instance with the owning Scene's moduleCanonicalizer.
+     */
+    private moduleCanonicalizer;
+    /**
+     * Edge type map, key is `${srcId}->${dstId}`, value is the dependency type.
+     * Used during SCC post-processing to remove edges by dependency type priority.
+     */
+    private edgeTypeMap;
+    /**
+     * Topological order of nodes after SCC refinement, populated by refineSCCGroups.
+     * Depended-on modules appear before their dependents.
+     */
+    private topoOrder;
+    /**
+     * SCC groups: NodeID -> all NodeIDs in the same SCC group.
+     * Populated by refineSCCGroups and retained for later queries.
+     */
+    private sccGroups;
+    /**
+     * SCC post-processing threshold: the maximum allowed number of modules in a group; SCCs
+     * exceeding this size are split. Default 3; set to Number.MAX_SAFE_INTEGER to disable.
+     */
+    private maxSCCGroupSize;
+    constructor(moduleCanonicalizer: Canonicalizer<ArkModule>);
+    getGraphName(): string;
+    /**
+     * Add a module node to the graph.
+     * The node's NodeID directly uses the ModuleID assigned by the Canonicalizer.
+     */
+    addModule(module: ArkModule): void;
+    /**
+     * Add a dependency edge: src depends on dst (src -> dst).
+     * succMap stores successors (dependency targets), predMap stores predecessors (dependents).
+     * @param type Dependency type, used for edge removal priority during SCC post-processing.
+     *              When the same edge is added twice, the type with the lower removal priority is kept (i.e. the more core dependency).
+     */
+    addDependencyEdge(srcId: NodeID, dstId: NodeID, type?: DependencyType): void;
+    /**
+     * Remove a dependency edge.
+     */
+    removeDependencyEdge(srcId: NodeID, dstId: NodeID): void;
+    /**
+     * Remove a node ID from an adjacency list entry.
+     */
+    private removeFromAdjacencyList;
+    /**
+     * Get the dependency type of a specific edge.
+     * @returns The dependency type, or undefined if the edge does not exist.
+     */
+    getEdgeType(srcId: NodeID, dstId: NodeID): DependencyType | undefined;
+    /**
+     * Get all successor (dependency target) module IDs of the specified module.
+     */
+    getSuccModuleIds(moduleId: ModuleID): ModuleID[];
+    /**
+     * Get all predecessor (dependent) module IDs of the specified module.
+     */
+    getPredModuleIds(moduleId: ModuleID): ModuleID[];
+    /**
+     * Check whether a dependency edge exists between two modules.
+     */
+    hasDependencyEdge(srcId: NodeID, dstId: NodeID): boolean;
+    /**
+     * Get the total number of edges in the graph.
+     */
+    getEdgeCount(): number;
+    /**
+     * Get the topological order produced by the last refineSCCGroups call.
+     * Depended-on modules appear before their dependents.
+     */
+    getTopoOrder(): NodeID[];
+    /**
+     * Get the SCC groups map (NodeID -> all NodeIDs in the same SCC group) produced by the last
+     * refineSCCGroups call.
+     */
+    getSCCGroups(): Map<NodeID, NodeID[]>;
+    /**
+     * Set the SCC post-processing threshold. SCCs larger than this size are split.
+     * Set to Number.MAX_SAFE_INTEGER to disable post-processing.
+     */
+    setMaxSCCGroupSize(maxGroupSize: number): void;
+    /** Current SCC post-processing threshold. */
+    getMaxSCCGroupSize(): number;
+    /**
+     * Detect strong bridges in the SCC subgraph.
+     * A strong bridge is a directed edge whose removal increases the number of SCCs.
+     * For each edge u->v, check if removing it causes u and v to no longer be
+     * mutually reachable. If either u cannot reach v or v cannot reach u without
+     * the edge, then u->v is a strong bridge.
+     * @param members Node IDs in the large SCC
+     * @returns Array of strong bridge edges with their dependency types
+     */
+    findStrongBridges(members: NodeID[]): Array<{
+        src: NodeID;
+        dst: NodeID;
+        type: DependencyType;
+    }>;
+    /**
+     * Check if 'from' can reach 'to' in the subgraph, excluding edge excludedSrc->excludedDst.
+     * Uses DFS over successor edges within the member set.
+     */
+    private canReachWithoutEdge;
+    /**
+     * Build a temporary subgraph excluding specified edges, for SCC post-processing.
+     * Does not modify the original graph. Edge type labels are preserved from the original graph.
+     * @param sccMembers Node IDs in the SCC subgraph
+     * @param excludedEdges Set of edge keys ("srcId->dstId") to exclude
+     * @returns A new ModuleDepGraph containing only the SCC subgraph without excluded edges
+     */
+    buildTempGraphWithoutEdges(sccMembers: NodeID[], excludedEdges: Set<string>): ModuleDepGraph;
+    /**
+     * Recompute SCC on a temporary subgraph excluding specified edges, returning group results.
+     * @param members Node IDs in the SCC
+     * @param excludedEdges Set of edge keys to exclude from the temporary subgraph
+     * @returns Array of SCC groups, each group is an array of NodeIDs
+     */
+    recomputeSCC(members: NodeID[], excludedEdges: Set<string>): NodeID[][];
+    /**
+     * Split a single large SCC using strong bridge detection first,
+     * then fall back to dependency type priority for remaining edges.
+     * Does not modify the original graph.
+     * @param members Node IDs in the large SCC
+     * @param maxGroupSize Maximum allowed group size after splitting
+     * @returns Array of split groups, each group is an array of NodeIDs
+     */
+    splitLargeSCC(members: NodeID[], maxGroupSize: number): NodeID[][];
+    /**
+     * Refine SCC groups: split groups exceeding maxGroupSize using strong bridge
+     * detection and dependency type priority fallback.
+     * Stores the resulting groups in {@link sccGroups} and returns the same map.
+     * Also populates the topoOrder field with nodes in dependency order (depended-on first).
+     * @param maxGroupSize Maximum allowed group size; Number.MAX_SAFE_INTEGER disables post-processing
+     * @returns Map from each member NodeID to its group members array
+     */
+    refineSCCGroups(maxGroupSize: number): Map<NodeID, NodeID[]>;
+    /**
+     * Add members to topoOrder and sccGroups, skipping already-added members.
+     */
+    private addToTopoAndGroups;
+}
+//# sourceMappingURL=ModuleDepGraph.d.ts.map

package/lib/core/graph/ModuleDepGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleDepGraph.d.ts","sourceRoot":"","sources":["../../../src/core/graph/ModuleDepGraph.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG1D;;;;;;;;GAQG;AACH,oBAAY,cAAc;IACtB,YAAY,IAAI;IAChB,OAAO,IAAI;IACX,gBAAgB,IAAI;CACvB;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,cAAe,SAAQ,iBAAiB,CAAC,SAAS,CAAC;IAC5D;;;OAGG;IACH,OAAO,CAAC,mBAAmB,CAA2B;IAEtD;;;OAGG;IACH,OAAO,CAAC,WAAW,CAA0C;IAE7D;;;OAGG;IACH,OAAO,CAAC,SAAS,CAAgB;IAEjC;;;OAGG;IACH,OAAO,CAAC,SAAS,CAAoC;IAErD;;;OAGG;IACH,OAAO,CAAC,eAAe,CAAa;gBAExB,mBAAmB,EAAE,aAAa,CAAC,SAAS,CAAC;IAUlD,YAAY,IAAI,MAAM;IAI7B;;;OAGG;IACI,SAAS,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;IAczC;;;;;OAKG;IACI,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,cAA4C,GAAG,IAAI;IA6BhH;;OAEG;IACI,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAM/D;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAW/B;;;OAGG;IACI,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAI5E;;OAEG;IACI,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,EAAE;IAIvD;;OAEG;IACI,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,EAAE;IAIvD;;OAEG;IACI,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IAK/D;;OAEG;IACI,YAAY,IAAI,MAAM;IAQ7B;;;OAGG;IACI,YAAY,IAAI,MAAM,EAAE;IAI/B;;;OAGG;IACI,YAAY,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAI5C;;;OAGG;IACI,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAIrD,6CAA6C;IACtC,kBAAkB,IAAI,MAAM;IAInC;;;;;;;;OAQG;IACI,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,cAAc,CAAA;KAAE,CAAC;IA6BtG;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAgC3B;;;;;;OAMG;IACI,0BAA0B,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,cAAc;IAwBnG;;;;;OAKG;IACI,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,EAAE;IAc9E;;;;;;;OAOG;IACI,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE;IAoDzE;;;;;;;OAOG;IACI,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IA2BnE;;OAEG;IACH,OAAO,CAAC,kBAAkB;CAS7B"}