aoye 0.0.1 → 0.0.2

package/dist/aoye.esm.js

@@ -1,58 +1,21 @@
-function Queue() {
-  return {
-    len: 0,
-    push: Queue_$$$_push,
-    shift: Queue_$$$_shift,
-    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;
-    }
-  };
-}
-function Queue_$$$_push(it) {
-  this.len++;
-  const {
-    _last: last
-  } = this;
-  const item = {
-    v: it
-  };
-  if (!last) {
-    this._first = this._last = item;
-    return;
+class SortMap {
+  constructor() {
+    this.data = {};
   }
-  item.prev = this._last;
-  last.next = item;
-  this._last = item;
-}
-function Queue_$$$_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;
+  clear() {
+    this.data = {};
+  }
+  add(key, value) {
+    const {
+      data
+    } = this;
+    let list = data[key];
+    if (!list) {
+      list = [];
+      data[key] = list;
+    }
+    list.push(value);
   }
-  this._first = next;
-  return first.v;
-}
-function SortMap() {
-  return {
-    data: {},
-    clear: SortMap_$$$_clear,
-    add: SortMap_$$$_add
-  };
 }
 // const queue = new Queue([1,2,3,4]);
 // queue.shift()
@@ -69,21 +32,157 @@ function SortMap() {
 // queue.pop()
 // queue.push(10)
 // queue.array();
-function SortMap_$$$_clear() {
-  this.data = {};
-}
-function SortMap_$$$_add(key, value) {
-  const {
-    data
-  } = this;
-  let list = data[key];
-  if (!list) {
-    list = [];
-    data[key] = list;
+
+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();
   }
-  list.push(value);
 }
+BaseEvent.a = 19;
 
+const evt = new BaseEvent();
 const G = {
   /** 原子 signal 更新次数 */
   version: 0,
@@ -91,11 +190,12 @@ const G = {
   /** scope 销毁任务序号 */
   scopeDisposeI: 0
 };
-const dirtyLeafs = SortMap();
+const dirtyLeafs = new SortMap();
 var State;
 (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";
@@ -104,294 +204,7 @@ var State;
   State[State["ScopeReady"] = 1] = "ScopeReady";
 })(State || (State = {}));
 const DirtyState = State.Unknown | State.Dirty;
-
-var Scheduler;
-(function (Scheduler) {
-  Scheduler["Sync"] = "__Sync_";
-  Scheduler["Layout"] = "__Layout_";
-  Scheduler["Micro"] = "__Micro_";
-  Scheduler["Macro"] = "__Macro_";
-})(Scheduler || (Scheduler = {}));
-const _scheduler = {
-  [Scheduler.Sync]: defaultScheduler,
-  [Scheduler.Micro]: microScheduler,
-  [Scheduler.Macro]: macroScheduler,
-  [Scheduler.Layout]: schedulerLayout
-};
-const scheduler = (key, value) => _scheduler[key] = value;
-function defaultScheduler(effects) {
-  for (const effect of effects) {
-    effect.runIfDirty();
-  }
-}
-const p = Promise.resolve();
-let hasMicroTask = false;
-function microScheduler(effects) {
-  if (hasMicroTask) return;
-  p.then(() => {
-    defaultScheduler(effects);
-    hasMicroTask = false;
-  });
-  hasMicroTask = true;
-}
-let channel, macroQueue;
-if (globalThis.MessageChannel) {
-  channel = new MessageChannel();
-  macroQueue = Queue();
-  channel.port2.onmessage = () => {
-    while (macroQueue.first) {
-      macroQueue.shift()();
-    }
-  };
-}
-function macroScheduler(effects) {
-  if (channel) {
-    macroQueue.push(() => defaultScheduler(effects));
-    channel.port1.postMessage('');
-  }
-  setTimeout(() => {
-    defaultScheduler(effects);
-  });
-}
-function schedulerLayout(effects) {
-  requestAnimationFrame(() => {
-    defaultScheduler(effects);
-  });
-}
-
-const DefaultDFSOpt = {
-  isUp: false,
-  begin: undefined,
-  complete: undefined,
-  breakStack: [],
-  breakLine: undefined,
-  breakNode: undefined
-};
-function dfs(root, opt = {}) {
-  const {
-    isUp,
-    begin,
-    complete,
-    breakStack: lineStack,
-    breakLine
-  } = {
-    ...DefaultDFSOpt,
-    ...opt
-  };
-  let node = opt.breakNode || root;
-  let line = breakLine;
-  const listKey = isUp ? 'recStart' : 'emitStart';
-  const nodeKey = isUp ? 'upstream' : 'downstream';
-  // 向上意味着要找所有节点的入度
-  const nextLineKey = isUp ? 'nextRecLine' : 'nextEmitLine';
-  const reverseNodeKey = isUp ? 'downstream' : 'upstream';
-  while (1) {
-    let notGoDeep = begin === null || begin === void 0 ? void 0 : begin({
-      node: node,
-      lineFromUp: line,
-      walkedLine: lineStack
-    });
-    lineStack.push(line);
-    line = node[listKey];
-    if (line && !notGoDeep) {
-      const firstChild = line[nodeKey];
-      node = firstChild;
-      continue;
-    }
-    while (1) {
-      const noGoSibling = complete === null || complete === void 0 ? void 0 : complete({
-        node: node,
-        lineToDeep: line,
-        walkedLine: lineStack,
-        notGoDeep
-      });
-      // 只对当前不下钻的节点生效
-      // notGoDeep = false;
-      line = lineStack.pop();
-      // 递归出口，回到起点
-      if (node === root) {
-        return;
-      }
-      notGoDeep = false;
-      const nextLine = line[nextLineKey];
-      // 有兄弟节点， 进入外循环，向下遍历兄弟节点
-      if (!noGoSibling && nextLine) {
-        // 外层循环后会把 sibling line 入栈，这里不需要处理
-        line = nextLine;
-        node = nextLine[nodeKey];
-        break;
-      }
-      // 没有兄弟节点就上浮
-      node = line[reverseNodeKey];
-    }
-  }
-}
-
-function Line_$$$_link(v1, v2) {
-  let {
-      emitEnd
-    } = v1,
-    {
-      recEnd,
-      recStart
-    } = v2,
-    noRecEnd = !recEnd,
-    /** 模拟头节点 */
-    head = {
-      nextRecLine: recStart
-    },
-    line;
-  recEnd = recEnd || head;
-  const {
-    nextRecLine
-  } = recEnd || {};
-  // 没有下一个收到的线
-  if (!nextRecLine) {
-    line = Line();
-    // 内部会处理空链表的情况，即同步头部
-    Line.emit_line(v1, line);
-    Line.rec_line(v2, line);
-    emitEnd && Line.line_line_emit(emitEnd, line);
-    !noRecEnd && Line.line_line_rec(recEnd, line);
-  }
-  // 复用
-  else if (nextRecLine.upstream === v1) {
-    v2.recEnd = nextRecLine;
-    // TODO: link 版本标记
-  }
-  // 插入(这么做): v1 和 下一个 入度(订阅)节点不同
-  // TODO: v2上次真依赖了 v1 只是没检查出来，需要删除原依赖
-  else {
-    line = Line();
-    Line.emit_line(v1, line);
-    Line.rec_line(v2, line);
-    emitEnd && Line.line_line_emit(emitEnd, line);
-    Line.insert_line_rec(recEnd, nextRecLine, line);
-  }
-  // 消除 head
-  for (const key in head) {
-    head[key] = undefined;
-  }
-}
-Line.link = Line_$$$_link;
-function Line_$$$_unlink(line) {
-  let {
-    prevEmitLine,
-    nextEmitLine,
-    prevRecLine,
-    nextRecLine,
-    upstream,
-    downstream
-  } = line;
-  line.prevEmitLine = undefined;
-  line.nextEmitLine = undefined;
-  line.prevRecLine = undefined;
-  line.nextRecLine = undefined;
-  line.upstream = undefined;
-  line.downstream = undefined;
-  /** 上游节点发出的线 前一条 关联 后一条 */
-  if (prevEmitLine) {
-    prevEmitLine.nextEmitLine = nextEmitLine;
-  } else {
-    // 删除的是首个节点
-    upstream.emitStart = nextEmitLine;
-  }
-  if (nextEmitLine) {
-    nextEmitLine.prevEmitLine = prevEmitLine;
-  } else {
-    // 删除尾节点
-    upstream.emitEnd = prevEmitLine;
-  }
-  /** 下游节点接收的线，我们从 recEnd 开始删除的，
-   * 接收信息，不需要设置 recEnd ，
-   * 因为 recStart ~ recEnd 是经过上级 get 确认的有用依赖
-   * */
-  if (prevRecLine) {
-    prevRecLine.nextRecLine = nextRecLine;
-  } else {
-    // 删除的是首个节点，大概率不可能从有依赖 变成无依赖
-    downstream.recStart = nextRecLine;
-  }
-  if (nextRecLine) {
-    nextRecLine.prevRecLine = prevRecLine;
-  } else {
-    // 删除尾节点
-    downstream.recEnd = prevRecLine;
-  }
-}
-Line.unlink = Line_$$$_unlink;
-function Line_$$$_unlinkRec(line) {
-  // 作为下游，执行完 get 上游节点已经完成了依赖更新，把 recEnd 后的依赖删除即可
-  let toDel = line;
-  while (toDel) {
-    const memoNext = toDel.nextRecLine;
-    Line.unlink(toDel);
-    toDel = memoNext;
-  }
-}
-Line.unlinkRec = Line_$$$_unlinkRec;
-function Line_$$$_unlinkEmit(line) {
-  // 作为下游，执行完 get 上游节点已经完成了依赖更新，把 recEnd 后的依赖删除即可
-  let toDel = line;
-  while (toDel) {
-    const memoNext = toDel.nextEmitLine;
-    Line.unlink(toDel);
-    toDel = memoNext;
-  }
-}
-Line.unlinkEmit = Line_$$$_unlinkEmit;
-function Line_$$$_emit_line(upstream, line) {
-  if (!upstream.emitStart) {
-    upstream.emitStart = line;
-  }
-  upstream.emitEnd = line;
-  line.upstream = upstream;
-}
-Line.emit_line = Line_$$$_emit_line;
-function Line_$$$_rec_line(downstream, line) {
-  if (!downstream.recStart) {
-    downstream.recStart = line;
-  }
-  downstream.recEnd = line;
-  line.downstream = downstream;
-}
-Line.rec_line = Line_$$$_rec_line;
-function Line_$$$_line_line_emit(l1, l2) {
-  if (!l1 || !l2) return;
-  l1.nextEmitLine = l2;
-  l2.prevEmitLine = l1;
-}
-Line.line_line_emit = Line_$$$_line_line_emit;
-function Line_$$$_line_line_rec(l1, l2) {
-  if (!l1 || !l2) return;
-  l1.nextRecLine = l2;
-  l2.prevRecLine = l1;
-}
-Line.line_line_rec = Line_$$$_line_line_rec;
-function Line_$$$_insert_line_emit(l1, l2, ins) {
-  l1.nextEmitLine = ins;
-  ins.prevEmitLine = l1;
-  l2.prevEmitLine = ins;
-  ins.nextEmitLine = l2;
-}
-Line.insert_line_emit = Line_$$$_insert_line_emit;
-function Line_$$$_insert_line_rec(l1, l2, ins) {
-  l1.nextRecLine = ins;
-  ins.prevRecLine = l1;
-  l2.prevRecLine = ins;
-  ins.nextRecLine = l2;
-}
-Line.insert_line_rec = Line_$$$_insert_line_rec;
-function Line() {
-  return {
-    upstream: null,
-    prevEmitLine: null,
-    nextEmitLine: null,
-    downstream: null,
-    prevRecLine: null,
-    nextRecLine: null
-  };
-}
+const ScopeExecuted = State.ScopeReady | State.ScopeAbort | State.ScopeAborted;
 
 /**
  * 这是一个优先队列 （满足子节点总是比父节点大）
@@ -432,11 +245,13 @@ 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]];
-function PriorityQueue(aIsUrgent) {
-  return {
-    aIsUrgent: aIsUrgent,
-    arr: [],
-    goUp: (arr, current, len) => {
+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];
@@ -452,8 +267,8 @@ function PriorityQueue(aIsUrgent) {
           break;
         }
       }
-    },
-    goDown: (arr, i) => {
+    };
+    this.goDown = (arr, i) => {
       const len = this.size();
       const half = len >>> 1;
       while (i < half) {
@@ -474,14 +289,71 @@ function PriorityQueue(aIsUrgent) {
         // this.logTree();
         i = point;
       }
-    },
-    _add: PriorityQueue_$$$__add,
-    add: PriorityQueue_$$$_add,
-    poll: PriorityQueue_$$$_poll,
-    peek: PriorityQueue_$$$_peek,
-    size: PriorityQueue_$$$_size,
-    logTree: PriorityQueue_$$$_logTree
-  };
+    };
+  }
+  // 添加一个元素
+  _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)
@@ -509,113 +381,55 @@ function PriorityQueue(aIsUrgent) {
 // }
 // console.log(result);
 // [5,4,3,2,1]
-function PriorityQueue_$$$__add(current) {
-  // console.log(`加入 ${current}`);
-  this.arr.push(current);
-  const len = this.size();
-  // this.logTree();
-  if (len === 1) {
-    return;
+
+class TaskQueue {
+  constructor(callbackAble, aIsUrgent) {
+    this.callbackAble = callbackAble;
+    this.aIsUrgent = aIsUrgent;
+    this.isScheduling = false;
   }
-  this.goUp(this.arr, current, len);
-}
-function PriorityQueue_$$$_add(...items) {
-  items.forEach(it => this._add(it));
-}
-function PriorityQueue_$$$_poll() {
-  const {
-    arr
-  } = this;
-  // console.log(`弹出 ${arr[0]} 把 ${arr[arr.length - 1]} 放置到队头 `);
-  const len = this.size();
-  if (len <= 2) {
-    return arr.shift();
+  static create({
+    callbackAble,
+    aIsUrgent
+  }) {
+    const queue = new TaskQueue(callbackAble, aIsUrgent);
+    queue.taskQueue = new PriorityQueue(aIsUrgent);
+    return queue;
   }
-  const last = arr.pop();
-  const first = arr[0];
-  arr[0] = last;
-  // this.logTree();
-  this.goDown(this.arr, 0);
-  return first;
-}
-function PriorityQueue_$$$_peek() {
-  return this.arr[0];
-}
-function PriorityQueue_$$$_size() {
-  return this.arr.length;
-}
-function PriorityQueue_$$$_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');
-}
-
-function TaskQueue_$$$_create({
-  callbackAble,
-  aIsUrgent
-}) {
-  const queue = TaskQueue(callbackAble, aIsUrgent);
-  queue.taskQueue = PriorityQueue(aIsUrgent);
-  return queue;
-}
-TaskQueue.create = TaskQueue_$$$_create;
-function TaskQueue(callbackAble, aIsUrgent) {
-  return {
-    callbackAble: callbackAble,
-    aIsUrgent: aIsUrgent,
-    isScheduling: false,
-    pushTask: TaskQueue_$$$_pushTask,
-    scheduleTask: TaskQueue_$$$_scheduleTask
-  };
-}
-function TaskQueue_$$$_pushTask(task) {
-  const {
-    taskQueue,
-    isScheduling
-  } = this;
-  taskQueue._add(task);
-  if (!isScheduling) {
-    this.callbackAble(this.scheduleTask.bind(this));
-    this.isScheduling = true;
+  pushTask(task) {
+    const {
+      taskQueue,
+      isScheduling
+    } = this;
+    taskQueue._add(task);
+    if (!isScheduling) {
+      this.callbackAble(this.scheduleTask.bind(this));
+      this.isScheduling = true;
+    }
   }
-}
-function TaskQueue_$$$_scheduleTask() {
-  const {
-    taskQueue
-  } = this;
-  // console.log('调度 dispose');
-  const fn = taskQueue.peek();
-  if (!fn) return this.isScheduling = false;
-  const hasRemain = fn();
-  // 未完成
-  if (hasRemain) {
+  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));
-    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(() => {
@@ -627,37 +441,308 @@ 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);
+};
+
+var Scheduler;
+(function (Scheduler) {
+  Scheduler["Sync"] = "__Sync_";
+  Scheduler["Layout"] = "__Layout_";
+  Scheduler["Micro"] = "__Micro_";
+  Scheduler["Macro"] = "__Macro_";
+})(Scheduler || (Scheduler = {}));
+const _scheduler = {
+  [Scheduler.Sync]: defaultScheduler,
+  [Scheduler.Micro]: microScheduler,
+  [Scheduler.Macro]: macroScheduler,
+  [Scheduler.Layout]: layoutScheduler
+};
+const scheduler = (key, value) => _scheduler[key] = value;
+function defaultScheduler(effects) {
+  for (const effect of effects) {
+    effect.runIfDirty();
+  }
+}
+let microSTaskQueue;
+let macroSTaskQueue;
+let layoutSTaskQueue;
+function microScheduler(effects) {
+  microSTaskQueue = microSTaskQueue || TaskQueue.create({
+    callbackAble: micro,
+    aIsUrgent: (a, b) => a.time < b.time
+  });
+  microSTaskQueue.pushTask(defaultScheduler.bind(undefined, effects));
+}
+function macroScheduler(effects) {
+  macroSTaskQueue = macroSTaskQueue || TaskQueue.create({
+    callbackAble: macro,
+    aIsUrgent: (a, b) => a.time < b.time
+  });
+  macroSTaskQueue.pushTask(defaultScheduler.bind(undefined, 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 = {
+  isUp: false,
+  begin: undefined,
+  complete: undefined,
+  breakStack: [],
+  breakLine: undefined,
+  breakNode: undefined
+};
+function dfs(root, opt = {}) {
+  const {
+    isUp,
+    begin,
+    complete,
+    breakStack: lineStack,
+    breakLine
+  } = {
+    ...DefaultDFSOpt,
+    ...opt
+  };
+  let node = opt.breakNode || root;
+  let line = breakLine;
+  const listKey = isUp ? 'recStart' : 'emitStart';
+  const nodeKey = isUp ? 'upstream' : 'downstream';
+  // 向上意味着要找所有节点的入度
+  const nextLineKey = isUp ? 'nextRecLine' : 'nextEmitLine';
+  const reverseNodeKey = isUp ? 'downstream' : 'upstream';
+  while (1) {
+    let notGoDeep = begin === null || begin === void 0 ? void 0 : begin({
+      node: node,
+      lineFromUp: line,
+      walkedLine: lineStack
+    });
+    lineStack.push(line);
+    line = node[listKey];
+    if (line && !notGoDeep) {
+      const firstChild = line[nodeKey];
+      node = firstChild;
+      continue;
+    }
+    while (1) {
+      const noGoSibling = complete === null || complete === void 0 ? void 0 : complete({
+        node: node,
+        lineToDeep: line,
+        walkedLine: lineStack,
+        notGoDeep
+      });
+      // 只对当前不下钻的节点生效
+      // notGoDeep = false;
+      line = lineStack.pop();
+      // 递归出口，回到起点
+      if (node === root) {
+        return;
+      }
+      notGoDeep = false;
+      const nextLine = line[nextLineKey];
+      // 有兄弟节点， 进入外循环，向下遍历兄弟节点
+      if (!noGoSibling && nextLine) {
+        // 外层循环后会把 sibling line 入栈，这里不需要处理
+        line = nextLine;
+        node = nextLine[nodeKey];
+        break;
+      }
+      // 没有兄弟节点就上浮
+      node = line[reverseNodeKey];
+    }
+  }
+}
+
+class Line {
+  static link(v1, v2) {
+    let {
+        emitEnd
+      } = v1,
+      {
+        recEnd,
+        recStart
+      } = v2,
+      noRecEnd = !recEnd,
+      /** 模拟头节点 */
+      head = {
+        nextRecLine: recStart
+      },
+      line;
+    recEnd = recEnd || head;
+    const {
+      nextRecLine
+    } = recEnd || {};
+    // 没有下一个收到的线
+    if (!nextRecLine) {
+      line = new Line();
+      // 内部会处理空链表的情况，即同步头部
+      Line.emit_line(v1, line);
+      Line.rec_line(v2, line);
+      emitEnd && Line.line_line_emit(emitEnd, line);
+      !noRecEnd && Line.line_line_rec(recEnd, line);
+    }
+    // 复用
+    else if (nextRecLine.upstream === v1) {
+      v2.recEnd = nextRecLine;
+      // TODO: link 版本标记
+    }
+    // 插入(这么做): v1 和 下一个 入度(订阅)节点不同
+    // TODO: v2上次真依赖了 v1 只是没检查出来，需要删除原依赖
+    else {
+      line = new Line();
+      Line.emit_line(v1, line);
+      Line.rec_line(v2, line);
+      emitEnd && Line.line_line_emit(emitEnd, line);
+      Line.insert_line_rec(recEnd, nextRecLine, line);
+    }
+    // 消除 head
+    for (const key in head) {
+      head[key] = undefined;
+    }
+  }
+  static unlink(line) {
+    let {
+      prevEmitLine,
+      nextEmitLine,
+      prevRecLine,
+      nextRecLine,
+      upstream,
+      downstream
+    } = line;
+    line.prevEmitLine = undefined;
+    line.nextEmitLine = undefined;
+    line.prevRecLine = undefined;
+    line.nextRecLine = undefined;
+    line.upstream = undefined;
+    line.downstream = undefined;
+    /** 上游节点发出的线 前一条 关联 后一条 */
+    if (prevEmitLine) {
+      prevEmitLine.nextEmitLine = nextEmitLine;
+    } else {
+      // 删除的是首个节点
+      upstream.emitStart = nextEmitLine;
+    }
+    if (nextEmitLine) {
+      nextEmitLine.prevEmitLine = prevEmitLine;
+    } else {
+      // 删除尾节点
+      upstream.emitEnd = prevEmitLine;
+    }
+    /** 下游节点接收的线，我们从 recEnd 开始删除的，
+     * 接收信息，不需要设置 recEnd ，
+     * 因为 recStart ~ recEnd 是经过上级 get 确认的有用依赖
+     * */
+    if (prevRecLine) {
+      prevRecLine.nextRecLine = nextRecLine;
+    } else {
+      // 删除的是首个节点，大概率不可能从有依赖 变成无依赖
+      downstream.recStart = nextRecLine;
+    }
+    if (nextRecLine) {
+      nextRecLine.prevRecLine = prevRecLine;
+    } else {
+      // 删除尾节点
+      downstream.recEnd = prevRecLine;
+    }
+  }
+  static unlinkRec(line) {
+    // 作为下游，执行完 get 上游节点已经完成了依赖更新，把 recEnd 后的依赖删除即可
+    let toDel = line;
+    while (toDel) {
+      const memoNext = toDel.nextRecLine;
+      Line.unlink(toDel);
+      toDel = memoNext;
+    }
+  }
+  static unlinkEmit(line) {
+    // 作为下游，执行完 get 上游节点已经完成了依赖更新，把 recEnd 后的依赖删除即可
+    let toDel = line;
+    while (toDel) {
+      const memoNext = toDel.nextEmitLine;
+      Line.unlink(toDel);
+      toDel = memoNext;
+    }
+  }
+  /** 上游节点 连 link */
+  static emit_line(upstream, line) {
+    if (!upstream.emitStart) {
+      upstream.emitStart = line;
+    }
+    upstream.emitEnd = line;
+    line.upstream = upstream;
+  }
+  /** 下游节点 连 link */
+  static rec_line(downstream, line) {
+    if (!downstream.recStart) {
+      downstream.recStart = line;
+    }
+    downstream.recEnd = line;
+    line.downstream = downstream;
+  }
+  /** 同一节点发出的 两个条线 相连 */
+  static line_line_emit(l1, l2) {
+    if (!l1 || !l2) return;
+    l1.nextEmitLine = l2;
+    l2.prevEmitLine = l1;
+  }
+  /** 同一节点接收的 两个条线 相连 */
+  static line_line_rec(l1, l2) {
+    if (!l1 || !l2) return;
+    l1.nextRecLine = l2;
+    l2.prevRecLine = l1;
+  }
+  static insert_line_emit(l1, l2, ins) {
+    l1.nextEmitLine = ins;
+    ins.prevEmitLine = l1;
+    l2.prevEmitLine = ins;
+    ins.nextEmitLine = l2;
+  }
+  static insert_line_rec(l1, l2, ins) {
+    l1.nextRecLine = ins;
+    ins.prevRecLine = l1;
+    l2.prevRecLine = ins;
+    ins.nextRecLine = l2;
+  }
+  constructor() {
+    /** 上游顶点 */
+    this.upstream = null;
+    /** 上游节点 发出的上一条线 */
+    this.prevEmitLine = null;
+    /** 上游节点 发出的下一条线 */
+    this.nextEmitLine = null;
+    /** 下游顶点 */
+    this.downstream = null;
+    /** 下游节点 接收的上一条线 */
+    this.prevRecLine = null;
+    /** 下游节点 接收的下一条线 */
+    this.nextRecLine = null;
+  }
+}
 
