Nodes

Nodes are defined through FlowNodeEntity

Node Core API

id: string Node id
flowNodeType: string | number Node type
bounds: Rectangle Get the node's x, y, width, height, equivalent to transform.bounds
blocks: FlowNodeEntity[] Get child nodes, including collapsed child nodes, equivalent to collapsedChildren
collapsedChildren: FlowNodeEntity[] Get child nodes, including collapsed child nodes
allCollapsedChildren: FlowNodeEntity[] Get all child nodes, including all collapsed child nodes
children: FlowNodeEntity[] Get child nodes, not including collapsed child nodes
pre: FlowNodeEntity | undefined Get the previous node
next: FlowNodeEntity | undefined Get the next node
parent: FlowNodeEntity | undefined Get the parent node
originParent: FlowNodeEntity | undefined Get the original parent node, this is used to find the entire virtual branch for the first node of the fixed layout branch (orderIcon)
allChildren: FlowNodeEntity[] Get all child nodes, not including collapsed child nodes
document: FlowDocument Document link
transform: FlowNodeTransformData Get the node's transform data
renderData: FlowNodeRenderData Get the node's render data, including render status
form: NodeFormProps Get the node's form data, like getNodeForm
scope: FlowNodeScope Get the node's variable public scope
privateScope: FlowNodeScope Get the node's variable private scope
getNodeRegistry(): FlowNodeRegistry Get the node's registry
getService(): Get the IOC Service, such asnode.getService(HistoryService)
getExtInfo(): Get the node's ext info, such as node.getExtInfo<{ test: string }>()
updateExtInfo(): Update the node's ext info, such as node.updateExtInfo<{ test: string }>({ test: 'test' })
dispose(): Destroy node
toJSON(): Get the node's json data

Node Data

Can be obtained through node.toJSON()

Basic Structure:

id: string Node unique identifier, must be unique
meta: object Node UI configuration information, such as free layout position information is stored here
type: string | number Node type, corresponds to type in nodeRegistries
data: object Node form data, can be customized by business
blocks: array Node branches, using block is closer to Gramming

const nodeData: FlowNodeJSON = {
  id: 'xxxx',
  type: 'condition',
  data: {
    title: 'MyCondition',
    desc: 'xxxxx'
  },
}

Node Definition

Node declaration can be used to determine node type and rendering method

import { FlowNodeRegistry, ValidateTrigger } from '@flowgram.ai/fixed-layout-editor';

/**
 * Custom node registration
 */
export const nodeRegistries: FlowNodeRegistry[] = [
  {
    /**
     * Custom node type
     */
    type: 'condition',
    /**
     * Custom node extension:
     *  - loop: Extend as loop node
     *  - start: Extend as start node
     *  - dynamicSplit: Extend as branch node
     *  - end: Extend as end node
     *  - tryCatch: Extend as tryCatch node
     *  - default: Extend as normal node (default)
     */
    extend: 'dynamicSplit',
    /**
     * Node configuration information
     */
    meta: {
      // isStart: false, // Whether it's a start node
      // isNodeEnd: false, // Whether it's an end node, no nodes can be added after end node
      // draggable: false, // Whether draggable, start and end nodes cannot be dragged
      // selectable: false, // Triggers and start nodes cannot be box-selected
      // deleteDisable: true, // Disable deletion
      // copyDisable: true, // Disable copying
      // addDisable: true, // Disable adding
    },
    /**
     * Configure node form validation and rendering,
     * Note: validate uses data and rendering separation to ensure nodes can validate data even without rendering
     */
    formMeta: {
      validateTrigger: ValidateTrigger.onChange,
      validate: {
        title: ({ value }) => (value ? undefined : 'Title is required'),
      },
      /**
       * Render form
       */
      render: () => (
       <>
          <Field name="title">
            {({ field }) => <div className="demo-free-node-title">{field.value}</div>}
          </Field>
          <Field name="content">
            {({ field }) => <input onChange={field.onChange} value={field.value}/>}
          </Field>
        </>
      )
    },
  },
];

Getting Current Rendered Node

Get node-related methods through useNodeRender

function BaseNode() {
  const { id, type, data, updateData, node } = useNodeRender()
}

Creating Nodes

Create through FlowOperationService

Add node

const ctx = useClientContext()

ctx.operation.addNode({
  id: 'xxx', // Must be unique within canvas
  type: 'custom',
  meta: {},
  data: {}, // Form-related data
  blocks: [], // Child nodes
  parent: someParent // Parent node, used for branches
})

Add after specified node

const ctx = useClientContext()

ctx.operation.addFromNode(targetNode, {
  id: 'xxx', // Must be unique within canvas
  type: 'custom',
  meta: {},
  data: {}, // Form-related data
  blocks: [], // Child nodes
})

Add branch node (used for conditional branches)

const ctx = useClientContext()

ctx.operation.addBlock(parentNode, {
  id: 'xxx', // Must be unique within canvas
  type: 'block',
  meta: {},
  data: {}, // Form-related data
  blocks: [], // Child nodes
})

Deleting Nodes

function BaseNode({ node }) {
  const ctx = useClientContext()
  function onClick() {
    ctx.operation.deleteNode(node)
  }
  return (
    <button onClick={onClick}>Delete</button>
  )
}

Updating Node Data

Get node data through useNodeRender or node.form

function BaseNode() {
  const { form, node } = useNodeRender();
  // Corresponds to node's data
  // 1. form.values: Corresponds to node's data
  // 2. form.setValueIn('title', 'xxxx'): Update data.title
  // 3. form.getValueIn('title'): Get data.title
  // 4. form.updateFormValues({ ... }) Update all form values

  function onChange(e) {
    form.setValueIn('title', e.target.value)
  }
  return <input value={form.values.title} onChange={onChange}/>
}

Update form data through Field, see Form Usage for details

function FormRender() {
  return (
    <Field name="title">
      <Input />
    </Field>
  )
}

Updating Node ExtInfo Data

ExtInfo is used to store some UI states. If node engine is not enabled, node data will be stored in extInfo by default

function BaseNode({ node }) {
  const times = node.getExtInfo()?.times || 0
  function onClick() {
    node.updateExtInfo({ times: times ++ })
  }
  return (
    <div>
      <span>Click Times: {times}</span>
      <button onClick={onClick}>Click</button>
    </div>
  )
}

#Nodes

#Node Core API

#Node Data

#Node Definition

#Getting Current Rendered Node

#Creating Nodes

#Deleting Nodes

#Updating Node Data

#Updating Node ExtInfo Data