rendx-connect-plugin 0.2.0

package/dist/main.js

@@ -0,0 +1,519 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/connect.ts
+import { uid8 } from "rendx-core";
+import { Node as EngineNode } from "rendx-engine";
+var DEFAULT_CLASS_NAME = "connectable";
+var DEFAULT_SNAP_RADIUS = 20;
+var DEFAULT_CURSOR = "crosshair";
+var DEFAULT_PREVIEW_STROKE = "#1890ff";
+var DEFAULT_PREVIEW_STROKE_WIDTH = 2;
+var DEFAULT_PREVIEW_DASH = [6, 4];
+var DEFAULT_LINE_STROKE = "#999";
+var DEFAULT_LINE_STROKE_WIDTH = 2;
+var _app, _opts, _state, _source, _sourceAnchor, _snapTarget, _previewLine, _overlayLayer, _connections, _cleanups, _ConnectPlugin_instances, createPreviewLine_fn, showPreview_fn, hidePreview_fn, bindEvents_fn, _onPointerDown, _onPointerMove, _onPointerUp, _onKeyDown, completeConnect_fn, cancelConnect_fn, cleanupState_fn, reset_fn, createEdge_fn, buildEdgeData_fn, createEngineLine_fn, resolveConnectable_fn, findSnapTarget_fn, collectConnectables_fn, isSameElement_fn, getAnchor_fn, defaultAnchor_fn, resolveElementId_fn, getGraph_fn, isDragActive_fn;
+var ConnectPlugin = class {
+  // ──────────────────────────────────────────────────────────
+  constructor(options = {}) {
+    __privateAdd(this, _ConnectPlugin_instances);
+    this.name = "connect";
+    this.state = [
+      { key: "connect:connecting", description: "\u662F\u5426\u6B63\u5728\u8FDE\u63A5", initial: false },
+      { key: "connect:source", description: "\u8FDE\u63A5\u8D77\u70B9 Graphics", initial: null }
+    ];
+    this.layers = [{ name: "selection", zIndex: 10 }];
+    // ── 私有字段 ──
+    __privateAdd(this, _app, null);
+    __privateAdd(this, _opts);
+    /** 状态机 */
+    __privateAdd(this, _state, 0 /* Idle */);
+    /** 连接起点 */
+    __privateAdd(this, _source, null);
+    /** 起点世界坐标 */
+    __privateAdd(this, _sourceAnchor, [0, 0]);
+    /** 当前吸附的目标 */
+    __privateAdd(this, _snapTarget, null);
+    /** 预览线 Node */
+    __privateAdd(this, _previewLine, null);
+    /** overlay 层（与 selection-plugin 共享的交互层） */
+    __privateAdd(this, _overlayLayer, null);
+    /** 纯引擎模式下维护的连接列表 */
+    __privateAdd(this, _connections, /* @__PURE__ */ new Map());
+    /** 清理回调 */
+    __privateAdd(this, _cleanups, []);
+    // ════════════════════════════════════════════════════════════
+    //  Internal — 事件回调
+    // ════════════════════════════════════════════════════════════
+    __privateAdd(this, _onPointerDown, (e) => {
+      if (__privateGet(this, _state) !== 0 /* Idle */) return;
+      if (__privateMethod(this, _ConnectPlugin_instances, isDragActive_fn).call(this)) return;
+      const source = __privateMethod(this, _ConnectPlugin_instances, resolveConnectable_fn).call(this, e.target);
+      if (!source) return;
+      __privateSet(this, _source, source);
+      __privateSet(this, _sourceAnchor, __privateMethod(this, _ConnectPlugin_instances, getAnchor_fn).call(this, source));
+      __privateSet(this, _state, 1 /* Connecting */);
+      __privateGet(this, _app).setCursor(__privateGet(this, _opts).cursor);
+      __privateGet(this, _app).setState("connect:connecting", true);
+      __privateGet(this, _app).setState("connect:source", source);
+      __privateMethod(this, _ConnectPlugin_instances, showPreview_fn).call(this, __privateGet(this, _sourceAnchor)[0], __privateGet(this, _sourceAnchor)[1], e.worldX, e.worldY);
+      __privateGet(this, _app).requestRender();
+      __privateGet(this, _app).bus.emit("connect:start", {
+        source,
+        origin: [e.worldX, e.worldY]
+      });
+    });
+    __privateAdd(this, _onPointerMove, (e) => {
+      if (__privateGet(this, _state) !== 1 /* Connecting */) return;
+      const worldX = e.worldX;
+      const worldY = e.worldY;
+      __privateSet(this, _snapTarget, __privateMethod(this, _ConnectPlugin_instances, findSnapTarget_fn).call(this, worldX, worldY));
+      let endX = worldX;
+      let endY = worldY;
+      if (__privateGet(this, _snapTarget)) {
+        const anchor = __privateMethod(this, _ConnectPlugin_instances, getAnchor_fn).call(this, __privateGet(this, _snapTarget));
+        endX = anchor[0];
+        endY = anchor[1];
+      }
+      __privateMethod(this, _ConnectPlugin_instances, showPreview_fn).call(this, __privateGet(this, _sourceAnchor)[0], __privateGet(this, _sourceAnchor)[1], endX, endY);
+      __privateGet(this, _app).requestRender();
+      __privateGet(this, _app).bus.emit("connect:move", {
+        source: __privateGet(this, _source),
+        cursor: [worldX, worldY],
+        snapTarget: __privateGet(this, _snapTarget)
+      });
+    });
+    __privateAdd(this, _onPointerUp, () => {
+      if (__privateGet(this, _state) !== 1 /* Connecting */) return;
+      if (__privateGet(this, _snapTarget)) {
+        __privateMethod(this, _ConnectPlugin_instances, completeConnect_fn).call(this, __privateGet(this, _snapTarget));
+      } else {
+        __privateMethod(this, _ConnectPlugin_instances, cancelConnect_fn).call(this);
+      }
+    });
+    __privateAdd(this, _onKeyDown, (e) => {
+      if (e.key === "Escape" && __privateGet(this, _state) === 1 /* Connecting */) {
+        __privateMethod(this, _ConnectPlugin_instances, cancelConnect_fn).call(this);
+      }
+    });
+    __privateSet(this, _opts, {
+      className: options.className ?? DEFAULT_CLASS_NAME,
+      canConnect: options.canConnect ?? null,
+      allowSelfLoop: options.allowSelfLoop ?? false,
+      anchor: options.anchor ?? null,
+      edgeType: options.edgeType ?? null,
+      edgeFactory: options.edgeFactory ?? null,
+      lineStroke: options.lineStyle?.stroke ?? DEFAULT_LINE_STROKE,
+      lineStrokeWidth: options.lineStyle?.strokeWidth ?? DEFAULT_LINE_STROKE_WIDTH,
+      previewStroke: options.previewStroke ?? DEFAULT_PREVIEW_STROKE,
+      previewStrokeWidth: options.previewStrokeWidth ?? DEFAULT_PREVIEW_STROKE_WIDTH,
+      previewDash: options.previewDash ?? DEFAULT_PREVIEW_DASH,
+      previewPath: options.previewPath ?? null,
+      snapRadius: options.snapRadius ?? DEFAULT_SNAP_RADIUS,
+      cursor: options.cursor ?? DEFAULT_CURSOR
+    });
+  }
+  // ════════════════════════════════════════════════════════════
+  //  Plugin lifecycle
+  // ════════════════════════════════════════════════════════════
+  install(app) {
+    __privateSet(this, _app, app);
+    __privateSet(this, _overlayLayer, app.getLayer("selection"));
+    __privateGet(this, _overlayLayer).setPointerEvents(false);
+    __privateGet(this, _overlayLayer).culling = false;
+    __privateMethod(this, _ConnectPlugin_instances, createPreviewLine_fn).call(this);
+    __privateMethod(this, _ConnectPlugin_instances, bindEvents_fn).call(this);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  resize(_w, _h) {
+  }
+  serialize() {
+    const connections = [];
+    for (const conn of __privateGet(this, _connections).values()) {
+      connections.push({
+        id: conn.id,
+        sourceUid: conn.source.uid,
+        targetUid: conn.target.uid
+      });
+    }
+    return { connections };
+  }
+  dispose() {
+    if (__privateGet(this, _state) === 1 /* Connecting */) {
+      __privateMethod(this, _ConnectPlugin_instances, cancelConnect_fn).call(this);
+    }
+    for (const conn of __privateGet(this, _connections).values()) {
+      if (conn.line.parent) {
+        conn.line.parent.remove(conn.line);
+      }
+    }
+    __privateGet(this, _connections).clear();
+    if (__privateGet(this, _previewLine)) {
+      __privateGet(this, _overlayLayer)?.remove(__privateGet(this, _previewLine));
+    }
+    __privateSet(this, _previewLine, null);
+    for (const fn of __privateGet(this, _cleanups)) fn();
+    __privateSet(this, _cleanups, []);
+    __privateGet(this, _app)?.resetCursor();
+    __privateMethod(this, _ConnectPlugin_instances, reset_fn).call(this);
+    __privateSet(this, _app, null);
+  }
+  // ════════════════════════════════════════════════════════════
+  //  Public API
+  // ════════════════════════════════════════════════════════════
+  /** 当前是否正在连接 */
+  isConnecting() {
+    return __privateGet(this, _state) === 1 /* Connecting */;
+  }
+  /** 获取当前连接起点 */
+  getSource() {
+    return __privateGet(this, _source);
+  }
+  /** 编程式取消当前连接 */
+  cancel() {
+    if (__privateGet(this, _state) === 1 /* Connecting */) {
+      __privateMethod(this, _ConnectPlugin_instances, cancelConnect_fn).call(this);
+    }
+  }
+  /** 获取纯引擎模式下的所有连接记录（只读） */
+  getConnections() {
+    return [...__privateGet(this, _connections).values()];
+  }
+  /** 移除纯引擎模式下的连接 */
+  removeConnection(id) {
+    const conn = __privateGet(this, _connections).get(id);
+    if (!conn) return false;
+    if (conn.line.parent) {
+      conn.line.parent.remove(conn.line);
+    }
+    __privateGet(this, _connections).delete(id);
+    __privateGet(this, _app)?.requestRender();
+    return true;
+  }
+  /**
+   * 同步纯引擎模式下的连接线位置。
+   * 在 render 前调用，更新所有 line 端点为最新的 anchor 坐标。
+   */
+  syncConnections() {
+    if (__privateGet(this, _connections).size === 0) return;
+    let dirty = false;
+    for (const conn of __privateGet(this, _connections).values()) {
+      const [sx, sy] = __privateMethod(this, _ConnectPlugin_instances, getAnchor_fn).call(this, conn.source);
+      const [tx, ty] = __privateMethod(this, _ConnectPlugin_instances, getAnchor_fn).call(this, conn.target);
+      conn.line.shape.from(sx, sy, tx, ty);
+      conn.line.setDirty(true);
+      dirty = true;
+    }
+    if (dirty) {
+      __privateGet(this, _app)?.requestRender();
+    }
+  }
+};
+_app = new WeakMap();
+_opts = new WeakMap();
+_state = new WeakMap();
+_source = new WeakMap();
+_sourceAnchor = new WeakMap();
+_snapTarget = new WeakMap();
+_previewLine = new WeakMap();
+_overlayLayer = new WeakMap();
+_connections = new WeakMap();
+_cleanups = new WeakMap();
+_ConnectPlugin_instances = new WeakSet();
+// ════════════════════════════════════════════════════════════
+//  Internal — 预览线
+// ════════════════════════════════════════════════════════════
+createPreviewLine_fn = function() {
+  __privateSet(this, _previewLine, EngineNode.create("path", {
+    stroke: __privateGet(this, _opts).previewStroke,
+    strokeWidth: __privateGet(this, _opts).previewStrokeWidth,
+    strokeDasharray: __privateGet(this, _opts).previewDash,
+    fill: "none"
+  }));
+  __privateGet(this, _previewLine).setDisplay(false);
+  __privateGet(this, _previewLine).setName("connect-preview-line");
+  __privateGet(this, _overlayLayer).add(__privateGet(this, _previewLine));
+};
+showPreview_fn = function(x1, y1, x2, y2) {
+  if (!__privateGet(this, _previewLine)) return;
+  const source = [x1, y1];
+  const target = [x2, y2];
+  const pathData = __privateGet(this, _opts).previewPath ? __privateGet(this, _opts).previewPath(source, target) : `M${x1} ${y1}L${x2} ${y2}`;
+  __privateGet(this, _previewLine).shape.from(pathData);
+  __privateGet(this, _previewLine).setDisplay(true);
+};
+hidePreview_fn = function() {
+  if (!__privateGet(this, _previewLine)) return;
+  __privateGet(this, _previewLine).setDisplay(false);
+};
+// ════════════════════════════════════════════════════════════
+//  Internal — 事件绑定
+// ════════════════════════════════════════════════════════════
+bindEvents_fn = function() {
+  const scene = __privateGet(this, _app).scene;
+  scene.on("pointerdown", __privateGet(this, _onPointerDown));
+  __privateGet(this, _cleanups).push(() => scene.off("pointerdown", __privateGet(this, _onPointerDown)));
+  scene.on("pointermove", __privateGet(this, _onPointerMove));
+  __privateGet(this, _cleanups).push(() => scene.off("pointermove", __privateGet(this, _onPointerMove)));
+  window.addEventListener("pointerup", __privateGet(this, _onPointerUp));
+  __privateGet(this, _cleanups).push(() => window.removeEventListener("pointerup", __privateGet(this, _onPointerUp)));
+  window.addEventListener("keydown", __privateGet(this, _onKeyDown));
+  __privateGet(this, _cleanups).push(() => window.removeEventListener("keydown", __privateGet(this, _onKeyDown)));
+};
+_onPointerDown = new WeakMap();
+_onPointerMove = new WeakMap();
+_onPointerUp = new WeakMap();
+_onKeyDown = new WeakMap();
+// ════════════════════════════════════════════════════════════
+//  Internal — 连接操作
+// ════════════════════════════════════════════════════════════
+/**
+ * 完成连接：委托 graph 或自行创建 line
+ */
+completeConnect_fn = function(target) {
+  const source = __privateGet(this, _source);
+  __privateMethod(this, _ConnectPlugin_instances, hidePreview_fn).call(this);
+  __privateMethod(this, _ConnectPlugin_instances, createEdge_fn).call(this, source, target);
+  __privateGet(this, _app).bus.emit("connect:complete", {
+    source,
+    target
+  });
+  __privateMethod(this, _ConnectPlugin_instances, cleanupState_fn).call(this);
+};
+/**
+ * 取消连接
+ */
+cancelConnect_fn = function() {
+  console.log("cancel");
+  __privateMethod(this, _ConnectPlugin_instances, hidePreview_fn).call(this);
+  __privateGet(this, _app).bus.emit("connect:cancel", {
+    source: __privateGet(this, _source)
+  });
+  __privateMethod(this, _ConnectPlugin_instances, cleanupState_fn).call(this);
+};
+/**
+ * 连接结束后的状态清理
+ */
+cleanupState_fn = function() {
+  __privateGet(this, _app).resetCursor();
+  __privateGet(this, _app).setState("connect:connecting", false);
+  __privateGet(this, _app).setState("connect:source", null);
+  console.log("cleanupState", __privateGet(this, _overlayLayer)?.display, __privateGet(this, _app)?.scene);
+  __privateGet(this, _app).requestRender();
+  __privateMethod(this, _ConnectPlugin_instances, reset_fn).call(this);
+};
+/**
+ * 复位内部状态
+ */
+reset_fn = function() {
+  __privateSet(this, _state, 0 /* Idle */);
+  __privateSet(this, _source, null);
+  __privateSet(this, _sourceAnchor, [0, 0]);
+  __privateSet(this, _snapTarget, null);
+};
+// ════════════════════════════════════════════════════════════
+//  Internal — 边的创建（两种路径）
+// ════════════════════════════════════════════════════════════
+/**
+ * 创建边。优先走 graph-plugin，否则自行创建 line。
+ */
+createEdge_fn = function(source, target) {
+  const graph = __privateMethod(this, _ConnectPlugin_instances, getGraph_fn).call(this);
+  if (graph && __privateGet(this, _opts).edgeType) {
+    const edgeData = __privateMethod(this, _ConnectPlugin_instances, buildEdgeData_fn).call(this, source, target);
+    graph.add(__privateGet(this, _opts).edgeType, edgeData);
+    __privateGet(this, _app).requestRender();
+    return;
+  }
+  __privateMethod(this, _ConnectPlugin_instances, createEngineLine_fn).call(this, source, target);
+};
+/**
+ * Graph 模式：构建 edge data
+ */
+buildEdgeData_fn = function(source, target) {
+  if (__privateGet(this, _opts).edgeFactory) {
+    return __privateGet(this, _opts).edgeFactory(source, target);
+  }
+  const sourceId = __privateMethod(this, _ConnectPlugin_instances, resolveElementId_fn).call(this, source);
+  const targetId = __privateMethod(this, _ConnectPlugin_instances, resolveElementId_fn).call(this, target);
+  const data = {
+    id: `edge-${uid8()}`,
+    source: sourceId ?? source.uid,
+    target: targetId ?? target.uid
+  };
+  if (source.data && Object.keys(source.data).length > 0) {
+    data.sourcePort = { ...source.data };
+  }
+  if (target.data && Object.keys(target.data).length > 0) {
+    data.targetPort = { ...target.data };
+  }
+  return data;
+};
+/**
+ * 纯引擎模式：创建 line Node 并添加到场景
+ */
+createEngineLine_fn = function(source, target) {
+  const [sx, sy] = __privateMethod(this, _ConnectPlugin_instances, getAnchor_fn).call(this, source);
+  const [tx, ty] = __privateMethod(this, _ConnectPlugin_instances, getAnchor_fn).call(this, target);
+  const line = EngineNode.create("line", {
+    stroke: __privateGet(this, _opts).lineStroke,
+    strokeWidth: __privateGet(this, _opts).lineStrokeWidth
+  });
+  line.shape.from(sx, sy, tx, ty);
+  __privateGet(this, _app).scene.add(line);
+  const id = `conn-${uid8()}`;
+  __privateGet(this, _connections).set(id, { id, line, source, target });
+  __privateGet(this, _app).requestRender();
+  __privateGet(this, _app).bus.emit("connect:edge-created", { id, source, target });
+};
+// ════════════════════════════════════════════════════════════
+//  Internal — 目标解析
+// ════════════════════════════════════════════════════════════
+/**
+ * 检查 Graphics 是否是可连接的。
+ * 沿 parent chain 向上搜索，找到第一个带有 connectable className 的节点。
+ */
+resolveConnectable_fn = function(target) {
+  if (target === __privateGet(this, _app).scene) return null;
+  let current = target;
+  while (current) {
+    if (current.hasClassName(__privateGet(this, _opts).className)) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
+};
+/**
+ * 在 snapRadius 内寻找最近的可连接目标
+ */
+findSnapTarget_fn = function(worldX, worldY) {
+  const candidates = __privateMethod(this, _ConnectPlugin_instances, collectConnectables_fn).call(this);
+  const radius = __privateGet(this, _opts).snapRadius;
+  const radiusSq = radius * radius;
+  let best = null;
+  let bestDistSq = Infinity;
+  for (const candidate of candidates) {
+    if (!__privateGet(this, _opts).allowSelfLoop && __privateMethod(this, _ConnectPlugin_instances, isSameElement_fn).call(this, candidate, __privateGet(this, _source))) {
+      continue;
+    }
+    if (__privateGet(this, _opts).canConnect && !__privateGet(this, _opts).canConnect(__privateGet(this, _source), candidate)) {
+      continue;
+    }
+    const [ax, ay] = __privateMethod(this, _ConnectPlugin_instances, getAnchor_fn).call(this, candidate);
+    const dx = worldX - ax;
+    const dy = worldY - ay;
+    const distSq = dx * dx + dy * dy;
+    if (distSq < radiusSq && distSq < bestDistSq) {
+      bestDistSq = distSq;
+      best = candidate;
+    }
+  }
+  return best;
+};
+/**
+ * 收集场景中所有可连接的 Graphics
+ */
+collectConnectables_fn = function() {
+  const result = [];
+  const className = __privateGet(this, _opts).className;
+  __privateGet(this, _app).scene.traverse((g) => {
+    if (g.hasClassName(className) && g.display) {
+      result.push(g);
+    }
+  });
+  return result;
+};
+/**
+ * 判断两个端口是否属于同一个元素。
+ * 有 graph-plugin 时按 element ID 比较；否则按 Graphics 引用比较。
+ */
+isSameElement_fn = function(a, b) {
+  const graph = __privateMethod(this, _ConnectPlugin_instances, getGraph_fn).call(this);
+  if (graph) {
+    const idA = __privateMethod(this, _ConnectPlugin_instances, resolveElementId_fn).call(this, a);
+    const idB = __privateMethod(this, _ConnectPlugin_instances, resolveElementId_fn).call(this, b);
+    if (idA && idB) return idA === idB;
+  }
+  return a.uid === b.uid;
+};
+// ════════════════════════════════════════════════════════════
+//  Internal — 坐标与溯源
+// ════════════════════════════════════════════════════════════
+/**
+ * 获取 Graphics 的连接锚点（世界坐标）。
+ */
+getAnchor_fn = function(target) {
+  if (__privateGet(this, _opts).anchor) {
+    return __privateGet(this, _opts).anchor(target);
+  }
+  return __privateMethod(this, _ConnectPlugin_instances, defaultAnchor_fn).call(this, target);
+};
+/**
+ * 默认锚点计算：
+ * - Node（type=3）: 取 getWorldBBox() 中心
+ * - Group / 其他: 取 worldMatrix 的 translation 部分
+ */
+defaultAnchor_fn = function(target) {
+  if (target.type === 3) {
+    const bbox = target.getWorldBBox();
+    if (bbox && !bbox.empty) {
+      return [bbox.cx, bbox.cy];
+    }
+  }
+  const m = target.worldMatrix;
+  return [m[4], m[5]];
+};
+/**
+ * 从端口 Graphics 沿 parent chain 向上走，
+ * 找到 graph-plugin 认识的 element group（group.name === element.id）。
+ */
+resolveElementId_fn = function(graphics) {
+  const graph = __privateMethod(this, _ConnectPlugin_instances, getGraph_fn).call(this);
+  if (!graph) return null;
+  let current = graphics;
+  while (current) {
+    if (current.name && graph.has(current.name)) {
+      return current.name;
+    }
+    current = current.parent;
+  }
+  return null;
+};
+// ════════════════════════════════════════════════════════════
+//  Internal — 插件感知
+// ════════════════════════════════════════════════════════════
+/**
+ * 获取 graph-plugin 实例（软感知，无则返回 null）
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+getGraph_fn = function() {
+  if (!__privateGet(this, _app)) return null;
+  const graph = __privateGet(this, _app).getPlugin("graph");
+  if (!graph || typeof graph.add !== "function" || typeof graph.has !== "function") return null;
+  return graph;
+};
+/**
+ * 检查 drag-plugin 是否正在拖拽
+ */
+isDragActive_fn = function() {
+  if (!__privateGet(this, _app)) return false;
+  try {
+    return __privateGet(this, _app).getState("drag:dragging") === true;
+  } catch {
+    return false;
+  }
+};
+function connectPlugin(options) {
+  return new ConnectPlugin(options);
+}
+export {
+  ConnectPlugin,
+  connectPlugin
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "rendx-connect-plugin",
+  "version": "0.2.0",
+  "description": "Connect interaction plugin for Rendx engine — interactive edge creation",
+  "license": "MIT",
+  "author": "wei.liang (https://github.com/weiliang0121)",
+  "type": "module",
+  "keywords": [
+    "rendx",
+    "2d",
+    "canvas",
+    "rendering",
+    "visualization",
+    "scene-graph",
+    "connect",
+    "edge"
+  ],
+  "homepage": "https://weiliang0121.github.io/rendx/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/weiliang0121/rendx.git",
+    "directory": "packages/connect-plugin"
+  },
+  "main": "dist/main.cjs",
+  "module": "dist/main.js",
+  "types": "dist/main.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/main.d.ts",
+      "import": "./dist/main.js",
+      "require": "./dist/main.cjs"
+    }
+  },
+  "dependencies": {
+    "rendx-core": "^0.1.1",
+    "rendx-engine": "^0.4.1"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}