@planet-matrix/mobius-model 0.1.1

package/tests/unit/signals/computed.spec.ts

@@ -0,0 +1,92 @@
+import { computed, signal } from '../../../src';
+import { expect, test } from 'vitest';
+
+test('should correctly propagate changes through computed signals', () => {
+  /**
+   *   src
+   *    |
+   *   c1
+   *    |
+   *   c2
+   *    |
+   *   c3
+   */
+  const src = signal(0);
+  const c1 = computed(() => src.get() % 2);
+  const c2 = computed(() => c1.get());
+  const c3 = computed(() => c2.get());
+
+  expect(c3.get()).toBe(0);
+  src.set(1);
+  expect(c2.get()).toBe(1);
+  src.set(3);
+  expect(c3.get()).toBe(1);
+});
+
+test('should propagate updated source value through chained computations', () => {
+  /**
+   *        src
+   *       /   \
+   *      a     c
+   *      |     |
+   *      b     |
+   *       \   /
+   *         d
+   */
+  const src = signal(0);
+  const a = computed(() => src.get());
+  const b = computed(() => a.get() % 2);
+  const c = computed(() => src.get());
+  const d = computed(() => b.get() + c.get());
+
+  expect(d.get()).toBe(0);
+  src.set(2);
+  expect(d.get()).toBe(2);
+});
+
+test('should handle flags are indirectly updated during resolve pending', () => {
+  /**
+   *      a
+   *      |
+   *      b
+   *     / \
+   *    c   d
+   *     \ /
+   *      d
+   */
+  const a = signal(false);
+  const b = computed(() => a.get());
+  const c = computed(() => {
+    b.get();
+    return 0;
+  });
+  const d = computed(() => {
+    c.get();
+    return b.get();
+  });
+
+  expect(d.get()).toBe(false);
+  a.set(true);
+  expect(d.get()).toBe(true);
+});
+
+test('should not update if the signal value is reverted', () => {
+  /**
+   *   src
+   *    |
+   *   c1
+   */
+  let times = 0;
+  const src = signal(0);
+  const c1 = computed(() => {
+    times = times + 1;
+    return src.get();
+  });
+
+  expect(c1.get()).toBe(0);
+  expect(times).toBe(1);
+  src.set(1);
+  src.set(0);
+  expect(c1.get()).toBe(0);
+  expect(times).toBe(1);
+});

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

@@ -0,0 +1,108 @@
+import { computed, effect, endBatch, signal, startBatch } from '../../../src';
+import { expect, test } from 'vitest';
+
+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);
+});

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "@planet-matrix/mobius-mono/tsconfig.base.json",
+}

package/vite.config.ts

@@ -0,0 +1,8 @@
+/// <reference types="vitest/config" />
+import { defineConfig } from "vite";
+
+const config = defineConfig({
+  test: {}
+})
+
+export default config