@planet-matrix/mobius-model 0.1.4 → 0.3.0

package/tests/unit/reactor/reactor-operators-filter.spec.ts

@@ -0,0 +1,604 @@
+import { expect, test } from 'vitest';
+
+import type { Signal } from '#Source/reactor/index.ts';
+import {
+  auditByCount, auditByDynamic, auditByTime, auditByToggle, auditByTrigger,
+  current, debounceByCount, debounceByDynamic, debounceByTime, debounceByToggle,
+  debounceByTrigger, distinct,
+  distinctUntilChanged, filter, interval, next, signal,
+  takeByCount, takeByPredicate, takeByTime, takeByToggle, takeByTrigger, takeUntilTrigger,
+  throttleByCount, throttleByDynamic, throttleByTime, throttleByToggle, throttleByTrigger
+} from '#Source/reactor/index.ts';
+
+test("current operator should work correctly", () => {
+  const a = signal(() => 0);
+
+  const currentA = current({ target: a });
+  expect(currentA.get()).toBe(0);
+
+  a.set(1);
+  expect(currentA.get()).toBe(0);
+
+  a.set(2);
+  expect(currentA.get()).toBe(0);
+});
+
+test("next operator should get next value after initial", () => {
+  const a = signal(() => 0);
+
+  const nextA = next({ target: a, valueInitializer: () => -1 });
+  expect(nextA.get()).toBe(-1);
+
+  a.set(1);
+  expect(nextA.get()).toBe(1);
+
+  a.set(2);
+  expect(nextA.get()).toBe(1);
+});
+
+test("filter operator should work correctly", () => {
+  const source = signal(() => 1);
+  const filtered = filter({
+    target: source,
+    truthyPredicate: (value) => value % 2 === 0,
+    falsyValueGetter: (context) => {
+      if (context.isInitializingRun) {
+        return 0
+      } else {
+        return context.previousValue
+      }
+    }
+  });
+
+  expect(filtered.get()).toBe(0);
+
+  source.set(2);
+  expect(filtered.get()).toBe(2);
+
+  source.set(3);
+  expect(filtered.get()).toBe(2);
+
+  source.set(4);
+  expect(filtered.get()).toBe(4);
+});
+
+test("auditByCount operator should work correctly", () => {
+  const source = signal(() => 0);
+  const audited = auditByCount({ target: source, count: 3 });
+
+  expect(audited.get()).toBe(0);
+
+  source.set(1);
+  expect(audited.get()).toBe(0);
+
+  source.set(2);
+  expect(audited.get()).toBe(0);
+
+  source.set(3);
+  expect(audited.get()).toBe(3);
+
+  source.set(4);
+  source.set(5);
+  source.set(6);
+  expect(audited.get()).toBe(6);
+});
+
+test("auditByTime operator should work correctly", async () => {
+  const source = signal(() => 1);
+  const audited = auditByTime({ target: source, time: 100 });
+
+  expect(audited.get()).toBe(1);
+
+  source.set(2);
+  source.set(3);
+  expect(audited.get()).toBe(1);
+
+  await new Promise((resolve) => {
+    setTimeout(resolve, 120);
+  });
+  expect(audited.get()).toBe(3);
+
+  source.set(4);
+  source.set(5);
+  source.set(6);
+  expect(audited.get()).toBe(3);
+
+  await new Promise((resolve) => {
+    setTimeout(resolve, 110);
+  });
+  expect(audited.get()).toBe(6);
+});
+
+test("auditByTrigger operator should work correctly", () => {
+  const source = signal(() => 1);
+  const trigger = signal(() => 0);
+  const audited = auditByTrigger({ target: source, trigger });
+
+  expect(audited.get()).toBe(1);
+
+  source.set(2);
+  source.set(3);
+  expect(audited.get()).toBe(1);
+
+  trigger.set(1);
+  expect(audited.get()).toBe(3);
+
+  source.set(4);
+  source.set(5);
+  expect(audited.get()).toBe(3);
+
+  trigger.set(2);
+  expect(audited.get()).toBe(5);
+});
+
+test("auditByToggle operator should work correctly", () => {
+  const source = signal(() => 1);
+  const open = signal(() => []);
+  const close = signal(() => []);
+  const audited = auditByToggle({ target: source, open, close });
+
+  expect(audited.get()).toBe(1);
+
+  source.set(2);
+  expect(audited.get()).toBe(1);
+
+  open.set([]);
+  source.set(3);
+  source.set(4);
+  expect(audited.get()).toBe(1);
+
+  close.set([]);
+  expect(audited.get()).toBe(4);
+
+  source.set(5);
+  expect(audited.get()).toBe(4);
+
+  open.set([]);
+  source.set(6);
+  source.set(7);
+  expect(audited.get()).toBe(4);
+
+  close.set([]);
+  expect(audited.get()).toBe(7);
+});
+
+test("auditByDynamic operator should work correctly", async () => {
+  const source = signal(() => 1);
+  const dynamic = (): Signal<number> => interval({ interval: 100 });
+  const audited = auditByDynamic({ target: source, dynamic });
+
+  expect(audited.get()).toBe(1);
+
+  source.set(2);
+  source.set(3);
+  expect(audited.get()).toBe(1);
+
+  await new Promise((resolve) => {
+    setTimeout(resolve, 120);
+  });
+  expect(audited.get()).toBe(3);
+
+  source.set(4);
+  source.set(5);
+  source.set(6);
+  expect(audited.get()).toBe(3);
+
+  await new Promise((resolve) => {
+    setTimeout(resolve, 110);
+  });
+  expect(audited.get()).toBe(6);
+});
+
+test("debounceByCount operator should work correctly", () => {
+  const source = signal(() => 0);
+  const debounced = debounceByCount({ target: source, count: 3 });
+
+  expect(debounced.get()).toBe(0);
+
+  source.set(1);
+  expect(debounced.get()).toBe(0);
+
+  source.set(2);
+  expect(debounced.get()).toBe(0);
+
+  source.set(3);
+  expect(debounced.get()).toBe(3);
+
+  source.set(4);
+  source.set(5);
+  source.set(6);
+  expect(debounced.get()).toBe(6);
+});
+
+test("debounceByTime operator should work correctly", async () => {
+  const source = signal(() => 1);
+  const debounced = debounceByTime({ target: source, time: 100 });
+
+  expect(debounced.get()).toBe(1);
+
+  source.set(2);
+  source.set(3);
+  expect(debounced.get()).toBe(1);
+
+  await new Promise((resolve) => {
+    setTimeout(resolve, 120);
+  });
+  expect(debounced.get()).toBe(3);
+
+  source.set(4);
+  source.set(5);
+  source.set(6);
+  expect(debounced.get()).toBe(3);
+
+  await new Promise((resolve) => {
+    setTimeout(resolve, 110);
+  });
+  expect(debounced.get()).toBe(6);
+});
+
+test("debounceByTrigger operator should work correctly", () => {
+  const source = signal(() => 1);
+  const trigger = signal(() => 0);
+  const debounced = debounceByTrigger({ target: source, trigger });
+
+  expect(debounced.get()).toBe(1);
+
+  source.set(2);
+  source.set(3);
+  expect(debounced.get()).toBe(1);
+
+  trigger.set(1);
+  expect(debounced.get()).toBe(3);
+
+  source.set(4);
+  source.set(5);
+  expect(debounced.get()).toBe(3);
+
+  trigger.set(2);
+  expect(debounced.get()).toBe(5);
+});
+
+test("debounceByToggle operator should work correctly", () => {
+  const source = signal(() => 1);
+  const open = signal(() => []);
+  const close = signal(() => []);
+  const debounced = debounceByToggle({ target: source, open, close });
+
+  expect(debounced.get()).toBe(1);
+
+  source.set(2);
+  expect(debounced.get()).toBe(1);
+
+  open.set([]);
+  source.set(3);
+  source.set(4);
+  expect(debounced.get()).toBe(1);
+
+  close.set([]);
+  expect(debounced.get()).toBe(4);
+
+  source.set(5);
+  expect(debounced.get()).toBe(4);
+
+  open.set([]);
+  source.set(6);
+  source.set(7);
+  expect(debounced.get()).toBe(4);
+
+  close.set([]);
+  expect(debounced.get()).toBe(7);
+});
+
+test("debounceByDynamic operator should work correctly", async () => {
+  const source = signal(() => 1);
+  const dynamic = (): Signal<number> => interval({ interval: 100 });
+  const debounced = debounceByDynamic({ target: source, dynamic });
+
+  expect(debounced.get()).toBe(1);
+
+  source.set(2);
+  source.set(3);
+  expect(debounced.get()).toBe(1);
+
+  await new Promise((resolve) => {
+    setTimeout(resolve, 120);
+  });
+  expect(debounced.get()).toBe(3);
+
+  source.set(4);
+  source.set(5);
+  source.set(6);
+  expect(debounced.get()).toBe(3);
+
+  await new Promise((resolve) => {
+    setTimeout(resolve, 110);
+  });
+  expect(debounced.get()).toBe(6);
+});
+
+test("throttleByCount operator should work correctly", () => {
+  const source = signal(() => 0);
+  const throttled = throttleByCount({ target: source, count: 3 });
+
+  expect(throttled.get()).toBe(0);
+
+  source.set(1);
+  expect(throttled.get()).toBe(0);
+
+  source.set(2);
+  expect(throttled.get()).toBe(0);
+
+  source.set(3);
+  expect(throttled.get()).toBe(3);
+
+  source.set(4);
+  source.set(5);
+  source.set(6);
+  expect(throttled.get()).toBe(6);
+});
+
+
+test("throttleByTime operator should work correctly", async () => {
+  const source = signal(() => 1);
+  const throttled = throttleByTime({ target: source, time: 100 });
+
+  expect(throttled.get()).toBe(1);
+
+  source.set(2);
+  source.set(3);
+  expect(throttled.get()).toBe(1);
+
+  await new Promise((resolve) => {
+    setTimeout(resolve, 120);
+  });
+  expect(throttled.get()).toBe(1);
+
+  source.set(4);
+  source.set(5);
+  source.set(6);
+  expect(throttled.get()).toBe(4);
+
+  await new Promise((resolve) => {
+    setTimeout(resolve, 110);
+  });
+  source.set(7);
+  expect(throttled.get()).toBe(7);
+});
+
+test("throttleByTrigger operator should work correctly", () => {
+  const source = signal(() => 1);
+  const trigger = signal(() => 0);
+  const throttled = throttleByTrigger({ target: source, trigger });
+
+  expect(throttled.get()).toBe(1);
+
+  source.set(2);
+  source.set(3);
+  expect(throttled.get()).toBe(1);
+
+  trigger.set(1);
+  expect(throttled.get()).toBe(1);
+
+  source.set(4);
+  source.set(5);
+  expect(throttled.get()).toBe(4);
+
+  trigger.set(2);
+  expect(throttled.get()).toBe(4);
+});
+
+test("throttleByToggle operator should work correctly", () => {
+  const source = signal(() => 1);
+  const open = signal(() => []);
+  const close = signal(() => []);
+  const throttled = throttleByToggle({ target: source, open, close });
+
+  expect(throttled.get()).toBe(1);
+
+  source.set(2);
+  expect(throttled.get()).toBe(1);
+
+  open.set([]);
+  source.set(3);
+  source.set(4);
+  expect(throttled.get()).toBe(3);
+
+  close.set([]);
+  expect(throttled.get()).toBe(3);
+
+  source.set(5);
+  expect(throttled.get()).toBe(3);
+
+  open.set([]);
+  source.set(6);
+  source.set(7);
+  expect(throttled.get()).toBe(6);
+
+  close.set([]);
+  expect(throttled.get()).toBe(6);
+});
+
+test("throttleByDynamic operator should work correctly", async () => {
+  const source = signal(() => 1);
+  const dynamic = (): Signal<number> => interval({ interval: 100 });
+  const throttled = throttleByDynamic({ target: source, dynamic });
+
+  expect(throttled.get()).toBe(1);
+
+  source.set(2);
+  source.set(3);
+  expect(throttled.get()).toBe(1);
+
+  await new Promise((resolve) => {
+    setTimeout(resolve, 120);
+  });
+  expect(throttled.get()).toBe(1);
+
+  source.set(4);
+  source.set(5);
+  source.set(6);
+  expect(throttled.get()).toBe(4);
+
+  await new Promise((resolve) => {
+    setTimeout(resolve, 110);
+  });
+  expect(throttled.get()).toBe(4);
+
+  source.set(7);
+  expect(throttled.get()).toBe(7);
+});
+
+test("distinct operator should work correctly", () => {
+  const source = signal(() => 1);
+  const distinctSignal = distinct({ target: source });
+
+  expect(distinctSignal.get()).toBe(1);
+
+  source.set(1);
+  expect(distinctSignal.get()).toBe(1);
+
+  source.set(2);
+  expect(distinctSignal.get()).toBe(2);
+
+  source.set(2);
+  expect(distinctSignal.get()).toBe(2);
+
+  source.set(3);
+  expect(distinctSignal.get()).toBe(3);
+});
+
+test("distinctUntilChanged operator should work correctly", () => {
+  const source = signal(() => 1);
+  const distinctSignal = distinctUntilChanged({ target: source });
+
+  expect(distinctSignal.get()).toBe(1);
+
+  source.set(1);
+  expect(distinctSignal.get()).toBe(1);
+
+  source.set(2);
+  expect(distinctSignal.get()).toBe(2);
+
+  source.set(2);
+  expect(distinctSignal.get()).toBe(2);
+
+  source.set(3);
+  expect(distinctSignal.get()).toBe(3);
+});
+
+test("takeByPredicate operator should work correctly", () => {
+  const source = signal(() => 1);
+  const takeSignal = takeByPredicate({ target: source, predicate: (value) => value < 3 });
+
+  expect(takeSignal.get()).toBe(1);
+
+  source.set(2);
+  expect(takeSignal.get()).toBe(2);
+
+  source.set(3);
+  expect(takeSignal.get()).toBe(2);
+
+  source.set(4);
+  expect(takeSignal.get()).toBe(2);
+});
+
+test("takeByCount operator should work correctly", () => {
+  const source = signal(() => 1);
+  const takeSignal = takeByCount({ target: source, count: 3 });
+
+  expect(takeSignal.get()).toBe(1);
+
+  source.set(2);
+  expect(takeSignal.get()).toBe(2);
+
+  source.set(3);
+  expect(takeSignal.get()).toBe(3);
+
+  source.set(4);
+  expect(takeSignal.get()).toBe(3);
+});
+
+test("takeByTime operator should work correctly", async () => {
+  const source = signal(() => 1);
+  const takeSignal = takeByTime({ target: source, time: 200 });
+
+  expect(takeSignal.get()).toBe(1);
+
+  source.set(2);
+  expect(takeSignal.get()).toBe(2);
+
+  await new Promise((resolve) => {
+    setTimeout(resolve, 150);
+  });
+  source.set(3);
+  expect(takeSignal.get()).toBe(3);
+
+  await new Promise((resolve) => {
+    setTimeout(resolve, 100);
+  });
+  source.set(4);
+  expect(takeSignal.get()).toBe(3);
+});
+
+test("takeByTrigger operator should work correctly", () => {
+  const source = signal(() => 1);
+  const trigger = signal(() => 0);
+  const takeSignal = takeByTrigger({ target: source, trigger });
+
+  expect(takeSignal.get()).toBe(1);
+
+  source.set(2);
+  expect(takeSignal.get()).toBe(1);
+
+  trigger.set(1);
+  expect(takeSignal.get()).toBe(2);
+
+  source.set(3);
+  expect(takeSignal.get()).toBe(2);
+
+  trigger.set(2);
+  expect(takeSignal.get()).toBe(3);
+});
+
+test("takeByToggle operator should work correctly", () => {
+  const source = signal(() => 1);
+  const open = signal(() => []);
+  const close = signal(() => []);
+  const takeSignal = takeByToggle({ target: source, open, close });
+
+  expect(takeSignal.get()).toBe(1);
+
+  source.set(2);
+  expect(takeSignal.get()).toBe(1);
+
+  open.set([]);
+  source.set(3);
+  expect(takeSignal.get()).toBe(3);
+
+  close.set([]);
+  source.set(4);
+  expect(takeSignal.get()).toBe(3);
+
+  open.set([]);
+  source.set(5);
+  expect(takeSignal.get()).toBe(5);
+
+  close.set([]);
+  source.set(6);
+  expect(takeSignal.get()).toBe(5);
+});
+
+test("takeUntilTrigger operator should work correctly", () => {
+  const source = signal(() => 1);
+  const trigger = signal(() => 0);
+  const takeSignal = takeUntilTrigger({ target: source, trigger });
+
+  expect(takeSignal.get()).toBe(1);
+
+  source.set(2);
+  expect(takeSignal.get()).toBe(2);
+
+  trigger.set(1);
+  source.set(3);
+  expect(takeSignal.get()).toBe(2);
+});

