@antv/layout 2.0.0-beta.0 → 2.0.0-beta.1

package/src/algorithm/dagre/index.ts

@@ -1,9 +1,9 @@
 import { isBoolean, isNil, pick } from '@antv/util';
 import dagre, { graphlib } from 'dagre';
-import { BaseLayout } from '../base-layout';
 import type { LayoutNode } from '../../types';
 import { parsePoint, parseSize } from '../../util';
-import { formatNumberFn, formatSizeFn } from '../../util/format';
+import { formatFn, formatNumberFn, formatSizeFn } from '../../util/format';
+import { BaseLayout } from '../base-layout';
 import type { DagreLayoutOptions } from './types';
 
 export type { DagreLayoutOptions };
@@ -98,12 +98,14 @@ export class DagreLayout extends BaseLayout<DagreLayoutOptions> {
       edgeWeight,
     } = this.options;
 
-    const edgeLabelSizeFn = formatSizeFn(edgeLabelSize, 0);
-    const edgeLabelOffsetFn = formatNumberFn(edgeLabelOffset, 10);
+    const edgeLabelSizeFn = formatSizeFn(edgeLabelSize, 0, 'edge');
+    const edgeLabelOffsetFn = formatNumberFn(edgeLabelOffset, 10, 'edge');
     const edgeLabelPosFn =
