@yh-ui/flow 0.1.21

package/dist/utils/event-bus.cjs

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EventBus = void 0;
+exports.createEventBus = createEventBus;
+exports.getEventBus = getEventBus;
+class EventBus {
+  handlers = /* @__PURE__ */new Map();
+  /**
+   * 订阅事件
+   */
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */new Set());
+    }
+    this.handlers.get(event).add(handler);
+  }
+  /**
+   * 取消订阅
+   */
+  off(event, handler) {
+    const handlers = this.handlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.handlers.delete(event);
+      }
+    }
+  }
+  /**
+   * 触发事件
+   */
+  emit(event, payload) {
+    const handlers = this.handlers.get(event);
+    if (handlers) {
+      handlers.forEach(handler => {
+        try {
+          if (payload !== void 0) {
+            handler(payload);
+          } else {
+            handler();
+          }
+        } catch (error) {
+          console.error(`[YhFlow EventBus] Error in event handler for "${event}":`, error);
+        }
+      });
+    }
+  }
+  /**
+   * 单次订阅
+   */
+  once(event, handler) {
+    const wrappedHandler = (...args) => {
+      handler(...args);
+      this.off(event, handler);
+    };
+    this.on(event, wrappedHandler);
+  }
+  /**
+   * 清空所有事件处理函数
+   */
+  clear() {
+    this.handlers.clear();
+  }
+  /**
+   * 获取事件处理器数量
+   */
+  listenerCount(event) {
+    if (event) {
+      return this.handlers.get(event)?.size || 0;
+    }
+    let total = 0;
+    this.handlers.forEach(handlers => {
+      total += handlers.size;
+    });
+    return total;
+  }
+}
+exports.EventBus = EventBus;
+let eventBusInstance = null;
+function getEventBus() {
+  if (!eventBusInstance) {
+    eventBusInstance = new EventBus();
+  }
+  return eventBusInstance;
+}
+function createEventBus() {
+  return new EventBus();
+}

package/dist/utils/event-bus.d.ts

@@ -0,0 +1,39 @@
+import type { FlowEventKey, FlowEventHandler, FlowEvents } from '../types';
+/**
+ * 简单事件总线实现 - 用于 Flow 组件内部和插件系统
+ */
+export declare class EventBus {
+    private handlers;
+    /**
+     * 订阅事件
+     */
+    on<K extends FlowEventKey>(event: K, handler: FlowEventHandler<K>): void;
+    /**
+     * 取消订阅
+     */
+    off<K extends FlowEventKey>(event: K, handler: FlowEventHandler<K>): void;
+    /**
+     * 触发事件
+     */
+    emit<K extends FlowEventKey>(event: K, payload?: FlowEvents[K]): void;
+    /**
+     * 单次订阅
+     */
+    once<K extends FlowEventKey>(event: K, handler: FlowEventHandler<K>): void;
+    /**
+     * 清空所有事件处理函数
+     */
+    clear(): void;
+    /**
+     * 获取事件处理器数量
+     */
+    listenerCount(event?: FlowEventKey): number;
+}
+/**
+ * 获取事件总线单例
+ */
+export declare function getEventBus(): EventBus;
+/**
+ * 创建新的事件总线实例
+ */
+export declare function createEventBus(): EventBus;

package/dist/utils/event-bus.mjs

@@ -0,0 +1,82 @@
+export class EventBus {
+  handlers = /* @__PURE__ */ new Map();
+  /**
+   * 订阅事件
+   */
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(event).add(handler);
+  }
+  /**
+   * 取消订阅
+   */
+  off(event, handler) {
+    const handlers = this.handlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.handlers.delete(event);
+      }
+    }
+  }
+  /**
+   * 触发事件
+   */
+  emit(event, payload) {
+    const handlers = this.handlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          if (payload !== void 0) {
+            handler(payload);
+          } else {
+            handler();
+          }
+        } catch (error) {
+          console.error(`[YhFlow EventBus] Error in event handler for "${event}":`, error);
+        }
+      });
+    }
+  }
+  /**
+   * 单次订阅
+   */
+  once(event, handler) {
+    const wrappedHandler = ((...args) => {
+      handler(...args);
+      this.off(event, handler);
+    });
+    this.on(event, wrappedHandler);
+  }
+  /**
+   * 清空所有事件处理函数
+   */
+  clear() {
+    this.handlers.clear();
+  }
+  /**
+   * 获取事件处理器数量
+   */
+  listenerCount(event) {
+    if (event) {
+      return this.handlers.get(event)?.size || 0;
+    }
+    let total = 0;
+    this.handlers.forEach((handlers) => {
+      total += handlers.size;
+    });
+    return total;
+  }
+}
+let eventBusInstance = null;
+export function getEventBus() {
+  if (!eventBusInstance) {
+    eventBusInstance = new EventBus();
+  }
+  return eventBusInstance;
+}
+export function createEventBus() {
+  return new EventBus();
+}

