signalium 1.2.2 → 2.0.1

package/src/trace.ts

@@ -1,454 +0,0 @@
-import { scheduleTracer } from './internals/scheduling.js';
-import { DerivedSignal, SignalId } from './internals/derived.js';
-import { Signal } from './types.js';
-
-export let TRACER: TracerProxy | undefined;
-
-export interface VisualizerLink {
-  connected: boolean;
-  version: number;
-  node: VisualizerNode;
-}
-
-export interface TracerMeta {
-  id: string | number;
-  desc: string;
-  params: string;
-  tracer?: Tracer;
-}
-
-export enum TracerEventType {
-  StartUpdate = 'StartUpdate',
-  EndUpdate = 'EndUpdate',
-  StartLoading = 'StartLoading',
-  EndLoading = 'EndLoading',
-
-  Connected = 'Connected',
-  Disconnected = 'Disconnected',
-
-  ConsumeState = 'ConsumeState',
-}
-
-type StartUpdateEvent = {
-  type: TracerEventType.StartUpdate;
-  id: string | number;
-};
-
-type EndUpdateEvent = {
-  type: TracerEventType.EndUpdate;
-  id: string | number;
-  value: unknown;
-  preserveChildren?: boolean;
-};
-
-type StartLoadingEvent = {
-  type: TracerEventType.StartLoading;
-  id: string | number;
-};
-
-type EndLoadingEvent = {
-  type: TracerEventType.EndLoading;
-  id: string | number;
-  value: unknown;
-};
-
-type ConnectedEvent = {
-  type: TracerEventType.Connected;
-  id: string | number;
-  childId: string | number;
-  nodeType: SignalType;
-  name?: string;
-  params?: string;
-};
-
-type DisconnectedEvent = {
-  type: TracerEventType.Disconnected;
-  id: string | number;
-  childId: string | number;
-};
-
-type ConsumeStateEvent = {
-  type: TracerEventType.ConsumeState;
-  id: string | number;
-  childId: string | number;
-  value: unknown;
-  setValue: (value: unknown) => void;
-};
-
-type TracerEvent =
-  | StartUpdateEvent
-  | EndUpdateEvent
-  | StartLoadingEvent
-  | EndLoadingEvent
-  | ConnectedEvent
-  | DisconnectedEvent
-  | ConsumeStateEvent;
-
-export enum SignalType {
-  State = 'state',
-  Reactive = 'reactive',
-  Watcher = 'watcher',
-}
-
-export class VisualizerNode {
-  private subscribers: (() => void)[] = [];
-
-  private nextStateChildren: VisualizerNode[] = [];
-
-  public stateChildren: VisualizerNode[] = [];
-  public children: VisualizerLink[] = [];
-  public updating = true;
-  public loading = false;
-  public version = 0;
-
-  private updatingVersion = 0;
-  private didConnect = false;
-
-  constructor(
-    private tracer: Tracer,
-    public depth: number,
-    public type: SignalType,
-    public id: string | number,
-    public value: unknown,
-    public name?: string,
-    public params?: string,
-    private _setValue?: (value: unknown) => void,
-  ) {
-    this.tracer.maxDepth = Math.max(this.tracer.maxDepth, this.depth);
-  }
-
-  get showParams() {
-    return this.tracer.showParams;
-  }
-
-  get showValue() {
-    return this.tracer.showValue;
-  }
-
-  get interactive() {
-    return this.tracer.interactive;
-  }
-
-  setValue(value: unknown) {
-    if (this.type !== SignalType.State) {
-      throw new Error('setValue is only allowed on state nodes');
-    }
-
-    this._setValue?.(value);
-    this.notify();
-    scheduleTracer(this.tracer);
-  }
-
-  connectChild(child: VisualizerNode): boolean {
-    let childLink = this.children.find(
-      link => link.node.id === child.id || (link.node.name === child.name && link.version !== this.updatingVersion),
-    );
-
-    let shouldSkip = false;
-
-    if (childLink) {
-      if (!child.didConnect) {
-        child.value = childLink.node.value;
-        child.children = childLink.node.children.map(link => ({
-          ...link,
-          version: child.version,
-        }));
-      }
-
-      childLink.node = child;
-      childLink.connected = true;
-      childLink.version = this.updatingVersion;
-      shouldSkip = true;
-    } else {
-      this.children.push({
-        connected: true,
-        node: child,
-        version: this.updatingVersion,
-      });
-    }
-
-    child.didConnect = true;
-    this.notify();
-
-    return shouldSkip;
-  }
-
-  disconnectChild(childId: string | number) {
-    const childLink = this.children.find(link => link.node.id === childId);
-
-    if (!childLink) {
-      return;
-    }
-
-    childLink.connected = false;
-
-    this.notify();
-  }
-
-  startUpdate() {
-    this.updating = true;
-    this.updatingVersion++;
-
-    this.notify();
-  }
-
-  endUpdate(value: unknown, preserveChildren = false) {
-    this.updating = false;
-    this.value = value;
-    if (!preserveChildren) {
-      this.stateChildren = this.nextStateChildren;
-    }
-    this.nextStateChildren = [];
-    this.notify();
-  }
-
-  startLoading() {
-    this.loading = true;
-    this.notify();
-  }
-
-  endLoading(value: unknown) {
-    this.loading = false;
-    this.value = value;
-    this.notify();
-  }
-
-  consumeState(id: string | number, value: unknown, setValue: (value: unknown) => void) {
-    const existing = this.stateChildren.find(child => child.id === id);
-
-    if (existing) {
-      existing.value = value;
-      this.nextStateChildren.push(existing);
-      existing.notify();
-    } else {
-      const node = new VisualizerNode(
-        this.tracer,
-        this.depth + 1,
-        SignalType.State,
-        id,
-        value,
-        undefined,
-        undefined,
-        setValue,
-      );
-      node.updating = false;
-      this.nextStateChildren.push(node);
-    }
-  }
-
-  notify() {
-    this.version++;
-    for (const subscriber of this.subscribers) {
-      subscriber();
-    }
-  }
-
-  subscribe(subscriber: () => void) {
-    this.subscribers.push(subscriber);
-
-    return () => {
-      this.subscribers = this.subscribers.filter(s => s !== subscriber);
-    };
-  }
-}
-
-let ID = 0;
-
-class TraceFlush {
-  private forceComplete = false;
-  public promise: Promise<void>;
-  public id = ID++;
-  constructor(tracer: Tracer, queue: TracerEvent[], previousFlush?: TraceFlush) {
-    this.promise = this.runFlush(tracer, queue, previousFlush);
-  }
-
-  complete() {
-    this.forceComplete = true;
-    return this.promise;
-  }
-
-  private async runFlush(tracer: Tracer, queue: TracerEvent[], previousFlush?: TraceFlush) {
-    if (previousFlush) {
-      await previousFlush.complete();
-    }
-
-    for (let i = 0; i < queue.length; i++) {
-      const event = queue[i];
-      const nextEvent = queue[i + 1];
-
-      const skipDelay = tracer.handleEvent(event, nextEvent);
-
-      if (!this.forceComplete && !skipDelay && tracer.delay > 0 && !document.hidden) {
-        await new Promise(resolve => setTimeout(resolve, tracer.delay));
-      }
-    }
-  }
-}
-
-export class Tracer {
-  private nodeMap = new Map<string | number, VisualizerNode>();
-
-  delay = 200;
-  maxDepth = 0;
-
-  private initialized = false;
-
-  constructor(
-    id: string | number,
-    immediate = false,
-    public showParams = true,
-    public showValue = true,
-    public interactive = true,
-  ) {
-    // If it's immediate, we should run the first flush immediately, skipping animations
-    this.initialized = !immediate;
-
-    const node = new VisualizerNode(this, 0, SignalType.Watcher, id, '');
-
-    this.rootNode = node;
-    this.nodeMap.set(id, node);
-  }
-
-  public rootNode: VisualizerNode;
-
-  private eventQueue: TracerEvent[] = [];
-  private currentFlush: TraceFlush | undefined;
-
-  emit(event: TracerEvent) {
-    if (event.type === TracerEventType.Connected || event.type === TracerEventType.ConsumeState) {
-      const node = this.nodeMap.get(event.id);
-
-      if (!node || (event.type === TracerEventType.Connected && !event.name)) {
-        return;
-      }
-
-      if (!this.nodeMap.has(event.childId)) {
-        const name = event.type === TracerEventType.Connected ? event.name : undefined;
-        const params = event.type === TracerEventType.Connected ? event.params : undefined;
-        const nodeType = event.type === TracerEventType.Connected ? event.nodeType : SignalType.State;
-
-        this.nodeMap.set(
-          event.childId,
-          new VisualizerNode(this, node.depth + 1, nodeType, event.childId, '', name, params),
-        );
-      }
-    }
-
-    if (this.initialized) {
-      this.eventQueue.push(event);
-    } else {
-      this.handleEvent(event);
-    }
-  }
-
-  handleEvent(event: TracerEvent, nextEvent?: TracerEvent) {
-    const node = this.nodeMap.get(event.id);
-
-    if (!node) {
-      return true;
-    }
-
-    let skipDelay = nextEvent?.type === TracerEventType.StartLoading;
-
-    if (event.type === TracerEventType.Connected) {
-      let child = this.nodeMap.get(event.childId);
-
-      if (!child) {
-        throw new Error(`Child node ${event.childId} not found`);
-      }
-
-      skipDelay = node.connectChild(child);
-    } else if (event.type === TracerEventType.Disconnected) {
-      node.disconnectChild(event.childId);
-    } else if (event.type === TracerEventType.StartUpdate) {
-      node.startUpdate();
-      if (
-        nextEvent &&
-        nextEvent.id === event.id &&
-        (nextEvent.type === TracerEventType.EndUpdate || nextEvent.type === TracerEventType.StartLoading)
-      ) {
-        skipDelay = true;
-      }
-    } else if (event.type === TracerEventType.EndUpdate) {
-      node.endUpdate(event.value, event.preserveChildren);
-    } else if (event.type === TracerEventType.StartLoading) {
-      node.startLoading();
-      skipDelay = true;
-    } else if (event.type === TracerEventType.EndLoading) {
-      node.endLoading(event.value);
-    } else if (event.type === TracerEventType.ConsumeState) {
-      node.consumeState(event.childId, event.value, event.setValue);
-    }
-
-    return skipDelay;
-  }
-
-  async flush() {
-    if (this.eventQueue.length === 0) {
-      return;
-    }
-
-    this.currentFlush = new TraceFlush(this, this.eventQueue, this.currentFlush);
-    this.eventQueue = [];
-  }
-
-  addListener(listener: () => void) {
-    this.initialized = true;
-    return this.rootNode.subscribe(listener);
-  }
-}
-
-class TracerProxy {
-  private tracers: Tracer[] = [];
-
-  constructor() {}
-
-  emit(event: TracerEvent) {
-    this.tracers.forEach(tracer => tracer.emit(event));
-  }
-
-  createTracer(id: string | number, immediate = false): Tracer {
-    const tracer = new Tracer(id, immediate);
-
-    this.tracers.push(tracer);
-
-    return tracer;
-  }
-
-  removeTracer(tracer: Tracer) {
-    this.tracers = this.tracers.filter(t => t !== tracer);
-  }
-
-  flush() {
-    this.tracers.forEach(tracer => tracer.flush());
-  }
-}
-
-export function setTracing(enabled: boolean) {
-  if (enabled) {
-    TRACER = new TracerProxy();
-  } else {
-    TRACER = undefined;
-  }
-}
-
-export function createTracer(_signal: Signal<unknown>, immediate = false) {
-  const signal = _signal as unknown as DerivedSignal<unknown, unknown[]>;
-  return createTracerFromId(signal.tracerMeta!.id, immediate);
-}
-
-export function createTracerFromId(id: string | number, immediate = false) {
-  if (!TRACER) {
-    throw new Error('Tracing is not enabled');
-  }
-
-  return TRACER.createTracer(id, immediate);
-}
-
-export function removeTracer(tracer: Tracer) {
-  if (!TRACER) {
-    throw new Error('Tracing is not enabled');
-  }
-
-  TRACER.removeTracer(tracer);
-}

