@yh-ui/flow 0.1.21

package/dist/utils/graph.cjs

@@ -0,0 +1,158 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bfs = bfs;
+exports.dfs = dfs;
+exports.findAllPaths = findAllPaths;
+exports.findConnectedComponents = findConnectedComponents;
+exports.hasCycle = hasCycle;
+exports.topologicalSort = topologicalSort;
+function hasCycle(edges, startNodeId, visited = /* @__PURE__ */new Set(), recursionStack = /* @__PURE__ */new Set()) {
+  visited.add(startNodeId);
+  recursionStack.add(startNodeId);
+  const outgoingEdges = edges.filter(e => e.source === startNodeId);
+  for (const edge of outgoingEdges) {
+    if (!visited.has(edge.target)) {
+      if (hasCycle(edges, edge.target, visited, recursionStack)) {
+        return true;
+      }
+    } else if (recursionStack.has(edge.target)) {
+      return true;
+    }
+  }
+  recursionStack.delete(startNodeId);
+  return false;
+}
+function topologicalSort(nodes, edges) {
+  const inDegree = /* @__PURE__ */new Map();
+  const adjacency = /* @__PURE__ */new Map();
+  for (const node of nodes) {
+    inDegree.set(node.id, 0);
+    adjacency.set(node.id, []);
+  }
+  for (const edge of edges) {
+    const current = inDegree.get(edge.target) || 0;
+    inDegree.set(edge.target, current + 1);
+    const adj = adjacency.get(edge.source) || [];
+    adj.push(edge.target);
+    adjacency.set(edge.source, adj);
+  }
+  const queue = [];
+  for (const [nodeId, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(nodeId);
+    }
+  }
+  const result = [];
+  while (queue.length > 0) {
+    const nodeId = queue.shift();
+    result.push(nodeId);
+    const neighbors = adjacency.get(nodeId) || [];
+    for (const neighbor of neighbors) {
+      const degree = inDegree.get(neighbor) - 1;
+      inDegree.set(neighbor, degree);
+      if (degree === 0) {
+        queue.push(neighbor);
+      }
+    }
+  }
+  return result;
+}
+function findAllPaths(edges, startId, endId) {
+  const adjacency = /* @__PURE__ */new Map();
+  for (const edge of edges) {
+    const adj = adjacency.get(edge.source) || [];
+    adj.push(edge.target);
+    adjacency.set(edge.source, adj);
+  }
+  const paths = [];
+  const currentPath = [];
+  function dfs2(node) {
+    currentPath.push(node);
+    if (node === endId) {
+      paths.push([...currentPath]);
+    } else {
+      const neighbors = adjacency.get(node) || [];
+      for (const neighbor of neighbors) {
+        if (!currentPath.includes(neighbor)) {
+          dfs2(neighbor);
+        }
+      }
+    }
+    currentPath.pop();
+  }
+  dfs2(startId);
+  return paths;
+}
+function findConnectedComponents(nodes, edges) {
+  const adjacency = /* @__PURE__ */new Map();
+  for (const node of nodes) {
+    adjacency.set(node.id, []);
+  }
+  for (const edge of edges) {
+    const sourceAdj = adjacency.get(edge.source) || [];
+    sourceAdj.push(edge.target);
+    adjacency.set(edge.source, sourceAdj);
+    const targetAdj = adjacency.get(edge.target) || [];
+    targetAdj.push(edge.source);
+    adjacency.set(edge.target, targetAdj);
+  }
+  const visited = /* @__PURE__ */new Set();
+  const components = [];
+  for (const node of nodes) {
+    if (!visited.has(node.id)) {
+      const component = [];
+      const queue = [node.id];
+      while (queue.length > 0) {
+        const current = queue.shift();
+        if (!visited.has(current)) {
+          visited.add(current);
+          component.push(current);
+          const neighbors = adjacency.get(current) || [];
+          for (const neighbor of neighbors) {
+            if (!visited.has(neighbor)) {
+              queue.push(neighbor);
+            }
+          }
+        }
+      }
+      components.push(component);
+    }
+  }
+  return components;
+}
+function bfs(adjacency, startId) {
+  const visited = /* @__PURE__ */new Set([startId]);
+  const queue = [startId];
+  const result = [];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    result.push(node);
+    const neighbors = adjacency.get(node) || [];
+    for (const neighbor of neighbors) {
+      if (!visited.has(neighbor)) {
+        visited.add(neighbor);
+        queue.push(neighbor);
+      }
+    }
+  }
+  return result;
+}
+function dfs(adjacency, startId) {
+  const visited = /* @__PURE__ */new Set();
+  const result = [];
+  function _dfs(node) {
+    visited.add(node);
+    result.push(node);
+    const neighbors = adjacency.get(node) || [];
+    for (const neighbor of neighbors) {
+      if (!visited.has(neighbor)) {
+        _dfs(neighbor);
+      }
+    }
+  }
+  _dfs(startId);
+  return result;
+}