-      typeof edgeLabelPos === 'function' ? edgeLabelPos : () => edgeLabelPos;
-    const edgeMinLenFn = formatNumberFn(edgeMinLen, 1);
-    const edgeWeightFn = formatNumberFn(edgeWeight, 1);
+      typeof edgeLabelPos === 'string'
+        ? () => edgeLabelPos
+        : formatFn(edgeLabelPos, ['edge']);
+    const edgeMinLenFn = formatNumberFn(edgeMinLen, 1, 'edge');
+    const edgeWeightFn = formatNumberFn(edgeWeight, 1, 'edge');
 
     this.model.forEachEdge((edge) => {
       const raw = edge._original;

package/src/algorithm/dagre/types.ts

@@ -1,7 +1,7 @@
 import type { GraphLabel } from 'dagre';
-import type { BaseLayoutOptions } from '../types';
+import type { EdgeData, Expr, Size } from '../../types';
 import type { EdgeLabelPos } from '../../types/edge-label';
-import type { NodeData, Size } from '../../types';
+import type { BaseLayoutOptions } from '../types';
 
 /**
  * <zh/> 边标签位置：'l' 左侧，'c' 中心，'r' 右侧
@@ -38,47 +38,39 @@ export interface DagreLayoutOptions extends BaseLayoutOptions, GraphLabel {
    */
   multigraph?: boolean;
 
-  /**
-   * <zh/> 定义节点占用的空间大小，影响节点间距和整体布局疏密
-   *
-   * <en/> Defines space occupied by nodes, affecting inter-node spacing and overall layout density
-   * @defaultValue [0, 0]
-   */
-  nodeSize?: Size | ((d?: NodeData) => Size);
-
   /**
    * <zh/> 设置边跨越的最小层数，值越大节点间距越远，用于控制布局紧凑度
    *
    * <en/> Sets minimum number of layers an edge spans; larger values create more distance between nodes, controlling layout compactness
    * @defaultValue 1
    */
-  edgeMinLen?: number | ((d?: NodeData) => number);
+  edgeMinLen?: number | Expr | ((edge: EdgeData) => number);
 
   /**
    * <zh/> 边的权重，影响边的长度优化优先级，权重大的边倾向于更短
    *
    * <en/> Edge weight affecting length optimization priority; higher weight edges tend to be shorter
    */
-  edgeWeight?: number | ((d?: NodeData) => number);
+  edgeWeight?: number | Expr | ((edge: EdgeData) => number);
 
   /**
    * <zh/> 边标签的尺寸，用于为标签预留空间，避免与节点重叠
    *
    * <en/> Size of edge labels for reserving space to prevent overlap with nodes
    */
-  edgeLabelSize?: Size | ((d?: NodeData) => Size);
+  edgeLabelSize?: Size | Expr | ((edge: EdgeData) => Size);
 
   /**
    * <zh/> 标签在边上的位置，控制标签相对于边的对齐方式
    *
    * <en/> Label position on edge, controlling label alignment relative to the edge
    */
-  edgeLabelPos?: EdgeLabelPos | ((d?: NodeData) => EdgeLabelPos);
+  edgeLabelPos?: EdgeLabelPos | Expr | ((edge: EdgeData) => EdgeLabelPos);
 
   /**
    * <zh/> 标签与边的偏移距离，用于微调标签位置避免视觉重叠
    *
    * <en/> Offset distance between label and edge for fine-tuning label position to avoid visual overlap
    */
-  edgeLabelOffset?: number | ((d?: NodeData) => number);
+  edgeLabelOffset?: number | Expr | ((edge: EdgeData) => number);
 }

package/src/algorithm/force/index.ts

@@ -1,17 +1,22 @@
 import { isEmpty } from '@antv/util';
-import { BaseLayoutWithIterations } from '../base-layout';
+import type { GraphLib } from '../../model/data';
+import { initNodePosition } from '../../model/data';
 import type { EdgeData, NodeData, Point, PointObject } from '../../types';
 import { normalizeViewport } from '../../util';
-import { initNodePosition } from '../../model/data';
-import type { GraphLib } from '../../model/data';
-import { formatNodeSizeFn, formatNumberFn } from '../../util/format';
+import { formatFn, formatNodeSizeFn, formatNumberFn } from '../../util/format';
+import { BaseLayoutWithIterations } from '../base-layout';
 import { forceAttractive } from './attractive';
 import { forceCentripetal } from './centripetal';
 import { forceCollide } from './collide';
 import { forceGravity } from './gravity';
 import { forceRepulsive } from './repulsive';
 import { ForceSimulation } from './simulation';
-import { ForceLayoutOptions, ParsedForceLayoutOptions } from './types';
+import {
+  ForceLayoutOptions,
+  GetCenterFn,
+  NodeClusterByFn,
+  ParsedForceLayoutOptions,
+} from './types';
 
 export type { ForceLayoutOptions };
 
@@ -251,31 +256,45 @@ export class ForceLayout extends BaseLayoutWithIterations<ForceLayoutOptions> {
       ...normalizeViewport(options),
     } as ParsedForceLayoutOptions;
 
+    // Format nodeClusterBy (for clustering / leafCluster)
+    if (_.nodeClusterBy) {
+      _.nodeClusterBy = formatFn(_.nodeClusterBy, ['node']) as NodeClusterByFn;
+    }
+
     // Format node mass
     if (!options.getMass) {
-      _.getMass = (d?: NodeData) => {
-        if (!d) return 1;
+      _.getMass = (node: NodeData) => {
+        if (!node) return 1;
         const massWeight = 1;
-        const degree = this.model.degree(d.id, 'both');
+        const degree = this.model.degree(node.id, 'both');
         return !degree || degree < 5 ? massWeight : degree * 5 * massWeight;
       };
+    } else {
+      _.getMass = formatNumberFn(options.getMass, 1);
+    }
+
+    // Format per-node center force callback
+    if (options.getCenter) {
+      const params = ['node', 'degree'];
+      _.getCenter = formatFn(options.getCenter, params) as GetCenterFn;
     }
 
     // Format node size
-    _.nodeSize = formatNodeSizeFn(options.nodeSize, options.nodeSpacing);
+    const nodeSizeVec = formatNodeSizeFn(options.nodeSize, options.nodeSpacing);
+    _.nodeSize = (node: NodeData) => {
+      if (!node) return 0;
+      const [w, h, z] = nodeSizeVec(node);
+      return Math.max(w, h, z);
+    };
 
     // Format node / edge strengths
     _.linkDistance = options.linkDistance
-      ? formatNumberFn(options.linkDistance, 1)
-      : (edge?: EdgeData) => {
-          return (
-            1 +
-            _.nodeSize(this.model.node(edge!.source)!._original) +
-            _.nodeSize(this.model.node(edge!.target)!._original)
-          );
-        };
+      ? (formatFn(options.linkDistance, ['edge', 'source', 'target']) as any)
+      : (_: EdgeData, source: NodeData, target: NodeData) =>
+          1 + _.nodeSize(source) + _.nodeSize(target);
     _.nodeStrength = formatNumberFn(options.nodeStrength, 1);
-    _.edgeStrength = formatNumberFn(options.edgeStrength, 1);
+    _.edgeStrength = formatNumberFn(options.edgeStrength, 1, 'edge');
+    _.clusterNodeStrength = formatNumberFn(options.clusterNodeStrength, 1);
 
     // Format centripetal options
     this.formatCentripetal(_);
@@ -291,28 +310,45 @@ export class ForceLayout extends BaseLayoutWithIterations<ForceLayoutOptions> {
       dimensions,
       centripetalOptions,
       center,
-      clusterNodeStrength,
       leafCluster,
       clustering,
       nodeClusterBy,
     } = options;
 
-    // Basic centripetal settings
-    const basicCentripetal = centripetalOptions || {
-      leaf: 2,
-      single: 2,
-      others: 1,
-      center: (_: NodeData) => {
+    const leafParams = ['node', 'nodes', 'edges'];
+    const leafFn = formatFn(centripetalOptions?.leaf, leafParams);
+    const singleFn = formatNumberFn(centripetalOptions?.single, 2);
+    const othersFn = formatNumberFn(centripetalOptions?.others, 1);
+
+    const centerRaw =
+      centripetalOptions?.center ??
+      ((_: NodeData) => {
         return {
           x: center[0],
           y: center[1],
           z: dimensions === 3 ? center[2] : undefined,
         };
-      },
+      });
+
+    const centerFn = formatFn(centerRaw, [
+      'node',
+      'nodes',
+      'edges',
+      'width',
+      'height',
+    ]) as any;
+
+    const basicCentripetal = {
+      ...centripetalOptions,
+      leaf: leafFn,
+      single: singleFn,
+      others: othersFn,
+      center: centerFn,
     };
 
-    if (typeof clusterNodeStrength !== 'function') {
-      options.clusterNodeStrength = () => clusterNodeStrength as number;
+    // If user provided centripetalOptions, normalize them even without clustering modes.
+    if (centripetalOptions) {
+      options.centripetalOptions = basicCentripetal as any;
     }
 
     let sameTypeLeafMap: any;
@@ -406,18 +442,6 @@ export class ForceLayout extends BaseLayoutWithIterations<ForceLayoutOptions> {
         },
       });
     }
-
-    // Normalize functions
-    const { leaf, single, others } = options.centripetalOptions || {};
-    if (leaf && typeof leaf !== 'function') {
-      options.centripetalOptions.leaf = () => leaf;
-    }
-    if (single && typeof single !== 'function') {
-      options.centripetalOptions.single = () => single;
-    }
-    if (others && typeof others !== 'function') {
-      options.centripetalOptions.others = () => others;
-    }
   }
 
   /**

package/src/algorithm/force/types.ts

@@ -1,9 +1,9 @@
 import type {
   CommonForceLayoutOptions,
   EdgeData,
+  Expr,
   NodeData,
   Point,
-  Size,
 } from '../../types';
 
 export type AccMap = { [id: string]: { x: number; y: number; z: number } };
@@ -25,6 +25,7 @@ export interface CentripetalOptions {
    */
   leaf?:
     | number
