@knotx/core 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,307 @@
+import { DataOperationPipe, DataOperation, DataManager } from '@knotx/data';
+import { BehaviorSubject } from 'rxjs';
+import { Container as Container$1, PluginDefinition as PluginDefinition$1, NodeData as NodeData$1, EdgeData as EdgeData$1, IEngineRuntime as IEngineRuntime$1, RenderType as RenderType$1, LayerComponent as LayerComponent$1, IPlugin as IPlugin$1, Layer as Layer$1, NodeRenderType as NodeRenderType$1, EdgeRenderType as EdgeRenderType$1, PluginData as PluginData$1, InteractionPriority as InteractionPriority$1 } from '@knotx/core';
+export * from '@knotx/utils';
+
+type HorizontalAlignment = 'left' | 'right';
+type VerticalAlignment = 'top' | 'bottom';
+interface NodePosition {
+    x: number;
+    y: number;
+}
+interface NodeMeasured {
+    width: number;
+    height: number;
+}
+interface NodeData<TData = any> {
+    id: string;
+    type?: string;
+    position: NodePosition;
+    measured?: NodeMeasured;
+    data: TData;
+}
+interface NodeProps<T = any> {
+    node: NodeData<T>;
+}
+interface EdgeData<TData = any> {
+    id: string;
+    source: string;
+    target: string;
+    type?: string;
+    data?: TData;
+}
+interface EdgeProps<T = any> {
+    edge: T;
+    sourceX: number;
+    sourceY: number;
+    targetX: number;
+    targetY: number;
+}
+interface Container {
+    width: number;
+    height: number;
+}
+type Position = 'top' | 'right' | 'bottom' | 'left';
+type RenderType = (...args: any[]) => any;
+type NodeRenderType<TD extends Record<string, any> = any, TR = any> = (props: NodeProps<TD>) => TR;
+type EdgeRenderType<TD extends Record<string, any> = any, TR = any> = (props: EdgeProps<TD>) => TR;
+declare enum Layer {
+    Canvas = 0,
+    Background = 4,
+    Edges = 16,
+    Nodes = 64,
+    Foreground = 256
+}
+interface LayerComponent<TRenderType> {
+    plugin: string;
+    name: string;
+    layer: Layer;
+    render: TRenderType;
+    /**
+     * 层级偏移量
+     * @default 0
+     * (layer >> 1, layer << 1]
+     */
+    offset?: number;
+}
+interface IPlugin<TPluginName extends string = string, TRenderType extends RenderType = RenderType> {
+    name: TPluginName;
+    pluginId: string;
+    onInit?: () => void;
+    onDestroy?: () => void;
+    render?: (...args: Parameters<TRenderType>) => ReturnType<TRenderType>;
+}
+declare abstract class BasePlugin<TPluginName extends string = string, TRenderType extends RenderType = RenderType> implements IPlugin<TPluginName, TRenderType> {
+    abstract name: TPluginName;
+    private static _instanceId;
+    private _instanceId;
+    get pluginId(): string;
+}
+type PluginFactory<TPluginName extends string = string, TRenderType extends RenderType = RenderType> = () => IPlugin<TPluginName, TRenderType>;
+type PluginDefinition<TPluginName extends string = string, TRenderType extends RenderType = RenderType> = (typeof BasePlugin<TPluginName, TRenderType>) | IPlugin<TPluginName, TRenderType> | PluginFactory<TPluginName, TRenderType> | PluginWithOptions<any>;
+type PluginWithOptions<T extends abstract new (...args: any) => any> = [
+    T,
+    ...ConstructorParameters<T>
+];
+/**
+ * plugin data host
+ * @example
+ * `declare module '@knotx/core' {
+ *   interface PluginData {
+ *     pluginName: {
+ *       property: any
+ *     }
+ *   }
+ * }`
+ */
+interface PluginData {
+}
+type NodeOperationPipe<T = any> = DataOperationPipe<NodeData<T>>;
+type EdgeOperationPipe<T = any> = DataOperationPipe<EdgeData<T>>;
+type NodeOperation<T = any> = DataOperation<NodeData<T>>;
+type EdgeOperation<T = any> = DataOperation<EdgeData<T>>;
+type NodeOperatorFunction<T = any, Args extends any[] = any[]> = (...args: Args) => NodeOperation<T>[];
+type EdgeOperatorFunction<T = any, Args extends any[] = any[]> = (...args: Args) => EdgeOperation<T>[];
+interface IEngineRuntime {
+    render?: {
+        getValue: <T, R = T>(value: BehaviorSubject<T> | T, options: {
+            paths: string[];
+            selector?: (value: T, context?: any) => R;
+            context?: any;
+        }) => T | R;
+    };
+}
+
+/**
+ * 用户交互优先级定义
+ * 数值越大优先级越高
+ */
+declare enum InteractionPriority {
+    /** 文本输入框激活状态（输入中需独占） */
+    InputActive = 2000,
+    /** 实体连接拖拽 */
+    EntityConnectDrag = 1930,
+    /** 实体测量拖拽 */
+    EntityMeasureDrag = 1920,
+    /** 实体位置拖拽 */
+    EntityPositionDrag = 1910,
+    /** 连续操作：拖拽、缩放等进行中的动作 */
+    ContinuousDrag = 1900,
+    /** 右键菜单/上下文操作 */
+    ContextMenu = 1800,
+    /** 键盘快捷键（如 Delete/Ctrl+C） */
+    KeyboardShortcut = 1700,
+    /** 单击选中元素 */
+    ClickSelection = 1600,
+    /** 双击编辑元素 */
+    DoubleClickEdit = 1500,
+    /** 框选（多选）操作 */
+    MarqueeSelection = 1300,
+    /** 套索选择（Lasso Select） */
+    LassoSelection = 1250,
+    /** 长按操作（长按菜单/工具） */
+    LongPress = 1100,
+    /** 悬停提示（Hover Tooltip） */
+    HoverTooltip = 1000,
+    /** 画布平移（空格拖拽或手势） */
+    CanvasPan = 900,
+    /** 画布缩放（滚轮或双指） */
+    CanvasZoom = 800,
+    /** 多指手势（如三指滑动） */
+    MultiTouchGesture = 700
+}
+interface Interaction {
+    pluginId: string;
+    type: string;
+    priority: InteractionPriority;
+    active?: boolean;
+}
+/**
+ * 交互管理器
+ */
+declare class InteractionManager {
+    private interactions;
+    /**
+     * 获取当前活动的交互
+     */
+    get activeInteraction(): Interaction | undefined;
+    /**
+     * 检查是否可以交互
+     * @param pluginId 插件ID
+     * @param type 交互类型
+     * @param autoStartPriority 自动启动优先级
+     * @returns 是否可以交互
+     */
+    canInteract(pluginId: string, type: string, autoStartPriority?: InteractionPriority): boolean;
+    /**
+     * 启动交互
+     * @param pluginId 插件ID
+     * @param type 交互类型
+     * @param priority 优先级
+     * @returns 取消交互的函数
+     */
+    startInteraction(pluginId: string, type: string, priority: InteractionPriority): () => void;
+    /**
+     * 结束交互
+     * @param pluginId 插件ID
+     * @param type 交互类型
+     */
+    endInteraction(pluginId: string, type: string): void;
+    private updateActive;
+}
+
+interface EngineOptions {
+    container: Container$1;
+    plugins?: PluginDefinition$1[];
+    nodes?: NodeData$1[];
+    edges?: EdgeData$1[];
+    runtime?: IEngineRuntime$1;
+}
+declare class Engine<TRenderType extends RenderType$1 = RenderType$1> {
+    readonly runtime: IEngineRuntime$1;
+    readonly interactionManager: InteractionManager;
+    readonly nodesManager: DataManager<NodeData$1>;
+    readonly edgesManager: DataManager<EdgeData$1>;
+    private container$;
+    private nodes$;
+    private edges$;
+    private layers$;
+    private plugins$;
+    private nodeRenderers$;
+    private edgeRenderers$;
+    private _pluginDataContainer;
+    get container(): Container$1;
+    set container(value: Container$1);
+    get nodes(): NodeData$1<any>[];
+    get edges(): EdgeData$1<any>[];
+    get layers(): Map<number, LayerComponent$1<TRenderType>[]>;
+    get plugins(): IPlugin$1<string, TRenderType>[];
+    constructor(options: EngineOptions);
+    private init;
+    private calculateEffectiveLayer;
+    getLayerComponents(layer: Layer$1): LayerComponent$1<TRenderType>[];
+    addNodePipe(pipe: DataOperationPipe<NodeData$1>): void;
+    addEdgePipe(pipe: DataOperationPipe<EdgeData$1>): void;
+    dispatchNodeOperation(operation: DataOperation<NodeData$1>): void;
+    dispatchEdgeOperation(operation: DataOperation<EdgeData$1>): void;
+    getNode(id: string): NodeData$1 | undefined;
+    getNodeDraft(id: string): NodeData$1 | undefined;
+    getNodes(): NodeData$1[];
+    getNodeRenderer(type: string): NodeRenderType$1 | undefined;
+    getEdge(id: string): EdgeData$1 | undefined;
+    getEdgeDraft(id: string): EdgeData$1 | undefined;
+    getEdges(): EdgeData$1[];
+    getEdgeRenderer(type: string): EdgeRenderType$1 | undefined;
+    registerPluginData<T extends keyof PluginData$1, TP extends keyof PluginData$1[T]>(pluginName: T, property: TP, data: BehaviorSubject<PluginData$1[T][TP]>): void;
+    registerNodeRenderer(type: string, renderer: NodeRenderType$1): void;
+    registerEdgeRenderer(type: string, renderer: EdgeRenderType$1): void;
+    canInteract(pluginId: string, type: string, autoStartPriority?: InteractionPriority$1): boolean;
+    startInteraction(pluginId: string, type: string, priority: InteractionPriority$1): void;
+    endInteraction(pluginId: string, type: string): void;
+    destroy(): void;
+}
+
+declare function getLayerRenders<TRenderType extends RenderType$1 = RenderType$1>(plugin: IPlugin$1<string, TRenderType>): LayerComponent$1<TRenderType>[];
+
+/**
+ * Runtime 类
+ * 用于管理上下文和值处理
+ */
+declare class Runtime {
+    /**
+     * 当前上下文
+     */
+    currentContext: {
+        type: any;
+        value: any;
+    } | undefined;
+    /**
+     * 在上下文中运行函数
+     * @param type 上下文类型
+     * @param handler 处理函数
+     * @param contextValue 上下文值
+     * @returns 处理函数的返回值
+     */
+    runInContext<T>(type: any, handler: () => T, contextValue?: any): T;
+    /**
+     * 值处理器
+     */
+    getValue<T>(engine: Engine<any>, options: {
+        paths: any[];
+        matcher?: (engine: Engine<any>) => BehaviorSubject<any>;
+        selector?: (value: T, context?: any) => any;
+    }): any;
+    /**
+     * 获取 Runtime 实例
+     * @returns Runtime 实例
+     */
+    private static instance;
+    static getInstance(): Runtime;
+    /**
+     * 默认值处理器
+     */
+    static DEFAULT_VALUE_HANDLER: <T>(value: BehaviorSubject<T> | T, { selector, context }: {
+        paths: string[];
+        selector?: (value: T, context?: any) => any;
+        context?: any;
+    }) => any;
+}
+
+/**
+ * 在 render 上下文执行 hook 函数
+ * 函数中被读取的值会被转换为对应 runtime render 的响应式数据
+ * @param hook
+ */
+declare function use<T>(hook: () => T): T;
+/**
+ * 在 render 上下文执行 hook 函数，context 作为 inject selector 的上下文
+ * 函数中被读取的值会被转换为对应 runtime render 的响应式数据
+ * @param hook
+ * @param context
+ */
+declare function use<T, TContext>(hook: () => {
+    __contextRef__: T;
+    __contextValue__: TContext;
+}, context: TContext): T;
+
+export { BasePlugin, type Container, type EdgeData, type EdgeOperation, type EdgeOperationPipe, type EdgeOperatorFunction, type EdgeProps, type EdgeRenderType, Engine, type EngineOptions, type HorizontalAlignment, type IEngineRuntime, type IPlugin, type Interaction, InteractionManager, InteractionPriority, Layer, type LayerComponent, type NodeData, type NodeMeasured, type NodeOperation, type NodeOperationPipe, type NodeOperatorFunction, type NodePosition, type NodeProps, type NodeRenderType, type PluginData, type PluginDefinition, type PluginFactory, type PluginWithOptions, type Position, type RenderType, Runtime, type VerticalAlignment, getLayerRenders, use };

