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

package/lib/worker.js

@@ -663,72 +663,6 @@ 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
@@ -882,7 +816,239 @@ class MinHeap {
     }
 }
 
-class LayoutModel {
+/**
+ * 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;
+                }
+            });
+        }
+    });
+    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++;
+            }
+            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;
+                    }
+                }
+            }
+        }
+        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;
+    }
+    // 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;
+    };
+};
+
+class GraphLib {
     constructor(data, options = {}) {
         this.edgeIdCounter = new Map();
         this.nodeMap = extractNodeData(data.nodes, options.node);
@@ -891,7 +1057,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 +1166,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;
@@ -1106,227 +1280,146 @@ function extractNodeData(nodes, node) {
         }
         result.set(nodeData.id, nodeData);
     }
-    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);
-    }
-    return result;
-}
-function initModelNodePosition(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);
-        }
-    });
-}
-
-/**
- * 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;
-                }
-            });
-        }
-    });
-    return target;
-}
-function mergeOptions(base, patch) {
-    return Object.assign({}, 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);
-    });
-    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++;
-            }
-            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;
-                    }
-                }
+    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;
             }
         }
-        i++;
-    });
-    // Update model with ordered nodes
-    model.nodeMap.clear();
-    orderedNodes.forEach((node) => {
-        model.nodeMap.set(node.id, node);
+        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);
+        }
     });
-    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/> 布局基类
  *
@@ -1335,16 +1428,20 @@ 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.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 +1459,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 +1469,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;
@@ -1400,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 布局算法
  *
@@ -4904,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') {
@@ -4921,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;
@@ -4989,6 +5020,7 @@ class AntVDagreLayout extends BaseLayout {
                 acyclicer: 'greedy',
                 ranker,
                 rankdir,
+                nodesep,
                 align,
             });
             const layoutTopLeft = [0, 0];
@@ -7093,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,
@@ -7328,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);
@@ -7365,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);
@@ -7403,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();
@@ -7442,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);
@@ -7483,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);
@@ -7517,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);
@@ -24016,7 +24010,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 +25102,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 +25606,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 +32210,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 +32217,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,