@planet-matrix/mobius-model 0.1.3 → 0.3.0

package/src/signal/signal-core/primitive.ts

@@ -1,275 +0,0 @@
-import type { Flags } from "./flags.ts"
-import { createReactiveSystem } from "./reactive-system.ts"
-import { flags } from "./flags.ts"
-import type { Link, Node } from "./reactive-system.ts"
-
-const VOID = Symbol("void") as unknown;
-
-const queue: Effect[] = [];
-const flush = (): void => {
-  while (queue.length !== 0) {
-    queue.shift()!.run();
-  }
-}
-
-let batchDepth = 0;
-export const startBatch = (): void => {
-  batchDepth = batchDepth + 1;
-}
-export const endBatch = (): void => {
-  batchDepth = batchDepth - 1;
-  if (batchDepth === 0) {
-    flush();
-  }
-}
-
-const reactiveSystem = createReactiveSystem({
-  update(node: Signal | Computed) {
-    return node.update();
-  },
-  notify(node: Effect) {
-    const nodes = []
-    let currentNode: Effect | undefined = node
-    while (currentNode !== undefined) {
-      if (currentNode.flags.hasWatching() === false) {
-        break
-      }
-      node.notify();
-      nodes.push(currentNode);
-      const nextNode: Node | undefined = currentNode?.headSubLink?.sub
-      currentNode = nextNode instanceof Effect ? nextNode : undefined
-    }
-    queue.push(...nodes.toReversed());
-  },
-  unwatched(node: Signal | Computed | Effect) {
-    return node.stop();
-  }
-});
-const {
-  unlinkAllDepLinksOfNode,
-
-  withTracking,
-  track,
-
-  shallowPropagate,
-  deeeeepPropagate,
-  resolvePending,
-} = reactiveSystem
-
-/**
- * Signal 的值只有在被获取的时候才会更新。
- */
-export class Signal<T = unknown> implements Node {
-  headSubLink: Link | undefined;
-  tailSubLink: Link | undefined;
-  flags: Flags;
-
-  value: T;
-  pendingValue: T;
-
-  constructor(value: T) {
-    this.headSubLink = undefined;
-    this.tailSubLink = undefined;
-    this.flags = flags().setMutable();
-
-    this.pendingValue = value;
-    this.value = value;
-  }
-
-  get(): T {
-    let valueChanged = false
-
-    // 如果包含 Dirty 标记，则进行更新
-    const shouldUpdate = this.flags.hasDirty();
-    if (shouldUpdate === true) {
-      valueChanged = this.update()
-    }
-
-    // 如果值发生变化，则更新直接下游节点的标记
-    if (valueChanged === true) {
-      shallowPropagate(this);
-    }
-
-    // 自动进行依赖收集
-    track(this);
-
-    return this.value;
-  }
-
-  set(value: T): void {
-    // 将新值暂存起来，等用到的时候再执行更新
-    this.pendingValue = value;
-    // 为当前节点添加 Dirty 标记
-    this.flags.setDirty();
-
-    // 更新所有下游节点的标记
-    deeeeepPropagate(this);
-
-    // 执行更新队列
-    if (batchDepth === 0) {
-      flush();
-    }
-  }
-
-  /**
-   * 返回值表示更新前后值是否变化。
-   */
-  update(): boolean {
-    this.flags.unsetDirty();
-
-    const oldValue = this.value;
-    const newValue = this.pendingValue;
-    this.value = newValue;
-
-    return oldValue !== newValue;
-  }
-
-  stop(): void {
-    // do nothing
-  }
-}
-
-/**
- * Computed 的值只有在被获取的时候才会更新。
- * Computed 的值只有在上游节点的值发生变化时才会更新。
- * Computed 的下游节点全部解除连接时会自动与所有上游节点解除连接，并回到初始状态。
- */
-export class Computed<T = unknown> implements Node {
-  headDepLink: Link | undefined;
-  tailDepLink: Link | undefined;
-  headSubLink: Link | undefined;
-  tailSubLink: Link | undefined;
-  flags: Flags;
-
-  value: T;
-  getValue: () => T;
-
-  constructor(getValue: () => T) {
-    this.headDepLink = undefined;
-    this.tailDepLink = undefined;
-    this.headSubLink = undefined;
-    this.tailSubLink = undefined;
-    // 值在创建时尚未计算，因此初始时添加 Dirty 标记
-    this.flags = flags().setMutable().setDirty();
-
-    // undefined 可能是使用者期待的合法值，因此这里使用 VOID 占位
-    // oxlint-disable-next-line no-unsafe-type-assertion
-    this.value = VOID as T;
-    this.getValue = getValue;
-  }
-
-  get(): T {
-    let valueChanged = false;
-
-    // 如果包含 Pending 标记，则进行解决
-    const shouldResolve = this.flags.hasPending();
-    if (shouldResolve === true) {
-      resolvePending(this);
-    }
-
-    // 如果包含 Dirty 标记，则进行更新
-    const shouldUpdate = this.flags.hasDirty();
-    if (shouldUpdate === true) {
-      valueChanged = this.update()
-    }
-
-    // 如果值变化，则通知下游（仅通知直接下游）
-    if (valueChanged === true) {
-      shallowPropagate(this);
-    }
-
-    // 自动进行依赖收集
-    track(this);
-
-    return this.value;
-  }
-
-  /**
-   * 返回值表示更新前后值是否变化。
-   */
-  update(): boolean {
-    const result = withTracking(this, () => {
-      const oldValue = this.value;
-      const newValue = this.getValue();
-      this.value = newValue;
-      return oldValue !== newValue;
-    })
-    return result;
-  }
-
-  stop(): void {
-    unlinkAllDepLinksOfNode(this);
-    this.flags = flags().setMutable().setDirty();
-  }
-}
-
-/**
- * Effect 会在创建时立即执行一次传入的函数。
- * Effect 会在每次上游节点的值发生变化时重新执行传入的函数。
- * Effect 在任意时刻最多只能一个待运行。
- * Effect 可以与 Effect 建立连接。
- * 作为上游节点的 Effect 在没有下游节点时会自动与所有上游节点解除连接，并将标记清空。
- */
-export class Effect implements Node {
-  headDepLink: Link | undefined;
-  tailDepLink: Link | undefined;
-  headSubLink: Link | undefined;
-  tailSubLink: Link | undefined;
-  flags: Flags;
-
-  fn: () => void;
-
-  constructor(fn: () => void) {
-    this.headDepLink = undefined;
-    this.tailDepLink = undefined;
-    this.headSubLink = undefined;
-    this.tailSubLink = undefined;
-    // 在创建完成后即进入观察状态，因此初始时添加 Watching 标记
-    this.flags = flags().setWatching();
-
-    this.fn = fn;
-    this.internalRun();
-  }
-
-  notify(): void {
-    this.flags.unsetWatching();
-  }
-
-  run(): void {
-    this.flags.setWatching();
-
-    // 如果包含 Pending 标记，则进行解决
-    const shouldResolve = this.flags.hasPending();
-    if (shouldResolve === true) {
-      resolvePending(this);
-    }
-
-    // 如果包含 Dirty 标记，则进行更新
-    const shouldRun = this.flags.hasDirty();
-    if (shouldRun === true) {
-      this.internalRun();
-    }
-  }
-
-  private internalRun(): void {
-    track(this);
-    withTracking(this, () => {
-      return this.fn();
-    })
-  }
-
-  stop(): void {
-    unlinkAllDepLinksOfNode(this);
-    this.flags.clear();
-  }
-}
-
-export const signal = <T>(initialValue: T): Signal<T> => {
-  return new Signal(initialValue);
-}
-export const computed = <T>(getter: () => T): Computed<T> => {
-  return new Computed<T>(getter);
-}
-export const effect = (fn: () => void): Effect => {
-  return new Effect(fn);
-}

