@async/framework 0.10.2 → 0.11.1

package/src/async-signal.js

@@ -1,277 +0,0 @@
-const asyncSignalKind = Symbol.for("@async/framework.asyncSignal");
-
-export function asyncSignal(id, fn) {
-  if (typeof id !== "string" || id.length === 0) {
-    throw new TypeError("asyncSignal(id, fn) requires a non-empty string id.");
-  }
-  if (typeof fn !== "function") {
-    throw new TypeError("asyncSignal(id, fn) requires a function.");
-  }
-
-  let value;
-  let loading = false;
-  let error = null;
-  let status = "idle";
-  let version = 0;
-  let registry;
-  let registeredId = id;
-  let activeController;
-  let activeAbort;
-  const subscribers = new Set();
-  const dependencyCleanups = new Set();
-
-  const state = {
-    [asyncSignalKind]: true,
-    kind: "async-signal",
-
-    get id() {
-      return registeredId;
-    },
-
-    get value() {
-      return value;
-    },
-
-    get loading() {
-      return loading;
-    },
-
-    get error() {
-      return error;
-    },
-
-    get status() {
-      return status;
-    },
-
-    get version() {
-      return version;
-    },
-
-    set(nextValue) {
-      value = nextValue;
-      loading = false;
-      error = null;
-      status = "ready";
-      notify();
-      return value;
-    },
-
-    refresh() {
-      if (!registry) {
-        throw new Error(`Async signal "${registeredId}" is not registered.`);
-      }
-
-      if (activeAbort && !activeAbort.aborted) {
-        activeAbort.cancel(new Error(`Async signal "${registeredId}" refreshed.`));
-      }
-
-      const runVersion = version + 1;
-      version = runVersion;
-      loading = true;
-      error = null;
-      status = "loading";
-
-      const controller = new AbortController();
-      activeController = controller;
-      activeAbort = controller.signal;
-      attachCancel(activeAbort, controller);
-      notify();
-
-      const context = {
-        signals: registry,
-        id: registeredId,
-        get server() {
-          const context = registry._context?.() ?? {};
-          const server = context.server;
-          if (typeof server?._withContext === "function") {
-            return server._withContext({
-              signals: registry,
-              router: context.router,
-              loader: context.loader,
-              cache: context.cache,
-              abort: activeAbort,
-              scheduler: context.scheduler
-            });
-          }
-          return server;
-        },
-        get router() {
-          return registry._context?.().router;
-        },
-        get loader() {
-          return registry._context?.().loader;
-        },
-        get cache() {
-          return registry._context?.().cache;
-        },
-        get scheduler() {
-          return registry._context?.().scheduler;
-        },
-        get version() {
-          return runVersion;
-        },
-        get abort() {
-          return activeAbort;
-        },
-        refresh() {
-          return state.refresh();
-        }
-      };
-
-      let outcome;
-      try {
-        outcome = registry._collectDependencies(() => fn.call(context));
-      } catch (cause) {
-        finishError(runVersion, cause);
-        return Promise.reject(cause);
-      }
-
-      syncDependencies(outcome.dependencies);
-
-      return Promise.resolve(outcome.value).then(
-        (nextValue) => {
-          if (!isCurrent(runVersion)) {
-            return value;
-          }
-          value = nextValue;
-          loading = false;
-          error = null;
-          status = "ready";
-          notify();
-          return value;
-        },
-        (cause) => {
-          if (!isCurrent(runVersion)) {
-            return value;
-          }
-          if (activeAbort?.aborted) {
-            loading = false;
-            status = value === undefined ? "idle" : "ready";
-            notify();
-            return value;
-          }
-          finishError(runVersion, cause);
-          return value;
-        }
-      );
-    },
-
-    cancel(reason) {
-      if (activeAbort && !activeAbort.aborted) {
-        activeAbort.cancel(reason);
-      }
-    },
-
-    subscribe(fn) {
-      if (typeof fn !== "function") {
-        throw new TypeError("subscribe(fn) requires a function.");
-      }
-      subscribers.add(fn);
-      return () => subscribers.delete(fn);
-    },
-
-    snapshot() {
-      return {
-        value,
-        loading,
-        error,
-        status,
-        version
-      };
-    },
-
-    _bindRegistry(nextRegistry, nextId) {
-      registry = nextRegistry;
-      registeredId = nextId;
-      const start = () => {
-        if (registry === nextRegistry && status === "idle") {
-          state.refresh();
-        }
-      };
-      const scheduler = registry._context?.().scheduler;
-      if (scheduler) {
-        scheduler.enqueue("async", start, {
-          scope: registeredId,
-          key: `asyncSignal:${registeredId}:initial`
-        });
-      } else {
-        queueMicrotask(start);
-      }
-    },
-
-    _dispose() {
-      state.cancel(new Error(`Async signal "${registeredId}" disposed.`));
-      for (const cleanup of dependencyCleanups) {
-        cleanup();
-      }
-      dependencyCleanups.clear();
-      subscribers.clear();
-    }
-  };
-
-  function finishError(runVersion, cause) {
-    if (!isCurrent(runVersion)) {
-      return;
-    }
-    loading = false;
-    error = cause;
-    status = "error";
-    notify();
-  }
-
-  function isCurrent(runVersion) {
-    return runVersion === version && activeController?.signal === activeAbort;
-  }
-
-  function syncDependencies(dependencies) {
-    for (const cleanup of dependencyCleanups) {
-      cleanup();
-    }
-    dependencyCleanups.clear();
-
-    for (const dependency of dependencies) {
-      const dependencyId = String(dependency).split(".")[0];
-      if (dependencyId && dependencyId !== registeredId) {
-        dependencyCleanups.add(registry.subscribe(dependency, () => scheduleRefresh()));
-      }
-    }
-  }
-
-  function scheduleRefresh() {
-    if (activeAbort && !activeAbort.aborted) {
-      activeAbort.cancel(new Error(`Async signal "${registeredId}" dependency changed.`));
-    }
-    const scheduler = registry?._context?.().scheduler;
-    if (!scheduler) {
-      state.refresh();
-      return;
-    }
-    scheduler.enqueue("async", () => state.refresh(), {
-      scope: registeredId,
-      key: `asyncSignal:${registeredId}:refresh`
-    });
-  }
-
-  function notify() {
-    for (const subscriber of [...subscribers]) {
-      subscriber(state);
-    }
-  }
-
-  return state;
-}
-
-export function isAsyncSignal(value) {
-  return Boolean(value?.[asyncSignalKind]);
-}
-
-function attachCancel(signal, controller) {
-  Object.defineProperty(signal, "cancel", {
-    configurable: true,
-    enumerable: false,
-    value(reason) {
-      controller.abort(reason);
-    }
-  });
-}

