signalium 1.2.2 → 2.0.1

package/src/__tests__/gc.test.ts

@@ -1,256 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { reactive, createContext, withContexts, watcher, state } from '../index.js';
-import { SignalScope, ROOT_SCOPE, forceGc, clearRootContexts } from '../internals/contexts.js';
-import { nextTick, sleep } from './utils/async.js';
-
-// Helper to access private properties for testing
-const getSignalsMap = (scope: SignalScope) => {
-  return (scope as any).signals as Map<number, any>;
-};
-
-const getGCCandidates = (scope: SignalScope) => {
-  return (scope as any).gcCandidates as Set<any>;
-};
-
-describe('Garbage Collection', () => {
-  beforeEach(() => {
-    clearRootContexts();
-  });
-
-  it('should automatically garbage collect unwatched signals', async () => {
-    const testSignal = reactive(() => 42);
-
-    const w = watcher(() => testSignal());
-
-    // Watch the signal
-    const unwatch = w.addListener(() => {
-      testSignal();
-    });
-
-    await nextTick();
-
-    // Signal should be in the scope
-    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
-
-    // Unwatch the signal
-    unwatch();
-
-    await sleep(50);
-
-    // Signal should be garbage collected
-    expect(getSignalsMap(ROOT_SCOPE).size).toBe(0);
-  });
-
-  it('should not garbage collect signals with shouldGC returning false', async () => {
-    // Create a signal that should not be garbage collected
-    const persistentSignal = reactive(() => 'persist', {
-      shouldGC: () => false,
-    });
-
-    const w = watcher(() => persistentSignal());
-
-    // Watch the signal
-    const unwatch = w.addListener(() => {
-      persistentSignal();
-    });
-
-    await nextTick();
-
-    // Signal should be in the scope
-    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
-
-    // Unwatch the signal
-    unwatch();
-
-    await sleep(50);
-
-    // Signal should still be in the scope
-    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
-  });
-
-  it('should support conditional GC based on signal state', async () => {
-    // Create a signal with conditional GC
-    const shouldAllowGC = state(false);
-
-    const conditionalSignal = reactive(() => shouldAllowGC.get(), {
-      shouldGC: (signal, value) => {
-        // console.log('shouldGC', signal, value);
-        return value;
-      },
-    });
-
-    const w = watcher(() => conditionalSignal());
-
-    // Watch the signal
-    const unwatch = w.addListener(() => {
-      conditionalSignal();
-    });
-
-    await nextTick();
-
-    // Signal should be in the scope
-    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
-
-    // Unwatch the signal
-    unwatch();
-
-    await sleep(50);
-
-    // Signal should still be in the scope because shouldGC returns false
-    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
-
-    // Now allow GC
-    shouldAllowGC.set(true);
-
-    // Watch the signal
-    const unwatch2 = w.addListener(() => {
-      conditionalSignal();
-    });
-
-    await nextTick();
-
-    // Signal should be in GC candidates
-    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
-
-    unwatch2();
-
-    await sleep(50);
-
-    // Signal should be garbage collected
-    expect(getSignalsMap(ROOT_SCOPE).size).toBe(0);
-  });
-
-  it('should support manual garbage collection', async () => {
-    let signalObj: object;
-
-    // Create multiple signals
-    const signal1 = reactive(() => 'signal1');
-    const signal2 = reactive(() => 'signal2', {
-      shouldGC: signal => {
-        signalObj = signal;
-        return false;
-      },
-    });
-
-    const w1 = watcher(() => signal1());
-    const w2 = watcher(() => signal2());
-
-    // Watch both signals
-    const unwatch1 = w1.addListener(() => {
-      signal1();
-    });
-    const unwatch2 = w2.addListener(() => {
-      signal2();
-    });
-
-    await nextTick();
-
-    // Both signals should be in the scope
-    expect(getSignalsMap(ROOT_SCOPE).size).toBe(2);
-
-    // Unwatch both signals
-    unwatch1();
-    unwatch2();
-
-    await sleep(50);
-
-    // Only signal1 should be garbage collected
-    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
-
-    // The remaining signal should be signal2
-    const remainingSignal = Array.from(getSignalsMap(ROOT_SCOPE).values())[0];
-    expect(remainingSignal.get()).toBe('signal2');
-
-    forceGc(signalObj!);
-
-    await sleep(50);
-
-    expect(getSignalsMap(ROOT_SCOPE).size).toBe(0);
-  });
-
-  it('should not garbage collect signals that are still being watched', async () => {
-    // Create a signal
-    const watchedSignal = reactive(() => 'watched');
-
-    const w = watcher(() => watchedSignal());
-
-    // Watch the signal but don't unwatch
-    w.addListener(() => {
-      watchedSignal();
-    });
-
-    await nextTick();
-
-    // Signal should be in the scope
-    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
-
-    await sleep(50);
-
-    // Signal should still be in the scope because it's being watched
-    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
-  });
-
-  it('should handle context-scoped signals correctly', async () => {
-    // Create a context
-    const TestContext = createContext('test');
-
-    // Create signals in context
-    let contextSignal: any;
-
-    withContexts([[TestContext, 'value']], () => {
-      contextSignal = reactive(() => 'context-scoped');
-
-      const w = watcher(() => contextSignal());
-
-      // Watch and unwatch
-      const unwatch = w.addListener(() => {
-        contextSignal();
-      });
-
-      unwatch();
-    });
-
-    await nextTick();
-
-    // Get the context scope (this is a bit hacky for testing)
-    const contextScope = (ROOT_SCOPE as any).children.values().next().value;
-
-    await sleep(50);
-
-    // Signal should be garbage collected from the context scope
-    expect(getSignalsMap(contextScope).size).toBe(0);
-  });
-
-  it('should remove signal from GC candidates if watched again', async () => {
-    // Create a signal
-    const signal = reactive(() => 'rewatch');
-
-    const w = watcher(() => signal());
-
-    // Watch and unwatch
-    const unwatch = w.addListener(() => {
-      signal();
-    });
-
-    await nextTick();
-
-    // Signal should be in the scope
-    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
-
-    unwatch();
-    await nextTick();
-
-    // Signal should be in GC candidates
-    expect(getGCCandidates(ROOT_SCOPE).size).toBe(1);
-
-    // Watch again
-    w.addListener(() => {
-      signal();
-    });
-
-    await nextTick();
-
-    // Signal should be removed from GC candidates
-    expect(getGCCandidates(ROOT_SCOPE).size).toBe(0);
-  });
-});

