节点

Node 是所有节点的基类，继承自 Cell，并定义了节点的通用属性和方法。

属性

除了从 Cell 继承属性外，还支持以下属性。

size

节点大小，是一个包含 width 和 height 属性的对象，可以通过 size(...) 方法来获取和设置节点大小。

position

节点位置，是一个包含 x 和 y 属性的对象，可以通过 position(...) 方法来获取和设置节点位置。

angle

节点的旋转角度，旋转中心为节点的中心，可以通过 rotate(...) 方法来获取和设置节点的旋转角度。

ports

连接桩是节点上的固定连接点，很多图应用都有连接桩，并且有些应用还将连接桩分为输入连接桩和输出连接桩。

连接桩选项 ports 是一个复杂对象，可以像下面这样使用。

const node = new Node({
  ports: {
    group: { ... }, // 连接桩组定义
    items: [ ... ], // 连接桩
  }
})

或者

const node = new Node({
  ports: [ ... ], // 连接桩
})

通常我们将具有相同行为和外观的连接桩归为同一组，并通过 group 选项来设置分组，该选项是一个对象 { [groupName: string]: PortGroupMetadata }，组名为键，值为每组连接桩的默认选项，支持的选项如下：

interface PortGroupMetadata {
  /**
   * 连接桩 DOM 结构定义。
   */
  markup?: Markup

  /**
   * 属性和样式。
   */
  attrs?: Attr.CellAttrs

  /**
   * 连接桩的 DOM 层级，值越大层级越高。
   */
  zIndex?: number | 'auto'

  /**
   * 群组中连接桩的布局。
   */
  position?:
    | [number, number] // 绝对定位
    | string // 连接桩布局方法的名称
    | {
        // 连接桩布局方法的名称和参数
        name: string
        args?: object
      }

  /**
   * 连接桩标签。
   */
  label?: {
    markup?: Markup
    position?: {
      // 连接桩标签布局
      name: string // 布局名称
      args?: object // 布局参数
    }
  }
}

例如：

const node = new Node({
  ports: {
    group: {
      group1: {
        markup: { tagName: 'circle' },
        attrs: { },
        zIndex: 1,
        position: {
          name: 'top',
          args: {},
        },
      },
      group2: { ... },
      group3: { ... },
    },
    items: [ ... ],
  }
})

另一个选项 items 是一个数组 PortMetadata[]，数组的每一项表示一个连接桩，连接桩支持的选项如下：

interface PortMetadata {
  /**
   *  连接桩唯一 ID，默认自动生成。
   */
  id?: string

  /**
   * 分组名称，指定分组后将继承分组中的连接桩选项。
   */
  group?: string

  /**
   * 为群组中指定的连接桩布局算法提供参数。
   * 我们不能为单个连接桩指定布局算法，但可以为群组中指定的布局算法提供不同的参数。
   */
  args?: object

  /**
   * 连接桩的 DOM 元素和结构定义。指定该选项后将覆盖 `group` 指代的群组提供的默认选项。
   */
  markup?: Markup

  /**
   * 元素的属性样式。指定该选项后将覆盖 `group` 指代的群组提供的默认选项。
   */
  attrs?: Attr.CellAttrs

  /**
   * 连接桩的 DOM 层级，值越大层级越高。指定该选项后将覆盖 `group` 指代的群组提供的默认选项。
   */
  zIndex?: number | 'auto'

  /**
   * 连接桩标签。指定该选项后将覆盖 `group` 指代的群组提供的默认选项。
   */
  label?: {
    markup?: Markup
    position?: {
      // 连接桩标签布局
      name: string // 布局名称
      args?: object // 布局参数
    }
  }
}

例如：

const node = new Node({
  ports: {
    group: { ... },
    items: [
      { id: 'port1', group: 'group1', ... },
      { id: 'port2', group: 'group1', ... },
      { id: 'port3', group: 'group2', ... },
    ],
  }
})

更多详情请参考配置连接桩文档。

portMarkup

连接桩的 DOM 结构。当 ports.groups 和 ports.items 都没有为对应的连接桩指定 markup 时，则使用这个默认选项来渲染连接桩，其默认值为：

{
  tagName: 'circle',
  selector: 'circle',
  attrs: {
    r: 10,
    fill: '#fff',
    stroke: '#000',
  },
}

表示用半径为 10px 的圆来渲染连接桩。

portLabelMarkup

连接桩标签的 DOM 结构。当 ports.groups 和 ports.items 都没有为对应的连接桩标签指定 markup 时，则使用这个默认选项来渲染连接桩标签，其默认值为：

{
  tagName: 'text',
  selector: 'text',
  attrs: {
    fill: '#000000',
  },
}

方法

通用

isNode()

isNode(): true

