@async/framework 0.10.2 → 0.11.0

package/src/handlers.js

@@ -1,219 +0,0 @@
-import {
-  applyServerResult,
-  defaultInput,
-  resolveServerCommandArguments,
-  unwrapServerResult
-} from "./server.js";
-import { attachRegistryInspection, createRegistryStore } from "./registry-store.js";
-import { createLazyRegistry, isLazyDescriptor } from "./lazy-registry.js";
-
-const builtInTokens = new Set(["prevent", "preventDefault", "stopPropagation", "stopImmediatePropagation"]);
-const builtInHandlers = {
-  prevent: preventDefault,
-  preventDefault,
-  stopPropagation() {
-    this.event?.stopPropagation?.();
-  },
-  stopImmediatePropagation() {
-    this.event?.stopImmediatePropagation?.();
-  }
-};
-
-function preventDefault() {
-  this.event?.preventDefault?.();
-}
-
-export function createHandlerRegistry(initialMap = {}, options = {}) {
-  const registryStore = options.registry ?? createRegistryStore();
-  const type = options.type ?? "handler";
-  const handlers = registryStore._map(type);
-  const lazyRegistry = options.lazyRegistry ?? createLazyRegistry(options);
-  const lazyHandlers = new Map();
-
-  const registry = attachRegistryInspection({
-    register(id, fn) {
-      assertId(id);
-      if (typeof fn !== "function" && !isLazyDescriptor(fn)) {
-        throw new TypeError(`Handler "${id}" must be a function.`);
-      }
-      if (handlers.has(id)) {
-        throw new Error(`Handler "${id}" is already registered.`);
-      }
-      handlers.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);
-      lazyHandlers.delete(id);
-      return handlers.delete(id);
-    },
-
-    resolve(id) {
-      assertId(id);
-      const handler = handlers.get(id);
-      if (!isLazyDescriptor(handler)) {
-        return handler;
-      }
-      if (!lazyHandlers.has(id)) {
-        lazyHandlers.set(id, async function runLazyHandler(...args) {
-          const resolved = await lazyRegistry.resolve(type, id, handler);
-          if (typeof resolved !== "function") {
-            throw new TypeError(`Handler "${id}" did not resolve to a function.`);
-          }
-          return resolved.apply(this, args);
-        });
-      }
-      return lazyHandlers.get(id);
-    },
-
-    async run(ref, context = {}) {
-      const steps = parseHandlerRef(ref);
-      const results = [];
-      let stopped = false;
-      const runContext = {
-        ...context,
-        handlers: registry,
-        input: context.input ?? defaultInput(context),
-        stop() {
-          stopped = true;
-        }
-      };
-
-      for (const step of steps) {
-        if (stopped) {
-          break;
-        }
-
-        if (step.type === "server") {
-          if (!runContext.server || typeof runContext.server.run !== "function") {
-            throw new Error(`Server command "${step.id}" cannot run without a server registry.`);
-          }
-          const resolved = resolveServerCommandArguments(step.args, runContext);
-          const result = await runContext.server.run(step.id, resolved.args, {
-            ...runContext,
-            signalPaths: resolved.signalPaths,
-            signalValues: resolved.signalValues
-          });
-          await applyServerResult(result, runContext);
-          results.push(unwrapServerResult(result));
-          continue;
-        }
-
-        const handler = registry.resolve(step.id);
-        if (!handler) {
-          throw new Error(`Handler "${step.id}" is not registered.`);
-        }
-        const value = await handler.call(runContext, runContext);
-        if (!(builtInTokens.has(step.id) && handler === builtInHandlers[step.id])) {
-          results.push(value);
-        }
-      }
-
-      return results;
-    },
-
-    _adoptMany() {
-      return registry;
-    }
-  }, registryStore, type);
-
-  registerBuiltIns(registry, handlers);
-  registry.registerMany(initialMap);
-  return registry;
-}
-
-function registerBuiltIns(registry, handlers) {
-  for (const [id, fn] of Object.entries(builtInHandlers)) {
-    if (!handlers.has(id)) {
-      registry.register(id, fn);
-      continue;
-    }
-    if (handlers.get(id) !== fn) {
-      throw new Error(`Handler "${id}" is already registered.`);
-    }
-  }
-}
-
-export function parseHandlerRef(ref) {
-  if (typeof ref !== "string" || ref.trim().length === 0) {
-    throw new TypeError("Handler ref must be a non-empty string.");
-  }
-
-  return ref
-    .split(";")
-    .map((part) => part.trim())
-    .filter(Boolean)
-    .map(parseCommand);
-}
-
-export function isHandlerToken(value) {
-  return builtInTokens.has(value);
-}
-
-function assertId(id) {
-  if (typeof id !== "string" || id.length === 0) {
-    throw new TypeError("Handler id must be a non-empty string.");
-  }
-}
-
-function parseCommand(command) {
-  if (command.startsWith("server.")) {
-    return parseServerCommand(command);
-  }
-  if (command.includes("(") || command.includes(")")) {
-    throw new Error(`Command "${command}" is not supported.`);
-  }
-  return { type: "handler", id: command };
-}
-
-function parseServerCommand(command) {
-  const open = command.indexOf("(");
-  if (open === -1 || !command.endsWith(")")) {
-    throw new Error(`Server command "${command}" must be called with parentheses.`);
-  }
-
-  const id = command.slice("server.".length, open).trim();
-  if (!isServerCommandId(id)) {
-    throw new Error(`Server command "${command}" has an invalid function id.`);
-  }
-
-  return {
-    type: "server",
-    id,
-    args: parseArguments(command.slice(open + 1, -1))
-  };
-}
-
-function parseArguments(source) {
-  if (source.trim().length === 0) {
-    return [];
-  }
-
-  return source
-    .split(",")
-    .map((part) => part.trim())
-    .filter(Boolean)
-    .map(parseArgument);
-}
-
-function parseArgument(token) {
-  if (!/^[^\s,();]+$/.test(token)) {
-    throw new Error(`Argument "${token}" is not supported.`);
-  }
-  if (token.startsWith("$")) {
-    return { type: "local", name: token };
-  }
-  return { type: "signal", path: token };
-}
-
-function isServerCommandId(id) {
-  return /^[^.\s();]+(?:\.[^.\s();]+)*$/.test(id);
-}

