@kasperrt/smolter 0.4.2 → 0.4.4

package/.generated/client/hash-history.ts

@@ -0,0 +1,27 @@
+import type { Router } from "../core/index.ts";
+
+export function connectHashHistory(router: Router) {
+  const read = router.getSnapshot;
+  const navigate = router.navigate;
+  router.navigate = async (url, options) => {
+    const target = new URL(url, router.getSnapshot().url);
+    const hash = `#${target.pathname}${target.search}${target.hash}`;
+    history[options?.replace ? "replaceState" : "pushState"](null, "", hash);
+    await navigate(url, options);
+  };
+  const unsubscribe = router.subscribe(() => {
+    const target = new URL(read().url);
+    const hash = `#${target.pathname}${target.search}${target.hash}`;
+
+    // Redirects commit inside the router rather than through navigate().
+    if (location.hash !== hash) history.replaceState(history.state, "", hash);
+  });
+  const onHashChange = () => void navigate(location.hash.slice(1) || "/");
+  window.addEventListener("hashchange", onHashChange);
+  const dispose = router.dispose;
+  router.dispose = () => {
+    unsubscribe();
+    window.removeEventListener("hashchange", onHashChange);
+    dispose();
+  };
+}

package/.generated/client/hydration.ts

@@ -0,0 +1,98 @@
+type Settlement = [number, unknown, string | null];
+
+interface PendingValue {
+  promise: Promise<unknown>;
+  resolve: (value: unknown) => void;
+  reject: (reason: Error) => void;
+}
+
+export interface DeferredWindow extends Window {
+  __smolterDeferred?: Settlement[];
+}
+
+/** Restore promise identity before hydrating Suspense boundaries. */
+export function readHydration(json: string, timeout = 30_000) {
+  if (!Number.isInteger(timeout) || timeout < 1 || timeout > 2_147_483_647)
+    throw new RangeError(
+      "deferredTimeout must be an integer between 1 and 2147483647 ms",
+    );
+
+  const pending = new Map<number, PendingValue>();
+  const queue = ((window as DeferredWindow).__smolterDeferred ??= []);
+
+  function revive(_key: string, value: unknown): unknown {
+    if (!value || typeof value !== "object") return value;
+    if ("__smolterUndefined" in value) return undefined;
+
+    if (
+      "__smolterPending" in value &&
+      typeof value.__smolterPending === "number"
+    ) {
+      const id = value.__smolterPending;
+      const existing = pending.get(id);
+      if (existing) return existing.promise;
+
+      let resolve!: PendingValue["resolve"];
+      let reject!: PendingValue["reject"];
+      const promise = new Promise((accept, fail) => {
+        resolve = accept;
+        reject = fail;
+      });
+      void promise.catch(() => {});
+      pending.set(id, { promise, resolve, reject });
+
+      return promise;
+    }
+
+    if ("__smolterRejected" in value) {
+      const failure = value.__smolterRejected as { message: string };
+      const rejected = Promise.reject(
+        Object.assign(new Error(failure.message), failure),
+      );
+      void rejected.catch(() => {});
+
+      return rejected;
+    }
+
+    return value;
+  }
+
+  const hydration = JSON.parse(json, revive);
+  const dispose = () => {
+    clearTimeout(deadline);
+    window.removeEventListener("DOMContentLoaded", dispose);
+    for (const target of pending.values())
+      target.reject(new Error("Hydration stream closed"));
+    pending.clear();
+    queue.push = () => 0;
+  };
+  const deadline = pending.size
+    ? setTimeout(() => {
+        for (const target of pending.values())
+          target.reject(new Error("Hydration stream timed out"));
+        dispose();
+      }, timeout)
+    : undefined;
+  const receive = (packet: Settlement) => {
+    const [id, value, error] = packet;
+    if (id === -1) return dispose();
+
+    const target = pending.get(id);
+    if (!target) return;
+
+    if (error !== null) target.reject(new Error(error));
+    if (error === null)
+      target.resolve(JSON.parse(JSON.stringify(value), revive));
+  };
+  const buffered = queue.splice(0);
+  queue.push = (...packets) => {
+    packets.forEach(receive);
+    return 0;
+  };
+
+  window.addEventListener("DOMContentLoaded", dispose, { once: true });
+  buffered.forEach(receive);
+  if (document.readyState !== "loading") dispose();
+
+  return { hydration, dispose };
+}

