@knotx/core 0.2.4 → 0.2.6

package/dist/index.d.cts

@@ -1,8 +1,10 @@
-export { BasePlugin, Container, EdgeData, EdgeOperation, EdgeOperationPipe, EdgeOperatorFunction, EdgeProps, EdgeRenderType, HorizontalAlignment, IEngineRuntime, IPlugin, Layer, LayerComponent, NodeData, NodeMeasured, NodeOperation, NodeOperationPipe, NodeOperatorFunction, NodePosition, NodeProps, NodeRenderType, Plugin, PluginConfigs, PluginData, Position, RenderType, VerticalAlignment } from './definition.cjs';
-import { Container, Plugin, NodeData, EdgeData, IEngineRuntime, RenderType, LayerComponent, IPlugin, Layer, NodeRenderType, EdgeRenderType, PluginData, InteractionPriority as InteractionPriority$1 } from '@knotx/core';
+import { C as Container, P as Plugin, N as NodeData, E as EdgeData, I as IEngineRuntime, R as RenderType, L as LayerComponent, a as IPlugin, b as Layer, c as NodeRenderType, d as EdgeRenderType, e as PluginData, f as PluginTools, g as IPluginInfo, h as IPluginToolInfo } from './shared/core.BUBec6Va.cjs';
+export { B as BasePlugin, r as EdgeOperation, p as EdgeOperationPipe, t as EdgeOperatorFunction, l as EdgeProps, H as HorizontalAlignment, j as NodeMeasured, q as NodeOperation, o as NodeOperationPipe, s as NodeOperatorFunction, i as NodePosition, k as NodeProps, n as PluginConfigs, m as Position, V as VerticalAlignment } from './shared/core.BUBec6Va.cjs';
+import { Schema } from 'jsonschema';
 import { BehaviorSubject } from 'rxjs';
 import { DataManager, DataOperationPipe, DataOperation } from '@knotx/data';
 export * from '@knotx/data';