package/src/html.js

@@ -1,158 +0,0 @@
-import { isSignalRef } from "./signals.js";
-import { attributeName, matchAttribute, normalizeAttributeConfig } from "./attributes.js";
-
-const templateKind = Symbol.for("@async/framework.template");
-const rawKind = Symbol.for("@async/framework.rawHtml");
-
-export function html(strings, ...values) {
-  return {
-    [templateKind]: true,
-    strings,
-    values
-  };
-}
-
-export function isTemplateResult(value) {
-  return Boolean(value?.[templateKind]);
-}
-
-export function rawHtml(value) {
-  return {
-    [rawKind]: true,
-    html: String(value ?? "")
-  };
-}
-
-export function renderTemplate(value, options = {}) {
-  if (isTemplateResult(value)) {
-    const context = createRenderContext(options);
-    let output = "";
-    for (let index = 0; index < value.strings.length; index += 1) {
-      output += value.strings[index];
-      if (index < value.values.length) {
-        output += renderValue(value.values[index], {
-          ...context,
-          attribute: readAttributeContext(value.strings[index])
-        });
-      }
-    }
-    return output;
-  }
-  return renderValue(value, createRenderContext(options));
-}
-
-function renderValue(value, context = createRenderContext()) {
-  if (value?.[rawKind]) {
-    return value.html;
-  }
-  if (isTemplateResult(value)) {
-    return renderTemplate(value, context);
-  }
-  if (context.attribute) {
-    return renderAttributeValue(value, context);
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => renderValue(item, context)).join("");
-  }
-  if (isSignalRef(value)) {
-    return escapeHtml(value.value);
-  }
-  if (value == null || value === false) {
-    return "";
-  }
-  return escapeHtml(value);
-}
-
-function renderAttributeValue(value, context) {
-  const signalName = matchAttribute(context.attribute.name, context.attributes, "signal");
-  const className = matchAttribute(context.attribute.name, context.attributes, "class");
-  const signalPath = signalPathFor(value, context);
-
-  if (context.attribute.name === "value" && signalPath) {
-    const currentValue = readSignalValue(value, context);
-    const signalValueAttribute = attributeName(context.attributes, "signal", "value");
-    return `${escapeHtml(currentValue)}${context.attribute.quote} ${signalValueAttribute}=${context.attribute.quote}${escapeHtml(signalPath)}`;
-  }
-
-  if (signalName != null || className != null) {
-    if (signalPath) {
-      return escapeHtml(signalPath);
-    }
-    if (isInlineBindingValue(value)) {
-      return escapeHtml(registerInlineBinding(value, context));
-    }
-  }
-
-  return renderValueAsAttributeLiteral(value, context);
-}
-
-function renderValueAsAttributeLiteral(value, context) {
-  if (Array.isArray(value)) {
-    return value.map((item) => renderValueAsAttributeLiteral(item, context)).join("");
-  }
-  if (isSignalRef(value)) {
-    return escapeHtml(value.value);
-  }
-  if (value == null || value === false) {
-    return "";
-  }
-  return escapeHtml(value);
-}
-
-function createRenderContext(options = {}) {
-  return {
-    ...options,
-    attributes: normalizeAttributeConfig(options.attributes)
-  };
-}
-
-function readAttributeContext(source) {
-  const match = source.match(/(?:^|[\s<])([^\s"'=<>`]+)\s*=\s*(["'])$/);
-  if (!match) {
-    return null;
-  }
-  return {
-    name: match[1],
-    quote: match[2]
-  };
-}
-
-function signalPathFor(value, context) {
-  if (isSignalRef(value)) {
-    return value.id;
-  }
-  if (typeof value === "string" && context.signals?.has?.(value)) {
-    return value;
-  }
-  return null;
-}
-
-function readSignalValue(value, context) {
-  if (isSignalRef(value)) {
-    return value.value;
-  }
-  if (typeof value === "string" && context.signals?.has?.(value)) {
-    return context.signals.get(value);
-  }
-  return value;
-}
-
-function isInlineBindingValue(value) {
-  return Boolean(value && typeof value === "object");
-}
-
-function registerInlineBinding(value, context) {
-  if (typeof context.bind !== "function") {
-    return value;
-  }
-  return context.bind(value);
-}
-
-export function escapeHtml(value) {
-  return String(value)
-    .replaceAll("&", "&amp;")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;")
-    .replaceAll('"', "&quot;")
-    .replaceAll("'", "&#39;");
-}

package/src/index.js

@@ -1,20 +0,0 @@
-export { asyncSignal } from "./async-signal.js";
-export { Async, createApp, defineApp, readSnapshot } from "./server-entry.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 { createRequestContextStore } from "./request-context.js";
-export { applyServerResult, createServerProxy, resolveServerCommandArguments, unwrapServerResult } from "./server.js";
-export { createServerRegistry } from "./server-registry.js";
-export { computed, createSignal, createSignalRegistry, effect, signal } from "./signals.js";

package/src/lazy-registry.js

@@ -1,218 +0,0 @@
-const descriptorTypes = new Set(["handler", "component", "asyncSignal", "partial", "route"]);
-const defaultBaseUrl = "_async";
-
-export function defineRegistrySnapshot(snapshot = {}) {
-  if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot)) {
-    throw new TypeError("defineRegistrySnapshot(snapshot) requires an object.");
-  }
-  return snapshot;
-}
-
-export function createLazyRegistry(options = {}) {
-  const registryAssets = normalizeRegistryAssets(options.registryAssets ?? options.assets);
-  const importModule = options.importModule ?? ((url) => import(url));
-  const moduleCache = new Map();
-  const exportCache = new Map();
-
-  return {
-    registryAssets,
-
-    resolveUrl(type, id, descriptor) {
-      return resolveDescriptorUrl(type, id, descriptor, registryAssets);
-    },
-
-    async resolve(type, id, descriptor) {
-      if (!isLazyDescriptor(descriptor)) {
-        return descriptor;
-      }
-      const cacheKey = `${type}:${id}`;
-      if (exportCache.has(cacheKey)) {
-        return exportCache.get(cacheKey);
-      }
-
-      const resolved = resolveDescriptorUrl(type, id, descriptor, registryAssets);
-      let modulePromise = moduleCache.get(resolved.moduleUrl);
-      if (!modulePromise) {
-        modulePromise = Promise.resolve().then(() => importModule(resolved.moduleUrl));
-        moduleCache.set(resolved.moduleUrl, modulePromise);
-      }
-      let module;
-      try {
-        module = await modulePromise;
-      } catch (cause) {
-        if (moduleCache.get(resolved.moduleUrl) === modulePromise) {
-          moduleCache.delete(resolved.moduleUrl);
-        }
-        throw new Error(`Lazy ${type} "${id}" failed to import ${resolved.moduleUrl}: ${errorMessage(cause)}`, {
-          cause
-        });
-      }
-      const value = resolveExport(module, resolved.exportNames, type, id);
-      exportCache.set(cacheKey, value);
-      return value;
-    },
-
-    inspect() {
-      return {
-        registryAssets,
-        modules: [...moduleCache.keys()],
-        exports: [...exportCache.keys()]
-      };
-    }
-  };
-}
-
-export function normalizeRegistryAssets(options = {}) {
-  const baseUrl = normalizeBaseUrl(options.baseUrl ?? defaultBaseUrl);
-  const paths = {
-    component: "component",
-    handler: "handler",
-    asyncSignal: "asyncSignal",
-    partial: "partial",
-    route: "route",
-    ...(options.paths ?? {})
-  };
-
-  for (const [type, value] of Object.entries(paths)) {
-    if (!descriptorTypes.has(type)) {
-      continue;
-    }
-    if (typeof value !== "string" || value.length === 0) {
-      throw new TypeError(`Registry asset path for "${type}" must be a non-empty string.`);
-    }
-  }
-
-  return {
-    baseUrl,
-    paths
-  };
-}
-
-export function isLazyDescriptor(value) {
-  return Boolean(
-    value &&
-      typeof value === "object" &&
-      !Array.isArray(value) &&
-      typeof value.url === "string"
-  );
-}
-
-export function sameRegistryValue(left, right) {
-  if (left === right) {
-    return true;
-  }
-  if (isLazyDescriptor(left) && isLazyDescriptor(right)) {
-    return stableStringify(left) === stableStringify(right);
-  }
-  return false;
-}
-
-export function publicRegistryValue(value, id) {
-  if (isLazyDescriptor(value)) {
-    return { ...value };
-  }
-  return { id };
-}
-
-function resolveDescriptorUrl(type, id, descriptor, registryAssets) {
-  if (!descriptorTypes.has(type)) {
-    throw new Error(`Registry type "${type}" does not support lazy descriptors.`);
-  }
-  if (!isLazyDescriptor(descriptor)) {
-    throw new TypeError(`Registry descriptor for "${type}:${id}" requires a url.`);
-  }
-
-  const { path, hash } = splitHash(descriptor.url);
-  const moduleUrl = resolveModuleUrl(type, path, registryAssets);
-  const exportNames = hash
-    ? [hash]
-    : inferredExportNames(id, path);
-
-  return {
-    moduleUrl,
-    exportNames,
-    url: hash ? `${moduleUrl}#${hash}` : moduleUrl
-  };
-}
-
-function resolveModuleUrl(type, path, registryAssets) {
-  if (isAbsoluteUrl(path) || path.startsWith("/") || path.startsWith("./") || path.startsWith("../")) {
-    return path;
-  }
-  const typePath = registryAssets.paths[type] ?? type;
-  return joinUrl(registryAssets.baseUrl, typePath, path);
-}
-
-function resolveExport(module, exportNames, type, id) {
-  for (const name of exportNames) {
-    if (name in module) {
-      return module[name];
-    }
-  }
-  throw new Error(`Lazy ${type} "${id}" did not export ${exportNames.map((name) => `"${name}"`).join(", ")}.`);
-}
-
-function inferredExportNames(id, path) {
-  const names = [];
-  const leaf = id.split(".").filter(Boolean).at(-1);
-  const basename = path
-    .split("/")
-    .filter(Boolean)
-    .at(-1)
-    ?.replace(/\.[^.]+$/, "");
-  for (const name of [leaf, basename, "default"]) {
-    if (name && !names.includes(name)) {
-      names.push(name);
-    }
-  }
-  return names;
-}
-
-function splitHash(url) {
-  const index = url.indexOf("#");
-  if (index === -1) {
-    return { path: url, hash: "" };
-  }
-  return {
-    path: url.slice(0, index),
-    hash: url.slice(index + 1)
-  };
-}
-
-function normalizeBaseUrl(baseUrl) {
-  if (typeof baseUrl !== "string" || baseUrl.length === 0) {
-    throw new TypeError("registryAssets.baseUrl must be a non-empty string.");
-  }
-  if (isAbsoluteUrl(baseUrl) || baseUrl.startsWith("/") || baseUrl.startsWith("./") || baseUrl.startsWith("../")) {
-    return stripTrailingSlash(baseUrl);
-  }
-  return `/${stripSlashes(baseUrl)}`;
-}
-
-function joinUrl(...parts) {
-  const [first, ...rest] = parts;
-  return [stripTrailingSlash(first), ...rest.map(stripSlashes)].filter(Boolean).join("/");
-}
-
-function stripSlashes(value) {
-  return String(value).replace(/^\/+|\/+$/g, "");
-}
-
-function stripTrailingSlash(value) {
-  return String(value).replace(/\/+$/g, "");
-}
-
-function isAbsoluteUrl(value) {
-  return /^[A-Za-z][A-Za-z\d+.-]*:/.test(value);
-}
-
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
-function stableStringify(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return JSON.stringify(value);
-  }
-  return JSON.stringify(Object.keys(value).sort().map((key) => [key, value[key]]));
-}