Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

5.4 KB
Raw Blame
import type { Edge, Node } from '../types'

const WORKFLOW_CLIPBOARD_KIND = 'dify-workflow-clipboard'

type WorkflowClipboardPayload = {
  kind: string
  version: string
  nodes: Node[]
  edges: Edge[]
}

type WorkflowClipboardData = {
  nodes: Node[]
  edges: Edge[]
}

type WorkflowClipboardReadResult = WorkflowClipboardData & {
  sourceVersion?: string
  isVersionMismatch: boolean
}

const emptyClipboardData: WorkflowClipboardData = {
  nodes: [],
  edges: [],
}

const emptyClipboardReadResult: WorkflowClipboardReadResult = {
  ...emptyClipboardData,
  isVersionMismatch: false,
}

const isNodeArray = (value: unknown): value is Node[] => Array.isArray(value)
const isEdgeArray = (value: unknown): value is Edge[] => Array.isArray(value)
const isPlainObject = (value: unknown): value is Record<string, unknown> =>
  value !== null && typeof value === 'object' && !Array.isArray(value)

export const sanitizeClipboardValueByDefault = (
  defaultValue: unknown,
  incomingValue: unknown,
): unknown => {
  if (defaultValue === undefined) return incomingValue

  if (Array.isArray(defaultValue))
    return Array.isArray(incomingValue) ? incomingValue : [...defaultValue]

  if (isPlainObject(defaultValue)) {
    if (!isPlainObject(incomingValue)) {
      return Object.fromEntries(
        Object.entries(defaultValue).map(([key, value]) => [
          key,
          sanitizeClipboardValueByDefault(value, undefined),
        ]),
      )
    }

    const merged: Record<string, unknown> = {}
    const keys = new Set([...Object.keys(defaultValue), ...Object.keys(incomingValue)])

    keys.forEach((key) => {
      const hasDefault = Object.hasOwn(defaultValue, key)
      const hasIncoming = Object.hasOwn(incomingValue, key)
      if (hasDefault && hasIncoming) {
        merged[key] = sanitizeClipboardValueByDefault(defaultValue[key], incomingValue[key])
        return
      }

      if (hasIncoming) {
        merged[key] = incomingValue[key]
        return
      }

      merged[key] = sanitizeClipboardValueByDefault(defaultValue[key], undefined)
    })

    return merged
  }

  if (typeof defaultValue === 'number')
    return typeof incomingValue === 'number' && Number.isFinite(incomingValue)
      ? incomingValue
      : defaultValue

  return typeof incomingValue === typeof defaultValue ? incomingValue : defaultValue
}

export const isClipboardValueCompatibleWithDefault = (
  defaultValue: unknown,
  incomingValue: unknown,
): boolean => {
  if (incomingValue === undefined) return true

  if (defaultValue === undefined) return true

  if (Array.isArray(defaultValue)) return Array.isArray(incomingValue)

  if (isPlainObject(defaultValue)) {
    if (!isPlainObject(incomingValue)) return false

    return Object.entries(defaultValue).every(([key, value]) => {
      return isClipboardValueCompatibleWithDefault(value, incomingValue[key])
    })
  }

  if (typeof defaultValue === 'number')
    return typeof incomingValue === 'number' && Number.isFinite(incomingValue)

  return typeof incomingValue === typeof defaultValue
}

export const isClipboardNodeStructurallyValid = (value: unknown): value is Node => {
  if (!isPlainObject(value)) return false

  if (typeof value.id !== 'string' || typeof value.type !== 'string') return false

  if (!isPlainObject(value.data) || !isPlainObject(value.position)) return false

  return Number.isFinite(value.position.x) && Number.isFinite(value.position.y)
}

export const isClipboardEdgeStructurallyValid = (value: unknown): value is Edge => {
  if (!isPlainObject(value)) return false

  return (
    typeof value.id === 'string' &&
    typeof value.source === 'string' &&
    typeof value.target === 'string'
  )
}

export const parseWorkflowClipboardText = (
  text: string,
  currentClipboardVersion: string,
): WorkflowClipboardReadResult => {
  if (!text) return emptyClipboardReadResult

  try {
    const parsed = JSON.parse(text) as Partial<WorkflowClipboardPayload>
    if (
      parsed.kind !== WORKFLOW_CLIPBOARD_KIND ||
      typeof parsed.version !== 'string' ||
      !isNodeArray(parsed.nodes) ||
      !isEdgeArray(parsed.edges)
    ) {
      return emptyClipboardReadResult
    }

    const sourceVersion = parsed.version

    const validatedNodes = parsed.nodes.filter(isClipboardNodeStructurallyValid)
    const validatedEdges = parsed.edges.filter(isClipboardEdgeStructurallyValid)

    return {
      nodes: validatedNodes,
      edges: validatedEdges,
      sourceVersion,
      isVersionMismatch: sourceVersion !== currentClipboardVersion,
    }
  } catch {
    return emptyClipboardReadResult
  }
}

const stringifyWorkflowClipboardData = (
  payload: WorkflowClipboardData,
  currentClipboardVersion: string,
): string => {
  const data: WorkflowClipboardPayload = {
    kind: WORKFLOW_CLIPBOARD_KIND,
    version: currentClipboardVersion,
    nodes: payload.nodes,
    edges: payload.edges,
  }

  return JSON.stringify(data)
}

export const writeWorkflowClipboard = async (
  payload: WorkflowClipboardData,
  currentClipboardVersion: string,
): Promise<void> => {
  const text = stringifyWorkflowClipboardData(payload, currentClipboardVersion)
  await navigator.clipboard.writeText(text)
}

export const readWorkflowClipboard = async (
  currentClipboardVersion: string,
): Promise<WorkflowClipboardReadResult> => {
  try {
    const text = await navigator.clipboard.readText()
    return parseWorkflowClipboardText(text, currentClipboardVersion)
  } catch {
    return emptyClipboardReadResult
  }
}