@yh-ui/flow 0.1.21

package/dist/utils/theme.mjs

@@ -0,0 +1,217 @@
+export const flowTheme = {
+  // 节点样式
+  "flow-node-background": "#ffffff",
+  "flow-node-border": "#dcdfe6",
+  "flow-node-border-radius": "8px",
+  "flow-node-padding": "10px",
+  "flow-node-shadow": "0 2px 4px rgba(0, 0, 0, 0.1)",
+  "flow-node-selected-border": "#409eff",
+  "flow-node-selected-shadow": "0 0 8px rgba(64, 158, 255, 0.4)",
+  "flow-node-dragging-opacity": "0.8",
+  // 节点文字
+  "flow-node-label-color": "#303133",
+  "flow-node-label-font-size": "14px",
+  "flow-node-label-font-weight": "500",
+  "flow-node-description-color": "#909399",
+  "flow-node-description-font-size": "12px",
+  // 连接点（Handle）
+  "flow-handle-background": "#ffffff",
+  "flow-handle-border": "#409eff",
+  "flow-handle-border-radius": "50%",
+  "flow-handle-size": "12px",
+  "flow-handle-hover-background": "#409eff",
+  "flow-handle-connected-background": "#67c23a",
+  // 连线样式
+  "flow-edge-stroke": "#b1b3b8",
+  "flow-edge-stroke-width": "2",
+  "flow-edge-selected-stroke": "#409eff",
+  "flow-edge-animated-stroke": "#409eff",
+  "flow-edge-label-background": "#ffffff",
+  "flow-edge-label-color": "#606266",
+  // BPMN 节点
+  "flow-bpmn-start-fill": "#e6f7ed",
+  "flow-bpmn-start-stroke": "#67c23a",
+  "flow-bpmn-end-fill": "#fef0f0",
+  "flow-bpmn-end-stroke": "#f56c6c",
+  "flow-bpmn-task-fill": "#ecf5ff",
+  "flow-bpmn-task-stroke": "#409eff",
+  "flow-bpmn-gateway-fill": "#fdf6ec",
+  "flow-bpmn-gateway-stroke": "#e6a23c",
+  "flow-bpmn-gateway-color": "#e6a23c",
+  // AI 节点
+  "flow-ai-node-background": "#f0f9ff",
+  "flow-ai-node-border": "#0ea5e9",
+  "flow-ai-node-accent": "#0284c7",
+  // 背景
+  "flow-background-color": "#fafafa",
+  "flow-grid-color": "#e4e7ed",
+  "flow-grid-size": "20",
+  // 辅助线
+  "flow-alignment-line-color": "#c0c4cc",
+  "flow-alignment-line-active-color": "#409eff",
+  // 选框
+  "flow-selection-box-border": "#409eff",
+  "flow-selection-box-background": "rgba(64, 158, 255, 0.1)",
+  // 控制按钮
+  "flow-control-background": "#ffffff",
+  "flow-control-border": "#dcdfe6",
+  "flow-control-icon-color": "#606266",
+  "flow-control-hover-background": "#f5f7fa",
+  "flow-control-active-background": "#ecf5ff",
+  // 小地图
+  "flow-minimap-background": "#f5f7fa",
+  "flow-minimap-mask-background": "rgba(255, 255, 255, 0.8)",
+  "flow-minimap-node-color": "#c0c4cc",
+  "flow-minimap-viewport-border": "#409eff",
+  // 编辑面板
+  "flow-panel-background": "#ffffff",
+  "flow-panel-border": "#e4e7ed",
+  "flow-panel-shadow": "0 4px 12px rgba(0, 0, 0, 0.15)",
+  "flow-panel-header-background": "#fafafa",
+  "flow-panel-title-color": "#303133",
+  // 工具栏
+  "flow-toolbar-background": "#ffffff",
+  "flow-toolbar-border": "#e4e7ed",
+  "flow-toolbar-icon-color": "#606266",
+  "flow-toolbar-hover-background": "#f5f7fa",
+  "flow-toolbar-active-background": "#ecf5ff"
+};
+export const flowThemeDark = {
+  // 节点样式
+  "flow-node-background": "#1f1f1f",
+  "flow-node-border": "#3a3a3a",
+  "flow-node-border-radius": "8px",
+  "flow-node-padding": "10px",
+  "flow-node-shadow": "0 2px 8px rgba(0, 0, 0, 0.3)",
+  "flow-node-selected-border": "#409eff",
+  "flow-node-selected-shadow": "0 0 8px rgba(64, 158, 255, 0.5)",
+  "flow-node-dragging-opacity": "0.7",
+  // 节点文字
+  "flow-node-label-color": "#e5e5e5",
+  "flow-node-label-font-size": "14px",
+  "flow-node-label-font-weight": "500",
+  "flow-node-description-color": "#8c8c8c",
+  "flow-node-description-font-size": "12px",
+  // 连接点（Handle）
+  "flow-handle-background": "#262626",
+  "flow-handle-border": "#409eff",
+  "flow-handle-border-radius": "50%",
+  "flow-handle-size": "12px",
+  "flow-handle-hover-background": "#409eff",
+  "flow-handle-connected-background": "#67c23a",
+  // 连线样式
+  "flow-edge-stroke": "#5c5c5c",
+  "flow-edge-stroke-width": "2",
+  "flow-edge-selected-stroke": "#409eff",
+  "flow-edge-animated-stroke": "#409eff",
+  "flow-edge-label-background": "#1f1f1f",
+  "flow-edge-label-color": "#e5e5e5",
+  // BPMN 节点
+  "flow-bpmn-start-fill": "#1a2e1a",
+  "flow-bpmn-start-stroke": "#67c23a",
+  "flow-bpmn-end-fill": "#2e1a1a",
+  "flow-bpmn-end-stroke": "#f56c6c",
+  "flow-bpmn-task-fill": "#1a2a33",
+  "flow-bpmn-task-stroke": "#409eff",
+  "flow-bpmn-gateway-fill": "#2e2a1a",
+  "flow-bpmn-gateway-stroke": "#e6a23c",
+  "flow-bpmn-gateway-color": "#e6a23c",
+  // AI 节点
+  "flow-ai-node-background": "#1a1a2e",
+  "flow-ai-node-border": "#0ea5e9",
+  "flow-ai-node-accent": "#38bdf8",
+  // 背景
+  "flow-background-color": "#141414",
+  "flow-grid-color": "#2a2a2a",
+  "flow-grid-size": "20",
+  // 辅助线
+  "flow-alignment-line-color": "#404040",
+  "flow-alignment-line-active-color": "#409eff",
+  // 选框
+  "flow-selection-box-border": "#409eff",
+  "flow-selection-box-background": "rgba(64, 158, 255, 0.2)",
+  // 控制按钮
+  "flow-control-background": "#1f1f1f",
+  "flow-control-border": "#3a3a3a",
+  "flow-control-icon-color": "#8c8c8c",
+  "flow-control-hover-background": "#2a2a2a",
+  "flow-control-active-background": "#1a2a33",
+  // 小地图
+  "flow-minimap-background": "#1a1a1a",
+  "flow-minimap-mask-background": "rgba(0, 0, 0, 0.7)",
+  "flow-minimap-node-color": "#404040",
+  "flow-minimap-viewport-border": "#409eff",
+  // 编辑面板
+  "flow-panel-background": "#1f1f1f",
+  "flow-panel-border": "#3a3a3a",
+  "flow-panel-shadow": "0 4px 12px rgba(0, 0, 0, 0.5)",
+  "flow-panel-header-background": "#262626",
+  "flow-panel-title-color": "#e5e5e5",
+  // 工具栏
+  "flow-toolbar-background": "#1f1f1f",
+  "flow-toolbar-border": "#3a3a3a",
+  "flow-toolbar-icon-color": "#8c8c8c",
+  "flow-toolbar-hover-background": "#2a2a2a",
+  "flow-toolbar-active-background": "#1a2a33"
+};
+export function applyFlowTheme(theme, target = document) {
+  const root = target instanceof Document ? target.documentElement : target;
+  for (const [key, value] of Object.entries(theme)) {
+    root.style.setProperty(`--${key}`, value);
+  }
+}
+export function createCustomTheme(overrides) {
+  return { ...flowTheme, ...overrides };
+}
+export const flowThemePresets = {
+  default: flowTheme,
+  dark: flowThemeDark,
+  blue: createCustomTheme({
+    "flow-node-background": "#e6f7ff",
+    "flow-node-border": "#91d5ff",
+    "flow-node-selected-border": "#1890ff",
+    "flow-node-selected-shadow": "0 0 8px rgba(24, 144, 255, 0.4)",
+    "flow-handle-border": "#1890ff",
+    "flow-edge-selected-stroke": "#1890ff",
+    "flow-edge-animated-stroke": "#1890ff",
+    "flow-background-color": "#f0f7ff",
+    "flow-grid-color": "#d0e6ff",
+    "flow-bpmn-start-stroke": "#52c41a",
+    "flow-bpmn-task-stroke": "#1890ff",
+    "flow-bpmn-gateway-stroke": "#faad14",
+    "flow-ai-node-border": "#722ed1",
+    "flow-ai-node-accent": "#b37feb"
+  }),
+  green: createCustomTheme({
+    "flow-node-background": "#f6ffed",
+    "flow-node-border": "#b7eb8f",
+    "flow-node-selected-border": "#52c41a",
+    "flow-node-selected-shadow": "0 0 8px rgba(82, 196, 26, 0.4)",
+    "flow-handle-border": "#52c41a",
+    "flow-edge-selected-stroke": "#52c41a",
+    "flow-edge-animated-stroke": "#52c41a",
+    "flow-background-color": "#f6ffed",
+    "flow-grid-color": "#d9f7be",
+    "flow-bpmn-start-stroke": "#52c41a",
+    "flow-bpmn-task-stroke": "#1890ff",
+    "flow-bpmn-gateway-stroke": "#faad14",
+    "flow-ai-node-border": "#13c2c2",
+    "flow-ai-node-accent": "#36cfc9"
+  }),
+  purple: createCustomTheme({
+    "flow-node-background": "#f9f0ff",
+    "flow-node-border": "#d3adf7",
+    "flow-node-selected-border": "#722ed1",
+    "flow-node-selected-shadow": "0 0 8px rgba(114, 46, 209, 0.4)",
+    "flow-handle-border": "#722ed1",
+    "flow-edge-selected-stroke": "#722ed1",
+    "flow-edge-animated-stroke": "#722ed1",
+    "flow-background-color": "#f9f0ff",
+    "flow-grid-color": "#efdbff",
+    "flow-bpmn-start-stroke": "#52c41a",
+    "flow-bpmn-task-stroke": "#1890ff",
+    "flow-bpmn-gateway-stroke": "#faad14",
+    "flow-ai-node-border": "#722ed1",
+    "flow-ai-node-accent": "#b37feb"
+  })
+};

