signalium 1.2.1 → 2.0.0

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

@@ -1,410 +0,0 @@
-import { afterEach, Assertion, expect } from 'vitest';
-import {
-  reactive as _reactive,
-  subscription as _subscription,
-  SignalSubscribe,
-  withContexts,
-  task as _task,
-  watcher,
-} from '../../index.js';
-import { ReactiveTask, ReactiveValue, SignalOptionsWithInit, SignalSubscription } from '../../types.js';
-import { Context, ContextImpl, getCurrentScope, ROOT_SCOPE, SignalScope } from '../../internals/contexts.js';
-import { DerivedSignal } from '../../internals/derived.js';
-import { ReactivePromise } from '../../internals/async.js';
-import { hashValue } from '../../internals/utils/hash.js';
-
-class SignalHookCounts {
-  name: string;
-
-  get = 0;
-  set = 0;
-  compute = 0;
-
-  resolve = 0;
-
-  subscribe = 0;
-  update = 0;
-  unsubscribe = 0;
-  internalGet = 0;
-  internalSet = 0;
-  error = 0;
-
-  effect = 0;
-
-  constructor(name: string) {
-    this.name = name;
-  }
-}
-
-const countsKeys = Object.keys(new SignalHookCounts('')).filter(k => k !== 'name') as (keyof SignalHookCounts)[];
-
-let currentOrder: string[] | undefined = [];
-
-type ContextPair<T extends unknown[]> = {
-  [K in keyof T]: [Context<T[K]>, NoInfer<T[K]>];
-};
-
-interface CustomMatchers<R = unknown> {
-  toHaveSignalValue: (v: any) => Assertion<R>;
-  toHaveCounts: (counts: Partial<SignalHookCounts>) => Assertion<R>;
-  toHaveValueAndCounts: (v: any, counts: Partial<SignalHookCounts>) => Assertion<R>;
-  toHaveComputedOrder: (order: string[]) => Assertion<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 {}
-}
-
-let unsubs: (() => void)[] = [];
-
-afterEach(() => {
-  unsubs.forEach(unsub => unsub());
-});
-
-let TEST_ID = 0;
-
-// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-const WATCHERS = new WeakMap<Function, DerivedSignal<unknown, unknown[]>>();
-
-// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-function getWatcherForHook(hook: Function) {
-  let w = WATCHERS.get(hook);
-
-  if (!w) {
-    w = watcher(
-      () => {
-        let result = hook();
-
-        if (result instanceof ReactivePromise) {
-          result = result.value;
-        }
-
-        return result;
-      },
-      { desc: 'test' + TEST_ID++ },
-    ) as DerivedSignal<unknown, unknown[]>;
-
-    unsubs.push(w.addListener(() => {}));
-
-    WATCHERS.set(hook, w);
-  }
-
-  return w;
-}
-
-function toHaveSignalValue(
-  this: { equals(a: unknown, b: unknown): boolean },
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-  hook: Function,
-  value: any,
-) {
-  if (hook instanceof ReactivePromise) {
-    return {
-      pass: this.equals(hook.value, value),
-      message: () =>
-        `Expected subscription value to be ${JSON.stringify(value)}, but got ${JSON.stringify(hook.value)}`,
-    };
-  }
-
-  const signalValue = getWatcherForHook(hook).get();
-
-  return {
-    pass: this.equals(signalValue, value),
-    message: () => `Expected signal value to be ${value}, but got ${signalValue}`,
-  };
-}
-
-function toHaveCounts(hook: { [COUNTS]: SignalHookCounts }, counts: SignalHookCounts) {
-  const signalCounts = hook[COUNTS];
-
-  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.addSnapshotSerializer({
-  serialize(val) {
-    const counts = val[COUNTS];
-    const value = getWatcherForHook(val).get();
-
-    return JSON.stringify([value, counts], null, 2);
-  },
-  test(val) {
-    return val[COUNTS] !== undefined;
-  },
-});
-
-expect.extend({
-  toHaveSignalValue,
-  toHaveCounts,
-
-  toHaveValueAndCounts(signal, value, counts) {
-    const valueResult = toHaveSignalValue.call(this, signal, value);
-    const countsResult = toHaveCounts.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()}`,
-    };
-  },
-});
-
-function getContextKeys(scope: SignalScope): symbol[] {
-  const contexts = scope['contexts'];
-
-  const keys = Object.getOwnPropertySymbols(contexts);
-
-  if (scope['parentScope']) {
-    return [...getContextKeys(scope['parentScope']), ...keys];
-  }
-
-  return keys;
-}
-
-function getSortedContexts(scope: SignalScope) {
-  const keys = getContextKeys(scope).sort((a, b) => a.toString().localeCompare(b.toString()));
-
-  return keys.map(key => {
-    const context = scope['contexts'][key];
-
-    return [key, context];
-  });
-}
-
-function getCountsFor(name: string, map: Map<number, SignalHookCounts>, scope: SignalScope, args: unknown[] = []) {
-  const key = hashValue([args, getSortedContexts(scope)]);
-  let countsForArgs = map.get(key);
-
-  if (!countsForArgs) {
-    countsForArgs = new SignalHookCounts(name);
-    map.set(key, countsForArgs);
-  }
-
-  return countsForArgs;
-}
-
-const COUNTS = Symbol('counts');
-
-export type SubscriptionWithCounts<T> = ReactivePromise<T> & {
-  [COUNTS]: SignalHookCounts;
-};
-
-export type ReactiveTaskWithCounts<T, Args extends unknown[]> = ReactiveTask<T, Args> & {
-  [COUNTS]: SignalHookCounts;
-};
-
-export type ReactiveFunctionWithCounts<T, Args extends unknown[]> = ((...args: Args) => ReactiveValue<T>) & {
-  [COUNTS]: SignalHookCounts;
-};
-
-export type ReactiveBuilderFunction<T, Args extends unknown[]> = ((...args: Args) => ReactiveValue<T>) & {
-  [COUNTS]: SignalHookCounts;
-  watch: () => () => void;
-  withParams: (...args: Args) => ReactiveBuilderFunction<T, []>;
-  withContexts: (...contexts: [Context<unknown>, unknown][]) => ReactiveBuilderFunction<T, Args>;
-};
-
-// Create a function-class hybrid for the builder pattern
-function createBuilderFunction<T, Args extends unknown[]>(
-  originalFn: (...args: Args) => ReactiveValue<T>,
-  countsMap: Map<number, SignalHookCounts>,
-  args: Args,
-  contexts?: [Context<unknown>, unknown][],
-): ReactiveBuilderFunction<T, []>;
-function createBuilderFunction<T, Args extends unknown[]>(
-  originalFn: (...args: Args) => ReactiveValue<T>,
-  countsMap: Map<number, SignalHookCounts>,
-  args?: undefined,
-  contexts?: [Context<unknown>, unknown][],
-): ReactiveBuilderFunction<T, Args>;
-function createBuilderFunction<T, Args extends unknown[]>(
-  originalFn: (...args: Args) => ReactiveValue<T>,
-  countsMap: Map<number, SignalHookCounts>,
-  args?: Args,
-  contexts?: [Context<unknown>, unknown][],
-): ReactiveBuilderFunction<T, Args> {
-  // Cast the function to include our additional properties
-  const builderFn = ((...passedArgs: Args) => {
-    if (args && passedArgs.length > 0) {
-      throw new Error('reactive function already has parameters');
-    }
-
-    let usedArgs = args ?? passedArgs;
-
-    const scope = getCurrentScope();
-    const counts = getCountsFor(originalFn.name, countsMap, scope, usedArgs);
-
-    // increment the get count since each time this is called, we're getting the value
-    counts.get++;
-
-    if (contexts) {
-      return withContexts(contexts, () => originalFn(...usedArgs));
-    }
-
-    return originalFn(...usedArgs);
-  }) as ReactiveBuilderFunction<T, Args>;
-
-  // Add the builder methods
-  builderFn.watch = (...args: Args) => {
-    const unsub = watcher(() => builderFn(...args)).addListener(() => {});
-    unsubs.push(unsub);
-    return unsub;
-  };
-
-  builderFn.withParams = (...withArgs: Args) => {
-    if (args) {
-      throw new Error('reactive function already has parameters');
-    }
-
-    return createBuilderFunction(originalFn, countsMap, withArgs, contexts);
-  };
-
-  builderFn.withContexts = (...withContexts: [Context<unknown>, unknown][]) => {
-    if (contexts) {
-      throw new Error('reactive function already has contexts');
-    }
-
-    return createBuilderFunction(originalFn, countsMap, args as Args, withContexts) as ReactiveBuilderFunction<T, Args>;
-  };
-
-  const scope = contexts ? ROOT_SCOPE.getChild(contexts as [ContextImpl<unknown>, unknown][]) : ROOT_SCOPE;
-  builderFn[COUNTS] = getCountsFor(originalFn.name, countsMap, scope, args);
-
-  return builderFn;
-}
-
-export function reactive<T, Args extends unknown[]>(
-  fn: (...args: Args) => T,
-  opts?: Partial<SignalOptionsWithInit<T, Args>>,
-): ReactiveBuilderFunction<T, Args> {
-  const countsMap = new Map<number, SignalHookCounts>();
-
-  return createBuilderFunction(
-    _reactive((...args: any[]) => {
-      const scope = getCurrentScope();
-      const counts = getCountsFor(opts?.desc ?? 'unknownReactive', countsMap, scope, args);
-
-      counts.compute++;
-
-      return fn(...(args as any));
-    }, opts) as ReactiveFunctionWithCounts<T, Args>,
-    countsMap,
-  );
-}
-
-export const task: typeof _task = (fn, opts) => {
-  const counts = new SignalHookCounts(opts?.desc ?? 'unknownTask');
-
-  const wrapper = _task((...args: any[]) => {
-    counts.compute++;
-
-    return fn(...(args as any));
-  }, opts) as ReactiveTaskWithCounts<any, any>;
-
-  wrapper[COUNTS] = counts;
-
-  return wrapper;
-};
-
-export const subscription = <T>(
-  fn: SignalSubscribe<T>,
-  opts?: Partial<SignalOptionsWithInit<T, unknown[]>>,
-): ReturnType<typeof _subscription<T>> => {
-  const counts = new SignalHookCounts(opts?.desc ?? 'unknownSubscription');
-
-  let wrapper = _subscription<T>(({ get, set, setError }) => {
-    counts.subscribe++;
-    counts.compute++;
-
-    const result = fn({
-      get: () => {
-        counts.internalGet++;
-        return get();
-      },
-      set: v => {
-        counts.internalSet++;
-        set(v);
-      },
-      setError: (error: unknown) => {
-        counts.error++;
-        setError(error);
-      },
-    });
-
-    let subscriptionWrapper: SignalSubscription | (() => unknown) | undefined;
-
-    if (result) {
-      if (typeof result === 'function') {
-        subscriptionWrapper = () => {
-          counts.unsubscribe++;
-          result();
-        };
-      } else {
-        subscriptionWrapper = {};
-
-        if (result.unsubscribe) {
-          subscriptionWrapper.unsubscribe = () => {
-            counts.unsubscribe++;
-            result.unsubscribe!();
-          };
-        }
-
-        if (result.update) {
-          subscriptionWrapper.update = () => {
-            counts.compute++;
-            counts.update++;
-            result.update!();
-          };
-        }
-      }
-    }
-
-    return subscriptionWrapper;
-  }, opts) as SubscriptionWithCounts<T>;
-
-  wrapper[COUNTS] = counts;
-
-  return wrapper as ReturnType<typeof _subscription<T>>;
-};

package/src/__tests__/utils/permute.ts

@@ -1,85 +0,0 @@
-import { describe } from 'vitest';
-import { ReactiveBuilderFunction, reactive, subscription } from './instrumented-hooks.js';
-import { SignalOptionsWithInit } from '../../types.js';
-
-const createMethods = [
-  {
-    name: 'createComputed',
-    create: reactive,
-  },
-  {
-    name: 'createAsyncComputed',
-    create: <T, Args extends unknown[]>(
-      fn: (...args: Args) => T | Promise<T>,
-      opts?: Partial<SignalOptionsWithInit<Promise<T>, Args>>,
-    ): ReactiveBuilderFunction<T, Args> => {
-      const computed = reactive(async (...args: Args) => {
-        return fn(...args);
-      }, opts);
-
-      return reactive((...args: Args) => {
-        return computed(...args).value as T;
-      });
-    },
-  },
-  {
-    name: 'createSubscription',
-    create: function _createSubscription<T, Args extends unknown[]>(
-      fn: (...args: Args) => T,
-      opts?: Partial<SignalOptionsWithInit<T, Args>>,
-    ): ReactiveBuilderFunction<T, Args> {
-      const computed = reactive((...args: Args) => {
-        return subscription(
-          state => {
-            state.set(fn(...args));
-
-            return {
-              update: () => {
-                state.set(fn(...args));
-              },
-            };
-          },
-          opts as Partial<SignalOptionsWithInit<T, unknown[]>>,
-        );
-      });
-
-      return reactive((...args: Args) => {
-        return computed(...args).value as T;
-      }, opts);
-    },
-  },
-];
-
-function generatePermutations(n: number, m: number): number[][] {
-  const results: number[][] = [];
-
-  function generate(current: number[], remaining: number) {
-    if (remaining === 0) {
-      results.push([...current]);
-      return;
-    }
-
-    for (let i = 0; i < n; i++) {
-      current.push(i);
-      generate(current, remaining - 1);
-      current.pop();
-    }
-  }
-
-  generate([], m);
-  return results;
-}
-
-type CreateMethod = (typeof createMethods)[number]['create'];
-
-export function permute(m: number, fn: (...args: CreateMethod[]) => void) {
-  const testCases = generatePermutations(createMethods.length, m);
-
-  for (const testCase of testCases) {
-    const testMethods = [createMethods[testCase[0]], ...testCase.slice(1).map(i => createMethods[i])];
-
-    describe(`${testMethods.map(m => m.name).join(', ')}`, () => {
-      fn(...testMethods.map(m => m.create));
-    });
-  }
-}

package/src/config.ts

@@ -1,54 +0,0 @@
-import { DerivedSignal } from './internals/derived.js';
-import { SignalScope } from './internals/contexts.js';
-import { ReactiveValue } from './types.js';
-import { StateSignal } from './internals/state.js';
-import { CURRENT_CONSUMER } from './internals/get.js';
-
-export type FlushCallback = () => void;
-
-export type FlushFn = (fn: FlushCallback) => void;
-export type BatchFn = (fn: () => void) => void;
-
-interface SignalHooksConfig {
-  scheduleFlush: FlushFn;
-  runBatch: BatchFn;
-  getFrameworkScope: () => SignalScope | undefined;
-  useStateSignal: <T>(signal: StateSignal<T>) => T;
-  useDerivedSignal: <T, Args extends unknown[]>(signal: DerivedSignal<T, Args>) => ReactiveValue<T>;
-}
-
-export let scheduleFlush: FlushFn = flushWatchers => {
-  setTimeout(() => {
-    flushWatchers();
-  }, 0);
-};
-
-export let runBatch: BatchFn = fn => fn();
-
-export let getFrameworkScope: () => SignalScope | undefined = () => undefined;
-
-let useFrameworkStateSignal: <T>(signal: StateSignal<T>) => T = signal => signal.get();
-let useFrameworkDerivedSignal: <T, Args extends unknown[]>(
-  signal: DerivedSignal<T, Args>,
-) => ReactiveValue<T> = signal => signal.get();
-
-export function useDerivedSignal<T, Args extends unknown[]>(signal: DerivedSignal<T, Args>): ReactiveValue<T> {
-  if (CURRENT_CONSUMER !== undefined) {
-    return signal.get();
-  } else {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    return useFrameworkDerivedSignal(signal);
-  }
-}
-
-export function useStateSignal<T>(signal: StateSignal<T>): T {
-  return useFrameworkStateSignal(signal);
-}
-
-export function setConfig(cfg: Partial<SignalHooksConfig>) {
-  scheduleFlush = cfg.scheduleFlush ?? scheduleFlush;
-  runBatch = cfg.runBatch ?? runBatch;
-  getFrameworkScope = cfg.getFrameworkScope ?? getFrameworkScope;
-  useFrameworkStateSignal = cfg.useStateSignal ?? useFrameworkStateSignal;
-  useFrameworkDerivedSignal = cfg.useDerivedSignal ?? useFrameworkDerivedSignal;
-}

package/src/debug.ts

@@ -1,14 +0,0 @@
-export {
-  setTracing,
-  createTracer,
-  createTracerFromId,
-  removeTracer,
-  VisualizerNode,
-  type VisualizerLink,
-  TracerEventType,
-  Tracer,
-  TRACER,
-  SignalType,
-} from './trace.js';
-
-export { scheduleTracer } from './internals/scheduling.js';

package/src/hooks.ts

@@ -1,82 +0,0 @@
-import {
-  ReactiveTask,
-  ReactiveValue,
-  ReadyReactivePromise,
-  ReadyReactiveValue,
-  Signal,
-  SignalOptions,
-  SignalSubscribe,
-  type SignalOptionsWithInit,
-} from './types.js';
-import { useDerivedSignal } from './config.js';
-import { getCurrentScope, SignalScope } from './internals/contexts.js';
-import { createStateSignal } from './internals/state.js';
-import { createDerivedSignal, DerivedSignalDefinition } from './internals/derived.js';
-import { ReactivePromise } from './internals/async.js';
-import { Tracer } from './trace.js';
-import { equalsFrom } from './internals/utils/equals.js';
-
-export const state = createStateSignal;
-
-export function reactive<T, Args extends unknown[]>(
-  fn: (...args: Args) => T,
-  opts?: Partial<SignalOptionsWithInit<T, Args>>,
-): (...args: Args) => ReactiveValue<T>;
-export function reactive<T, Args extends unknown[]>(
-  fn: (...args: Args) => T,
-  opts: SignalOptionsWithInit<T, Args>,
-): (...args: Args) => ReadyReactiveValue<T>;
-export function reactive<T, Args extends unknown[]>(
-  fn: (...args: Args) => T,
-  opts?: Partial<SignalOptionsWithInit<T, Args>>,
-): (...args: Args) => ReactiveValue<T> {
-  const def: DerivedSignalDefinition<T, Args> = {
-    compute: fn,
-    equals: equalsFrom(opts?.equals),
-    shouldGC: opts?.shouldGC,
-    isSubscription: false,
-  };
-
-  return (...args) => {
-    const scope = getCurrentScope();
-    const signal = scope.get(def, args, opts);
-
-    return useDerivedSignal(signal)!;
-  };
-}
-
-export function subscription<T>(subscribe: SignalSubscribe<T>, opts?: SignalOptions<T, unknown[]>): ReactivePromise<T>;
-export function subscription<T>(
-  subscribe: SignalSubscribe<T>,
-  opts: SignalOptionsWithInit<T, unknown[]>,
-): ReadyReactivePromise<T>;
-export function subscription<T>(
-  subscribe: SignalSubscribe<T>,
-  opts?: Partial<SignalOptionsWithInit<T, unknown[]>>,
-): ReactivePromise<T> | ReadyReactivePromise<T> {
-  const scope = getCurrentScope();
-
-  return ReactivePromise.createSubscription(subscribe, scope, opts);
-}
-
-export const task = <T, Args extends unknown[]>(
-  fn: (...args: Args) => Promise<T>,
-  opts?: Partial<SignalOptionsWithInit<T, Args>>,
-): ReactiveTask<T, Args> => {
-  const scope = getCurrentScope();
-
-  return ReactivePromise.createTask(fn, scope, opts);
-};
-
-export function watcher<T>(
-  fn: () => T,
-  opts?: SignalOptions<T, unknown[]> & { scope?: SignalScope; tracer?: Tracer },
-): Signal<ReactiveValue<T>> {
-  const def: DerivedSignalDefinition<T, unknown[]> = {
-    compute: fn,
-    equals: equalsFrom(opts?.equals),
-    isSubscription: false,
-  };
-
-  return createDerivedSignal(def, undefined, undefined, opts?.scope, opts);
-}

package/src/index.ts

@@ -1,20 +0,0 @@
-export type * from './types.js';
-
-export { state, reactive, subscription, task, watcher } from './hooks.js';
-
-export { isReactivePromise, isReactiveTask, isReactiveSubscription } from './internals/async.js';
-
-export { callback } from './internals/get.js';
-
-export {
-  createContext,
-  useContext,
-  withContexts,
-  setRootContexts,
-  SignalScope,
-  CONTEXT_KEY,
-} from './internals/contexts.js';
-
-export { setConfig } from './config.js';
-
-export { hashValue, registerCustomHash } from './internals/utils/hash.js';