@antv/layout 2.0.0-alpha.1 → 2.0.0-alpha.2

package/lib/worker.js

@@ -663,226 +663,7 @@ var pick = (function (object, keys) {
     return result;
 });
 
-class Supervisor {
-    constructor() {
-        this.worker = null;
-        this.workerApi = null;
-    }
-    /**
-     * Execute layout in worker
-     */
-    execute(layoutId, data, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.worker) {
-                yield this.initWorker();
-            }
-            if (!this.workerApi) {
-                throw new Error('Worker API not initialized');
-            }
-            const result = yield this.workerApi.execute(layoutId, data, options);
-            return result;
-        });
-    }
-    /**
-     * Destroy worker
-     */
-    destroy() {
-        if (this.workerApi) {
-            this.workerApi.destroy();
-        }
-        if (this.worker) {
-            this.worker.terminate();
-            this.worker = null;
-            this.workerApi = null;
-        }
-    }
-    /**
-     * Initialize worker
-     */
-    initWorker() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const workerPath = this.resolveWorkerPath();
-            const isESM = workerPath.includes('/lib/') || workerPath.endsWith('.mjs');
-            const type = isESM ? 'module' : 'classic';
-            this.worker = new Worker(workerPath, { type });
-            this.workerApi = wrap(this.worker);
-        });
-    }
-    /**
-     * Resolve worker script path which works in both ESM and UMD environments
-     */
-    resolveWorkerPath() {
-        if (typeof import.meta !== 'undefined' && import.meta.url) {
-            const currentUrl = new URL(import.meta.url);
-            return currentUrl.href.replace(/\/[^/]+\.js$/, '/worker.js');
-        }
-        if (typeof document !== 'undefined') {
-            const scripts = document.getElementsByTagName('script');
-            for (let i = scripts.length - 1; i >= 0; i--) {
-                const src = scripts[i].src;
-                if (src && (src.includes('index.js') || src.includes('index.min.js'))) {
-                    return src.replace(/index(\.min)?\.js/, 'worker.js');
-                }
-            }
-        }
-        return './worker.js';
-    }
-}
-
-/**
- * Return the layout result for a graph with zero or one node.
- * @param graph original graph
- * @param center the layout center
- * @returns layout result
- */
-function applySingleNodeLayout(model, center, dimensions = 2) {
-    const n = model.nodeCount();
-    if (n === 1) {
-        const first = model.firstNode();
-        first.x = center[0];
-        first.y = center[1];
-        if (dimensions === 3) {
-            first.z = center[2] || 0;
-        }
-    }
-}
-
-/**
- * Get the adjacency list of the graph model.
- */
-const getAdjList = (model, directed) => {
-    const n = model.nodeCount();
-    const adjList = Array.from({ length: n }, () => []);
-    // map node with index
-    const nodeMap = {};
-    let idx = 0;
-    model.forEachNode((node) => {
-        nodeMap[node.id] = idx++;
-    });
-    model.forEachEdge((e) => {
-        const s = nodeMap[e.source];
-        const t = nodeMap[e.target];
-        if (s == null || t == null)
-            return;
-        adjList[s].push(t);
-        adjList[t].push(s);
-    });
-    return adjList;
-};
-/**
- * scale matrix
- * @param matrix [ [], [], [] ]
- * @param ratio
- */
-const scaleMatrix = (matrix, ratio) => {
-    const n = matrix.length;
-    const result = new Array(n);
-    for (let i = 0; i < n; i++) {
-        const row = matrix[i];
-        const m = row.length;
-        const newRow = new Array(m);
-        for (let j = 0; j < m; j++) {
-            newRow[j] = row[j] * ratio;
-        }
-        result[i] = newRow;
-    }
-    return result;
-};
-/**
- * Use Johnson + Dijkstra to compute APSP for sparse graph.
- * Fully compatible with floydWarshall(adjMatrix).
- */
-function johnson(adjList) {
-    const n = adjList.length;
-    // Step 1: add a dummy node q connected to all nodes with weight 0
-    new Array(n).fill(0);
-    // Bellman-Ford to compute potentials h(v)
-    // 因为权重全是 1，无负边，可直接跳过 BF，h 全 0 即可
-    // Step 2: reweight edges
-    // 因为 h(u)=h(v)=0，reweight 后仍然是 1，省略 reweight 过程
-    // Step 3: run Dijkstra from each node
-    const distAll = Array.from({ length: n }, () => new Array(n).fill(Infinity));
-    for (let s = 0; s < n; s++) {
-        distAll[s] = dijkstra(adjList, s);
-    }
-    return distAll;
-}
-/**
- * Dijkstra algorithm to find shortest paths from source to all nodes.
- */
-function dijkstra(adjList, source) {
-    const n = adjList.length;
-    const dist = new Array(n).fill(Infinity);
-    dist[source] = 0;
-    // Minimal binary heap
-    const heap = new MinHeap();
-    heap.push([0, source]); // [distance, node]
-    while (!heap.empty()) {
-        const [d, u] = heap.pop();
-        if (d !== dist[u])
-            continue;
-        const neighbors = adjList[u];
-        for (let i = 0; i < neighbors.length; i++) {
-            const v = neighbors[i];
-            const nd = d + 1;
-            if (nd < dist[v]) {
-                dist[v] = nd;
-                heap.push([nd, v]);
-            }
-        }
-    }
-    return dist;
-}
-class MinHeap {
-    constructor() {
-        this.data = [];
-    }
-    push(item) {
-        this.data.push(item);
-        this.bubbleUp(this.data.length - 1);
-    }
-    pop() {
-        const top = this.data[0];
-        const end = this.data.pop();
-        if (this.data.length > 0) {
-            this.data[0] = end;
-            this.bubbleDown(0);
-        }
-        return top;
-    }
-    empty() {
-        return this.data.length === 0;
-    }
-    bubbleUp(pos) {
-        const data = this.data;
-        while (pos > 0) {
-            const parent = (pos - 1) >> 1;
-            if (data[parent][0] <= data[pos][0])
-                break;
-            [data[parent], data[pos]] = [data[pos], data[parent]];
-            pos = parent;
-        }
-    }
-    bubbleDown(pos) {
-        const data = this.data;
-        const length = data.length;
-        while (true) {
-            const left = pos * 2 + 1;
-            const right = pos * 2 + 2;
-            let min = pos;
-            if (left < length && data[left][0] < data[min][0])
-                min = left;
-            if (right < length && data[right][0] < data[min][0])
-                min = right;
-            if (min === pos)
-                break;
-            [data[pos], data[min]] = [data[min], data[pos]];
-            pos = min;
-        }
-    }
-}
-
-class LayoutModel {
+class GraphLib {
     constructor(data, options = {}) {
         this.edgeIdCounter = new Map();
         this.nodeMap = extractNodeData(data.nodes, options.node);
@@ -891,7 +672,7 @@ class LayoutModel {
     data() {
         return { nodes: this.nodeMap, edges: this.edgeMap };
     }
-    apply(result) {
+    replace(result) {
         this.nodeMap = result.nodes;
         this.edgeMap = result.edges;
         this.clearCache();
@@ -1000,6 +781,14 @@ class LayoutModel {
     predecessors(nodeId) {
         return this.neighbors(nodeId, 'in');
     }
+    setNodeOrder(nodes) {
+        const next = new Map();
+        for (const node of nodes)
+            next.set(node.id, node);
+        this.nodeMap = next;
+        this.nodeIndexCache = undefined;
+        this.indexNodeCache = undefined;
+    }
     clearCache() {
         this.degreeCache = undefined;
         this.inAdjacencyCache = undefined;
@@ -1137,7 +926,7 @@ function extractEdgeData(edges, edge, getEdgeId) {
     }
     return result;
 }
-function initModelNodePosition(model, width, height, dimensions = 2) {
+function initNodePosition(model, width, height, dimensions = 2) {
     model.forEachNode((node) => {
         if (isNil(node.x)) {
             node.x = Math.random() * width;
@@ -1151,6 +940,254 @@ function initModelNodePosition(model, width, height, dimensions = 2) {
     });
 }
 
+class RuntimeContext {
+    constructor(data, options = {}) {
+        this.graph = new GraphLib(data, options);
+    }
+    export() {
+        return this.graph.data();
+    }
+    replace(result) {
+        this.graph.replace(result);
+    }
+    forEachNode(callback) {
+        this.graph.forEachNode(callback);
+    }
+    forEachEdge(callback) {
+        this.graph.forEachEdge((edge, i) => {
+            edge.sourceNode = this.graph.node(edge.source);
+            edge.targetNode = this.graph.node(edge.target);
+            callback(edge, i);
+        });
+    }
+    destroy() {
+        this.graph.destroy();
+    }
+}
+
+class Supervisor {
+    constructor() {
+        this.worker = null;
+        this.workerApi = null;
+    }
+    /**
+     * Execute layout in worker
+     */
+    execute(layoutId, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.worker) {
+                yield this.initWorker();
+            }
+            if (!this.workerApi) {
+                throw new Error('Worker API not initialized');
+            }
+            return yield this.workerApi.execute(layoutId, data, options);
+        });
+    }
+    /**
+     * Destroy worker
+     */
+    destroy() {
+        if (this.workerApi) {
+            this.workerApi.destroy();
+        }
+        if (this.worker) {
+            this.worker.terminate();
+            this.worker = null;
+            this.workerApi = null;
+        }
+    }
+    /**
+     * Initialize worker
+     */
+    initWorker() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const workerPath = this.resolveWorkerPath();
+            const isESM = workerPath.includes('/lib/') || workerPath.endsWith('.mjs');
+            const type = isESM ? 'module' : 'classic';
+            this.worker = new Worker(workerPath, { type });
+            this.workerApi = wrap(this.worker);
+        });
+    }
+    /**
+     * Resolve worker script path which works in both ESM and UMD environments
+     */
+    resolveWorkerPath() {
+        if (typeof import.meta !== 'undefined' && import.meta.url) {
+            const currentUrl = new URL(import.meta.url);
+            // e.g. `.../lib/runtime/supervisor.js` -> `.../lib/worker.js`
+            const asRoot = currentUrl.href.replace(/\/runtime\/[^/]+\.js$/, '/worker.js');
+            if (asRoot !== currentUrl.href)
+                return asRoot;
+            // Fallback: keep legacy behavior (same directory)
+            return currentUrl.href.replace(/\/[^/]+\.js$/, '/worker.js');
+        }
+        if (typeof document !== 'undefined') {
+            const scripts = document.getElementsByTagName('script');
+            for (let i = scripts.length - 1; i >= 0; i--) {
+                const src = scripts[i].src;
+                if (src && (src.includes('index.js') || src.includes('index.min.js'))) {
+                    return src.replace(/index(\.min)?\.js/, 'worker.js');
+                }
+            }
+        }
+        return './worker.js';
+    }
+}
+
+/**
+ * Return the layout result for a graph with zero or one node.
+ * @param graph original graph
+ * @param center the layout center
+ * @returns layout result
+ */
+function applySingleNodeLayout(model, center, dimensions = 2) {
+    const n = model.nodeCount();
+    if (n === 1) {
+        const first = model.firstNode();
+        first.x = center[0];
+        first.y = center[1];
+        if (dimensions === 3) {
+            first.z = center[2] || 0;
+        }
+    }
+}
+
+/**
+ * Get the adjacency list of the graph model.
+ */
+const getAdjList = (model, directed) => {
+    const n = model.nodeCount();
+    const adjList = Array.from({ length: n }, () => []);
+    // map node with index
+    const nodeMap = {};
+    let idx = 0;
+    model.forEachNode((node) => {
+        nodeMap[node.id] = idx++;
+    });
+    model.forEachEdge((e) => {
+        const s = nodeMap[e.source];
+        const t = nodeMap[e.target];
+        if (s == null || t == null)
+            return;
+        adjList[s].push(t);
+        adjList[t].push(s);
+    });
+    return adjList;
+};
+/**
+ * scale matrix
+ * @param matrix [ [], [], [] ]
+ * @param ratio
+ */
+const scaleMatrix = (matrix, ratio) => {
+    const n = matrix.length;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+        const row = matrix[i];
+        const m = row.length;
+        const newRow = new Array(m);
+        for (let j = 0; j < m; j++) {
+            newRow[j] = row[j] * ratio;
+        }
+        result[i] = newRow;
+    }
+    return result;
+};
+/**
+ * Use Johnson + Dijkstra to compute APSP for sparse graph.
+ * Fully compatible with floydWarshall(adjMatrix).
+ */
+function johnson(adjList) {
+    const n = adjList.length;
+    // Step 1: add a dummy node q connected to all nodes with weight 0
+    new Array(n).fill(0);
+    // Bellman-Ford to compute potentials h(v)
+    // 因为权重全是 1，无负边，可直接跳过 BF，h 全 0 即可
+    // Step 2: reweight edges
+    // 因为 h(u)=h(v)=0，reweight 后仍然是 1，省略 reweight 过程
+    // Step 3: run Dijkstra from each node
+    const distAll = Array.from({ length: n }, () => new Array(n).fill(Infinity));
+    for (let s = 0; s < n; s++) {
+        distAll[s] = dijkstra(adjList, s);
+    }
+    return distAll;
+}
+/**
+ * Dijkstra algorithm to find shortest paths from source to all nodes.
+ */
+function dijkstra(adjList, source) {
+    const n = adjList.length;
+    const dist = new Array(n).fill(Infinity);
+    dist[source] = 0;
+    // Minimal binary heap
+    const heap = new MinHeap();
+    heap.push([0, source]); // [distance, node]
+    while (!heap.empty()) {
+        const [d, u] = heap.pop();
+        if (d !== dist[u])
+            continue;
+        const neighbors = adjList[u];
+        for (let i = 0; i < neighbors.length; i++) {
+            const v = neighbors[i];
+            const nd = d + 1;
+            if (nd < dist[v]) {
+                dist[v] = nd;
+                heap.push([nd, v]);
+            }
+        }
+    }
+    return dist;
+}
+class MinHeap {
+    constructor() {
+        this.data = [];
+    }
+    push(item) {
+        this.data.push(item);
+        this.bubbleUp(this.data.length - 1);
+    }
+    pop() {
+        const top = this.data[0];
+        const end = this.data.pop();
+        if (this.data.length > 0) {
+            this.data[0] = end;
+            this.bubbleDown(0);
+        }
+        return top;
+    }
+    empty() {
+        return this.data.length === 0;
+    }
+    bubbleUp(pos) {
+        const data = this.data;
+        while (pos > 0) {
+            const parent = (pos - 1) >> 1;
+            if (data[parent][0] <= data[pos][0])
+                break;
+            [data[parent], data[pos]] = [data[pos], data[parent]];
+            pos = parent;
+        }
+    }
+    bubbleDown(pos) {
+        const data = this.data;
+        const length = data.length;
+        while (true) {
+            const left = pos * 2 + 1;
+            const right = pos * 2 + 2;
+            let min = pos;
+            if (left < length && data[left][0] < data[min][0])
+                min = left;
+            if (right < length && data[right][0] < data[min][0])
+                min = right;
+            if (min === pos)
+                break;
+            [data[pos], data[min]] = [data[min], data[pos]];
+            pos = min;
+        }
+    }
+}
+
 /**
  * Get nested property value
  * For example: getNestedValue(obj, 'a.b.c') will return obj.a.b.c
@@ -1192,10 +1229,7 @@ function mergeOptions(base, patch) {
 function sort$1(model, compareFn) {
     const nodes = model.nodes();
     nodes.sort(compareFn);
-    model.nodeMap.clear();
-    nodes.forEach((node) => {
-        model.nodeMap.set(node.id, node);
-    });
+    model.setNodeOrder(nodes);
     return model;
 }
 function orderByDegree(model) {
@@ -1289,10 +1323,7 @@ function orderByTopology(model, directed = false) {
         i++;
     });
     // Update model with ordered nodes
-    model.nodeMap.clear();
-    orderedNodes.forEach((node) => {
-        model.nodeMap.set(node.id, node);
-    });
+    model.setNodeOrder(orderedNodes);
     return model;
 }
 
@@ -1344,7 +1375,8 @@ class BaseLayout {
         return __awaiter(this, void 0, void 0, function* () {
             this.runtimeOptions = mergeOptions(this.initialOptions, userOptions);
             const { node, edge, enableWorker } = this.runtimeOptions;
-            this.model = new LayoutModel(data, { node, edge });
+            this.context = new RuntimeContext(data, { node, edge });
+            this.model = this.context.graph;
             const shouldUseWorker = enableWorker && typeof Worker !== 'undefined';
             if (shouldUseWorker) {
                 yield this.layoutInWorker(data, this.runtimeOptions);
@@ -1362,7 +1394,7 @@ class BaseLayout {
                     this.supervisor = new Supervisor();
                 }
                 const result = yield this.supervisor.execute(this.id, data, options);
-                (_a = this.model) === null || _a === void 0 ? void 0 : _a.apply(result);
+                (_a = this.context) === null || _a === void 0 ? void 0 : _a.replace(result);
             }
             catch (error) {
                 console.error('Layout in worker failed, fallback to main thread layout.', error);
@@ -1372,20 +1404,18 @@ class BaseLayout {
         });
     }
     forEachNode(callback) {
-        this.model.forEachNode(callback);
+        this.context.forEachNode(callback);
     }
     forEachEdge(callback) {
-        this.model.forEachEdge((edge, i) => {
-            edge.sourceNode = this.model.nodeMap.get(edge.source);
-            edge.targetNode = this.model.nodeMap.get(edge.target);
-            callback(edge, i);
-        });
+        this.context.forEachEdge(callback);
     }
     destroy() {
         var _a;
-        (_a = this.model) === null || _a === void 0 ? void 0 : _a.destroy();
+        (_a = this.context) === null || _a === void 0 ? void 0 : _a.destroy();
         // @ts-ignore
         this.model = null;
+        // @ts-ignore
+        this.context = null;
         if (this.supervisor) {
             this.supervisor.destroy();
             this.supervisor = null;
@@ -24016,7 +24046,7 @@ class ForceLayout extends BaseLayoutWithIterations {
             const options = this.parseOptions(this.options);
             const { width, height, dimensions } = options;
             this.initializePhysicsData(this.model, options);
-            initModelNodePosition(this.model, width, height, dimensions);
+            initNodePosition(this.model, width, height, dimensions);
             if (!((_a = this.model.nodes()) === null || _a === void 0 ? void 0 : _a.length))
                 return;
             const simulation = this.setSimulation(options);
@@ -25108,7 +25138,7 @@ class ForceAtlas2Layout extends BaseLayoutWithIterations {
             if (!n || n === 1) {
                 return applySingleNodeLayout(this.model, center);
             }
-            initModelNodePosition(this.model, width, height);
+            initNodePosition(this.model, width, height);
             const sizes = this.getSizes(merged.nodeSize, merged.nodeSpacing);
             const simulation = this.setSimulation();
             simulation.data(this.model, sizes);
@@ -25612,7 +25642,7 @@ class FruchtermanLayout extends BaseLayoutWithIterations {
                 applySingleNodeLayout(this.model, center, dimensions);
                 return;
             }
-            initModelNodePosition(this.model, width, height, dimensions);
+            initNodePosition(this.model, width, height, dimensions);
             const simulation = this.setSimulation();
             simulation.data(this.model);
             simulation.initialize(options);
@@ -32216,8 +32246,6 @@ class RandomLayout extends BaseLayout {
     layout() {
         return __awaiter(this, void 0, void 0, function* () {
             const { width, height, center } = normalizeViewport(this.options);
-            const layoutScale = 0.9;
-            const randomCoord = (size) => (Math.random() - 0.5) * layoutScale * size;
             this.model.forEachNode((node) => {
                 node.x = randomCoord(width) + center[0];
                 node.y = randomCoord(height) + center[1];
@@ -32225,6 +32253,13 @@ class RandomLayout extends BaseLayout {
         });
     }
 }
+const layoutScale = 0.9;
+/**
+ * <zh/> 生成随机坐标
+ *
+ * <en/> Generate random coordinates
+ */
+const randomCoord = (size) => (Math.random() - 0.5) * layoutScale * size;
 
 const registry = {
     'antv-dagre': AntVDagreLayout,