package/src/signal/signal-operators/index.ts

@@ -1,19 +0,0 @@
-import type { Signal } from "#Source/index.ts"
-import { effect, signal } from "#Source/index.ts"
-
-export const withHistory = <T>(orginal: Signal<T>): Signal<T[]> => {
-  const history: T[] = []
-  effect(() => {
-    history.push(orginal.get())
-  })
-  const result = signal<T[]>(history)
-  return result
-}
-
-export const zip = <T, U>(signal1: Signal<T>, signal2: Signal<U>): Signal<[T, U]> => {
-  const result = signal<[T, U]>([signal1.get(), signal2.get()])
-  effect(() => {
-    result.set([signal1.get(), signal2.get()])
-  })
-  return result
-}

package/tests/unit/signal/effect.spec.ts

@@ -1,108 +0,0 @@
-import { expect, test } from 'vitest';
-import { computed, effect, endBatch, signal, startBatch } from '#Source/index.ts';
-
-test('should clear subscriptions when untracked by all subscribers', () => {
-  /**
-   *   a
-   *   |
-   *   b
-   *   |
-   *   e
-   */
-  let bRunTimes = 0;
-  const a = signal(1);
-  const b = computed(() => {
-    bRunTimes = bRunTimes + 1;
-    return a.get() * 2;
-  });
-  const e = effect(() => {
-    b.get();
-  });
-
-  expect(bRunTimes).toBe(1);
-  a.set(2);
-  expect(bRunTimes).toBe(2);
-  e.stop();
-  a.set(3);
-  expect(bRunTimes).toBe(2);
-});
-
-test('should not run untracked inner effect', () => {
-  /**
-   *     a
-   *    / \
-   *   b  e2(inner)
-   *    \ /
-   *     e1(outer)
-   */
-  let countOfInnerEffect = 0;
-  const a = signal(3);
-  const b = computed(() => a.get() > 0);
-  effect(() => {
-    if (b.get() === true) {
-      countOfInnerEffect = countOfInnerEffect + 1;
-      effect(() => {
-        if (a.get() === 0) {
-          throw new Error("bad");
-        }
-      });
-    }
-  });
-
-  a.set(2);
-  a.set(1);
-  a.set(0);
-});
-
-test('should run outer effect first', () => {
-  /**
-   *   a       b
-   *   | \     /
-   *   |   \  /
-   *   |  e2(inner)
-   *   \ /
-   *    e1(outer)
-   */
-  const a = signal(1);
-  const b = signal(1);
-  effect(() => {
-    if (a.get() !== 0) {
-      effect(() => {
-        b.get();
-        if (a.get() === 0) {
-          throw new Error("bad");
-        }
-      });
-    }
-  });
-
-  startBatch();
-  b.set(0);
-  a.set(0);
-  endBatch();
-});
-
-test('should not trigger inner effect when resolve maybe dirty', () => {
-  /**
-   *    a
-   *    |
-   *    b
-   *   e2(inner)
-   *    |
-   *   e1(outer)
-   */
-  const a = signal(0);
-  const b = computed(() => a.get() % 2);
-  let innerTriggerTimes = 0;
-  effect(() => {
-    effect(() => {
-      b.get();
-      innerTriggerTimes = innerTriggerTimes + 1;
-      if (innerTriggerTimes >= 2) {
-        throw new Error("bad");
-      }
-    });
-  });
-
-  a.set(2);
-});