signalium 0.3.8 → 1.0.0

package/src/internals/get.ts

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

@@ -0,0 +1,140 @@
+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';
+
+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[] = [];
+
+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);
+};
+
+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

@@ -0,0 +1,111 @@
+import { TRACER as TRACER, TracerEventType } from '../trace.js';
+import { ReactiveValue, SignalEquals, SignalListener, SignalOptions, WriteableSignal } from '../types.js';
+import { DerivedSignal, SignalState } 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 WriteableSignal<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

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

@@ -0,0 +1,12 @@
+import { SignalEquals } from '../../types.js';
+
+const DEFAULT_EQUALS: SignalEquals<unknown> = (a, b) => a === b;
+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;
+};