package/src/transform.ts

@@ -1,113 +0,0 @@
-import type { NodePath, PluginObj, types as t } from '@babel/core';
-
-export interface SignaliumAsyncTransformOptions {
-  transformedImports: [string, string | RegExp][];
-}
-
-export function signaliumAsyncTransform(opts?: SignaliumAsyncTransformOptions): (api: any) => PluginObj {
-  const transformedImports: Record<string, [string | RegExp]> = {
-    callback: ['signalium'],
-    reactive: ['signalium'],
-    subscription: ['signalium'],
-    task: ['signalium'],
-  };
-
-  for (const [name, path] of opts?.transformedImports ?? []) {
-    const existing = transformedImports[name];
-
-    if (existing) {
-      existing.push(path);
-    } else {
-      transformedImports[name] = [path];
-    }
-  }
-
-  return api => {
-    const t = api.types;
-
-    const isReactiveCall = (path: any) => {
-      if (!t.isCallExpression(path.node)) return false;
-      const callee = path.node.callee;
-
-      const importPath = transformedImports[callee.name];
-
-      if (!importPath) return false;
-
-      // Check if reactive is imported from signalium
-      const binding = path.scope.getBinding(callee.name);
-      if (!binding || !t.isImportSpecifier(binding.path.node)) return false;
-
-      const importDecl = binding.path.parent;
-
-      if (!t.isImportDeclaration(importDecl)) return false;
-
-      return importPath.some(p =>
-        typeof p === 'string' ? importDecl.source.value === p : p.test(importDecl.source.value),
-      );
-    };
-
-    function convertReactiveToGenerator(path: NodePath<t.FunctionExpression | t.ArrowFunctionExpression>) {
-      // Only transform if parent is a reactive() call
-      const parentPath = path.parentPath;
-      if (!isReactiveCall(parentPath)) return;
-      if (!path.node.async) return;
-
-      // Transform all await expressions to yields
-      path.traverse({
-        AwaitExpression(awaitPath) {
-          const funcParent = awaitPath.getFunctionParent();
-          if (funcParent?.node !== path.node) return;
-
-          awaitPath.replaceWith(t.yieldExpression(awaitPath.node.argument));
-        },
-      });
-
-      // Remove async keyword
-      path.node.async = false;
-
-      if (t.isArrowFunctionExpression(path.node)) {
-        // Convert arrow function to regular function expression
-        let hasThis = false;
-
-        // Scan for this keywords
-        path.traverse({
-          ThisExpression() {
-            hasThis = true;
-          },
-        });
-
-        const functionBody = t.isBlockStatement(path.node.body)
-          ? path.node.body
-          : t.blockStatement([t.returnStatement(path.node.body)]);
-
-        const newFunction = t.functionExpression(
-          null,
-          path.node.params,
-          functionBody,
-          true, // generator
-          false, // async
-        );
-
-        // If we found 'this' usage, wrap in bind call
-        if (hasThis) {
-          path.replaceWith(
-            t.callExpression(t.memberExpression(newFunction, t.identifier('bind')), [t.thisExpression()]),
-          );
-        } else {
-          path.replaceWith(newFunction);
-        }
-      } else {
-        // Regular function - just set generator flag
-        path.node.generator = true;
-      }
-    }
-
-    return {
-      name: 'transform-reactive-async',
-      visitor: {
-        FunctionExpression: convertReactiveToGenerator,
-        ArrowFunctionExpression: convertReactiveToGenerator,
-      },
-    };
-  };
-}