判断是不是节点，该方法始终返回 true。

getBBox(…)

getBBox(options: { deep?: boolean }): Rectangle

获取节点的包围盒。

const rect1 = node.getBBox()
const rect2 = node.getBBox({ deep: true })

大小 Size

size(…)

/**
 * 获取节点大小。
 */
size(): Size

/**
 * 设置节点大小。
 */
size(size: Size, options?: Node.ResizeOptions): this

/**
 * 设置节点大小。
 */
size(width: number, height: number, options?: Node.ResizeOptions): this

获取节点大小。

const size = node.size()
console.log(size.width, size.height)

设置节点大小的参数和使用方法与 resize 方法一样。

resize(…)

改变节点大小。根据旋转角度和 options.direction 的不同，节点位置和大小都可能发生改变。

支持向 8 个方向改变节点大小，默认为 'bottom-right' 表示左上角固定，往右下角改变节点大小。

• top
• right
• bottom
• left
• top-left
• top-right
• bottom-left
• bottom-right

node.resize(100, 40)

// 右下角固定，向左上角改变大小
node.resize(100, 40, { direction: 'top-left' })

// 不触发事件和重绘
node.resize(100, 40, { silent: true })

scale(…)

scale(
  sx: number,
  sy: number,
  origin?: Point.PointLike,
  options?: Node.SetOptions,
): this

缩放节点。根据缩放中心和缩放比例不同，节点的大小和位置都可能发生改变。

node.scale(1.5, 1.5)

// 自定义缩放中心
node.scale(1.5, 1.5, { x: 100, y: 30 })

// 不触发事件和重绘
node.scale(1.5, 1.5, null, { silent: true })

fit(…)

fit(options?: Node.FitEmbedsOptions): this

根据子节点和边的大小位置，自动调整节点的大小和位置，使所有子节点和边都位于节点的包围盒内。

node.fit()
node.fit({ padding: 10 })
node.fit({ padding: { top: 20, bottom: 20, left: 10, right: 10 } })

位置 Position

position(…)

/**
 * 获取节点位置。
 */
position(options?: Node.GetPositionOptions): Point.PointLike

/**
 * 设置节点位置。
 */
position(x: number, y: number, options?: Node.SetPositionOptions): this

获取节点位置。

const pos = rect.position()
console.log(pos.x, pos.y)

const relativePos = child.position({ relative: true })
console.log(relativePos.x, relativePos.y)

设置节点位置。

默认使用绝对坐标，当 options.relative 为 true 时表示使用相对坐标。

// 将节点移动到画布 [30, 30] 位置处
node.position(30, 30)

// 将子节点移动到相对父节点左上角 [30, 30] 位置处
child.position(30, 30, { relative: true })

当 options.deep 为 true 时将同时移动子节点和边。

parent.position(30, 30, { deep: true })

当 options.silent 为 true 时不触不触发 'change:position' 事件和画布重绘。

node.position(30, 30, { silent: true })

在选项中支持其他自定义键值对，可以在事件回调用使用。

node.position(30, 30, { otherKey: 'otherValue', ... })

translate(…)

translate(tx?: number, ty?: number, options?: Node.TranslateOptions): this

平移节点以及节点包含的子节点和边。

当指定的 tx 和 ty 为 undefined 时，表示对应方向的平移量为 0。

node.translate(30, 30)
node.translate(30) // 只在 X 轴移动
node.translate(undefined, 30) // 只在 Y 轴移动

我们可以通过 options.restrict 选项来将节点的移动限制在指定的矩形 {x: number; y: number; width: number; height: number} 范围内。

例如，我们可以将子节点的移动限制在父节点的包围盒中：

child.translate(30, 30, {
  restrict: child.getParent().getBBox(),
})

当 options.transition 为 true 或指定了一个动画选项时，表示使用动画来平移节点。

// 使用默认动画在平移节点
node.translate(30, 30, {
  transition: true,
})

// 自定动画选项
node.translate(30, 30, {
  transition: {
    duration: 2000,
  },
})

当 options.silent 为 true 时不触不触发 'change:position' 事件和画布重绘。

node.translate(30, 30, { silent: true })

在选项中支持其他自定义键值对，可以在事件回调用使用。

node.translate(30, 30, { otherKey: 'otherValue', ... })

旋转角度 Angle

getAngle()

getAngle(): number

获取节点的旋转角度。

if (node.getAngle() !== 0) {
  // do something
}

rotate(…)

rotate(
  deg: number,
  absolute?: boolean,
  origin?: Point.PointLike,
  options?: Node.RotateOptions,
): this

旋转节点。

默认为相对旋转，即在当前旋转角度的基础上在旋转给定的度数，当 options.absolute 为 true 时表示绝对旋转，即给定的度数为节点旋转后的度数。