package/dist/utils/graph.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 检查图中是否存在环
+ */
+export declare function hasCycle(edges: {
+    source: string;
+    target: string;
+}[], startNodeId: string, visited?: Set<string>, recursionStack?: Set<string>): boolean;
+/**
+ * 拓扑排序
+ */
+export declare function topologicalSort(nodes: {
+    id: string;
+}[], edges: {
+    source: string;
+    target: string;
+}[]): string[];
+/**
+ * 查找两个节点之间的所有路径
+ */
+export declare function findAllPaths(edges: {
+    source: string;
+    target: string;
+}[], startId: string, endId: string): string[][];
+/**
+ * 查找图中所有连通分量
+ */
+export declare function findConnectedComponents(nodes: {
+    id: string;
+}[], edges: {
+    source: string;
+    target: string;
+}[]): string[][];
+/**
+ * 广度优先搜索
+ */
+export declare function bfs(adjacency: Map<string, string[]>, startId: string): string[];
+/**
+ * 深度优先搜索
+ */
+export declare function dfs(adjacency: Map<string, string[]>, startId: string): string[];

package/dist/utils/graph.mjs

@@ -0,0 +1,147 @@
+export function hasCycle(edges, startNodeId, visited = /* @__PURE__ */ new Set(), recursionStack = /* @__PURE__ */ new Set()) {
+  visited.add(startNodeId);
+  recursionStack.add(startNodeId);
+  const outgoingEdges = edges.filter((e) => e.source === startNodeId);
+  for (const edge of outgoingEdges) {
+    if (!visited.has(edge.target)) {
+      if (hasCycle(edges, edge.target, visited, recursionStack)) {
+        return true;
+      }
+    } else if (recursionStack.has(edge.target)) {
+      return true;
+    }
+  }
+  recursionStack.delete(startNodeId);
+  return false;
+}
+export function topologicalSort(nodes, edges) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    inDegree.set(node.id, 0);
+    adjacency.set(node.id, []);
+  }
+  for (const edge of edges) {
+    const current = inDegree.get(edge.target) || 0;
+    inDegree.set(edge.target, current + 1);
+    const adj = adjacency.get(edge.source) || [];
+    adj.push(edge.target);
+    adjacency.set(edge.source, adj);
+  }
+  const queue = [];
+  for (const [nodeId, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(nodeId);
+    }
+  }
+  const result = [];
+  while (queue.length > 0) {
+    const nodeId = queue.shift();
+    result.push(nodeId);
+    const neighbors = adjacency.get(nodeId) || [];
+    for (const neighbor of neighbors) {
+      const degree = inDegree.get(neighbor) - 1;
+      inDegree.set(neighbor, degree);
+      if (degree === 0) {
+        queue.push(neighbor);
+      }
+    }
+  }
+  return result;
+}
+export function findAllPaths(edges, startId, endId) {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const adj = adjacency.get(edge.source) || [];
+    adj.push(edge.target);
+    adjacency.set(edge.source, adj);
+  }
+  const paths = [];
+  const currentPath = [];
+  function dfs2(node) {
+    currentPath.push(node);
+    if (node === endId) {
+      paths.push([...currentPath]);
+    } else {
+      const neighbors = adjacency.get(node) || [];
+      for (const neighbor of neighbors) {
+        if (!currentPath.includes(neighbor)) {
+          dfs2(neighbor);
+        }
+      }
+    }
+    currentPath.pop();
+  }
+  dfs2(startId);
+  return paths;
+}
+export function findConnectedComponents(nodes, edges) {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    adjacency.set(node.id, []);
+  }
+  for (const edge of edges) {
+    const sourceAdj = adjacency.get(edge.source) || [];
+    sourceAdj.push(edge.target);
+    adjacency.set(edge.source, sourceAdj);
+    const targetAdj = adjacency.get(edge.target) || [];
+    targetAdj.push(edge.source);
+    adjacency.set(edge.target, targetAdj);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const components = [];
+  for (const node of nodes) {
+    if (!visited.has(node.id)) {
+      const component = [];
+      const queue = [node.id];
+      while (queue.length > 0) {
+        const current = queue.shift();
+        if (!visited.has(current)) {
+          visited.add(current);
+          component.push(current);
+          const neighbors = adjacency.get(current) || [];
+          for (const neighbor of neighbors) {
+            if (!visited.has(neighbor)) {
+              queue.push(neighbor);
+            }
+          }
+        }
+      }
+      components.push(component);
+    }
+  }
+  return components;
+}
+export function bfs(adjacency, startId) {
+  const visited = /* @__PURE__ */ new Set([startId]);
+  const queue = [startId];
+  const result = [];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    result.push(node);
+    const neighbors = adjacency.get(node) || [];
+    for (const neighbor of neighbors) {
+      if (!visited.has(neighbor)) {
+        visited.add(neighbor);
+        queue.push(neighbor);
+      }
+    }
+  }
+  return result;
+}
+export function dfs(adjacency, startId) {
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  function _dfs(node) {
+    visited.add(node);
+    result.push(node);
+    const neighbors = adjacency.get(node) || [];
+    for (const neighbor of neighbors) {
+      if (!visited.has(neighbor)) {
+        _dfs(neighbor);
+      }
+    }
+  }
+  _dfs(startId);
+  return result;
+}

