@huanban/rulego-editor-core 1.3.18 → 1.4.0

package/dist/core/ActionRegistry.d.ts

@@ -0,0 +1,47 @@
+export type EditorActionSource = 'toolbar' | 'context-menu' | 'command-palette' | 'keyboard' | 'api';
+export interface EditorShortcut {
+    key: string;
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+}
+export interface EditorSelectionSnapshot {
+    nodeIds: string[];
+    edgeIds: string[];
+}
+export interface EditorActionRuntime {
+    getGraphData?: () => unknown;
+    focusElement?: (id: string) => void;
+    confirm?: (message: string) => boolean | Promise<boolean>;
+    notify?: (message: string, level?: 'success' | 'warning' | 'error' | 'info') => void;
+    [key: string]: unknown;
+}
+export interface EditorActionContext {
+    runtime: EditorActionRuntime;
+    selection: EditorSelectionSnapshot;
+    source: EditorActionSource;
+    [key: string]: unknown;
+}
+export interface EditorAction {
+    id: string;
+    label: string;
+    description?: string;
+    group?: string;
+    icon?: string;
+    order?: number;
+    shortcuts?: EditorShortcut[];
+    visible?: (context: EditorActionContext) => boolean;
+    enabled?: (context: EditorActionContext) => boolean;
+    run: (context: EditorActionContext) => void | Promise<void>;
+}
+export declare class ActionRegistry {
+    private actions;
+    register(action: EditorAction, overwrite?: boolean): void;
+    registerAll(actions: EditorAction[], overwrite?: boolean): void;
+    unregister(id: string): boolean;
+    get(id: string): EditorAction | undefined;
+    list(context?: EditorActionContext): EditorAction[];
+    invoke(id: string, context: EditorActionContext): Promise<boolean>;
+    clear(): void;
+}

package/dist/core/AutoLayout.d.ts

@@ -1,62 +1,15 @@
-/**
- * @file AutoLayout.ts
- * @description 自动排版引擎 — 基于 DAG 拓扑排序的智能布局算法
- *
- * 核心功能:
- *  - 对节点进行智能排版，支持普通节点和分组节点（group-node）
- *  - 基于有向无环图 (DAG) 的分层布局 (类似 Sugiyama 算法简化版)
- *  - 分组节点 (switch/fork/groupAction 等) 使用更大的间距
- *  - 防止节点位置重叠
- *  - 允许连线交叉, 但禁止横向或竖向连线完全重合
- *  - 提供手动触发入口
- *
- * 算法步骤:
- *  1. 构建邻接表 (adjacency list) 表示节点连接关系
- *  2. BFS 拓扑分层 — 从入口节点开始, 按依赖深度分层
- *  3. 层内排序 — 按连接关系减少交叉
- *  4. 分配坐标 — 层间水平间距, 层内垂直间距 (group 节点使用更大间距)
- *  5. 去重合检测 — 确保无两条连线完全在同一水平/垂直线上重合
- *
- * @see DataAdapter.ts 数据转换时的 layoutX / layoutY 读取
- * @see group-node.ts GROUP_NODE_TYPES 列表
- */
 import type { LFGraphData } from './DataAdapter';
-/** 自动布局配置选项 */
 export interface AutoLayoutOptions {
-    /** 层间水平间距 (像素), 默认 250 */
     layerGapX?: number;
-    /** 层内垂直间距 (像素), 默认 100 */
     nodeGapY?: number;
-    /** 起始 X 坐标 (像素), 默认 100 */
     startX?: number;
-    /** 起始 Y 坐标 (像素), 默认 200 */
     startY?: number;
-    /** Start 节点 ID (固定在最左侧), 默认 '$node_start_input' */
     startNodeId?: string;
-    /** 节点宽度 (用于计算连线端点), 默认 200 */
     nodeWidth?: number;
-    /** 节点高度 (用于计算间距), 默认 40 */
     nodeHeight?: number;
-    /** 分组节点宽度 (switch/fork 等), 默认 320 */
     groupNodeWidth?: number;
-    /** 分组节点高度 (switch/fork 等), 默认 200 */
     groupNodeHeight?: number;
+    scopeNodeIds?: readonly string[];
 }
