@mx-sose-front/mx-sose-graph 1.0.0

package/src/utils/hittest.ts

@@ -0,0 +1,135 @@
+// 选中测试：用 shapeType 区分 diagram / shape / edge
+import { inBounds, getBounds } from './geom'
+import type { Shape } from '../types'
+
+export const isDiagram = (s: any) =>
+    String(s?.shapeType).trim().toLowerCase() === 'diagram'
+export const isShape = (s: any) =>
+    String(s?.shapeType).trim().toLowerCase() === 'shape'
+export const isEdge = (s: any) =>
+    String(s?.shapeType).trim().toLowerCase() === 'edge'
+export const isPin = (s: any) =>
+    String(s?.shapeType).trim().toLowerCase() === 'pin'
+
+// 命中的返回类型（明确包含四种可能）
+const getZ = (s: Shape) =>
+  typeof s?.style?.zIndex === 'number' ? (s.style!.zIndex as number) : 0
+
+export type HitResult =
+  | { kind: 'shape'; shape: Shape }
+  | { kind: 'edge'; shape: Shape }
+  | { kind: 'pin'; shape: Shape }
+  | { kind: 'diagram'; shape: Shape }
+  | { kind: 'none'; shape: null }
+
+// 计算点到线段的距离
+function distanceToLineSegment(pt: { x: number; y: number }, p1: { x: number; y: number }, p2: { x: number; y: number }): number {
+  // 计算向量
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  const lengthSquared = dx * dx + dy * dy;
+  
+  if (lengthSquared === 0) {
+    // p1 和 p2 是同一点
+    return Math.sqrt((pt.x - p1.x) * (pt.x - p1.x) + (pt.y - p1.y) * (pt.y - p1.y));
+  }
+  
+  // 计算投影参数 t
+  let t = ((pt.x - p1.x) * dx + (pt.y - p1.y) * dy) / lengthSquared;
+  t = Math.max(0, Math.min(1, t));
+  
+  // 计算投影点
+  const projection = {
+    x: p1.x + t * dx,
+    y: p1.y + t * dy
+  };
+  
+  // 计算点到投影点的距离
+  return Math.sqrt((pt.x - projection.x) * (pt.x - projection.x) + (pt.y - projection.y) * (pt.y - projection.y));
+}
+
+// 检查点是否在线条附近
+function isPointNearEdge(pt: { x: number; y: number }, edge: Shape, threshold: number = 5): boolean {
+  // 首先尝试从waypointId获取路径点（与Edge.vue组件保持一致）
+  let waypoints = [];
+  
+  if (edge.waypointId) {
+    if (typeof edge.waypointId === 'string') {
+      try {
+        waypoints = JSON.parse(edge.waypointId);
+      } catch (error) {
+        console.error('解析waypointId失败:', error);
+      }
+    } else if (Array.isArray(edge.waypointId)) {
+      waypoints = edge.waypointId;
+    }
+  } else if (edge.waypoints) {
+    // 兼容旧格式
+    waypoints = edge.waypoints;
+  }
+  
+  if (!waypoints || waypoints.length < 2) {
+    return false;
+  }
+  
+  // 检查点是否靠近任意一条线段
+  for (let i = 0; i < waypoints.length - 1; i++) {
+    const p1 = waypoints[i];
+    const p2 = waypoints[i + 1];
+    
+    const distance = distanceToLineSegment(pt, p1, p2);
+    if (distance <= threshold) {
+      console.log('线条命中成功！距离:', distance, '阈值:', threshold);
+      return true;
+    }
+  }
+  
+  return false;
+}
+
+export function pickTarget(shapes: readonly Shape[], pt: { x: number; y: number }): HitResult {
+  // 首先检查 pin 类型（优先级最高，因为 pin 通常在其他图元之上）
+  const pinsOrdered = shapes
+    .map((s, i) => ({ s, i }))
+    .filter(x => isPin(x.s))
+    .sort((a, b) => {
+      const dz = getZ(b.s) - getZ(a.s)
+      return dz !== 0 ? dz : (b.i - a.i)
+    })
+
+  for (const { s } of pinsOrdered) {
+    if (inBounds(pt, getBounds(s))) return { kind: 'pin', shape: s }
+  }
+
+  // 然后检查普通图形（shape类型）
+  const shapesOrdered = shapes
+    .map((s, i) => ({ s, i }))
+    .filter(x => isShape(x.s))
+    .sort((a, b) => {
+      const dz = getZ(b.s) - getZ(a.s)
+      return dz !== 0 ? dz : (b.i - a.i)
+    })
+
+  for (const { s } of shapesOrdered) {
+    if (inBounds(pt, getBounds(s))) return { kind: 'shape', shape: s }
+  }
+  
+  // 然后检查线条（edge类型）
+  const edgesOrdered = shapes
+    .map((s, i) => ({ s, i }))
+    .filter(x => isEdge(x.s))
+    .sort((a, b) => {
+      const dz = getZ(b.s) - getZ(a.s)
+      return dz !== 0 ? dz : (b.i - a.i)
+    })
+
+  for (const { s } of edgesOrdered) {
+    if (isPointNearEdge(pt, s)) return { kind: 'edge', shape: s }
+  }
+  
+  // 最后检查画布（diagram类型）
+  const diagram = shapes.find(isDiagram)
+  if (diagram && inBounds(pt, getBounds(diagram))) return { kind: 'diagram', shape: diagram }
+  
+  return { kind: 'none', shape: null }
+}

