aoye 0.0.1 → 0.0.2

package/dist/aoye.umd.js

@@ -4,47 +4,6 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Aoye = {}));
 })(this, (function (exports) { 'use strict';
 
-  class Queue {
-      constructor() {
-          this.len = 0;
-      }
-      get first() {
-          var _a;
-          return (_a = this._first) === null || _a === void 0 ? void 0 : _a.v;
-      }
-      get last() {
-          var _a;
-          return (_a = this._last) === null || _a === void 0 ? void 0 : _a.v;
-      }
-      push(it) {
-          this.len++;
-          const { _last: last } = this;
-          const item = { v: it };
-          if (!last) {
-              this._first = this._last = item;
-              return;
-          }
-          item.prev = this._last;
-          last.next = item;
-          this._last = item;
-      }
-      shift() {
-          const { _first: first } = this;
-          if (!first)
-              return undefined;
-          this.len--;
-          const { next } = first;
-          first.next = undefined;
-          if (next) {
-              next.prev = undefined;
-          }
-          else {
-              this._last = undefined;
-          }
-          this._first = next;
-          return first.v;
-      }
-  }
   class SortMap {
       constructor() {
           this.data = {};
@@ -78,6 +37,151 @@
   // queue.push(10)
   // queue.array();
 
+  const timestamp = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+  var EventMode;
+  (function (EventMode) {
+      EventMode[EventMode["Immediate"] = 0] = "Immediate";
+      EventMode[EventMode["Queue"] = 1] = "Queue";
+  })(EventMode || (EventMode = {}));
+  var ProcessStatus;
+  (function (ProcessStatus) {
+      ProcessStatus[ProcessStatus["None"] = 0] = "None";
+      ProcessStatus[ProcessStatus["Processing"] = 1] = "Processing";
+      ProcessStatus[ProcessStatus["Paused"] = 2] = "Paused";
+  })(ProcessStatus || (ProcessStatus = {}));
+  const DefaultEventOpt = {
+      mode: EventMode.Immediate,
+  };
+  const ALL = '__ALL_KEY';
+  class BaseEvent {
+      constructor(opt = {}) {
+          this.opt = opt;
+          this.eventQueue = [];
+          this.status = ProcessStatus.None;
+          this.subMap = new Map();
+          this.on = (type, fn) => {
+              if (type == null)
+                  type = ALL;
+              const suber = this.subMap.get(type) || new Set();
+              suber.add(fn);
+              this.subMap.set(type, suber);
+          };
+          this.off = (type, fn) => {
+              const suber = this.subMap.get(type !== null && type !== void 0 ? type : ALL);
+              if (!suber)
+                  return;
+              suber.delete(fn);
+          };
+          this.once = (type, fn) => {
+              fn['once'] = true;
+              this.on(type, fn);
+          };
+          this.promiseOnce = (type) => {
+              return new Promise((resolve) => {
+                  this.once(type, (...args) => {
+                      resolve(args);
+                  });
+              });
+          };
+          this.setScheduler = (type, scheduler) => {
+              if (typeof type !== 'string') {
+                  this.scheduler = type;
+                  return;
+              }
+              const set = this.subMap.get(type) || new Set();
+              set['scheduler'] = scheduler;
+              this.subMap.set(type, set);
+          };
+          // construct 会初始化为下面其中一种
+          this.emit = (type, ...args) => {
+              this.opt.mode === EventMode.Immediate
+                  ? this.emitImmediate(type, ...args)
+                  : this.emitQueue(type, ...args);
+          };
+          this.pause = () => (this.status = ProcessStatus.Paused);
+          this.unPause = () => (this.status = ProcessStatus.None);
+          this.start = () => {
+              this.status = ProcessStatus.None;
+              this.processQueue();
+          };
+          this.process = () => {
+              if (this.scheduler) {
+                  return this.scheduler(this.recallScheduler);
+              }
+              return this.processQueue();
+          };
+          this.recallScheduler = () => {
+              this.scheduler(this.recallScheduler);
+          };
+          this.processQueue = () => {
+              // 如果是挂起状态则直接结束
+              if (this.status === ProcessStatus.Paused)
+                  return;
+              this.status = ProcessStatus.Processing;
+              let { type, args } = this.eventQueue.shift() || {};
+              if (type) {
+                  // 在此过程中用户可通过 pause 和 start 同步控制事件处理
+                  const fns = this.subMap.get(type);
+                  const allSub = this.subMap.get(ALL);
+                  fns === null || fns === void 0 ? void 0 : fns.forEach((it) => this.callSub(it, fns, args));
+                  allSub === null || allSub === void 0 ? void 0 : allSub.forEach((it) => this.callSub(it, allSub, args));
+                  if (this.eventQueue.length > 0) {
+                      this.processQueue();
+                  }
+              }
+              //@ts-ignore 队列全部处理完成，如果执行过程中被 pause 
+              if (this.status !== ProcessStatus.Paused) {
+                  this.status = ProcessStatus.None;
+              }
+          };
+          this.dispatchEvent = (iList) => {
+              // 从大到小排序
+              iList.sort((a, b) => b - a);
+              iList.forEach((idx) => {
+                  const [item] = this.eventQueue.splice(idx, 1);
+                  const { type, args } = item || {};
+                  if (type && args) {
+                      this.emitImmediate(type, ...args);
+                  }
+              });
+          };
+          this.clear = () => {
+              this.subMap.clear();
+              this.eventQueue = [];
+              this.scheduler = undefined;
+          };
+          this.opt = { ...DefaultEventOpt, ...opt };
+      }
+      callSub(it, fns, args) {
+          const doCall = (...args) => {
+              it(...args);
+              if (it['once'] === true)
+                  fns.delete(it);
+          };
+          const scheduler = it['scheduler'] || fns['scheduler'];
+          if (scheduler) {
+              scheduler(doCall, ...args);
+          }
+          else {
+              it(...args);
+              if (it['once'] === true)
+                  fns.delete(it);
+          }
+      }
+      emitImmediate(type, ...args) {
+          const fns = this.subMap.get(type);
+          const allSub = this.subMap.get(ALL);
+          fns === null || fns === void 0 ? void 0 : fns.forEach((it) => this.callSub(it, fns, args));
+          allSub === null || allSub === void 0 ? void 0 : allSub.forEach((it) => this.callSub(it, allSub, args));
+      }
+      emitQueue(type, ...args) {
+          this.eventQueue.push({ type, args, time: timestamp() });
+          this.process();
+      }
+  }
+  BaseEvent.a = 19;
+
+  const evt = new BaseEvent();
   const G = {
       /** 原子 signal 更新次数 */
       version: 0,
@@ -90,6 +194,7 @@
   (function (State) {
       State[State["Clean"] = 0] = "Clean";
       /** 仅用于 scope 节点是否 abort */
+      State[State["ScopeAborted"] = 64] = "ScopeAborted";
       State[State["ScopeAbort"] = 32] = "ScopeAbort";
       State[State["OutLink"] = 16] = "OutLink";
       State[State["Unknown"] = 8] = "Unknown";
@@ -98,6 +203,259 @@
       State[State["ScopeReady"] = 1] = "ScopeReady";
   })(State || (State = {}));
   const DirtyState = State.Unknown | State.Dirty;
+  const ScopeExecuted = State.ScopeReady | State.ScopeAbort | State.ScopeAborted;
+
+  /**
+   * 这是一个优先队列 （满足子节点总是比父节点大）
+   *                    1
+   *
+   *               10          20
+   *
+   *          15    30      25      30
+   *
+   *       17
+   *  现在插入 7 ， 会按广度优先的顺序插入在数组尾部
+   *                    1
+   *
+   *               10          20
+   *
+   *          15    30      25      30
+   *
+   *       17    7
+   * 接着我们只需要将 7  逐层与上门的父节点比较， 7 较小则两者交互，一直让 7 上浮到适合的位置
+   *
+   *                          0
+   *
+   *                    1           2                 2^0 得到第二层第一个索引
+   *
+   *              3       4     5       6            2^0 + 2^1 。。。 + 2^n + x = y
+   *
+   *          7      8
+   * 上浮后我们得到以上的树
+   */
+  // 父子节点的关系
+  // 计算一个节点的 index 公式 ①   2^0 + 2^1 。。。 + 2^n + y = x 已知
+  // 节点的左子节点 index     ②   2^0 + 2^1 。。。 + 2^n + 2^(n+1) + z = res 求 res
+  // ② - ① 得到 2^(n+1) + (z-y) = res - x
+  // 2^(n+1) + (z-y) + x = res
+  // 而 z 和 y 的关系是，③ z = 2y
+  const leakI = (y, max) => (y < 0 || y >= max ? null : y);
+  const getLeft = (x, max) => leakI(x * 2 + 1, max);
+  const getRight = (x, max) => leakI(x * 2 + 2, max);
+  const getParent = (x, max) => leakI((x - 1) >>> 1, max);
+  const exchange = (arr, i, j) => ([arr[i], arr[j]] = [arr[j], arr[i]]);
+  class PriorityQueue {
+      // 构造函数接受一个compare函数
+      // compare返回的-1, 0, 1决定元素是否优先被去除
+      constructor(aIsUrgent) {
+          this.aIsUrgent = aIsUrgent;
+          this.arr = [];
+          this.goUp = (arr, current, len) => {
+              let i = len - 1;
+              while (i > 0) {
+                  const item = arr[i];
+                  const pI = getParent(i, len);
+                  const parent = arr[pI];
+                  if (this.aIsUrgent(item, parent)) {
+                      // console.log(`交换 parent:${parent} -> child:${item} `);
+                      exchange(arr, i, pI);
+                      // this.logTree();
+                      i = pI;
+                  }
+                  else {
+                      // console.log(`parent:${parent} child:${item} 不需要交换 \n`);
+                      break;
+                  }
+              }
+          };
+          this.goDown = (arr, i) => {
+              const len = this.size();
+              const half = len >>> 1;
+              while (i < half) {
+                  const lI = getLeft(i, len);
+                  const rI = getRight(i, len);
+                  let point = i;
+                  if (lI != null && this.aIsUrgent(arr[lI], arr[point])) {
+                      point = lI;
+                  }
+                  if (rI != null && this.aIsUrgent(arr[rI], arr[point])) {
+                      point = rI;
+                  }
+                  if (point === i) {
+                      break;
+                  }
+                  // console.log(`交换 parent:${arr[i]} -> child:${arr[point]} `);
+                  exchange(arr, i, point);
+                  // this.logTree();
+                  i = point;
+              }
+          };
+      }
+      // 添加一个元素
+      _add(current) {
+          // console.log(`加入 ${current}`);
+          this.arr.push(current);
+          const len = this.size();
+          // this.logTree();
+          if (len === 1) {
+              return;
+          }
+          this.goUp(this.arr, current, len);
+      }
+      add(...items) {
+          items.forEach(it => this._add(it));
+      }
+      // 去除头元素并返回
+      poll() {
+          const { arr } = this;
+          // console.log(`弹出 ${arr[0]} 把 ${arr[arr.length - 1]} 放置到队头 `);
+          const len = this.size();
+          if (len <= 2) {
+              return arr.shift();
+          }
+          const last = arr.pop();
+          const first = arr[0];
+          arr[0] = last;
+          // this.logTree();
+          this.goDown(this.arr, 0);
+          return first;
+      }
+      // 取得头元素
+      peek() {
+          return this.arr[0];
+      }
+      // 取得元素数量
+      size() {
+          return this.arr.length;
+      }
+      logTree() {
+          const { arr } = this;
+          let i = 0;
+          let j = 1;
+          let level = 0;
+          const matrix = [];
+          do {
+              matrix.push(arr.slice(i, j));
+              i = i * 2 + 1;
+              j = i + Math.pow(2, level) + 1;
+              level++;
+          } while (i < arr.length);
+          const last = Math.pow(2, matrix.length - 1);
+          const arrStr = JSON.stringify(last);
+          const halfLen = arrStr.length >>> 1;
+          matrix.forEach(it => {
+              const str = JSON.stringify(it);
+              const halfIt = str.length >>> 1;
+              console.log(str.padStart(halfLen + halfIt, ' '));
+          });
+          console.log('\n');
+      }
+  }
+  // case 1
+  // const pq = new PriorityQueue((a, b) => a - b)
+  // pq.add(5)
+  // pq.add(3)
+  // pq.add(1)
+  // pq.add(4)
+  // pq.add(2)
+  // const result = []
+  // while (pq.size() > 0) {
+  //   result.push(pq.poll())
+  // }
+  // console.log(result);
+  // [1,2,3,4,5]
+  // case 2
+  // const pq = new PriorityQueue((a, b) => b - a)
+  // pq.add(1)
+  // pq.add(3)
+  // pq.add(4)
+  // pq.add(5)
+  // pq.add(2)
+  // const result = []
+  // while (pq.size() > 0) {
+  //   result.push(pq.poll())
+  // }
+  // console.log(result);
+  // [5,4,3,2,1]
+
+  class TaskQueue {
+      constructor(callbackAble, aIsUrgent) {
+          this.callbackAble = callbackAble;
+          this.aIsUrgent = aIsUrgent;
+          this.isScheduling = false;
+      }
+      static create({ callbackAble, aIsUrgent }) {
+          const queue = new TaskQueue(callbackAble, aIsUrgent);
+          queue.taskQueue = new PriorityQueue(aIsUrgent);
+          return queue;
+      }
+      pushTask(task) {
+          const { taskQueue, isScheduling } = this;
+          taskQueue._add(task);
+          if (!isScheduling) {
+              this.callbackAble(this.scheduleTask.bind(this));
+              this.isScheduling = true;
+          }
+      }
+      scheduleTask() {
+          const { taskQueue } = this;
+          // console.log('调度 dispose');
+          const fn = taskQueue.peek();
+          if (!fn)
+              return (this.isScheduling = false);
+          const hasRemain = fn();
+          // 未完成
+          if (hasRemain) {
+              this.callbackAble(this.scheduleTask.bind(this));
+              return;
+          }
+          // 完成
+          taskQueue.poll();
+          evt.emit('one', fn);
+          if (taskQueue.size() === 0) {
+              evt.emit('done', fn);
+              return (this.isScheduling = false);
+          }
+          // 任务列表中还有任务
+          this.callbackAble(this.scheduleTask.bind(this));
+      }
+  }
+
+  const ide = globalThis.requestIdleCallback ||
+      (globalThis.requestAnimationFrame
+          ? (fn) => globalThis.requestAnimationFrame(() => {
+              setTimeout(() => {
+                  fn();
+              });
+          })
+          : globalThis.setTimeout);
+  const now = () => {
+      const timer = globalThis.performance || globalThis.Date;
+      return timer.now();
+  };
+  let channel = globalThis.MessageChannel ? new MessageChannel() : null;
+  if (globalThis.MessageChannel) {
+      channel = new MessageChannel();
+  }
+  let msgId = 0;
+  const macro = fn => {
+      if (!channel) {
+          setTimeout(fn);
+      }
+      const memoId = msgId;
+      function onMessage(e) {
+          if (memoId === e.data) {
+              fn();
+              channel.port2.removeEventListener('message', onMessage);
+          }
+      }
+      channel.port2.addEventListener('message', onMessage);
+      channel.port1.postMessage(msgId++);
+  };
+  const p = Promise.resolve();
+  const micro = (cb) => {
+      p.then(cb);
+  };
 
   exports.Scheduler = void 0;
   (function (Scheduler) {
@@ -110,7 +468,7 @@
       [exports.Scheduler.Sync]: defaultScheduler,
       [exports.Scheduler.Micro]: microScheduler,
       [exports.Scheduler.Macro]: macroScheduler,
-      [exports.Scheduler.Layout]: schedulerLayout
+      [exports.Scheduler.Layout]: layoutScheduler
   };
   const scheduler = (key, value) => (_scheduler[key] = value);
   function defaultScheduler(effects) {
@@ -118,40 +476,21 @@
           effect.runIfDirty();
       }
   }
-  const p = Promise.resolve();
-  let hasMicroTask = false;
+  let microSTaskQueue;
+  let macroSTaskQueue;
+  let layoutSTaskQueue;
   function microScheduler(effects) {
-      if (hasMicroTask)
-          return;
-      p.then(() => {
-          defaultScheduler(effects);
-          hasMicroTask = false;
-      });
-      hasMicroTask = true;
-  }
-  let channel, macroQueue;
-  if (globalThis.MessageChannel) {
-      channel = new MessageChannel();
-      macroQueue = new Queue();
-      channel.port2.onmessage = () => {
-          while (macroQueue.first) {
-              macroQueue.shift()();
-          }
-      };
+      microSTaskQueue = microSTaskQueue || TaskQueue.create({ callbackAble: micro, aIsUrgent: (a, b) => a.time < b.time });
+      microSTaskQueue.pushTask(defaultScheduler.bind(undefined, effects));
   }
   function macroScheduler(effects) {
-      if (channel) {
-          macroQueue.push(() => defaultScheduler(effects));
-          channel.port1.postMessage('');
-      }
-      setTimeout(() => {
-          defaultScheduler(effects);
-      });
+      macroSTaskQueue = macroSTaskQueue || TaskQueue.create({ callbackAble: macro, aIsUrgent: (a, b) => a.time < b.time });
+      macroSTaskQueue.pushTask(defaultScheduler.bind(undefined, effects));
   }
-  function schedulerLayout(effects) {
-      requestAnimationFrame(() => {
-          defaultScheduler(effects);
-      });
+  function layoutScheduler(effects) {
+      layoutSTaskQueue =
+          layoutSTaskQueue || TaskQueue.create({ callbackAble: macro, aIsUrgent: (a, b) => a.time < b.time });
+      layoutSTaskQueue.pushTask(defaultScheduler.bind(undefined, effects));
   }
 
   const DefaultDFSOpt = {
@@ -366,262 +705,6 @@
       }
   }
 
-  /**
-   * 这是一个优先队列 （满足子节点总是比父节点大）
-   *                    1
-   *
-   *               10          20
-   *
-   *          15    30      25      30
-   *
-   *       17
-   *  现在插入 7 ， 会按广度优先的顺序插入在数组尾部
-   *                    1
-   *
-   *               10          20
-   *
-   *          15    30      25      30
-   *
-   *       17    7
-   * 接着我们只需要将 7  逐层与上门的父节点比较， 7 较小则两者交互，一直让 7 上浮到适合的位置
-   *
-   *                          0
-   *
-   *                    1           2                 2^0 得到第二层第一个索引
-   *
-   *              3       4     5       6            2^0 + 2^1 。。。 + 2^n + x = y
-   *
-   *          7      8
-   * 上浮后我们得到以上的树
-   */
-  // 父子节点的关系
-  // 计算一个节点的 index 公式 ①   2^0 + 2^1 。。。 + 2^n + y = x 已知
-  // 节点的左子节点 index     ②   2^0 + 2^1 。。。 + 2^n + 2^(n+1) + z = res 求 res
-  // ② - ① 得到 2^(n+1) + (z-y) = res - x
-  // 2^(n+1) + (z-y) + x = res
-  // 而 z 和 y 的关系是，③ z = 2y
-  const leakI = (y, max) => (y < 0 || y >= max ? null : y);
-  const getLeft = (x, max) => leakI(x * 2 + 1, max);
-  const getRight = (x, max) => leakI(x * 2 + 2, max);
-  const getParent = (x, max) => leakI((x - 1) >>> 1, max);
-  const exchange = (arr, i, j) => ([arr[i], arr[j]] = [arr[j], arr[i]]);
-  class PriorityQueue {
-      // 构造函数接受一个compare函数
-      // compare返回的-1, 0, 1决定元素是否优先被去除
-      constructor(aIsUrgent) {
-          this.aIsUrgent = aIsUrgent;
-          this.arr = [];
-          this.goUp = (arr, current, len) => {
-              let i = len - 1;
-              while (i > 0) {
-                  const item = arr[i];
-                  const pI = getParent(i, len);
-                  const parent = arr[pI];
-                  if (this.aIsUrgent(item, parent)) {
-                      // console.log(`交换 parent:${parent} -> child:${item} `);
-                      exchange(arr, i, pI);
-                      // this.logTree();
-                      i = pI;
-                  }
-                  else {
-                      // console.log(`parent:${parent} child:${item} 不需要交换 \n`);
-                      break;
-                  }
-              }
-          };
-          this.goDown = (arr, i) => {
-              const len = this.size();
-              const half = len >>> 1;
-              while (i < half) {
-                  const lI = getLeft(i, len);
-                  const rI = getRight(i, len);
-                  let point = i;
-                  if (lI != null && this.aIsUrgent(arr[lI], arr[point])) {
-                      point = lI;
-                  }
-                  if (rI != null && this.aIsUrgent(arr[rI], arr[point])) {
-                      point = rI;
-                  }
-                  if (point === i) {
-                      break;
-                  }
-                  // console.log(`交换 parent:${arr[i]} -> child:${arr[point]} `);
-                  exchange(arr, i, point);
-                  // this.logTree();
-                  i = point;
-              }
-          };
-      }
-      // 添加一个元素
-      _add(current) {
-          // console.log(`加入 ${current}`);
-          this.arr.push(current);
-          const len = this.size();
-          // this.logTree();
-          if (len === 1) {
-              return;
-          }
-          this.goUp(this.arr, current, len);
-      }
-      add(...items) {
-          items.forEach(it => this._add(it));
-      }
-      // 去除头元素并返回
-      poll() {
-          const { arr } = this;
-          // console.log(`弹出 ${arr[0]} 把 ${arr[arr.length - 1]} 放置到队头 `);
-          const len = this.size();
-          if (len <= 2) {
-              return arr.shift();
-          }
-          const last = arr.pop();
-          const first = arr[0];
-          arr[0] = last;
-          // this.logTree();
-          this.goDown(this.arr, 0);
-          return first;
-      }
-      // 取得头元素
-      peek() {
-          return this.arr[0];
-      }
-      // 取得元素数量
-      size() {
-          return this.arr.length;
-      }
-      logTree() {
-          const { arr } = this;
-          let i = 0;
-          let j = 1;
-          let level = 0;
-          const matrix = [];
-          do {
-              matrix.push(arr.slice(i, j));
-              i = i * 2 + 1;
-              j = i + Math.pow(2, level) + 1;
-              level++;
-          } while (i < arr.length);
-          const last = Math.pow(2, matrix.length - 1);
-          const arrStr = JSON.stringify(last);
-          const halfLen = arrStr.length >>> 1;
-          matrix.forEach(it => {
-              const str = JSON.stringify(it);
-              const halfIt = str.length >>> 1;
-              console.log(str.padStart(halfLen + halfIt, ' '));
-          });
-          console.log('\n');
-      }
-  }
-  // case 1
-  // const pq = new PriorityQueue((a, b) => a - b)
-  // pq.add(5)
-  // pq.add(3)
-  // pq.add(1)
-  // pq.add(4)
-  // pq.add(2)
-  // const result = []
-  // while (pq.size() > 0) {
-  //   result.push(pq.poll())
-  // }
-  // console.log(result);
-  // [1,2,3,4,5]
-  // case 2
-  // const pq = new PriorityQueue((a, b) => b - a)
-  // pq.add(1)
-  // pq.add(3)
-  // pq.add(4)
-  // pq.add(5)
-  // pq.add(2)
-  // const result = []
-  // while (pq.size() > 0) {
-  //   result.push(pq.poll())
-  // }
-  // console.log(result);
-  // [5,4,3,2,1]
-
-  class TaskQueue {
-      constructor(callbackAble, aIsUrgent) {
-          this.callbackAble = callbackAble;
-          this.aIsUrgent = aIsUrgent;
-          this.isScheduling = false;
-      }
-      static create({ callbackAble, aIsUrgent }) {
-          const queue = new TaskQueue(callbackAble, aIsUrgent);
-          queue.taskQueue = new PriorityQueue(aIsUrgent);
-          return queue;
-      }
-      pushTask(task) {
-          const { taskQueue, isScheduling } = this;
-          taskQueue._add(task);
-          if (!isScheduling) {
-              this.callbackAble(this.scheduleTask.bind(this));
-              this.isScheduling = true;
-          }
-      }
-      scheduleTask() {
-          const { taskQueue } = this;
-          // console.log('调度 dispose');
-          const fn = taskQueue.peek();
-          if (!fn)
-              return (this.isScheduling = false);
-          const hasRemain = fn();
-          // 未完成
-          if (hasRemain) {
-              this.callbackAble(this.scheduleTask.bind(this));
-              return;
-          }
-          // 完成
-          taskQueue.poll();
-          if (taskQueue.size() === 0)
-              return (this.isScheduling = false);
-          // 任务列表中还有任务
-          this.callbackAble(this.scheduleTask.bind(this));
-      }
-  }
-
-  const ide = globalThis.requestIdleCallback ||
-      (globalThis.requestAnimationFrame
-          ? (fn) => globalThis.requestAnimationFrame(() => {
-              setTimeout(() => {
-                  fn();
-              });
-          })
-          : globalThis.setTimeout);
-  const now = () => {
-      const timer = globalThis.performance || globalThis.Date;
-      return timer.now();
-  };
-
-  // export class IdeScheduler {
-  //   constructor() {}
-  //   isScheduling = false;
-  //   taskQueue = new Queue<Function>();
-  //   pushTask(task: Function) {
-  //     const { taskQueue, isScheduling } = this;
-  //     taskQueue.push(task);
-  //     if (!isScheduling) {
-  //       ide(this.scheduleTask.bind(this));
-  //       this.isScheduling = true;
-  //     }
-  //   }
-  //   scheduleTask() {
-  //     const { taskQueue } = this;
-  //     // console.log('调度 dispose');
-  //     const fn = taskQueue.first;
-  //     if (!fn) return (this.isScheduling = false);
-  //     const hasRemain = fn();
-  //     // 未完成
-  //     if (hasRemain) {
-  //       ide(this.scheduleTask.bind(this));
-  //       return;
-  //     }
-  //     // 完成
-  //     taskQueue.shift();
-  //     if (taskQueue.len === 0) return (this.isScheduling = false);
-  //     // 任务列表中还有任务
-  //     ide(this.scheduleTask.bind(this));
-  //   }
-  // }
   /** scope 捕获，引用外部 signal 孤岛 */
   const unTrackIsland = (signal) => {
       // 原来是孤岛，且被 scope 管理的要恢复
@@ -640,6 +723,14 @@
           Line.line_line_rec(recEnd, line);
       }
   };
+  /** 子 scope 释放，把其 only 被其持有的 signal 挂回其属于的 scope */
+  const trackByOtherScopeDispose = (signal) => {
+      const line = new Line();
+      const { recEnd } = signal.scope;
+      Line.emit_line(signal, line);
+      Line.rec_line(signal.scope, line);
+      Line.line_line_rec(recEnd, line);
+  };
   const markOutLink = (signal, downstream) => {
       // 上游是外部节点，或者上游引用了外部节点的， 做传播
       if (signal.scope !== downstream.scope || signal.state & State.OutLink) {
@@ -661,13 +752,16 @@
           return a.index < b.index;
       }
   });
-  function handleOneTask(s, breakStack) {
+  function handleOneTask(scope, breakStack) {
       breakStack = remain.stack || breakStack;
       // 将 s 同步到 remainRoot
       let lineToRemove = null;
       const startTime = now();
+      if (scope.emitStart) {
+          Line.unlink(scope.emitStart);
+      }
       try {
-          dfs(s, {
+          dfs(scope, {
               breakStack,
               breakNode: remain.node,
               breakLine: remain.line,
@@ -685,9 +779,28 @@
                       };
                       throw BreakErr;
                   }
+                  // 1. 未标记的节点，是外部节点
                   if (!(node.state & State.OutLink)) {
                       return true;
                   }
+                  // 2. 标记的节点，但是 scope 不一样，说明外部节点也引用了 另一 scope 的节点
+                  if (lineFromUp && node.scope !== lineFromUp.downstream['scope']) {
+                      // 是仅被 node 引用的外部节点
+                      if (node.emitStart === node.emitEnd) {
+                          // 已经 abort 只能继续释放
+                          if (scope.state & State.ScopeAborted) {
+                              const bound = handleOneTask.bind(undefined, node, []);
+                              bound.index = G.scopeDisposeI++;
+                              ideScheduler.pushTask(bound);
+                          }
+                          // 可以将其交给 原 scope 释放
+                          else {
+                              trackByOtherScopeDispose(node);
+                          }
+                      }
+                      // 任何外部引用都应该被断开
+                      return true;
+                  }
                   // 对于嵌套作用域不允许重复进入
                   node.state &= ~State.OutLink;
               },
@@ -711,6 +824,7 @@
               node: null,
               line: null
           };
+          scope.state |= State.ScopeAborted;
       }
       catch (error) {
           if (error === BreakErr)
@@ -962,7 +1076,7 @@
           // scope 被取消
           (this.scope && this.scope.state & State.ScopeAbort) ||
               // 是 scope 节点，且处于 ready 状态，不需要重复执行
-              (this === this.scope && this.state & (State.ScopeAbort | State.ScopeReady)));
+              (this === this.scope && this.state & ScopeExecuted));
       }
   }
   Signal.Pulling = null;
@@ -1039,8 +1153,54 @@
           return s;
       });
   };