-/**
- * 对 LogicFlow 图数据执行自动排版
- *
- * @param graphData - LogicFlow 图数据 (nodes + edges)
- * @param options - 布局参数
- * @returns 排版后的图数据 (直接修改并返回原对象)
- */
 export declare function autoLayout(graphData: LFGraphData, options?: AutoLayoutOptions): LFGraphData;
-/**
- * 检查节点数据是否需要自动排版
- *
- * 判断标准: 超过 50% 的节点没有有效坐标 (layoutX/layoutY 都为 0 或缺失)
- *
- * @param nodes - RuleGo DSL 中的节点数组
- * @returns true 表示需要自动排版
- */
 export declare function needsAutoLayout(nodes: any[]): boolean;
-//# sourceMappingURL=AutoLayout.d.ts.map

package/dist/core/ComponentDocService.d.ts

@@ -0,0 +1,28 @@
+export interface ComponentDocMeta {
+    type: string;
+    title: string;
+    category?: string;
+    description?: string;
+    [key: string]: unknown;
+}
+export interface ComponentDoc extends ComponentDocMeta {
+    content: string;
+}
+export interface ComponentDocProvider {
+    list(): ComponentDocMeta[] | Promise<ComponentDocMeta[]>;
+    has(type: string): boolean | Promise<boolean>;
+    load(type: string, signal?: AbortSignal): Promise<ComponentDoc | null>;
+    resolveExternalUrl?(target: string): string | null;
+}
+export declare class ComponentDocService {
+    private provider;
+    private cache;
+    constructor(provider?: ComponentDocProvider | null);
+    setProvider(provider?: ComponentDocProvider | null): void;
+    hasProvider(): boolean;
+    list(): Promise<ComponentDocMeta[]>;
+    has(type: string): Promise<boolean>;
+    load(type: string, signal?: AbortSignal): Promise<ComponentDoc | null>;
+    resolveExternalUrl(target: string): string | null;
+    clear(): void;
+}

package/dist/core/ComponentRegistry.d.ts

@@ -1,151 +1,27 @@
-/**
- * @file ComponentRegistry.ts
- * @description 组件注册表 — 管理所有可用的节点组件
- *
- * 负责:
- * - 注册和管理组件定义 (来自后端 API 或内置默认)
- * - 按分类分组 (filter/transform/action/external/flow)
- * - 提供按 type 快速查询
- * - 适配后端返回的原始数据格式
- * - 合并本地化信息 (标签、描述、图标等)
- *
- * @see default.js - 内置组件定义
- * @see local_zh.js - 中文本地化
- * @see util.js - adapterComponents 转换函数
- */
 import type { ComponentDefinition, ComponentGroup, RawComponentData, ComponentRegistryOptions } from '../types/component';