+import { RenderType as RenderType$1, IPlugin as IPlugin$1, LayerComponent as LayerComponent$1 } from '@knotx/core';
 export * from '@knotx/utils';
 
 /**
@@ -104,6 +106,8 @@ declare class Engine<TRenderType extends RenderType = RenderType> {
     private nodeRenderers$;
     private edgeRenderers$;
     private _pluginDataContainer;
+    private toolParamsValidator;
+    private _pluginToolsContainer;
     get container(): Container;
     set container(value: Container);
     get nodes(): NodeData<any>[];
@@ -114,8 +118,8 @@ declare class Engine<TRenderType extends RenderType = RenderType> {
     private init;
     private calculateEffectiveLayer;
     getLayerComponents(layer: Layer): LayerComponent<TRenderType>[];
-    addNodePipe(pipe: DataOperationPipe<NodeData>): void;
-    addEdgePipe(pipe: DataOperationPipe<EdgeData>): void;
+    addNodePipe(pipe: DataOperationPipe<NodeData>): () => void;
+    addEdgePipe(pipe: DataOperationPipe<EdgeData>): () => void;
     changePluginConfig(pluginName: string, config: Record<string, any>): void;
     dispatchNodeOperation(operation: DataOperation<NodeData>): void;
     dispatchEdgeOperation(operation: DataOperation<EdgeData>): void;
@@ -128,15 +132,26 @@ declare class Engine<TRenderType extends RenderType = RenderType> {
     getEdges(): EdgeData[];
     getEdgeRenderer(type: string): EdgeRenderType | undefined;
     registerPluginData<T extends keyof PluginData, TP extends keyof PluginData[T]>(pluginName: T, property: TP, data: BehaviorSubject<PluginData[T][TP]>): void;
-    registerNodeRenderer(type: string, renderer: NodeRenderType): void;
-    registerEdgeRenderer(type: string, renderer: EdgeRenderType): void;
-    canInteract(pluginId: string, type: string, autoStartPriority?: InteractionPriority$1): boolean;
-    startInteraction(pluginId: string, type: string, priority: InteractionPriority$1): void;
+    resetPluginData<T extends keyof PluginData>(pluginName: T): void;
+    registerPluginTool<T extends keyof PluginTools, TP extends keyof PluginTools[T]>(pluginName: T, property: TP, data: {
+        description: string;
+        params: Schema;
+        func: PluginTools[T][TP];
+    }): void;
+    resetPluginTool<T extends keyof PluginTools>(pluginName: T): void;
+    registerNodeRenderer(type: string, renderer: NodeRenderType): () => void;
+    registerEdgeRenderer(type: string, renderer: EdgeRenderType): (() => void);
+    canInteract(pluginId: string, type: string, autoStartPriority?: InteractionPriority): boolean;
+    startInteraction(pluginId: string, type: string, priority: InteractionPriority): void;
     endInteraction(pluginId: string, type: string): void;
+    callTool<T extends keyof PluginTools, TP extends keyof PluginTools[T]>(pluginName: T, toolName: TP, params: any): any;
+    listPlugins(): IPluginInfo[];
+    listPluginTools(pluginName: string): IPluginToolInfo[];
+    listEngineTools(): IPluginToolInfo[];
     destroy(): void;
 }
 
-declare function getLayerRenders<TRenderType extends RenderType = RenderType>(plugin: IPlugin): LayerComponent<TRenderType>[];
+declare function getLayerRenders<TRenderType extends RenderType$1 = RenderType$1>(plugin: IPlugin$1): LayerComponent$1<TRenderType>[];
 
 /**
  * Runtime 类
@@ -199,4 +214,4 @@ declare function use<T, TContext>(hook: () => {
     __contextValue__: TContext;
 }, context: TContext): T;
 
-export { Engine, type EngineOptions, type Interaction, InteractionManager, InteractionPriority, Runtime, getLayerRenders, use };
+export { Container, EdgeData, EdgeRenderType, Engine, type EngineOptions, IEngineRuntime, IPlugin, IPluginInfo, IPluginToolInfo, type Interaction, InteractionManager, InteractionPriority, Layer, LayerComponent, NodeData, NodeRenderType, Plugin, PluginData, PluginTools, RenderType, Runtime, getLayerRenders, use };

package/dist/index.d.mts

@@ -1,8 +1,10 @@
-export { BasePlugin, Container, EdgeData, EdgeOperation, EdgeOperationPipe, EdgeOperatorFunction, EdgeProps, EdgeRenderType, HorizontalAlignment, IEngineRuntime, IPlugin, Layer, LayerComponent, NodeData, NodeMeasured, NodeOperation, NodeOperationPipe, NodeOperatorFunction, NodePosition, NodeProps, NodeRenderType, Plugin, PluginConfigs, PluginData, Position, RenderType, VerticalAlignment } from './definition.mjs';
-import { Container, Plugin, NodeData, EdgeData, IEngineRuntime, RenderType, LayerComponent, IPlugin, Layer, NodeRenderType, EdgeRenderType, PluginData, InteractionPriority as InteractionPriority$1 } from '@knotx/core';
+import { C as Container, P as Plugin, N as NodeData, E as EdgeData, I as IEngineRuntime, R as RenderType, L as LayerComponent, a as IPlugin, b as Layer, c as NodeRenderType, d as EdgeRenderType, e as PluginData, f as PluginTools, g as IPluginInfo, h as IPluginToolInfo } from './shared/core.BUBec6Va.mjs';
+export { B as BasePlugin, r as EdgeOperation, p as EdgeOperationPipe, t as EdgeOperatorFunction, l as EdgeProps, H as HorizontalAlignment, j as NodeMeasured, q as NodeOperation, o as NodeOperationPipe, s as NodeOperatorFunction, i as NodePosition, k as NodeProps, n as PluginConfigs, m as Position, V as VerticalAlignment } from './shared/core.BUBec6Va.mjs';
+import { Schema } from 'jsonschema';
 import { BehaviorSubject } from 'rxjs';
 import { DataManager, DataOperationPipe, DataOperation } from '@knotx/data';
 export * from '@knotx/data';
+import { RenderType as RenderType$1, IPlugin as IPlugin$1, LayerComponent as LayerComponent$1 } from '@knotx/core';
 export * from '@knotx/utils';
 
 /**
@@ -104,6 +106,8 @@ declare class Engine<TRenderType extends RenderType = RenderType> {
     private nodeRenderers$;
     private edgeRenderers$;
     private _pluginDataContainer;
+    private toolParamsValidator;
+    private _pluginToolsContainer;
     get container(): Container;
     set container(value: Container);
     get nodes(): NodeData<any>[];
@@ -114,8 +118,8 @@ declare class Engine<TRenderType extends RenderType = RenderType> {
     private init;
     private calculateEffectiveLayer;
     getLayerComponents(layer: Layer): LayerComponent<TRenderType>[];
-    addNodePipe(pipe: DataOperationPipe<NodeData>): void;
-    addEdgePipe(pipe: DataOperationPipe<EdgeData>): void;
+    addNodePipe(pipe: DataOperationPipe<NodeData>): () => void;
+    addEdgePipe(pipe: DataOperationPipe<EdgeData>): () => void;
     changePluginConfig(pluginName: string, config: Record<string, any>): void;
     dispatchNodeOperation(operation: DataOperation<NodeData>): void;
     dispatchEdgeOperation(operation: DataOperation<EdgeData>): void;
@@ -128,15 +132,26 @@ declare class Engine<TRenderType extends RenderType = RenderType> {
     getEdges(): EdgeData[];
     getEdgeRenderer(type: string): EdgeRenderType | undefined;
     registerPluginData<T extends keyof PluginData, TP extends keyof PluginData[T]>(pluginName: T, property: TP, data: BehaviorSubject<PluginData[T][TP]>): void;
-    registerNodeRenderer(type: string, renderer: NodeRenderType): void;
-    registerEdgeRenderer(type: string, renderer: EdgeRenderType): void;
-    canInteract(pluginId: string, type: string, autoStartPriority?: InteractionPriority$1): boolean;
-    startInteraction(pluginId: string, type: string, priority: InteractionPriority$1): void;
+    resetPluginData<T extends keyof PluginData>(pluginName: T): void;
+    registerPluginTool<T extends keyof PluginTools, TP extends keyof PluginTools[T]>(pluginName: T, property: TP, data: {
+        description: string;
+        params: Schema;
+        func: PluginTools[T][TP];
+    }): void;
+    resetPluginTool<T extends keyof PluginTools>(pluginName: T): void;
+    registerNodeRenderer(type: string, renderer: NodeRenderType): () => void;
+    registerEdgeRenderer(type: string, renderer: EdgeRenderType): (() => void);
+    canInteract(pluginId: string, type: string, autoStartPriority?: InteractionPriority): boolean;
+    startInteraction(pluginId: string, type: string, priority: InteractionPriority): void;
     endInteraction(pluginId: string, type: string): void;
+    callTool<T extends keyof PluginTools, TP extends keyof PluginTools[T]>(pluginName: T, toolName: TP, params: any): any;
+    listPlugins(): IPluginInfo[];
+    listPluginTools(pluginName: string): IPluginToolInfo[];
+    listEngineTools(): IPluginToolInfo[];
     destroy(): void;
 }
 
-declare function getLayerRenders<TRenderType extends RenderType = RenderType>(plugin: IPlugin): LayerComponent<TRenderType>[];
+declare function getLayerRenders<TRenderType extends RenderType$1 = RenderType$1>(plugin: IPlugin$1): LayerComponent$1<TRenderType>[];
 
 /**
  * Runtime 类
@@ -199,4 +214,4 @@ declare function use<T, TContext>(hook: () => {
     __contextValue__: TContext;
 }, context: TContext): T;
 
-export { Engine, type EngineOptions, type Interaction, InteractionManager, InteractionPriority, Runtime, getLayerRenders, use };
+export { Container, EdgeData, EdgeRenderType, Engine, type EngineOptions, IEngineRuntime, IPlugin, IPluginInfo, IPluginToolInfo, type Interaction, InteractionManager, InteractionPriority, Layer, LayerComponent, NodeData, NodeRenderType, Plugin, PluginData, PluginTools, RenderType, Runtime, getLayerRenders, use };

package/dist/index.d.ts

@@ -1,8 +1,10 @@
-export { BasePlugin, Container, EdgeData, EdgeOperation, EdgeOperationPipe, EdgeOperatorFunction, EdgeProps, EdgeRenderType, HorizontalAlignment, IEngineRuntime, IPlugin, Layer, LayerComponent, NodeData, NodeMeasured, NodeOperation, NodeOperationPipe, NodeOperatorFunction, NodePosition, NodeProps, NodeRenderType, Plugin, PluginConfigs, PluginData, Position, RenderType, VerticalAlignment } from './definition.js';
-import { Container, Plugin, NodeData, EdgeData, IEngineRuntime, RenderType, LayerComponent, IPlugin, Layer, NodeRenderType, EdgeRenderType, PluginData, InteractionPriority as InteractionPriority$1 } from '@knotx/core';
+import { C as Container, P as Plugin, N as NodeData, E as EdgeData, I as IEngineRuntime, R as RenderType, L as LayerComponent, a as IPlugin, b as Layer, c as NodeRenderType, d as EdgeRenderType, e as PluginData, f as PluginTools, g as IPluginInfo, h as IPluginToolInfo } from './shared/core.BUBec6Va.js';
+export { B as BasePlugin, r as EdgeOperation, p as EdgeOperationPipe, t as EdgeOperatorFunction, l as EdgeProps, H as HorizontalAlignment, j as NodeMeasured, q as NodeOperation, o as NodeOperationPipe, s as NodeOperatorFunction, i as NodePosition, k as NodeProps, n as PluginConfigs, m as Position, V as VerticalAlignment } from './shared/core.BUBec6Va.js';
+import { Schema } from 'jsonschema';
 import { BehaviorSubject } from 'rxjs';
 import { DataManager, DataOperationPipe, DataOperation } from '@knotx/data';
 export * from '@knotx/data';
+import { RenderType as RenderType$1, IPlugin as IPlugin$1, LayerComponent as LayerComponent$1 } from '@knotx/core';
 export * from '@knotx/utils';
 
 /**
@@ -104,6 +106,8 @@ declare class Engine<TRenderType extends RenderType = RenderType> {
     private nodeRenderers$;
     private edgeRenderers$;
     private _pluginDataContainer;
+    private toolParamsValidator;
+    private _pluginToolsContainer;
     get container(): Container;
     set container(value: Container);
     get nodes(): NodeData<any>[];
@@ -114,8 +118,8 @@ declare class Engine<TRenderType extends RenderType = RenderType> {
     private init;
     private calculateEffectiveLayer;
     getLayerComponents(layer: Layer): LayerComponent<TRenderType>[];
-    addNodePipe(pipe: DataOperationPipe<NodeData>): void;
-    addEdgePipe(pipe: DataOperationPipe<EdgeData>): void;
+    addNodePipe(pipe: DataOperationPipe<NodeData>): () => void;
+    addEdgePipe(pipe: DataOperationPipe<EdgeData>): () => void;
     changePluginConfig(pluginName: string, config: Record<string, any>): void;
     dispatchNodeOperation(operation: DataOperation<NodeData>): void;
     dispatchEdgeOperation(operation: DataOperation<EdgeData>): void;
@@ -128,15 +132,26 @@ declare class Engine<TRenderType extends RenderType = RenderType> {
     getEdges(): EdgeData[];
     getEdgeRenderer(type: string): EdgeRenderType | undefined;
     registerPluginData<T extends keyof PluginData, TP extends keyof PluginData[T]>(pluginName: T, property: TP, data: BehaviorSubject<PluginData[T][TP]>): void;
-    registerNodeRenderer(type: string, renderer: NodeRenderType): void;
-    registerEdgeRenderer(type: string, renderer: EdgeRenderType): void;
-    canInteract(pluginId: string, type: string, autoStartPriority?: InteractionPriority$1): boolean;
-    startInteraction(pluginId: string, type: string, priority: InteractionPriority$1): void;
+    resetPluginData<T extends keyof PluginData>(pluginName: T): void;
+    registerPluginTool<T extends keyof PluginTools, TP extends keyof PluginTools[T]>(pluginName: T, property: TP, data: {
+        description: string;
+        params: Schema;
+        func: PluginTools[T][TP];
+    }): void;
+    resetPluginTool<T extends keyof PluginTools>(pluginName: T): void;
+    registerNodeRenderer(type: string, renderer: NodeRenderType): () => void;
+    registerEdgeRenderer(type: string, renderer: EdgeRenderType): (() => void);
+    canInteract(pluginId: string, type: string, autoStartPriority?: InteractionPriority): boolean;
+    startInteraction(pluginId: string, type: string, priority: InteractionPriority): void;
     endInteraction(pluginId: string, type: string): void;
+    callTool<T extends keyof PluginTools, TP extends keyof PluginTools[T]>(pluginName: T, toolName: TP, params: any): any;
+    listPlugins(): IPluginInfo[];
+    listPluginTools(pluginName: string): IPluginToolInfo[];
+    listEngineTools(): IPluginToolInfo[];
     destroy(): void;
 }
 
-declare function getLayerRenders<TRenderType extends RenderType = RenderType>(plugin: IPlugin): LayerComponent<TRenderType>[];
+declare function getLayerRenders<TRenderType extends RenderType$1 = RenderType$1>(plugin: IPlugin$1): LayerComponent$1<TRenderType>[];
 
 /**
  * Runtime 类
@@ -199,4 +214,4 @@ declare function use<T, TContext>(hook: () => {
     __contextValue__: TContext;
 }, context: TContext): T;
 
-export { Engine, type EngineOptions, type Interaction, InteractionManager, InteractionPriority, Runtime, getLayerRenders, use };
+export { Container, EdgeData, EdgeRenderType, Engine, type EngineOptions, IEngineRuntime, IPlugin, IPluginInfo, IPluginToolInfo, type Interaction, InteractionManager, InteractionPriority, Layer, LayerComponent, NodeData, NodeRenderType, Plugin, PluginData, PluginTools, RenderType, Runtime, getLayerRenders, use };

package/dist/index.js

@@ -1,4 +1,5 @@
-export { BasePlugin, Layer } from './definition.js';
+export { Layer } from './definition.js';
+import { Validator } from 'jsonschema';
 import { set, get } from 'lodash-es';
 import { BehaviorSubject, identity } from 'rxjs';
 import { Layer } from '@knotx/core';
@@ -7,9 +8,9 @@ export * from '@knotx/utils';
 import { DataManager } from '@knotx/data';
 export * from '@knotx/data';
 
-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 __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 InteractionPriority = /* @__PURE__ */ ((InteractionPriority2) => {
   InteractionPriority2[InteractionPriority2["InputActive"] = 2e3] = "InputActive";
   InteractionPriority2[InteractionPriority2["EntityConnectDrag"] = 1930] = "EntityConnectDrag";
@@ -31,7 +32,7 @@ var InteractionPriority = /* @__PURE__ */ ((InteractionPriority2) => {
 })(InteractionPriority || {});
 class InteractionManager {
   constructor() {
-    __publicField$2(this, "interactions", /* @__PURE__ */ new Map());
+    __publicField$3(this, "interactions", /* @__PURE__ */ new Map());
   }
   /**
    * 获取当前活动的交互
@@ -90,19 +91,19 @@ class InteractionManager {
   }
 }
 
-var __defProp$2 = Object.defineProperty;
+var __defProp$3 = 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 __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(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]);
+      __defNormalProp$3(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]);
+        __defNormalProp$3(a, prop, b[prop]);
     }
   return a;
 };
@@ -131,23 +132,25 @@ function getLayerRenders(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);
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(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", {});
+    __publicField$2(this, "runtime");
+    __publicField$2(this, "interactionManager", new InteractionManager());
+    __publicField$2(this, "nodesManager");
+    __publicField$2(this, "edgesManager");
+    __publicField$2(this, "container$", new BehaviorSubject(null));
+    __publicField$2(this, "nodes$", new BehaviorSubject([]));
+    __publicField$2(this, "edges$", new BehaviorSubject([]));
+    __publicField$2(this, "layers$", new BehaviorSubject(/* @__PURE__ */ new Map()));
+    __publicField$2(this, "plugins$", new BehaviorSubject([]));
+    __publicField$2(this, "nodeRenderers$", new BehaviorSubject(/* @__PURE__ */ new Map()));
+    __publicField$2(this, "edgeRenderers$", new BehaviorSubject(/* @__PURE__ */ new Map()));
+    __publicField$2(this, "_pluginDataContainer", {});
+    __publicField$2(this, "toolParamsValidator", new Validator());
+    __publicField$2(this, "_pluginToolsContainer", {});
     var _a;
     this.runtime = (_a = options.runtime) != null ? _a : {};
     this.container$.next(options.container);
@@ -184,6 +187,7 @@ class Engine {
         continue;
       }
       this._pluginDataContainer[plugin.name] = {};
+      this._pluginToolsContainer[plugin.name] = {};
       const engineSymbol = getSymbol("engine");
       if (!Reflect.has(plugin, engineSymbol)) {
         Reflect.set(plugin, engineSymbol, new BehaviorSubject(null));
@@ -216,10 +220,10 @@ class Engine {
     return this.layers$.value.get(layer) || [];
   }
   addNodePipe(pipe) {
-    this.nodesManager.addDataOperationPipe(pipe);
+    return this.nodesManager.addDataOperationPipe(pipe);
   }
   addEdgePipe(pipe) {
-    this.edgesManager.addDataOperationPipe(pipe);
+    return this.edgesManager.addDataOperationPipe(pipe);
   }
   changePluginConfig(pluginName, config) {
     var _a, _b;
@@ -258,15 +262,34 @@ class Engine {
   registerPluginData(pluginName, property, data) {
     set(this, ["_pluginDataContainer", pluginName, property], data);
   }
+  resetPluginData(pluginName) {
+    set(this, ["_pluginDataContainer", pluginName], void 0);
+  }
+  registerPluginTool(pluginName, property, data) {
+    set(this, ["_pluginToolsContainer", pluginName, property], data);
+  }
+  resetPluginTool(pluginName) {
+    set(this, ["_pluginToolsContainer", pluginName], void 0);
+  }
   registerNodeRenderer(type, renderer) {
     const nodeRenderers = this.nodeRenderers$.value;
     nodeRenderers.set(type, renderer);
     this.nodeRenderers$.next(nodeRenderers);
+    return () => {
+      const nodeRenderers2 = this.nodeRenderers$.value;
+      nodeRenderers2.delete(type);
+      this.nodeRenderers$.next(nodeRenderers2);
+    };
   }
   registerEdgeRenderer(type, renderer) {
     const edgeRenderers = this.edgeRenderers$.value;
     edgeRenderers.set(type, renderer);
     this.edgeRenderers$.next(edgeRenderers);
+    return () => {
+      const edgeRenderers2 = this.edgeRenderers$.value;
+      edgeRenderers2.delete(type);
+      this.edgeRenderers$.next(edgeRenderers2);
+    };
   }
   canInteract(pluginId, type, autoStartPriority) {
     return this.interactionManager.canInteract(pluginId, type, autoStartPriority);
@@ -277,6 +300,54 @@ class Engine {
   endInteraction(pluginId, type) {
     this.interactionManager.endInteraction(pluginId, type);
   }
+  callTool(pluginName, toolName, params) {
+    const toolDefinition = get(this, ["_pluginToolsContainer", pluginName, toolName]);
+    const tool = toolDefinition == null ? void 0 : toolDefinition.func;
+    if (!tool || typeof tool !== "function") {
+      throw new Error(`Tool ${String(toolName)} not found in plugin ${pluginName}`);
+    }
+    const validator = this.toolParamsValidator.validate(params, toolDefinition.params);
+    if (validator.errors.length > 0) {
+      throw new Error(`Invalid tool params: ${validator.errors.map((e) => e.stack).join(", ")}`);
+    }
+    return tool(params);
+  }
+  listPlugins() {
+    return this.plugins$.value.map((plugin) => ({
+      name: plugin.name,
+      description: plugin.description
+    }));
+  }
+  listPluginTools(pluginName) {
+    return Object.entries(get(this, ["_pluginToolsContainer", pluginName]) || {}).map(([toolName, toolDefinition]) => ({
+      type: "function",
+      name: toolName,
+      description: toolDefinition.description,
+      parameters: toolDefinition.params
+    }));
+  }
+  listEngineTools() {
+    return [
+      {
+        type: "function",
+        name: "listPlugins",
+        description: "List all plugins",
+        parameters: {}
+      },
+      {
+        type: "function",
+        name: "listPluginTools",
+        description: "List all tools of a plugin",
+        parameters: {
+          type: "object",
+          properties: {
+            pluginName: { type: "string" }
+          },
+          required: ["pluginName"]
+        }
+      }
+    ];
+  }
   destroy() {
     this.plugins$.value.forEach((plugin) => {
       var _a;
@@ -289,9 +360,44 @@ class Engine {
     this.edges$.complete();
     this.nodeRenderers$.complete();
     this.edgeRenderers$.complete();
+    this._pluginToolsContainer = {};
+    this._pluginDataContainer = {};
   }
 }
 
+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);
+const _BasePlugin = class _BasePlugin {
+  constructor(__) {
+    __publicField$1(this, "_instanceId", _BasePlugin._instanceId++);
+    /**
+     * 插件生命周期中的订阅回调
+     * 可随时存入，销毁时会自动执行
+     */
+    __publicField$1(this, "subscriptions", []);
+    Reflect.set(this, getSymbol("engine"), new BehaviorSubject(null));
+  }
+  get pluginId() {
+    return `${this.name}:${this._instanceId}`;
+  }
+  onDestroy() {
+    this.subscriptions.forEach((subscription) => {
+      if (typeof subscription === "function") {
+        subscription();
+      } else {
+        subscription.unsubscribe();
+      }
+    });
+    const engin$ = Reflect.get(this, getSymbol("engine"));
+    engin$.value.resetPluginData(this.name);
+    engin$.value.resetPluginTool(this.name);
+    engin$.complete();
+  }
+};
+__publicField$1(_BasePlugin, "_instanceId", 0);
+let BasePlugin = _BasePlugin;
+
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
@@ -370,4 +476,4 @@ function use(hook, context) {
   return Runtime.getInstance().runInContext("render", hook, context);
 }
 
-export { Engine, InteractionManager, InteractionPriority, Runtime, getLayerRenders, use };
+export { BasePlugin, Engine, InteractionManager, InteractionPriority, Runtime, getLayerRenders, use };

package/dist/shared/core.BUBec6Va.d.cts

@@ -0,0 +1,145 @@
+import { Schema } from 'jsonschema';
+import { SubscriptionLike, BehaviorSubject } from 'rxjs';
+import { DataOperationPipe, DataOperation } from '@knotx/data';
+
+declare abstract class BasePlugin<TPluginName extends string = string, TPluginConfig extends Record<string, any> | undefined = undefined, TRenderType extends RenderType = RenderType> implements IPlugin<TPluginName, TPluginConfig, TRenderType> {
+    abstract name: TPluginName;
+    constructor(__: TPluginConfig);
+    private static _instanceId;
+    private _instanceId;
+    get pluginId(): string;
+    /**
+     * 插件生命周期中的订阅回调
+     * 可随时存入，销毁时会自动执行
+     */
+    protected subscriptions: (SubscriptionLike | (() => void))[];
+    onDestroy(): void;
+}
+
+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: EdgeData<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, TPluginConfig extends Record<string, any> | undefined = any, TRenderType extends RenderType = RenderType> {
+    name: TPluginName;
+    pluginId: string;
+    description?: string;
+    onInit?: (config: TPluginConfig) => void;
+    onConfigChange?: (config: TPluginConfig) => void;
+    onDestroy?: () => void;
+    render?: (...args: Parameters<TRenderType>) => ReturnType<TRenderType>;
+}
+type Plugin<TName extends string = string, TConfig extends Record<string, any> | undefined = any, TRenderType extends RenderType = RenderType> = new (__: TConfig) => BasePlugin<TName, TConfig, TRenderType>;
+type PluginConfigs<TPlugins extends Plugin[]> = ((TPlugins[number] extends Plugin<infer T> ? {
+    [TName in T as Extract<TPlugins[number], Plugin<TName>> extends Plugin<TName, undefined> ? never : TName]: Extract<TPlugins[number], Plugin<TName>> extends infer T ? T extends Plugin<TName, infer TConfig> ? TConfig : never : never;
+} : {}));
+/**
+ * plugin data host
+ * @example
+ * `declare module '@knotx/core' {
+ *   interface PluginData {
+ *     pluginName: {
+ *       property: any
+ *     }
+ *   }
+ * }`
+ */
+interface PluginData {
+}
+/**
+ * plugin tools host
+ * @example
+ * `declare module '@knotx/core' {
+ *   interface PluginTools {
+ *     pluginName: {
+ *       toolName: (params: any) => any
+ *     }
+ *   }
+ * }`
+ */
+interface PluginTools {
+}
+interface IPluginInfo {
+    name: string;
+    description?: string;
+}
+interface IPluginToolInfo {
+    type: 'function';
+    name: string;
+    description: string;
+    parameters: Schema;
+}
+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;
+    };
+}
+
+export { BasePlugin as B, type Container as C, type EdgeData as E, type HorizontalAlignment as H, type IEngineRuntime as I, type LayerComponent as L, type NodeData as N, type Plugin as P, type RenderType as R, type VerticalAlignment as V, type IPlugin as a, Layer as b, type NodeRenderType as c, type EdgeRenderType as d, type PluginData as e, type PluginTools as f, type IPluginInfo as g, type IPluginToolInfo as h, type NodePosition as i, type NodeMeasured as j, type NodeProps as k, type EdgeProps as l, type Position as m, type PluginConfigs as n, type NodeOperationPipe as o, type EdgeOperationPipe as p, type NodeOperation as q, type EdgeOperation as r, type NodeOperatorFunction as s, type EdgeOperatorFunction as t };