@async/framework 0.10.1 → 0.11.0

package/src/partials.js

@@ -1,133 +0,0 @@
-import { isTemplateResult, renderTemplate } from "./html.js";
-import { attachRegistryInspection, createRegistryStore } from "./registry-store.js";
-import { createLazyRegistry, isLazyDescriptor } from "./lazy-registry.js";
-
-export function createPartialRegistry(initialMap = {}, options = {}) {
-  const registryStore = options.registry ?? createRegistryStore();
-  const type = options.type ?? "partial";
-  const entries = registryStore._map(type);
-  const lazyRegistry = options.lazyRegistry ?? createLazyRegistry(options);
-  const lazyPartials = new Map();
-
-  const registry = attachRegistryInspection({
-    register(id, fn) {
-      assertId(id);
-      if (typeof fn !== "function" && !isLazyDescriptor(fn)) {
-        throw new TypeError(`Partial "${id}" must be a function.`);
-      }
-      if (entries.has(id)) {
-        throw new Error(`Partial "${id}" is already registered.`);
-      }
-      entries.set(id, fn);
-      return id;
-    },
-
-    registerMany(map) {
-      for (const [id, fn] of Object.entries(map ?? {})) {
-        registry.register(id, fn);
-      }
-      return registry;
-    },
-
-    unregister(id) {
-      assertId(id);
-      lazyPartials.delete(id);
-      return entries.delete(id);
-    },
-
-    resolve(id) {
-      assertId(id);
-      const partial = entries.get(id);
-      if (!isLazyDescriptor(partial)) {
-        return partial;
-      }
-      if (!lazyPartials.has(id)) {
-        lazyPartials.set(id, async function runLazyPartial(...args) {
-          const resolved = await lazyRegistry.resolve(type, id, partial);
-          if (typeof resolved !== "function") {
-            throw new TypeError(`Partial "${id}" did not resolve to a function.`);
-          }
-          return resolved.apply(this, args);
-        });
-      }
-      return lazyPartials.get(id);
-    },
-
-    async render(id, props = {}, context = {}) {
-      assertId(id);
-      const fn = registry.resolve(id);
-      if (!fn) {
-        throw new Error(`Partial "${id}" is not registered.`);
-      }
-
-      const partialContext = {
-        ...context,
-        id,
-        props,
-        cache: context.cache,
-        partials: registry
-      };
-      const result = await fn.call(partialContext, props);
-      return normalizePartialResult(result, partialContext);
-    },
-
-    _adoptMany() {
-      return registry;
-    }
-  }, registryStore, type);
-
-  registry.registerMany(initialMap);
-  return registry;
-}
-
-export function normalizePartialResult(result, context = {}) {
-  if (isPartialEnvelope(result)) {
-    return {
-      ...result,
-      html: Object.hasOwn(result, "html") ? renderPartialValue(result.html, context) : result.html
-    };
-  }
-
-  return { html: renderPartialValue(result, context) };
-}
-
-function renderPartialValue(value, context) {
-  if (value?.nodeType) {
-    return value;
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  if (isTemplateResult(value)) {
-    return renderTemplate(value, templateRenderOptions(context));
-  }
-  return renderTemplate(value, templateRenderOptions(context));
-}
-
-function templateRenderOptions(context) {
-  return {
-    attributes: context.loader?.attributes,
-    signals: context.signals,
-    bind: context.loader?._registerBinding?.bind(context.loader)
-  };
-}
-
-function isPartialEnvelope(value) {
-  return Boolean(
-    value &&
-      typeof value === "object" &&
-      !Array.isArray(value) &&
-      (Object.hasOwn(value, "html") ||
-        Object.hasOwn(value, "signals") ||
-        Object.hasOwn(value, "boundary") ||
-        Object.hasOwn(value, "redirect") ||
-        Object.hasOwn(value, "status") ||
-        Object.hasOwn(value, "cache"))
-  );
-}
-
-function assertId(id) {
-  if (typeof id !== "string" || id.length === 0) {
-    throw new TypeError("Partial id must be a non-empty string.");
-  }
-}

package/src/registry-store.js

@@ -1,267 +0,0 @@
-import { publicRegistryValue } from "./lazy-registry.js";
-
-const declarationTypes = new Set(["signal", "handler", "server", "partial", "route", "component", "asyncSignal"]);
-const cacheTypes = new Set(["cache.browser", "cache.server"]);
-const cacheEntryTypes = new Set(["cache.browser.entries", "cache.server.entries"]);
-const allTypes = new Set([...declarationTypes, ...cacheTypes, ...cacheEntryTypes]);
-
-export function createRegistryStore(initial = {}, options = {}) {
-  const backing = options.backing ?? createBacking();
-  const target = options.target ?? "server";
-
-  const registry = {
-    target,
-
-    register(type, id, value) {
-      const map = registry._map(type);
-      assertId(type, id);
-      if (map.has(id)) {
-        throw new Error(`${type} "${id}" is already registered.`);
-      }
-      map.set(id, value);
-      return id;
-    },
-
-    registerMany(type, map = {}) {
-      for (const [id, value] of Object.entries(map ?? {})) {
-        registry.register(type, id, value);
-      }
-      return registry;
-    },
-
-    set(type, id, value) {
-      const map = registry._map(type);
-      assertId(type, id);
-      map.set(id, value);
-      return value;
-    },
-
-    unregister(type, id) {
-      return registry.delete(type, id);
-    },
-
-    delete(type, id) {
-      return registry._map(type).delete(id);
-    },
-
-    keys(type) {
-      if (isHiddenInBrowser(type, target)) {
-        return [];
-      }
-      return [...registry._map(type).keys()];
-    },
-
-    entries(type, entryOptions = {}) {
-      const normalized = normalizeType(type);
-      if (isHiddenInBrowser(normalized, entryOptions.target ?? target)) {
-        return [];
-      }
-      return [...registry._map(normalized)].map(([id, value]) => [
-        id,
-        publicValue(normalized, id, value, { target, ...entryOptions })
-      ]);
-    },
-
-    has(type, id) {
-      assertId(type, id);
-      if (isHiddenInBrowser(type, target)) {
-        return false;
-      }
-      return registry._map(type).has(id);
-    },
-
-    get(type, id, getOptions = {}) {
-      assertId(type, id);
-      const normalized = normalizeType(type);
-      if (isHiddenInBrowser(normalized, getOptions.target ?? target)) {
-        return undefined;
-      }
-      const value = registry._map(normalized).get(id);
-      if (value === undefined) {
-        return undefined;
-      }
-      return publicValue(normalized, id, value, { target, ...getOptions });
-    },
-
-    snapshot(snapshotOptions = {}) {
-      const snapshotTarget = snapshotOptions.target ?? target;
-      return {
-        signal: snapshotSignals(backing.signal),
-        handler: snapshotDescriptors(backing.handler),
-        server: snapshotDescriptors(backing.server),
-        partial: snapshotDescriptors(backing.partial),
-        route: snapshotPlain(backing.route),
-        component: snapshotDescriptors(backing.component),
-        asyncSignal: snapshotDescriptors(backing.asyncSignal),
-        cache: {
-          browser: snapshotPlain(backing.cache.browser),
-          server: snapshotPlain(backing.cache.server)
-        },
-        entries: {
-          browser: snapshotCacheEntries(backing.cacheEntries.browser),
-          server: snapshotTarget === "browser" ? {} : snapshotCacheEntries(backing.cacheEntries.server)
-        }
-      };
-    },
-
-    rawSnapshot() {
-      return {
-        signal: Object.fromEntries(backing.signal),
-        handler: Object.fromEntries(backing.handler),
-        server: Object.fromEntries(backing.server),
-        partial: Object.fromEntries(backing.partial),
-        route: Object.fromEntries(backing.route),
-        component: Object.fromEntries(backing.component),
-        asyncSignal: Object.fromEntries(backing.asyncSignal),
-        cache: {
-          browser: Object.fromEntries(backing.cache.browser),
-          server: Object.fromEntries(backing.cache.server)
-        }
-      };
-    },
-
-    view(viewOptions = {}) {
-      return createRegistryStore(undefined, {
-        backing,
-        target: viewOptions.target ?? target
-      });
-    },
-
-    _map(type) {
-      const normalized = normalizeType(type);
-      if (declarationTypes.has(normalized)) {
-        return backing[normalized];
-      }
-      if (normalized === "cache.browser") {
-        return backing.cache.browser;
-      }
-      if (normalized === "cache.server") {
-        return backing.cache.server;
-      }
-      if (normalized === "cache.browser.entries") {
-        return backing.cacheEntries.browser;
-      }
-      if (normalized === "cache.server.entries") {
-        return backing.cacheEntries.server;
-      }
-      throw new Error(`Unknown Async registry type "${type}".`);
-    }
-  };
-
-  applyInitial(registry, initial);
-  return registry;
-}
-
-export function attachRegistryInspection(target, registry, type) {
-  Object.defineProperty(target, "registry", {
-    configurable: true,
-    enumerable: true,
-    value: registry
-  });
-  target.keys = () => registry.keys(type);
-  target.entries = () => registry.entries(type);
-  target.inspect = () => registry.entries(type);
-  return target;
-}
-
-function createBacking() {
-  return {
-    signal: new Map(),
-    handler: new Map(),
-    server: new Map(),
-    partial: new Map(),
-    route: new Map(),
-    component: new Map(),
-    asyncSignal: new Map(),
-    cache: {
-      browser: new Map(),
-      server: new Map()
-    },
-    cacheEntries: {
-      browser: new Map(),
-      server: new Map()
-    }
-  };
-}
-
-function applyInitial(registry, initial = {}) {
-  registry.registerMany("signal", initial.signal);
-  registry.registerMany("handler", initial.handler);
-  registry.registerMany("server", initial.server);
-  registry.registerMany("partial", initial.partial);
-  registry.registerMany("route", initial.route);
-  registry.registerMany("component", initial.component);
-  registry.registerMany("asyncSignal", initial.asyncSignal);
-  registry.registerMany("cache.browser", initial.cache?.browser);
-  registry.registerMany("cache.server", initial.cache?.server);
-
-  const entries = initial.entries ?? {};
-  for (const [key, value] of Object.entries(entries.browser ?? {})) {
-    registry.set("cache.browser.entries", key, cacheEntry(value));
-  }
-  for (const [key, value] of Object.entries(entries.server ?? {})) {
-    registry.set("cache.server.entries", key, cacheEntry(value));
-  }
-}
-
-function normalizeType(type) {
-  if (!allTypes.has(type)) {
-    throw new Error(`Unknown Async registry type "${type}".`);
-  }
-  return type;
-}
-
-function assertId(type, id) {
-  if (typeof id !== "string" || id.length === 0) {
-    throw new TypeError(`${type} id must be a non-empty string.`);
-  }
-}
-
-function publicValue(type, id, value, options) {
-  if (type === "server" && options.target === "browser") {
-    return publicRegistryValue(value, id);
-  }
-  if (cacheEntryTypes.has(type)) {
-    return value?.value;
-  }
-  return value;
-}
-
-function isHiddenInBrowser(type, target) {
-  return type === "cache.server.entries" && target === "browser";
-}
-
-function snapshotSignals(map) {
-  const snapshot = {};
-  for (const [id, entry] of map) {
-    snapshot[id] = typeof entry?.snapshot === "function" ? entry.snapshot() : entry?.value ?? entry;
-  }
-  return snapshot;
-}
-
-function snapshotDescriptors(map) {
-  const snapshot = {};
-  for (const [id, value] of map) {
-    snapshot[id] = publicRegistryValue(value, id);
-  }
-  return snapshot;
-}
-
-function snapshotPlain(map) {
-  return Object.fromEntries(map);
-}
-
-function snapshotCacheEntries(map) {
-  const snapshot = {};
-  for (const [id, entry] of map) {
-    snapshot[id] = entry?.value;
-  }
-  return snapshot;
-}
-
-function cacheEntry(value) {
-  if (value && typeof value === "object" && Object.hasOwn(value, "value")) {
-    return value;
-  }
-  return { value };
-}

package/src/request-context.js

@@ -1,40 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-
-export function createRequestContextStore() {
-  const storage = new AsyncLocalStorage();
-
-  return {
-    storage,
-
-    run(context, fn, ...args) {
-      if (typeof fn !== "function") {
-        throw new TypeError("requestContext.run(context, fn) requires a function.");
-      }
-      return storage.run(context ?? {}, fn, ...args);
-    },
-
-    get() {
-      return storage.getStore();
-    },
-
-    snapshot() {
-      return { ...(storage.getStore() ?? {}) };
-    }
-  };
-}
-
-export function readRequestContext(store) {
-  if (!store) {
-    return {};
-  }
-  if (typeof store.get === "function") {
-    return store.get() ?? {};
-  }
-  if (typeof store.getStore === "function") {
-    return store.getStore() ?? {};
-  }
-  if (typeof store === "object") {
-    return store;
-  }
-  return {};
-}