package/src/attributes.js

@@ -1,52 +0,0 @@
-const defaultPrefixes = Object.freeze({
-  async: ["async:"],
-  class: ["class:"],
-  signal: ["signal:"],
-  on: ["on:"]
-});
-
-export function defineAttributeConfig(config = {}) {
-  return normalizeAttributeConfig(config);
-}
-
-export function normalizeAttributeConfig(config = {}) {
-  return {
-    async: normalizePrefixes(config.async, defaultPrefixes.async),
-    class: normalizePrefixes(config.class, defaultPrefixes.class),
-    signal: normalizePrefixes(config.signal, defaultPrefixes.signal),
-    on: normalizePrefixes(config.on, defaultPrefixes.on)
-  };
-}
-
-export function attributeName(attributes, type, name) {
-  return normalizeAttributeConfig(attributes)[type][0] + name;
-}
-
-export function readAttribute(element, attributes, type, name) {
-  for (const prefix of normalizeAttributeConfig(attributes)[type]) {
-    const attr = `${prefix}${name}`;
-    if (element.hasAttribute?.(attr)) {
-      return element.getAttribute(attr);
-    }
-  }
-  return null;
-}
-
-export function matchAttribute(name, attributes, type) {
-  for (const prefix of normalizeAttributeConfig(attributes)[type]) {
-    if (name.startsWith(prefix)) {
-      return name.slice(prefix.length);
-    }
-  }
-  return null;
-}
-
-function normalizePrefixes(value, fallback) {
-  const prefixes = value == null ? fallback : Array.isArray(value) ? value : [value];
-  return prefixes.map((prefix) => {
-    if (typeof prefix !== "string" || prefix.length === 0) {
-      throw new TypeError("Attribute prefixes must be non-empty strings.");
-    }
-    return prefix;
-  });
-}

