signalium 0.2.7 → 0.3.0

package/dist/esm/utils.js

@@ -0,0 +1,75 @@
+import { createComputedSignal, createSubscriptionSignal } from './signals.js';
+const objectToIdMap = new WeakMap();
+let nextId = 1;
+export function getObjectId(obj) {
+    let id = objectToIdMap.get(obj);
+    if (id === undefined) {
+        id = `obj-${nextId++}`;
+        objectToIdMap.set(obj, id);
+    }
+    return id;
+}
+// Handle basic POJOs and arrays recursively
+function isPOJO(obj) {
+    return Object.getPrototypeOf(obj) === Object.prototype;
+}
+function isPlainArray(arr) {
+    return Array.isArray(arr);
+}
+export function hashValue(value) {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    switch (typeof value) {
+        case 'number':
+        case 'boolean':
+        case 'string':
+            return String(value);
+        case 'bigint':
+            return value.toString();
+        case 'symbol':
+            return String(value);
+        case 'object': {
+            if (value instanceof Date) {
+                return value.toISOString();
+            }
+            if (isPlainArray(value)) {
+                return `[${value.map(hashValue).join(',')}]`;
+            }
+            if (isPOJO(value)) {
+                const entries = [
+                    ...Object.entries(value),
+                    ...Object.getOwnPropertySymbols(value).map(sym => [sym, value[sym]]),
+                ].sort(([a], [b]) => (String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0));
+                return `{ ${entries.map(([k, v]) => `${String(k)}: ${hashValue(v)}`).join(', ')} }`;
+            }
+            return getObjectId(value);
+        }
+        case 'function':
+            return getObjectId(value);
+        default:
+            return getObjectId(value);
+    }
+}
+let UNKNOWN_SUBSCRIPTION_ID = 0;
+let UNKNOWN_COMPUTED_ID = 0;
+let UNKNOWN_ASYNC_COMPUTED_ID = 0;
+const UNKNOWN_SIGNAL_NAMES = new Map();
+export function getUnknownSignalFnName(fn, makeSignal) {
+    let name = UNKNOWN_SIGNAL_NAMES.get(fn);
+    if (name === undefined) {
+        if (makeSignal === createSubscriptionSignal) {
+            name = `unknownSubscription${UNKNOWN_SUBSCRIPTION_ID++}`;
+        }
+        else if (makeSignal === createComputedSignal) {
+            name = `unknownComputed${UNKNOWN_COMPUTED_ID++}`;
+        }
+        else {
+            name = `unknownAsyncComputed${UNKNOWN_ASYNC_COMPUTED_ID++}`;
+        }
+        UNKNOWN_SIGNAL_NAMES.set(fn, name);
+    }
+    return name;
+}
+//# sourceMappingURL=utils.js.map

package/dist/esm/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalium",
-  "version": "0.2.7",
+  "version": "0.3.0",
   "type": "module",
   "repository": "https://github.com/pzuraq/signalium",
   "description": "Chain-reactivity at critical mass",
@@ -21,11 +21,48 @@
         "require": "./dist/cjs/index.d.ts"
       }
     },
+    "./debug": {
+      "import": {
+        "development": "./src/debug.ts",
+        "default": "./dist/esm/debug.js"
+      },
+      "require": {
+        "default": "./dist/cjs/debug.js"
+      },
+      "types": {
+        "development": "./src/debug.ts",
+        "import": "./dist/esm/debug.d.ts",
+        "require": "./dist/cjs/debug.d.ts"
+      }
+    },
+    "./react": {
+      "import": {
+        "development": "./src/react/index.ts",
+        "default": "./dist/esm/react/index.js"
+      },
+      "require": {
+        "default": "./dist/cjs/react/index.js"
+      },
+      "types": {
+        "development": "./src/react/index.ts",
+        "import": "./dist/esm/react/index.d.ts",
+        "require": "./dist/cjs/react/index.d.ts"
+      }
+    },
     "./package.json": "./package.json"
   },
+  "peerDependencies": {
+    "react": ">=18.3.1"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
   "scripts": {
     "dev": "vitest",
     "test": "vitest run",
+    "check-types": "tsc --noEmit",
     "build": "npm run build:esm && npm run build:cjs",
     "build:esm": "tsc",
     "build:cjs": "tsc --module commonjs --outDir dist/cjs --moduleResolution node"
@@ -33,7 +70,11 @@
   "author": "",
   "license": "ISC",
   "devDependencies": {
+    "@vitejs/plugin-react": "^4.3.4",
+    "@vitest/browser": "^3.0.6",
     "vite": "^5.4.8",
-    "vitest": "^2.1.2"
+    "vitest": "^3.0.6",
+    "vitest-browser-react": "^0.1.1",
+    "playwright": "^1.50.1"
   }
 }

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

@@ -0,0 +1,190 @@
+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

@@ -0,0 +1,227 @@
+import { describe, expect, test } from 'vitest';
+import { asyncComputed, 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('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');
+  });
+});

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

@@ -0,0 +1,126 @@
+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 });
+    });
+  });
+});