package/dist/utils/index.cjs

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _transform = require("./transform.cjs");
+Object.keys(_transform).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _transform[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _transform[key];
+    }
+  });
+});
+var _edge = require("./edge.cjs");
+Object.keys(_edge).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _edge[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _edge[key];
+    }
+  });
+});
+var _graph = require("./graph.cjs");
+Object.keys(_graph).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _graph[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _graph[key];
+    }
+  });
+});
+var _geometry = require("./geometry.cjs");
+Object.keys(_geometry).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _geometry[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _geometry[key];
+    }
+  });
+});
+var _validation = require("./validation.cjs");
+Object.keys(_validation).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _validation[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _validation[key];
+    }
+  });
+});
+var _customTypes = require("./custom-types.cjs");
+Object.keys(_customTypes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _customTypes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _customTypes[key];
+    }
+  });
+});
+var _performance = require("./performance.cjs");
+Object.keys(_performance).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _performance[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _performance[key];
+    }
+  });
+});
+var _screenshot = require("./screenshot.cjs");
+Object.keys(_screenshot).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _screenshot[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _screenshot[key];
+    }
+  });
+});
+var _bpmn = require("./bpmn.cjs");
+Object.keys(_bpmn).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _bpmn[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _bpmn[key];
+    }
+  });
+});
+var _bpmnEngine = require("./bpmn-engine.cjs");
+Object.keys(_bpmnEngine).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _bpmnEngine[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _bpmnEngine[key];
+    }
+  });
+});
+var _theme = require("./theme.cjs");
+Object.keys(_theme).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _theme[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _theme[key];
+    }
+  });
+});
+var _collaboration = require("./collaboration.cjs");
+Object.keys(_collaboration).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _collaboration[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _collaboration[key];
+    }
+  });
+});

package/dist/utils/index.d.ts

@@ -0,0 +1,12 @@
+export * from './transform';
+export * from './edge';
+export * from './graph';
+export * from './geometry';
+export * from './validation';
+export * from './custom-types';
+export * from './performance';
+export * from './screenshot';
+export * from './bpmn';
+export * from './bpmn-engine';
+export * from './theme';
+export * from './collaboration';

package/dist/utils/index.mjs

@@ -0,0 +1,12 @@
+export * from "./transform.mjs";
+export * from "./edge.mjs";
+export * from "./graph.mjs";
+export * from "./geometry.mjs";
+export * from "./validation.mjs";
+export * from "./custom-types.mjs";
+export * from "./performance.mjs";
+export * from "./screenshot.mjs";
+export * from "./bpmn.mjs";
+export * from "./bpmn-engine.mjs";
+export * from "./theme.mjs";
+export * from "./collaboration.mjs";

package/dist/utils/performance.cjs

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ReactiveGraph = void 0;
+exports.clearMemoCache = clearMemoCache;
+exports.debounce = debounce;
+exports.generateId = generateId;
+exports.memo = memo;
+exports.throttle = throttle;
+var _vue = require("vue");
+class ReactiveGraph {
+  _nodes = (0, _vue.shallowRef)([]);
+  _edges = (0, _vue.shallowRef)([]);
+  get nodes() {
+    return this._nodes.value;
+  }
+  set nodes(value) {
+    this._nodes.value = value;
+  }
+  get edges() {
+    return this._edges.value;
+  }
+  set edges(value) {
+    this._edges.value = value;
+  }
+  // Get edges connected to a specific node
+  getConnectedEdges(nodeId) {
+    return this._edges.value.filter(e => e.source === nodeId || e.target === nodeId);
+  }
+  // Get nodes connected to a specific node
+  getConnectedNodes(nodeId) {
+    const connectedIds = /* @__PURE__ */new Set();
+    const edges = this.getConnectedEdges(nodeId);
+    for (const edge of edges) {
+      if (edge.source === nodeId) {
+        connectedIds.add(edge.target);
+      } else {
+        connectedIds.add(edge.source);
+      }
+    }
+    return this._nodes.value.filter(n => connectedIds.has(n.id));
+  }
+  // Batch update nodes without triggering multiple renders
+  batchUpdateNodes(updater) {
+    this._nodes.value = updater(this._nodes.value);
+  }
+  // Batch update edges without triggering multiple renders
+  batchUpdateEdges(updater) {
+    this._edges.value = updater(this._edges.value);
+  }
+}
+exports.ReactiveGraph = ReactiveGraph;
+let idCounter = 0;
+function generateId(prefix = "id") {
+  return `${prefix}-${Date.now()}-${++idCounter}`;
+}
+function debounce(fn, delay) {
+  let timeoutId = null;
+  return (...args) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn(...args);
+      timeoutId = null;
+    }, delay);
+  };
+}
+function throttle(fn, limit) {
+  let inThrottle = false;
+  return (...args) => {
+    if (!inThrottle) {
+      fn(...args);
+      inThrottle = true;
+      setTimeout(() => {
+        inThrottle = false;
+      }, limit);
+    }
+  };
+}
+const memoCache = /* @__PURE__ */new Map();
+function memo(key, fn) {
+  if (memoCache.has(key)) {
+    return memoCache.get(key);
+  }
+  const result = fn();
+  memoCache.set(key, result);
+  return result;
+}
+function clearMemoCache() {
+  memoCache.clear();
+}

