signalium 0.3.8 → 1.0.1

package/src/__tests__/signals/watcher.test.ts

@@ -1,253 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import {
-  createStateSignal,
-  createComputedSignal,
-  createAsyncComputedSignal,
-  createSubscriptionSignal,
-  createWatcherSignal,
-} from '../utils/instrumented-signals.js';
-import { result } from '../utils/builders.js';
-import { nextTick, sleep } from '../utils/async.js';
-
-describe('Watcher functionality', () => {
-  describe('with computeds', () => {
-    test('watches computed values', async () => {
-      const a = createStateSignal(1);
-      const b = createStateSignal(2);
-
-      const c = createComputedSignal(() => {
-        return a.get() + b.get();
-      });
-
-      let value;
-      const w = createWatcherSignal(() => {
-        value = c.get();
-      });
-
-      w.addListener(() => {
-        // do something
-      });
-
-      expect(value).toBe(undefined);
-      expect(w).toHaveSignalCounts({ compute: 0, effect: 0 });
-
-      await nextTick();
-
-      expect(value).toBe(3);
-      expect(w).toHaveSignalCounts({ compute: 1, effect: 1 });
-
-      a.set(2);
-
-      await nextTick();
-
-      expect(value).toBe(4);
-      expect(w).toHaveSignalCounts({ compute: 2, effect: 2 });
-    });
-
-    test('immediate option works', async () => {
-      const a = createStateSignal(1);
-      const b = createStateSignal(2);
-
-      const c = createComputedSignal(() => {
-        return a.get() + b.get();
-      });
-
-      let value;
-      const w = createWatcherSignal(() => {
-        value = c.get();
-      });
-
-      w.addListener(
-        () => {
-          // do something
-        },
-        { immediate: true },
-      );
-
-      expect(value).toBe(3);
-      expect(w).toHaveSignalCounts({ compute: 1, effect: 1 });
-
-      a.set(2);
-
-      await nextTick();
-
-      expect(value).toBe(4);
-      expect(w).toHaveSignalCounts({ compute: 2, effect: 2 });
-    });
-  });
-
-  describe('with async computeds', () => {
-    test('watches async computed values', async () => {
-      const a = createStateSignal(1);
-      const b = createStateSignal(2);
-
-      const c = createAsyncComputedSignal(async () => {
-        return a.get() + b.get();
-      });
-
-      let value;
-      const w = createWatcherSignal(() => {
-        return c.get();
-      });
-
-      const unsub = w.addListener(v => {
-        value = { ...v };
-        // do something
-      });
-
-      expect(value).toEqual(undefined);
-      expect(w).toHaveSignalCounts({ compute: 0, effect: 0 });
-
-      await sleep(); // First tick to start async computation
-
-      expect(value).toEqual(result(undefined, 'pending', 'initial'));
-      expect(w).toHaveSignalCounts({ compute: 1, effect: 1 });
-
-      await nextTick(); // Extra tick for async resolution
-
-      expect(value).toEqual(result(3, 'success', 'resolved'));
-      expect(w).toHaveSignalCounts({ compute: 2, effect: 2 });
-
-      a.set(2);
-
-      await sleep(); // First tick to start async computation
-
-      expect(value).toEqual(result(3, 'pending', 'resolved'));
-      expect(w).toHaveSignalCounts({ compute: 3, effect: 3 });
-
-      await nextTick(); // Extra tick for async resolution
-
-      expect(value).toEqual(result(4, 'success', 'resolved'));
-      expect(w).toHaveSignalCounts({ compute: 4, effect: 4 });
-
-      unsub();
-    });
-
-    test('immediate option works', async () => {
-      const a = createStateSignal(1);
-      const b = createStateSignal(2);
-
-      const c = createAsyncComputedSignal(async () => {
-        return a.get() + b.get();
-      });
-
-      const w = createWatcherSignal(() => {
-        return c.get();
-      });
-
-      let value;
-      w.addListener(
-        v => {
-          value = { ...v };
-          // do something
-        },
-        {
-          immediate: true,
-        },
-      );
-
-      expect(value).toEqual(result(undefined, 'pending', 'initial'));
-      expect(w).toHaveSignalCounts({ compute: 1, effect: 1 });
-
-      await nextTick(); // Extra tick for async resolution
-
-      expect(value).toEqual(result(3, 'success', 'resolved'));
-      expect(w).toHaveSignalCounts({ compute: 2, effect: 2 });
-
-      a.set(2);
-
-      await sleep(); // First tick to start async computation
-
-      expect(value).toEqual(result(3, 'pending', 'resolved'));
-      expect(w).toHaveSignalCounts({ compute: 3, effect: 3 });
-
-      await nextTick(); // Extra tick for async resolution
-
-      expect(value).toEqual(result(4, 'success', 'resolved'));
-      expect(w).toHaveSignalCounts({ compute: 4, effect: 4 });
-    });
-  });
-
-  describe('with subscriptions', () => {
-    test('watches subscription values', async () => {
-      let value = createStateSignal(1);
-
-      const s = createSubscriptionSignal(({ get, set }) => {
-        set(value.get());
-
-        return {
-          update() {
-            set(value.get());
-          },
-        };
-      });
-
-      let watchedValue;
-      const w = createWatcherSignal(() => {
-        watchedValue = s.get();
-      });
-
-      w.addListener(() => {
-        // do something
-      });
-
-      expect(watchedValue).toBe(undefined);
-      expect(w).toHaveSignalCounts({ compute: 0, effect: 0 });
-      expect(s).toHaveSignalValueAndCounts(undefined, { subscribe: 0 });
-
-      await nextTick();
-
-      expect(watchedValue).toBe(1);
-      expect(w).toHaveSignalCounts({ compute: 1, effect: 1 });
-      expect(s).toHaveSignalValueAndCounts(1, { subscribe: 1 });
-
-      value.set(2);
-      s.get();
-
-      await nextTick();
-
-      expect(watchedValue).toBe(2);
-      expect(w).toHaveSignalCounts({ compute: 2, effect: 2 });
-      expect(s).toHaveSignalValueAndCounts(2, { subscribe: 1 });
-    });
-
-    test('immediate option works', async () => {
-      let value = createStateSignal(1);
-
-      const s = createSubscriptionSignal(({ get, set }) => {
-        set(value.get());
-
-        return {
-          update() {
-            set(value.get());
-          },
-        };
-      });
-
-      let watchedValue;
-      const w = createWatcherSignal(() => {
-        watchedValue = s.get();
-      });
-
-      w.addListener(
-        () => {
-          // do something
-        },
-        { immediate: true },
-      );
-
-      expect(watchedValue).toBe(1);
-      expect(w).toHaveSignalCounts({ compute: 1, effect: 1 });
-      expect(s).toHaveSignalValueAndCounts(1, { subscribe: 1 });
-
-      value.set(2);
-      s.get();
-
-      await nextTick();
-
-      expect(watchedValue).toBe(2);
-      expect(w).toHaveSignalCounts({ compute: 2, effect: 2 });
-      expect(s).toHaveSignalValueAndCounts(2, { subscribe: 1 });
-    });
-  });
-});