package/src/types.ts

@@ -1,115 +0,0 @@
-import { SignalScope } from './internals/contexts.js';
-
-export interface Signal<T = unknown> {
-  get(): T;
-  addListener(listener: SignalListener): () => void;
-}
-
-export interface StateSignal<T> extends Signal<T> {
-  set(value: T): void;
-  peek(): T;
-  update(updater: (value: T) => T): void;
-}
-
-/**
- * @deprecated Use `StateSignal` instead.
- */
-export type WriteableSignal<T> = StateSignal<T>;
-
-export type SignalEquals<T> = (prev: T, next: T) => boolean;
-
-export type SignalListener = () => void;
-
-export type SignalSubscription = {
-  update?(): void;
-  unsubscribe?(): void;
-};
-
-export interface SubscriptionState<T> {
-  get: () => T | undefined;
-  set: (value: T | Promise<T>) => void;
-  setError: (error: unknown) => void;
-}
-
-export type SignalSubscribe<T> = (
-  state: SubscriptionState<T>,
-) => SignalSubscription | (() => unknown) | undefined | void;
-
-export interface SignalOptions<T, Args extends unknown[]> {
-  equals?: SignalEquals<T> | false;
-  id?: string;
-  desc?: string;
-  scope?: SignalScope;
-  paramKey?: (...args: Args) => string;
-
-  /**
-   * Called when signal's watchCount reaches 0.
-   * Return `true` to allow GC, `false` to prevent it.
-   * If not provided, defaults to always allowing GC.
-   */
-  shouldGC?: (signal: object, value: T, args: Args) => boolean;
-}
-
-export interface SignalOptionsWithInit<T, Args extends unknown[]> extends SignalOptions<T, Args> {
-  initValue: T extends Promise<infer U> ? U : T extends Generator<any, infer U, any> ? U : T;
-}
-
-export interface Thenable<T> {
-  then(onfulfilled?: (value: T) => void, onrejected?: (reason: unknown) => void): void;
-  finally: any;
-  catch: any;
-  [Symbol.toStringTag]: string;
-}
-
-export interface BaseReactivePromise<T> extends Promise<T> {
-  value: T | undefined;
-  error: unknown;
-
-  isPending: boolean;
-  isRejected: boolean;
-  isResolved: boolean;
-  isSettled: boolean;
-  isReady: boolean;
-
-  rerun(): void;
-}
-
-export interface PendingReactivePromise<T> extends BaseReactivePromise<T> {
-  value: undefined;
-  isReady: false;
-}
-
-export interface ReadyReactivePromise<T> extends BaseReactivePromise<T> {
-  value: T;
-  isReady: true;
-}
-
-export type ReactivePromise<T> = PendingReactivePromise<T> | ReadyReactivePromise<T>;
-
-export type ReactiveTask<T, Args extends unknown[]> = Omit<ReactivePromise<T>, 'notify'> & {
-  run(...args: Args): ReactivePromise<T>;
-};
-
-export type ReactiveSubscription<T> = Omit<ReactivePromise<T>, 'rerun'>;
-
-export type ReactiveValue<T> =
-  // We have to first check if T is a ReactiveTask, because it will also match Promise<T>
-  T extends ReactiveTask<infer U, infer Args>
-    ? ReactiveTask<U, Args>
-    : T extends Promise<infer U>
-      ? ReactivePromise<U>
-      : T extends Generator<any, infer U>
-        ? ReactivePromise<U>
-        : T;
-
-// This type is used when initial values are provided to async functions and
-// subscriptions. It allows us to skip checking `isReady` when there is always
-// a guaranteed value to return.
-export type ReadyReactiveValue<T> =
-  T extends ReactiveTask<infer U, infer Args>
-    ? ReactiveTask<U, Args>
-    : T extends Promise<infer U>
-      ? ReadyReactivePromise<U>
-      : T extends Generator<any, infer U>
-        ? ReadyReactivePromise<U>
-        : T;

package/src/weakref.ts

@@ -1,9 +0,0 @@
-class WeakRefPolyfill<T extends WeakKey> {
-  constructor(private value: T) {}
-
-  deref(): T {
-    return this.value;
-  }
-}
-
-export default typeof WeakRef === 'function' ? WeakRef : (WeakRefPolyfill as unknown as WeakRefConstructor);

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "dist/esm",
-    "rootDir": "src",
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "jsx": "react-jsx"
-  },
-  "include": ["src"],
-  "exclude": ["**/__tests__"]
-}