+  // const globalSignal = $(10);
+  // let outerA, outerB, innerX, innerY, outerResult, innerResult, innerDispose;
+  // const outerDispose = scope(() => {
+  //   outerA = $(1);
+  //   outerB = $(2);
+  //   // 外层计算信号
+  //   outerResult = $(() => {
+  //     const res = globalSignal.v + outerA.v + outerB.v;
+  //     return res;
+  //   });
+  //   innerDispose = scope(() => {
+  //     innerX = $(3);
+  //     innerY = $(4);
+  //     // 内层计算信号，既依赖内层也依赖外层信号
+  //     innerResult = $(() => {
+  //       const res = outerA.v + innerX.v + innerY.v;
+  //       return res;
+  //     });
+  //     // 访问信号以建立依赖关系
+  //     innerResult();
+  //   });
+  //   // 访问外层信号
+  //   outerResult();
+  //   // 将内层dispose函数绑定到外层scope，这样可以测试嵌套行为
+  //   (outerResult as any).innerDispose = innerDispose;
+  // });
+  // outerA.v = 5;
+  // innerX.v = 6;
+  // globalSignal.v = 20;
+  // // 先释放内层scope
+  // innerDispose();
+  // innerX.v = 7;
+  // outerA.v = 8;
+  // outerDispose();
+  // evt.on('one', ({ index }) => {
+  //   switch (index) {
+  //     case 0:
+  //       console.log({ index });
+  //       break;
+  //     case 1:
+  //       console.log({ index });
+  //     default:
+  //       break;
+  //   }
+  // });
 
   exports.$ = $;
+  exports.TaskQueue = TaskQueue;
   exports.customSignal = customSignal;
   exports.scheduler = scheduler;
   exports.scope = scope;