package/dist/index.mjs

@@ -0,0 +1,400 @@
+import { Layer as Layer$1, BasePlugin as BasePlugin$1 } from '@knotx/core';
+import { DataManager } from '@knotx/data';
+import { set, get } from 'lodash-es';
+import { BehaviorSubject, identity } from 'rxjs';
+import { getSymbol } from '@knotx/utils';
+export * from '@knotx/utils';
+
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => __defNormalProp$4(obj, key + "" , value);
+var Layer = /* @__PURE__ */ ((Layer2) => {
+  Layer2[Layer2["Canvas"] = 0] = "Canvas";
+  Layer2[Layer2["Background"] = 4] = "Background";
+  Layer2[Layer2["Edges"] = 16] = "Edges";
+  Layer2[Layer2["Nodes"] = 64] = "Nodes";
+  Layer2[Layer2["Foreground"] = 256] = "Foreground";
+  return Layer2;
+})(Layer || {});
+const _BasePlugin = class _BasePlugin {
+  constructor() {
+    __publicField$3(this, "_instanceId", _BasePlugin._instanceId++);
+  }
+  get pluginId() {
+    return `${this.name}:${this._instanceId}`;
+  }
+};
+__publicField$3(_BasePlugin, "_instanceId", 0);
+let BasePlugin = _BasePlugin;
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => __defNormalProp$3(obj, key + "" , value);
+var InteractionPriority = /* @__PURE__ */ ((InteractionPriority2) => {
+  InteractionPriority2[InteractionPriority2["InputActive"] = 2e3] = "InputActive";
+  InteractionPriority2[InteractionPriority2["EntityConnectDrag"] = 1930] = "EntityConnectDrag";
+  InteractionPriority2[InteractionPriority2["EntityMeasureDrag"] = 1920] = "EntityMeasureDrag";
+  InteractionPriority2[InteractionPriority2["EntityPositionDrag"] = 1910] = "EntityPositionDrag";
+  InteractionPriority2[InteractionPriority2["ContinuousDrag"] = 1900] = "ContinuousDrag";
+  InteractionPriority2[InteractionPriority2["ContextMenu"] = 1800] = "ContextMenu";
+  InteractionPriority2[InteractionPriority2["KeyboardShortcut"] = 1700] = "KeyboardShortcut";
+  InteractionPriority2[InteractionPriority2["ClickSelection"] = 1600] = "ClickSelection";
+  InteractionPriority2[InteractionPriority2["DoubleClickEdit"] = 1500] = "DoubleClickEdit";
+  InteractionPriority2[InteractionPriority2["MarqueeSelection"] = 1300] = "MarqueeSelection";
+  InteractionPriority2[InteractionPriority2["LassoSelection"] = 1250] = "LassoSelection";
+  InteractionPriority2[InteractionPriority2["LongPress"] = 1100] = "LongPress";
+  InteractionPriority2[InteractionPriority2["HoverTooltip"] = 1e3] = "HoverTooltip";
+  InteractionPriority2[InteractionPriority2["CanvasPan"] = 900] = "CanvasPan";
+  InteractionPriority2[InteractionPriority2["CanvasZoom"] = 800] = "CanvasZoom";
+  InteractionPriority2[InteractionPriority2["MultiTouchGesture"] = 700] = "MultiTouchGesture";
+  return InteractionPriority2;
+})(InteractionPriority || {});
+class InteractionManager {
+  constructor() {
+    __publicField$2(this, "interactions", /* @__PURE__ */ new Map());
+  }
+  /**
+   * 获取当前活动的交互
+   */
+  get activeInteraction() {
+    return Array.from(this.interactions.values()).find((interaction) => interaction.active);
+  }
+  /**
+   * 检查是否可以交互
+   * @param pluginId 插件ID
+   * @param type 交互类型
+   * @param autoStartPriority 自动启动优先级
+   * @returns 是否可以交互
+   */
+  canInteract(pluginId, type, autoStartPriority) {
+    var _a, _b;
+    const interaction = this.interactions.get(pluginId + type);
+    if (!interaction && autoStartPriority) {
+      this.startInteraction(pluginId, type, autoStartPriority);
+    }
+    return (_b = (_a = this.interactions.get(pluginId + type)) == null ? void 0 : _a.active) != null ? _b : false;
+  }
+  /**
+   * 启动交互
+   * @param pluginId 插件ID
+   * @param type 交互类型
+   * @param priority 优先级
+   * @returns 取消交互的函数
+   */
+  startInteraction(pluginId, type, priority) {
+    this.interactions.set(pluginId + type, { pluginId, type, priority });
+    this.updateActive();
+    return () => {
+      this.endInteraction(pluginId, type);
+    };
+  }
+  /**
+   * 结束交互
+   * @param pluginId 插件ID
+   * @param type 交互类型
+   */
+  endInteraction(pluginId, type) {
+    this.interactions.delete(pluginId + type);
+    this.updateActive();
+  }
+  updateActive() {
+    const activeInteraction = Array.from(this.interactions.values()).reduce((acc, interaction) => {
+      if (acc) {
+        return interaction.priority >= acc.priority ? interaction : acc;
+      }
+      return interaction;
+    }, null);
+    this.interactions.values().forEach((interaction) => {
+      interaction.active = interaction === activeInteraction;
+    });
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+function getLayerRenders(plugin) {
+  var _a;
+  const components = [];
+  let isRenderConsumed = false;
+  for (const [name, layer] of Object.entries((_a = Reflect.get(plugin, getSymbol("layer"))) != null ? _a : {})) {
+    components.push(__spreadValues$1({
+      plugin: plugin.name,
+      name: `${plugin.name}:${name}`,
+      render: Reflect.get(plugin, name).bind(plugin)
+    }, layer));
+    if (name === "render") {
+      isRenderConsumed = true;
+    }
+  }
+  if (!isRenderConsumed && plugin.render) {
+    components.push({
+      plugin: plugin.name,
+      name: `${plugin.name}:render`,
+      layer: Layer$1.Foreground,
+      render: plugin.render.bind(plugin)
+    });
+  }
+  return components;
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+class Engine {
+  constructor(options) {
+    __publicField$1(this, "runtime");
+    __publicField$1(this, "interactionManager", new InteractionManager());
+    __publicField$1(this, "nodesManager");
+    __publicField$1(this, "edgesManager");
+    __publicField$1(this, "container$", new BehaviorSubject(null));
+    __publicField$1(this, "nodes$", new BehaviorSubject([]));
+    __publicField$1(this, "edges$", new BehaviorSubject([]));
+    __publicField$1(this, "layers$", new BehaviorSubject(/* @__PURE__ */ new Map()));
+    __publicField$1(this, "plugins$", new BehaviorSubject([]));
+    __publicField$1(this, "nodeRenderers$", new BehaviorSubject(/* @__PURE__ */ new Map()));
+    __publicField$1(this, "edgeRenderers$", new BehaviorSubject(/* @__PURE__ */ new Map()));
+    __publicField$1(this, "_pluginDataContainer", {});
+    var _a;
+    this.runtime = (_a = options.runtime) != null ? _a : {};
+    this.container$.next(options.container);
+    this.nodesManager = new DataManager("nodes");
+    this.edgesManager = new DataManager("edges");
+    this.nodesManager.getDataList$().subscribe(this.nodes$);
+    this.edgesManager.getDataList$().subscribe(this.edges$);
+    this.init(options);
+  }
+  get container() {
+    return this.container$.value;
+  }
+  set container(value) {
+    this.container$.next(value);
+  }
+  get nodes() {
+    return this.nodes$.value;
+  }
+  get edges() {
+    return this.edges$.value;
+  }
+  get layers() {
+    return this.layers$.value;
+  }
+  get plugins() {
+    return this.plugins$.value;
+  }
+  init(options) {
+    const { plugins = [], nodes = [], edges = [] } = options;
+    for (const def of plugins) {
+      let plugin;
+      if (Array.isArray(def)) {
+        plugin = new def[0](...def.slice(1));
+      } else if (typeof def === "function") {
+        if (Object.is(Reflect.getPrototypeOf(def), BasePlugin$1)) {
+          plugin = new def();
+        } else {
+          plugin = def();
+        }
+      }
+      if (plugin) {
+        if (this._pluginDataContainer[plugin.name]) {
+          console.warn(`Plugin ${plugin.name} already registered, please check the plugin definition`);
+          continue;
+        }
+        this._pluginDataContainer[plugin.name] = {};
+        const engineSymbol = getSymbol("engine");
+        if (!Reflect.has(plugin, engineSymbol)) {
+          Reflect.set(plugin, engineSymbol, new BehaviorSubject(null));
+        }
+        Reflect.get(plugin, engineSymbol).next(this);
+        const currentPlugins = this.plugins$.value || [];
+        this.plugins$.next([...currentPlugins, plugin]);
+        const currentLayers = this.layers$.value;
+        getLayerRenders(plugin).forEach((component) => {
+          const effectiveLayer = this.calculateEffectiveLayer(component.layer, component.offset);
+          const layerComponents = currentLayers.get(effectiveLayer) || [];
+          currentLayers.set(effectiveLayer, [...layerComponents, component]);
+        });
+        this.layers$.next(currentLayers);
+      }
+    }
+    this.plugins$.complete();
+    this.plugins$.value.forEach((plugin) => {
+      var _a;
+      return (_a = plugin.onInit) == null ? void 0 : _a.call(plugin);
+    });
+    this.nodesManager.init(nodes);
+    this.edgesManager.init(edges);
+  }
+  calculateEffectiveLayer(layer, offset) {
+    if (offset === void 0)
+      return layer;
+    return Math.max((layer >> 1) + 1, Math.min(layer << 1, layer + offset));
+  }
+  getLayerComponents(layer) {
+    return this.layers$.value.get(layer) || [];
+  }
+  addNodePipe(pipe) {
+    this.nodesManager.addDataOperationPipe(pipe);
+  }
+  addEdgePipe(pipe) {
+    this.edgesManager.addDataOperationPipe(pipe);
+  }
+  dispatchNodeOperation(operation) {
+    this.nodesManager.dispatch(operation);
+  }
+  dispatchEdgeOperation(operation) {
+    this.edgesManager.dispatch(operation);
+  }
+  getNode(id) {
+    return this.nodesManager.getData(id);
+  }
+  getNodeDraft(id) {
+    return this.nodesManager.getCurrentDraftData(id);
+  }
+  getNodes() {
+    return this.nodesManager.getDataList();
+  }
+  getNodeRenderer(type) {
+    return this.nodeRenderers$.value.get(type);
+  }
+  getEdge(id) {
+    return this.edgesManager.getData(id);
+  }
+  getEdgeDraft(id) {
+    return this.edgesManager.getCurrentDraftData(id);
+  }
+  getEdges() {
+    return this.edgesManager.getDataList();
+  }
+  getEdgeRenderer(type) {
+    return this.edgeRenderers$.value.get(type);
+  }
+  registerPluginData(pluginName, property, data) {
+    set(this, ["_pluginDataContainer", pluginName, property], data);
+  }
+  registerNodeRenderer(type, renderer) {
+    const nodeRenderers = this.nodeRenderers$.value;
+    nodeRenderers.set(type, renderer);
+    this.nodeRenderers$.next(nodeRenderers);
+  }
+  registerEdgeRenderer(type, renderer) {
+    const edgeRenderers = this.edgeRenderers$.value;
+    edgeRenderers.set(type, renderer);
+    this.edgeRenderers$.next(edgeRenderers);
+  }
+  canInteract(pluginId, type, autoStartPriority) {
+    return this.interactionManager.canInteract(pluginId, type, autoStartPriority);
+  }
+  startInteraction(pluginId, type, priority) {
+    this.interactionManager.startInteraction(pluginId, type, priority);
+  }
+  endInteraction(pluginId, type) {
+    this.interactionManager.endInteraction(pluginId, type);
+  }
+  destroy() {
+    this.plugins$.value.forEach((plugin) => {
+      var _a;
+      (_a = plugin.onDestroy) == null ? void 0 : _a.call(plugin);
+    });
+    this.plugins$.next([]);
+    this.container$.complete();
+    this.layers$.complete();
+    this.nodes$.complete();
+    this.edges$.complete();
+    this.nodeRenderers$.complete();
+    this.edgeRenderers$.complete();
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const _Runtime = class _Runtime {
+  constructor() {
+    /**
+     * 当前上下文
+     */
+    __publicField(this, "currentContext");
+  }
+  /**
+   * 在上下文中运行函数
+   * @param type 上下文类型
+   * @param handler 处理函数
+   * @param contextValue 上下文值
+   * @returns 处理函数的返回值
+   */
+  runInContext(type, handler, contextValue) {
+    this.currentContext = {
+      type,
+      value: contextValue
+    };
+    const result = handler();
+    this.currentContext = void 0;
+    return result;
+  }
+  /**
+   * 值处理器
+   */
+  getValue(engine, options) {
+    var _a, _b;
+    const { type: context, value: contextValue } = this.currentContext || {};
+    const getValue = ((_a = engine.runtime[context]) == null ? void 0 : _a.getValue) || _Runtime.DEFAULT_VALUE_HANDLER;
+    const value = getValue(
+      ((_b = options.matcher) == null ? void 0 : _b.call(options, engine)) || get(engine, options.paths),
+      __spreadProps(__spreadValues({}, options), { context: contextValue })
+    );
+    return value;
+  }
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new _Runtime();
+    }
+    return this.instance;
+  }
+};
+/**
+ * 获取 Runtime 实例
+ * @returns Runtime 实例
+ */
+__publicField(_Runtime, "instance");
+/**
+ * 默认值处理器
+ */
+__publicField(_Runtime, "DEFAULT_VALUE_HANDLER", (value, { selector = identity, context }) => selector(value instanceof BehaviorSubject ? value.value : value, context));
+let Runtime = _Runtime;
+
+function use(hook, context) {
+  return Runtime.getInstance().runInContext("render", hook, context);
+}
+
+export { BasePlugin, Engine, InteractionManager, InteractionPriority, Layer, Runtime, getLayerRenders, use };