-/**
- * 组件注册表
- *
- * 管理编辑器中所有可用的节点组件定义。
- * 支持按 type 查找、按 category 分组、动态注册/注销等操作。
- *
- * @example
- * ```typescript
- * const registry = new ComponentRegistry()
- *
- * // 从后端 API 数据加载组件
- * registry.loadFromRawData(apiData)
- *
- * // 按 type 查找
- * const filterNode = registry.getByType('jsFilter')
- *
- * // 获取分组 (用于侧边栏渲染)
- * const groups = registry.getGroups()
- *
- * // 动态注册自定义组件
- * registry.register({
- *   type: 'myCustomNode',
- *   category: 'action',
- *   label: 'My Custom Node',
- *   ...
- * })
- * ```
- */
 export declare class ComponentRegistry {
-    /** 组件映射表: type => ComponentDefinition */
     private components;
-    /** 自定义分类定义 */
     private categories;
-    /** 自定义适配器函数 */
     private adapter?;
-    /**
-     * 创建组件注册表
-     *
-     * @param options - 初始化选项
-     */
+    private transform?;
     constructor(options?: ComponentRegistryOptions);
-    /**
-     * 注册单个组件
-     *
-     * @param definition - 组件定义
-     * @param overwrite - 如果已存在是否覆盖 (默认: true)
-     */
     register(definition: ComponentDefinition, overwrite?: boolean): void;
-    /**
-     * 批量注册组件
-     *
-     * @param definitions - 组件定义列表
-     * @param overwrite - 如果已存在是否覆盖
-     */
     registerAll(definitions: ComponentDefinition[], overwrite?: boolean): void;
-    /**
-     * 注销组件
-     *
-     * @param type - 组件类型标识
-     * @returns 是否成功移除
-     */
     unregister(type: string): boolean;
-    /**
-     * 根据类型获取组件定义
-     *
-     * @param type - 组件类型标识
-     * @returns 组件定义, 不存在返回 undefined
-     */
     getByType(type: string): ComponentDefinition | undefined;
-    /**
-     * 获取所有组件的扁平列表
-     *
-     * @returns 所有已注册组件的数组
-     */
     getAll(): ComponentDefinition[];
-    /**
-     * 获取组件映射表 (type => definition)
-     * 用于快速查找, 对应原版的 nodeComponents 对象
-     *
-     * @returns type => ComponentDefinition 的映射
-     */
     getMap(): Record<string, ComponentDefinition>;
-    /**
-     * 获取按分类分组的组件列表
-     * 用于侧边栏渲染
-     *
-     * @returns 分组后的组件列表
-     */
     getGroups(options?: {
         translateCategory?: (categoryKey: string, fallback: string) => string | undefined;
         sort?: boolean;
     }): ComponentGroup[];
-    /**
-     * 从后端 API 返回的原始数据加载组件
-     *
-     * 如果设置了自定义 adapter 则使用自定义逻辑，
-     * 否则使用内置的默认适配逻辑。
-     *
-     * @param rawData - 后端返回的原始组件数据
-     * @returns 分组后的组件列表
-     */
     loadFromRawData(rawData: RawComponentData): ComponentGroup[];
-    /**
-     * 注册自定义分类
-     *
-     * @param category - 分类标识
-     * @param info - 分类信息 (标签和颜色)
-     */
     registerCategory(category: string, info: {
         label: string;
         color: string;
     }): void;
-    /**
-     * 获取组件总数
-     */
     get size(): number;
-    /**
-     * 检查组件是否已注册
-     *
-     * @param type - 组件类型标识
-     */
     has(type: string): boolean;
-    /**
-     * 清空所有已注册组件
-     */
     clear(): void;
-    /**
-     * 检查是否存在某个分类下的组件 (用于特性的平滑降级探测)
-     *
-     * @param categoryName - 分类名称
-     * @returns boolean
-     */
     hasCategory(categoryName: string): boolean;
 }
-//# sourceMappingURL=ComponentRegistry.d.ts.map

package/dist/core/DataAdapter.d.ts

@@ -1,133 +1,48 @@
-/**
- * @file DataAdapter.ts
- * @description 数据格式转换器 — adapterIn / adapterOut
- *
- * 负责 RuleGo JSON 格式 <-> LogicFlow 内部格式 的双向转换。
- *
- * adapterIn:  RuleChainData → LogicFlowGraphData (用于渲染)
- * adapterOut: LogicFlowGraphData → RuleChainData (用于保存)
- *
- * 这是原版 RuleGoEditor.vue 中最核心的业务逻辑之一，
- * 从框架层抽取到 core 中后，Vue/React/原生 JS 都可以复用。
- *
- * @see RuleGoEditor.vue 的 lf.adapterIn 和 lf.adapterOut 方法
- */
 import type { RuleChainData, RuleChainConfig, RuleNodeConfig } from '../types/rule-chain';
 import type { ComponentDefinition } from '../types/component';
 import type { EditorInternalData } from '../types/editor';
-/**
- * LogicFlow 节点数据
- */
 export interface LFNodeData {
-    /** 节点 ID */
     id: string;
-    /** 节点类型 (simple-node, start-node, chain-node, group-node) */
     type: string;
-    /** X 坐标 */
     x: number;
-    /** Y 坐标 */
     y: number;
-    /** 节点显示文本 */
     text?: string;
-    /** 节点属性 */
+    children?: string[];
     properties: {
-        /** RuleGo 节点配置 */
         model?: RuleNodeConfig;
-        /** 组件视图定义 */
         view?: ComponentDefinition;
+        width?: number;
+        height?: number;
+        children?: string[];
     };
 }
-/**
- * LogicFlow 连接点数据
- */
 export interface LFPoint {
     x: number;
     y: number;
 }