package/.generated/client/root-data.ts

@@ -0,0 +1,52 @@
+import type { RevalidationArgs, Router } from "../core/index.ts";
+
+interface RootModule {
+  default?: unknown;
+  Layout?: unknown;
+  id?: string;
+  loaderPath?: string;
+  shouldRevalidate?: (args: RevalidationArgs) => boolean;
+}
+
+export { createStore as createRootStore } from "../core/store.ts";
+
+import { createStore } from "../core/store.ts";
+
+export function attachRootData(
+  router: Router,
+  initial: unknown,
+  rootModule?: RootModule,
+) {
+  const store = createStore(initial);
+  const loaderPath = rootModule?.loaderPath;
+
+  if (!rootModule || !loaderPath) return store;
+
+  let pending: ReturnType<Router["createFetcher"]> | undefined;
+  const unregister = router.registerRevalidator(
+    rootModule.id ?? "root",
+    async (args) => {
+      if (rootModule.shouldRevalidate?.(args) === false) return;
+
+      pending?.dispose();
+      const fetcher = router.createFetcher();
+      pending = fetcher;
+      const result = await fetcher.load(loaderPath);
+
+      if (pending === fetcher && !result.error) store.update(result.data);
+
+      fetcher.dispose();
+
+      if (pending === fetcher) pending = undefined;
+    },
+  );
+  const dispose = router.dispose;
+  router.dispose = () => {
+    pending?.dispose();
+    pending = undefined;
+    unregister();
+    dispose();
+  };
+
+  return store;
+}

package/.generated/core/environment.ts