package/src/utils/iconLoader.ts

@@ -0,0 +1,105 @@
+/**
+ * 全局图标加载工具
+ */
+
+export interface IconMap {
+  [key: string]: string;
+}
+
+export class IconLoader {
+  private static iconMaps: Map<string, IconMap> = new Map();
+
+  static loadIcons(iconPath: string): IconMap {
+    if (this.iconMaps.has(iconPath)) {
+      return this.iconMaps.get(iconPath)!;
+    }
+
+    // 使用 switch 语句处理不同的图标目录
+    let modules: Record<string, string>;
+    switch (iconPath) {
+      case 'menu':
+        modules = import.meta.glob('/src/statics/icons/menu/*.{png,svg,jpg,jpeg,webp}', {
+          eager: true,
+          import: "default",
+        }) as Record<string, string>;
+        break;
+      case 'home':
+        modules = import.meta.glob('/src/statics/icons/home/*.{png,svg,jpg,jpeg,webp}', {
+          eager: true,
+          import: "default",
+        }) as Record<string, string>;
+        break;
+      case 'createElement':
+        modules = import.meta.glob('/src/statics/icons/createElement/*.{png,svg,jpg,jpeg,webp}', {
+          eager: true,
+          import: "default",
+        }) as Record<string, string>;
+        break;
+      case 'createMenu':
+        modules = import.meta.glob('/src/statics/icons/createMenu/*.{png,svg,jpg,jpeg,webp}', {
+          eager: true,
+          import: "default",
+        }) as Record<string, string>;
+        break;
+      case 'modelView':
+        modules = import.meta.glob('/src/statics/icons/modelView/*.{png,svg,jpg,jpeg,webp}', {
+          eager: true,
+          import: "default",
+        }) as Record<string, string>;
+        break;
+      case 'sideMenu':
+        modules = import.meta.glob('/src/statics/icons/sideMenu/*.{png,svg,jpg,jpeg,webp}', {
+          eager: true,
+          import: "default",
+        }) as Record<string, string>;
+        break;
+      case 'childIcons':
+        modules = import.meta.glob('/src/statics/icons/childIcons/*.{png,svg,jpg,jpeg,webp}', {
+          eager: true,
+          import: "default",
+        }) as Record<string, string>;
+        break;
+      default:
+        return {};
+    }
+
+    const iconMap: IconMap = {};
+    Object.entries(modules).forEach(([fullPath, url]) => {
+      const name = fullPath.split("/").pop()!.replace(/\.[^.]+$/, "");
+      iconMap[name] = url;
+    });
+
+    this.iconMaps.set(iconPath, iconMap);
+    return iconMap;
+  }
+
+  static getMenuIcon(iconName: string, isDisabled: boolean = false, disabledIconName?: string): string {
+    const iconMap = this.loadIcons('menu');
+
+    if (isDisabled) {
+      if (disabledIconName && iconMap[disabledIconName]) {
+        return iconMap[disabledIconName];
+      }
+      const guess = `${iconName}_disabled`;
+      if (iconMap[guess]) {
+        return iconMap[guess];
+      }
+    }
+
+    return iconMap[iconName] || '';
+  }
+
+  static getIcon(iconPath: string, iconName: string): string {
+    const iconMap = this.loadIcons(iconPath);
+    return iconMap[iconName] || '';
+  }
+
+  static clearCache(): void {
+    this.iconMaps.clear();
+  }
+}
+
+export const getMenuIcon = (iconName: string, isDisabled?: boolean, disabledIconName?: string) =>
+  IconLoader.getMenuIcon(iconName, isDisabled, disabledIconName);
+export const getIcon = (iconPath: string, iconName: string) =>
+  IconLoader.getIcon(iconPath, iconName);

package/src/utils/index.ts

@@ -0,0 +1,20 @@
+/**
+ * 生成UUID（不包含连字符）
+ * @param version UUID版本，默认为4
+ * @returns 生成的UUID字符串（不包含连字符）
+ */
+export function getUuid(): string {
+    const timestamp = Date.now()
+    const random = Math.random().toString(16).substring(2, 14)
+    const clockSeq = Math.floor(Math.random() * 0x3fff) + 0x8000
+    const node = Math.floor(Math.random() * 0xffffffffffff)
+    
+    const hex = (timestamp.toString(16) + random).padStart(24, '0')
+    const timeLow = hex.substring(0, 8)
+    const timeMid = hex.substring(8, 12)
+    const timeHigh = (parseInt(hex.substring(12, 16), 16) & 0x0fff | 0x1000).toString(16)
+    const clockSeqHex = clockSeq.toString(16)
+    const nodeHex = node.toString(16).padStart(12, '0')
+    
+    return `${timeLow}${timeMid}${timeHigh}${clockSeqHex}${nodeHex}`
+}

package/src/utils/packgeMap.ts

@@ -0,0 +1 @@
+export const packageMap = ['Strategic']