package/dist/utils/transform.cjs

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.canvasToScreen = canvasToScreen;
+exports.distanceBetweenPoints = distanceBetweenPoints;
+exports.getElementCanvasPosition = getElementCanvasPosition;
+exports.getElementPosition = getElementPosition;
+exports.getVector = getVector;
+exports.getVectorMagnitude = getVectorMagnitude;
+exports.normalizeVector = normalizeVector;
+exports.projectNodePosition = projectNodePosition;
+exports.screenToCanvas = screenToCanvas;
+exports.snapPositionToGrid = snapPositionToGrid;
+exports.snapToGrid = snapToGrid;
+function screenToCanvas(screenX, screenY, transform) {
+  return {
+    x: (screenX - transform.x) / transform.zoom,
+    y: (screenY - transform.y) / transform.zoom
+  };
+}
+function canvasToScreen(canvasX, canvasY, transform) {
+  return {
+    x: canvasX * transform.zoom + transform.x,
+    y: canvasY * transform.zoom + transform.y
+  };
+}
+function projectNodePosition(position, fromTransform, toTransform) {
+  const canvasPos = screenToCanvas(position.x, position.y, fromTransform);
+  return canvasToScreen(canvasPos.x, canvasPos.y, toTransform);
+}
+function getElementPosition(element, container) {
+  const containerRect = container.getBoundingClientRect();
+  const elementRect = element.getBoundingClientRect();
+  return {
+    x: elementRect.left - containerRect.left,
+    y: elementRect.top - containerRect.top
+  };
+}
+function getElementCanvasPosition(element, container, transform) {
+  const screenPos = getElementPosition(element, container);
+  return screenToCanvas(screenPos.x, screenPos.y, transform);
+}
+function distanceBetweenPoints(p1, p2) {
+  return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
+}
+function getVector(source, target) {
+  return {
+    x: target.x - source.x,
+    y: target.y - source.y
+  };
+}
+function getVectorMagnitude(vector) {
+  return Math.sqrt(vector.x * vector.x + vector.y * vector.y);
+}
+function normalizeVector(vector) {
+  const magnitude = getVectorMagnitude(vector);
+  if (magnitude === 0) return {
+    x: 0,
+    y: 0
+  };
+  return {
+    x: vector.x / magnitude,
+    y: vector.y / magnitude
+  };
+}
+function snapToGrid(value, grid) {
+  return Math.round(value / grid) * grid;
+}
+function snapPositionToGrid(position, grid) {
+  return {
+    x: snapToGrid(position.x, grid[0]),
+    y: snapToGrid(position.y, grid[1])
+  };
+}

