dify/web/app/components/workflow/nodes/loop/use-interactions.helpers.ts

import type { BlockEnum, Node } from '../../types'
import { LOOP_PADDING, NESTED_ELEMENT_Z_INDEX } from '../../constants'
import { CUSTOM_LOOP_START_NODE } from '../loop-start/constants'

type ContainerBounds = {
  rightNode?: Node
  bottomNode?: Node
}

export const getContainerBounds = (childrenNodes: Node[]): ContainerBounds => {
  return childrenNodes.reduce<ContainerBounds>((acc, node) => {
    const nextRightNode =
      !acc.rightNode ||
      node.position.x + node.width! > acc.rightNode.position.x + acc.rightNode.width!
        ? node
        : acc.rightNode
    const nextBottomNode =
      !acc.bottomNode ||
      node.position.y + node.height! > acc.bottomNode.position.y + acc.bottomNode.height!
        ? node
        : acc.bottomNode

    return {
      rightNode: nextRightNode,
      bottomNode: nextBottomNode,
    }
  }, {})
}

export const getContainerResize = (currentNode: Node, bounds: ContainerBounds) => {
  const width =
    bounds.rightNode && currentNode.width! < bounds.rightNode.position.x + bounds.rightNode.width!
      ? bounds.rightNode.position.x + bounds.rightNode.width! + LOOP_PADDING.right
      : undefined
  const height =
    bounds.bottomNode &&
    currentNode.height! < bounds.bottomNode.position.y + bounds.bottomNode.height!
      ? bounds.bottomNode.position.y + bounds.bottomNode.height! + LOOP_PADDING.bottom
      : undefined

  return {
    width,
    height,
  }
}

export const getRestrictedLoopPosition = (node: Node, parentNode?: Node) => {
  const restrictPosition: { x?: number; y?: number } = { x: undefined, y: undefined }

  if (!node.data.isInLoop || !parentNode) return restrictPosition

  if (node.position.y < LOOP_PADDING.top) restrictPosition.y = LOOP_PADDING.top
  if (node.position.x < LOOP_PADDING.left) restrictPosition.x = LOOP_PADDING.left
  if (node.position.x + node.width! > parentNode.width! - LOOP_PADDING.right)
    restrictPosition.x = parentNode.width! - LOOP_PADDING.right - node.width!
  if (node.position.y + node.height! > parentNode.height! - LOOP_PADDING.bottom)
    restrictPosition.y = parentNode.height! - LOOP_PADDING.bottom - node.height!

  return restrictPosition
}

export const getLoopChildren = (nodes: Node[], nodeId: string) => {
  return nodes.filter((node) => node.parentId === nodeId && node.type !== CUSTOM_LOOP_START_NODE)
}

export const buildLoopChildCopy = ({
  child,
  childNodeType,
  defaultValue,
  nodesWithSameTypeCount,
  newNodeId,
  index,
}: {
  child: Node
  childNodeType: BlockEnum
  defaultValue: Node['data']
  nodesWithSameTypeCount: number
  newNodeId: string
  index: number
}) => {
  const params = {
    type: child.type!,
    data: {
      ...defaultValue,
      ...child.data,
      selected: false,
      _isBundled: false,
      _connectedSourceHandleIds: [],
      _connectedTargetHandleIds: [],
      _dimmed: false,
      title:
        nodesWithSameTypeCount > 0
          ? `${defaultValue.title} ${nodesWithSameTypeCount + 1}`
          : defaultValue.title,
      isInLoop: true,
      loop_id: newNodeId,
      type: childNodeType,
    },
    position: child.position,
    positionAbsolute: child.positionAbsolute,
    parentId: newNodeId,
    extent: child.extent,
    zIndex: NESTED_ELEMENT_Z_INDEX,
  }

  return {
    params,
    newId: `${newNodeId}${index}`,
  }
}