@knotx/core 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 格桑
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,418 @@
+'use strict';
+
+const core = require('@knotx/core');
+const data = require('@knotx/data');
+const lodashEs = require('lodash-es');
+const rxjs = require('rxjs');
+const utils = require('@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, utils.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: core.Layer.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 rxjs.BehaviorSubject(null));
+    __publicField$1(this, "nodes$", new rxjs.BehaviorSubject([]));
+    __publicField$1(this, "edges$", new rxjs.BehaviorSubject([]));
+    __publicField$1(this, "layers$", new rxjs.BehaviorSubject(/* @__PURE__ */ new Map()));
+    __publicField$1(this, "plugins$", new rxjs.BehaviorSubject([]));
+    __publicField$1(this, "nodeRenderers$", new rxjs.BehaviorSubject(/* @__PURE__ */ new Map()));
+    __publicField$1(this, "edgeRenderers$", new rxjs.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 data.DataManager("nodes");
+    this.edgesManager = new data.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), core.BasePlugin)) {
+          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 = utils.getSymbol("engine");
+        if (!Reflect.has(plugin, engineSymbol)) {
+          Reflect.set(plugin, engineSymbol, new rxjs.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) {
+    lodashEs.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)) || lodashEs.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 = rxjs.identity, context }) => selector(value instanceof rxjs.BehaviorSubject ? value.value : value, context));
+let Runtime = _Runtime;
+
+function use(hook, context) {
+  return Runtime.getInstance().runInContext("render", hook, context);
+}
+
+exports.BasePlugin = BasePlugin;
+exports.Engine = Engine;
+exports.InteractionManager = InteractionManager;
+exports.InteractionPriority = InteractionPriority;
+exports.Layer = Layer;
+exports.Runtime = Runtime;
+exports.getLayerRenders = getLayerRenders;
+exports.use = use;
+Object.prototype.hasOwnProperty.call(utils, '__proto__') &&
+  !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
+  Object.defineProperty(exports, '__proto__', {
+    enumerable: true,
+    value: utils['__proto__']
+  });
+
+Object.keys(utils).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = utils[k];
+});