package/dist/utils/transform.d.ts

@@ -0,0 +1,45 @@
+import type { Coordinate, ViewportTransform } from '../types';
+/**
+ * 屏幕坐标转换为画布坐标
+ */
+export declare function screenToCanvas(screenX: number, screenY: number, transform: ViewportTransform): Coordinate;
+/**
+ * 画布坐标转换为屏幕坐标
+ */
+export declare function canvasToScreen(canvasX: number, canvasY: number, transform: ViewportTransform): Coordinate;
+/**
+ * 将节点坐标从一个视口转换到另一个视口
+ */
+export declare function projectNodePosition(position: Coordinate, fromTransform: ViewportTransform, toTransform: ViewportTransform): Coordinate;
+/**
+ * 获取元素在屏幕上的位置
+ */
+export declare function getElementPosition(element: HTMLElement, container: HTMLElement): Coordinate;
+/**
+ * 获取元素在画布上的位置
+ */
+export declare function getElementCanvasPosition(element: HTMLElement, container: HTMLElement, transform: ViewportTransform): Coordinate;
+/**
+ * 计算两个位置之间的距离
+ */
+export declare function distanceBetweenPoints(p1: Coordinate, p2: Coordinate): number;
+/**
+ * 计算从源位置到目标位置的向量
+ */
+export declare function getVector(source: Coordinate, target: Coordinate): Coordinate;
+/**
+ * 获取向量的模（长度）
+ */
+export declare function getVectorMagnitude(vector: Coordinate): number;
+/**
+ * 归一化向量
+ */
+export declare function normalizeVector(vector: Coordinate): Coordinate;
+/**
+ * 将值吸附到网格
+ */
+export declare function snapToGrid(value: number, grid: number): number;
+/**
+ * 将坐标吸附到网格
+ */
+export declare function snapPositionToGrid(position: Coordinate, grid: [number, number]): Coordinate;

