@planet-matrix/mobius-model 0.1.4 → 0.3.0

package/src/{signal/signal-core → reactor/reactor-core}/reactive-system.ts

@@ -38,11 +38,11 @@ export interface Link {
    */
   dep: Node;
   /**
-   * 连接中的上游节点的下游连接链中的上一个连接。（下一个下游连接）
+   * 连接中的上游节点的下游连接链中的上一个连接。（上一个下游连接）
    */
   prevSubLink?: Link | undefined;
   /**
-   * 连接中的上游节点的下游连接链中的下一个连接。（上一个下游连接）
+   * 连接中的上游节点的下游连接链中的下一个连接。（下一个下游连接）
    */
   nextSubLink?: Link | undefined;
 
@@ -61,6 +61,31 @@ export interface Link {
 }
 
 export interface CreateReactiveSystemOptions {
+  /**
+   * 当节点的上游节点发生变化时此回调会执行。
+   */
+  onDepChanged?: (sub: Node) => void;
+  /**
+   * 当节点的下游节点发生变化时此回调会执行。
+   */
+  onSubChanged?: (dep: Node) => void;
+  /**
+   * 当节点拥有第一个上游节点时此回调会执行。
+   */
+  onHasDep?: (sub: Node, dep: Node) => void;
+  /**
+   * 当节点不再拥有任何上游节点时此回调会执行。
+   */
+  onNoDep?: (sub: Node, dep: Node) => void;
+  /**
+   * 当节点拥有第一个下游节点时此回调会执行。
+   */
+  onHasSub?: (dep: Node, sub: Node) => void;
+  /**
+   * 当节点不再拥有任何下游节点时此回调会执行。
+   */
+  onNoSub?: (dep: Node, sub: Node) => void;
+
   /**
    * 当节点的值需要更新时此回调会执行，返回值表示更新前后值是否变化。
    */
@@ -71,12 +96,24 @@ export interface CreateReactiveSystemOptions {
    * 注意：只有包含 Watching 标记的节点会触发此方法。
    */
   notify(node: Node): void;
-  /**
-   * 当节点不再拥有任何下游节点时此回调会执行。
-   */
-  unwatched(node: Node): void;
 }
 export interface ReactiveSystem {
+  /**
+   * 获取节点的上游连接。
+   */
+  getDepLinksOfNode(node: Node): Link[];
+  /**
+   * 获取节点的下游连接。
+   */
+  getSubLinksOfNode(node: Node): Link[];
+  /**
+   * 获取节点的上游节点。
+   */
+  getDepsOfNode(node: Node): Node[];
+  /**
+   * 获取节点的下游节点。
+   */
+  getSubsOfNode(node: Node): Node[];
   /**
    * 判断连接是否是节点的上游连接。
    */
@@ -86,34 +123,53 @@ export interface ReactiveSystem {
    */
   isSubLinkOfNode(link: Link, node: Node): boolean;
   /**
-   * 获取两个节点之间的连接。
+   * 判断节点是否是目标节点的上游节点。
+   */
+  isDepOfNode(node: Node, targetNode: Node): boolean;
+  /**
+   * 判断节点是否是目标节点的下游节点。
+   */
+  isSubOfNode(node: Node, targetNode: Node): boolean;
+  /**
+   * 获取两个节点之间的连接（从上游节点的下游连接链中查找）。
    */
-  getLinkOfNodes(dep: Node, sub: Node): Link | undefined;
+  getLinkBetweenFromDep(dep: Node, sub: Node): Link | undefined;
   /**
-   * 判断两个节点之间是否存在连接。
+   * 获取两个节点之间的连接（从下游节点的上游连接链中查找）。
    */
-  isLinked(nodeA: Node, nodeB: Node): boolean;
+  getLinkBetweenFromSub(dep: Node, sub: Node): Link | undefined;
+  /**
+   * 判断两个节点之间是否存在连接（从上游节点的下游连接链中查找）。
+   */
+  hasLinkBetweenFromDep(dep: Node, sub: Node): boolean;
+  /**
+   * 判断两个节点之间是否存在连接（从下游节点的上游连接链中查找）。
+   */
+  hasLinkBetweenFromSub(dep: Node, sub: Node): boolean;
   /**
    * 为两个节点建立连接。
    */
-  linkNode(dep: Node, sub: Node): void;
+  addLinkBetween(dep: Node, sub: Node): Link;
   /**
-   * 为两个节点解除连接。
+   * 为两个节点移除连接（从上游节点的下游连接链中查找）。
    */
-  unlinkNode(nodeA: Node, nodeB: Node): void;
+  removeLinkBetweenFromDep(dep: Node, sub: Node): void;
   /**
-   * 解除连接。
+   * 为两个节点移除连接（从下游节点的上游连接链中查找）。
    */
-  unlink(link: Link): void;
+  removeLinkBetweenFromSub(dep: Node, sub: Node): void;
   /**
-   * 为节点解除所有上游连接。
+   * 移除连接。
    */
-  unlinkAllDepLinksOfNode(node: Node): void;
+  removeLink(link: Link): void;
   /**
-   * 为节点解除所有下游连接。
+   * 为节点移除所有上游连接。
    */
-  unlinkAllSubLinksOfNode(node: Node): void;
-
+  removeAllDepLinksOfNode(node: Node): Node[];
+  /**
+   * 为节点移除所有下游连接。
+   */
+  removeAllSubLinksOfNode(node: Node): Node[];
 
   /**
    * 获取当前正在进行依赖收集的节点。
@@ -122,7 +178,11 @@ export interface ReactiveSystem {
   /**
    * 设置当前正在进行依赖收集的节点。
    */
-  setActiveNodeAsSub(nodeAsSub: Node): void;
+  setActiveNodeAsSub(nodeAsSub: Node | undefined): void;
+  /**
+   * 设置当前正在进行依赖收集的节点为空。
+   */
+  setNoActiveNodeAsSub(): undefined;
   /**
    * 重置当前正在进行依赖收集的节点。
    */
@@ -130,7 +190,15 @@ export interface ReactiveSystem {
   /**
    * 将指定节点作为当前正在进行依赖收集的节点执行指定函数。
    */
-  withActiveNodeAsSub<T>(nodeAsSub: Node, fn: () => T): T;
+  withActiveNodeAsSub<T>(nodeAsSub: Node | undefined, fn: () => T): T;
+  /**
+   * 以无当前正在进行依赖收集的节点的状态执行指定函数。
+   */
+  withoutActiveNodeAsSub<T>(fn: () => T): T;
+  /**
+   * 断言当前没有正在进行依赖收集的节点。
+   */
+  assertWithoutActiveNodeAsSub(): void;
   /**
    * 开始对节点（作为下游节点）进行依赖收集。
    */
@@ -143,14 +211,26 @@ export interface ReactiveSystem {
    * 对节点（作为下游节点）进行依赖收集。
    */
   withTracking<T>(node: Node, fn: () => T): T;
+  /**
+   * 以无当前正在进行依赖收集的节点的状态执行指定函数。
+   */
+  withoutTracking<T>(fn: () => T): T;
+  /**
+   * 断言当前没有正在进行依赖收集的节点。
+   */
+  assertWithoutTracking(): void;
   /**
    * 为两个节点建立连接（依赖收集优化版）。
    */
-  linkNodeOptimizedForTracking(dep: Node, sub: Node): void;
+  addLinkBetweenOptimizedForTracking(dep: Node, sub: Node): Link;
   /**
    * 将节点作为当前正在进行依赖收集的节点的上游节点。
    */
   track(node: Node): void;
+  /**
+   * 将节点作为当前正在进行依赖收集的节点的上游节点。
+   */
+  trackNearestMutableOrWatching(node: Node): void;
 
   /**
    * 当节点的值发生变化后，调用此方法更新直接下游节点的标记。
@@ -166,60 +246,192 @@ export interface ReactiveSystem {
   resolvePending(node: Node): void;
 }
 export const createReactiveSystem = (options: CreateReactiveSystemOptions): ReactiveSystem => {
-  const { update, notify, unwatched } = options;
+  const {
+    onDepChanged,
+    onSubChanged,
+    onHasDep,
+    onNoDep,
+    onHasSub,
+    onNoSub,
+    update,
+    notify
+  } = options;
+
+  /**
+   * 获取目标节点的所有上游连接。
+   *
+   * 依赖收集过程中会尝试复用现存连接，该机制会导致在未完全完成依赖收集前，连接链中可能出现
+   * 未经验证的连接。此方法只会返回经过验证的连接。
+   */
+  const getDepLinksOfNode = (node: Node): Link[] => {
+    const depLinks: Link[] = [];
+    let currentDepLink = node.headDepLink;
+    const tailDepLink = node.tailDepLink;
+    while (currentDepLink !== undefined) {
+      depLinks.push(currentDepLink);
+      const isValidLastDepLink = currentDepLink === tailDepLink;
+      if (isValidLastDepLink === true) {
+        break;
+      } else {
+        currentDepLink = currentDepLink.nextDepLink;
+      }
+    }
+    return depLinks;
+  }
+
+  /**
+   * 获取目标节点的所有下游连接。
+   *
+   * 依赖收集过程中会尝试复用现存连接，该机制会导致在未完全完成依赖收集前，连接链中可能出现
+   * 未经验证的连接。此方法只会返回经过验证的连接。
+   */
+  const getSubLinksOfNode = (node: Node): Link[] => {
+    const subLinks: Link[] = [];
+    let currentSubLink = node.headSubLink;
+    const tailSubLink = node.tailSubLink;
+    while (currentSubLink !== undefined) {
+      subLinks.push(currentSubLink);
+      const isValidLastSubLink = currentSubLink === tailSubLink;
+      if (isValidLastSubLink === true) {
+        break;
+      } else {
+        currentSubLink = currentSubLink.nextSubLink;
+      }
+    }
+    return subLinks;
+  }
+
+  const getDepsOfNode = (node: Node): Node[] => {
+    const depLinks = getDepLinksOfNode(node);
+    const deps = depLinks.map(link => link.dep);
+    return deps;
+  }
+
+  const getSubsOfNode = (node: Node): Node[] => {
+    const subLinks = getSubLinksOfNode(node);
+    const subs = subLinks.map(link => link.sub);
+    return subs;
+  }
 
   const isDepLinkOfNode = (link: Link, node: Node): boolean => {
-    let tailDepLinkOfNode = node.tailDepLink;
-    while (tailDepLinkOfNode !== undefined) {
-      if (tailDepLinkOfNode === link) {
+    let currentDepLink = node.headDepLink;
+    const tailDepLink = node.tailDepLink;
+    while (currentDepLink !== undefined) {
+      if (currentDepLink === link) {
         return true;
       }
-      tailDepLinkOfNode = tailDepLinkOfNode.prevDepLink;
+      const isValidLastDepLink = currentDepLink === tailDepLink;
+      if (isValidLastDepLink === true) {
+        break;
+      } else {
+        currentDepLink = currentDepLink.nextDepLink;
+      }
     }
     return false;
   }
 
   const isSubLinkOfNode = (link: Link, node: Node): boolean => {
-    let tailSubLinkOfNode = node.tailSubLink;
-    while (tailSubLinkOfNode !== undefined) {
-      if (tailSubLinkOfNode === link) {
+    let currentSubLink = node.headSubLink;
+    const tailSubLink = node.tailSubLink;
+    while (currentSubLink !== undefined) {
+      if (currentSubLink === link) {
         return true;
       }
-      tailSubLinkOfNode = tailSubLinkOfNode.prevSubLink;
+      const isValidLastSubLink = currentSubLink === tailSubLink;
+      if (isValidLastSubLink === true) {
+        break;
+      } else {
+        currentSubLink = currentSubLink.nextSubLink;
+      }
     }
     return false;
   }
 
-  const getLinkOfNodes = (dep: Node, sub: Node): Link | undefined => {
-    let subToCheck = dep.tailSubLink;
-    while (subToCheck !== undefined) {
-      if (subToCheck.sub === sub) {
-        return subToCheck;
+  const isDepOfNode = (node: Node, targetNode: Node): boolean => {
+    let currentDepLink = targetNode.headDepLink;
+    const tailDepLink = targetNode.tailDepLink;
+    while (currentDepLink !== undefined) {
+      if (currentDepLink.dep === node) {
+        return true;
+      }
+      const isValidLastDepLink = currentDepLink === tailDepLink;
+      if (isValidLastDepLink === true) {
+        break;
+      } else {
+        currentDepLink = currentDepLink.nextDepLink;
       }
-      subToCheck = subToCheck.prevSubLink;
     }
-    return undefined;
+    return false;
   }
 
-  const isLinked = (nodeA: Node, nodeB: Node): boolean => {
-    const aIsDepOfB = getLinkOfNodes(nodeA, nodeB) !== undefined;
-    if (aIsDepOfB === true) {
-      return true;
-    }
-    const bIsDepOfA = getLinkOfNodes(nodeB, nodeA) !== undefined;
-    if (bIsDepOfA === true) {
-      return true;
+  const isSubOfNode = (node: Node, targetNode: Node): boolean => {
+    let currentSubLink = targetNode.headSubLink;
+    const tailSubLink = targetNode.tailSubLink;
+    while (currentSubLink !== undefined) {
+      if (currentSubLink.sub === node) {
+        return true;
+      }
+      const isValidLastSubLink = currentSubLink === tailSubLink;
+      if (isValidLastSubLink === true) {
+        break;
+      } else {
+        currentSubLink = currentSubLink.nextSubLink;
+      }
     }
     return false;
   }
 
-  const linkNode = (dep: Node, sub: Node): void => {
+  const getLinkBetweenFromDep = (dep: Node, sub: Node): Link | undefined => {
+    let currentSubLink = dep.headSubLink;
+    const tailSubLink = dep.tailSubLink;
+    while (currentSubLink !== undefined) {
+      if (currentSubLink.sub === sub) {
+        return currentSubLink;
+      }
+      const isValidLastSubLink = currentSubLink === tailSubLink;
+      if (isValidLastSubLink === true) {
+        break;
+      } else {
+        currentSubLink = currentSubLink.nextSubLink;
+      }
+    }
+    return undefined;
+  }
+
+  const getLinkBetweenFromSub = (dep: Node, sub: Node): Link | undefined => {
+    let currentDepLink = sub.headDepLink;
+    const tailDepLink = sub.tailDepLink;
+    while (currentDepLink !== undefined) {
+      if (currentDepLink.dep === dep) {
+        return currentDepLink;
+      }
+      const isValidLastDepLink = currentDepLink === tailDepLink;
+      if (isValidLastDepLink === true) {
+        break;
+      } else {
+        currentDepLink = currentDepLink.nextDepLink;
+      }
+    }
+    return undefined;
+  }
+
+  const hasLinkBetweenFromDep = (dep: Node, sub: Node): boolean => {
+    const link = getLinkBetweenFromDep(dep, sub);
+    return link !== undefined;
+  }
+
+  const hasLinkBetweenFromSub = (dep: Node, sub: Node): boolean => {
+    const link = getLinkBetweenFromSub(dep, sub);
+    return link !== undefined;
+  }
+
+  const addLinkBetween = (dep: Node, sub: Node): Link => {
     /**
      * 检查是否存在重复连接。
      */
-    const isLinked = getLinkOfNodes(dep, sub) !== undefined;
-    if (isLinked === true) {
-      return;
+    const existLink = getLinkBetweenFromSub(dep, sub);
+    if (existLink !== undefined) {
+      return existLink;
     }
 
     /**
@@ -252,20 +464,39 @@ export const createReactiveSystem = (options: CreateReactiveSystemOptions): Reac
       dep.headSubLink = newLink;
     }
     dep.tailSubLink = newLink;
+
+    /**
+     * 连接全部更新完成之后，触发回调，优先通知上游节点。
+     */
+    onSubChanged?.(dep);
+    const isFirstSub = tailSubLinkOfDep === undefined;
+    if (isFirstSub === true) {
+      onHasSub?.(dep, sub);
+    }
+    onDepChanged?.(sub);
+    const isFirstDep = tailDepLinkOfSub === undefined;
+    if (isFirstDep === true) {
+      onHasDep?.(sub, dep);
+    }
+
+    return newLink;
   }
 
-  const unlinkNode = (nodeA: Node, nodeB: Node): void => {
-    const linkAB = getLinkOfNodes(nodeA, nodeB);
-    if (linkAB !== undefined) {
-      unlink(linkAB);
+  const removeLinkBetweenFromDep = (dep: Node, sub: Node): void => {
+    const linkFromDep = getLinkBetweenFromDep(dep, sub);
+    if (linkFromDep !== undefined) {
+      removeLink(linkFromDep);
     }
-    const linkBA = getLinkOfNodes(nodeB, nodeA);
-    if (linkBA !== undefined) {
-      unlink(linkBA);
+  }
+
+  const removeLinkBetweenFromSub = (dep: Node, sub: Node): void => {
+    const linkFromSub = getLinkBetweenFromSub(dep, sub);
+    if (linkFromSub !== undefined) {
+      removeLink(linkFromSub);
     }
   }
 
-  const unlink = (link: Link): void => {
+  const removeLink = (link: Link): void => {
     const prevDepLink = link.prevDepLink;
     const dep = link.dep;
     const nextDepLink = link.nextDepLink;
@@ -312,13 +543,15 @@ export const createReactiveSystem = (options: CreateReactiveSystemOptions): Reac
     }
 
     /**
-     * 处理完连接链之后，检查当前连接中的上游节点是否还有下游节点。
-     *
-     * - 如果有：什么都不做。
-     * - 如果没有：触发回调。
+     * 连接全部更新完成之后，触发回调，优先通知上游节点。
      */
+    onSubChanged?.(dep);
     if (dep.headSubLink === undefined && dep.tailSubLink === undefined) {
-      unwatched(dep);
+      onNoSub?.(dep, sub);
+    }
+    onDepChanged?.(sub);
+    if (sub.headDepLink === undefined && sub.tailDepLink === undefined) {
+      onNoDep?.(sub, dep);
     }
 
     /**
@@ -334,22 +567,28 @@ export const createReactiveSystem = (options: CreateReactiveSystemOptions): Reac
     link.nextSubLink = undefined;
   }
 
-  const unlinkAllDepLinksOfNode = (node: Node): void => {
+  const removeAllDepLinksOfNode = (node: Node): Node[] => {
+    const depNodes = [];
     let currentDepLink = node.headDepLink;
     while (currentDepLink !== undefined) {
+      depNodes.push(currentDepLink.dep);
       const nextDepLink = currentDepLink.nextDepLink;
-      unlink(currentDepLink);
+      removeLink(currentDepLink);
       currentDepLink = nextDepLink;
     }
+    return depNodes;
   }
 
-  const unlinkAllSubLinksOfNode = (node: Node): void => {
+  const removeAllSubLinksOfNode = (node: Node): Node[] => {
+    const subNodes = [];
     let currentSubLink = node.headSubLink;
     while (currentSubLink !== undefined) {
+      subNodes.push(currentSubLink.sub);
       const nextSubLink = currentSubLink.nextSubLink;
-      unlink(currentSubLink);
+      removeLink(currentSubLink);
       currentSubLink = nextSubLink;
     }
+    return subNodes;
   }
 
   let prevActiveNodeAsSubStack: Array<Node | undefined> = [];
@@ -357,14 +596,20 @@ export const createReactiveSystem = (options: CreateReactiveSystemOptions): Reac
   const getActiveNodeAsSub = (): Node | undefined => {
     return activeNodeAsSub;
   }
-  const setActiveNodeAsSub = (nodeAsSub: Node): void => {
+  const setActiveNodeAsSub = (nodeAsSub: Node | undefined): Node | undefined => {
     prevActiveNodeAsSubStack.push(activeNodeAsSub);
     activeNodeAsSub = nodeAsSub;
+    return activeNodeAsSub;
   }
-  const resetActiveNodeAsSub = (): void => {
+  const setNoActiveNodeAsSub = (): undefined => {
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    return setActiveNodeAsSub(undefined) as undefined;
+  }
+  const resetActiveNodeAsSub = (): Node | undefined => {
     activeNodeAsSub = prevActiveNodeAsSubStack.pop();
+    return activeNodeAsSub;
   }
-  const withActiveNodeAsSub = <T>(nodeAsSub: Node, fn: () => T): T => {
+  const withActiveNodeAsSub = <T>(nodeAsSub: Node | undefined, fn: () => T): T => {
     setActiveNodeAsSub(nodeAsSub);
     try {
       return fn();
@@ -372,6 +617,15 @@ export const createReactiveSystem = (options: CreateReactiveSystemOptions): Reac
       resetActiveNodeAsSub();
     }
   }
+  const withoutActiveNodeAsSub = <T>(fn: () => T): T => {
+    return withActiveNodeAsSub(undefined, fn);
+  }
+  const assertWithoutActiveNodeAsSub = (): void => {
+    const currentActiveNodeAsSub = getActiveNodeAsSub();
+    if (currentActiveNodeAsSub !== undefined) {
+      throw new Error(`Expected no active node as sub, but got one.`);
+    }
+  }
 
   const startTracking = (nodeAsSub: Node): void => {
     setActiveNodeAsSub(nodeAsSub);
@@ -387,7 +641,7 @@ export const createReactiveSystem = (options: CreateReactiveSystemOptions): Reac
         let toRemove: Link | undefined = firstRedundantDepLink;
         while (toRemove !== undefined) {
           const nextToRemove: Link | undefined = toRemove.nextDepLink;
-          unlink(toRemove);
+          removeLink(toRemove);
           toRemove = nextToRemove;
         }
       }
@@ -404,18 +658,30 @@ export const createReactiveSystem = (options: CreateReactiveSystemOptions): Reac
       endTracking(node);
     }
   }
+  const withoutTracking = <T>(fn: () => T): T => {
+    return withoutActiveNodeAsSub(() => {
+      return fn();
+    });
+  }
+  const assertWithoutTracking = (): void => {
+    try {
+      assertWithoutActiveNodeAsSub();
+    } catch {
+      throw new Error(`Expected no active node as sub for tracking, but got one.`);
+    }
+  }
   /**
    * 依赖收集的目标是：在完成一次依赖收集之后，对于所有在依赖收集执行过程中被访问过的节点（上游节点），
    * 都与进行依赖收集的节点（下游节点）建立且仅建立一个连接。
    */
-  const linkNodeOptimizedForTracking = (dep: Node, sub: Node): void => {
+  const addLinkBetweenOptimizedForTracking = (dep: Node, sub: Node): Link => {
     let existingDepLinkToCompare: Link | undefined;
 
     const subFlags = sub.flags;
     if (subFlags.hasTracking() === true && subFlags.hasTrackingReusing() === false) {
       subFlags.setTrackingReusing();
       sub.tailDepLink = sub.headDepLink;
-      existingDepLinkToCompare = sub.tailDepLink
+      existingDepLinkToCompare = sub.tailDepLink;
     } else {
       existingDepLinkToCompare = sub.tailDepLink?.nextDepLink;
     }
@@ -423,16 +689,34 @@ export const createReactiveSystem = (options: CreateReactiveSystemOptions): Reac
     /**
      * 检查是否可以复用现存连接。
      */
+
     if (existingDepLinkToCompare !== undefined && existingDepLinkToCompare.dep === dep) {
-      return;
+      // 如果可以，则复用该连接
+      sub.tailDepLink = existingDepLinkToCompare;
+      // 触发回调
+      onDepChanged?.(sub);
+      return existingDepLinkToCompare;
+    } else {
+      // 否则，建立新连接
+      const newLink = addLinkBetween(dep, sub);
+      return newLink;
     }
-
-    linkNode(dep, sub);
   }
   const track = (node: Node): void => {
-    const activeNodeAsSub = getActiveNodeAsSub();
-    if (activeNodeAsSub !== undefined) {
-      linkNodeOptimizedForTracking(node, activeNodeAsSub);
+    let targetSub = getActiveNodeAsSub();
+    if (targetSub !== undefined) {
+      addLinkBetweenOptimizedForTracking(node, targetSub);
+    }
+  }
+  const trackNearestMutableOrWatching = (node: Node): void => {
+    let targetSub = getActiveNodeAsSub();
+    while (targetSub !== undefined) {
+      const flags = targetSub.flags;
+      if (flags.hasMutable() === true || flags.hasWatching() === true) {
+        addLinkBetweenOptimizedForTracking(node, targetSub);
+        break;
+      }
+      targetSub = targetSub.headSubLink?.sub;
     }
   }
 
@@ -496,8 +780,8 @@ export const createReactiveSystem = (options: CreateReactiveSystemOptions): Reac
          * 此时，添加 Pending 标记，根据其它标记决定是否需要 Notify，根据其它标记决定是否需要 Downward。
          */
         flags.setPending();
-        // shouldNotify = shouldNotify;
-        // shouldDownward = shouldDownward;
+        shouldNotify = shouldNotify;
+        shouldDownward = shouldDownward;
       } else if (flags.hasTracking() === false) {
         /**
          * 进入此分支的 flags：
@@ -508,7 +792,7 @@ export const createReactiveSystem = (options: CreateReactiveSystemOptions): Reac
          *
          * 此时，什么都不做，不需要修改标记，不需要 Notify，不需要 Downward。
          */
-        // flags = flags;
+        flags = flags;
         shouldNotify = false;
         shouldDownward = false;
       } else if (flags.hasDirty() === false && flags.hasPending() === false) {
@@ -523,7 +807,7 @@ export const createReactiveSystem = (options: CreateReactiveSystemOptions): Reac
          */
         flags.setPending();
         shouldNotify = false;
-        // shouldDownward = shouldDownward;
+        shouldDownward = shouldDownward;
       } else {
         /**
          * 进入此分支的 flags：
@@ -534,7 +818,7 @@ export const createReactiveSystem = (options: CreateReactiveSystemOptions): Reac
          *
          * 此时，不需要修改标记，不需要 Notify，不需要 Downward。
          */
-        // flags = flags;
+        flags = flags;
         shouldNotify = false;
         shouldDownward = false;
       }
@@ -631,25 +915,40 @@ export const createReactiveSystem = (options: CreateReactiveSystemOptions): Reac
   }
 
   return {
+    getDepLinksOfNode,
+    getSubLinksOfNode,
+    getDepsOfNode,
+    getSubsOfNode,
     isDepLinkOfNode,
     isSubLinkOfNode,
-    getLinkOfNodes,
-    isLinked,
-    linkNode,
-    unlinkNode,
-    unlink,
-    unlinkAllDepLinksOfNode,
-    unlinkAllSubLinksOfNode,
+    isDepOfNode,
+    isSubOfNode,
+    getLinkBetweenFromDep,
+    getLinkBetweenFromSub,
+    hasLinkBetweenFromDep,
+    hasLinkBetweenFromSub,
+    addLinkBetween,
+    removeLinkBetweenFromDep,
+    removeLinkBetweenFromSub,
+    removeLink,
+    removeAllDepLinksOfNode,
+    removeAllSubLinksOfNode,
 
     getActiveNodeAsSub,
     setActiveNodeAsSub,
+    setNoActiveNodeAsSub,
     resetActiveNodeAsSub,
     withActiveNodeAsSub,
+    withoutActiveNodeAsSub,
+    assertWithoutActiveNodeAsSub,
     startTracking,
     endTracking,
     withTracking,
-    linkNodeOptimizedForTracking,
+    withoutTracking,
+    assertWithoutTracking,
+    addLinkBetweenOptimizedForTracking,
     track,
+    trackNearestMutableOrWatching,
 
     shallowPropagate,
     deeeeepPropagate,