+    | Expr
     | ((node: NodeData, nodes: NodeData[], edges: EdgeData[]) => number);
   /**
    * <zh/> 离散节点（即度数为 0 的节点）受到的向心力大小
@@ -35,7 +36,7 @@ export interface CentripetalOptions {
    * - ((node: NodeData) => number): return different values according to the node situation
    * @defaultValue 2
    */
-  single?: number | ((node: NodeData) => number);
+  single?: number | Expr | ((node: NodeData) => number);
   /**
    * <zh/> 除离散节点、叶子节点以外的其他节点（即度数 > 1 的节点）受到的向心力大小
    * - number: 固定向心力大小
@@ -45,13 +46,35 @@ export interface CentripetalOptions {
    * - ((node: NodeData) => number): return different values according to the node situation
    * @defaultValue 1
    */
-  others?: number | ((node: NodeData) => number);
+  others?: number | Expr | ((node: NodeData) => number);
   /**
    * <zh/> 向心力发出的位置，可根据节点、边的情况返回不同的值、默认为图的中心
    *
    * <en/> The position where the centripetal force is emitted, which can return different values according to the node, edge, and situation. The default is the center of the graph
    */
-  center?: (
+  center?:
+    | Expr
+    | ((
+        node: NodeData,
+        nodes: NodeData[],
+        edges: EdgeData[],
+        width: number,
+        height: number,
+      ) => {
+        x: number;
+        y: number;
+        z?: number;
+        centerStrength?: number;
+      });
+}
+
+interface FormatCentripetalOptions extends CentripetalOptions {
+  leaf: (node: NodeData, nodes: NodeData[], edges: EdgeData[]) => number;
+  /** Force strength for single nodes. */
+  single: (node: NodeData) => number;
+  /** Force strength for other nodes. */
+  others: (node: NodeData) => number;
+  center: (
     node: NodeData,
     nodes: NodeData[],
     edges: EdgeData[],
@@ -65,41 +88,34 @@ export interface CentripetalOptions {
   };
 }
 
-interface FormatCentripetalOptions extends CentripetalOptions {
-  leaf: (node: NodeData, nodes: NodeData[], edges: EdgeData[]) => number;
-  /** Force strength for single nodes. */
-  single: (node: NodeData) => number;
-  /** Force strength for other nodes. */
-  others: (node: NodeData) => number;
-}
-
 export interface ForceLayoutOptions extends CommonForceLayoutOptions {
   /**
    * <zh/> 边的长度
    * - number: 固定长度
-   * - ((edge?: EdgeData, source?: any, target?: any) => number): 根据边的信息返回长度
+   * - ((edge: EdgeData, source: NodeData, target: NodeData) => number): 根据边的信息返回长度
    * <en/> The length of the edge
    * - number: fixed length
-   * - ((edge?: EdgeData, source?: any, target?: any) => number): return length according to the edge information
+   * - ((edge: EdgeData, source: NodeData, target: NodeData) => number): return length according to the edge information
    * @defaultValue 200
    */
   linkDistance?:
     | number
-    | ((edge?: EdgeData, source?: any, target?: any) => number);
+    | Expr
+    | ((edge: EdgeData, source: NodeData, target: NodeData) => number);
   /**
    * <zh/> 节点作用力，正数代表节点之间的引力作用，负数代表节点之间的斥力作用
    *
    * <en/> The force of the node, positive numbers represent the attraction force between nodes, and negative numbers represent the repulsion force between nodes
    * @defaultValue 1000
    */
-  nodeStrength?: number | ((d?: NodeData) => number);
+  nodeStrength?: number | Expr | ((node: NodeData) => number);
   /**
    * <zh/> 边的作用力（引力）大小
    *
    * <en/> The size of the force of the edge (attraction)
    * @defaultValue 50
    */
-  edgeStrength?: number | ((d?: EdgeData) => number);
+  edgeStrength?: number | Expr | ((edge: EdgeData) => number);
   /**
    * <zh/> 是否防止重叠，必须配合下面属性 nodeSize 或节点数据中的 data.size 属性，只有在数据中设置了 data.size 或在该布局中配置了与当前图节点大小相同的 nodeSize 值，才能够进行节点重叠的碰撞检测
    *
@@ -107,18 +123,6 @@ export interface ForceLayoutOptions extends CommonForceLayoutOptions {
    * @defaultValue true
    */
   preventOverlap?: boolean;
-  /**
-   * <zh/> 节点大小（直径）。用于防止节点重叠时的碰撞检测
-   *
-   * <en/> The size of the node (diameter). Used for collision detection when preventing node overlap
-   */
-  nodeSize?: Size | ((d?: NodeData) => Size);
-  /**
-   * <zh/> preventOverlap 为 true 时生效, 防止重叠时节点边缘间距的最小值。可以是回调函数, 为不同节点设置不同的最小间距
-   *
-   * <en/> It is effective when preventOverlap is true. The minimum spacing of the node edge when preventing overlap. It can be a callback function to set different minimum spacing for different nodes
-   */
-  nodeSpacing?: number | ((d?: NodeData) => number);
   /**
    * <zh/> 阻尼系数，取值范围 [0, 1]。数字越大，速度降低得越慢
    *
@@ -194,14 +198,14 @@ export interface ForceLayoutOptions extends CommonForceLayoutOptions {
    *
    * <en/> Specify the field name of the node data as the clustering basis for the node, and it takes effect when clustering is true. You can combine it with clusterNodeStrength to use it
    */
-  nodeClusterBy?: (node: NodeData) => string;
+  nodeClusterBy?: Expr | ((node: NodeData) => string);
   /**
    * <zh/> 配合 clustering 和 nodeClusterBy 使用，指定聚类向心力的大小
    *
    * <en/> Use it with clustering and nodeClusterBy to specify the size of the centripetal force of the cluster
    * @defaultValue 20
    */
-  clusterNodeStrength?: number | ((node: NodeData) => number);
+  clusterNodeStrength?: number | Expr | ((node: NodeData) => number);
   /**
    * <zh/> 防止重叠的力强度，范围 [0, 1]
    *
@@ -216,7 +220,7 @@ export interface ForceLayoutOptions extends CommonForceLayoutOptions {
    * @param node - <zh/> 节点数据 | <en/> NodeData data
    * @returns <zh/> 节点质量大小 | <en/> Mass size of the node
    */
-  getMass?: (node?: NodeData) => number;
+  getMass?: Expr | ((node: NodeData) => number);
   /**
    * <zh/> 每个节点中心力的 x、y、强度的回调函数，若不指定，则没有额外中心力
    *
@@ -225,7 +229,7 @@ export interface ForceLayoutOptions extends CommonForceLayoutOptions {
    * @param degree - <zh/> 节点度数 | <en/> NodeData degree
    * @returns <zh/> 中心力 x、y、强度 | <en/> Center force x、y、strength
    */
-  getCenter?: (node?: NodeData, degree?: number) => number[];
+  getCenter?: Expr | ((node: NodeData, degree: number) => number[]);
   /**
    * <zh/> 每个迭代的监控信息回调，energy 表示布局的收敛能量。若配置可能带来额外的计算能量性能消耗，不配置则不计算
    *
@@ -240,7 +244,18 @@ export interface ForceLayoutOptions extends CommonForceLayoutOptions {
   }) => void;
 }
 
-export interface ParsedForceLayoutOptions extends ForceLayoutOptions {
+export interface ParsedForceLayoutOptions
+  extends Omit<
+    ForceLayoutOptions,
+    | 'centripetalOptions'
+    | 'nodeClusterBy'
+    | 'clusterNodeStrength'
+    | 'getMass'
+    | 'getCenter'
+    | 'nodeStrength'
+    | 'edgeStrength'
+    | 'linkDistance'
+  > {
   width: number;
   height: number;
   center: Point;
@@ -251,15 +266,31 @@ export interface ParsedForceLayoutOptions extends ForceLayoutOptions {
   damping: number;
   maxSpeed: number;
   coulombDisScale: number;
-  centripetalOptions: FormatCentripetalOptions;
-  nodeSize: (d?: NodeData) => number;
-  getMass: (d?: NodeData) => number;
-  nodeStrength: (d?: NodeData) => number;
-  edgeStrength: (d?: EdgeData) => number;
-  linkDistance: (
-    edge?: EdgeData,
-    source?: NodeData,
-    target?: NodeData,
-  ) => number;
-  clusterNodeStrength: (node?: NodeData) => number;
+  centripetalOptions?: FormatCentripetalOptions;
+  nodeClusterBy?: NodeClusterByFn;
+  getCenter?: GetCenterFn;
+  nodeSize: NodeSizeFn;
+  getMass: GetMassFn;
+  nodeStrength: NodeStrengthFn;
+  edgeStrength: EdgeStrengthFn;
+  linkDistance: LinkDistanceFn;
+  clusterNodeStrength: NodeStrengthFn;
 }
+
+export type NodeClusterByFn = (node: NodeData) => string;
+
+export type GetCenterFn = (node: NodeData, degree: number) => number[];
+
+export type NodeSizeFn = (node: NodeData) => number;
+
+export type GetMassFn = (node: NodeData) => number;
+
+export type NodeStrengthFn = (node: NodeData) => number;
+
+export type EdgeStrengthFn = (edge: EdgeData) => number;
+
+export type LinkDistanceFn = (
+  edge: EdgeData,
+  source: NodeData,
+  target: NodeData,
+) => number;

package/src/algorithm/force-atlas2/index.ts

@@ -1,9 +1,9 @@
-import { BaseLayoutWithIterations } from '../base-layout';
+import { initNodePosition } from '../../model/data';
 import type { ID, NullablePosition } from '../../types';
 import { normalizeViewport } from '../../util';
-import { initNodePosition } from '../../model/data';
 import { applySingleNodeLayout } from '../../util/common';
-import { formatNodeSizeFn, formatNumberFn, formatSizeFn } from '../../util/format';
+import { formatNodeSizeFn } from '../../util/format';
+import { BaseLayoutWithIterations } from '../base-layout';
 import { Simulation } from './simulation';
 import type {
   ForceAtlas2LayoutOptions,
@@ -97,9 +97,16 @@ export class ForceAtlas2Layout extends BaseLayoutWithIterations<ForceAtlas2Layou
     nodeSpacing?: ForceAtlas2LayoutOptions['nodeSpacing'],
   ): SizeMap {
     const result: SizeMap = {};
+
+    const nodeSizeFn = formatNodeSizeFn(
+      nodeSize,
+      nodeSpacing,
+      DEFAULTS_LAYOUT_OPTIONS.nodeSize as number,
+      DEFAULTS_LAYOUT_OPTIONS.nodeSpacing as number,
+    );
+
     this.model.forEachNode((node) => {
-      const nodeSizeFn = formatNodeSizeFn(nodeSize, nodeSpacing);
-      result[node.id] = nodeSizeFn(node._original);
+      result[node.id] = Math.max(...nodeSizeFn(node._original!));
     });
     return result;
   }
@@ -119,8 +126,7 @@ export class ForceAtlas2Layout extends BaseLayoutWithIterations<ForceAtlas2Layou
   private parseOptions(
     options: ForceAtlas2LayoutOptions = {},
   ): ParsedForceAtlas2LayoutOptions {
-    const { barnesHut, prune, maxIteration, kr, kg, nodeSize, nodeSpacing } =
-      options;
+    const { barnesHut, prune, maxIteration, kr, kg } = options;
     const auto: Partial<ForceAtlas2LayoutOptions> = {};
 
     const n = this.model.nodeCount();
@@ -153,14 +159,6 @@ export class ForceAtlas2Layout extends BaseLayoutWithIterations<ForceAtlas2Layou
       ...options,
       ...auto,
       ...normalizeViewport(options),
-      nodeSize: formatSizeFn(
-        nodeSize,
-        DEFAULTS_LAYOUT_OPTIONS.nodeSize as number,
-      ),
-      nodeSpacing: formatNumberFn(
-        nodeSpacing,
-        DEFAULTS_LAYOUT_OPTIONS.nodeSpacing as number,
-      ),
     } as ParsedForceAtlas2LayoutOptions;
   }
 

package/src/algorithm/force-atlas2/types.ts

@@ -89,18 +89,6 @@ export interface ForceAtlas2LayoutOptions extends CommonForceLayoutOptions {
    * <en/> By default, it will be activated when the number of nodes is greater than 100. Note that pruning can improve the convergence speed, but it may reduce the layout quality of the graph. Setting it to false will not be activated automatically
    */
   prune?: boolean;
-  /**
-   * <zh/> 节点大小（直径）。用于防止节点重叠时的碰撞检测
-   *
-   * <en/> Node size (diameter). Used for collision detection when preventing node overlap
-   */
-  nodeSize?: Size | ((d?: NodeData) => Size);
-  /**
-   * <zh/> 节点间距。用于防止节点重叠时的碰撞检测
-   *
-   * <en/> Node spacing. Used for collision detection when preventing node overlap
-   */
-  nodeSpacing?: number | ((d?: NodeData) => number);
 }
 
 export type ParsedForceAtlas2LayoutOptions = Required<ForceAtlas2LayoutOptions>;

package/src/algorithm/fruchterman/index.ts

@@ -1,11 +1,7 @@
-import { BaseLayoutWithIterations } from '../base-layout';
-import type { ID, NodeData, NullablePosition } from '../../types';
-import {
-  applySingleNodeLayout,
-  getNestedValue,
-  normalizeViewport,
-} from '../../util';
 import { initNodePosition } from '../../model/data';
+import type { ID, NullablePosition } from '../../types';
+import { applySingleNodeLayout, formatFn, normalizeViewport } from '../../util';
+import { BaseLayoutWithIterations } from '../base-layout';
 import { Simulation } from './simulation';
 import type {
   FruchtermanLayoutOptions,
@@ -22,7 +18,7 @@ const DEFAULTS_LAYOUT_OPTIONS: Partial<FruchtermanLayoutOptions> = {
   clusterGravity: 10,
   width: 300,
   height: 300,
-  nodeClusterBy: 'data.cluster',
+  nodeClusterBy: 'node.cluster',
   dimensions: 2,
 };
 
@@ -36,18 +32,14 @@ export class FruchtermanLayout extends BaseLayoutWithIterations<FruchtermanLayou
   }
 
   protected parseOptions(
-    options?: Partial<FruchtermanLayoutOptions>,
+    options: Partial<FruchtermanLayoutOptions> = {},
   ): ParsedFruchtermanLayoutOptions {
     const { clustering, nodeClusterBy } = this.options;
     const clusteringEnabled = clustering && !!nodeClusterBy;
-    const nodeClusterByFunc =
-      typeof nodeClusterBy === 'string'
-        ? (node: NodeData) => getNestedValue(node, nodeClusterBy)
-        : nodeClusterBy!;
 
-    Object.assign((options ||= {}), normalizeViewport(options), {
+    Object.assign(options, normalizeViewport(options), {
       clustering: clusteringEnabled,
-      nodeClusterBy: nodeClusterByFunc,
+      nodeClusterBy: formatFn(nodeClusterBy, ['node']),
     });
 
     return options as ParsedFruchtermanLayoutOptions;

package/src/algorithm/fruchterman/simulation.ts

@@ -1,5 +1,5 @@
 import { isNil } from '@antv/util';
-import { BaseSimulation } from '../base-simulation';
+import type { GraphLib } from '../../model/data';
 import type {
   DisplacementMap,
   ID,
@@ -8,7 +8,7 @@ import type {
   NullablePosition,
 } from '../../types';
 import { normalizeViewport } from '../../util';
-import type { GraphLib } from '../../model/data';
+import { BaseSimulation } from '../base-simulation';
 import type {
   FruchtermanLayoutOptions,
   ParsedFruchtermanLayoutOptions,

package/src/algorithm/fruchterman/types.ts

@@ -1,4 +1,4 @@
-import type { CommonForceLayoutOptions, NodeData } from '../../types';
+import type { CommonForceLayoutOptions, Expr, NodeData } from '../../types';
 
 /**
  * <zh/> Fruchterman 力导布局配置项
@@ -13,6 +13,7 @@ export interface FruchtermanLayoutOptions extends CommonForceLayoutOptions {
    * @defaultValue 10
    */
   gravity?: number;
+
   /**
    * <zh/> 每次迭代节点移动的速度。速度太快可能会导致强烈震荡
    *
@@ -20,6 +21,7 @@ export interface FruchtermanLayoutOptions extends CommonForceLayoutOptions {
    * @defaultValue 5
    */
   speed?: number;
+
   /**
    * <zh/> 是否按照聚类布局
    *
@@ -27,6 +29,7 @@ export interface FruchtermanLayoutOptions extends CommonForceLayoutOptions {
    * @defaultValue false
    */
   clustering?: boolean;
+
   /**
    * <zh/> 聚类内部的重力大小，影响聚类的紧凑程度，在 clustering 为 true 时生效
    *
@@ -41,7 +44,7 @@ export interface FruchtermanLayoutOptions extends CommonForceLayoutOptions {
    * <en/> The field name of the node data in the data, which is used when cluster is true
    * @defaultValue 'cluster'
    */
-  nodeClusterBy?: string | ((node: NodeData) => string);
+  nodeClusterBy?: Expr | ((node: NodeData) => string);
 }
 
 export type ParsedFruchtermanLayoutOptions = Required<FruchtermanLayoutOptions>;