package/dist/utils/transform.mjs

@@ -0,0 +1,57 @@
+export function screenToCanvas(screenX, screenY, transform) {
+  return {
+    x: (screenX - transform.x) / transform.zoom,
+    y: (screenY - transform.y) / transform.zoom
+  };
+}
+export function canvasToScreen(canvasX, canvasY, transform) {
+  return {
+    x: canvasX * transform.zoom + transform.x,
+    y: canvasY * transform.zoom + transform.y
+  };
+}
+export function projectNodePosition(position, fromTransform, toTransform) {
+  const canvasPos = screenToCanvas(position.x, position.y, fromTransform);
+  return canvasToScreen(canvasPos.x, canvasPos.y, toTransform);
+}
+export function getElementPosition(element, container) {
+  const containerRect = container.getBoundingClientRect();
+  const elementRect = element.getBoundingClientRect();
+  return {
+    x: elementRect.left - containerRect.left,
+    y: elementRect.top - containerRect.top
+  };
+}
+export function getElementCanvasPosition(element, container, transform) {
+  const screenPos = getElementPosition(element, container);
+  return screenToCanvas(screenPos.x, screenPos.y, transform);
+}
+export function distanceBetweenPoints(p1, p2) {
+  return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
+}
+export function getVector(source, target) {
+  return {
+    x: target.x - source.x,
+    y: target.y - source.y
+  };
+}
+export function getVectorMagnitude(vector) {
+  return Math.sqrt(vector.x * vector.x + vector.y * vector.y);
+}
+export function normalizeVector(vector) {
+  const magnitude = getVectorMagnitude(vector);
+  if (magnitude === 0) return { x: 0, y: 0 };
+  return {
+    x: vector.x / magnitude,
+    y: vector.y / magnitude
+  };
+}
+export function snapToGrid(value, grid) {
+  return Math.round(value / grid) * grid;
+}
+export function snapPositionToGrid(position, grid) {
+  return {
+    x: snapToGrid(position.x, grid[0]),
+    y: snapToGrid(position.y, grid[1])
+  };
+}