@@ -1,3 +1,4 @@
+/** Application base URLs, navigation handoff and document-transition settings shared by browser integrations. */
 export interface ApplicationEnvironment {
   resolveURL?: (url: URL) => URL;
   isDocumentHandoff?: (from: URL, to: URL) => boolean;

package/.generated/core/navigation.ts

@@ -7,6 +7,7 @@ import { createStore } from "./store.ts";
 import type { NavigateOptions, Router } from "./types.ts";
 import { navigationClick } from "./url.ts";
 
+/** Browser history operation: POP, PUSH or REPLACE. */
 export type NavigationType = "POP" | "PUSH" | "REPLACE";
 
 export interface NavigationSnapshot {

package/.generated/core/prepare-routes.ts

@@ -0,0 +1,50 @@
+import { normalizeResult } from "./responses.ts";
+import type { DataFunction, Route } from "./types.ts";
+
+type AppRoute = Route & { routePath?: string; preload?: () => Promise<void> };
+
+export function prepareRoutes(
+  routes: AppRoute[],
+  preserveDeferred = false,
+): AppRoute[] {
+  return routes.map((route) => {
+    const wrapped: AppRoute = {
+      ...route,
+      path: route.routePath ?? route.path,
+      shouldRevalidate: (args) => {
+        const { currentUrl, nextUrl } = args;
+
+        if (
+          args.reason === "navigation" &&
+          currentUrl.pathname === nextUrl.pathname &&
+          currentUrl.search === nextUrl.search &&
+          currentUrl.hash !== nextUrl.hash
+        )
+          return false;
+
+        return route.shouldRevalidate?.(args) ?? args.defaultShouldRevalidate;
+      },
+    };
+
+    for (const key of [
+      "loader",
+      "action",
+      "clientLoader",
+      "clientAction",
+    ] as const) {
+      const handler = route[key] as DataFunction | undefined;
+
+      if (!handler) continue;
+
+      wrapped[key] = (args) =>
+        Promise.resolve()
+          .then(() => handler(args))
+          .then(
+            (value) => normalizeResult(value, !preserveDeferred),
+            (error) => normalizeResult(error, !preserveDeferred),
+          );
+    }
+
+    return wrapped;
+  });
+}

package/.generated/core/presentation.ts

@@ -9,7 +9,7 @@ type CommitView = (update: () => void) => void;
 const pending = new WeakMap<Router, () => Snapshot>();
 
 export function pendingLocation(router: Router) {
-  const snapshot = pending.get(router)?.();
+  const snapshot = pending.get(router)?.() ?? router.getSnapshot();
 
   return snapshot?.state !== "idle" && snapshot?.url
     ? new URL(snapshot.url)

package/.generated/core/responses.ts

@@ -1,19 +1,28 @@
+/**
+ * HTTP response helpers and loader result normalization.
+ *
+ * @module
+ */
+/** Normalized route failure with an HTTP status, status text and optional response data. */
 export interface RouteError extends Error {
   status: number;
   statusText: string;
   data?: unknown;
 }
 
+/** Loader value paired with HTTP response metadata. */
 export interface DataResponse<T> {
   value: T;
   init: ResponseInit;
   __routeData: true;
 }
 
+/** Wrap loader data with HTTP status and headers without creating a Response body. */
 export function data<T>(value: T, init: ResponseInit = {}): DataResponse<T> {
   return { value, init, __routeData: true };
 }
 
+/** Create an empty redirect Response with a Location header; defaults to HTTP 302. */
 export function redirect(
   location: string,
   init: number | ResponseInit = 302,
@@ -29,10 +38,12 @@ export function redirect(
   });
 }
 
+/** Identify normalized Error objects carrying an HTTP status. */
 export function isRouteErrorResponse(value: unknown): value is RouteError {
   return value instanceof Error && "status" in value;
 }
 
+/** Normalize transport responses and wrapped data, optionally resolving nested deferred values. */
 export async function normalizeResult(
   value: unknown,
   resolveDeferred = true,
@@ -68,6 +79,7 @@ export async function normalizeResult(
 }
 
 // Smolter transfers JSON snapshots. Resolve deferred fields before serialization.
+/** Recursively resolve promises in arrays and plain objects before JSON serialization. */
 export async function resolveData(value: unknown): Promise<unknown> {
   const resolved = await value;
 

package/.generated/core/utils.ts

@@ -1,5 +1,8 @@
-/** Framework-independent, browser-safe utilities. @module */
-export * from "./errors.ts";
+/**
+ * Routing patterns, query strings and serialized data utilities.
+ *
+ * @module
+ */
 export * from "./match.ts";
 export * from "./serialize.ts";
 export * from "./url.ts";

package/.generated/preact/await.tsx

@@ -17,6 +17,7 @@ type Resolution = { value: unknown } | { error: unknown };
 // Cache only the error-as-data adapter. Preact owns pending and resolved state.
 const resolutions = new WeakMap<Promise<unknown>, Promise<Resolution>>();
 
+/** Render a value or promise. An explicit fallback owns pending content during early hydration; errorElement handles rejection. */
 export function Await<T>(props: AwaitProps<T>): ComponentChildren {
   const app = useContext(Application);
   if (!(props.resolve instanceof Promise))

package/.generated/preact/client.tsx

@@ -1,4 +1,8 @@
-/** Browser mounting and hydration for Preact applications. @module */
+/**
+ * Preact document hydration, browser history and deployment recovery.
+ *
+ * @module
+ */
 /** @jsxImportSource preact */
 
 import {
@@ -6,6 +10,7 @@ import {
   recoverDeployment,
   watchDeployment,
 } from "../client/index.ts";
+import { connectHashHistory } from "../client/hash-history.ts";
 import { createDataRouter, matchRoutes, type Router } from "../core/index.ts";
 import { connectNavigation } from "../core/navigation.ts";
 import { retainRoute } from "../core/presentation.ts";
@@ -19,6 +24,7 @@ import { prepareRoutes, RouterApplication } from "./router.tsx";
 export * from "../client/index.ts";
 export { configureApplication } from "../core/environment.ts";
 
+/** Browser hydration settings for hash history, deployment recovery and deferred-data timeout. */
 export interface MountApplicationOptions {
   hash?: boolean;
   deployment?: DeploymentOptions | null;
@@ -26,6 +32,7 @@ export interface MountApplicationOptions {
   deferredTimeout?: number;
 }
 
+/** Create the browser application router and hydrate the document, installing recovery before initial lazy loading. */
 export async function mountApplication(
   routes: AppRoute[],
   rootModule?: RootModule,
@@ -117,29 +124,3 @@ export async function mountApplication(
 
   return router;
 }
-
-function connectHashHistory(router: Router) {
-  const read = router.getSnapshot;
-  const navigate = router.navigate;
-  router.navigate = async (url, options) => {
-    const target = new URL(url, router.getSnapshot().url);
-    const hash = `#${target.pathname}${target.search}${target.hash}`;
-    history[options?.replace ? "replaceState" : "pushState"](null, "", hash);
-    await navigate(url, options);
-  };
-  const unsubscribe = router.subscribe(() => {
-    const target = new URL(read().url);
-    const hash = `#${target.pathname}${target.search}${target.hash}`;
-
-    // Redirects commit inside the router rather than through navigate().
-    if (location.hash !== hash) history.replaceState(history.state, "", hash);
-  });
-  const onHashChange = () => void navigate(location.hash.slice(1) || "/");
-  window.addEventListener("hashchange", onHashChange);
-  const dispose = router.dispose;
-  router.dispose = () => {
-    unsubscribe();
-    window.removeEventListener("hashchange", onHashChange);
-    dispose();
-  };
-}

package/.generated/preact/deferred-hydration.ts

@@ -1,98 +1 @@
-type Settlement = [number, unknown, string | null];
-
-interface PendingValue {
-  promise: Promise<unknown>;
-  resolve: (value: unknown) => void;
-  reject: (reason: Error) => void;
-}
-
-export interface DeferredWindow extends Window {
-  __smolterDeferred?: Settlement[];
-}
-
-/** Restore promise identity before hydrating Suspense boundaries. */
-export function readHydration(json: string, timeout = 30_000) {
-  if (!Number.isInteger(timeout) || timeout < 1 || timeout > 2_147_483_647)
-    throw new RangeError(
-      "deferredTimeout must be an integer between 1 and 2147483647 ms",
-    );
-
-  const pending = new Map<number, PendingValue>();
-  const queue = ((window as DeferredWindow).__smolterDeferred ??= []);
-
-  function revive(_key: string, value: unknown): unknown {
-    if (!value || typeof value !== "object") return value;
-    if ("__smolterUndefined" in value) return undefined;
-
-    if (
-      "__smolterPending" in value &&
-      typeof value.__smolterPending === "number"
-    ) {
-      const id = value.__smolterPending;
-      const existing = pending.get(id);
-      if (existing) return existing.promise;
-
-      let resolve!: PendingValue["resolve"];
-      let reject!: PendingValue["reject"];
-      const promise = new Promise((accept, fail) => {
-        resolve = accept;
-        reject = fail;
-      });
-      void promise.catch(() => {});
-      pending.set(id, { promise, resolve, reject });
-
-      return promise;
-    }
-
-    if ("__smolterRejected" in value) {
-      const failure = value.__smolterRejected as { message: string };
-      const rejected = Promise.reject(
-        Object.assign(new Error(failure.message), failure),
-      );
-      void rejected.catch(() => {});
-
-      return rejected;
-    }
-
-    return value;
-  }
-
-  const hydration = JSON.parse(json, revive);
-  const dispose = () => {
-    clearTimeout(deadline);
-    window.removeEventListener("DOMContentLoaded", dispose);
-    for (const target of pending.values())
-      target.reject(new Error("Hydration stream closed"));
-    pending.clear();
-    queue.push = () => 0;
-  };
-  const deadline = pending.size
-    ? setTimeout(() => {
-        for (const target of pending.values())
-          target.reject(new Error("Hydration stream timed out"));
-        dispose();
-      }, timeout)
-    : undefined;
-  const receive = (packet: Settlement) => {
-    const [id, value, error] = packet;
-    if (id === -1) return dispose();
-
-    const target = pending.get(id);
-    if (!target) return;
-
-    if (error !== null) target.reject(new Error(error));
-    if (error === null)
-      target.resolve(JSON.parse(JSON.stringify(value), revive));
-  };
-  const buffered = queue.splice(0);
-  queue.push = (...packets) => {
-    packets.forEach(receive);
-    return 0;
-  };
-
-  window.addEventListener("DOMContentLoaded", dispose, { once: true });
-  buffered.forEach(receive);
-  if (document.readyState !== "loading") dispose();
-
-  return { hydration, dispose };
-}
+export { type DeferredWindow, readHydration } from "../client/hydration.ts";

package/.generated/preact/document.tsx

@@ -1,3 +1,8 @@
+/**
+ * Preact document metadata, resource links and hydration scripts.
+ *
+ * @module
+ */
 /** @jsxImportSource preact */
 
 import { applicationEnvironment } from "../core/environment.ts";
@@ -34,6 +39,7 @@ function renderMeta(item: MetaDescriptor, index: number) {
   });
 }
 
+/** Render root or active-route metadata in the document head. */
 export function Meta(): import("preact").JSX.Element {
   const { routes, rootModule } = useApplication();
   const snapshot = useSnapshot();
@@ -55,6 +61,7 @@ export function Meta(): import("preact").JSX.Element {
   return <Fragment>{values.map(renderMeta)}</Fragment>;
 }
 
+/** Render stylesheet and other link descriptors from the application root. */
 export function Links(): import("preact").JSX.Element {
   const { rootModule } = useApplication();
 
@@ -67,10 +74,12 @@ export function Links(): import("preact").JSX.Element {
   );
 }
 
+/** Nonce and browser entry options for the document hydration scripts. */
 export interface ScriptProps {
   nonce?: string;
 }
 
+/** Render the hydration snapshot and browser entry script with an optional CSP nonce. */
 export function Scripts({ nonce }: ScriptProps): import("preact").JSX.Element {
   const { root, rootError, router, entry, streaming, initialData } =
     useApplication();
@@ -119,6 +128,7 @@ export function Scripts({ nonce }: ScriptProps): import("preact").JSX.Element {
   );
 }
 
+/** Reset scroll after navigation unless the navigation requests preservation. */
 export function ScrollRestoration(_props: ScriptProps): null {
   const { router } = useApplication();
   const { url, state } = useSnapshot();

package/.generated/preact/index.ts

@@ -1,4 +1,8 @@
-/** Framework components and typed data hooks. @module */
+/**
+ * Preact routing components, typed data hooks and application integration.
+ *
+ * @module
+ */
 export type * from "../core/index.ts";
 export {
   createDataRouter,
@@ -30,5 +34,10 @@ export {
   useSubmit,
 } from "./route-hooks.tsx";
 export * from "./route-types.ts";
-export { Outlet, RouterApplication } from "./router.tsx";
+export {
+  type ApplicationProps,
+  Outlet,
+  type OutletProps,
+  RouterApplication,
+} from "./router.tsx";
 export * from "./routes.ts";

package/.generated/preact/lazy-route.ts

@@ -1,3 +1,8 @@
+/**
+ * On-demand Preact route modules with shared intent prefetching.
+ *
+ * @module
+ */
 import { serverRoute } from "../client/index.ts";
 import type { DataArgs, RouteModule, Router } from "../core/index.ts";
 import { type ComponentType, createElement } from "preact";
@@ -6,6 +11,7 @@ import type { AppRoute } from "./route-types.ts";
 import type { ErrorProps } from "./routes.ts";
 import { useSyncExternalStore } from "./runtime.ts";
 
+/** Lazy route path, server transport endpoint and available handler capabilities. */
 export interface LazyRouteOptions {
   path: string;
   dataEndpoint?: string;
@@ -36,6 +42,7 @@ function LazyView() {
   return Component && createElement(Component, {});
 }
 
+/** Create a route that imports its module on demand and shares the import with intent prefetching. */
 export function lazyRoute(
   options: LazyRouteOptions,
   importer: () => Promise<LoadedRoute>,

package/.generated/preact/navigation.tsx

@@ -7,7 +7,7 @@ import { navigationClick } from "../core/url.ts";
 import type { TargetedMouseEvent } from "preact";
 import type { ComponentProps, ReactNode } from "preact/compat";
 import { useRouter, useSnapshot } from "./context.ts";
-import { useURLLocation } from "./route-hooks.tsx";
+import { useNavigation, useURLLocation } from "./route-hooks.tsx";
 import type { AppRoute } from "./route-types.ts";
 import { createElement } from "./runtime.ts";
 
@@ -15,11 +15,13 @@ export type { NavigateOptions } from "../core/index.ts";
 
 export type { NavigationType } from "../core/navigation.ts";
 
+/** Navigate to a URL or move through browser history using a numeric offset. */
 export type NavigateFunction = (
   to: string | number | Partial<Pick<URL, "pathname" | "search" | "hash">>,
   options?: NavigateOptions,
 ) => void;
 
+/** Anchor properties and router navigation options, including document reload and prefetch controls. */
 export interface LinkProps extends Omit<ComponentProps<"a">, "href" | "role"> {
   to?: string;
   href?: string;
@@ -47,11 +49,13 @@ export interface LinkProps extends Omit<ComponentProps<"a">, "href" | "role"> {
   reloadDocument?: boolean;
 }
 
+/** Active and pending flags supplied to NavLink render callbacks. */
 export interface NavLinkRenderProps {
   isActive: boolean;
   isPending: boolean;
 }
 
+/** Link options with matching rules and state-aware class or children callbacks. */
 export interface NavLinkProps
   extends Omit<LinkProps, "className" | "children"> {
   end?: boolean;
@@ -59,6 +63,7 @@ export interface NavLinkProps
   children?: ReactNode | ((state: NavLinkRenderProps) => ReactNode);
 }
 
+/** Render an anchor with same-origin router navigation and optional intent prefetching. */
 export function Link(options: LinkProps): ReactNode {
   const {
     href: hrefProp,
@@ -115,6 +120,7 @@ export function Link(options: LinkProps): ReactNode {
   });
 }
 
+/** Render a Link with active-route state and aria-current for the matching destination. */
 export function NavLink({
   href,
   to = href ?? "/",
@@ -124,11 +130,19 @@ export function NavLink({
   ...props
 }: NavLinkProps): ReactNode {
   const location = useURLLocation();
-  const target = new URL(to, location.href).pathname;
+  const destination = resolveApplicationURL(new URL(to, location.href));
+  const target = destination.pathname;
   const isActive =
-    location.pathname === target ||
-    (!end && target !== "/" && location.pathname.startsWith(`${target}/`));
-  const state = { isActive, isPending: false };
+    destination.origin === location.origin &&
+    (location.pathname === target ||
+      (!end && target !== "/" && location.pathname.startsWith(`${target}/`)));
+  const pending = useNavigation().location;
+  const isPending =
+    !!pending &&
+    pending.origin === destination.origin &&
+    (pending.pathname === target ||
+      (!end && target !== "/" && pending.pathname.startsWith(`${target}/`)));
+  const state = { isActive, isPending };
 
   return createElement(Link, {
     ...props,