package/src/boundary-receiver.js

@@ -1,302 +0,0 @@
-const defaultRecentLimit = 50;
-
-export function createBoundaryReceiver(options = {}) {
-  const loader = options.loader;
-  const signals = options.signals ?? loader?.signals;
-  const cache = options.cache ?? loader?.cache;
-  const scheduler = options.scheduler ?? loader?.scheduler;
-  const router = options.router ?? loader?.router;
-  const recentLimit = options.recentLimit ?? defaultRecentLimit;
-  const throwOnError = options.throwOnError === true;
-  const onApply = typeof options.onApply === "function" ? options.onApply : undefined;
-  const onIgnore = typeof options.onIgnore === "function" ? options.onIgnore : undefined;
-  const onError = typeof options.onError === "function" ? options.onError : undefined;
-  const isScopeDestroyed = typeof options.isScopeDestroyed === "function"
-    ? options.isScopeDestroyed
-    : (scope) => scheduler?.isScopeDestroyed?.(scope) ?? scheduler?.inspectDestroyed?.(scope) ?? false;
-
-  if (!loader || typeof loader.swap !== "function") {
-    throw new TypeError("createBoundaryReceiver(...) requires a loader with swap(boundary, html).");
-  }
-  if (!Number.isInteger(recentLimit) || recentLimit < 0) {
-    throw new TypeError("createBoundaryReceiver(...) recentLimit must be a non-negative integer.");
-  }
-
-  const boundaries = new Map();
-  const recent = [];
-  let destroyed = false;
-
-  const receiver = {
-    async apply(patch) {
-      if (destroyed) {
-        throw new Error("Boundary receiver has been destroyed.");
-      }
-
-      const normalized = validatePatch(patch);
-      const record = boundaryRecord(normalized.boundary);
-      if (normalized.seq <= record.lastSeq) {
-        const result = {
-          status: "ignored-stale",
-          boundary: normalized.boundary,
-          seq: normalized.seq,
-          lastSeq: record.lastSeq
-        };
-        record.ignored += 1;
-        record.lastStatus = result.status;
-        remember(result);
-        onIgnore?.(result, patch);
-        return result;
-      }
-
-      if (normalized.parentScope !== undefined && isScopeDestroyed(normalized.parentScope)) {
-        const result = {
-          status: "ignored-destroyed",
-          boundary: normalized.boundary,
-          seq: normalized.seq,
-          parentScope: normalized.parentScope
-        };
-        record.ignored += 1;
-        record.lastStatus = result.status;
-        remember(result);
-        onIgnore?.(result, patch);
-        return result;
-      }
-
-      record.lastSeq = normalized.seq;
-
-      if (Object.hasOwn(normalized, "error")) {
-        const error = toStableError(normalized.error);
-        const result = {
-          status: "errored",
-          boundary: normalized.boundary,
-          seq: normalized.seq,
-          error
-        };
-        record.errored += 1;
-        record.lastStatus = result.status;
-        remember(result);
-        onError?.(error, result, patch);
-        if (throwOnError) {
-          throw error;
-        }
-        return result;
-      }
-
-      if (normalized.signals) {
-        if (!signals || typeof signals.set !== "function") {
-          throw new Error("Boundary patch includes signals, but no signal registry is available.");
-        }
-        for (const [path, value] of Object.entries(normalized.signals)) {
-          signals.set(path, value);
-        }
-      }
-
-      if (normalized.cache?.browser) {
-        if (!cache || typeof cache.restore !== "function") {
-          throw new Error("Boundary patch includes browser cache, but no cache registry is available.");
-        }
-        cache.restore(normalized.cache.browser);
-      }
-
-      if (normalized.html != null) {
-        loader.swap(normalized.boundary, normalized.html);
-      }
-
-      await flushScheduler(scheduler, normalized.scope);
-
-      if (normalized.redirect) {
-        await followRedirect(normalized.redirect, router, loader);
-        const result = {
-          status: "redirected",
-          boundary: normalized.boundary,
-          seq: normalized.seq,
-          redirect: normalized.redirect
-        };
-        record.applied += 1;
-        record.lastStatus = result.status;
-        remember(result);
-        onApply?.(result, patch);
-        return result;
-      }
-
-      const result = {
-        status: "applied",
-        boundary: normalized.boundary,
-        seq: normalized.seq
-      };
-      record.applied += 1;
-      record.lastStatus = result.status;
-      remember(result);
-      onApply?.(result, patch);
-      return result;
-    },
-
-    inspect() {
-      const snapshot = {};
-      for (const [boundary, record] of boundaries) {
-        snapshot[boundary] = {
-          lastSeq: record.lastSeq,
-          applied: record.applied,
-          ignored: record.ignored,
-          lastStatus: record.lastStatus
-        };
-        if (record.errored > 0) {
-          snapshot[boundary].errored = record.errored;
-        }
-      }
-      return {
-        destroyed,
-        boundaries: snapshot,
-        recent: recent.map((entry) => ({ ...entry }))
-      };
-    },
-
-    reset(boundary) {
-      if (boundary === undefined) {
-        boundaries.clear();
-        recent.length = 0;
-        return receiver;
-      }
-      assertBoundary(boundary);
-      boundaries.delete(boundary);
-      for (let index = recent.length - 1; index >= 0; index -= 1) {
-        if (recent[index].boundary === boundary) {
-          recent.splice(index, 1);
-        }
-      }
-      return receiver;
-    },
-
-    destroy() {
-      destroyed = true;
-      boundaries.clear();
-      recent.length = 0;
-    }
-  };
-
-  return receiver;
-
-  function boundaryRecord(boundary) {
-    if (!boundaries.has(boundary)) {
-      boundaries.set(boundary, {
-        lastSeq: -Infinity,
-        applied: 0,
-        ignored: 0,
-        errored: 0,
-        lastStatus: undefined
-      });
-    }
-    return boundaries.get(boundary);
-  }
-
-  function remember(result) {
-    if (recentLimit === 0) {
-      return;
-    }
-    recent.push(toRecentEntry(result));
-    while (recent.length > recentLimit) {
-      recent.shift();
-    }
-  }
-}
-
-function validatePatch(patch) {
-  if (!patch || typeof patch !== "object" || Array.isArray(patch)) {
-    throw new TypeError("receiver.apply(patch) requires a boundary patch object.");
-  }
-
-  assertBoundary(patch.boundary);
-  if (typeof patch.seq !== "number" || !Number.isFinite(patch.seq)) {
-    throw new TypeError("Boundary patch seq must be a finite number.");
-  }
-
-  if (patch.signals !== undefined && !isPlainObject(patch.signals)) {
-    throw new TypeError("Boundary patch signals must be an object.");
-  }
-  if (patch.cache !== undefined && !isPlainObject(patch.cache)) {
-    throw new TypeError("Boundary patch cache must be an object.");
-  }
-  if (patch.cache?.browser !== undefined && !isPlainObject(patch.cache.browser)) {
-    throw new TypeError("Boundary patch cache.browser must be an object.");
-  }
-  if (patch.redirect !== undefined && (typeof patch.redirect !== "string" || patch.redirect.length === 0)) {
-    throw new TypeError("Boundary patch redirect must be a non-empty string.");
-  }
-  if (patch.parentScope !== undefined && typeof patch.parentScope !== "string") {
-    throw new TypeError("Boundary patch parentScope must be a string.");
-  }
-  if (patch.scope !== undefined && typeof patch.scope !== "string") {
-    throw new TypeError("Boundary patch scope must be a string.");
-  }
-
-  const hasHtml = Object.hasOwn(patch, "html") && patch.html != null;
-  const hasSignals = patch.signals && Object.keys(patch.signals).length > 0;
-  const hasBrowserCache = patch.cache?.browser && Object.keys(patch.cache.browser).length > 0;
-  const hasRedirect = Boolean(patch.redirect);
-  const hasError = Object.hasOwn(patch, "error");
-  if (!hasHtml && !hasSignals && !hasBrowserCache && !hasRedirect && !hasError) {
-    throw new TypeError("Boundary patch must include html, signals, cache.browser, redirect, or error.");
-  }
-
-  return patch;
-}
-
-function assertBoundary(boundary) {
-  if (typeof boundary !== "string" || boundary.length === 0) {
-    throw new TypeError("Boundary patch boundary must be a non-empty string.");
-  }
-}
-
-async function flushScheduler(scheduler, scope) {
-  if (!scheduler) {
-    return;
-  }
-  if (scope !== undefined && typeof scheduler.flushScope === "function") {
-    await scheduler.flushScope(scope);
-    return;
-  }
-  if (typeof scheduler.flush === "function") {
-    await scheduler.flush();
-  }
-}
-
-async function followRedirect(redirect, router, loader) {
-  if (router && typeof router.navigate === "function") {
-    await router.navigate(redirect);
-    return;
-  }
-  const location = loader?.root?.ownerDocument?.defaultView?.location ?? globalThis.location;
-  location?.assign?.(redirect);
-}
-
-function toStableError(value) {
-  if (value instanceof Error) {
-    return value;
-  }
-  if (value && typeof value === "object" && typeof value.message === "string") {
-    return Object.assign(new Error(value.message), value);
-  }
-  return new Error(String(value));
-}
-
-function toRecentEntry(result) {
-  const entry = {
-    boundary: result.boundary,
-    seq: result.seq,
-    status: result.status
-  };
-  if (result.status === "ignored-stale") {
-    entry.lastSeq = result.lastSeq;
-  }
-  if (result.status === "ignored-destroyed" && result.parentScope !== undefined) {
-    entry.parentScope = result.parentScope;
-  }
-  if (result.status === "redirected") {
-    entry.redirect = result.redirect;
-  }
-  return entry;
-}
-
-function isPlainObject(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}