package/dist/utils/performance.d.ts

@@ -0,0 +1,18 @@
+import type { Node, Edge } from '../types';
+export declare class ReactiveGraph<N extends Node = Node, E extends Edge = Edge> {
+    private _nodes;
+    private _edges;
+    get nodes(): N[];
+    set nodes(value: N[]);
+    get edges(): E[];
+    set edges(value: E[]);
+    getConnectedEdges(nodeId: string): E[];
+    getConnectedNodes(nodeId: string): N[];
+    batchUpdateNodes(updater: (nodes: N[]) => N[]): void;
+    batchUpdateEdges(updater: (edges: E[]) => E[]): void;
+}
+export declare function generateId(prefix?: string): string;
+export declare function debounce<T extends (...args: unknown[]) => void>(fn: T, delay: number): (...args: Parameters<T>) => void;
+export declare function throttle<T extends (...args: unknown[]) => void>(fn: T, limit: number): (...args: Parameters<T>) => void;
+export declare function memo<T>(key: string, fn: () => T): T;
+export declare function clearMemoCache(): void;

package/dist/utils/performance.mjs

@@ -0,0 +1,82 @@
+import { shallowRef } from "vue";
+export class ReactiveGraph {
+  _nodes = shallowRef([]);
+  _edges = shallowRef([]);
+  get nodes() {
+    return this._nodes.value;
+  }
+  set nodes(value) {
+    this._nodes.value = value;
+  }
+  get edges() {
+    return this._edges.value;
+  }
+  set edges(value) {
+    this._edges.value = value;
+  }
+  // Get edges connected to a specific node
+  getConnectedEdges(nodeId) {
+    return this._edges.value.filter((e) => e.source === nodeId || e.target === nodeId);
+  }
+  // Get nodes connected to a specific node
+  getConnectedNodes(nodeId) {
+    const connectedIds = /* @__PURE__ */ new Set();
+    const edges = this.getConnectedEdges(nodeId);
+    for (const edge of edges) {
+      if (edge.source === nodeId) {
+        connectedIds.add(edge.target);
+      } else {
+        connectedIds.add(edge.source);
+      }
+    }
+    return this._nodes.value.filter((n) => connectedIds.has(n.id));
+  }
+  // Batch update nodes without triggering multiple renders
+  batchUpdateNodes(updater) {
+    this._nodes.value = updater(this._nodes.value);
+  }
+  // Batch update edges without triggering multiple renders
+  batchUpdateEdges(updater) {
+    this._edges.value = updater(this._edges.value);
+  }
+}
+let idCounter = 0;
+export function generateId(prefix = "id") {
+  return `${prefix}-${Date.now()}-${++idCounter}`;
+}
+export function debounce(fn, delay) {
+  let timeoutId = null;
+  return (...args) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn(...args);
+      timeoutId = null;
+    }, delay);
+  };
+}
+export function throttle(fn, limit) {
+  let inThrottle = false;
+  return (...args) => {
+    if (!inThrottle) {
+      fn(...args);
+      inThrottle = true;
+      setTimeout(() => {
+        inThrottle = false;
+      }, limit);
+    }
+  };
+}
+const memoCache = /* @__PURE__ */ new Map();
+export function memo(key, fn) {
+  if (memoCache.has(key)) {
+    return memoCache.get(key);
+  }
+  const result = fn();
+  memoCache.set(key, result);
+  return result;
+}
+export function clearMemoCache() {
+  memoCache.clear();
+}