@streetui/state 1.0.0

package/dist/index.js

@@ -0,0 +1,352 @@
+// src/signal.ts
+var _activeConsumer = null;
+function withConsumer(consumer, fn) {
+  const prev = _activeConsumer;
+  _activeConsumer = consumer;
+  try {
+    return fn();
+  } finally {
+    _activeConsumer = prev;
+  }
+}
+var _batchDepth = 0;
+var _pendingFlushes = /* @__PURE__ */ new Map();
+function _enqueueBatchFlush(sig, value) {
+  _pendingFlushes.set(sig, { signal: sig, value });
+}
+function _drainBatch() {
+  const flushes = [..._pendingFlushes.values()];
+  _pendingFlushes.clear();
+  for (const { signal: sig, value } of flushes) {
+    sig._flushBatch(value);
+  }
+}
+var Signal = class {
+  _value;
+  _subscribers = /* @__PURE__ */ new Set();
+  _consumers = /* @__PURE__ */ new Set();
+  constructor(initial) {
+    this._value = initial;
+  }
+  get() {
+    if (_activeConsumer !== null) {
+      this._consumers.add(_activeConsumer);
+      _activeConsumer._addSource(this);
+    }
+    return this._value;
+  }
+  peek() {
+    return this._value;
+  }
+  set(value) {
+    if (Object.is(this._value, value)) return;
+    this._value = value;
+    if (_batchDepth > 0) {
+      _enqueueBatchFlush(this, value);
+    } else {
+      this._flush(value);
+    }
+  }
+  update(fn) {
+    this.set(fn(this._value));
+  }
+  subscribe(fn) {
+    this._subscribers.add(fn);
+    return () => {
+      this._subscribers.delete(fn);
+    };
+  }
+  _removeConsumer(consumer) {
+    this._consumers.delete(consumer);
+  }
+  /**
+   * Called by the batch machinery after the batch has completed.
+   * Notifies subscribers with the final coalesced value.
+   */
+  _flushBatch(value) {
+    this._flush(value);
+  }
+  _flush(value) {
+    for (const sub of [...this._subscribers]) sub(value);
+    for (const consumer of [...this._consumers]) consumer._invalidate();
+  }
+  /**
+   * @internal DevTools inspection only. The number of live observers
+   * (direct subscribers plus derived/effect consumers). Read-only; never
+   * mutates reactive state.
+   */
+  _observerCount() {
+    return this._subscribers.size + this._consumers.size;
+  }
+};
+var DerivedSignal = class {
+  _value = void 0;
+  _dirty = true;
+  _disposed = false;
+  _fn;
+  _subscribers = /* @__PURE__ */ new Set();
+  /** All upstream sources this derived currently reads from. */
+  _sources = /* @__PURE__ */ new Set();
+  /** Downstream consumers that depend on this derived. */
+  _consumers = /* @__PURE__ */ new Set();
+  constructor(fn) {
+    this._fn = fn;
+  }
+  get() {
+    if (_activeConsumer !== null) {
+      this._consumers.add(_activeConsumer);
+      _activeConsumer._addSource(this);
+    }
+    if (this._dirty) this._recompute();
+    return this._value;
+  }
+  peek() {
+    if (this._dirty) this._recompute();
+    return this._value;
+  }
+  subscribe(fn) {
+    if (this._dirty) this._recompute();
+    this._subscribers.add(fn);
+    return () => {
+      this._subscribers.delete(fn);
+    };
+  }
+  _addSource(src) {
+    this._sources.add(src);
+  }
+  _removeConsumer(consumer) {
+    this._consumers.delete(consumer);
+  }
+  _invalidate() {
+    if (this._disposed) return;
+    this._dirty = true;
+    const newVal = this.peek();
+    for (const sub of [...this._subscribers]) sub(newVal);
+    for (const consumer of [...this._consumers]) consumer._invalidate();
+  }
+  _recompute() {
+    for (const src of this._sources) src._removeConsumer(this);
+    this._sources.clear();
+    this._value = withConsumer(this, this._fn);
+    this._dirty = false;
+  }
+  dispose() {
+    this._disposed = true;
+    for (const src of this._sources) src._removeConsumer(this);
+    this._sources.clear();
+    this._subscribers.clear();
+    this._consumers.clear();
+  }
+  /**
+   * @internal DevTools inspection only. Live observers (subscribers plus
+   * downstream consumers). Read-only.
+   */
+  _observerCount() {
+    return this._subscribers.size + this._consumers.size;
+  }
+};
+var Effect = class {
+  _fn;
+  _cleanup = void 0;
+  _disposed = false;
+  _sources = /* @__PURE__ */ new Set();
+  constructor(fn) {
+    this._fn = fn;
+    this._run();
+  }
+  _addSource(src) {
+    this._sources.add(src);
+  }
+  _invalidate() {
+    if (this._disposed) return;
+    this._run();
+  }
+  _run() {
+    for (const src of this._sources) src._removeConsumer(this);
+    this._sources.clear();
+    if (typeof this._cleanup === "function") this._cleanup();
+    const result = withConsumer(this, this._fn);
+    this._cleanup = typeof result === "function" ? result : void 0;
+  }
+  dispose() {
+    this._disposed = true;
+    for (const src of this._sources) src._removeConsumer(this);
+    this._sources.clear();
+    if (typeof this._cleanup === "function") this._cleanup();
+    this._cleanup = void 0;
+  }
+};
+function signal(initial) {
+  return new Signal(initial);
+}
+function derived(fn) {
+  return new DerivedSignal(fn);
+}
+function effect(fn) {
+  const e = new Effect(fn);
+  return () => e.dispose();
+}
+function batch(fn) {
+  _batchDepth++;
+  try {
+    fn();
+  } finally {
+    _batchDepth--;
+    if (_batchDepth === 0) {
+      _drainBatch();
+    }
+  }
+}
+function isBatching() {
+  return _batchDepth > 0;
+}
+function signalKind(source) {
+  return source instanceof DerivedSignal ? "derived" : "writable";
+}
+function observerCount(source) {
+  const maybe = source;
+  return typeof maybe._observerCount === "function" ? maybe._observerCount() : void 0;
+}
+
+// src/store.ts
+var Store = class {
+  _signals;
+  constructor(initial) {
+    const signals = {};
+    for (const key in initial) {
+      if (Object.prototype.hasOwnProperty.call(initial, key)) {
+        signals[key] = signal(initial[key]);
+      }
+    }
+    this._signals = signals;
+  }
+  get(key) {
+    const s = this._signals[key];
+    if (s === void 0) {
+      throw new Error(`Store: unknown key "${String(key)}"`);
+    }
+    return s.get();
+  }
+  set(key, value) {
+    const s = this._signals[key];
+    if (s === void 0) {
+      throw new Error(`Store: unknown key "${String(key)}"`);
+    }
+    s.set(value);
+  }
+  signal(key) {
+    const s = this._signals[key];
+    if (s === void 0) {
+      throw new Error(`Store: unknown key "${String(key)}"`);
+    }
+    return s;
+  }
+  subscribe(key, fn) {
+    return this.signal(key).subscribe(fn);
+  }
+  getSnapshot() {
+    const snap = {};
+    for (const key in this._signals) {
+      if (Object.prototype.hasOwnProperty.call(this._signals, key)) {
+        snap[key] = this._signals[key]?.peek();
+      }
+    }
+    return snap;
+  }
+};
+function createStore(initial) {
+  return new Store(initial);
+}
+
+// src/resource.ts
+function isAbortError(err) {
+  return err instanceof Error && err.name === "AbortError" || typeof DOMException !== "undefined" && err instanceof DOMException && err.name === "AbortError";
+}
+function resource(loader, options = {}) {
+  const hasInitial = options.initialData !== void 0 || options.initialError !== void 0 || options.initialStatus !== void 0;
+  const seededStatus = options.initialStatus ?? (options.initialData !== void 0 ? "success" : options.initialError !== void 0 ? "error" : "idle");
+  const status = signal(seededStatus);
+  const data = signal(options.initialData);
+  const error = signal(options.initialError);
+  const loading = derived(() => status.get() === "loading");
+  const isRefetching = derived(() => status.get() === "loading" && data.get() !== void 0);
+  let disposed = false;
+  let runId = 0;
+  let controller = null;
+  const load = async () => {
+    if (disposed) return;
+    controller?.abort();
+    const myRun = ++runId;
+    const myController = new AbortController();
+    controller = myController;
+    batch(() => {
+      error.set(void 0);
+      status.set("loading");
+    });
+    try {
+      const result = await loader({ signal: myController.signal });
+      if (disposed || myRun !== runId) return;
+      batch(() => {
+        data.set(result);
+        error.set(void 0);
+        status.set("success");
+      });
+    } catch (err) {
+      if (disposed || myRun !== runId) return;
+      if (isAbortError(err)) return;
+      batch(() => {
+        error.set(err);
+        status.set("error");
+      });
+    }
+  };
+  const refetch = () => load();
+  const watchUnsubs = [];
+  if (options.watch !== void 0) {
+    for (const dep of options.watch) {
+      watchUnsubs.push(
+        dep.subscribe(() => {
+          if (!disposed) void load();
+        })
+      );
+    }
+  }
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    controller?.abort();
+    controller = null;
+    for (const unsub of watchUnsubs) unsub();
+    watchUnsubs.length = 0;
+  };
+  if (options.onCleanup !== void 0) {
+    options.onCleanup(dispose);
+  }
+  if (options.immediate === true || options.immediate !== false && !hasInitial) {
+    void load();
+  }
+  return {
+    status,
+    data,
+    error,
+    loading,
+    isRefetching,
+    refetch,
+    dispose
+  };
+}
+export {
+  DerivedSignal,
+  Signal,
+  Store,
+  batch,
+  createStore,
+  derived,
+  effect,
+  isBatching,
+  observerCount,
+  resource,
+  signal,
+  signalKind
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/signal.ts","../src/store.ts","../src/resource.ts"],"sourcesContent":["/**\n * StreetUI reactive signals — framework-owned reactivity, no external libraries.\n *\n * Architecture:\n *   Signal<T>        — writable, holds a value, notifies on change\n *   DerivedSignal<T> — read-only, lazily computed from other signals\n *   effect()         — side-effect that re-runs when dependencies change\n *   batch()          — run multiple updates before notifying\n */\n\nexport type Subscriber<T> = (value: T) => void;\nexport type Unsubscribe = () => void;\n\n// ── Tracking ──────────────────────────────────────────────────────────────────\n\n/**\n * Any reactive source that can have downstream consumers attached.\n * Both Signal and DerivedSignal implement this.\n */\nexport interface ReactiveSource<T> {\n  get(): T;\n  peek(): T;\n  subscribe(fn: Subscriber<T>): Unsubscribe;\n  /** Internal: remove a downstream consumer. */\n  _removeConsumer(consumer: ReactiveConsumer): void;\n}\n\n/**\n * A downstream consumer (DerivedSignal or Effect) that can be invalidated\n * and can register itself as depending on a source.\n */\nexport interface ReactiveConsumer {\n  _invalidate(): void;\n  /** Internal: called by a source to register a dependency. */\n  _addSource(src: ReactiveSource<unknown>): void;\n}\n\n/** The active consumer being tracked during a computation. */\nlet _activeConsumer: ReactiveConsumer | null = null;\n\nfunction withConsumer<T>(consumer: ReactiveConsumer, fn: () => T): T {\n  const prev = _activeConsumer;\n  _activeConsumer = consumer;\n  try {\n    return fn();\n  } finally {\n    _activeConsumer = prev;\n  }\n}\n\n// ── Batch state (must be before Signal class so .set() can reference it) ──────\n\n/** Depth counter — batches nest; only the outermost flush propagates. */\nlet _batchDepth = 0;\n\ninterface PendingFlush {\n  signal: Signal<unknown>;\n  value: unknown;\n}\n\n/**\n * Keyed by signal identity — last-write-wins for each signal within a batch.\n * An ordered Map preserves first-seen insertion order for stable flush sequence.\n */\nconst _pendingFlushes = new Map<Signal<unknown>, PendingFlush>();\n\nfunction _enqueueBatchFlush(sig: Signal<unknown>, value: unknown): void {\n  _pendingFlushes.set(sig, { signal: sig, value });\n}\n\nfunction _drainBatch(): void {\n  const flushes = [..._pendingFlushes.values()];\n  _pendingFlushes.clear();\n  for (const { signal: sig, value } of flushes) {\n    sig._flushBatch(value);\n  }\n}\n\n// ── Signal ────────────────────────────────────────────────────────────────────\n\nexport interface ReadonlySignal<T> {\n  get(): T;\n  peek(): T;\n  subscribe(fn: Subscriber<T>): Unsubscribe;\n}\n\nexport class Signal<T> implements ReactiveSource<T>, ReadonlySignal<T> {\n  protected _value: T;\n  private readonly _subscribers: Set<Subscriber<T>> = new Set();\n  private readonly _consumers: Set<ReactiveConsumer> = new Set();\n\n  constructor(initial: T) {\n    this._value = initial;\n  }\n\n  get(): T {\n    if (_activeConsumer !== null) {\n      this._consumers.add(_activeConsumer);\n      _activeConsumer._addSource(this as ReactiveSource<unknown>);\n    }\n    return this._value;\n  }\n\n  peek(): T {\n    return this._value;\n  }\n\n  set(value: T): void {\n    if (Object.is(this._value, value)) return;\n    this._value = value;\n    if (_batchDepth > 0) {\n      // Defer notification until the batch flushes.\n      // The stored value is always the latest (last-write-wins for same signal).\n      _enqueueBatchFlush(this as unknown as Signal<unknown>, value);\n    } else {\n      this._flush(value);\n    }\n  }\n\n  update(fn: (current: T) => T): void {\n    this.set(fn(this._value));\n  }\n\n  subscribe(fn: Subscriber<T>): Unsubscribe {\n    this._subscribers.add(fn);\n    return () => { this._subscribers.delete(fn); };\n  }\n\n  _removeConsumer(consumer: ReactiveConsumer): void {\n    this._consumers.delete(consumer);\n  }\n\n  /**\n   * Called by the batch machinery after the batch has completed.\n   * Notifies subscribers with the final coalesced value.\n   */\n  _flushBatch(value: unknown): void {\n    this._flush(value as T);\n  }\n\n  private _flush(value: T): void {\n    for (const sub of [...this._subscribers]) sub(value);\n    for (const consumer of [...this._consumers]) consumer._invalidate();\n  }\n\n  /**\n   * @internal DevTools inspection only. The number of live observers\n   * (direct subscribers plus derived/effect consumers). Read-only; never\n   * mutates reactive state.\n   */\n  _observerCount(): number {\n    return this._subscribers.size + this._consumers.size;\n  }\n}\n\n// ── DerivedSignal ─────────────────────────────────────────────────────────────\n\nexport class DerivedSignal<T> implements ReactiveSource<T>, ReactiveConsumer, ReadonlySignal<T> {\n  private _value: T | undefined = undefined;\n  private _dirty = true;\n  private _disposed = false;\n  private readonly _fn: () => T;\n  private readonly _subscribers: Set<Subscriber<T>> = new Set();\n  /** All upstream sources this derived currently reads from. */\n  private readonly _sources: Set<ReactiveSource<unknown>> = new Set();\n  /** Downstream consumers that depend on this derived. */\n  private readonly _consumers: Set<ReactiveConsumer> = new Set();\n\n  constructor(fn: () => T) {\n    this._fn = fn;\n  }\n\n  get(): T {\n    // Register this derived with the outer consumer if any\n    if (_activeConsumer !== null) {\n      this._consumers.add(_activeConsumer);\n      _activeConsumer._addSource(this as ReactiveSource<unknown>);\n    }\n    if (this._dirty) this._recompute();\n    return this._value as T;\n  }\n\n  peek(): T {\n    if (this._dirty) this._recompute();\n    return this._value as T;\n  }\n\n  subscribe(fn: Subscriber<T>): Unsubscribe {\n    // Eagerly compute so sources track this derived as a consumer\n    if (this._dirty) this._recompute();\n    this._subscribers.add(fn);\n    return () => { this._subscribers.delete(fn); };\n  }\n\n  _addSource(src: ReactiveSource<unknown>): void {\n    this._sources.add(src);\n  }\n\n  _removeConsumer(consumer: ReactiveConsumer): void {\n    this._consumers.delete(consumer);\n  }\n\n  _invalidate(): void {\n    if (this._disposed) return;\n    this._dirty = true;\n    const newVal = this.peek(); // recompute\n    for (const sub of [...this._subscribers]) sub(newVal);\n    for (const consumer of [...this._consumers]) consumer._invalidate();\n  }\n\n  private _recompute(): void {\n    // Detach from all current sources before re-tracking\n    for (const src of this._sources) src._removeConsumer(this);\n    this._sources.clear();\n\n    this._value = withConsumer(this, this._fn);\n    this._dirty = false;\n  }\n\n  dispose(): void {\n    this._disposed = true;\n    for (const src of this._sources) src._removeConsumer(this);\n    this._sources.clear();\n    this._subscribers.clear();\n    this._consumers.clear();\n  }\n\n  /**\n   * @internal DevTools inspection only. Live observers (subscribers plus\n   * downstream consumers). Read-only.\n   */\n  _observerCount(): number {\n    return this._subscribers.size + this._consumers.size;\n  }\n}\n\n// ── effect ────────────────────────────────────────────────────────────────────\n\nclass Effect implements ReactiveConsumer {\n  private readonly _fn: () => void | (() => void);\n  private _cleanup: (() => void) | undefined = undefined;\n  private _disposed = false;\n  private readonly _sources: Set<ReactiveSource<unknown>> = new Set();\n\n  constructor(fn: () => void | (() => void)) {\n    this._fn = fn;\n    this._run();\n  }\n\n  _addSource(src: ReactiveSource<unknown>): void {\n    this._sources.add(src);\n  }\n\n  _invalidate(): void {\n    if (this._disposed) return;\n    this._run();\n  }\n\n  private _run(): void {\n    // Detach from all current sources before re-tracking\n    for (const src of this._sources) src._removeConsumer(this);\n    this._sources.clear();\n\n    if (typeof this._cleanup === 'function') this._cleanup();\n    const result = withConsumer(this, this._fn);\n    this._cleanup = typeof result === 'function' ? result : undefined;\n  }\n\n  dispose(): void {\n    this._disposed = true;\n    for (const src of this._sources) src._removeConsumer(this);\n    this._sources.clear();\n    if (typeof this._cleanup === 'function') this._cleanup();\n    this._cleanup = undefined;\n  }\n}\n\n// ── Public API ─────────────────────────────────────────────────────────────────\n\nexport function signal<T>(initial: T): Signal<T> {\n  return new Signal(initial);\n}\n\nexport function derived<T>(fn: () => T): DerivedSignal<T> {\n  return new DerivedSignal(fn);\n}\n\nexport function effect(fn: () => void | (() => void)): Unsubscribe {\n  const e = new Effect(fn);\n  return () => e.dispose();\n}\n\n/**\n * Run multiple signal updates as an atomic batch.\n *\n * Within the callback, calls to signal.set() are deferred — each signal\n * accumulates its latest value. When the outermost batch() returns,\n * each modified signal fires its subscribers exactly once with the final\n * value. Nested batch() calls are supported; the flush only runs when the\n * outermost batch exits.\n *\n * Example:\n *   batch(() => {\n *     count.set(1);\n *     count.set(2);\n *     count.set(3);\n *   });\n *   // subscribers see count = 3 exactly once\n */\nexport function batch(fn: () => void): void {\n  _batchDepth++;\n  try {\n    fn();\n  } finally {\n    _batchDepth--;\n    if (_batchDepth === 0) {\n      _drainBatch();\n    }\n  }\n}\n\n/** True when inside a batch() call. Useful for advanced scheduling integration. */\nexport function isBatching(): boolean {\n  return _batchDepth > 0;\n}\n\n// ── Inspection (read-only, DevTools-facing) ─────────────────────────────────\n\n/** Whether a signal is writable (`signal()`) or computed (`derived()`). */\nexport type SignalKind = 'writable' | 'derived';\n\n/** Classify a reactive value as writable or derived. */\nexport function signalKind(source: ReadonlySignal<unknown>): SignalKind {\n  return source instanceof DerivedSignal ? 'derived' : 'writable';\n}\n\n/**\n * The number of live observers on a signal — direct subscribers plus derived\n * or effect consumers — or `undefined` if the source does not expose the count.\n * Read-only; safe for DevTools. Never mutates reactive state.\n */\nexport function observerCount(source: ReadonlySignal<unknown>): number | undefined {\n  const maybe = source as { _observerCount?: () => number };\n  return typeof maybe._observerCount === 'function' ? maybe._observerCount() : undefined;\n}\n","/**\n * A simple reactive store built on top of signals.\n * Useful for structured state with multiple fields.\n */\n\nimport { Signal, signal, type Subscriber, type Unsubscribe } from './signal.js';\n\nexport type StoreState = Record<string, unknown>;\n\nexport class Store<T extends StoreState> {\n  private readonly _signals: Record<string, Signal<unknown>>;\n\n  constructor(initial: T) {\n    const signals: Record<string, Signal<unknown>> = {};\n    for (const key in initial) {\n      if (Object.prototype.hasOwnProperty.call(initial, key)) {\n        signals[key] = signal(initial[key] as unknown);\n      }\n    }\n    this._signals = signals;\n  }\n\n  get<K extends keyof T>(key: K): T[K] {\n    const s = this._signals[key as string];\n    if (s === undefined) {\n      throw new Error(`Store: unknown key \"${String(key)}\"`);\n    }\n    return s.get() as T[K];\n  }\n\n  set<K extends keyof T>(key: K, value: T[K]): void {\n    const s = this._signals[key as string];\n    if (s === undefined) {\n      throw new Error(`Store: unknown key \"${String(key)}\"`);\n    }\n    s.set(value as unknown);\n  }\n\n  signal<K extends keyof T>(key: K): Signal<T[K]> {\n    const s = this._signals[key as string];\n    if (s === undefined) {\n      throw new Error(`Store: unknown key \"${String(key)}\"`);\n    }\n    return s as unknown as Signal<T[K]>;\n  }\n\n  subscribe<K extends keyof T>(key: K, fn: Subscriber<T[K]>): Unsubscribe {\n    return this.signal(key).subscribe(fn);\n  }\n\n  getSnapshot(): T {\n    const snap = {} as T;\n    for (const key in this._signals) {\n      if (Object.prototype.hasOwnProperty.call(this._signals, key)) {\n        (snap as Record<string, unknown>)[key] = this._signals[key]?.peek();\n      }\n    }\n    return snap;\n  }\n}\n\nexport function createStore<T extends StoreState>(initial: T): Store<T> {\n  return new Store(initial);\n}\n","/**\n * StreetUI async resources — framework-native asynchronous data.\n *\n * A `resource` wraps a Promise-returning loader and exposes its lifecycle as\n * ordinary StreetUI signals (status / data / error), so it composes with\n * `derived`, `effect`, `when()`, `listOf` and the renderer with no second\n * reactive system.\n *\n * State machine:\n *\n *   idle ──(load)──▶ loading ──(resolve)──▶ success\n *                      │\n *                      └────(reject)──────▶ error\n *\n * Refetch keeps the previously-loaded `data` visible while `status` is\n * `'loading'` again (see `isRefetching`) — there is no separate `'refetching'`\n * status; it is expressed through `status === 'loading'` with `data` still set.\n *\n * The resource is transport-agnostic: the loader is any function returning a\n * value or a Promise. When it accepts the provided `AbortSignal`, in-flight\n * work is cancelled on `dispose()` or when a newer request supersedes it.\n */\n\nimport { signal, derived, batch, type ReadonlySignal, type Unsubscribe } from './signal.js';\n\nexport type ResourceStatus = 'idle' | 'loading' | 'success' | 'error';\n\n/** Context handed to the loader; carries an AbortSignal for cancellation. */\nexport interface ResourceLoaderContext {\n  readonly signal: AbortSignal;\n}\n\n/** Any value-or-Promise producing function. Receives an abort-aware context. */\nexport type ResourceLoader<T> = (ctx: ResourceLoaderContext) => Promise<T> | T;\n\nexport interface ResourceOptions<T = unknown> {\n  /** Load immediately on creation. Defaults to `true`. When `false`, stays `idle` until `refetch()`. */\n  readonly immediate?: boolean;\n  /**\n   * Explicit reactive dependencies. When any listed signal changes, the\n   * resource refetches. Dependencies are explicit (not auto-tracked from the\n   * loader body) so there is no risk of an accidental infinite refetch loop.\n   */\n  readonly watch?: ReadonlyArray<ReadonlySignal<unknown>>;\n  /**\n   * Optional teardown registrar (e.g. a route's `ctx.onCleanup`). When given,\n   * the resource registers its own `dispose` so it is cleaned up automatically\n   * when its owner is removed.\n   */\n  readonly onCleanup?: (fn: () => void) => void;\n  /**\n   * Server-provided initial value for hydration. When present the resource\n   * starts in `'success'` with this data already visible, and the initial\n   * auto-load is skipped (so the client does not refetch data the server\n   * already resolved). This is the client half of SSR resource transfer; the\n   * server side awaits `refetch()` before serializing. Set `immediate: true`\n   * explicitly to force a client refetch anyway.\n   */\n  readonly initialData?: T;\n  /** Server-provided initial error for hydration (mirrors `initialData`). */\n  readonly initialError?: unknown;\n  /**\n   * Explicit initial status override. Rarely needed — inferred as `'success'`\n   * from `initialData` or `'error'` from `initialError`.\n   */\n  readonly initialStatus?: ResourceStatus;\n}\n\nexport interface Resource<T> {\n  /** Reactive lifecycle status. */\n  readonly status: ReadonlySignal<ResourceStatus>;\n  /** The last successfully-loaded value, or `undefined` before first success. */\n  readonly data: ReadonlySignal<T | undefined>;\n  /** The most recent error, or `undefined` when there is none. Typed `unknown` — never `any`. */\n  readonly error: ReadonlySignal<unknown>;\n  /** Convenience: `status === 'loading'`. */\n  readonly loading: ReadonlySignal<boolean>;\n  /** Convenience: loading while previously-loaded data is still present (a refetch). */\n  readonly isRefetching: ReadonlySignal<boolean>;\n  /** Trigger a new request. Resolves when the request settles (or is superseded). */\n  refetch(): Promise<void>;\n  /** Cancel in-flight work, drop watchers, and ignore any late results. Idempotent. */\n  dispose(): void;\n}\n\n/** True for an abort we initiated (so it is not surfaced as a real error). */\nfunction isAbortError(err: unknown): boolean {\n  return (\n    err instanceof Error && err.name === 'AbortError'\n  ) || (\n    typeof DOMException !== 'undefined' && err instanceof DOMException && err.name === 'AbortError'\n  );\n}\n\nexport function resource<T>(loader: ResourceLoader<T>, options: ResourceOptions<T> = {}): Resource<T> {\n  // Seed hydrated initial state (SSR transfer). `initialStatus` wins if given,\n  // otherwise infer success/error from the provided value.\n  const hasInitial =\n    options.initialData !== undefined ||\n    options.initialError !== undefined ||\n    options.initialStatus !== undefined;\n\n  const seededStatus: ResourceStatus =\n    options.initialStatus ??\n    (options.initialData !== undefined\n      ? 'success'\n      : options.initialError !== undefined\n        ? 'error'\n        : 'idle');\n\n  const status = signal<ResourceStatus>(seededStatus);\n  const data = signal<T | undefined>(options.initialData);\n  const error = signal<unknown>(options.initialError);\n\n  const loading = derived<boolean>(() => status.get() === 'loading');\n  const isRefetching = derived<boolean>(() => status.get() === 'loading' && data.get() !== undefined);\n\n  let disposed = false;\n  /** Monotonic request id — only the newest request may write state (race guard). */\n  let runId = 0;\n  let controller: AbortController | null = null;\n\n  const load = async (): Promise<void> => {\n    if (disposed) return;\n\n    // Supersede any in-flight request: abort it and bump the run id so its\n    // eventual resolution is ignored.\n    controller?.abort();\n    const myRun = ++runId;\n    const myController = new AbortController();\n    controller = myController;\n\n    // Enter loading. Preserve `data` (so a refetch keeps showing the old value)\n    // and clear any previous error.\n    batch(() => {\n      error.set(undefined);\n      status.set('loading');\n    });\n\n    try {\n      const result = await loader({ signal: myController.signal });\n      // Ignore stale or cancelled resolutions.\n      if (disposed || myRun !== runId) return;\n      batch(() => {\n        data.set(result);\n        error.set(undefined);\n        status.set('success');\n      });\n    } catch (err) {\n      if (disposed || myRun !== runId) return;\n      // A self-initiated abort is not a user-visible error.\n      if (isAbortError(err)) return;\n      batch(() => {\n        error.set(err);\n        status.set('error');\n      });\n    }\n  };\n\n  const refetch = (): Promise<void> => load();\n\n  // Explicit reactive dependencies: refetch when any watched signal changes.\n  const watchUnsubs: Unsubscribe[] = [];\n  if (options.watch !== undefined) {\n    for (const dep of options.watch) {\n      watchUnsubs.push(\n        dep.subscribe(() => {\n          if (!disposed) void load();\n        }),\n      );\n    }\n  }\n\n  const dispose = (): void => {\n    if (disposed) return;\n    disposed = true;\n    controller?.abort();\n    controller = null;\n    for (const unsub of watchUnsubs) unsub();\n    watchUnsubs.length = 0;\n  };\n\n  if (options.onCleanup !== undefined) {\n    options.onCleanup(dispose);\n  }\n\n  // Auto-load on creation unless disabled. When hydrated initial state is\n  // present we skip the initial load by default (the server already resolved\n  // it); an explicit `immediate: true` still forces a refetch.\n  if (options.immediate === true || (options.immediate !== false && !hasInitial)) {\n    void load();\n  }\n\n  return {\n    status,\n    data,\n    error,\n    loading,\n    isRefetching,\n    refetch,\n    dispose,\n  };\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@streetui/state",
+  "version": "1.0.0",
+  "description": "StreetUI reactive state — signals, subscriptions, derived state",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {
+    "typescript": "*",
+    "tsup": "*",
+    "vitest": "*"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
+}