package/dist/utils/geometry.cjs

@@ -0,0 +1,178 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.angleToCanvasCoordinateSystem = angleToCanvasCoordinateSystem;
+exports.degToRad = degToRad;
+exports.getAngle = getAngle;
+exports.getAngleBetweenPoints = getAngleBetweenPoints;
+exports.getBoundingBox = getBoundingBox;
+exports.getLineIntersection = getLineIntersection;
+exports.getNodeBounds = getNodeBounds;
+exports.getRectIntersection = getRectIntersection;
+exports.isPointInPolygon = isPointInPolygon;
+exports.isPointInRect = isPointInRect;
+exports.pointToLineDistance = pointToLineDistance;
+exports.pointToPointDistance = pointToPointDistance;
+exports.pointToRectDistance = pointToRectDistance;
+exports.radToDeg = radToDeg;
+exports.rectIntersect = rectIntersect;
+exports.viewportIntersectsBounds = viewportIntersectsBounds;
+function isPointInRect(point, rect) {
+  return point.x >= rect.x && point.x <= rect.x + rect.width && point.y >= rect.y && point.y <= rect.y + rect.height;
+}
+function rectIntersect(rect1, rect2) {
+  return !(rect1.x + rect1.width < rect2.x || rect2.x + rect2.width < rect1.x || rect1.y + rect1.height < rect2.y || rect2.y + rect2.height < rect1.y);
+}
+function getRectIntersection(rect1, rect2) {
+  if (!rectIntersect(rect1, rect2)) {
+    return null;
+  }
+  const x = Math.max(rect1.x, rect2.x);
+  const y = Math.max(rect1.y, rect2.y);
+  const width = Math.min(rect1.x + rect1.width, rect2.x + rect2.x) - x;
+  const height = Math.min(rect1.y + rect1.height, rect2.y + rect2.height) - y;
+  return {
+    x,
+    y,
+    width,
+    height
+  };
+}
+function getBoundingBox(points) {
+  if (points.length === 0) {
+    return {
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0
+    };
+  }
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const point of points) {
+    minX = Math.min(minX, point.x);
+    minY = Math.min(minY, point.y);
+    maxX = Math.max(maxX, point.x);
+    maxY = Math.max(maxY, point.y);
+  }
+  return {
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
+}
+function getNodeBounds(nodes) {
+  const points = nodes.flatMap(node => {
+    const w = node.width || 0;
+    const h = node.height || 0;
+    return [{
+      x: node.position.x,
+      y: node.position.y
+    }, {
+      x: node.position.x + w,
+      y: node.position.y + h
+    }];
+  });
+  return getBoundingBox(points);
+}
+function pointToLineDistance(point, lineStart, lineEnd) {
+  const A = point.x - lineStart.x;
+  const B = point.y - lineStart.y;
+  const C = lineEnd.x - lineStart.x;
+  const D = lineEnd.y - lineStart.y;
+  const dot = A * C + B * D;
+  const lenSq = C * C + D * D;
+  let param = -1;
+  if (lenSq !== 0) {
+    param = dot / lenSq;
+  }
+  let xx;
+  let yy;
+  if (param < 0) {
+    xx = lineStart.x;
+    yy = lineStart.y;
+  } else if (param > 1) {
+    xx = lineEnd.x;
+    yy = lineEnd.y;
+  } else {
+    xx = lineStart.x + param * C;
+    yy = lineStart.y + param * D;
+  }
+  const dx = point.x - xx;
+  const dy = point.y - yy;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function pointToPointDistance(p1, p2) {
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function degToRad(deg) {
+  return deg * Math.PI / 180;
+}
+function radToDeg(rad) {
+  return rad * 180 / Math.PI;
+}
+function getLineIntersection(line1Start, line1End, line2Start, line2End) {
+  const d1x = line1End.x - line1Start.x;
+  const d1y = line1End.y - line1Start.y;
+  const d2x = line2End.x - line2Start.x;
+  const d2y = line2End.y - line2Start.y;
+  const cross = d1x * d2y - d1y * d2x;
+  if (Math.abs(cross) < 1e-10) {
+    return null;
+  }
+  const d = {
+    x: line1Start.x - line2Start.x,
+    y: line1Start.y - line2Start.y
+  };
+  const t = (d.x * d2y - d.y * d2x) / cross;
+  return {
+    x: line1Start.x + t * d1x,
+    y: line1Start.y + t * d1y
+  };
+}
+function getAngle(from, to) {
+  return Math.atan2(to.y - from.y, to.x - from.x);
+}
+function getAngleBetweenPoints(p1, p2, origin) {
+  return Math.atan2(p2.y - origin.y, p2.x - origin.x) - Math.atan2(p1.y - origin.y, p1.x - origin.x);
+}
+function angleToCanvasCoordinateSystem(angle) {
+  return -angle;
+}
+function isPointInPolygon(point, polygon) {
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const xi = polygon[i].x;
+    const yi = polygon[i].y;
+    const xj = polygon[j].x;
+    const yj = polygon[j].y;
+    const intersect = yi > point.y !== yj > point.y && point.x < (xj - xi) * (point.y - yi) / (yj - yi) + xi;
+    if (intersect) {
+      inside = !inside;
+    }
+  }
+  return inside;
+}
+function pointToRectDistance(point, rect) {
+  const rectRight = rect.x + rect.width;
+  const rectBottom = rect.y + rect.height;
+  const dx = Math.max(rect.x - point.x, 0, point.x - rectRight);
+  const dy = Math.max(rect.y - point.y, 0, point.y - rectBottom);
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function viewportIntersectsBounds(viewport, bounds, zoom) {
+  const scaledBounds = {
+    x: bounds.x * zoom,
+    y: bounds.y * zoom,
+    width: bounds.width * zoom,
+    height: bounds.height * zoom
+  };
+  return rectIntersect(viewport, scaledBounds);
+}

package/dist/utils/geometry.d.ts

@@ -0,0 +1,186 @@
+/**
+ * 判断点是否在矩形内
+ */
+export declare function isPointInRect(point: {
+    x: number;
+    y: number;
+}, rect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): boolean;
+/**
+ * 判断两个矩形是否相交
+ */
+export declare function rectIntersect(rect1: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, rect2: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): boolean;
+/**
+ * 获取两个矩形的交集
+ */
+export declare function getRectIntersection(rect1: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, rect2: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;
+/**
+ * 获取包含多个点的最小矩形
+ */
+export declare function getBoundingBox(points: {
+    x: number;
+    y: number;
+}[]): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * 获取节点边界框
+ */
+export declare function getNodeBounds(nodes: {
+    position: {
+        x: number;
+        y: number;
+    };
+    width?: number;
+    height?: number;
+}[]): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * 计算点到直线的距离
+ */
+export declare function pointToLineDistance(point: {
+    x: number;
+    y: number;
+}, lineStart: {
+    x: number;
+    y: number;
+}, lineEnd: {
+    x: number;
+    y: number;
+}): number;
+/**
+ * 计算点到点的距离
+ */
+export declare function pointToPointDistance(p1: {
+    x: number;
+    y: number;
+}, p2: {
+    x: number;
+    y: number;
+}): number;
+/**
+ * 角度转弧度
+ */
+export declare function degToRad(deg: number): number;
+/**
+ * 弧度转角度
+ */
+export declare function radToDeg(rad: number): number;
+/**
+ * 计算两条线的交点
+ */
+export declare function getLineIntersection(line1Start: {
+    x: number;
+    y: number;
+}, line1End: {
+    x: number;
+    y: number;
+}, line2Start: {
+    x: number;
+    y: number;
+}, line2End: {
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+} | null;
+/**
+ * 获取角度
+ */
+export declare function getAngle(from: {
+    x: number;
+    y: number;
+}, to: {
+    x: number;
+    y: number;
+}): number;
+/**
+ * 获取从原点到目标点的角度
+ */
+export declare function getAngleBetweenPoints(p1: {
+    x: number;
+    y: number;
+}, p2: {
+    x: number;
+    y: number;
+}, origin: {
+    x: number;
+    y: number;
+}): number;
+/**
+ * 角度规范化到 [-PI, PI]
+ */
+export declare function angleToCanvasCoordinateSystem(angle: number): number;
+/**
+ * 判断点是否在多边形内
+ */
+export declare function isPointInPolygon(point: {
+    x: number;
+    y: number;
+}, polygon: {
+    x: number;
+    y: number;
+}[]): boolean;
+/**
+ * 点到矩形边缘的最短距离
+ */
+export declare function pointToRectDistance(point: {
+    x: number;
+    y: number;
+}, rect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): number;
+/**
+ * 检查视口是否与边界相交（用于虚拟滚动）
+ */
+export declare function viewportIntersectsBounds(viewport: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, bounds: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, zoom: number): boolean;

package/dist/utils/geometry.mjs

@@ -0,0 +1,144 @@
+export function isPointInRect(point, rect) {
+  return point.x >= rect.x && point.x <= rect.x + rect.width && point.y >= rect.y && point.y <= rect.y + rect.height;
+}
+export function rectIntersect(rect1, rect2) {
+  return !(rect1.x + rect1.width < rect2.x || rect2.x + rect2.width < rect1.x || rect1.y + rect1.height < rect2.y || rect2.y + rect2.height < rect1.y);
+}
+export function getRectIntersection(rect1, rect2) {
+  if (!rectIntersect(rect1, rect2)) {
+    return null;
+  }
+  const x = Math.max(rect1.x, rect2.x);
+  const y = Math.max(rect1.y, rect2.y);
+  const width = Math.min(rect1.x + rect1.width, rect2.x + rect2.x) - x;
+  const height = Math.min(rect1.y + rect1.height, rect2.y + rect2.height) - y;
+  return { x, y, width, height };
+}
+export function getBoundingBox(points) {
+  if (points.length === 0) {
+    return { x: 0, y: 0, width: 0, height: 0 };
+  }
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const point of points) {
+    minX = Math.min(minX, point.x);
+    minY = Math.min(minY, point.y);
+    maxX = Math.max(maxX, point.x);
+    maxY = Math.max(maxY, point.y);
+  }
+  return {
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
+}
+export function getNodeBounds(nodes) {
+  const points = nodes.flatMap((node) => {
+    const w = node.width || 0;
+    const h = node.height || 0;
+    return [
+      { x: node.position.x, y: node.position.y },
+      { x: node.position.x + w, y: node.position.y + h }
+    ];
+  });
+  return getBoundingBox(points);
+}
+export function pointToLineDistance(point, lineStart, lineEnd) {
+  const A = point.x - lineStart.x;
+  const B = point.y - lineStart.y;
+  const C = lineEnd.x - lineStart.x;
+  const D = lineEnd.y - lineStart.y;
+  const dot = A * C + B * D;
+  const lenSq = C * C + D * D;
+  let param = -1;
+  if (lenSq !== 0) {
+    param = dot / lenSq;
+  }
+  let xx;
+  let yy;
+  if (param < 0) {
+    xx = lineStart.x;
+    yy = lineStart.y;
+  } else if (param > 1) {
+    xx = lineEnd.x;
+    yy = lineEnd.y;
+  } else {
+    xx = lineStart.x + param * C;
+    yy = lineStart.y + param * D;
+  }
+  const dx = point.x - xx;
+  const dy = point.y - yy;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+export function pointToPointDistance(p1, p2) {
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+export function degToRad(deg) {
+  return deg * Math.PI / 180;
+}
+export function radToDeg(rad) {
+  return rad * 180 / Math.PI;
+}
+export function getLineIntersection(line1Start, line1End, line2Start, line2End) {
+  const d1x = line1End.x - line1Start.x;
+  const d1y = line1End.y - line1Start.y;
+  const d2x = line2End.x - line2Start.x;
+  const d2y = line2End.y - line2Start.y;
+  const cross = d1x * d2y - d1y * d2x;
+  if (Math.abs(cross) < 1e-10) {
+    return null;
+  }
+  const d = {
+    x: line1Start.x - line2Start.x,
+    y: line1Start.y - line2Start.y
+  };
+  const t = (d.x * d2y - d.y * d2x) / cross;
+  return {
+    x: line1Start.x + t * d1x,
+    y: line1Start.y + t * d1y
+  };
+}
+export function getAngle(from, to) {
+  return Math.atan2(to.y - from.y, to.x - from.x);
+}
+export function getAngleBetweenPoints(p1, p2, origin) {
+  return Math.atan2(p2.y - origin.y, p2.x - origin.x) - Math.atan2(p1.y - origin.y, p1.x - origin.x);
+}
+export function angleToCanvasCoordinateSystem(angle) {
+  return -angle;
+}
+export function isPointInPolygon(point, polygon) {
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const xi = polygon[i].x;
+    const yi = polygon[i].y;
+    const xj = polygon[j].x;
+    const yj = polygon[j].y;
+    const intersect = yi > point.y !== yj > point.y && point.x < (xj - xi) * (point.y - yi) / (yj - yi) + xi;
+    if (intersect) {
+      inside = !inside;
+    }
+  }
+  return inside;
+}
+export function pointToRectDistance(point, rect) {
+  const rectRight = rect.x + rect.width;
+  const rectBottom = rect.y + rect.height;
+  const dx = Math.max(rect.x - point.x, 0, point.x - rectRight);
+  const dy = Math.max(rect.y - point.y, 0, point.y - rectBottom);
+  return Math.sqrt(dx * dx + dy * dy);
+}
+export function viewportIntersectsBounds(viewport, bounds, zoom) {
+  const scaledBounds = {
+    x: bounds.x * zoom,
+    y: bounds.y * zoom,
+    width: bounds.width * zoom,
+    height: bounds.height * zoom
+  };
+  return rectIntersect(viewport, scaledBounds);
+}