@qorejs/qore 0.7.0 → 0.7.2

package/src/response.js

@@ -1,312 +0,0 @@
-import { batch, computed, signal } from './signal.js';
-import { toAsyncIterable } from './iterable.js';
-import { normalizeError } from './utils.js';
-
-// Treat these states as closed so late writes cannot mutate a finished response.
-function isTerminalStatus(currentStatus) {
-  return currentStatus === 'completed' || currentStatus === 'error' || currentStatus === 'aborted';
-}
-
-// Build a response state machine that accumulates chunks into a reactive value.
-export function createResponse(options) {
-  const { seed, reduce } = options;
-
-  const status = signal('idle');
-  const value = signal(seed);
-  const error = signal(null);
-  const chunks = signal([]);
-  const startedAt = signal(null);
-  const finishedAt = signal(null);
-
-  const pending = computed(() => {
-    const currentStatus = status();
-    return currentStatus === 'pending' || currentStatus === 'streaming';
-  });
-
-  const streaming = computed(() => status() === 'streaming');
-  const completed = computed(() => status() === 'completed');
-  const failed = computed(() => status() === 'error');
-  const aborted = computed(() => status() === 'aborted');
-  const chunkCount = computed(() => chunks().length);
-
-  let activeController = null;
-  let runId = 0;
-
-  // Abort the active executor when a new run supersedes it.
-  function supersedeActiveRun(reason = 'Response superseded by a new run') {
-    if (!activeController) {
-      return;
-    }
-
-    activeController.abort(reason);
-    activeController = null;
-  }
-
-  // Reset the response to its initial seed and clear all lifecycle markers.
-  function reset(nextSeed = seed) {
-    supersedeActiveRun('Response reset');
-
-    batch(() => {
-      status('idle');
-      value(nextSeed);
-      error(null);
-      chunks([]);
-      startedAt(null);
-      finishedAt(null);
-    });
-
-    return nextSeed;
-  }
-
-  // Push a chunk through the reducer and advance the response into streaming state.
-  function push(chunk) {
-    const currentStatus = status.peek();
-
-    if (isTerminalStatus(currentStatus)) {
-      return value.peek();
-    }
-
-    const index = chunks.peek().length;
-    const nextValue = reduce(value.peek(), chunk, index);
-
-    batch(() => {
-      if (status.peek() === 'idle' || status.peek() === 'pending') {
-        status('streaming');
-      }
-
-      chunks([...chunks.peek(), chunk]);
-      value(nextValue);
-    });
-
-    return nextValue;
-  }
-
-  // Mark the response as completed and freeze the current accumulated value.
-  function complete() {
-    const currentStatus = status.peek();
-
-    if (isTerminalStatus(currentStatus)) {
-      return value.peek();
-    }
-
-    activeController = null;
-
-    batch(() => {
-      status('completed');
-      finishedAt(Date.now());
-    });
-
-    return value.peek();
-  }
-
-  // Capture an error unless the response is already closed.
-  function fail(reason) {
-    const currentStatus = status.peek();
-    const normalizedError = normalizeError(reason);
-
-    if (isTerminalStatus(currentStatus)) {
-      return currentStatus === 'error' ? error.peek() : value.peek();
-    }
-
-    activeController = null;
-
-    batch(() => {
-      status('error');
-      error(normalizedError);
-      finishedAt(Date.now());
-    });
-
-    return normalizedError;
-  }
-
-  // Abort an in-flight response while keeping the value accumulated so far.
-  function abort(reason = 'Response aborted') {
-    const currentStatus = status.peek();
-
-    if (currentStatus !== 'pending' && currentStatus !== 'streaming') {
-      return value.peek();
-    }
-
-    activeController?.abort(reason);
-    activeController = null;
-
-    batch(() => {
-      status('aborted');
-      finishedAt(Date.now());
-    });
-
-    return value.peek();
-  }
-
-  // Run an async executor and guard every lifecycle method to the active run only.
-  async function run(executor, options = {}) {
-    const { resetValue = true, nextSeed = seed } = options;
-
-    supersedeActiveRun();
-
-    runId += 1;
-    const currentRunId = runId;
-
-    const controller = new AbortController();
-    activeController = controller;
-
-    // A response may outlive older executors, so every write must prove it still owns the run.
-    const isCurrentRun = () => (
-      currentRunId === runId
-      && activeController === controller
-      && !controller.signal.aborted
-    );
-
-    batch(() => {
-      if (resetValue) {
-        value(nextSeed);
-        chunks([]);
-      }
-
-      error(null);
-      status('pending');
-      startedAt(Date.now());
-      finishedAt(null);
-    });
-
-    // Expose guarded lifecycle helpers so stale executors cannot leak writes into the latest run.
-    const context = {
-      get signal() {
-        return controller.signal;
-      },
-
-      response: api,
-      push(chunk) {
-        if (!isCurrentRun()) {
-          return value.peek();
-        }
-
-        return push(chunk);
-      },
-      complete() {
-        if (!isCurrentRun()) {
-          return value.peek();
-        }
-
-        return complete();
-      },
-      fail(reason) {
-        if (!isCurrentRun()) {
-          return status.peek() === 'error' ? error.peek() : value.peek();
-        }
-
-        return fail(reason);
-      },
-      abort(reason) {
-        if (!isCurrentRun()) {
-          return value.peek();
-        }
-
-        return abort(reason);
-      }
-    };
-
-    try {
-      await executor(context);
-
-      if (!isCurrentRun()) {
-        return value.peek();
-      }
-
-      return complete();
-    } catch (reason) {
-      if (!isCurrentRun()) {
-        return value.peek();
-      }
-
-      throw fail(reason);
-    } finally {
-      if (currentRunId === runId && activeController === controller) {
-        activeController = null;
-      }
-    }
-  }
-
-  // Consume any async iterable-like source and route each chunk through the guarded writer.
-  async function consume(source, options = {}) {
-    return run(async ({ signal: abortSignal, push: write }) => {
-      const resolvedSource = typeof source === 'function'
-        && typeof source[Symbol.asyncIterator] !== 'function'
-        && typeof source.peek !== 'function'
-        ? await source({ signal: abortSignal, response: api })
-        : await source;
-
-      for await (const chunk of toAsyncIterable(resolvedSource)) {
-        if (abortSignal.aborted) {
-          break;
-        }
-
-        write(chunk);
-      }
-    }, options);
-  }
-
-  // Return a plain snapshot suitable for inspection without exposing mutable internals.
-  function snapshot() {
-    return {
-      status: status.peek(),
-      value: value.peek(),
-      error: error.peek(),
-      chunks: [...chunks.peek()],
-      startedAt: startedAt.peek(),
-      finishedAt: finishedAt.peek(),
-      chunkCount: chunks.peek().length
-    };
-  }
-
-  const api = {
-    status,
-    value,
-    error,
-    chunks,
-    startedAt,
-    finishedAt,
-    pending,
-    streaming,
-    completed,
-    failed,
-    aborted,
-    chunkCount,
-    reset,
-    push,
-    complete,
-    fail,
-    abort,
-    run,
-    consume,
-    snapshot
-  };
-
-  return api;
-}
-
-// Ship a few common reducers as convenience constructors on top of createResponse.
-export const response = {
-  create: createResponse,
-
-  text(seed = '') {
-    return createResponse({
-      seed,
-      reduce: (currentValue, chunk) => currentValue + String(chunk)
-    });
-  },
-
-  list(seed = []) {
-    return createResponse({
-      seed,
-      reduce: (currentValue, chunk) => [...currentValue, chunk]
-    });
-  },
-
-  latest(seed = null) {
-    return createResponse({
-      seed,
-      reduce: (_, chunk) => chunk
-    });
-  }
-};

