@kasperrt/smolter 0.4.2 → 0.4.3

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/resource-types.ts

@@ -1,16 +1,19 @@
 export type Params = Readonly<Record<string, string>>;
 
+/** Resource parameters and cancellation signal supplied to a loader. */
 export interface LoaderFunctionArgs {
   params: Params;
   signal: AbortSignal;
 }
 
+/** Submitted input, resource parameters and cancellation signal supplied to an action. */
 export interface ActionFunctionArgs<Input = unknown> {
   input: Input;
   params: Params;
   signal: AbortSignal;
 }
 
+/** Successful resource data or a normalized resource failure. */
 export interface DataResult<Data> {
   data: Data | null;
   error: string;
@@ -23,6 +26,7 @@ export interface ResourceModule {
   shouldRevalidate?: (args: ShouldRevalidateFunctionArgs) => boolean;
 }
 
+/** Navigation or mutation context used to decide whether loader data should refresh. */
 export interface ShouldRevalidateFunctionArgs {
   actionResult: DataResult<unknown>;
   defaultShouldRevalidate: boolean;

package/.generated/core/resources.ts

@@ -18,6 +18,7 @@ const IDLE_ROUTE_STATE: RouteState = {
   unexpectedError: false,
 };
 
+/** Manage keyed resource reads, submissions, subscriptions and cancellation independently of navigation. */
 export class ResourceRouter {
   readonly #cleanupTimers = new Map<string, ReturnType<typeof setTimeout>>();
   readonly #controllers = new Map<string, AbortController>();
@@ -427,6 +428,7 @@ export class ResourceRouter {
   }
 }
 
+/** Create an independent resource-data router from registered modules; this does not manage URL history. */
 export function createResourceRouter(
   routes: ReadonlyMap<string, ResourceModule>,
 ): ResourceRouter {

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 {
@@ -19,6 +23,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 +31,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,

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,5 @@ export {
   useSubmit,
 } from "./route-hooks.tsx";
 export * from "./route-types.ts";
-export { Outlet, RouterApplication } from "./router.tsx";
+export { 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

@@ -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 ?? "/",

package/.generated/preact/route-hooks.tsx

@@ -15,6 +15,7 @@ import { OutletContext, useApplication } from "./root-context.ts";
 import type { RouteData } from "./route-types.ts";
 import { useContext, useMemo } from "./runtime.ts";
 
+/** Read root loader data from the application context. */
 export function useRootData<T = unknown>(): RouteData<T> {
   return useApplication().root as RouteData<T>;
 }
@@ -37,10 +38,12 @@ export function useRouteLoaderData<T = unknown>(
 
 export { useSnapshot };
 
+/** Read the current route error for an error boundary. */
 export function useRouteError(): Error | undefined {
   return useSnapshot("error");
 }
 
+/** Read the current page navigation or submission state. */
 export function useNavigation(): {
   state: "idle" | "loading" | "submitting";
   location: URL | undefined;
@@ -58,24 +61,27 @@ export function useNavigation(): {
   );
 }
 
+/** Read the active flat route match and loader data; this is not a nested layout match chain. */
 export function useMatches(): {
   id: string;
   data: unknown;
   params: import("../core/index.ts").Params;
 }[] {
-  const { routes } = useApplication();
+  const router = useRouter();
   const snapshot = useSnapshot();
-  const route = routes.find((item) => item.path === snapshot.path);
+  const route = router.routes.find((item) => item.path === snapshot.path);
 
   return [
     { id: route?.id ?? "", data: snapshot.data, params: snapshot.params },
   ];
 }
 
+/** Read context supplied by the nearest Outlet. */
 export function useOutletContext<T>(): T {
   return useContext(OutletContext) as T;
 }
 
+/** Return a function that submits form data through the current router. */
 export function useSubmit(): (
   value: Submission,
   options?: SubmissionOptions,
@@ -103,6 +109,7 @@ export function useSubmit(): (
   );
 }
 
+/** Read the current router location as a URL. */
 export function useURLLocation(): URL & { state: unknown; key: string } {
   const href = useSnapshot("url");
   const snapshot = useNavigationSnapshot(useRouter<Router>());
@@ -117,6 +124,7 @@ export function useURLLocation(): URL & { state: unknown; key: string } {
   );
 }
 
+/** Return the application navigation function, including history offsets and relative destinations. */
 export function useNavigate(): NavigateFunction {
   const router = useRouter<Router>();
 
@@ -139,6 +147,7 @@ export function useNavigate(): NavigateFunction {
   );
 }
 
+/** Read URL search parameters and update them through router navigation. */
 export function useSearchParams(): [
   URLSearchParams,
   (
@@ -165,6 +174,7 @@ export function useSearchParams(): [
   return [params, set];
 }
 
+/** Read the last browser history operation. */
 export function useNavigationType(): NavigationType {
   return useNavigationSnapshot(useRouter<Router>()).type;
 }

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

@@ -7,30 +7,38 @@ import type {
 import type { DataResponse } from "../core/responses.ts";
 import type { ComponentType, ReactNode } from "preact/compat";
 
+/** Request, route parameters and cancellation signal supplied to a loader. */
 export interface LoaderFunctionArgs extends DataArgs {
   context?: unknown;
 }
 
+/** Request, route parameters and cancellation signal supplied to an action. */
 export type ActionFunctionArgs = LoaderFunctionArgs;
 
+/** Loader arguments with a serverLoader callback for the server transport. */
 export interface ClientLoaderFunctionArgs extends LoaderFunctionArgs {
   serverLoader: <T = unknown>() => Promise<T>;
 }
 
+/** Action arguments with a serverAction callback for the server transport. */
 export interface ClientActionFunctionArgs extends LoaderFunctionArgs {
   serverAction: <T = unknown>() => Promise<T>;
 }
 
+/** Navigation or mutation context used to decide whether loader data should refresh. */
 export type ShouldRevalidateFunctionArgs = RevalidationArgs;
 
 type UnwrapData<T> = T extends DataResponse<infer V> ? V : T;
 
+/** Infer successful loader data, unwrapping promises and data responses. */
 export type RouteData<T> = T extends (...args: never[]) => infer R
   ? UnwrapData<Exclude<Awaited<R>, Response | Error>>
   : T;
 
+/** A document metadata descriptor, such as a title, meta tag or structured-data record. */
 export type MetaDescriptor = Record<string, unknown>;
 
+/** Loader data, error, parameters and location supplied to a route metadata function. */
 export interface MetaArgs<T> {
   data: RouteData<T> | undefined;
   loaderData: RouteData<T> | undefined;
@@ -39,10 +47,13 @@ export interface MetaArgs<T> {
   location: URL;
 }
 
+/** Derive document metadata descriptors from the current route data and location. */
 export type MetaFunction<T = unknown> = (args: MetaArgs<T>) => MetaDescriptor[];
 
+/** Return link descriptors rendered in the document head. */
 export type LinksFunction = () => Record<string, string>[];
 
+/** Data route with optional lazy component, preload and document metadata integration. */
 export interface AppRoute extends Route {
   resolveComponent?: () => ComponentType | undefined;
   preload?: () => Promise<void>;
@@ -51,6 +62,7 @@ export interface AppRoute extends Route {
   meta?: MetaFunction;
 }
 
+/** Root document components, loader, metadata and revalidation policy for a Preact application. */
 export interface RootModule {
   /** Route identity used by targeted revalidation. Defaults to root. */
   id?: string;
@@ -65,12 +77,14 @@ export interface RootModule {
   shouldRevalidate?: (args: RevalidationArgs) => boolean;
 }
 
+/** Serialized root data and route snapshot used to hydrate without repeating initial loaders. */
 export interface Hydration {
   rootError?: boolean;
   root: unknown;
   snapshot: Snapshot;
 }
 
+/** Transform a data transport response using the current request context. */
 export type HandleDataRequestFunction = (
   response: Response,
   args: LoaderFunctionArgs,

package/.generated/preact/router.tsx

@@ -14,11 +14,13 @@ import type { AppRoute } from "./route-types.ts";
 import { Routes } from "./routes.ts";
 import { useContext, useMemo, useSyncExternalStore } from "./runtime.ts";
 
+/** Optional children and context shared with descendants through useOutletContext. */
 export interface OutletProps {
   context?: unknown;
   children?: ReactNode;
 }
 
+/** Render supplied children or the active route, and provide outlet context to descendants. */
 export function Outlet({
   context,
   children,
@@ -37,6 +39,7 @@ export interface ApplicationProps extends ApplicationContext {
   rootStore?: ReturnType<typeof createRootStore>;
 }
 
+/** Render a Preact root document and active route with shared root data and application context. */
 export function RouterApplication(
   props: ApplicationProps,
 ): import("preact").JSX.Element {

package/.generated/react/data.ts

@@ -1,4 +1,8 @@
-/** Resource subscriptions independent of URL navigation. @module */
+/**
+ * Independent React resource data, forms and subscriptions.
+ *
+ * @module
+ */
 export type {
   ActionFunctionArgs as ResourceActionArgs,
   DataResult as ResourceResult,

package/.generated/react/index.ts

@@ -1,4 +1,8 @@
-/** Framework components and typed data hooks. @module */
+/**
+ * React routing components, typed data hooks and forms.
+ *
+ * @module
+ */
 export type * from "../core/index.ts";
 export {
   createDataRouter,
@@ -14,4 +18,10 @@ export * from "./fetcher.ts";
 export * from "./form.ts";
 export * from "./hooks.ts";
 export * from "./link.ts";
+export {
+  Outlet,
+  type OutletProps,
+  useMatches,
+  useOutletContext,
+} from "./outlet.ts";
 export * from "./routes.ts";

package/.generated/react/outlet.ts

@@ -0,0 +1,48 @@
+import { useRouter, useSnapshot } from "./context.ts";
+import { Routes } from "./routes.ts";
+import {
+  createContext,
+  createElement,
+  type ReactNode,
+  useContext,
+} from "./runtime.ts";
+
+const OutletContext = createContext<unknown>(undefined);
+
+/** Optional children and context shared with descendants through useOutletContext. */
+export interface OutletProps {
+  context?: unknown;
+  children?: ReactNode;
+}
+
+/** Render the active route under a layout's shared context. */
+export function Outlet({ context, children }: OutletProps): ReactNode {
+  const inherited = useContext(OutletContext);
+  return createElement(
+    OutletContext.Provider,
+    { value: context ?? inherited },
+    children ??
+      createElement(Routes, {
+        fallback: createElement("p", { role: "status" }, "Loading…"),
+      }),
+  );
+}
+
+/** Read the nearest Outlet's context. */
+export function useOutletContext<T>(): T {
+  return useContext(OutletContext) as T;
+}
+
+/** Read the active flat route match; this is not a nested layout match chain. */
+export function useMatches(): {
+  id: string;
+  data: unknown;
+  params: import("../core/index.ts").Params;
+}[] {
+  const router = useRouter();
+  const snapshot = useSnapshot();
+  const route = router.routes.find((item) => item.path === snapshot.path);
+  return [
+    { id: route?.id ?? "", data: snapshot.data, params: snapshot.params },
+  ];
+}

package/.generated/react/resources/components.tsx

@@ -23,6 +23,7 @@ import {
   useSyncExternalStore,
 } from "react";
 
+/** Resource handlers with optional React content, pending UI and retry boundary. */
 export interface ResourceRouteModule extends ResourceModule {
   default?: ComponentType;
   ErrorBoundary?: ComponentType<{ retry: () => void }>;
@@ -42,6 +43,7 @@ interface RouterProviderProps extends PropsWithChildren {
   router: ResourceRouter;
 }
 
+/** Provide a resource router and load initial matches; dispose it when unmounted. */
 export function RouterProvider({
   children,
   initialMatches = EMPTY_MATCHES,
@@ -66,6 +68,7 @@ interface RouteProps extends PropsWithChildren {
   routeId: string;
 }
 
+/** Provide a resource route and render its content, loading state or retry boundary. */
 export function Route({
   children,
   params = {},
@@ -121,12 +124,14 @@ export function Route({
   );
 }
 
+/** Read the current resource route loader result. */
 export function useLoaderData<Data>(): Data | null {
   const route = useCurrentRoute();
 
   return useRouteLoaderData<Data>(route.routeId, route.params);
 }
 
+/** Read loader data for a registered resource route. */
 export function useRouteLoaderData<Data>(
   routeId: string,
   params: Params = {},
@@ -136,6 +141,7 @@ export function useRouteLoaderData<Data>(
   return state.loaderData as Data | null;
 }
 
+/** Read the current resource route action result. */
 export function useActionData<Data>(): Data | null {
   const route = useCurrentRoute();
   const state = useRouteState(route.routeId, route.params, false);
@@ -143,6 +149,7 @@ export function useActionData<Data>(): Data | null {
   return state.actionData as Data | null;
 }
 
+/** Read the current page navigation or submission state. */
 export function useNavigation(): { state: NavigationState } {
   const route = useCurrentRoute();
   const state = useRouteState(route.routeId, route.params, false);
@@ -150,6 +157,7 @@ export function useNavigation(): { state: NavigationState } {
   return { state: state.navigationState };
 }
 
+/** Return the resource route revalidation function. */
 export function useRevalidator(): {
   revalidate: () => Promise<DataResult<unknown>>;
   state: string;
@@ -183,6 +191,7 @@ interface FormProps extends PropsWithChildren {
   params?: Params;
 }
 
+/** Submit a resource action from a form without document navigation. */
 export function Form({
   action,
   children,
@@ -208,6 +217,7 @@ export function Form({
   return <FormContext.Provider value={submit}>{children}</FormContext.Provider>;
 }
 
+/** Return a function that submits form data through the current router. */
 export function useSubmit(): (input?: unknown) => Promise<DataResult<unknown>> {
   const submit = useContext(FormContext);
 
@@ -216,6 +226,7 @@ export function useSubmit(): (input?: unknown) => Promise<DataResult<unknown>> {
   return submit;
 }
 
+/** Read or mutate a resource independently of the rendered route. */
 export function useFetcher<Data = unknown>(
   options: FetcherOptions = {},
 ): readonly [
@@ -312,6 +323,7 @@ export function useFetcher<Data = unknown>(
   return [fetcherState, fetcherOperations] as const;
 }
 
+/** Read the resource router supplied by its provider. */
 export function useRouter(): ResourceRouter {
   const router = useContext(RouterContext);
 

package/.generated/server/application.tsx

@@ -17,11 +17,13 @@ import { privateResponse } from "./private-response.ts";
 import { progressiveDocument } from "./progressive-document.ts";
 import { resolveHydration, streamDocument } from "./stream-document.ts";
 
+/** SSR settings for CSP nonce and early deferred-data hydration. */
 export interface RenderApplicationOptions {
   nonce?: string;
   earlyHydration?: boolean;
 }
 
+/** Render a Preact application response with root and route data, streaming deferred content when enabled. */
 export async function renderApplication(
   request: Request,
   routes: AppRoute[],
@@ -260,6 +262,7 @@ async function dispatch(
   return Response.json((await normalizeResult(value)) ?? null);
 }
 
+/** Dispatch a normalized application URL to its route loader or action and return an HTTP response. */
 export async function dispatchRoute(
   request: Request,
   routes: AppRoute[],