package/src/__tests__/utils/builders.ts

@@ -1,22 +0,0 @@
-import { expect } from 'vitest';
-import { AsyncResult } from '../../types.js';
-
-export const result = <T>(
-  value: T | undefined,
-  promiseState: 'pending' | 'error' | 'success',
-  readyState: 'initial' | 'ready' | 'resolved',
-  error?: any,
-): AsyncResult<T> =>
-  ({
-    result: value,
-    error,
-    isPending: promiseState === 'pending',
-    isError: promiseState === 'error',
-    isSuccess: promiseState === 'success',
-
-    isReady: readyState === 'ready' || readyState === 'resolved',
-    didResolve: readyState === 'resolved',
-
-    await: expect.any(Function),
-    invalidate: expect.any(Function),
-  }) as AsyncResult<T>;

package/src/__tests__/utils/instrumented-signals.ts

@@ -1,291 +0,0 @@
-import { expect, beforeEach, afterEach, vi } from 'vitest';
-import {
-  createStateSignal as _createStateSignal,
-  createComputedSignal as _createComputedSignal,
-  createAsyncComputedSignal as _createAsyncComputedSignal,
-  createSubscriptionSignal as _createSubscriptionSignal,
-  createWatcherSignal as _createWatcherSignal,
-  SignalOptions,
-  Signal,
-  WriteableSignal,
-  SignalSubscription,
-  Watcher,
-} from '../../index.js';
-
-class SignalCounts {
-  name: string;
-
-  get = 0;
-  set = 0;
-  compute = 0;
-
-  resolve = 0;
-
-  subscribe = 0;
-  update = 0;
-  unsubscribe = 0;
-  internalGet = 0;
-  internalSet = 0;
-
-  effect = 0;
-
-  constructor(name: string) {
-    this.name = name;
-  }
-}
-
-const countsKeys = Object.keys(new SignalCounts('')).filter(k => k !== 'name') as (keyof SignalCounts)[];
-
-let currentOrder: string[] | undefined = [];
-const COUNTS = new WeakMap<Signal<any> | Watcher<any>, SignalCounts>();
-
-interface CustomMatchers<R = unknown> {
-  toHaveSignalValue: (v: any) => R;
-  toHaveSignalCounts: (counts: Partial<SignalCounts>) => R;
-  toHaveSignalValueAndCounts: (v: any, counts: Partial<SignalCounts>) => R;
-  toHaveComputedOrder: (order: string[]) => R;
-}
-
-declare module 'vitest' {
-  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-  interface Assertion<T = any> extends CustomMatchers<T> {}
-  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-  interface AsymmetricMatchersContaining extends CustomMatchers {}
-}
-
-function toHaveSignalValue(this: { equals(a: unknown, b: unknown): boolean }, signal: Signal<any>, value: any) {
-  const signalValue = signal.get();
-
-  return {
-    pass: this.equals(signalValue, value),
-    message: () => `Expected signal value to be ${JSON.stringify(value)}, but got ${JSON.stringify(signalValue)}`,
-  };
-}
-
-function toHaveSignalCounts(signal: Signal<any>, counts: SignalCounts) {
-  const signalCounts = COUNTS.get(signal);
-
-  if (!signalCounts) {
-    return {
-      pass: false,
-      message: () => 'Signal not found in counts map',
-    };
-  }
-
-  for (const key of countsKeys) {
-    const count = counts[key];
-
-    if (count !== undefined && signalCounts[key] !== count) {
-      return {
-        pass: false,
-        message: () => `Expected ${key} count to be ${count} but got ${signalCounts[key]}`,
-      };
-    }
-  }
-
-  return {
-    pass: true,
-    message: () => 'Counts match',
-  };
-}
-
-expect.extend({
-  toHaveSignalValue,
-  toHaveSignalCounts,
-
-  toHaveSignalValueAndCounts(signal, value, counts) {
-    const valueResult = toHaveSignalValue.call(this, signal, value);
-    const countsResult = toHaveSignalCounts.call(this, signal, counts);
-
-    return {
-      pass: valueResult.pass && countsResult.pass,
-      message: () => {
-        const messages = [
-          !valueResult.pass && valueResult.message(),
-          !countsResult.pass && countsResult.message(),
-        ].filter(m => m);
-
-        return messages.join('\n');
-      },
-    };
-  },
-
-  toHaveComputedOrder(fn: () => void, expectedOrder: string[]) {
-    const order = (currentOrder = []);
-
-    fn();
-
-    currentOrder = undefined;
-
-    return {
-      pass: this.equals(order, expectedOrder),
-      message: () => `Expected compute count to be ${expectedOrder.toString()} but got ${order.toString()}`,
-    };
-  },
-});
-
-export const createStateSignal = <T>(initialValue: T, opts?: SignalOptions<T, []>): WriteableSignal<T> => {
-  const desc = opts?.desc || 'unlabeled';
-  const s = _createStateSignal(initialValue, opts);
-
-  const counts = new SignalCounts(desc);
-
-  const wrapper = {
-    get() {
-      counts.get++;
-      return s.get();
-    },
-
-    set(value: T) {
-      counts.set++;
-      s.set(value);
-    },
-  };
-
-  COUNTS.set(wrapper, counts);
-
-  return wrapper;
-};
-
-export const createComputedSignal: typeof _createComputedSignal = (compute, opts) => {
-  const desc = opts?.desc || 'unlabeled';
-  const counts = new SignalCounts(desc);
-
-  const s = _createComputedSignal(v => {
-    counts.compute++;
-
-    if (desc) {
-      currentOrder?.push(desc);
-    }
-
-    return compute(v);
-  }, opts);
-
-  const wrapper = {
-    get() {
-      counts.get++;
-
-      // Get twice to ensure idempotency
-      s.get();
-
-      return s.get();
-    },
-  };
-
-  COUNTS.set(wrapper, counts);
-
-  return wrapper;
-};
-
-export const createAsyncComputedSignal: typeof _createAsyncComputedSignal = (compute, opts) => {
-  const desc = opts?.desc || 'unlabeled';
-  const counts = new SignalCounts(desc);
-
-  const s = _createAsyncComputedSignal(async v => {
-    counts.compute++;
-
-    if (desc) {
-      currentOrder?.push(desc);
-    }
-
-    const result = await compute(v);
-
-    counts.resolve++;
-
-    return result;
-  }, opts);
-
-  const wrapper = {
-    get() {
-      counts.get++;
-      return s.get();
-    },
-  };
-
-  COUNTS.set(wrapper, counts);
-
-  return wrapper;
-};
-
-export const createSubscriptionSignal: typeof _createSubscriptionSignal = (subscribe, opts) => {
-  const desc = opts?.desc || 'unlabeled';
-  const counts = new SignalCounts(desc);
-
-  const s = _createSubscriptionSignal(({ get, set }) => {
-    counts.subscribe++;
-
-    if (desc) {
-      currentOrder?.push(desc);
-    }
-
-    const result = subscribe({
-      get: () => {
-        counts.internalGet++;
-        return get();
-      },
-      set: v => {
-        counts.internalSet++;
-        set(v);
-      },
-    });
-
-    let subscriptionWrapper: SignalSubscription | (() => unknown) | undefined;
-
-    if (typeof result === 'function') {
-      subscriptionWrapper = () => {
-        counts.unsubscribe++;
-        result();
-      };
-    } else {
-      subscriptionWrapper = {};
-
-      subscriptionWrapper.unsubscribe = () => {
-        counts.unsubscribe++;
-        result?.unsubscribe?.();
-      };
-
-      subscriptionWrapper.update = () => {
-        counts.compute++;
-        counts.update++;
-        result?.update?.();
-      };
-    }
-
-    return subscriptionWrapper;
-  }, opts);
-
-  const wrapper = {
-    get() {
-      counts.get++;
-      return s.get();
-    },
-  };
-
-  COUNTS.set(wrapper, counts);
-
-  return wrapper;
-};
-
-export function createWatcherSignal<T>(fn: () => T, opts?: SignalOptions<T, []>): Watcher<T> {
-  const desc = opts?.desc || 'unlabeled';
-  const counts = new SignalCounts(desc);
-
-  const w = _createWatcherSignal<T>(() => {
-    counts.compute++;
-    return fn();
-  }, opts);
-
-  const wrapper: Watcher<T> = {
-    addListener: (fn, opts) => {
-      counts.subscribe++;
-      return w.addListener(v => {
-        counts.effect++;
-        return fn(v);
-      }, opts);
-    },
-  };
-
-  COUNTS.set(wrapper, counts);
-
-  return wrapper;
-}