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

package/dist/es/fields/EventSelect.vue_vue_type_script_setup_true_lang.js

@@ -173,7 +173,7 @@ var EventSelect_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defi
 					name: "name",
 					label: "事件名",
 					type: eventNameConfig.value.type,
-					options: (mForm, { formValue }) => eventsService.getEvent(formValue.type).map((option) => ({
+					options: (mForm, { formValue }) => eventsService.getEvent(formValue.type, { node: editorService.getNodeById(formValue.id) }).map((option) => ({
 						text: option.label,
 						value: option.value
 					}))
@@ -190,7 +190,10 @@ var EventSelect_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defi
 					options: (mForm, { model }) => {
 						const node = editorService.getNodeById(model.to);
 						if (!node?.type) return [];
-						return eventsService.getMethod(node.type, model.to).map((option) => ({
+						return eventsService.getMethod(node.type, {
+							targetId: model.to,
+							node
+						}).map((option) => ({
 							text: option.label,
 							value: option.value
 						}));

package/dist/es/services/events.js

@@ -32,7 +32,7 @@ var Events = class extends BaseService {
 	setEvent(type, events) {
 		eventMap[toLine(type)] = [...events];
 	}
-	getEvent(type) {
+	getEvent(type, _data = {}) {
 		return cloneDeep(eventMap[toLine(type)]) || [];
 	}
 	setMethods(methods) {
@@ -43,7 +43,7 @@ var Events = class extends BaseService {
 	setMethod(type, method) {
 		methodMap[toLine(type)] = [...method];
 	}
-	getMethod(type, _targetId) {
+	getMethod(type, _data = {}) {
 		return cloneDeep(methodMap[toLine(type)]) || [];
 	}
 	resetState() {

package/dist/es/utils/dep/idle-task.js

@@ -1,6 +1,16 @@
 import { error } from "../logger.js";
 import { EventEmitter } from "events";
 //#region packages/editor/src/utils/dep/idle-task.ts
+/**
+* 回调因 timeout 触发（主线程一直没有空闲）时，单次回调执行任务的时间预算，单位 ms
+* 参考一帧内可让出的余量：既保证队列有进展，又不长时间阻塞主线程
+*/
+var TIMEOUT_RUN_BUDGET = 5;
+/**
+* 回调因 timeout 触发时，每两次读取时钟之间执行的任务数
+* 与空闲时间 <=5ms 时的批量保持一致，避免每个任务都读一次时钟
+*/
+var TIMEOUT_BATCH_SIZE = 10;
 globalThis.requestIdleCallback = globalThis.requestIdleCallback || function(cb) {
 	const start = Date.now();
 	return setTimeout(() => {
@@ -52,6 +62,13 @@ var IdleTask = class extends EventEmitter {
 	runTaskQueue(deadline) {
 		this.taskHandle = null;
 		try {
+			if (deadline.didTimeout) {
+				const start = Date.now();
+				do
+					this.runTaskBatch(TIMEOUT_BATCH_SIZE);
+				while (this.getTaskLength() && Date.now() - start < TIMEOUT_RUN_BUDGET);
+				return;
+			}
 			while (deadline.timeRemaining() > 0 && this.getTaskLength()) {
 				const timeRemaining = deadline.timeRemaining();
 				let times = 0;
@@ -59,17 +76,23 @@ var IdleTask = class extends EventEmitter {
 				else if (timeRemaining <= 10) times = 100;
 				else if (timeRemaining <= 15) times = 300;
 				else times = 600;
-				for (let i = 0; i < times; i++) {
-					const task = this.hightLevelTaskList.length > 0 ? this.hightLevelTaskList.shift() : this.taskList.shift();
-					if (task) this.runTask(task);
-					if (!this.getTaskLength()) break;
-				}
+				this.runTaskBatch(times);
 			}
 		} finally {
 			this.finishRun();
 		}
 	}
 	/**
+	* 执行一批任务，队列被清空时提前结束
+	*/
+	runTaskBatch(times) {
+		for (let i = 0; i < times; i++) {
+			const task = this.hightLevelTaskList.length > 0 ? this.hightLevelTaskList.shift() : this.taskList.shift();
+			if (task) this.runTask(task);
+			if (!this.getTaskLength()) break;
+		}
+	}
+	/**
 	* 单个任务失败不能中断整个队列，否则后续任务永远不会被执行，
 	* 依赖收集会停在半路（收集中状态与剩余任务数都不再变化）
 	*/

package/dist/es/utils/event.js

@@ -19,7 +19,8 @@ var normalizeCompActionValue = (value) => {
 var getEventNameOptions = (src, formValue = {}) => {
 	if (!formValue.type) return [];
 	if (src === "component") {
-		let events = events_default.getEvent(formValue.type) || [];
+		const sourceNode = editor_default.getNodeById(formValue.id);
+		let events = events_default.getEvent(formValue.type, { node: sourceNode }) || [];
 		if (formValue.type === "page-fragment-container" && formValue.pageFragmentId) {
 			const pageFragment = editor_default.get("root")?.items?.find((page) => page.id === formValue.pageFragmentId);
 			if (!pageFragment) return [];
@@ -28,9 +29,11 @@ var getEventNameOptions = (src, formValue = {}) => {
 				value: pageFragment.id,
 				children: events
 			}];
-			(pageFragment.items || []).forEach((node) => {
-				traverseNode(node, (current) => {
-					const nodeEvents = current.type && events_default.getEvent(current.type) || [];
+			(pageFragment.items || []).forEach((item) => {
+				traverseNode(item, (current) => {
+					if (!current.type) return;
+					const node = editor_default.getNodeById(current.id) || current;
+					const nodeEvents = events_default.getEvent(current.type, { node }) || [];
 					events.push({
 						label: `${current.name}_${current.id}`,
 						value: `${current.id}`,
@@ -89,15 +92,24 @@ var getCompActionOptions = (toId) => {
 	if (typeof toId === "undefined" || toId === null || toId === "") return [];
 	const node = editor_default.getNodeById(toId);
 	if (!node?.type) return [];
-	let methods = events_default.getMethod(node.type, toId) || [];
+	let methods = events_default.getMethod(node.type, {
+		targetId: toId,
+		node
+	}) || [];
 	if (node.type === "page-fragment-container" && node.pageFragmentId) {
 		const pageFragment = editor_default.get("root")?.items?.find((page) => page.id === node.pageFragmentId);
 		if (!pageFragment) return [];
 		methods = [];
 		(pageFragment.items || []).forEach((item) => {
 			traverseNode(item, (current) => {
-				const nodeMethods = current.type && events_default.getMethod(current.type, current.id) || [];
-				if (nodeMethods.length) methods.push({
+				const node = editor_default.getNodeById(current.id) || current;
+				if (!current.type) return;
+				const nodeMethods = events_default.getMethod(current.type, {
+					targetId: current.id,
+					node
+				}) || [];
+				if (!nodeMethods.length) return;
+				methods.push({
 					label: `${current.name}_${current.id}`,
 					value: `${current.id}`,
 					children: nodeMethods

package/dist/tmagic-editor.umd.cjs

@@ -9647,6 +9647,16 @@
 	};
 	//#endregion
 	//#region packages/editor/src/utils/dep/idle-task.ts
+	/**
+	* 回调因 timeout 触发（主线程一直没有空闲）时，单次回调执行任务的时间预算，单位 ms
+	* 参考一帧内可让出的余量：既保证队列有进展，又不长时间阻塞主线程
+	*/
+	var TIMEOUT_RUN_BUDGET = 5;
+	/**
+	* 回调因 timeout 触发时，每两次读取时钟之间执行的任务数
+	* 与空闲时间 <=5ms 时的批量保持一致，避免每个任务都读一次时钟
+	*/
+	var TIMEOUT_BATCH_SIZE = 10;
 	globalThis.requestIdleCallback = globalThis.requestIdleCallback || function(cb) {
 		const start = Date.now();
 		return setTimeout(() => {
@@ -9698,6 +9708,13 @@
 		runTaskQueue(deadline) {
 			this.taskHandle = null;
 			try {
+				if (deadline.didTimeout) {
+					const start = Date.now();
+					do
+						this.runTaskBatch(TIMEOUT_BATCH_SIZE);
+					while (this.getTaskLength() && Date.now() - start < TIMEOUT_RUN_BUDGET);
+					return;
+				}
 				while (deadline.timeRemaining() > 0 && this.getTaskLength()) {
 					const timeRemaining = deadline.timeRemaining();
 					let times = 0;
@@ -9705,17 +9722,23 @@
 					else if (timeRemaining <= 10) times = 100;
 					else if (timeRemaining <= 15) times = 300;
 					else times = 600;
-					for (let i = 0; i < times; i++) {
-						const task = this.hightLevelTaskList.length > 0 ? this.hightLevelTaskList.shift() : this.taskList.shift();
-						if (task) this.runTask(task);
-						if (!this.getTaskLength()) break;
-					}
+					this.runTaskBatch(times);
 				}
 			} finally {
 				this.finishRun();
 			}
 		}
 		/**
+		* 执行一批任务，队列被清空时提前结束
+		*/
+		runTaskBatch(times) {
+			for (let i = 0; i < times; i++) {
+				const task = this.hightLevelTaskList.length > 0 ? this.hightLevelTaskList.shift() : this.taskList.shift();
+				if (task) this.runTask(task);
+				if (!this.getTaskLength()) break;
+			}
+		}
+		/**
 		* 单个任务失败不能中断整个队列，否则后续任务永远不会被执行，
 		* 依赖收集会停在半路（收集中状态与剩余任务数都不再变化）
 		*/
@@ -11193,7 +11216,7 @@
 		setEvent(type, events) {
 			eventMap[(0, _tmagic_utils.toLine)(type)] = [...events];
 		}
-		getEvent(type) {
+		getEvent(type, _data = {}) {
 			return cloneDeep$1(eventMap[(0, _tmagic_utils.toLine)(type)]) || [];
 		}
 		setMethods(methods) {
@@ -11204,7 +11227,7 @@
 		setMethod(type, method) {
 			methodMap[(0, _tmagic_utils.toLine)(type)] = [...method];
 		}
-		getMethod(type, _targetId) {
+		getMethod(type, _data = {}) {
 			return cloneDeep$1(methodMap[(0, _tmagic_utils.toLine)(type)]) || [];
 		}
 		resetState() {
@@ -11238,7 +11261,8 @@
 	var getEventNameOptions = (src, formValue = {}) => {
 		if (!formValue.type) return [];
 		if (src === "component") {
-			let events = events_default.getEvent(formValue.type) || [];
+			const sourceNode = editor_default.getNodeById(formValue.id);
+			let events = events_default.getEvent(formValue.type, { node: sourceNode }) || [];
 			if (formValue.type === "page-fragment-container" && formValue.pageFragmentId) {
 				const pageFragment = editor_default.get("root")?.items?.find((page) => page.id === formValue.pageFragmentId);
 				if (!pageFragment) return [];
@@ -11247,9 +11271,11 @@
 					value: pageFragment.id,
 					children: events
 				}];
-				(pageFragment.items || []).forEach((node) => {
-					(0, _tmagic_utils.traverseNode)(node, (current) => {
-						const nodeEvents = current.type && events_default.getEvent(current.type) || [];
+				(pageFragment.items || []).forEach((item) => {
+					(0, _tmagic_utils.traverseNode)(item, (current) => {
+						if (!current.type) return;
+						const node = editor_default.getNodeById(current.id) || current;
+						const nodeEvents = events_default.getEvent(current.type, { node }) || [];
 						events.push({
 							label: `${current.name}_${current.id}`,
 							value: `${current.id}`,
@@ -11308,15 +11334,24 @@
 		if (typeof toId === "undefined" || toId === null || toId === "") return [];
 		const node = editor_default.getNodeById(toId);
 		if (!node?.type) return [];
-		let methods = events_default.getMethod(node.type, toId) || [];
+		let methods = events_default.getMethod(node.type, {
+			targetId: toId,
+			node
+		}) || [];
 		if (node.type === "page-fragment-container" && node.pageFragmentId) {
 			const pageFragment = editor_default.get("root")?.items?.find((page) => page.id === node.pageFragmentId);
 			if (!pageFragment) return [];
 			methods = [];
 			(pageFragment.items || []).forEach((item) => {
 				(0, _tmagic_utils.traverseNode)(item, (current) => {
-					const nodeMethods = current.type && events_default.getMethod(current.type, current.id) || [];
-					if (nodeMethods.length) methods.push({
+					const node = editor_default.getNodeById(current.id) || current;
+					if (!current.type) return;
+					const nodeMethods = events_default.getMethod(current.type, {
+						targetId: current.id,
+						node
+					}) || [];
+					if (!nodeMethods.length) return;
+					methods.push({
 						label: `${current.name}_${current.id}`,
 						value: `${current.id}`,
 						children: nodeMethods
@@ -23003,7 +23038,7 @@
 						name: "name",
 						label: "事件名",
 						type: eventNameConfig.value.type,
-						options: (mForm, { formValue }) => eventsService.getEvent(formValue.type).map((option) => ({
+						options: (mForm, { formValue }) => eventsService.getEvent(formValue.type, { node: editorService.getNodeById(formValue.id) }).map((option) => ({
 							text: option.label,
 							value: option.value
 						}))
@@ -23020,7 +23055,10 @@
 						options: (mForm, { model }) => {
 							const node = editorService.getNodeById(model.to);
 							if (!node?.type) return [];
-							return eventsService.getMethod(node.type, model.to).map((option) => ({
+							return eventsService.getMethod(node.type, {
+								targetId: model.to,
+								node
+							}).map((option) => ({
 								text: option.label,
 								value: option.value
 							}));

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.8.0-beta.20",
+  "version": "1.8.0-beta.21",
   "name": "@tmagic/editor",
   "type": "module",
   "sideEffects": [
@@ -58,11 +58,11 @@
     "moveable": "^0.53.0",
     "serialize-javascript": "^7.0.0",
     "sortablejs": "^1.15.6",
-    "@tmagic/design": "1.8.0-beta.20",
-    "@tmagic/form": "1.8.0-beta.20",
-    "@tmagic/stage": "1.8.0-beta.20",
-    "@tmagic/table": "1.8.0-beta.20",
-    "@tmagic/utils": "1.8.0-beta.20"
+    "@tmagic/design": "1.8.0-beta.21",
+    "@tmagic/form": "1.8.0-beta.21",
+    "@tmagic/stage": "1.8.0-beta.21",
+    "@tmagic/table": "1.8.0-beta.21",
+    "@tmagic/utils": "1.8.0-beta.21"
   },
   "devDependencies": {
     "@types/events": "^3.0.3",
@@ -76,7 +76,7 @@
     "type-fest": "^5.2.0",
     "typescript": "^6.0.3",
     "vue": "^3.5.40",
-    "@tmagic/core": "1.8.0-beta.20"
+    "@tmagic/core": "1.8.0-beta.21"
   },
   "peerDependenciesMeta": {
     "typescript": {

package/src/fields/EventSelect.vue

@@ -311,10 +311,12 @@ const tableConfig = computed(
           label: '事件名',
           type: eventNameConfig.value.type,
           options: (mForm: FormState, { formValue }: any) =>
-            eventsService.getEvent(formValue.type).map((option: any) => ({
-              text: option.label,
-              value: option.value,
-            })),
+            eventsService
+              .getEvent(formValue.type, { node: editorService.getNodeById(formValue.id) })
+              .map((option: any) => ({
+                text: option.label,
+                value: option.value,
+              })),
         },
         {
           name: 'to',
@@ -329,7 +331,7 @@ const tableConfig = computed(
             const node = editorService.getNodeById(model.to);
             if (!node?.type) return [];
 
-            return eventsService.getMethod(node.type, model.to).map((option: any) => ({
+            return eventsService.getMethod(node.type, { targetId: model.to, node }).map((option: any) => ({
               text: option.label,
               value: option.value,
             }));

package/src/services/events.ts

@@ -20,7 +20,7 @@ import { reactive } from 'vue';
 import { cloneDeep } from 'lodash-es';
 import type { Writable } from 'type-fest';
 
-import { type EventOption, type Id } from '@tmagic/core';
+import type { EventOption, Id, MNode } from '@tmagic/core';
 import { toLine } from '@tmagic/utils';
 
 import type { AsyncHookPlugin, SyncHookPlugin } from '@editor/type';
@@ -56,7 +56,7 @@ class Events extends BaseService {
     eventMap[toLine(type)] = [...events];
   }
 
-  public getEvent(type: string): EventOption[] {
+  public getEvent(type: string, _data: { node?: MNode | null } = {}): EventOption[] {
     return cloneDeep(eventMap[toLine(type)]) || [];
   }
 
@@ -70,7 +70,7 @@ class Events extends BaseService {
     methodMap[toLine(type)] = [...method];
   }
 
-  public getMethod(type: string, _targetId: Id) {
+  public getMethod(type: string, _data: { node?: MNode | null; targetId?: Id } = {}) {
     return cloneDeep(methodMap[toLine(type)]) || [];
   }
 

package/src/utils/dep/idle-task.ts

@@ -13,6 +13,18 @@ type TaskList<T> = {
   data: T;
 }[];
 
+/**
+ * 回调因 timeout 触发（主线程一直没有空闲）时，单次回调执行任务的时间预算，单位 ms
+ * 参考一帧内可让出的余量：既保证队列有进展，又不长时间阻塞主线程
+ */
+const TIMEOUT_RUN_BUDGET = 5;
+
+/**
+ * 回调因 timeout 触发时，每两次读取时钟之间执行的任务数
+ * 与空闲时间 <=5ms 时的批量保持一致，避免每个任务都读一次时钟
+ */
+const TIMEOUT_BATCH_SIZE = 10;
+
 globalThis.requestIdleCallback =
   globalThis.requestIdleCallback ||
   function (cb) {
@@ -94,6 +106,19 @@ export class IdleTask<T = any> extends EventEmitter {
     this.taskHandle = null;
 
     try {
+      // 主线程一直没有空闲时，回调只会因 timeout 触发，此时 deadline.timeRemaining() 恒为 0（规范行为）。
+      // 若仍以它作为循环条件，一个任务都执行不了，而 finishRun 又会接着重新调度，
+      // 队列就会无限空转下去：依赖收集永远不结束，collecting 卡在 true，画布也不再更新。
+      // 这种情况下改用自有时间预算推进，既保证有进展，又不会像放开循环那样长时间阻塞主线程。
+      if (deadline.didTimeout) {
+        const start = Date.now();
+        do {
+          this.runTaskBatch(TIMEOUT_BATCH_SIZE);
+        } while (this.getTaskLength() && Date.now() - start < TIMEOUT_RUN_BUDGET);
+
+        return;
+      }
+
       // 动画会占用空闲时间,当任务一直无法执行时，看看是否有动画正在播放
       // 根据空闲时间的多少来决定执行的任务数，保证页面不卡死的情况下尽量多执行任务，不然当任务数巨大时，执行时间会很久
       // 执行不完不会影响配置，但是会影响画布渲染
@@ -110,17 +135,7 @@ export class IdleTask<T = any> extends EventEmitter {
           times = 600;
         }
 
-        for (let i = 0; i < times; i++) {
-          // 每次都从实例上取队列，任务执行过程中调用 clearTasks 能立即生效，不会继续消费已被清空的旧队列
-          const task = this.hightLevelTaskList.length > 0 ? this.hightLevelTaskList.shift() : this.taskList.shift();
-          if (task) {
-            this.runTask(task);
-          }
-
-          if (!this.getTaskLength()) {
-            break;
-          }
-        }
+        this.runTaskBatch(times);
       }
     } finally {
       // 必须放在 finally 中：一旦这里被跳过，taskHandle 会一直是真值，
@@ -129,6 +144,23 @@ export class IdleTask<T = any> extends EventEmitter {
     }
   }
 
+  /**
+   * 执行一批任务，队列被清空时提前结束
+   */
+  private runTaskBatch(times: number) {
+    for (let i = 0; i < times; i++) {
+      // 每次都从实例上取队列，任务执行过程中调用 clearTasks 能立即生效，不会继续消费已被清空的旧队列
+      const task = this.hightLevelTaskList.length > 0 ? this.hightLevelTaskList.shift() : this.taskList.shift();
+      if (task) {
+        this.runTask(task);
+      }
+
+      if (!this.getTaskLength()) {
+        break;
+      }
+    }
+  }
+
   /**
    * 单个任务失败不能中断整个队列，否则后续任务永远不会被执行，
    * 依赖收集会停在半路（收集中状态与剩余任务数都不再变化）

package/src/utils/event.ts

@@ -56,7 +56,8 @@ export const getEventNameOptions = (
   }
 
   if (src === 'component') {
-    let events: EventOption[] | CascaderOption[] = eventsService.getEvent(formValue.type) || [];
+    const sourceNode = editorService.getNodeById(formValue.id);
+    let events: EventOption[] | CascaderOption[] = eventsService.getEvent(formValue.type, { node: sourceNode }) || [];
 
     if (formValue.type === 'page-fragment-container' && formValue.pageFragmentId) {
       const pageFragment = editorService.get('root')?.items?.find((page) => page.id === formValue.pageFragmentId);
@@ -72,9 +73,14 @@ export const getEventNameOptions = (
         },
       ];
 
-      (pageFragment.items || []).forEach((node) => {
-        traverseNode<MComponent | MContainer>(node, (current) => {
-          const nodeEvents = (current.type && eventsService.getEvent(current.type)) || [];
+      (pageFragment.items || []).forEach((item) => {
+        traverseNode<MComponent | MContainer>(item, (current) => {
+          if (!current.type) {
+            return;
+          }
+
+          const node = editorService.getNodeById(current.id) || current;
+          const nodeEvents = eventsService.getEvent(current.type, { node }) || [];
           (events as CascaderOption[]).push({
             label: `${current.name}_${current.id}`,
             value: `${current.id}`,
@@ -176,7 +182,7 @@ export const getCompActionOptions = (toId?: Id): EventNameOption[] => {
     return [];
   }
 
-  let methods: EventOption[] | CascaderOption[] = eventsService.getMethod(node.type, toId) || [];
+  let methods: EventOption[] | CascaderOption[] = eventsService.getMethod(node.type, { targetId: toId, node }) || [];
 
   if (node.type === 'page-fragment-container' && node.pageFragmentId) {
     const pageFragment = editorService.get('root')?.items?.find((page) => page.id === node.pageFragmentId);
@@ -187,15 +193,22 @@ export const getCompActionOptions = (toId?: Id): EventNameOption[] => {
     methods = [];
     (pageFragment.items || []).forEach((item: MComponent | MContainer) => {
       traverseNode<MComponent | MContainer>(item, (current) => {
-        const nodeMethods = (current.type && eventsService.getMethod(current.type, current.id)) || [];
+        const node = editorService.getNodeById(current.id) || current;
 
-        if (nodeMethods.length) {
-          (methods as CascaderOption[]).push({
-            label: `${current.name}_${current.id}`,
-            value: `${current.id}`,
-            children: nodeMethods,
-          });
+        if (!current.type) {
+          return;
         }
+
+        const nodeMethods = eventsService.getMethod(current.type, { targetId: current.id, node }) || [];
+        if (!nodeMethods.length) {
+          return;
+        }
+
+        (methods as CascaderOption[]).push({
+          label: `${current.name}_${current.id}`,
+          value: `${current.id}`,
+          children: nodeMethods,
+        });
       });
     });
 

package/types/index.d.ts

@@ -1023,10 +1023,15 @@ declare class Events extends BaseService {
   constructor();
   setEvents(events: Record<string, EventOption[]>): void;
   setEvent(type: string, events: EventOption[]): void;
-  getEvent(type: string): EventOption[];
+  getEvent(type: string, _data?: {
+    node?: MNode | null;
+  }): EventOption[];
   setMethods(methods: Record<string, EventOption[]>): void;
   setMethod(type: string, method: EventOption[]): void;
-  getMethod(type: string, _targetId: Id): EventOption[];
+  getMethod(type: string, _data?: {
+    node?: MNode | null;
+    targetId?: Id;
+  }): EventOption[];
   resetState(): void;
   destroy(): void;
   usePlugin(options: AsyncHookPlugin<AsyncMethodName$3, Events> & SyncHookPlugin<SyncMethodName$4, Events>): void;
@@ -3395,6 +3400,10 @@ declare class IdleTask<T = any> extends EventEmitter {
   once<Name extends keyof IdleTaskEvents, Param extends IdleTaskEvents[Name]>(eventName: Name, listener: (...args: Param) => void | Promise<void>): this;
   emit<Name extends keyof IdleTaskEvents, Param extends IdleTaskEvents[Name]>(eventName: Name, ...args: Param): boolean;
   private runTaskQueue;
+  /**
+   * 执行一批任务，队列被清空时提前结束
+   */
+  private runTaskBatch;
   /**
    * 单个任务失败不能中断整个队列，否则后续任务永远不会被执行，
    * 依赖收集会停在半路（收集中状态与剩余任务数都不再变化）