package/tests/unit/reactor/reactor-operators-join.spec.ts

@@ -0,0 +1,94 @@
+import { expect, test } from 'vitest';
+
+import {
+  combineLatestArray, combineLatestObject,
+  computed, derived,
+  mergeArray,
+  signal,
+  withLatestFrom, zip
+} from '#Source/reactor/index.ts';
+
+test("combineLatestArray operator should work correctly", () => {
+  const a = signal(() => 1);
+  const b = signal(() => 2);
+  const c = derived(() => {
+    return a.get() * 2;
+  });
+  const d = computed(() => {
+    return a.get() + b.get() + c.get();
+  });
+  const combined = combineLatestArray({ target: [a, b, c, d] });
+
+  expect(combined.get()).toEqual([1, 2, 2, 5]);
+
+  a.set(3);
+  expect(combined.get()).toEqual([3, 2, 6, 11]);
+
+  b.set(4);
+  expect(combined.get()).toEqual([3, 4, 6, 13]);
+});
+
+test("combineLatestObject operator should work correctly", () => {
+  const a = signal(() => 1);
+  const b = signal(() => 2);
+  const c = derived(() => {
+    return a.get() * 2;
+  });
+  const d = computed(() => {
+    return a.get() + b.get() + c.get();
+  });
+  const combined = combineLatestObject({ target: { a, b, c, d } });
+
+  expect(combined.get()).toEqual({ a: 1, b: 2, c: 2, d: 5 });
+
+  a.set(3);
+  expect(combined.get()).toEqual({ a: 3, b: 2, c: 6, d: 11 });
+
+  b.set(4);
+  expect(combined.get()).toEqual({ a: 3, b: 4, c: 6, d: 13 });
+});
+
+test("mergeArray operator should work correctly", () => {
+  const a = signal(() => 1);
+  const b = signal(() => 2);
+  const c = mergeArray({ target: [a, b] });
+
+  expect(c.get()).toBe(2);
+
+  a.set(3);
+  expect(c.get()).toBe(3);
+
+  b.set(4);
+  expect(c.get()).toBe(4);
+});
+
+test("withLatestFrom operator should work correctly", () => {
+  const a = signal(() => 1);
+  const b = signal(() => 2);
+  const c = withLatestFrom({ target: a, other: b });
+
+  expect(c.get()).toEqual([1, 2]);
+
+  a.set(3);
+  expect(c.get()).toEqual([3, 2]);
+
+  b.set(4);
+  expect(c.get()).toEqual([3, 2]);
+
+  a.set(5);
+  expect(c.get()).toEqual([5, 4]);
+});
+
+test("zip operator should work correctly", () => {
+  const a = signal(() => 1);
+  const b = signal(() => 2);
+  const c = zip({ a: a, b: b });
+
+  expect(c.get()).toEqual([1, 2]);
+
+  a.set(3);
+  expect(c.get()).toEqual([1, 2]);
+
+  b.set(4);
+  expect(c.get()).toEqual([3, 4]);
+});