signalium 0.3.8 → 1.0.1

package/src/__tests__/hooks/async-computed.test.ts

@@ -1,190 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { state } from '../../index.js';
-import { asyncComputed } from '../utils/instrumented-hooks.js';
-import { nextTick } from '../utils/async.js';
-
-describe('async computeds', () => {
-  test('Basic async computed works', async () => {
-    const getC = asyncComputed(async (a: number, b: number) => {
-      return a + b;
-    });
-
-    const result1 = getC(1, 2);
-    expect(result1.isPending).toBe(true);
-    expect(result1.result).toBe(undefined);
-    await nextTick();
-    expect(result1.isSuccess).toBe(true);
-    expect(result1.result).toBe(3);
-
-    const result2 = getC(2, 2);
-    expect(result2.isPending).toBe(true);
-    expect(result2.result).toBe(undefined);
-    await nextTick();
-    expect(result2.isSuccess).toBe(true);
-    expect(result2.result).toBe(4);
-  });
-
-  test('Async computed is not recomputed when the same arguments are passed', async () => {
-    let computeCount = 0;
-    const getC = asyncComputed(async (a: number, b: number) => {
-      computeCount++;
-      return a + b;
-    });
-
-    const result1 = getC(1, 2);
-    await nextTick();
-    expect(result1.result).toBe(3);
-    expect(computeCount).toBe(1);
-
-    const result2 = getC(1, 2);
-    await nextTick();
-    expect(result2.result).toBe(3);
-    expect(computeCount).toBe(1);
-  });
-
-  test('Async computed is recomputed when the arguments change', async () => {
-    let computeCount = 0;
-    const getC = asyncComputed(async (a: number, b: number) => {
-      computeCount++;
-      return a + b;
-    });
-
-    const result1 = getC(1, 2);
-    await nextTick();
-    expect(result1.result).toBe(3);
-    expect(computeCount).toBe(1);
-
-    const result2 = getC(2, 2);
-    await nextTick();
-    expect(result2.result).toBe(4);
-    expect(computeCount).toBe(2);
-  });
-
-  test('Async computed is recomputed when state changes', async () => {
-    let computeCount = 0;
-    const stateValue = state(1);
-
-    const getC = asyncComputed(async (a: number) => {
-      computeCount++;
-      return a + stateValue.get();
-    });
-
-    const result1 = getC(1);
-    await nextTick();
-    expect(result1.result).toBe(2);
-    expect(computeCount).toBe(1);
-
-    stateValue.set(2);
-    const result2 = getC(1);
-    await nextTick();
-    expect(result2.result).toBe(3);
-    expect(computeCount).toBe(2);
-  });
-
-  test('Async computed handles errors', async () => {
-    const getC = asyncComputed(async (shouldError: boolean) => {
-      if (shouldError) {
-        throw new Error('Test error');
-      }
-      return 'success';
-    });
-
-    const result1 = getC(false);
-    await nextTick();
-    expect(result1.isSuccess).toBe(true);
-    expect(result1.result).toBe('success');
-
-    const result2 = getC(true);
-    await nextTick();
-    expect(result2.isError).toBe(true);
-    expect(result2.error as Error).toBeInstanceOf(Error);
-    expect((result2.error as Error).message).toBe('Test error');
-  });
-
-  test('Async computed with init value starts ready', () => {
-    const getC = asyncComputed(async () => 'updated', { initValue: 'initial' });
-
-    const result = getC();
-    expect(result.isReady).toBe(true);
-    expect(result.result).toBe('initial');
-    expect(result.isPending).toBe(true);
-  });
-
-  test('Nested async computeds work correctly', async () => {
-    let innerCount = 0;
-    let outerCount = 0;
-
-    const inner = asyncComputed(async (x: number) => {
-      innerCount++;
-      await nextTick();
-      return x * 2;
-    });
-
-    const outer = asyncComputed(async (x: number) => {
-      outerCount++;
-      const innerResult = inner(x);
-      const result = innerResult.await();
-      return result + 1;
-    });
-
-    const result1 = outer(2);
-    expect(result1.result).toBe(undefined);
-    expect(innerCount).toBe(1);
-    expect(outerCount).toBe(1);
-
-    await new Promise(resolve => setTimeout(resolve, 10));
-    const result2 = outer(2);
-    expect(result2.result).toBe(5);
-    expect(innerCount).toBe(1);
-    expect(outerCount).toBe(2);
-  });
-
-  test('Nested async computeds handle errors correctly', async () => {
-    const inner = asyncComputed(async (shouldError: boolean) => {
-      if (shouldError) throw new Error('Inner error');
-      await nextTick();
-      return 'inner success';
-    });
-
-    const outer = asyncComputed(async (shouldError: boolean) => {
-      const innerResult = inner(shouldError);
-      await innerResult.await();
-      return 'outer: ' + innerResult.result;
-    });
-
-    // Test success case
-    const successResult = outer(false);
-    await new Promise(resolve => setTimeout(resolve, 10));
-    expect(successResult.isSuccess).toBe(true);
-    expect(successResult.result).toBe('outer: inner success');
-
-    // Test error case
-    const errorResult = outer(true);
-    await new Promise(resolve => setTimeout(resolve, 10));
-    expect(errorResult.isError).toBe(true);
-    expect(errorResult.error).toBeInstanceOf(Error);
-    expect((errorResult.error as Error).message).toBe('Inner error');
-  });
-
-  test('Nested async computeds with init values work correctly', async () => {
-    const inner = asyncComputed(async (x: number) => x * 2, { initValue: 0 });
-    const outer = asyncComputed(
-      async (x: number) => {
-        const innerResult = inner(x);
-        await innerResult.await();
-        return innerResult.result! + 1;
-      },
-      { initValue: -1 },
-    );
-
-    const result = outer(2);
-    expect(result.isReady).toBe(true);
-    expect(result.result).toBe(-1); // Initial value
-    expect(result.isPending).toBe(true);
-
-    await new Promise(resolve => setTimeout(resolve, 10));
-    expect(result.result).toBe(5); // (2 * 2) + 1
-    expect(result.isPending).toBe(false);
-    expect(result.isSuccess).toBe(true);
-  });
-});