// 相对旋转，节点在当前旋转角度的基础上在旋转 30 度
node.rotate(30)

// 绝对旋转，节点旋转后的角度为 30 度
node.rotate(30, { absolute: true })

默认沿节点中心旋转，可以通过 options.center 选项来指定一个旋转中心。

node.rotate(30, { center: { x: 10, y: 10 } })

默认触发 'change:angle' 事件和画布重绘，当 options.silent 为 true 时，不触发 'change:angle' 事件和画布重绘。

node.rotate(30, { silent: true })

在选项中支持其他自定义键值对，可以在事件回调用使用。

node.rotate(30, { otherKey: 'otherValue', ... })

连接桩 Ports

连接桩是节点上的固定连接点，很多图应用都有连接桩，并且有些应用还将连接桩分为输入连接桩和输出连接桩。

在上面我们介绍了连接桩的数据结构，这里我们将继续介绍节点上操作连接桩的一些方法。

addPort(…)

addPort(port: PortMetadata, options?: Node.SetOptions): this

添加单个连接桩。连接桩被添加到连接桩数组末尾。

addPorts(…)

addPorts(ports: PortMetadata[], options?: Node.SetOptions)

添加多个连接桩。连接桩被添加到连接桩数组末尾。

insertPort(…)

insertPort(index: number, port: PortMetadata, options?: Node.SetOptions): this

在指定位置添加连接桩。注意 port 参数需要带上 id 属性。

hasPort(…)

hasPort(portId: string): boolean

检查指定的连接桩是否存在。

if (node.hasPort('port1')) {
  // do something
}

hasPorts()

hasPorts(): boolean

检查节点是否包含连接桩。

if (node.hasPorts()) {
  // do something
}

getPort(…)

getPort(portId: string): PortMetadata

根据连接桩 ID 获取连接桩。

getPortAt(…)

getPortAt(index: number): PortMetadata | null

获取指定索引位置的连接桩。

getPorts()

getPorts(): PortMetadata[]

获取所有连接桩。

getPortsByGroup(…)

getPortsByGroup(groupName: string): PortMetadata[]

获取群组下的所有连接桩。

removePort(…)

/**
 * 删除指定的连接桩。
 */
removePort(port: PortMetadata, options?: Node.SetOptions): this

/**
 * 删除指定 ID 的连接桩。
 */
removePort(portId: string, options?: Node.SetOptions): this

删除指定的连接桩。

删除指定 ID 的连接桩。

removePortAt(…)

removePortAt(index: number, options?: Node.SetOptions): this

删除指定索引位置的连接桩。

removePorts(…)

/**
 * 删除所有连接桩。
 */
removePorts(options?: Node.SetOptions): this

/**
 * 删除指定的连接桩。
 */
removePorts(ports: (PortMetadata | string)[], options?: Node.SetOptions): this

删除指定的多个连接桩。

getPortIndex(…)

getPortIndex(port: PortMetadata | string): number

获取连接桩的索引位置。

getPortProp(…)

getPortProp<T>(portId: string, path?: string | string[]): any

获取连接桩指定路径上的属性值。当路径为空时，返回完整的连接桩。

node.getPortProp('port1')
node.getPortProp('port1', 'attrs/circle')
node.getPortProp('port1', ['attrs', 'circle'])

setPortProp(…)

setPortProp(
  portId: string,
  path: string | string[],
  value: any,
  options?: Node.SetOptions,
): this

根据路径设置连接桩的属性。

node.setPortProp('port1', 'attrs/circle', {
  fill: '#ffffff',
  stroke: '#000000',
})
node.setPortProp('port1', ['attrs', 'circle'], {
  fill: '#ffffff',
  stroke: '#000000',
})

setPortProp(
  portId: string,
  value: DeepPartial<PortMetadata>,
  options?: Node.SetOptions,
): this

设置连接桩的属性，提供的属性选项与当前值进行深度 merge。

node.setPortProp('port1', {
  attrs: {
    circle: {
      fill: '#ffffff',
      stroke: '#000000',
    },
  },
})

removePortProp(…)

removePortProp(portId: string, options?: Node.SetOptions): this

删除指定连接桩的选项。

removePortProp(portId: string, path: string | string[], options?: Node.SetOptions): this

删除指定连接桩和指定路径的选项。

portProp(…)

portProp(portId: string): PortMetadata
portProp<T>(portId: string, path: string | string[]): T
portProp(
  portId: string,
  path: string | string[],
  value: any,
  options?: Node.SetOptions,
): this
portProp(
  portId: string,
  value: DeepPartial<PortMetadata>,
  options?: Node.SetOptions,
): this

该方法是 getPortProp 和 setPortProp 两个方法的集合，参数选项和使用方法与这两个方法一致。