signalium 1.2.2 → 2.0.0

package/src/internals/get.ts

@@ -1,298 +0,0 @@
-import { scheduleListeners, scheduleTracer, scheduleUnwatch, setResolved } from './scheduling.js';
-import { SignalType, TRACER as TRACER, TracerEventType } from '../trace.js';
-import { DerivedSignal, SignalFlags, SignalState } from './derived.js';
-import { createEdge, Edge, EdgeType } from './edge.js';
-import { watchSignal } from './connect.js';
-import { ReactivePromise } from './async.js';
-import { ReactiveValue } from '../types.js';
-import { isGeneratorResult, isPromise, isReactivePromise } from './utils/type-utils.js';
-
-export let CURRENT_CONSUMER: DerivedSignal<any, any> | undefined;
-
-export function getSignal<T, Args extends unknown[]>(signal: DerivedSignal<T, Args>): ReactiveValue<T> {
-  if (CURRENT_CONSUMER !== undefined) {
-    const { ref, computedCount, deps } = CURRENT_CONSUMER;
-    const prevEdge = deps.get(signal);
-
-    const prevConsumedAt = prevEdge?.consumedAt;
-
-    if (prevConsumedAt !== computedCount) {
-      if (prevEdge === undefined) {
-        TRACER?.emit({
-          type: TracerEventType.Connected,
-          id: CURRENT_CONSUMER.tracerMeta!.id,
-          childId: signal.tracerMeta!.id,
-          name: signal.tracerMeta!.desc,
-          params: signal.tracerMeta!.params,
-          nodeType: SignalType.Reactive,
-        });
-
-        if (CURRENT_CONSUMER.watchCount > 0) {
-          watchSignal(signal);
-        }
-      }
-
-      const updatedAt = checkSignal(signal);
-      const newEdge = createEdge(prevEdge, EdgeType.Signal, signal, updatedAt, computedCount);
-
-      signal.subs.set(ref, newEdge);
-      deps.set(signal, newEdge);
-    }
-  } else {
-    checkSignal(signal);
-  }
-
-  return signal.value as ReactiveValue<T>;
-}
-
-export function checkSignal(signal: DerivedSignal<any, any>): number {
-  let { ref, _state: state } = signal;
-
-  if (state < SignalState.Dirty) {
-    return signal.updatedCount;
-  }
-
-  if (state === SignalState.MaybeDirty) {
-    let edge: Edge | undefined = signal.dirtyHead;
-
-    while (edge !== undefined) {
-      if (edge.type === EdgeType.Promise) {
-        const dep = edge.dep;
-
-        // If the dependency is pending, then we need to propagate the pending state to the
-        // parent signal, and we halt the computation here.
-        if (dep.isPending) {
-          const value = signal.value;
-
-          if (value instanceof ReactivePromise) {
-            // Propagate the pending state to the parent signal
-            value._setPending();
-          }
-
-          // Add the signal to the awaitSubs map to be notified when the promise is resolved
-          dep._awaitSubs.set(ref, edge);
-
-          state = SignalState.Pending;
-          signal.dirtyHead = edge;
-
-          // Early return to prevent the signal from being computed and to preserve the dirty state
-          return signal.updatedCount;
-        }
-
-        edge = edge.nextDirty;
-        continue;
-      }
-
-      const dep = edge.dep;
-      const updatedAt = checkSignal(dep);
-
-      dep.subs.set(ref, edge);
-
-      if (edge.updatedAt !== updatedAt) {
-        signal.dirtyHead = edge.nextDirty;
-        state = SignalState.Dirty;
-        break;
-      }
-
-      edge = edge.nextDirty;
-    }
-  }
-
-  if (state === SignalState.Dirty) {
-    runSignal(signal);
-  }
-
-  signal._state = SignalState.Clean;
-  signal.dirtyHead = undefined;
-
-  if (TRACER !== undefined && signal.tracerMeta?.tracer) {
-    scheduleTracer(signal.tracerMeta.tracer);
-  }
-
-  return signal.updatedCount;
-}
-
-export function runSignal(signal: DerivedSignal<any, any[]>) {
-  TRACER?.emit({
-    type: TracerEventType.StartUpdate,
-    id: signal.tracerMeta!.id,
-  });
-
-  const prevConsumer = CURRENT_CONSUMER;
-
-  const updatedCount = signal.updatedCount;
-  const computedCount = ++signal.computedCount;
-
-  try {
-    CURRENT_CONSUMER = signal;
-
-    const initialized = updatedCount !== 0;
-    const prevValue = signal.value;
-    let nextValue = signal.def.compute(...signal.args);
-    let valueIsPromise = false;
-
-    if (nextValue !== null && typeof nextValue === 'object') {
-      if (isGeneratorResult(nextValue)) {
-        nextValue = generatorResultToPromise(nextValue, signal);
-        valueIsPromise = true;
-      } else if (isPromise(nextValue)) {
-        valueIsPromise = true;
-      }
-    }
-
-    if (valueIsPromise) {
-      if (TRACER !== undefined) {
-        TRACER.emit({
-          type: TracerEventType.StartLoading,
-          id: signal.tracerMeta!.id,
-        });
-
-        nextValue.finally(() => {
-          TRACER!.emit({
-            type: TracerEventType.EndLoading,
-            id: signal.tracerMeta!.id,
-            value: signal.value,
-          });
-        });
-      }
-
-      TRACER?.emit({
-        type: TracerEventType.StartLoading,
-        id: signal.tracerMeta!.id,
-      });
-
-      if (prevValue !== null && typeof prevValue === 'object' && isReactivePromise(prevValue)) {
-        // Update the ReactivePromise with the new promise. Since the value
-        // returned from the function is the same ReactivePromise instance,
-        // we don't need to increment the updatedCount, because the returned
-        // value is the same. _setPromise will update the nested values on the
-        // ReactivePromise instance, and consumers of those values will be notified
-        // of the change through that.
-        prevValue._setPromise(nextValue);
-      } else {
-        // If the signal has not been computed yet, we then the initValue was assigned
-        // in the constructor. Otherwise, we don't know what the initial value was, so
-        // we don't pass it to the ReactivePromise constructor.
-        const initValue = !initialized ? prevValue : undefined;
-        signal.value = ReactivePromise.createPromise(nextValue, signal, initValue);
-        signal.updatedCount = updatedCount + 1;
-      }
-    } else if (!initialized || !signal.def.equals(prevValue!, nextValue)) {
-      signal.value = nextValue;
-      signal.updatedCount = updatedCount + 1;
-    }
-  } finally {
-    CURRENT_CONSUMER = prevConsumer;
-
-    TRACER?.emit({
-      type: TracerEventType.EndUpdate,
-      id: signal.tracerMeta!.id,
-      value: signal.value,
-    });
-
-    const { ref, deps } = signal;
-
-    for (const [dep, edge] of deps) {
-      if (edge.consumedAt !== computedCount) {
-        scheduleUnwatch(dep);
-        dep.subs.delete(ref);
-        deps.delete(dep);
-
-        TRACER?.emit({
-          type: TracerEventType.Disconnected,
-          id: signal.tracerMeta!.id,
-          childId: dep.tracerMeta!.id,
-        });
-      }
-    }
-  }
-}
-
-export function checkAndRunListeners(signal: DerivedSignal<any, any>, willWatch = false) {
-  const listeners = signal.listeners;
-
-  if (willWatch && (listeners === null || listeners.current.size === 0)) {
-    signal.watchCount++;
-    signal['flags'] |= SignalFlags.isListener;
-  }
-
-  let updatedCount = checkSignal(signal);
-
-  if (listeners !== null && listeners.updatedAt !== updatedCount) {
-    listeners.updatedAt = updatedCount;
-
-    scheduleListeners(signal);
-  }
-
-  return updatedCount;
-}
-
-export function callback<T, Args extends unknown[]>(fn: (...args: Args) => T): (...args: Args) => T {
-  const savedConsumer = CURRENT_CONSUMER;
-
-  return (...args) => {
-    const prevConsumer = CURRENT_CONSUMER;
-    CURRENT_CONSUMER = savedConsumer;
-
-    try {
-      const result = fn(...args);
-
-      if (result !== null && typeof result === 'object' && isGeneratorResult(result)) {
-        return generatorResultToPromise(result, savedConsumer) as T;
-      }
-
-      return result;
-    } finally {
-      CURRENT_CONSUMER = prevConsumer;
-    }
-  };
-}
-
-export function generatorResultToPromise<T, Args extends unknown[]>(
-  generator: Generator<any, T>,
-  savedConsumer: DerivedSignal<any, any> | undefined,
-): Promise<T> {
-  function adopt(value: any) {
-    return typeof value === 'object' && value !== null && (isPromise(value) || isReactivePromise(value))
-      ? value
-      : Promise.resolve(value);
-  }
-
-  return new Promise((resolve, reject) => {
-    function step(result: any) {
-      if (result.done) {
-        resolve(result.value);
-      } else {
-        adopt(result.value).then(fulfilled, rejected);
-      }
-    }
-
-    function fulfilled(value: any) {
-      const prevConsumer = CURRENT_CONSUMER;
-
-      try {
-        CURRENT_CONSUMER = savedConsumer;
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      } finally {
-        CURRENT_CONSUMER = prevConsumer;
-      }
-    }
-
-    function rejected(value: any) {
-      const prevConsumer = CURRENT_CONSUMER;
-
-      try {
-        CURRENT_CONSUMER = savedConsumer;
-        step(generator['throw'](value));
-      } catch (e) {
-        reject(e);
-      } finally {
-        CURRENT_CONSUMER = prevConsumer;
-      }
-    }
-
-    step(generator.next());
-  });
-}