package/src/__tests__/hooks/async-task.test.ts

@@ -1,334 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { asyncTask, computed } from '../utils/instrumented-hooks.js';
-import { nextTick } from '../utils/async.js';
-
-describe('async tasks', () => {
-  test('Basic async task works', async () => {
-    const getC = asyncTask(async (a: number, b: number) => {
-      return a + b;
-    });
-
-    // First set of args
-    const task1 = getC(1, 2);
-    expect(task1.isPending).toBe(false);
-    expect(task1.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 0 });
-
-    await nextTick();
-    expect(task1.isPending).toBe(false);
-    expect(task1.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 0 });
-
-    const result1 = task1.run();
-    expect(task1.isPending).toBe(true);
-    expect(task1.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 1 });
-
-    expect(await result1).toBe(3);
-    expect(task1.isSuccess).toBe(true);
-    expect(task1.result).toBe(3);
-    expect(getC).toHaveCounts({ compute: 1 });
-
-    const result2 = task1.run();
-    expect(task1.isPending).toBe(true);
-    expect(task1.result).toBe(3);
-    expect(getC).toHaveCounts({ compute: 2 });
-
-    expect(await result2).toBe(3);
-    expect(task1.isSuccess).toBe(true);
-    expect(task1.result).toBe(3);
-    expect(getC).toHaveCounts({ compute: 2 });
-
-    // Second set of args
-    const task2 = getC(2, 2);
-    expect(task2.isPending).toBe(false);
-    expect(task2.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 2 });
-
-    await nextTick();
-    expect(task2.isPending).toBe(false);
-    expect(task2.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 2 });
-
-    const result3 = task2.run();
-    expect(task2.isPending).toBe(true);
-    expect(task2.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 3 });
-
-    expect(await result3).toBe(4);
-    expect(task2.isSuccess).toBe(true);
-    expect(task2.result).toBe(4);
-    expect(getC).toHaveCounts({ compute: 3 });
-
-    const result4 = task2.run();
-    expect(task2.isPending).toBe(true);
-    expect(task2.result).toBe(4);
-    expect(getC).toHaveCounts({ compute: 4 });
-
-    expect(await result4).toBe(4);
-    expect(task2.isSuccess).toBe(true);
-    expect(task2.result).toBe(4);
-    expect(getC).toHaveCounts({ compute: 4 });
-  });
-
-  test('Separate tasks are created for different arguments', async () => {
-    const getC = asyncTask(async (a: number, b: number) => {
-      return a + b;
-    });
-
-    const task1 = getC(1, 2);
-    const task2 = getC(2, 2);
-
-    expect(task1.isPending).toBe(false);
-    expect(task1.result).toBe(undefined);
-    expect(task2.isPending).toBe(false);
-    expect(task2.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 0 });
-
-    await nextTick();
-    expect(task1.isPending).toBe(false);
-    expect(task1.result).toBe(undefined);
-    expect(task2.isPending).toBe(false);
-    expect(task2.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 0 });
-
-    const result1 = task1.run();
-    expect(task1.isPending).toBe(true);
-    expect(task1.result).toBe(undefined);
-    expect(task2.isPending).toBe(false);
-    expect(task2.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 1 });
-
-    expect(await result1).toBe(3);
-    expect(task1.isSuccess).toBe(true);
-    expect(task1.result).toBe(3);
-    expect(task2.isPending).toBe(false);
-    expect(task2.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 1 });
-
-    const result2 = task2.run();
-    expect(task2.isPending).toBe(true);
-    expect(task2.result).toBe(undefined);
-    expect(task1.isPending).toBe(false);
-    expect(task1.result).toBe(3);
-    expect(getC).toHaveCounts({ compute: 2 });
-
-    expect(await result2).toBe(4);
-    expect(task1.isPending).toBe(false);
-    expect(task1.result).toBe(3);
-    expect(task2.isSuccess).toBe(true);
-    expect(task2.result).toBe(4);
-    expect(getC).toHaveCounts({ compute: 2 });
-  });
-
-  test('Separate tasks notify separately', async () => {
-    const getC = asyncTask(async (a: number, b: number) => {
-      return a + b;
-    });
-
-    const computed1 = computed(() => getC(1, 2));
-    const computed2 = computed(() => getC(2, 2));
-
-    const task1 = computed1();
-    const task2 = computed2();
-
-    expect(task1.isPending).toBe(false);
-    expect(task1.result).toBe(undefined);
-    expect(task2.isPending).toBe(false);
-    expect(task2.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 0 });
-    expect(computed1).toHaveCounts({ compute: 1 });
-    expect(computed2).toHaveCounts({ compute: 1 });
-
-    await nextTick();
-    expect(task1.isPending).toBe(false);
-    expect(task1.result).toBe(undefined);
-    expect(task2.isPending).toBe(false);
-    expect(task2.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 0 });
-    expect(computed1).toHaveCounts({ compute: 1 });
-    expect(computed2).toHaveCounts({ compute: 1 });
-
-    const result1 = task1.run();
-
-    computed1();
-    computed2();
-
-    expect(task1.isPending).toBe(true);
-    expect(task1.result).toBe(undefined);
-    expect(task2.isPending).toBe(false);
-    expect(task2.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 1 });
-    expect(computed1).toHaveCounts({ compute: 2 });
-    expect(computed2).toHaveCounts({ compute: 1 });
-
-    computed1();
-    computed2();
-
-    expect(await result1).toBe(3);
-    expect(task1.isSuccess).toBe(true);
-    expect(task1.result).toBe(3);
-    expect(task2.isPending).toBe(false);
-    expect(task2.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 1 });
-
-    computed1();
-    computed2();
-
-    expect(computed1).toHaveCounts({ compute: 3 });
-    expect(computed2).toHaveCounts({ compute: 1 });
-
-    const result2 = task2.run();
-    expect(task2.isPending).toBe(true);
-    expect(task2.result).toBe(undefined);
-    expect(task1.isPending).toBe(false);
-    expect(task1.result).toBe(3);
-    expect(getC).toHaveCounts({ compute: 2 });
-
-    computed1();
-    computed2();
-
-    expect(computed1).toHaveCounts({ compute: 3 });
-    expect(computed2).toHaveCounts({ compute: 2 });
-
-    expect(await result2).toBe(4);
-    expect(task1.isPending).toBe(false);
-    expect(task1.result).toBe(3);
-    expect(task2.isSuccess).toBe(true);
-    expect(task2.result).toBe(4);
-    expect(getC).toHaveCounts({ compute: 2 });
-
-    computed1();
-    computed2();
-
-    expect(computed1).toHaveCounts({ compute: 3 });
-    expect(computed2).toHaveCounts({ compute: 3 });
-  });
-
-  test('Basic async task works with run args', async () => {
-    const getC = asyncTask(async (a: number, b: number, c: number, d: number) => {
-      return a + b + c + d;
-    });
-
-    // First set of args
-    const task1 = getC(1, 2);
-    expect(task1.isPending).toBe(false);
-    expect(task1.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 0 });
-
-    await nextTick();
-    expect(task1.isPending).toBe(false);
-    expect(task1.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 0 });
-
-    const result1 = task1.run(3, 4);
-    expect(task1.isPending).toBe(true);
-    expect(task1.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 1 });
-
-    expect(await result1).toBe(10);
-    expect(task1.isSuccess).toBe(true);
-    expect(task1.result).toBe(10);
-    expect(getC).toHaveCounts({ compute: 1 });
-
-    const result2 = task1.run(5, 6);
-    expect(task1.isPending).toBe(true);
-    expect(task1.result).toBe(10);
-    expect(getC).toHaveCounts({ compute: 2 });
-
-    expect(await result2).toBe(14);
-    expect(task1.isSuccess).toBe(true);
-    expect(task1.result).toBe(14);
-    expect(getC).toHaveCounts({ compute: 2 });
-
-    // Second set of args
-    const task2 = getC(2, 2);
-    expect(task2.isPending).toBe(false);
-    expect(task2.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 2 });
-
-    await nextTick();
-    expect(task2.isPending).toBe(false);
-    expect(task2.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 2 });
-
-    const result3 = task2.run(7, 8);
-    expect(task2.isPending).toBe(true);
-    expect(task2.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 3 });
-
-    expect(await result3).toBe(19);
-    expect(task2.isSuccess).toBe(true);
-    expect(task2.result).toBe(19);
-    expect(getC).toHaveCounts({ compute: 3 });
-
-    const result4 = task2.run(9, 10);
-    expect(task2.isPending).toBe(true);
-    expect(task2.result).toBe(19);
-    expect(getC).toHaveCounts({ compute: 4 });
-
-    expect(await result4).toBe(23);
-    expect(task2.isSuccess).toBe(true);
-    expect(task2.result).toBe(23);
-    expect(getC).toHaveCounts({ compute: 4 });
-  });
-
-  test('Task can be defined with rest params', async () => {
-    const getC = asyncTask(async (...nums: number[]) => {
-      return nums.reduce((acc, num) => acc + num, 0);
-    });
-
-    // First set of args
-    const task1 = getC(1, 2);
-    expect(task1.isPending).toBe(false);
-    expect(task1.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 0 });
-
-    await nextTick();
-    expect(task1.isPending).toBe(false);
-    expect(task1.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 0 });
-
-    const result1 = task1.run(3, 4);
-    expect(task1.isPending).toBe(true);
-    expect(task1.result).toBe(undefined);
-    expect(getC).toHaveCounts({ compute: 1 });
-
-    expect(await result1).toBe(10);
-    expect(task1.isSuccess).toBe(true);
-    expect(task1.result).toBe(10);
-    expect(getC).toHaveCounts({ compute: 1 });
-
-    const result2 = task1.run(5, 6, 7);
-    expect(task1.isPending).toBe(true);
-    expect(task1.result).toBe(10);
-    expect(getC).toHaveCounts({ compute: 2 });
-
-    expect(await result2).toBe(21);
-    expect(task1.isSuccess).toBe(true);
-    expect(task1.result).toBe(21);
-    expect(getC).toHaveCounts({ compute: 2 });
-  });
-
-  test('Async task handles errors', async () => {
-    const getC = asyncTask(async (shouldError: boolean) => {
-      if (shouldError) {
-        throw new Error('Test error');
-      }
-      return 'success';
-    });
-
-    const result1 = getC(false);
-    await expect(result1.run()).resolves.toBe('success');
-    await nextTick();
-    expect(result1.isSuccess).toBe(true);
-    expect(result1.result).toBe('success');
-
-    const result2 = getC(true);
-    await expect(result2.run()).rejects.toThrow('Test error');
-    await nextTick();
-    expect(result2.isError).toBe(true);
-    expect(result2.error as Error).toBeInstanceOf(Error);
-    expect((result2.error as Error).message).toBe('Test error');
-  });
-});