package/src/signal.js

@@ -1,328 +0,0 @@
-// Use a sentinel so signals can still store undefined as a real value.
-const READ = Symbol('qore.signal.read');
-
-let activeObserver = null;
-let batchDepth = 0;
-const pendingObservers = new Set();
-
-// Remove this observer from every dependency it tracked during the last run.
-function cleanupObserver(observer) {
-  for (const dep of observer.deps) {
-    dep.subscribers.delete(observer);
-  }
-
-  observer.deps.clear();
-}
-
-// Queue observer work during batching, otherwise notify immediately.
-function scheduleObserver(observer) {
-  if (!observer.active) {
-    return;
-  }
-
-  if (batchDepth > 0) {
-    pendingObservers.add(observer);
-    return;
-  }
-
-  observer.notify();
-}
-
-// Flush batched observer work in FIFO-like waves until the queue is empty.
-function flushObservers() {
-  while (pendingObservers.size > 0) {
-    const queue = Array.from(pendingObservers);
-    pendingObservers.clear();
-
-    for (const observer of queue) {
-      observer.notify();
-    }
-  }
-}
-
-// A mutable signal node stores a value and fan-outs updates to listeners and observers.
-class SignalNode {
-  constructor(initialValue) {
-    this.value = initialValue;
-    this.subscribers = new Set();
-    this.listeners = new Set();
-  }
-
-  get() {
-    if (activeObserver) {
-      this.subscribers.add(activeObserver);
-      activeObserver.deps.add(this);
-    }
-
-    return this.value;
-  }
-
-  peek() {
-    return this.value;
-  }
-
-  set(nextValue) {
-    if (Object.is(this.value, nextValue)) {
-      return this.value;
-    }
-
-    this.value = nextValue;
-    this.emit();
-    return this.value;
-  }
-
-  update(updater) {
-    return this.set(updater(this.value));
-  }
-
-  subscribe(listener, options = {}) {
-    const { immediate = true } = options;
-
-    this.listeners.add(listener);
-
-    if (immediate) {
-      listener(this.value);
-    }
-
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-
-  // Snapshot listeners first so resubscription during notification cannot loop forever.
-  emit() {
-    for (const listener of Array.from(this.listeners)) {
-      listener(this.value);
-    }
-
-    for (const observer of Array.from(this.subscribers)) {
-      scheduleObserver(observer);
-    }
-  }
-}
-
-// A computed node re-runs its getter whenever one of its dependencies changes.
-class ComputedNode {
-  constructor(getter) {
-    this.getter = getter;
-    this.subscribers = new Set();
-    this.listeners = new Set();
-    this.deps = new Set();
-    this.active = true;
-    this.initialized = false;
-    this.value = undefined;
-
-    this.recompute();
-  }
-
-  get() {
-    if (activeObserver) {
-      this.subscribers.add(activeObserver);
-      activeObserver.deps.add(this);
-    }
-
-    return this.value;
-  }
-
-  peek() {
-    return this.value;
-  }
-
-  notify() {
-    this.recompute();
-  }
-
-  subscribe(listener, options = {}) {
-    const { immediate = true } = options;
-
-    this.listeners.add(listener);
-
-    if (immediate) {
-      listener(this.value);
-    }
-
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-
-  // Recompute under dependency tracking and notify downstream observers only on change.
-  recompute() {
-    if (!this.active) {
-      return;
-    }
-
-    const previousValue = this.value;
-
-    cleanupObserver(this);
-
-    const previousObserver = activeObserver;
-    activeObserver = this;
-
-    try {
-      const nextValue = this.getter();
-      const changed = !this.initialized || !Object.is(previousValue, nextValue);
-
-      this.value = nextValue;
-      this.initialized = true;
-
-      if (!changed) {
-        return;
-      }
-
-      for (const listener of Array.from(this.listeners)) {
-        listener(this.value);
-      }
-
-      for (const observer of Array.from(this.subscribers)) {
-        scheduleObserver(observer);
-      }
-    } finally {
-      activeObserver = previousObserver;
-    }
-  }
-
-  stop() {
-    if (!this.active) {
-      return;
-    }
-
-    this.active = false;
-    cleanupObserver(this);
-    pendingObservers.delete(this);
-    this.subscribers.clear();
-    this.listeners.clear();
-  }
-}
-
-// Effects are observers with optional cleanup that re-run when dependencies change.
-class EffectNode {
-  constructor(fn) {
-    this.fn = fn;
-    this.deps = new Set();
-    this.active = true;
-    this.cleanup = null;
-
-    this.run();
-  }
-
-  notify() {
-    this.run();
-  }
-
-  // Execute the effect under tracking and remember any returned cleanup callback.
-  run() {
-    if (!this.active) {
-      return;
-    }
-
-    cleanupObserver(this);
-
-    if (typeof this.cleanup === 'function') {
-      this.cleanup();
-      this.cleanup = null;
-    }
-
-    const previousObserver = activeObserver;
-    activeObserver = this;
-
-    try {
-      const maybeCleanup = this.fn();
-      this.cleanup = typeof maybeCleanup === 'function' ? maybeCleanup : null;
-    } finally {
-      activeObserver = previousObserver;
-    }
-  }
-
-  stop() {
-    if (!this.active) {
-      return;
-    }
-
-    this.active = false;
-    cleanupObserver(this);
-    pendingObservers.delete(this);
-
-    if (typeof this.cleanup === 'function') {
-      this.cleanup();
-      this.cleanup = null;
-    }
-  }
-}
-
-// Create a mutable signal function with helper methods attached to it.
-export function signal(initialValue) {
-  const node = new SignalNode(initialValue);
-
-  const readWriteSignal = (nextValue = READ) => {
-    if (nextValue === READ) {
-      return node.get();
-    }
-
-    return node.set(nextValue);
-  };
-
-  readWriteSignal.set = (nextValue) => node.set(nextValue);
-  readWriteSignal.update = (updater) => node.update(updater);
-  readWriteSignal.peek = () => node.peek();
-  readWriteSignal.subscribe = (listener, options) => node.subscribe(listener, options);
-
-  return readWriteSignal;
-}
-
-// Create a read-only computed signal backed by dependency tracking.
-export function computed(getter) {
-  const node = new ComputedNode(getter);
-
-  const readOnlySignal = (nextValue = READ) => {
-    if (nextValue !== READ) {
-      throw new Error('Computed signals are read-only');
-    }
-
-    return node.get();
-  };
-
-  readOnlySignal.peek = () => node.peek();
-  readOnlySignal.subscribe = (listener, options) => node.subscribe(listener, options);
-  readOnlySignal.stop = () => node.stop();
-
-  return readOnlySignal;
-}
-
-// Run a reactive effect and return a disposer for it.
-export function effect(fn) {
-  const node = new EffectNode(fn);
-  return () => node.stop();
-}
-
-// Batch synchronous updates so dependent observers only re-run once afterward.
-export function batch(fn) {
-  batchDepth += 1;
-
-  try {
-    return fn();
-  } finally {
-    batchDepth -= 1;
-
-    if (batchDepth === 0) {
-      flushObservers();
-    }
-  }
-}
-
-// Read signals without subscribing the current observer to them.
-export function untrack(fn) {
-  const previousObserver = activeObserver;
-  activeObserver = null;
-
-  try {
-    return fn();
-  } finally {
-    activeObserver = previousObserver;
-  }
-}
-
-// Detect Qore signal-like values by their callable shape plus peek helper.
-export function isSignal(value) {
-  return typeof value === 'function' && typeof value.peek === 'function';
-}