package/src/internals/scheduling.ts

@@ -1,160 +0,0 @@
-import { scheduleFlush as _scheduleFlush, runBatch } from '../config.js';
-import { DerivedSignal } from './derived.js';
-import { checkAndRunListeners, checkSignal } from './get.js';
-import { runListeners as runDerivedListeners } from './derived.js';
-import { runListeners as runStateListeners } from './state.js';
-import { Tracer } from '../trace.js';
-import { unwatchSignal } from './connect.js';
-import { StateSignal } from './state.js';
-import { ROOT_SCOPE, SignalScope } from './contexts.js';
-
-// Determine once at startup which scheduling function to use for GC
-const scheduleIdleCallback =
-  typeof requestIdleCallback === 'function' ? requestIdleCallback : (cb: () => void) => _scheduleFlush(cb);
-
-let PROMISE_WAS_RESOLVED = false;
-
-let PENDING_PULLS: DerivedSignal<any, any>[] = [];
-let PENDING_ASYNC_PULLS: DerivedSignal<any, any>[] = [];
-let PENDING_UNWATCH = new Map<DerivedSignal<any, any>, number>();
-let PENDING_LISTENERS: (DerivedSignal<any, any> | StateSignal<any>)[] = [];
-let PENDING_TRACERS: Tracer[] = [];
-let PENDING_GC = new Set<SignalScope>();
-
-const microtask = () => Promise.resolve();
-
-let currentFlush: { promise: Promise<void>; resolve: () => void } | null = null;
-
-const scheduleFlush = (fn: () => void) => {
-  if (currentFlush) return;
-
-  let resolve: () => void;
-  const promise = new Promise<void>(r => (resolve = r));
-
-  currentFlush = { promise, resolve: resolve! };
-
-  _scheduleFlush(flushWatchers);
-};
-
-export const setResolved = () => {
-  PROMISE_WAS_RESOLVED = true;
-};
-
-export const schedulePull = (signal: DerivedSignal<any, any>) => {
-  PENDING_PULLS.push(signal);
-  scheduleFlush(flushWatchers);
-};
-
-export const scheduleAsyncPull = (signal: DerivedSignal<any, any>) => {
-  PENDING_ASYNC_PULLS.push(signal);
-  scheduleFlush(flushWatchers);
-};
-
-export const scheduleUnwatch = (unwatch: DerivedSignal<any, any>) => {
-  const current = PENDING_UNWATCH.get(unwatch) ?? 0;
-
-  PENDING_UNWATCH.set(unwatch, current + 1);
-
-  scheduleFlush(flushWatchers);
-};
-
-export const scheduleListeners = (signal: DerivedSignal<any, any> | StateSignal<any>) => {
-  PENDING_LISTENERS.push(signal);
-  scheduleFlush(flushWatchers);
-};
-
-export const scheduleTracer = (tracer: Tracer) => {
-  PENDING_TRACERS.push(tracer);
-  scheduleFlush(flushWatchers);
-};
-
-export const scheduleGcSweep = (scope: SignalScope) => {
-  PENDING_GC.add(scope);
-
-  if (PENDING_GC.size > 1) return;
-
-  scheduleIdleCallback(() => {
-    for (const scope of PENDING_GC) {
-      scope.sweepGc();
-    }
-
-    PENDING_GC.clear();
-  });
-};
-
-const flushWatchers = async () => {
-  const flush = currentFlush!;
-
-  // Flush all auto-pulled signals recursively, clearing
-  // the microtask queue until they are all settled
-  while (PROMISE_WAS_RESOLVED || PENDING_ASYNC_PULLS.length > 0 || PENDING_PULLS.length > 0) {
-    PROMISE_WAS_RESOLVED = false;
-    const asyncPulls = PENDING_ASYNC_PULLS;
-
-    PENDING_ASYNC_PULLS = [];
-
-    for (const pull of asyncPulls) {
-      checkSignal(pull);
-    }
-
-    const pulls = PENDING_PULLS;
-
-    PENDING_PULLS = [];
-
-    for (const pull of pulls) {
-      checkAndRunListeners(pull);
-    }
-
-    // This is used to tell the scheduler to wait if any async values have been resolved
-    // since the last tick. If they have, we wait an extra microtask to ensure that the
-    // async values have recursivey flushed before moving on to pulling watchers.
-
-    await microtask();
-  }
-
-  // Clear the flush so that if any more watchers are scheduled,
-  // they will be flushed in the next tick
-  currentFlush = null;
-
-  runBatch(() => {
-    for (const [signal, count] of PENDING_UNWATCH) {
-      unwatchSignal(signal, count);
-    }
-
-    for (const signal of PENDING_LISTENERS) {
-      if (signal instanceof DerivedSignal) {
-        runDerivedListeners(signal as any);
-      } else {
-        runStateListeners(signal as any);
-      }
-    }
-
-    for (const tracer of PENDING_TRACERS) {
-      tracer.flush();
-    }
-
-    PENDING_UNWATCH.clear();
-    PENDING_LISTENERS = [];
-    PENDING_TRACERS = [];
-  });
-
-  // resolve the flush promise
-  flush.resolve();
-};
-
-export const settled = async () => {
-  while (currentFlush) {
-    await currentFlush.promise;
-  }
-};
-
-export const batch = (fn: () => void) => {
-  let resolve: () => void;
-  const promise = new Promise<void>(r => (resolve = r));
-
-  currentFlush = { promise, resolve: resolve! };
-
-  fn();
-  flushWatchers();
-  // flushDisconnects();
-};