package/dist/utils/validation.cjs

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createConnectionValidator = createConnectionValidator;
+exports.detectCycles = detectCycles;
+exports.isValidConnection = isValidConnection;
+function createConnectionValidator(rules) {
+  return connection => {
+    if (!rules || rules.length === 0) {
+      return true;
+    }
+    for (const rule of rules) {
+      const sourceMatches = matchesRule(connection.source, rule.source);
+      const targetMatches = matchesRule(connection.target, rule.target);
+      const sourceHandleMatches = matchesHandleRule(connection.sourceHandle, rule.sourceHandle);
+      const targetHandleMatches = matchesHandleRule(connection.targetHandle, rule.targetHandle);
+      if (sourceMatches && targetMatches && sourceHandleMatches && targetHandleMatches) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+function matchesRule(value, pattern) {
+  if (!pattern) return true;
+  if (Array.isArray(pattern)) {
+    return pattern.includes(value);
+  }
+  if (pattern === "*") return true;
+  try {
+    const regex = new RegExp(pattern);
+    return regex.test(value);
+  } catch {
+    return value === pattern;
+  }
+}
+function matchesHandleRule(handle, pattern) {
+  if (pattern === null || pattern === void 0) return true;
+  if (!handle && pattern) return false;
+  return matchesRule(handle, pattern);
+}
+function isValidConnection(sourceNode, targetNode, connection) {
+  if (!sourceNode) {
+    return {
+      isValid: false,
+      message: "Source node not found"
+    };
+  }
+  if (!targetNode) {
+    return {
+      isValid: false,
+      message: "Target node not found"
+    };
+  }
+  if (connection.source === connection.target) {
+    return {
+      isValid: false,
+      message: "Cannot connect to the same node"
+    };
+  }
+  if (connection.target === connection.source) {
+    return {
+      isValid: false,
+      message: "Cannot create self-loop"
+    };
+  }
+  return {
+    isValid: true
+  };
+}
+function detectCycles(edges, newEdge) {
+  const adjacencyList = /* @__PURE__ */new Map();
+  for (const edge of edges) {
+    if (!adjacencyList.has(edge.source)) {
+      adjacencyList.set(edge.source, []);
+    }
+    adjacencyList.get(edge.source).push(edge.target);
+  }
+  if (!adjacencyList.has(newEdge.source)) {
+    adjacencyList.set(newEdge.source, []);
+  }
+  adjacencyList.get(newEdge.source).push(newEdge.target);
+  const visited = /* @__PURE__ */new Set();
+  const recursionStack = /* @__PURE__ */new Set();
+  function hasCycle(node) {
+    visited.add(node);
+    recursionStack.add(node);
+    const neighbors = adjacencyList.get(node) || [];
+    for (const neighbor of neighbors) {
+      if (!visited.has(neighbor)) {
+        if (hasCycle(neighbor)) return true;
+      } else if (recursionStack.has(neighbor)) {
+        return true;
+      }
+    }
+    recursionStack.delete(node);
+    return false;
+  }
+  for (const node of adjacencyList.keys()) {
+    if (!visited.has(node)) {
+      if (hasCycle(node)) return true;
+    }
+  }
+  return false;
+}

package/dist/utils/validation.d.ts

@@ -0,0 +1,29 @@
+import type { Node, Edge } from '../types';
+export type ConnectionType = 'default' | 'loop' | 'step' | 'custom';
+export interface ConnectionRule {
+    source: string | string[];
+    target: string | string[];
+    sourceHandle?: string | string[] | null;
+    targetHandle?: string | string[] | null;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    message?: string;
+}
+export type IsValidConnectionFn = (connection: {
+    source: string;
+    target: string;
+    sourceHandle?: string | null;
+    targetHandle?: string | null;
+}) => boolean;
+export declare function createConnectionValidator(rules?: ConnectionRule[]): IsValidConnectionFn;
+export declare function isValidConnection(sourceNode: Node | undefined, targetNode: Node | undefined, connection: {
+    source: string;
+    target: string;
+    sourceHandle?: string | null;
+    targetHandle?: string | null;
+}): ValidationResult;
+export declare function detectCycles(edges: Edge[], newEdge: {
+    source: string;
+    target: string;
+}): boolean;

package/dist/utils/validation.mjs

@@ -0,0 +1,85 @@
+export function createConnectionValidator(rules) {
+  return (connection) => {
+    if (!rules || rules.length === 0) {
+      return true;
+    }
+    for (const rule of rules) {
+      const sourceMatches = matchesRule(connection.source, rule.source);
+      const targetMatches = matchesRule(connection.target, rule.target);
+      const sourceHandleMatches = matchesHandleRule(connection.sourceHandle, rule.sourceHandle);
+      const targetHandleMatches = matchesHandleRule(connection.targetHandle, rule.targetHandle);
+      if (sourceMatches && targetMatches && sourceHandleMatches && targetHandleMatches) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+function matchesRule(value, pattern) {
+  if (!pattern) return true;
+  if (Array.isArray(pattern)) {
+    return pattern.includes(value);
+  }
+  if (pattern === "*") return true;
+  try {
+    const regex = new RegExp(pattern);
+    return regex.test(value);
+  } catch {
+    return value === pattern;
+  }
+}
+function matchesHandleRule(handle, pattern) {
+  if (pattern === null || pattern === void 0) return true;
+  if (!handle && pattern) return false;
+  return matchesRule(handle, pattern);
+}
+export function isValidConnection(sourceNode, targetNode, connection) {
+  if (!sourceNode) {
+    return { isValid: false, message: "Source node not found" };
+  }
+  if (!targetNode) {
+    return { isValid: false, message: "Target node not found" };
+  }
+  if (connection.source === connection.target) {
+    return { isValid: false, message: "Cannot connect to the same node" };
+  }
+  if (connection.target === connection.source) {
+    return { isValid: false, message: "Cannot create self-loop" };
+  }
+  return { isValid: true };
+}
+export function detectCycles(edges, newEdge) {
+  const adjacencyList = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (!adjacencyList.has(edge.source)) {
+      adjacencyList.set(edge.source, []);
+    }
+    adjacencyList.get(edge.source).push(edge.target);
+  }
+  if (!adjacencyList.has(newEdge.source)) {
+    adjacencyList.set(newEdge.source, []);
+  }
+  adjacencyList.get(newEdge.source).push(newEdge.target);
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  function hasCycle(node) {
+    visited.add(node);
+    recursionStack.add(node);
+    const neighbors = adjacencyList.get(node) || [];
+    for (const neighbor of neighbors) {
+      if (!visited.has(neighbor)) {
+        if (hasCycle(neighbor)) return true;
+      } else if (recursionStack.has(neighbor)) {
+        return true;
+      }
+    }
+    recursionStack.delete(node);
+    return false;
+  }
+  for (const node of adjacencyList.keys()) {
+    if (!visited.has(node)) {
+      if (hasCycle(node)) return true;
+    }
+  }
+  return false;
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@yh-ui/flow",
+  "version": "0.1.21",
+  "description": "YH-UI High-performance Flow Chart Component",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.mjs",
+      "require": "./dist/*.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@yh-ui/utils": "0.1.21",
+    "@yh-ui/hooks": "0.1.21"
+  },
+  "devDependencies": {
+    "vue": "^3.5.27",
+    "vue-tsc": "^2.2.0"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.27"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/1079161148/yh-ui.git",
+    "directory": "packages/flow"
+  },
+  "keywords": [
+    "yh-ui",
+    "flow",
+    "flow-chart",
+    "node-editor",
+    "vue-flow",
+    "diagram"
+  ],
+  "homepage": "https://1079161148.github.io/yh-ui/",
+  "author": "YH-UI Team",
+  "license": "MIT",
+  "scripts": {
+    "build": "unbuild",
+    "dev": "unbuild --stub",
+    "typecheck": "vue-tsc --noEmit",
+    "lint": "eslint ."
+  }
+}