@tmagic/editor 1.8.0-beta.19 → 1.8.0-beta.20

package/src/services/keybinding.ts

@@ -1,6 +1,6 @@
 import KeyController, { KeyControllerEvent } from 'keycon';
 
-import { isPage, isPageFragment } from '@tmagic/utils';
+import { isPageOrFragment } from '@tmagic/utils';
 
 import { KeyBindingCacheItem, KeyBindingCommand, KeyBindingItem } from '@editor/type';
 
@@ -19,7 +19,7 @@ class Keybinding extends BaseService {
     [KeyBindingCommand.DELETE_NODE]: () => {
       const nodes = editorService.get('nodes');
 
-      if (!nodes || isPage(nodes[0]) || isPageFragment(nodes[0])) return;
+      if (!nodes || isPageOrFragment(nodes[0])) return;
       editorService.remove(nodes, { historySource: 'shortcut' });
     },
     [KeyBindingCommand.COPY_NODE]: () => {
@@ -29,7 +29,7 @@ class Keybinding extends BaseService {
     [KeyBindingCommand.CUT_NODE]: () => {
       const nodes = editorService.get('nodes');
 
-      if (!nodes || isPage(nodes[0]) || isPageFragment(nodes[0])) return;
+      if (!nodes || isPageOrFragment(nodes[0])) return;
       editorService.copy(nodes);
       editorService.remove(nodes, { historySource: 'shortcut' });
     },

package/src/utils/content-menu.ts

@@ -2,7 +2,7 @@ import { computed, markRaw, type ShallowRef } from 'vue';
 import { CopyDocument, Delete, DocumentCopy } from '@element-plus/icons-vue';
 
 import { cloneDeep, Id, MContainer, NodeType } from '@tmagic/core';
-import { calcValueByFontsize, isPage, isPageFragment } from '@tmagic/utils';
+import { calcValueByFontsize, isPage, isPageOrFragment } from '@tmagic/utils';
 
 import ContentMenu from '@editor/components/ContentMenu.vue';
 import type { HistoryOpSource, MenuButton, Services } from '@editor/type';
@@ -20,7 +20,7 @@ export const useDeleteMenu = (historySource?: HistoryOpSource): MenuButton => ({
   icon: Delete,
   display: ({ editorService }) => {
     const node = editorService.get('node');
-    return node?.type !== NodeType.ROOT && !isPage(node) && !isPageFragment(node);
+    return node?.type !== NodeType.ROOT && !isPageOrFragment(node);
   },
   handler: ({ editorService }) => {
     const nodes = editorService.get('nodes');

package/src/utils/dep/collect-worker-client.ts

@@ -0,0 +1,149 @@
+import serialize from 'serialize-javascript';
+
+import type { Id, MApp } from '@tmagic/core';
+
+import { error } from '../logger';
+
+import type { CollectWorkerPayload, CollectWorkerRequest, CollectWorkerResponse, DepsData } from './worker';
+import CollectWorker from './worker.ts?worker&inline';
+
+export interface CollectWorkerResult {
+  deps: DepsData;
+  nodeIds: Id[];
+}
+
+/**
+ * 依赖收集 worker 的主线程客户端
+ *
+ * 依赖收集需要深度遍历整棵节点树并对每个属性做匹配，节点/数据源多时会长时间占用主线程导致页面卡死，
+ * 这里把遍历匹配放到 worker 中执行，主线程只负责把结果写回 target。
+ *
+ * 全量收集与增量收集共用一个常驻 worker：增量收集调用频繁（每次节点更新都会触发），
+ * 按次创建 worker 的启动开销无法接受，也容易漏掉销毁导致线程泄漏。
+ */
+export class CollectWorkerClient {
+  private worker: Worker | null = null;
+
+  private seed = 0;
+
+  private pending = new Map<number, (response: CollectWorkerResponse | null) => void>();
+
+  public get isSupported() {
+    return typeof Worker !== 'undefined';
+  }
+
+  /**
+   * 在 worker 中全量收集整个 DSL 的依赖，target 由 worker 根据 DSL 重建
+   * @returns 收集结果，返回 null 表示 worker 不可用或执行失败
+   */
+  public collectDsl(dsl: MApp): Promise<DepsData | null> {
+    return this.request((id) => ({ id, dsl: serialize(dsl) })).then((response) => response?.deps || null);
+  }
+
+  /**
+   * 在 worker 中增量收集指定节点的依赖，target 以可序列化描述的形式传入
+   * @returns 收集结果，返回 null 表示 worker 不可用或执行失败，调用方需要回退到主线程收集
+   */
+  public collect(payload: CollectWorkerPayload): Promise<CollectWorkerResult | null> {
+    return this.request((id) => ({ id, payload: serialize(payload) })).then((response) =>
+      response ? { deps: response.deps || {}, nodeIds: response.nodeIds || [] } : null,
+    );
+  }
+
+  public terminate() {
+    this.worker?.terminate();
+    this.worker = null;
+    this.settleAllPending();
+  }
+
+  /**
+   * 丢弃在途请求并重建 worker
+   * clearIdleTasks / reset 中断收集时调用，避免已 abort 的长任务继续占着常驻 worker 拖慢后续收集
+   */
+  public abort() {
+    this.terminate();
+  }
+
+  /**
+   * worker 按收到的顺序逐个处理请求，因此请求间不会互相打断，用 id 把结果分发回各自的调用方
+   */
+  private request(createRequest: (id: number) => CollectWorkerRequest): Promise<CollectWorkerResponse | null> {
+    const worker = this.getWorker();
+
+    if (!worker) {
+      return Promise.resolve(null);
+    }
+
+    this.seed += 1;
+    const id = this.seed;
+
+    return new Promise<CollectWorkerResponse | null>((resolve) => {
+      this.pending.set(id, resolve);
+
+      try {
+        // 节点配置中可能存在函数等无法结构化克隆的值，需要先序列化再传递
+        worker.postMessage(createRequest(id));
+      } catch (e) {
+        error('magic editor: 依赖收集 worker 通信失败', e);
+        this.pending.delete(id);
+        resolve(null);
+      }
+    });
+  }
+
+  private getWorker() {
+    if (!this.isSupported) {
+      return null;
+    }
+
+    if (this.worker) {
+      return this.worker;
+    }
+
+    try {
+      const worker: Worker = new CollectWorker();
+      worker.onmessage = (e: MessageEvent<CollectWorkerResponse>) => {
+        this.handleResponse(e.data);
+      };
+      // worker 整体异常时无法定位到具体请求，只能结算全部在途请求并重建 worker
+      worker.onerror = () => {
+        this.handleFatalError();
+      };
+      worker.onmessageerror = () => {
+        this.handleFatalError();
+      };
+      this.worker = worker;
+    } catch (e) {
+      error('magic editor: 依赖收集 worker 创建失败', e);
+      return null;
+    }
+
+    return this.worker;
+  }
+
+  private handleResponse(response: CollectWorkerResponse) {
+    const resolve = this.pending.get(response?.id);
+
+    if (!resolve) {
+      return;
+    }
+
+    this.pending.delete(response.id);
+    resolve(response.failed ? null : response);
+  }
+
+  private handleFatalError() {
+    this.worker?.terminate();
+    this.worker = null;
+    this.settleAllPending();
+  }
+
+  private settleAllPending() {
+    const resolvers = [...this.pending.values()];
+    this.pending.clear();
+
+    for (const resolve of resolvers) {
+      resolve(null);
+    }
+  }
+}

package/src/utils/dep/worker.ts

@@ -3,30 +3,85 @@ import {
   createDataSourceCondTarget,
   createDataSourceMethodTarget,
   createDataSourceTarget,
+  createTargetByDescriptor,
   type DepData,
+  type DepExtendedData,
   DepTargetType,
   type Id,
   type MApp,
+  type TargetDescriptor,
+  type TargetNode,
   traverseTarget,
   Watcher,
 } from '@tmagic/core';
 
 import { error } from '../logger';
 
-onmessage = (e) => {
-  const watcher = new Watcher({ initialTargets: {} });
+export type DepsData = Record<string, Record<Id, DepData>>;
 
-  const { dsl } = e.data;
+/** 全量收集请求：worker 中根据 DSL 重建代码块/数据源 target */
+export interface DslCollectRequest {
+  /** 请求 id，用于把结果与调用方对应起来 */
+  id: number;
+  /** serialize-javascript 序列化后的 MApp */
+  dsl: string;
+}
 
+export interface CollectWorkerPayload {
+  /** 待收集的节点 */
+  nodes: TargetNode[];
+  /** 参与本次收集的 target 描述，worker 中据此重建 target */
+  targets: TargetDescriptor[];
+  depExtendedData: DepExtendedData;
+  deep: boolean;
+}
+
+/** 增量收集请求：target 由主线程以可序列化描述的形式传入 */
+export interface NodesCollectRequest {
+  id: number;
+  /** serialize-javascript 序列化后的 CollectWorkerPayload */
+  payload: string;
+}
+
+export type CollectWorkerRequest = DslCollectRequest | NodesCollectRequest;
+
+export interface CollectWorkerResponse {
+  id: number;
+  /** 收集结果，结构为 { [target.type]: { [target.id]: deps } } */
+  deps: DepsData;
+  /** 增量收集时本次覆盖到的节点 id（deep=true 时含子孙），主线程据此删除旧依赖 */
+  nodeIds?: Id[];
+  /** 收集失败，调用方需要回退到主线程收集 */
+  failed?: boolean;
+}
+
+/**
+ * 收集本次会覆盖到的节点 id
+ * 必须与 deep 一致：deep=false 时不能带上子孙 id，否则写回阶段 removeDep 会清掉未重收的子节点依赖
+ */
+const getNodeIds = (nodes: TargetNode[], deep: boolean, ids: Id[] = []) => {
+  for (const node of nodes) {
+    ids.push(node.id);
+
+    if (deep && Array.isArray(node.items) && node.items.length) {
+      getNodeIds(node.items, deep, ids);
+    }
+  }
+
+  return ids;
+};
+
+const collectDsl = ({ id, dsl }: DslCollectRequest) => {
   try {
     // eslint-disable-next-line no-eval
     const mApp: MApp = eval(`(${dsl})`);
 
     if (!mApp) {
-      postMessage({});
+      postMessage({ id, deps: {} });
+      return;
     }
 
-    watcher.clearTargets();
+    const watcher = new Watcher({ initialTargets: {} });
 
     if (mApp.codeBlocks) {
       for (const [id, code] of Object.entries(mApp.codeBlocks)) {
@@ -48,7 +103,7 @@ onmessage = (e) => {
       watcher.collectItems(page, targets, { pageId: page.id }, true);
     }
 
-    const data: Record<string, Record<Id, DepData>> = {
+    const deps: DepsData = {
       [DepTargetType.DATA_SOURCE]: {},
       [DepTargetType.DATA_SOURCE_METHOD]: {},
       [DepTargetType.DATA_SOURCE_COND]: {},
@@ -56,12 +111,61 @@ onmessage = (e) => {
     };
 
     traverseTarget(watcher.getTargetsList(), (target) => {
-      data[target.type][target.id] = target.deps;
+      deps[target.type][target.id] = target.deps;
     });
 
-    postMessage(data);
+    const response: CollectWorkerResponse = { id, deps };
+    postMessage(response);
   } catch (e: any) {
     error(e);
-    postMessage({});
+    const response: CollectWorkerResponse = { id, deps: {}, failed: true };
+    postMessage(response);
   }
 };
+
+const collectNodes = ({ id, payload }: NodesCollectRequest) => {
+  try {
+    // eslint-disable-next-line no-eval
+    const { nodes, targets: descriptors, depExtendedData, deep }: CollectWorkerPayload = eval(`(${payload})`);
+
+    const watcher = new Watcher({ initialTargets: {} });
+    // worker 中 target 均为新建（deps 为空），无需删除阶段，直接批量收集
+    const targets = descriptors.map((descriptor) => createTargetByDescriptor(descriptor));
+
+    for (const node of nodes) {
+      watcher.collectItems(node, targets, depExtendedData, deep);
+    }
+
+    const deps: DepsData = {};
+    for (const target of targets) {
+      if (!deps[target.type]) {
+        deps[target.type] = {};
+      }
+      deps[target.type][target.id] = target.deps;
+    }
+
+    const response: CollectWorkerResponse = { id, deps, nodeIds: getNodeIds(nodes, deep) };
+    postMessage(response);
+  } catch (e: any) {
+    error(e);
+    const response: CollectWorkerResponse = { id, deps: {}, nodeIds: [], failed: true };
+    postMessage(response);
+  }
+};
+
+/**
+ * 依赖收集 worker
+ *
+ * 依赖收集需要深度遍历整棵节点树并对每个属性做 target 匹配，节点/数据源多时会长时间占用主线程导致页面卡死，
+ * 因此把遍历匹配放到 worker 中执行。
+ * 全量与增量收集共用一个常驻 worker：收集逻辑只打进一份 inline worker 产物，
+ * 也不会因为频繁收集而反复创建线程，每个请求用 id 与调用方对应。
+ */
+onmessage = (e: MessageEvent<CollectWorkerRequest>) => {
+  if ('dsl' in e.data) {
+    collectDsl(e.data);
+    return;
+  }
+
+  collectNodes(e.data);
+};

package/src/utils/operator.ts

@@ -3,7 +3,7 @@ import { isEmpty } from 'lodash-es';
 
 import type { Id, MContainer, MNode } from '@tmagic/core';
 import { NodeType } from '@tmagic/core';
-import { calcValueByFontsize, getElById, isPage, isPageFragment } from '@tmagic/utils';
+import { calcValueByFontsize, getElById, isPage, isPageOrFragment } from '@tmagic/utils';
 
 import editorService from '@editor/services/editor';
 import propsService from '@editor/services/props';
@@ -58,7 +58,7 @@ export const beforePaste = (position: PastePosition, config: MNode[], doc?: Docu
       };
     }
     const root = editorService.get('root');
-    if ((isPage(pasteConfig) || isPageFragment(pasteConfig)) && root) {
+    if (isPageOrFragment(pasteConfig) && root) {
       pasteConfig.name = generatePageNameByApp(root, isPage(pasteConfig) ? NodeType.PAGE : NodeType.PAGE_FRAGMENT);
     }
     return pasteConfig as MNode;

package/types/index.d.ts

@@ -503,6 +503,9 @@ declare class DataSource extends BaseService {
 type DataSourceService = DataSource;
 declare const _default$42: DataSource;
 //#endregion
+//#region temp/packages/editor/src/utils/dep/worker.d.ts
+type DepsData = Record<string, Record<Id, DepData>>;
+//#endregion
 //#region temp/packages/editor/src/services/dep.d.ts
 interface DepEvents {
   'add-target': [target: Target];
@@ -518,6 +521,7 @@ type StateKey = keyof State$1;
 declare class Dep extends BaseService {
   private state;
   private idleTask;
+  private collectWorker;
   private watcher;
   private waitingWorker?;
   private resolveWaitingWorker?;
@@ -536,8 +540,16 @@ declare class Dep extends BaseService {
   removeTarget(id: Id, type?: string): void;
   clearTargets(): void;
   collect(nodes: MNode[], depExtendedData?: DepExtendedData, deep?: boolean, type?: DepTargetType$1): void;
+  /**
+   * 空闲收集依赖
+   *
+   * 遍历匹配是整个收集过程中最耗时的部分（要深度遍历节点树并对每个属性做 target 匹配），
+   * 节点/数据源多时在主线程执行会长时间卡死页面，因此优先交给 worker 执行，主线程只负责把结果写回 target。
+   * 自定义 target 的 isTarget 是无法跨线程传递的闭包函数（没有 descriptor），仍走主线程空闲队列；
+   * worker 不可用（如 SSR）或执行失败时也会回退到主线程空闲队列。
+   */
   collectIdle(nodes: MNode[], depExtendedData?: DepExtendedData, deep?: boolean, type?: DepTargetType$1): Promise<boolean>;
-  collectByWorker(dsl: MApp): Promise<Record<string, Record<string, DepData>>>;
+  collectByWorker(dsl: MApp): Promise<DepsData>;
   collectNode(node: MNode, target: Target, depExtendedData?: DepExtendedData, deep?: boolean): void;
   clear(nodes?: MNode[]): void;
   clearByType(type: DepTargetType$1, nodes?: MNode[]): void;
@@ -554,7 +566,17 @@ declare class Dep extends BaseService {
    * 按 pageId 匹配，可清掉页面内已被删除节点的残留依赖
    */
   private removePageDep;
+  /**
+   * 把遍历匹配交给 worker，结果回来后按 target 分片写回主线程
+   */
+  private collectByCollectWorker;
+  /**
+   * 用 worker 的收集结果替换 target 上这批节点的依赖
+   */
+  private enqueueApplyTask;
+  private enqueueTasks;
   private enqueueTask;
+  private beginBatchTask;
   private onBatchTaskDone;
   private settleBatchDs;
   private finishBatch;
@@ -1231,7 +1253,7 @@ declare class History extends BaseService {
    * 派发「页面 / 页面片结构变更」事件（`page-structure-change`）。
    *
    * 常规 `editorService.add` / `remove` 页面节点不会写入 `page` 历史栈（见 editor.add / remove 中
-   * 对 isPage / isPageFragment 的分支），因此不会产生任何 historyService 事件。该方法用于在这些
+   * 对 isPageOrFragment 的分支），因此不会产生任何 historyService 事件。该方法用于在这些
    * 场景（以及 setRoot 整体替换 DSL 增删页面）下，向外统一通知页面结构的增删变化，供业务方感知。
    *
    * 一次操作涉及多个页面时，调用方应把本次增删的页面**合并为一个 change 一次性传入**，