package/src/browser.js

@@ -1,18 +0,0 @@
-export { asyncSignal } from "./async-signal.js";
-export { Async, createApp, defineApp, readSnapshot } from "./app.js";
-export { attributeName, defineAttributeConfig } from "./attributes.js";
-export { createBoundaryReceiver } from "./boundary-receiver.js";
-export { createCacheRegistry, defineCache } from "./cache.js";
-export { component, createComponentRegistry, defineComponent } from "./component.js";
-export { delay } from "./delay.js";
-export { defineAsyncContainerElement, defineAsyncSuspenseElement } from "./elements.js";
-export { createHandlerRegistry } from "./handlers.js";
-export { html } from "./html.js";
-export { createLazyRegistry, defineRegistrySnapshot } from "./lazy-registry.js";
-export { Loader, AsyncLoader } from "./loader.js";
-export { createPartialRegistry } from "./partials.js";
-export { createRegistryStore } from "./registry-store.js";
-export { createRouteRegistry, createRouter, defineRoute, route } from "./router.js";
-export { createScheduler } from "./scheduler.js";
-export { applyServerResult, createServerProxy, resolveServerCommandArguments, unwrapServerResult } from "./server.js";
-export { computed, createSignal, createSignalRegistry, effect, signal } from "./signals.js";