package/src/__tests__/hooks/computed.test.ts

@@ -1,126 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { state } from '../../index.js';
-import { computed } from '../utils/instrumented-hooks.js';
-
-describe('computeds', () => {
-  test('Basic computed works', () => {
-    const getC = computed((a: number, b: number) => {
-      return a + b;
-    });
-
-    expect(getC).withParams(1, 2).toHaveValueAndCounts(3, { compute: 1 });
-    expect(getC).withParams(2, 2).toHaveValueAndCounts(4, { compute: 2 });
-  });
-
-  test('Computed can throw errors', () => {
-    const getC = computed((a: number) => {
-      if (a < 0) throw new Error('negative number');
-      return a * 2;
-    });
-
-    expect(getC).withParams(2).toHaveValueAndCounts(4, { compute: 1 });
-    expect(() => getC(-1)).toThrow('negative number');
-  });
-
-  describe('nesting behavior', () => {
-    test('Nested computeds work', () => {
-      const getInner = computed((a: number, b: number) => {
-        return a + b;
-      });
-
-      const getOuter = computed((x: number) => {
-        return getInner(x, 2) * 2;
-      });
-
-      expect(getOuter).withParams(1).toHaveValueAndCounts(6, { compute: 1 });
-      expect(getOuter).withParams(1).toHaveValueAndCounts(6, { compute: 1 });
-      expect(getOuter).withParams(2).toHaveValueAndCounts(8, { compute: 2 });
-    });
-
-    test('Nested computeds with shared state', () => {
-      const sharedState = state(1);
-
-      const getInner = computed((a: number) => {
-        return a + sharedState.get();
-      });
-
-      const getOuter = computed((x: number) => {
-        return getInner(x) * 2;
-      });
-
-      expect(getOuter).withParams(1).toHaveValueAndCounts(4, { compute: 1 });
-      sharedState.set(2);
-      expect(getOuter).withParams(1).toHaveValueAndCounts(6, { compute: 2 });
-    });
-
-    test('Deeply nested computeds maintain independence', () => {
-      const getA = computed((x: number) => {
-        return x + 1;
-      });
-
-      const getB = computed((x: number) => {
-        return getA(x) * 2 + getA(x * 2);
-      });
-
-      const getC = computed((x: number) => {
-        return getB(x) + getA(x);
-      });
-
-      expect(getC).withParams(1).toHaveValueAndCounts(9, { compute: 1 });
-      expect(getC).withParams(1).toHaveValueAndCounts(9, { compute: 1 });
-      expect(getC).withParams(2).toHaveValueAndCounts(14, { compute: 2 });
-    });
-
-    test('Nested computeds work with state signals', () => {
-      const stateA = state(1);
-      const stateB = state(2);
-
-      const getInner = computed((x: number) => {
-        return x + stateA.get();
-      });
-
-      const getOuter = computed((x: number) => {
-        return getInner(x) * stateB.get();
-      });
-
-      expect(getOuter).withParams(3).toHaveValueAndCounts(8, { compute: 1 });
-
-      stateA.set(2);
-      expect(getOuter).withParams(3).toHaveValueAndCounts(10, { compute: 2 });
-
-      stateB.set(3);
-      expect(getOuter).withParams(3).toHaveValueAndCounts(15, { compute: 3 });
-
-      expect(getOuter).withParams(3).toHaveValueAndCounts(15, { compute: 3 });
-    });
-
-    test('Nested computeds work with both state and arguments', () => {
-      const stateA = state(1);
-      const stateB = state(2);
-
-      const getInner = computed((x: number, y: number) => {
-        return x + y + stateA.get();
-      });
-
-      const getMiddle = computed((x: number) => {
-        return getInner(x, stateB.get()) * 2;
-      });
-
-      const getOuter = computed((x: number, y: number) => {
-        return getMiddle(x) + y;
-      });
-
-      expect(getOuter).withParams(1, 3).toHaveValueAndCounts(11, { compute: 1 });
-
-      stateB.set(3);
-      expect(getOuter).withParams(1, 3).toHaveValueAndCounts(13, { compute: 2 });
-
-      stateA.set(2);
-      expect(getOuter).withParams(1, 3).toHaveValueAndCounts(15, { compute: 3 });
-
-      expect(getOuter).withParams(1, 4).toHaveValueAndCounts(16, { compute: 4 });
-
-      expect(getOuter).withParams(1, 4).toHaveValueAndCounts(16, { compute: 4 });
-    });
-  });
-});