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

package/lib/worker.js

@@ -663,701 +663,763 @@ var pick = (function (object, keys) {
     return result;
 });
 
-class GraphLib {
-    constructor(data, options = {}) {
-        this.edgeIdCounter = new Map();
-        this.nodeMap = extractNodeData(data.nodes, options.node);
-        this.edgeMap = extractEdgeData(data.edges || [], options.edge, this.getEdgeId.bind(this));
-    }
-    data() {
-        return { nodes: this.nodeMap, edges: this.edgeMap };
-    }
-    replace(result) {
-        this.nodeMap = result.nodes;
-        this.edgeMap = result.edges;
-        this.clearCache();
-    }
-    nodes() {
-        return Array.from(this.nodeMap.values());
-    }
-    node(id) {
-        return this.nodeMap.get(id);
-    }
-    nodeAt(index) {
-        if (!this.indexNodeCache) {
-            this.buildNodeIndexCache();
+/**
+ * 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;
         }
-        const nodeId = this.indexNodeCache.get(index);
-        return nodeId ? this.nodeMap.get(nodeId) : undefined;
     }
-    nodeIndexOf(id) {
-        var _a;
-        if (!this.nodeIndexCache) {
-            this.buildNodeIndexCache();
+}
+
+/**
+ * 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;
         }
-        return (_a = this.nodeIndexCache.get(id)) !== null && _a !== void 0 ? _a : -1;
-    }
-    firstNode() {
-        return this.nodeMap.values().next().value;
-    }
-    forEachNode(callback) {
-        let i = 0;
-        this.nodeMap.forEach((node) => callback(node, i++));
-    }
-    originalNode(id) {
-        const node = this.nodeMap.get(id);
-        return node === null || node === void 0 ? void 0 : node._original;
-    }
-    nodeCount() {
-        return this.nodeMap.size;
-    }
-    edges() {
-        return Array.from(this.edgeMap.values());
+        result[i] = newRow;
     }
-    edge(id) {
-        return this.edgeMap.get(id);
+    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);
     }
-    firstEdge() {
-        return this.edgeMap.values().next().value;
+    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]);
+            }
+        }
     }
-    forEachEdge(callback) {
-        let i = 0;
-        this.edgeMap.forEach((edge) => callback(edge, i++));
+    return dist;
+}
+class MinHeap {
+    constructor() {
+        this.data = [];
     }
-    originalEdge(id) {
-        const edge = this.edgeMap.get(id);
-        return edge === null || edge === void 0 ? void 0 : edge._original;
+    push(item) {
+        this.data.push(item);
+        this.bubbleUp(this.data.length - 1);
     }
-    edgeCount() {
-        return this.edgeMap.size;
+    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;
     }
-    getEdgeId(edge) {
-        if (edge.id)
-            return edge.id;
-        const baseId = `${edge.source}-${edge.target}`;
-        const count = this.edgeIdCounter.get(baseId) || 0;
-        const id = count === 0 ? baseId : `${baseId}-${count}`;
-        this.edgeIdCounter.set(baseId, count + 1);
-        return id;
+    empty() {
+        return this.data.length === 0;
     }
-    degree(nodeId, direction = 'both') {
-        if (!this.degreeCache) {
-            this.buildDegreeCache();
+    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;
         }
-        const degree = this.degreeCache.get(nodeId);
-        if (!degree)
-            return 0;
-        return degree[direction];
     }
-    neighbors(nodeId, direction = 'both') {
-        if (!this.outAdjacencyCache || !this.inAdjacencyCache) {
-            this.buildAdjacencyCache();
-        }
-        if (direction === 'out') {
-            return Array.from(this.outAdjacencyCache.get(nodeId) || []);
-        }
-        if (direction === 'in') {
-            return Array.from(this.inAdjacencyCache.get(nodeId) || []);
-        }
-        if (this.bothAdjacencyCache) {
-            return Array.from(this.bothAdjacencyCache.get(nodeId) || []);
+    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;
         }
-        const inSet = this.inAdjacencyCache.get(nodeId);
-        const outSet = this.outAdjacencyCache.get(nodeId);
-        if (!inSet && !outSet)
-            return [];
-        if (!inSet)
-            return Array.from(outSet);
-        if (!outSet)
-            return Array.from(inSet);
-        const merged = new Set();
-        inSet.forEach((id) => merged.add(id));
-        outSet.forEach((id) => merged.add(id));
-        return Array.from(merged);
-    }
-    successors(nodeId) {
-        return this.neighbors(nodeId, 'out');
-    }
-    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;
-        this.outAdjacencyCache = undefined;
-        this.bothAdjacencyCache = undefined;
-        this.nodeIndexCache = undefined;
-        this.indexNodeCache = undefined;
-    }
-    buildDegreeCache() {
-        this.degreeCache = new Map();
-        for (const edge of this.edges()) {
-            const { source, target } = edge;
-            if (edge.source === edge.target)
-                continue;
-            if (!this.degreeCache.has(source)) {
-                this.degreeCache.set(source, { in: 0, out: 0, both: 0 });
-            }
-            const sourceDeg = this.degreeCache.get(edge.source);
-            if (sourceDeg) {
-                sourceDeg.out++;
-                sourceDeg.both++;
-            }
-            if (!this.degreeCache.has(target)) {
-                this.degreeCache.set(target, { in: 0, out: 0, both: 0 });
-            }
-            const targetDeg = this.degreeCache.get(edge.target);
-            if (targetDeg) {
-                targetDeg.in++;
-                targetDeg.both++;
-            }
+}
+
+/**
+ * Get nested property value
+ * For example: getNestedValue(obj, 'a.b.c') will return obj.a.b.c
+ */
+function getNestedValue(obj, path) {
+    const keys = String(path).split('.');
+    return get$1(obj, keys);
+}
+/**
+ * Merge objects, but undefined values in source objects will not override existing values
+ * @param target - The target object
+ * @param sources - Source objects to merge
+ * @returns A new merged object
+ *
+ * @example
+ * assignDefined({ a: 1, b: 2 }, { b: undefined, c: 3 })
+ * // Returns: { a: 1, b: 2, c: 3 }
+ */
+function assignDefined(target, ...sources) {
+    sources.forEach((source) => {
+        if (source) {
+            Object.keys(source).forEach((key) => {
+                const value = source[key];
+                if (value !== undefined) {
+                    target[key] = value;
+                }
+            });
         }
-    }
-    buildAdjacencyCache() {
-        this.inAdjacencyCache = new Map();
-        this.outAdjacencyCache = new Map();
-        for (const edge of this.edges()) {
-            if (!this.nodeMap.has(edge.source) || !this.nodeMap.has(edge.target))
-                continue;
-            if (!this.outAdjacencyCache.has(edge.source)) {
-                this.outAdjacencyCache.set(edge.source, new Set());
+    });
+    return target;
+}
+
+/**
+ * 通用排序核心函数
+ */
+function sort$1(model, compareFn) {
+    const nodes = model.nodes();
+    nodes.sort(compareFn);
+    model.setNodeOrder(nodes);
+    return model;
+}
+function orderByDegree(model) {
+    return sort$1(model, (nodeA, nodeB) => {
+        const degreeA = model.degree(nodeA.id);
+        const degreeB = model.degree(nodeB.id);
+        return degreeB - degreeA; // descending order
+    });
+}
+/**
+ * 按 ID 排序
+ */
+function orderById(model) {
+    return sort$1(model, (nodeA, nodeB) => {
+        const idA = nodeA.id;
+        const idB = nodeB.id;
+        if (typeof idA === 'number' && typeof idB === 'number') {
+            return idA - idB;
+        }
+        return String(idA).localeCompare(String(idB));
+    });
+}
+/**
+ * 按自定义比较函数排序
+ */
+function orderBySorter(model, sorter) {
+    return sort$1(model, (nodeA, nodeB) => {
+        const a = model.originalNode(nodeA.id);
+        const b = model.originalNode(nodeB.id);
+        return sorter(a, b);
+    });
+}
+/**
+ * Order nodes according to graph topology
+ */
+function orderByTopology(model, directed = false) {
+    const n = model.nodeCount();
+    if (n === 0)
+        return model;
+    const nodes = model.nodes();
+    const orderedNodes = [nodes[0]];
+    const pickFlags = {};
+    pickFlags[nodes[0].id] = true;
+    let k = 0;
+    let i = 0;
+    model.forEachNode((node) => {
+        if (i !== 0) {
+            const currentDegree = model.degree(node.id, 'both');
+            const nextDegree = i < n - 1 ? model.degree(nodes[i + 1].id, 'both') : 0;
+            const currentNodeId = orderedNodes[k].id;
+            const isNeighbor = model
+                .neighbors(currentNodeId, 'both')
+                .includes(node.id);
+            if ((i === n - 1 || currentDegree !== nextDegree || isNeighbor) &&
+                !pickFlags[node.id]) {
+                orderedNodes.push(node);
+                pickFlags[node.id] = true;
+                k++;
             }
-            this.outAdjacencyCache.get(edge.source).add(edge.target);
-            if (!this.inAdjacencyCache.has(edge.target)) {
-                this.inAdjacencyCache.set(edge.target, new Set());
+            else {
+                const children = directed
+                    ? model.successors(currentNodeId)
+                    : model.neighbors(currentNodeId);
+                let foundChild = false;
+                for (let j = 0; j < children.length; j++) {
+                    const childId = children[j];
+                    const child = model.node(childId);
+                    if (child &&
+                        model.degree(childId) === model.degree(node.id) &&
+                        !pickFlags[childId]) {
+                        orderedNodes.push(child);
+                        pickFlags[childId] = true;
+                        foundChild = true;
+                        break;
+                    }
+                }
+                let ii = 0;
+                while (!foundChild) {
+                    if (!pickFlags[nodes[ii].id]) {
+                        orderedNodes.push(nodes[ii]);
+                        pickFlags[nodes[ii].id] = true;
+                        foundChild = true;
+                    }
+                    ii++;
+                    if (ii === n) {
+                        break;
+                    }
+                }
             }
-            this.inAdjacencyCache.get(edge.target).add(edge.source);
         }
+        i++;
+    });
+    // Update model with ordered nodes
+    model.setNodeOrder(orderedNodes);
+    return model;
+}
+
+function parsePoint(point) {
+    var _a;
+    return [point.x, point.y, (_a = point.z) !== null && _a !== void 0 ? _a : 0];
+}
+
+function parseSize(size) {
+    if (!size)
+        return [0, 0, 0];
+    if (isNumber(size))
+        return [size, size, size];
+    else if (Array.isArray(size) && size.length === 0)
+        return [0, 0, 0];
+    const [x, y = x, z = x] = size;
+    return [x, y, z];
+}
+
+/**
+ * Viewport configuration such as width, height and center point.
+ */
+const normalizeViewport = (options) => {
+    const { width, height, center } = options;
+    const normalizedWidth = width !== null && width !== void 0 ? width : (typeof window !== 'undefined' ? window.innerWidth : 0);
+    const normalizedHeight = height !== null && height !== void 0 ? height : (typeof window !== 'undefined' ? window.innerHeight : 0);
+    const centerPoint = center !== null && center !== void 0 ? center : [normalizedWidth / 2, normalizedHeight / 2];
+    return {
+        width: normalizedWidth,
+        height: normalizedHeight,
+        center: centerPoint,
+    };
+};
+
+/**
+ * Format value with multiple types into a function that returns a number
+ * @param value The value to be formatted
+ * @param defaultValue The default value when value is invalid
+ * @returns A function that returns a number
+ */
+function formatNumberFn(value, defaultValue) {
+    // If value is a function, return it directly
+    if (isFunction(value)) {
+        return value;
     }
-    buildNodeIndexCache() {
-        this.nodeIndexCache = new Map();
-        this.indexNodeCache = new Map();
-        let index = 0;
-        this.nodeMap.forEach((_node, nodeId) => {
-            this.nodeIndexCache.set(nodeId, index);
-            this.indexNodeCache.set(index, nodeId);
-            index++;
-        });
-    }
-    destroy() {
-        this.clearCache();
-        this.nodeMap.clear();
-        this.edgeMap.clear();
-        this.edgeIdCounter.clear();
+    // If value is a number, return a function that returns this number
+    if (isNumber(value)) {
+        return () => value;
     }
+    // For other cases (undefined or invalid values), return default value function
+    return () => defaultValue;
 }
-const nodeFields = [
-    'id',
-    'x',
-    'y',
-    'z',
-    'vx',
-    'vy',
-    'vz',
-    'fx',
-    'fy',
-    'fz',
-    'parentId',
-];
-const edgeFields = ['id', 'source', 'target', 'points'];
-function extractNodeData(nodes, node) {
-    if (!nodes) {
-        throw new Error('Data.nodes is required');
+/**
+ * Format size config with multiple types into a function that returns a size
+ * @param value The value to be formatted
+ * @param defaultValue The default value when value is invalid
+ * @param resultIsNumber Whether to return a number (max of width/height) or size array
+ * @returns A function that returns a size
+ */
+function formatSizeFn(value, defaultValue = 10) {
+    // If value is undefined, return default value function
+    if (!value) {
+        return () => defaultValue;
     }
-    const result = new Map();
-    for (const datum of nodes) {
-        const nodeData = { _original: datum };
-        for (const field of nodeFields) {
-            const value = datum[field];
-            if (isNil(value))
-                continue;
-            nodeData[field] = value;
-        }
-        if (node) {
-            const customFields = node(datum);
-            for (const key in customFields) {
-                const value = customFields[key];
-                if (isNil(value))
-                    continue;
-                nodeData[key] = value;
-            }
-        }
-        if (isNil(nodeData.id)) {
-            throw new Error(`Node is missing id field`);
-        }
-        result.set(nodeData.id, nodeData);
+    // If value is a function, return it directly
+    if (isFunction(value)) {
+        return value;
     }
-    return result;
-}
-function extractEdgeData(edges, edge, getEdgeId) {
-    const result = new Map();
-    for (const datum of edges) {
-        const edgeData = { _original: datum };
-        for (const field of edgeFields) {
-            const value = datum[field];
-            if (isNil(value))
-                continue;
-            edgeData[field] = value;
-        }
-        if (edge) {
-            const customFields = edge(datum);
-            for (const key in customFields) {
-                const value = customFields[key];
-                if (isNil(value))
-                    continue;
-                edgeData[key] = value;
-            }
-        }
-        if (isNil(edgeData.source) || isNil(edgeData.target)) {
-            throw new Error(`Edge is missing source or target field`);
-        }
-        if (isNil(edgeData.id)) {
-            edgeData.id = getEdgeId === null || getEdgeId === void 0 ? void 0 : getEdgeId(datum);
-        }
-        result.set(edgeData.id, edgeData);
+    // If value is a number, return a function that returns this number
+    if (isNumber(value)) {
+        return () => value;
     }
-    return result;
-}
-function initNodePosition(model, width, height, dimensions = 2) {
-    model.forEachNode((node) => {
-        if (isNil(node.x)) {
-            node.x = Math.random() * width;
-        }
-        if (isNil(node.y)) {
-            node.y = Math.random() * height;
-        }
-        if (dimensions === 3 && isNil(node.z)) {
-            node.z = Math.random() * Math.min(width, height);
-        }
-    });
+    // If value is an array, return max or the array itself
+    if (Array.isArray(value)) {
+        return () => value;
+    }
+    // If value is an object with width and height
+    if (isObject(value) && value.width && value.height) {
+        return () => [value.width, value.height];
+    }
+    return () => defaultValue;
 }
+/**
+ * Format nodeSize and nodeSpacing into a function that returns the total size
+ * @param nodeSize The size of the node
+ * @param nodeSpacing The spacing around the node
+ * @param defaultNodeSize The default node size when value is invalid
+ * @returns A function that returns the total size (node size + spacing)
+ */
+const formatNodeSizeFn = (nodeSize, nodeSpacing, defaultNodeSize = 10) => {
+    const nodeSpacingFunc = formatNumberFn(nodeSpacing, 0);
+    const nodeSizeFunc = formatSizeFn(nodeSize, defaultNodeSize);
+    return (node) => {
+        const size = nodeSizeFunc(node);
+        const spacing = nodeSpacingFunc(node);
+        return Math.max(...parseSize(size)) + spacing;
+    };
+};
 
-class RuntimeContext {
+class GraphLib {
     constructor(data, options = {}) {
-        this.graph = new GraphLib(data, options);
+        this.edgeIdCounter = new Map();
+        this.nodeMap = extractNodeData(data.nodes, options.node);
+        this.edgeMap = extractEdgeData(data.edges || [], options.edge, this.getEdgeId.bind(this));
+    }
+    data() {
+        return { nodes: this.nodeMap, edges: this.edgeMap };
+    }
+    replace(result) {
+        this.nodeMap = result.nodes;
+        this.edgeMap = result.edges;
+        this.clearCache();
+    }
+    nodes() {
+        return Array.from(this.nodeMap.values());
+    }
+    node(id) {
+        return this.nodeMap.get(id);
+    }
+    nodeAt(index) {
+        if (!this.indexNodeCache) {
+            this.buildNodeIndexCache();
+        }
+        const nodeId = this.indexNodeCache.get(index);
+        return nodeId ? this.nodeMap.get(nodeId) : undefined;
+    }
+    nodeIndexOf(id) {
+        var _a;
+        if (!this.nodeIndexCache) {
+            this.buildNodeIndexCache();
+        }
+        return (_a = this.nodeIndexCache.get(id)) !== null && _a !== void 0 ? _a : -1;
+    }
+    firstNode() {
+        return this.nodeMap.values().next().value;
+    }
+    forEachNode(callback) {
+        let i = 0;
+        this.nodeMap.forEach((node) => callback(node, i++));
+    }
+    originalNode(id) {
+        const node = this.nodeMap.get(id);
+        return node === null || node === void 0 ? void 0 : node._original;
+    }
+    nodeCount() {
+        return this.nodeMap.size;
     }
-    export() {
-        return this.graph.data();
+    edges() {
+        return Array.from(this.edgeMap.values());
     }
-    replace(result) {
-        this.graph.replace(result);
+    edge(id) {
+        return this.edgeMap.get(id);
     }
-    forEachNode(callback) {
-        this.graph.forEachNode(callback);
+    firstEdge() {
+        return this.edgeMap.values().next().value;
     }
     forEachEdge(callback) {
-        this.graph.forEachEdge((edge, i) => {
-            edge.sourceNode = this.graph.node(edge.source);
-            edge.targetNode = this.graph.node(edge.target);
-            callback(edge, i);
-        });
+        let i = 0;
+        this.edgeMap.forEach((edge) => callback(edge, i++));
     }
-    destroy() {
-        this.graph.destroy();
+    originalEdge(id) {
+        const edge = this.edgeMap.get(id);
+        return edge === null || edge === void 0 ? void 0 : edge._original;
     }
-}
-
-class Supervisor {
-    constructor() {
-        this.worker = null;
-        this.workerApi = null;
+    edgeCount() {
+        return this.edgeMap.size;
     }
-    /**
-     * 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);
-        });
+    getEdgeId(edge) {
+        if (edge.id)
+            return edge.id;
+        const baseId = `${edge.source}-${edge.target}`;
+        const count = this.edgeIdCounter.get(baseId) || 0;
+        const id = count === 0 ? baseId : `${baseId}-${count}`;
+        this.edgeIdCounter.set(baseId, count + 1);
+        return id;
     }
-    /**
-     * Destroy worker
-     */
-    destroy() {
-        if (this.workerApi) {
-            this.workerApi.destroy();
-        }
-        if (this.worker) {
-            this.worker.terminate();
-            this.worker = null;
-            this.workerApi = null;
+    degree(nodeId, direction = 'both') {
+        if (!this.degreeCache) {
+            this.buildDegreeCache();
         }
+        const degree = this.degreeCache.get(nodeId);
+        if (!degree)
+            return 0;
+        return degree[direction];
     }
-    /**
-     * 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');
+    neighbors(nodeId, direction = 'both') {
+        if (!this.outAdjacencyCache || !this.inAdjacencyCache) {
+            this.buildAdjacencyCache();
         }
-        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');
-                }
-            }
+        if (direction === 'out') {
+            return Array.from(this.outAdjacencyCache.get(nodeId) || []);
         }
-        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;
+        if (direction === 'in') {
+            return Array.from(this.inAdjacencyCache.get(nodeId) || []);
         }
-    }
-}
-
-/**
- * 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;
+        if (this.bothAdjacencyCache) {
+            return Array.from(this.bothAdjacencyCache.get(nodeId) || []);
         }
-        result[i] = newRow;
+        const inSet = this.inAdjacencyCache.get(nodeId);
+        const outSet = this.outAdjacencyCache.get(nodeId);
+        if (!inSet && !outSet)
+            return [];
+        if (!inSet)
+            return Array.from(outSet);
+        if (!outSet)
+            return Array.from(inSet);
+        const merged = new Set();
+        inSet.forEach((id) => merged.add(id));
+        outSet.forEach((id) => merged.add(id));
+        return Array.from(merged);
     }
-    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);
+    successors(nodeId) {
+        return this.neighbors(nodeId, 'out');
     }
-    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]);
+    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;
+        this.outAdjacencyCache = undefined;
+        this.bothAdjacencyCache = undefined;
+        this.nodeIndexCache = undefined;
+        this.indexNodeCache = undefined;
+    }
+    buildDegreeCache() {
+        this.degreeCache = new Map();
+        for (const edge of this.edges()) {
+            const { source, target } = edge;
+            if (edge.source === edge.target)
+                continue;
+            if (!this.degreeCache.has(source)) {
+                this.degreeCache.set(source, { in: 0, out: 0, both: 0 });
+            }
+            const sourceDeg = this.degreeCache.get(edge.source);
+            if (sourceDeg) {
+                sourceDeg.out++;
+                sourceDeg.both++;
+            }
+            if (!this.degreeCache.has(target)) {
+                this.degreeCache.set(target, { in: 0, out: 0, both: 0 });
+            }
+            const targetDeg = this.degreeCache.get(edge.target);
+            if (targetDeg) {
+                targetDeg.in++;
+                targetDeg.both++;
             }
         }
     }
-    return dist;
-}
-class MinHeap {
-    constructor() {
-        this.data = [];
+    buildAdjacencyCache() {
+        this.inAdjacencyCache = new Map();
+        this.outAdjacencyCache = new Map();
+        for (const edge of this.edges()) {
+            if (!this.nodeMap.has(edge.source) || !this.nodeMap.has(edge.target))
+                continue;
+            if (!this.outAdjacencyCache.has(edge.source)) {
+                this.outAdjacencyCache.set(edge.source, new Set());
+            }
+            this.outAdjacencyCache.get(edge.source).add(edge.target);
+            if (!this.inAdjacencyCache.has(edge.target)) {
+                this.inAdjacencyCache.set(edge.target, new Set());
+            }
+            this.inAdjacencyCache.get(edge.target).add(edge.source);
+        }
     }
-    push(item) {
-        this.data.push(item);
-        this.bubbleUp(this.data.length - 1);
+    buildNodeIndexCache() {
+        this.nodeIndexCache = new Map();
+        this.indexNodeCache = new Map();
+        let index = 0;
+        this.nodeMap.forEach((_node, nodeId) => {
+            this.nodeIndexCache.set(nodeId, index);
+            this.indexNodeCache.set(index, nodeId);
+            index++;
+        });
     }
-    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;
+    destroy() {
+        this.clearCache();
+        this.nodeMap.clear();
+        this.edgeMap.clear();
+        this.edgeIdCounter.clear();
     }
-    empty() {
-        return this.data.length === 0;
+}
+const nodeFields = [
+    'id',
+    'x',
+    'y',
+    'z',
+    'vx',
+    'vy',
+    'vz',
+    'fx',
+    'fy',
+    'fz',
+    'parentId',
+];
+const edgeFields = ['id', 'source', 'target', 'points'];
+function extractNodeData(nodes, node) {
+    if (!nodes) {
+        throw new Error('Data.nodes is required');
     }
-    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;
+    const result = new Map();
+    for (const datum of nodes) {
+        const nodeData = { _original: datum };
+        for (const field of nodeFields) {
+            const value = datum[field];
+            if (isNil(value))
+                continue;
+            nodeData[field] = value;
         }
-    }
-    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;
+        if (node) {
+            const customFields = node(datum);
+            for (const key in customFields) {
+                const value = customFields[key];
+                if (isNil(value))
+                    continue;
+                nodeData[key] = value;
+            }
         }
-    }
-}
-
-/**
- * Get nested property value
- * For example: getNestedValue(obj, 'a.b.c') will return obj.a.b.c
- */
-function getNestedValue(obj, path) {
-    const keys = String(path).split('.');
-    return get$1(obj, keys);
-}
-/**
- * Merge objects, but undefined values in source objects will not override existing values
- * @param target - The target object
- * @param sources - Source objects to merge
- * @returns A new merged object
- *
- * @example
- * assignDefined({ a: 1, b: 2 }, { b: undefined, c: 3 })
- * // Returns: { a: 1, b: 2, c: 3 }
- */
-function assignDefined(target, ...sources) {
-    sources.forEach((source) => {
-        if (source) {
-            Object.keys(source).forEach((key) => {
-                const value = source[key];
-                if (value !== undefined) {
-                    target[key] = value;
-                }
-            });
+        if (isNil(nodeData.id)) {
+            throw new Error(`Node is missing id field`);
         }
-    });
-    return target;
-}
-function mergeOptions(base, patch) {
-    return Object.assign({}, base, patch || {});
-}
-
-/**
- * 通用排序核心函数
- */
-function sort$1(model, compareFn) {
-    const nodes = model.nodes();
-    nodes.sort(compareFn);
-    model.setNodeOrder(nodes);
-    return model;
-}
-function orderByDegree(model) {
-    return sort$1(model, (nodeA, nodeB) => {
-        const degreeA = model.degree(nodeA.id);
-        const degreeB = model.degree(nodeB.id);
-        return degreeB - degreeA; // descending order
-    });
+        result.set(nodeData.id, nodeData);
+    }
+    return result;
 }
-/**
- * 按 ID 排序
- */
-function orderById(model) {
-    return sort$1(model, (nodeA, nodeB) => {
-        const idA = nodeA.id;
-        const idB = nodeB.id;
-        if (typeof idA === 'number' && typeof idB === 'number') {
-            return idA - idB;
+function extractEdgeData(edges, edge, getEdgeId) {
+    const result = new Map();
+    for (const datum of edges) {
+        const edgeData = { _original: datum };
+        for (const field of edgeFields) {
+            const value = datum[field];
+            if (isNil(value))
+                continue;
+            edgeData[field] = value;
         }
-        return String(idA).localeCompare(String(idB));
-    });
-}
-/**
- * 按自定义比较函数排序
- */
-function orderBySorter(model, sorter) {
-    return sort$1(model, (nodeA, nodeB) => {
-        const a = model.originalNode(nodeA.id);
-        const b = model.originalNode(nodeB.id);
-        return sorter(a, b);
-    });
-}
-/**
- * Order nodes according to graph topology
- */
-function orderByTopology(model, directed = false) {
-    const n = model.nodeCount();
-    if (n === 0)
-        return model;
-    const nodes = model.nodes();
-    const orderedNodes = [nodes[0]];
-    const pickFlags = {};
-    pickFlags[nodes[0].id] = true;
-    let k = 0;
-    let i = 0;
-    model.forEachNode((node) => {
-        if (i !== 0) {
-            const currentDegree = model.degree(node.id, 'both');
-            const nextDegree = i < n - 1 ? model.degree(nodes[i + 1].id, 'both') : 0;
-            const currentNodeId = orderedNodes[k].id;
-            const isNeighbor = model
-                .neighbors(currentNodeId, 'both')
-                .includes(node.id);
-            if ((i === n - 1 || currentDegree !== nextDegree || isNeighbor) &&
-                !pickFlags[node.id]) {
-                orderedNodes.push(node);
-                pickFlags[node.id] = true;
-                k++;
-            }
-            else {
-                const children = directed
-                    ? model.successors(currentNodeId)
-                    : model.neighbors(currentNodeId);
-                let foundChild = false;
-                for (let j = 0; j < children.length; j++) {
-                    const childId = children[j];
-                    const child = model.node(childId);
-                    if (child &&
-                        model.degree(childId) === model.degree(node.id) &&
-                        !pickFlags[childId]) {
-                        orderedNodes.push(child);
-                        pickFlags[childId] = true;
-                        foundChild = true;
-                        break;
-                    }
-                }
-                let ii = 0;
-                while (!foundChild) {
-                    if (!pickFlags[nodes[ii].id]) {
-                        orderedNodes.push(nodes[ii]);
-                        pickFlags[nodes[ii].id] = true;
-                        foundChild = true;
-                    }
-                    ii++;
-                    if (ii === n) {
-                        break;
-                    }
-                }
+        if (edge) {
+            const customFields = edge(datum);
+            for (const key in customFields) {
+                const value = customFields[key];
+                if (isNil(value))
+                    continue;
+                edgeData[key] = value;
             }
         }
-        i++;
+        if (isNil(edgeData.source) || isNil(edgeData.target)) {
+            throw new Error(`Edge is missing source or target field`);
+        }
+        if (isNil(edgeData.id)) {
+            edgeData.id = getEdgeId === null || getEdgeId === void 0 ? void 0 : getEdgeId(datum);
+        }
+        result.set(edgeData.id, edgeData);
+    }
+    return result;
+}
+function initNodePosition(model, width, height, dimensions = 2) {
+    model.forEachNode((node) => {
+        if (isNil(node.x)) {
+            node.x = Math.random() * width;
+        }
+        if (isNil(node.y)) {
+            node.y = Math.random() * height;
+        }
+        if (dimensions === 3 && isNil(node.z)) {
+            node.z = Math.random() * Math.min(width, height);
+        }
     });
-    // Update model with ordered nodes
-    model.setNodeOrder(orderedNodes);
-    return model;
 }
 
-function parsePoint(point) {
-    var _a;
-    return [point.x, point.y, (_a = point.z) !== null && _a !== void 0 ? _a : 0];
+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();
+    }
 }
 
-function parseSize(size) {
-    if (!size)
-        return [0, 0, 0];
-    if (isNumber(size))
-        return [size, size, size];
-    else if (Array.isArray(size) && size.length === 0)
-        return [0, 0, 0];
-    const [x, y = x, z = x] = size;
-    return [x, y, z];
+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';
+    }
 }
 
-/**
- * Viewport configuration such as width, height and center point.
- */
-const normalizeViewport = (options) => {
-    const { width, height, center } = options;
-    const normalizedWidth = width !== null && width !== void 0 ? width : (typeof window !== 'undefined' ? window.innerWidth : 0);
-    const normalizedHeight = height !== null && height !== void 0 ? height : (typeof window !== 'undefined' ? window.innerHeight : 0);
-    const centerPoint = center !== null && center !== void 0 ? center : [normalizedWidth / 2, normalizedHeight / 2];
-    return {
-        width: normalizedWidth,
-        height: normalizedHeight,
-        center: centerPoint,
-    };
-};
-
 /**
  * <zh/> 布局基类
  *
@@ -1366,14 +1428,17 @@ const normalizeViewport = (options) => {
 class BaseLayout {
     constructor(options) {
         this.supervisor = null;
-        this.initialOptions = mergeOptions(this.getDefaultOptions(), options);
+        this.initialOptions = this.mergeOptions(this.getDefaultOptions(), options);
     }
     get options() {
         return this.runtimeOptions || this.initialOptions;
     }
+    mergeOptions(base, patch) {
+        return Object.assign({}, base, patch || {});
+    }
     execute(data, userOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.runtimeOptions = mergeOptions(this.initialOptions, userOptions);
+            this.runtimeOptions = this.mergeOptions(this.initialOptions, userOptions);
             const { node, edge, enableWorker } = this.runtimeOptions;
             this.context = new RuntimeContext(data, { node, edge });
             this.model = this.context.graph;
@@ -1430,71 +1495,6 @@ class BaseLayout {
 class BaseLayoutWithIterations extends BaseLayout {
 }
 
-/**
- * Format value with multiple types into a function that returns a number
- * @param value The value to be formatted
- * @param defaultValue The default value when value is invalid
- * @returns A function that returns a number
- */
-function formatNumberFn(value, defaultValue) {
-    // If value is a function, return it directly
-    if (isFunction(value)) {
-        return value;
-    }
-    // If value is a number, return a function that returns this number
-    if (isNumber(value)) {
-        return () => value;
-    }
-    // For other cases (undefined or invalid values), return default value function
-    return () => defaultValue;
-}
-/**
- * Format size config with multiple types into a function that returns a size
- * @param value The value to be formatted
- * @param defaultValue The default value when value is invalid
- * @param resultIsNumber Whether to return a number (max of width/height) or size array
- * @returns A function that returns a size
- */
-function formatSizeFn(value, defaultValue = 10) {
-    // If value is undefined, return default value function
-    if (!value) {
-        return () => defaultValue;
-    }
-    // If value is a function, return it directly
-    if (isFunction(value)) {
-        return value;
-    }
-    // If value is a number, return a function that returns this number
-    if (isNumber(value)) {
-        return () => value;
-    }
-    // If value is an array, return max or the array itself
-    if (Array.isArray(value)) {
-        return () => value;
-    }
-    // If value is an object with width and height
-    if (isObject(value) && value.width && value.height) {
-        return () => [value.width, value.height];
-    }
-    return () => defaultValue;
-}
-/**
- * Format nodeSize and nodeSpacing into a function that returns the total size
- * @param nodeSize The size of the node
- * @param nodeSpacing The spacing around the node
- * @param defaultNodeSize The default node size when value is invalid
- * @returns A function that returns the total size (node size + spacing)
- */
-const formatNodeSizeFn = (nodeSize, nodeSpacing, defaultNodeSize = 10) => {
-    const nodeSpacingFunc = formatNumberFn(nodeSpacing, 0);
-    const nodeSizeFunc = formatSizeFn(nodeSize, defaultNodeSize);
-    return (node) => {
-        const size = nodeSizeFunc(node);
-        const spacing = nodeSpacingFunc(node);
-        return Math.max(...parseSize(size)) + spacing;
-    };
-};
-
 /**
  * <zh/> 内部图数据结构，用于 antv-dagre 布局算法
  *
@@ -4934,9 +4934,9 @@ class AntVDagreLayout extends BaseLayout {
         return __awaiter(this, void 0, void 0, function* () {
             const { nodeSize, align, rankdir = 'TB', ranksep, nodesep, edgeLabelSpace, ranker = 'tight-tree', nodeOrder, begin, controlPoints, radial, sortByCombo, 
             // focusNode,
-            preset, } = options;
-            const ranksepfunc = formatNumberFn(ranksep, DEFAULTS_LAYOUT_OPTIONS$8.ranksep);
-            const nodesepfunc = formatNumberFn(nodesep, DEFAULTS_LAYOUT_OPTIONS$8.nodesep);
+            preset, ranksepFunc, nodesepFunc, } = options;
+            const ranksepfunc = formatNumberFn(ranksepFunc, ranksep !== null && ranksep !== void 0 ? ranksep : 50);
+            const nodesepfunc = formatNumberFn(nodesepFunc, nodesep !== null && nodesep !== void 0 ? nodesep : 50);
             let horisep = nodesepfunc;
             let vertisep = ranksepfunc;
             if (rankdir === 'LR' || rankdir === 'RL') {
@@ -4951,9 +4951,10 @@ class AntVDagreLayout extends BaseLayout {
             const edges = this.model.edges();
             nodes.forEach((node) => {
                 var _a;
-                const size = parseSize(nodeSizeFunc(node));
-                const verti = vertisep(node);
-                const hori = horisep(node);
+                const raw = node._original;
+                const size = parseSize(nodeSizeFunc(raw));
+                const verti = vertisep(raw);
+                const hori = horisep(raw);
                 const width = size[0] + 2 * hori;
                 const height = size[1] + 2 * verti;
                 const layer = (_a = node.data) === null || _a === void 0 ? void 0 : _a.layer;
@@ -5019,6 +5020,7 @@ class AntVDagreLayout extends BaseLayout {
                 acyclicer: 'greedy',
                 ranker,
                 rankdir,
+                nodesep,
                 align,
             });
             const layoutTopLeft = [0, 0];
@@ -7123,25 +7125,17 @@ function forceInABox() {
 }
 
 const DEFAULTS_LAYOUT_OPTIONS$6 = {
-    centerStrength: 1,
-    edgeId: (d) => String(d.id),
-    linkDistance: 30,
-    edgeStrength: undefined,
-    edgeIterations: 1,
+    link: {
+        id: (d) => String(d.id),
+    },
+    manyBody: {
+        strength: -30,
+    },
     preventOverlap: false,
     nodeSize: 10,
     nodeSpacing: 0,
-    collideStrength: 1,
-    collideIterations: 1,
-    nodeStrength: -30,
-    distanceMin: undefined,
-    distanceMax: undefined,
-    theta: undefined,
-    alpha: 1,
-    alphaMin: 0.001,
-    alphaDecay: 1 - Math.pow(0.001, 1 / 300),
-    alphaTarget: 0,
-    velocityDecay: 0.4,
+    x: false,
+    y: false,
     clustering: false,
     clusterNodeStrength: -1,
     clusterEdgeStrength: 0.1,
@@ -7358,20 +7352,17 @@ class D3ForceLayout extends BaseLayoutWithIterations {
         this.setupClusterForce(simulation, options);
     }
     getCenterOptions(options) {
-        if (!options.width ||
-            !options.height ||
-            options.centerStrength !== undefined) {
-            const viewport = normalizeViewport({
-                width: options.width,
-                height: options.height,
-            });
-            return assignDefined({}, options.center || {}, {
-                x: viewport.width / 2,
-                y: viewport.height / 2,
-                strength: options.centerStrength,
-            });
-        }
-        return undefined;
+        if (options.center === false)
+            return undefined;
+        const viewport = normalizeViewport({
+            width: options.width,
+            height: options.height,
+        });
+        return assignDefined({}, options.center || {}, {
+            x: viewport.width / 2,
+            y: viewport.height / 2,
+            strength: options.centerStrength,
+        });
     }
     setupCenterForce(simulation, options) {
         const center = this.getCenterOptions(options);
@@ -7395,19 +7386,14 @@ class D3ForceLayout extends BaseLayoutWithIterations {
         }
     }
     getManyBodyOptions(options) {
-        if (options.manyBody !== undefined ||
-            options.nodeStrength !== undefined ||
-            options.distanceMin !== undefined ||
-            options.distanceMax !== undefined ||
-            options.theta !== undefined) {
-            return assignDefined({}, options.manyBody || {}, {
-                strength: options.nodeStrength,
-                distanceMin: options.distanceMin,
-                distanceMax: options.distanceMax,
-                theta: options.theta,
-            });
-        }
-        return undefined;
+        if (options.manyBody === false)
+            return undefined;
+        return assignDefined({}, options.manyBody || {}, {
+            strength: options.nodeStrength,
+            distanceMin: options.distanceMin,
+            distanceMax: options.distanceMax,
+            theta: options.theta,
+        });
     }
     setupManyBodyForce(simulation, options) {
         const manyBody = this.getManyBodyOptions(options);
@@ -7433,19 +7419,14 @@ class D3ForceLayout extends BaseLayoutWithIterations {
         }
     }
     getLinkOptions(options) {
-        if (options.link ||
-            options.edgeId !== undefined ||
-            options.linkDistance !== undefined ||
-            options.edgeStrength !== undefined ||
-            options.edgeIterations !== undefined) {
-            return assignDefined({}, options.link || {}, {
-                id: options.edgeId,
-                distance: options.linkDistance,
-                strength: options.edgeStrength,
-                iterations: options.edgeIterations,
-            });
-        }
-        return undefined;
+        if (options.link === false)
+            return undefined;
+        return assignDefined({}, options.link || {}, {
+            id: options.edgeId,
+            distance: options.linkDistance,
+            strength: options.edgeStrength,
+            iterations: options.edgeIterations,
+        });
     }
     setupLinkForce(simulation, options) {
         const edges = this.model.edges();
@@ -7472,23 +7453,16 @@ class D3ForceLayout extends BaseLayoutWithIterations {
         }
     }
     getCollisionOptions(options) {
-        if (!options.preventOverlap)
+        if (options.preventOverlap === false || options.collide === false)
             return undefined;
-        if (options.collide !== undefined ||
-            options.nodeSize !== undefined ||
-            options.nodeSpacing !== undefined ||
-            options.collideStrength !== undefined ||
-            options.collideIterations !== undefined) {
-            const radius = options.nodeSize || options.nodeSpacing
-                ? (d) => formatNodeSizeFn(options.nodeSize, options.nodeSpacing)(d._original) / 2
-                : undefined;
-            return assignDefined({}, options.collide || {}, {
-                radius,
-                strength: options.collideStrength,
-                iterations: options.collideIterations,
-            });
-        }
-        return undefined;
+        const radius = options.nodeSize || options.nodeSpacing
+            ? (d) => formatNodeSizeFn(options.nodeSize, options.nodeSpacing)(d._original) / 2
+            : undefined;
+        return assignDefined({}, options.collide || {}, {
+            radius: options.collide || radius,
+            strength: options.collideStrength,
+            iterations: options.collideIterations,
+        });
     }
     setupCollisionForce(simulation, options) {
         const collide = this.getCollisionOptions(options);
@@ -7513,18 +7487,13 @@ class D3ForceLayout extends BaseLayoutWithIterations {
     }
     getXForceOptions(options) {
         var _a;
-        if (options.x !== undefined ||
-            options.forceXPosition !== undefined ||
-            options.forceXStrength !== undefined ||
-            options.width !== undefined ||
-            options.height !== undefined) {
-            const center = this.getCenterOptions(options);
-            return assignDefined({}, options.x || {}, {
-                x: (_a = options.forceXPosition) !== null && _a !== void 0 ? _a : (center && center.x),
-                strength: options.forceXStrength,
-            });
-        }
-        return undefined;
+        if (options.x === false)
+            return undefined;
+        const center = this.getCenterOptions(options);
+        return assignDefined({}, options.x || {}, {
+            x: (_a = options.forceXPosition) !== null && _a !== void 0 ? _a : (center && center.x),
+            strength: options.forceXStrength,
+        });
     }
     setupXForce(simulation, options) {
         const x = this.getXForceOptions(options);
@@ -7547,18 +7516,13 @@ class D3ForceLayout extends BaseLayoutWithIterations {
     }
     getYForceOptions(options) {
         var _a;
-        if (options.y !== undefined ||
-            options.forceYPosition !== undefined ||
-            options.forceYStrength !== undefined ||
-            options.width !== undefined ||
-            options.height !== undefined) {
-            const center = this.getCenterOptions(options);
-            return assignDefined({}, options.y || {}, {
-                y: (_a = options.forceYPosition) !== null && _a !== void 0 ? _a : (center && center.y),
-                strength: options.forceYStrength,
-            });
-        }
-        return undefined;
+        if (options.y === false)
+            return undefined;
+        const center = this.getCenterOptions(options);
+        return assignDefined({}, options.y || {}, {
+            y: (_a = options.forceYPosition) !== null && _a !== void 0 ? _a : (center && center.y),
+            strength: options.forceYStrength,
+        });
     }
     setupYForce(simulation, options) {
         const y = this.getYForceOptions(options);