package/src/__tests__/nesting.test.ts

@@ -1,298 +0,0 @@
-import { describe, expect, test, vi } from 'vitest';
-import { state } from '../index.js';
-import { nextTick } from './utils/async.js';
-import { permute } from './utils/permute.js';
-
-describe('nesting', () => {
-  permute(2, (create1, create2) => {
-    test('simple nesting', async () => {
-      const inner = create2(
-        (a: number, b: number) => {
-          return a + b;
-        },
-        {
-          desc: 'inner',
-        },
-      );
-
-      const outer = create1(
-        (a: number) => {
-          return inner(a, 2);
-        },
-        {
-          desc: 'outer',
-        },
-      );
-
-      outer.withParams(1).watch();
-      outer.withParams(2).watch();
-
-      await nextTick();
-
-      expect(outer.withParams(1)).toHaveSignalValue(3).toMatchSnapshot();
-      expect(outer.withParams(2)).toHaveSignalValue(4).toMatchSnapshot();
-
-      expect(outer.withParams(1)).toHaveSignalValue(3).toMatchSnapshot();
-      expect(outer.withParams(2)).toHaveSignalValue(4).toMatchSnapshot();
-    });
-
-    test('outer state + params', async () => {
-      const val = state(1);
-
-      const inner = create2((a: number, b: number) => {
-        return a + b;
-      });
-
-      const outer = create1((a: number) => {
-        if (a > 1) {
-          return inner(a, 2)! + val.get();
-        }
-
-        return inner(a, 2);
-      });
-
-      outer.withParams(1).watch();
-      outer.withParams(2).watch();
-
-      await nextTick();
-
-      expect(outer.withParams(1)).toHaveSignalValue(3).toMatchSnapshot();
-      expect(outer.withParams(2)).toHaveSignalValue(5).toMatchSnapshot();
-
-      val.set(2);
-      await nextTick();
-
-      expect(outer.withParams(1)).toHaveSignalValue(3).toMatchSnapshot();
-      expect(outer.withParams(2)).toHaveSignalValue(6).toMatchSnapshot();
-    });
-
-    test('inner state + params', async () => {
-      const val = state(1);
-
-      const inner = create2((a: number, b: number) => {
-        if (a > 1) {
-          return a + b + val.get();
-        }
-
-        return a + b;
-      });
-
-      const outer = create1((a: number) => {
-        return inner(a, 2);
-      });
-
-      outer.withParams(1).watch();
-      outer.withParams(2).watch();
-
-      await nextTick();
-
-      expect(outer.withParams(1)).toHaveSignalValue(3).toMatchSnapshot();
-      expect(outer.withParams(2)).toHaveSignalValue(5).toMatchSnapshot();
-
-      val.set(2);
-
-      await nextTick();
-
-      expect(outer.withParams(1)).toHaveSignalValue(3).toMatchSnapshot();
-      expect(outer.withParams(2)).toHaveSignalValue(6).toMatchSnapshot();
-    });
-  });
-
-  permute(3, (create1, create2, create3) => {
-    test('simple nesting', async () => {
-      const inner = create3((a: number, b: number, c: number) => {
-        return a + b + c;
-      });
-
-      const middle = create2((a: number, b: number) => {
-        return inner(a, b, 3);
-      });
-
-      const outer = create1((a: number) => {
-        return middle(a, 2);
-      });
-
-      outer.withParams(1).watch();
-
-      await nextTick();
-
-      expect(outer.withParams(1)).toHaveSignalValue(6).toMatchSnapshot();
-    });
-
-    test('state + params one level deep', async () => {
-      const val = state(1);
-
-      const inner = create3((a: number, b: number, c: number) => {
-        return a + b + c;
-      });
-
-      const middle = create2((a: number, b: number) => {
-        if (a > 1) {
-          return inner(a, b, 3)! + val.get();
-        }
-
-        return inner(a, b, 3);
-      });
-
-      const outer = create1((a: number) => {
-        return middle(a, 2);
-      });
-
-      outer.withParams(1).watch();
-      outer.withParams(2).watch();
-
-      await nextTick();
-
-      expect(outer.withParams(1)).toHaveSignalValue(6).toMatchSnapshot();
-      expect(outer.withParams(2)).toHaveSignalValue(8).toMatchSnapshot();
-
-      val.set(2);
-      await nextTick();
-
-      expect(outer.withParams(1)).toHaveSignalValue(6).toMatchSnapshot();
-      expect(outer.withParams(2)).toHaveSignalValue(9).toMatchSnapshot();
-    });
-
-    test('state + params two levels deep', async () => {
-      const val = state(1);
-
-      const inner = create3((a: number, b: number, c: number) => {
-        if (a > 1) {
-          return a + b + c + val.get();
-        }
-
-        return a + b + c;
-      });
-
-      const middle = create2((a: number, b: number) => {
-        return inner(a, b, 3);
-      });
-
-      const outer = create1((a: number) => {
-        return middle(a, 2);
-      });
-
-      outer.withParams(1).watch();
-      outer.withParams(2).watch();
-
-      await nextTick();
-
-      expect(outer.withParams(1)).toHaveSignalValue(6).toMatchSnapshot();
-      expect(outer.withParams(2)).toHaveSignalValue(8).toMatchSnapshot();
-
-      val.set(2);
-
-      await nextTick();
-
-      expect(outer.withParams(1)).toHaveSignalValue(6).toMatchSnapshot();
-      expect(outer.withParams(2)).toHaveSignalValue(9).toMatchSnapshot();
-    });
-
-    test('params + multiple children', async () => {
-      const inner1 = create3((a: number, b: number, c: number) => {
-        return a + b + c;
-      });
-
-      const inner2 = create2((a: number, b: number) => {
-        return a + b + inner1(a, b, 3)!;
-      });
-
-      const outer = create1((a: number, b: number) => {
-        return inner1(a, 2, 3)! + inner2(b, 2)!;
-      });
-
-      outer.withParams(1, 2).watch();
-      outer.withParams(2, 2).watch();
-      outer.withParams(2, 3).watch();
-
-      await nextTick();
-      await nextTick();
-
-      expect(outer.withParams(1, 2)).toHaveSignalValue(17).toMatchSnapshot();
-      expect(outer.withParams(2, 2)).toHaveSignalValue(18).toMatchSnapshot();
-      expect(outer.withParams(2, 3)).toHaveSignalValue(20).toMatchSnapshot();
-    });
-
-    test('params + state + multiple children', async () => {
-      const val = state(1);
-
-      const inner1 = create3((a: number, b: number, c: number) => {
-        return a + b + c;
-      });
-
-      const inner2 = create2((a: number, b: number) => {
-        if (a > 1) {
-          return a + b + inner1(a, b, 3)! + val.get();
-        }
-
-        return a + b + inner1(a, b, 3)!;
-      });
-
-      const outer = create1((a: number, b: number) => {
-        return inner1(a, 2, 3)! + inner2(b, 2)!;
-      });
-
-      outer.withParams(1, 2).watch();
-      outer.withParams(2, 2).watch();
-      outer.withParams(2, 3).watch();
-      outer.withParams(3, 3).watch();
-
-      await nextTick();
-
-      expect(outer.withParams(1, 2)).toHaveSignalValue(18).toMatchSnapshot();
-      expect(outer.withParams(2, 2)).toHaveSignalValue(19).toMatchSnapshot();
-      expect(outer.withParams(2, 3)).toHaveSignalValue(21).toMatchSnapshot();
-      expect(outer.withParams(3, 3)).toHaveSignalValue(22).toMatchSnapshot();
-
-      val.set(2);
-
-      // Wait for async with subscriptions
-      await nextTick();
-
-      expect(outer.withParams(1, 2)).toHaveSignalValue(19).toMatchSnapshot();
-      expect(outer.withParams(2, 2)).toHaveSignalValue(20).toMatchSnapshot();
-      expect(outer.withParams(2, 3)).toHaveSignalValue(22).toMatchSnapshot();
-      expect(outer.withParams(3, 3)).toHaveSignalValue(23).toMatchSnapshot();
-    });
-
-    test('passing state as params + multiple children', async () => {
-      const stateA = state(1);
-      const stateB = state(2);
-
-      const inner1 = create2((a: number, s: typeof stateA) => {
-        return a + s.get();
-      });
-
-      const inner2 = create3((b: number, s: typeof stateB) => {
-        return b * s.get();
-      });
-
-      const outer = create1((x: number) => {
-        if (x > 2) {
-          return inner1(x, stateA)! + inner2(x, stateB)!;
-        }
-        return inner1(x, stateA);
-      });
-
-      outer.withParams(1).watch();
-      outer.withParams(3).watch();
-
-      await nextTick();
-
-      expect(outer.withParams(1)).toHaveSignalValue(2).toMatchSnapshot();
-      expect(outer.withParams(3)).toHaveSignalValue(10).toMatchSnapshot();
-
-      stateA.set(2);
-      await nextTick();
-
-      expect(outer.withParams(1)).toHaveSignalValue(3).toMatchSnapshot();
-      expect(outer.withParams(3)).toHaveSignalValue(11).toMatchSnapshot();
-
-      stateB.set(3);
-
-      await nextTick();
-      expect(outer.withParams(1)).toHaveSignalValue(3).toMatchSnapshot();
-      expect(outer.withParams(3)).toHaveSignalValue(14).toMatchSnapshot();
-    });
-  });
-});