-// 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 管理的要恢复
@@ -667,7 +752,7 @@ const unTrackIsland = signal => {
 };
 /** scope 释放，被重新连接的孤岛 */
 const trackIsland = signal => {
-  const line = Line();
+  const line = new Line();
   // 上游节点处于孤岛状态，切有引用外部信号，需要被 scope 管理来删除外部依赖
   if (!signal.emitStart && signal.state & State.OutLink) {
     const {
@@ -678,6 +763,16 @@ const trackIsland = signal => {
     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) {
@@ -699,13 +794,16 @@ const ideScheduler = TaskQueue.create({
     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,
@@ -727,9 +825,28 @@ function handleOneTask(s, breakStack) {
           };
           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;
       },
@@ -757,6 +874,7 @@ function handleOneTask(s, breakStack) {
       node: null,
       line: null
     };
+    scope.state |= State.ScopeAborted;
   } catch (error) {
     if (error === BreakErr) return true;
     remain = {
@@ -780,20 +898,6 @@ function unlinkRecWithScope(line) {
   }
 }
 
-function Signal_$$$_create(nextValue, {
-  customPull,
-  isScope,
-  ...rest
-}) {
-  const s = Signal(nextValue, customPull);
-  s.pull = s.customPull || s.DEFAULT_PULL;
-  Object.assign(s, rest);
-  if (isScope) {
-    s.scope = s;
-  }
-  return s;
-}
-Signal.create = Signal_$$$_create;
 const markDeep = signal => {
   let level = 0;
   dfs(signal, {
@@ -830,200 +934,208 @@ const markDeep = signal => {
   }
   dirtyLeafs.clear();
 };
-function Signal(nextValue,
-/** 为什么是 shallow，因为 pullDeep 会把
- * 上游节点 get 执行完成，让其可以直接拿到缓存值
- */
-customPull) {
-  return {
-    nextValue: nextValue,
-    customPull: customPull,
-    version: -1,
-    id: G.id++,
-    state: State.Clean,
-    scope: Signal.Pulling,
-    recEnd: null,
-    recStart: null,
-    emitStart: null,
-    emitEnd: null,
-    scheduler: null,
-    value: null,
-    pull: null,
-    DEFAULT_PULL: Signal_$$$_DEFAULT_PULL,
-    pullRecurse: Signal_$$$_pullRecurse,
-    pullDeep: Signal_$$$_pullDeep,
-    get: Signal_$$$_get,
-    markDownStreamsDirty: Signal_$$$_markDownStreamsDirty,
-    set: Signal_$$$_set,
-    run: Signal_$$$_run,
-    runIfDirty: Signal_$$$_runIfDirty,
-    isAbort: Signal_$$$_isAbort
-  };
-}
-function Signal_$$$_DEFAULT_PULL() {
-  return this.nextValue;
-}
-function Signal_$$$_pullRecurse(shouldLink = true) {
-  var _a;
-  let downstream = Signal.Pulling;
-  if (shouldLink && downstream) {
-    // 如果上游节点被 scope 管理了，解除管理
-    unTrackIsland(this);
-    Line.link(this, downstream);
+class Signal {
+  constructor(nextValue,
+  /** 为什么是 shallow，因为 pullDeep 会把
+   * 上游节点 get 执行完成，让其可以直接拿到缓存值
+   */
+  customPull) {
+    this.nextValue = nextValue;
+    this.customPull = customPull;
+    this.version = -1;
+    this.id = G.id++;
+    this.state = State.Clean;
+    /** 当前节点创建时处于的 effect 就是 scope */
+    this.scope = Signal.Pulling;
+    this.recEnd = null;
+    this.recStart = null;
+    this.emitStart = null;
+    this.emitEnd = null;
+    this.scheduler = null;
+    this.value = null;
+    this.pull = null;
   }
-  try {
-    if (this.version === G.version) {
-      return this.value;
-    }
-    this.state &= ~State.OutLink;
-    // 进 pullShallow 前重置 recEnd，让子 getter 重构订阅链表
-    this.recEnd = undefined;
-    Signal.Pulling = this;
-    const v = this.pull();
-    // 如果使用了 DEFAULT_PULL，处理一次 set 的取值后，替换回 customPull，如果有的话
-    this.pull = this.customPull || this.DEFAULT_PULL;
-    this.value = v;
-    // 依赖上游的 版本号
-    this.version = G.version;
-    // if (this.value !== v) {
-    // }
-    return this.value;
-  } catch (error) {
-    console.error('计算属性报错这次不触发，后续状态可能出错', error);
-    return this.value;
-  } finally {
-    // 本 getter 执行完成时上游 getter 通过 link，完成对下游 recLines 的更新
-    const toDel = (_a = this.recEnd) === null || _a === void 0 ? void 0 : _a.nextRecLine;
-    unlinkRecWithScope(toDel);
-    if (shouldLink && downstream) {
-      // 用于 scope 指示哪些节点依赖 scope 外部
-      markOutLink(this, downstream);
+  static create(nextValue, {
+    customPull,
+    isScope,
+    ...rest
+  }) {
+    const s = new Signal(nextValue, customPull);
+    s.pull = s.customPull || s.DEFAULT_PULL;
+    Object.assign(s, rest);
+    if (isScope) {
+      s.scope = s;
     }
-    Signal.Pulling = downstream;
+    return s;
   }
-}
-function Signal_$$$_pullDeep() {
-  /*----------------- 有上游节点，通过 dfs 重新计算结果 -----------------*/
-  const signal = this;
-  // 优化执行
-  if (!(signal.state & DirtyState)) {
-    return this.value;
+  DEFAULT_PULL() {
+    return this.nextValue;
   }
-  dfs(signal, {
-    isUp: true,
-    begin: ({
-      node
-    }) => {
-      // console.log('begin', node.id);
-      /**
-       * 不需要检查
-       * 1. 正在查
-       * 2. 干净
-       * 3. 放弃 或者为 scope 节点
-       */
-      if (node.state & State.Check || !(node.state & DirtyState) || node.isAbort()) {
-        return true;
+  /**
+   * 递归拉取负责建立以来链
+   */
+  pullRecurse(shouldLink = true) {
+    var _a;
+    let downstream = Signal.Pulling;
+    if (shouldLink && downstream) {
+      // 如果上游节点被 scope 管理了，解除管理
+      unTrackIsland(this);
+      Line.link(this, downstream);
+    }
+    try {
+      if (this.version === G.version) {
+        return this.value;
       }
-      node.state |= State.Check;
-      // 交给下游重新计算是否 引用外部节点
-      node.state &= ~State.OutLink;
-    },
-    complete: ({
-      node,
-      notGoDeep: currentClean,
-      walkedLine
-    }) => {
-      let noGoSibling = false;
-      const last = walkedLine[walkedLine.length - 1];
-      const downstream = last === null || last === void 0 ? void 0 : last.downstream;
-      // 当前正在检查，生成检查屏障，同时避免重新标记 和
-      if (currentClean) ;
-      // 当前节点需要重新计算
-      else if (node.state & State.Dirty) {
-        // 优化：源节点变化，直接让下游节点重新计算
-        if (!node.recStart && node.value !== node.nextValue) {
-          node.markDownStreamsDirty();
-          node.state &= ~State.Dirty;
-          node.state &= ~State.Check;
-          return;
+      this.state &= ~State.OutLink;
+      // 进 pullShallow 前重置 recEnd，让子 getter 重构订阅链表
+      this.recEnd = undefined;
+      Signal.Pulling = this;
+      const v = this.pull();
+      // 如果使用了 DEFAULT_PULL，处理一次 set 的取值后，替换回 customPull，如果有的话
+      this.pull = this.customPull || this.DEFAULT_PULL;
+      this.value = v;
+      // 依赖上游的 版本号
+      this.version = G.version;
+      // if (this.value !== v) {
+      // }
+      return this.value;
+    } catch (error) {
+      console.error('计算属性报错这次不触发，后续状态可能出错', error);
+      return this.value;
+    } finally {
+      // 本 getter 执行完成时上游 getter 通过 link，完成对下游 recLines 的更新
+      const toDel = (_a = this.recEnd) === null || _a === void 0 ? void 0 : _a.nextRecLine;
+      unlinkRecWithScope(toDel);
+      if (shouldLink && downstream) {
+        // 用于 scope 指示哪些节点依赖 scope 外部
+        markOutLink(this, downstream);
+      }
+      Signal.Pulling = downstream;
+    }
+  }
+  pullDeep() {
+    /*----------------- 有上游节点，通过 dfs 重新计算结果 -----------------*/
+    const signal = this;
+    // 优化执行
+    if (!(signal.state & DirtyState)) {
+      return this.value;
+    }
+    dfs(signal, {
+      isUp: true,
+      begin: ({
+        node
+      }) => {
+        // console.log('begin', node.id);
+        /**
+         * 不需要检查
+         * 1. 正在查
+         * 2. 干净
+         * 3. 放弃 或者为 scope 节点
+         */
+        if (node.state & State.Check || !(node.state & DirtyState) || node.isAbort()) {
+          return true;
         }
-        // 预检数据
-        else {
-          const prevPulling = Signal.Pulling;
-          Signal.Pulling = downstream;
-          const prevValue = node.value;
-          // 递归转用递归拉取，且不需要重建 link 因为dfs的前提就是上游节点依赖于 本节点
-          node.pullRecurse(false);
-          // dirty 传播， 由于本节点值已被计算出，因此消除 dirty
-          if (prevValue !== node.value) {
+        node.state |= State.Check;
+        // 交给下游重新计算是否 引用外部节点
+        node.state &= ~State.OutLink;
+      },
+      complete: ({
+        node,
+        notGoDeep: currentClean,
+        walkedLine
+      }) => {
+        let noGoSibling = false;
+        const last = walkedLine[walkedLine.length - 1];
+        const downstream = last === null || last === void 0 ? void 0 : last.downstream;
+        // 当前正在检查，生成检查屏障，同时避免重新标记 和
+        if (currentClean) ;
+        // 当前节点需要重新计算
+        else if (node.state & State.Dirty) {
+          // 优化：源节点变化，直接让下游节点重新计算
+          if (!node.recStart && node.value !== node.nextValue) {
             node.markDownStreamsDirty();
+            node.state &= ~State.Dirty;
+            node.state &= ~State.Check;
+            return;
+          }
+          // 预检数据
+          else {
+            const prevPulling = Signal.Pulling;
+            Signal.Pulling = downstream;
+            const prevValue = node.value;
+            // 递归转用递归拉取，且不需要重建 link 因为dfs的前提就是上游节点依赖于 本节点
+            node.pullRecurse(false);
+            // dirty 传播， 由于本节点值已被计算出，因此消除 dirty
+            if (prevValue !== node.value) {
+              node.markDownStreamsDirty();
+            }
+            node.state &= ~State.Dirty;
+            Signal.Pulling = prevPulling;
+            // 立刻返回父节点重新计算
+            noGoSibling = true;
           }
-          node.state &= ~State.Dirty;
-          Signal.Pulling = prevPulling;
-          // 立刻返回父节点重新计算
-          noGoSibling = true;
         }
+        // 没被上游节点标记为 Dirty，说明是干净的
+        else if (node.state & State.Unknown) {
+          node.state &= ~State.Unknown;
+        }
+        node.version = G.version;
+        node.state &= ~State.Check;
+        if (downstream) {
+          markOutLink(node, downstream);
+        }
+        return noGoSibling;
       }
-      // 没被上游节点标记为 Dirty，说明是干净的
-      else if (node.state & State.Unknown) {
-        node.state &= ~State.Unknown;
-      }
-      node.version = G.version;
-      node.state &= ~State.Check;
-      if (downstream) {
-        markOutLink(node, downstream);
-      }
-      return noGoSibling;
-    }
-  });
-  return this.value;
-}
-function Signal_$$$_get() {
-  if (this.isAbort()) {
+    });
     return this.value;
   }
-  // 没有上游节点，应该通过递归重新建立
-  if (!this.recStart) {
-    return this.pullRecurse(true);
+  get() {
+    if (this.isAbort()) {
+      return this.value;
+    }
+    // 没有上游节点，应该通过递归重新建立
+    if (!this.recStart) {
+      return this.pullRecurse(true);
+    }
+    // 有上游节点则采用 dfs 直接遍历，查看情况
+    return this.pullDeep();
   }
-  // 有上游节点则采用 dfs 直接遍历，查看情况
-  return this.pullDeep();
-}
-function Signal_$$$_markDownStreamsDirty() {
-  let point = this.emitStart;
-  while (point != null) {
-    const downstream = point.downstream;
-    downstream.state |= State.Dirty;
-    downstream.state &= ~State.Unknown;
-    point = point.nextEmitLine;
+  markDownStreamsDirty() {
+    let point = this.emitStart;
+    while (point != null) {
+      const downstream = point.downstream;
+      downstream.state |= State.Dirty;
+      downstream.state &= ~State.Unknown;
+      point = point.nextEmitLine;
+    }
   }
-}
-function Signal_$$$_set(v) {
-  if (this.isAbort() || this.nextValue === v) {
-    return;
+  set(v) {
+    if (this.isAbort() || this.nextValue === v) {
+      return;
+    }
+    this.nextValue = v;
+    // 手动设值后，采用默认拉取，能拉取到设置的值，拉取完成后在替换回 customPull
+    this.pull = this.DEFAULT_PULL;
+    G.version++;
+    markDeep(this);
   }
-  this.nextValue = v;
-  // 手动设值后，采用默认拉取，能拉取到设置的值，拉取完成后在替换回 customPull
-  this.pull = this.DEFAULT_PULL;
-  G.version++;
-  markDeep(this);
-}
-function Signal_$$$_run(...args) {
-  if (args.length) {
-    return this.set(args[0]);
+  run(...args) {
+    if (args.length) {
+      return this.set(args[0]);
+    }
+    return this.get();
+  }
+  runIfDirty() {
+    this.state & (State.Unknown | State.Dirty) && this.run();
+  }
+  isAbort() {
+    return (
+      // scope 被取消
+      this.scope && this.scope.state & State.ScopeAbort ||
+      // 是 scope 节点，且处于 ready 状态，不需要重复执行
+      this === this.scope && this.state & ScopeExecuted
+    );
   }
-  return this.get();
-}
-function Signal_$$$_runIfDirty() {
-  this.state & (State.Unknown | State.Dirty) && this.run();
-}
-function Signal_$$$_isAbort() {
-  return (
-    // scope 被取消
-    this.scope && this.scope.state & State.ScopeAbort ||
-    // 是 scope 节点，且处于 ready 状态，不需要重复执行
-    this === this.scope && this.state & (State.ScopeAbort | State.ScopeReady)
-  );
 }
 Signal.Pulling = null;
 function runWithPulling(fn, signal) {
@@ -1108,5 +1220,50 @@ const customSignal = opt => {
     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;
+//   }
+// });
 
-export { $, Scheduler, customSignal, scheduler, scope, watch };
+export { $, Scheduler, TaskQueue, customSignal, scheduler, scope, watch };