package/src/internals/state.ts

@@ -1,111 +0,0 @@
-import { TRACER as TRACER, TracerEventType } from '../trace.js';
-import { SignalEquals, SignalListener, SignalOptions, StateSignal as IStateSignal } from '../types.js';
-import { DerivedSignal } from './derived.js';
-import { dirtySignal } from './dirty.js';
-import { CURRENT_CONSUMER } from './get.js';
-import { useStateSignal } from '../config.js';
-import { scheduleListeners } from './scheduling.js';
-
-let STATE_ID = 0;
-
-export class StateSignal<T> implements IStateSignal<T> {
-  private _value: T;
-  private _equals: SignalEquals<T>;
-  private _subs = new Map<WeakRef<DerivedSignal<unknown, unknown[]>>, number>();
-  _desc: string;
-  _id: number;
-
-  private _listeners: Set<SignalListener> | null = null;
-
-  constructor(value: T, equals: SignalEquals<T> = (a, b) => a === b, desc: string = 'state') {
-    this._value = value;
-    this._equals = equals;
-    this._id = STATE_ID++;
-    this._desc = `${desc}${this._id}`;
-  }
-
-  get(): T {
-    if (CURRENT_CONSUMER !== undefined) {
-      TRACER?.emit({
-        type: TracerEventType.ConsumeState,
-        id: CURRENT_CONSUMER.tracerMeta!.id,
-        childId: this._id,
-        value: this._value,
-        setValue: (value: unknown) => {
-          this.set(value as T);
-        },
-      });
-      this._subs.set(CURRENT_CONSUMER.ref, CURRENT_CONSUMER.computedCount);
-      return this._value!;
-    }
-
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    return useStateSignal(this);
-  }
-
-  update(fn: (value: T) => T) {
-    this.set(fn(this._value));
-  }
-
-  peek(): T {
-    return this._value;
-  }
-
-  set(value: T) {
-    if (this._equals(value, this._value)) {
-      return;
-    }
-
-    this._value = value;
-    const { _subs: subs, _listeners: listeners } = this;
-
-    for (const [subRef, consumedAt] of subs.entries()) {
-      const sub = subRef.deref();
-
-      if (sub === undefined || consumedAt !== sub.computedCount) {
-        continue;
-      }
-
-      dirtySignal(sub);
-    }
-
-    this._subs = new Map();
-
-    scheduleListeners(this);
-  }
-
-  addListener(listener: SignalListener): () => void {
-    let listeners = this._listeners;
-
-    if (listeners === null) {
-      this._listeners = listeners = new Set();
-    }
-
-    listeners.add(listener);
-
-    return () => listeners.delete(listener);
-  }
-}
-
-export function runListeners(signal: StateSignal<any>) {
-  const listeners = signal['_listeners'];
-
-  if (listeners === null) {
-    return;
-  }
-
-  for (const listener of listeners) {
-    listener();
-  }
-}
-
-const FALSE_EQUALS: SignalEquals<unknown> = () => false;
-
-export function createStateSignal<T>(
-  initialValue: T,
-  opts?: Omit<SignalOptions<T, unknown[]>, 'paramKey'>,
-): StateSignal<T> {
-  const equals = opts?.equals === false ? FALSE_EQUALS : (opts?.equals ?? ((a, b) => a === b));
-
-  return new StateSignal(initialValue, equals, opts?.desc);
-}

package/src/internals/utils/debug-name.ts

@@ -1,14 +0,0 @@
-let UNKNOWN_SIGNAL_ID = 0;
-const UNKNOWN_SIGNAL_NAMES = new Map<object, string>();
-
-export function getUnknownSignalFnName(fn: object) {
-  let name = UNKNOWN_SIGNAL_NAMES.get(fn);
-
-  if (name === undefined) {
-    name = `unknownSignal${UNKNOWN_SIGNAL_ID++}`;
-
-    UNKNOWN_SIGNAL_NAMES.set(fn, name);
-  }
-
-  return name;
-}

package/src/internals/utils/equals.ts

@@ -1,12 +0,0 @@
-import { SignalEquals } from '../../types.js';
-
-export const DEFAULT_EQUALS: SignalEquals<unknown> = (a, b) => a === b;
-export const FALSE_EQUALS: SignalEquals<unknown> = () => false;
-
-export const equalsFrom = <T>(equals: SignalEquals<T> | false | undefined): SignalEquals<T> => {
-  if (equals === false) {
-    return FALSE_EQUALS;
-  }
-
-  return equals ?? DEFAULT_EQUALS;
-};