-/**
- * LogicFlow 边数据
- */
 export interface LFEdgeData {
-    /** 边 ID */
     id: string;
-    /** 边类型 */
     type: string;
-    /** 源节点 ID */
     sourceNodeId: string;
-    /** 目标节点 ID */
     targetNodeId: string;
-    /** 起点坐标 (可选 — 不设则由 LogicFlow 根据锚点自动计算) */
     startPoint?: LFPoint;
-    /** 终点坐标 (可选 — 不设则由 LogicFlow 根据锚点自动计算) */
     endPoint?: LFPoint;
-    /** 源锚点 ID (指定连接到源节点的哪个锚点) */
     sourceAnchorId?: string;
-    /** 目标锚点 ID (指定连接到目标节点的哪个锚点) */
     targetAnchorId?: string;
-    /** 显示文本 */
     text?: string;
-    /** 边属性 */
     properties: {
-        /** 连接数据 */
         model: Record<string, any>;
     };
 }
-/**
- * LogicFlow 图数据 (完整的画布数据)
- */
 export interface LFGraphData {
-    /** 节点列表 */
     nodes: LFNodeData[];
-    /** 边列表 */
     edges: LFEdgeData[];
 }
-/**
- * 数据格式转换器
- * 实现 RuleGo JSON 与 LogicFlow 格式的双向转换
- */
 export declare class DataAdapter {
-    /**
-     * 将 RuleGo 数据转换为 LogicFlow 格式 (用于渲染)
-     *
-     * 转换逻辑:
-     * 1. 添加固定的 Start 节点
-     * 2. 将 metadata.nodes 转换为 LF 节点 (带布局位置)
-     * 3. 根据 firstNodeIndex 创建 Start -> 第一个节点的边
-     * 4. 将 metadata.connections 转换为 LF 边 (合并同源同目标的多关系)
-     *
-     * @param userData - RuleGo 规则链 JSON 数据
-     * @param nodeComponents - 组件注册表 (type => definition)
-     * @param internalData - 编辑器内部运行时数据 (计数器等)
-     * @param options - 额外选项 (如起始坐标)
-     * @returns LogicFlow 格式的图数据
-     */
     adapterIn(userData: RuleChainData, nodeComponents: Record<string, ComponentDefinition>, internalData: EditorInternalData, options: {
         startX: number;
         startY: number;
     }): LFGraphData;
-    /**
-     * 将 LogicFlow 数据转换回 RuleGo 格式 (用于保存)
-     *
-     * 转换逻辑:
-     * 1. 遍历边, 过滤掉 Start 节点的出边, 将合并的关系类型拆分为多条连接
-     * 2. 遍历节点, 过滤掉 Start 节点, 更新布局信息
-     * 3. 确定第一个节点 (Start 节点连接的目标节点)
-     * 4. 组装 RuleChainData 返回
-     *
-     * @param logicFlowData - LogicFlow 的图数据
-     * @param ruleChain - 当前规则链配置
-     * @param internalData - 编辑器内部运行时数据
-     * @param getNodeModelById - 从 LogicFlow 获取节点 Model 的函数
-     * @returns RuleGo 规则链 JSON 数据
-     */
     adapterOut(logicFlowData: LFGraphData, ruleChain: RuleChainConfig, internalData: EditorInternalData, getNodeModelById: (id: string) => LFNodeData | null): RuleChainData;
-    /**
-     * 根据 LogicFlow 节点 ID 查找对应的 RuleGo 自定义节点 ID
-     *
-     * @param lfNodeId - LogicFlow 内部节点 ID
-     * @param getNodeModelById - 获取节点数据的函数
-     * @returns 自定义节点 ID, 找不到返回空字符串
-     */
     private lfNodeId2CustomNodeId;
 }
-//# sourceMappingURL=DataAdapter.d.ts.map

package/dist/core/DiagnosticService.d.ts

@@ -0,0 +1,15 @@
+import type { LFGraphData } from './DataAdapter';
+import type { DiagnosticItem, TopologyContext } from './topology-rules';
+export type DiagnosticListener = (items: readonly DiagnosticItem[]) => void;
+export declare class DiagnosticService {
+    private items;
+    private listeners;
+    private disabledRules;
+    validate(graph: LFGraphData, context?: TopologyContext): DiagnosticItem[];
+    getItems(): readonly DiagnosticItem[];
+    getBlockingItems(): DiagnosticItem[];
+    setRuleEnabled(rule: string, enabled: boolean): void;
+    subscribe(listener: DiagnosticListener): () => void;
+    clear(): void;
+    destroy(): void;
+}