aoye 0.0.2 → 0.0.4

package/dist/aoye.umd.js

@@ -1,1211 +0,0 @@
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-  typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Aoye = {}));
-})(this, (function (exports) { 'use strict';
-
-  class SortMap {
-      constructor() {
-          this.data = {};
-      }
-      clear() {
-          this.data = {};
-      }
-      add(key, value) {
-          const { data } = this;
-          let list = data[key];
-          if (!list) {
-              list = [];
-              data[key] = list;
-          }
-          list.push(value);
-      }
-  }
-  // const queue = new Queue([1,2,3,4]);
-  // queue.shift()
-  // queue.pop()
-  // // @ts-ignore
-  // queue.unshift('a')
-  // // @ts-ignore
-  // queue.push('b')
-  // queue.shift()
-  // queue.pop()
-  // queue.shift()
-  // queue.pop()
-  // queue.shift()
-  // queue.pop()
-  // 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,
-      id: 0,
-      /** scope 销毁任务序号 */
-      scopeDisposeI: 0
-  };
-  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";
-      State[State["Dirty"] = 4] = "Dirty";
-      State[State["Check"] = 2] = "Check";
-      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) {
-      Scheduler["Sync"] = "__Sync_";
-      Scheduler["Layout"] = "__Layout_";
-      Scheduler["Micro"] = "__Micro_";
-      Scheduler["Macro"] = "__Macro_";
-  })(exports.Scheduler || (exports.Scheduler = {}));
-  const _scheduler = {
-      [exports.Scheduler.Sync]: defaultScheduler,
-      [exports.Scheduler.Micro]: microScheduler,
-      [exports.Scheduler.Macro]: macroScheduler,
-      [exports.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;
-      }
-  }
-
-  /** scope 捕获，引用外部 signal 孤岛 */
-  const unTrackIsland = (signal) => {
-      // 原来是孤岛，且被 scope 管理的要恢复
-      if (signal.emitStart && signal.emitStart.downstream === signal.scope) {
-          Line.unlink(signal.emitStart);
-      }
-  };
-  /** scope 释放，被重新连接的孤岛 */
-  const trackIsland = (signal) => {
-      const line = new Line();
-      // 上游节点处于孤岛状态，切有引用外部信号，需要被 scope 管理来删除外部依赖
-      if (!signal.emitStart && signal.state & State.OutLink) {
-          const { recEnd } = signal.scope;
-          Line.emit_line(signal, line);
-          Line.rec_line(signal.scope, line);
-          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) {
-          downstream.state |= State.OutLink;
-      }
-      // else {
-      //   downstream.state &= ~State.OutLink;
-      // }
-  };
-  const BreakErr = '_ERR_BREAK_';
-  let remain = {
-      stack: null,
-      node: null,
-      line: null
-  };
-  const ideScheduler = TaskQueue.create({
-      callbackAble: ide,
-      aIsUrgent(a, b) {
-          return a.index < b.index;
-      }
-  });
-  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(scope, {
-              breakStack,
-              breakNode: remain.node,
-              breakLine: remain.line,
-              isUp: true,
-              begin: ({ walkedLine, node, lineFromUp }) => {
-                  if (lineToRemove) {
-                      Line.unlink(lineToRemove);
-                      lineToRemove = null;
-                  }
-                  if (now() - startTime > 5) {
-                      remain = {
-                          stack: walkedLine,
-                          node: node,
-                          line: lineFromUp
-                      };
-                      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;
-              },
-              complete: ({ node, notGoDeep, walkedLine }) => {
-                  if (lineToRemove) {
-                      Line.unlink(lineToRemove);
-                      lineToRemove = null;
-                  }
-                  if (notGoDeep) {
-                      const last = walkedLine[walkedLine.length - 1];
-                      const downstream = last === null || last === void 0 ? void 0 : last.downstream;
-                      // 节点没被标记 OutLink 但是发现与下游节点的 scope 不一致，是需要解除 link 的位置
-                      if (downstream && downstream.scope !== node.scope) {
-                          lineToRemove = last;
-                      }
-                  }
-              }
-          });
-          remain = {
-              stack: null,
-              node: null,
-              line: null
-          };
-          scope.state |= State.ScopeAborted;
-      }
-      catch (error) {
-          if (error === BreakErr)
-              return true;
-          remain = {
-              stack: null,
-              node: null,
-              line: null
-          };
-          throw error;
-      }
-  }
-  function unlinkRecWithScope(line) {
-      // 作为下游，执行完 get 上游节点已经完成了依赖更新，把 recEnd 后的依赖删除即可
-      let toDel = line;
-      while (toDel) {
-          const memoNext = toDel.nextRecLine;
-          const upstream = toDel.upstream;
-          Line.unlink(toDel);
-          // 删除完后看看是否要被 scope 管理
-          trackIsland(upstream);
-          toDel = memoNext;
-      }
-  }
-
-  const markDeep = (signal) => {
-      let level = 0;
-      dfs(signal, {
-          isUp: false,
-          begin: ({ node }) => {
-              /**
-               * 1. 当前节点在预检  应该跳过
-               * 2. 当前节点       已标记
-               * 3. 当前节点       已放弃
-               */
-              // console.log('markBegin', node.id);
-              if (node.state & (State.Check | State.Unknown | State.Dirty) || node.isAbort()) {
-                  return true;
-              }
-              const isEffect = level > 0;
-              const isLeaf = !node.emitStart || node.emitStart.downstream['scope'] === node.emitStart.downstream;
-              if (isEffect) {
-                  node.state |= State.Unknown;
-              }
-              else {
-                  node.state |= State.Dirty;
-              }
-              if (isLeaf && isEffect) {
-                  dirtyLeafs.add(node.scheduler, node);
-              }
-              level++;
-          }
-      });
-      for (const key in dirtyLeafs.data) {
-          const effects = dirtyLeafs.data[key];
-          const scheduler = _scheduler[key];
-          scheduler(effects);
-      }
-      dirtyLeafs.clear();
-  };
-  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;
-      }
-      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;
-          }
-          return s;
-      }
-      DEFAULT_PULL() {
-          return this.nextValue;
-      }
-      /**
-       * 递归拉取负责建立以来链
-       */
-      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;
-              }
-              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;
-                  }
-                  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;
-                      }
-                  }
-                  // 没被上游节点标记为 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;
-      }
-      get() {
-          if (this.isAbort()) {
-              return this.value;
-          }
-          // 没有上游节点，应该通过递归重新建立
-          if (!this.recStart) {
-              return this.pullRecurse(true);
-          }
-          // 有上游节点则采用 dfs 直接遍历，查看情况
-          return this.pullDeep();
-      }
-      markDownStreamsDirty() {
-          let point = this.emitStart;
-          while (point != null) {
-              const downstream = point.downstream;
-              downstream.state |= State.Dirty;
-              downstream.state &= ~State.Unknown;
-              point = point.nextEmitLine;
-          }
-      }
-      set(v) {
-          if (this.isAbort() || this.nextValue === v) {
-              return;
-          }
-          this.nextValue = v;
-          // 手动设值后，采用默认拉取，能拉取到设置的值，拉取完成后在替换回 customPull
-          this.pull = this.DEFAULT_PULL;
-          G.version++;
-          markDeep(this);
-      }
-      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));
-      }
-  }
-  Signal.Pulling = null;
-  function runWithPulling(fn, signal) {
-      const prevPulling = Signal.Pulling;
-      Signal.Pulling = signal;
-      fn();
-      Signal.Pulling = prevPulling;
-  }
-
-  const DefaultCustomSignalOpt = {
-      scheduler: exports.Scheduler.Sync,
-      isScope: false
-  };
-  const $ = (init, opt = {}) => {
-      let intiValue, pull;
-      if (init instanceof Function) {
-          intiValue = undefined;
-          pull = init;
-      }
-      else {
-          intiValue = init;
-      }
-      const signalOpt = { ...DefaultCustomSignalOpt, ...opt, customPull: pull };
-      const s = Signal.create(intiValue, signalOpt);
-      const bound = s.run.bind(s);
-      bound.ins = s;
-      Object.defineProperty(bound, 'v', {
-          get() {
-              return s.get();
-          },
-          set(v) {
-              return s.set(v);
-          }
-      });
-      return bound;
-  };
-  const watch = (values, watcher, opt) => {
-      let mounted = false;
-      const get = $(() => {
-          for (const get of values) {
-              get();
-          }
-          if (mounted) {
-              runWithPulling(watcher, undefined);
-          }
-          mounted = true;
-      }, opt);
-      get();
-      return get;
-  };
-  const scope = (fn) => {
-      const s = Signal.create(undefined, { customPull: fn, isScope: true });
-      s.get();
-      s.state |= State.ScopeReady;
-      function dispose() {
-          s.state |= State.ScopeAbort;
-          const bound = handleOneTask.bind(undefined, s, []);
-          bound.index = G.scopeDisposeI++;
-          ideScheduler.pushTask(bound);
-      }
-      dispose.ins = s;
-      return dispose;
-  };
-  /**
-   * 数据变化时，自定义 触发订阅函数的时机
-   * @param {CustomSignalOpt} opt 配置如下:
-   * @prop scheduler: (runIfDirty, effect) => void 执行 runIfDirty 定制触发 effect 时机
-   * @prop scope: 用于统一释放 effect link 的作用域 默认是 defaultScope 可以全局获取
-   */
-  const customSignal = (opt) => {
-      return ((init, innerOpt = {}) => {
-          const s = $(init, { ...opt, ...innerOpt });
-          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;
-  exports.watch = watch;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
-
-}));