@kasperrt/smolter 0.0.0-stage → 0.0.1-rc.1

package/dist/internal/core/router.d.ts

@@ -0,0 +1,3 @@
+import type { Route, Router, RouterOptions } from "./types.ts";
+/** Create an isolated router. Use browser: true for browser history, or loadRouter for SSR. */
+export declare function createRouter(routes: readonly Route[], options?: RouterOptions): Router;

package/dist/internal/core/router.js

@@ -0,0 +1,189 @@
+import { safeWrapAsync } from "./errors.js";
+import { matchRoutes } from "./match.js";
+import { internalURL } from "./url.js";
+/** Create an isolated router. Use browser: true for browser history, or loadRouter for SSR. */
+export function createRouter(routes, options = {}) {
+    const browser = options.browser && typeof window !== "undefined";
+    let initialized = options.hydrationData?.state === "idle";
+    const initial = {
+        loaded: initialized,
+        ...(options.hydrationData ?? {
+            url: new URL(options.url ?? (browser ? location.href : "/"), "http://localhost").href,
+            params: {},
+            state: "idle",
+        }),
+    };
+    const disposers = new Set();
+    const channel = (initial, local = false) => {
+        let snapshot = initial;
+        let controller;
+        const listeners = new Set();
+        const dispose = () => {
+            disposers.delete(dispose);
+            controller?.abort();
+            listeners.clear();
+        };
+        const emit = (next) => {
+            snapshot = { ...snapshot, ...next };
+            for (const listener of listeners)
+                listener();
+        };
+        const run = async (href, body, operation = {}, 
+        // true pushes history; false handles popstate; undefined is a data request.
+        navigation) => {
+            controller?.abort();
+            controller = new AbortController();
+            const { signal } = controller;
+            disposers.add(dispose);
+            const previous = snapshot;
+            const url = internalURL(main.getSnapshot().url, href);
+            const match = url && matchRoutes(routes, url.pathname);
+            const commit = () => {
+                if (local || !url)
+                    return;
+                const changed = snapshot.url !== url.href;
+                if (!changed && snapshot.path !== undefined)
+                    return;
+                if (browser && (navigation || body) && changed)
+                    history[operation.replace ? "replaceState" : "pushState"](null, "", url);
+                const sameRoute = snapshot.path === match?.route.path;
+                snapshot = {
+                    ...snapshot,
+                    url: url.href,
+                    path: match?.route.path,
+                    params: match?.params ?? {},
+                    actionData: undefined,
+                    data: sameRoute ? snapshot.data : undefined,
+                    loaded: sameRoute && snapshot.loaded,
+                };
+            };
+            if (!body)
+                commit();
+            emit({ state: body ? "submitting" : "loading", error: undefined });
+            const result = await safeWrapAsync(() => {
+                if (!match)
+                    return new Error(url ? "No route" : "External URL");
+                if (navigation !== undefined &&
+                    !body &&
+                    previous.loaded &&
+                    !previous.error &&
+                    previous.path === match.route.path &&
+                    match.route.shouldRevalidate?.({
+                        url,
+                        currentUrl: new URL(previous.url),
+                        nextUrl: url,
+                        defaultShouldRevalidate: true,
+                        reason: "navigation",
+                    }) === false)
+                    return previous.data;
+                const fn = match.route[body ? "clientAction" : "clientLoader"] ||
+                    match.route[body ? "action" : "loader"];
+                if (!fn)
+                    return body && new Error("No action");
+                return fn({
+                    request: new Request(url, {
+                        signal,
+                        method: body && (operation.method ?? "POST"),
+                        body,
+                    }),
+                    params: match.params,
+                    signal,
+                });
+            });
+            if (signal.aborted)
+                return result;
+            const redirectTo = result.data instanceof Response && result.data.headers.get("Location");
+            if (redirectTo && (operation.hops ?? 0) < 10) {
+                await main.load(new URL(redirectTo, url).href, undefined, {
+                    replace: true,
+                    hops: (operation.hops ?? 0) + 1,
+                }, true);
+                if (!signal.aborted)
+                    emit({ state: "idle" });
+                return result;
+            }
+            if (redirectTo)
+                result.error = new Error("Redirect loop");
+            if (body && !result.error)
+                commit();
+            emit({
+                [body && !local ? "actionData" : "data"]: result.data,
+                error: result.error,
+                loaded: body ? snapshot.loaded : !result.error,
+                state: body && !result.error ? "loading" : "idle",
+            });
+            if (body && !result.error) {
+                await router.revalidate("action", {
+                    formMethod: operation.method ?? "POST",
+                    formAction: url.href,
+                    formData: body,
+                    actionResult: result.data,
+                });
+                if (!signal.aborted)
+                    emit({ state: "idle" });
+            }
+            return result;
+        };
+        return {
+            getSnapshot: () => snapshot,
+            subscribe(listener) {
+                listeners.add(listener);
+                return () => {
+                    listeners.delete(listener);
+                };
+            },
+            load: run,
+            submit: run,
+            dispose,
+        };
+    };
+    const main = channel(initial);
+    let started = 0;
+    const pop = () => {
+        void main.load(location.href, undefined, undefined, false);
+    };
+    const router = {
+        ...main,
+        routes,
+        start() {
+            if (!started++ && browser)
+                addEventListener("popstate", pop);
+            if (!initialized) {
+                initialized = true;
+                void main.load(initial.url);
+            }
+            return () => {
+                if (!--started && browser)
+                    removeEventListener("popstate", pop);
+            };
+        },
+        async navigate(url, operation) {
+            initialized = true;
+            await main.load(url, undefined, operation, true);
+        },
+        async revalidate(reason = "manual", context = {}) {
+            const url = new URL(main.getSnapshot().url);
+            if (matchRoutes(routes, url.pathname)?.route.shouldRevalidate?.({
+                ...context,
+                url,
+                currentUrl: url,
+                nextUrl: url,
+                defaultShouldRevalidate: true,
+                reason,
+            }) === false)
+                return;
+            await main.load(url.href);
+        },
+        createFetcher() {
+            return channel({ state: "idle" }, true);
+        },
+        dispose() {
+            main.dispose();
+            for (const dispose of disposers)
+                dispose();
+            if (browser)
+                removeEventListener("popstate", pop);
+        },
+    };
+    return router;
+}

package/dist/internal/core/types.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Framework-independent route matching, data requests, and state.
+ * @module
+ */
+/** Framework-independent data routing. No global request state. */
+export type Params = Record<string, string>;
+/** Request, path parameters, and cancellation signal passed to a data handler. */
+export interface DataArgs {
+    request: Request;
+    params: Params;
+    signal: AbortSignal;
+}
+/** A loader or action that returns data, a Response, or an Error value. */
+export type DataFunction = (args: DataArgs) => unknown;
+/** A handler signature used to infer data from specialized loader and action arguments. */
+export type AnyDataFunction = (...args: never[]) => unknown;
+/** Client loader arguments, including a typed call to the server loader. */
+export interface ClientLoaderArgs<L extends AnyDataFunction = DataFunction> extends DataArgs {
+    serverLoader: () => Promise<DataOf<L>>;
+}
+/** Client action arguments, including a typed call to the server action. */
+export interface ClientActionArgs<A extends AnyDataFunction = DataFunction> extends DataArgs {
+    serverAction: () => Promise<DataOf<A>>;
+}
+/** The resolved data returned by a handler, excluding Error values. */
+export type DataOf<F> = F extends AnyDataFunction ? Exclude<Awaited<ReturnType<F>>, Error> : undefined;
+/** Mutation details supplied when deciding whether to reload route data. */
+export interface RevalidationContext {
+    formMethod?: string;
+    formAction?: string;
+    formData?: FormData;
+    actionResult?: unknown;
+}
+/** Current URL, mutation result, and reason passed to shouldRevalidate. */
+export interface RevalidationArgs extends RevalidationContext {
+    currentUrl: URL;
+    nextUrl: URL;
+    defaultShouldRevalidate: boolean;
+    url: URL;
+    reason: "manual" | "action" | "navigation";
+}
+/** A route component and its optional server and client data handlers. */
+export interface RouteModule {
+    default?: unknown;
+    HydrateFallback?: unknown;
+    ErrorBoundary?: unknown;
+    loader?: DataFunction;
+    action?: DataFunction;
+    clientLoader?(args: ClientLoaderArgs): unknown;
+    clientAction?(args: ClientActionArgs): unknown;
+    shouldRevalidate?: (args: RevalidationArgs) => boolean;
+}
+/** A route module associated with an explicit URL pattern. */
+export type Route<M extends RouteModule = RouteModule> = M & {
+    path: string;
+};
+/** The first matching route and its decoded path parameters. */
+export interface Match {
+    route: Route;
+    params: Params;
+}
+/** Immutable current route state observed by framework hooks. */
+export interface Snapshot {
+    url: string;
+    path?: string;
+    params: Params;
+    data?: unknown;
+    /** Whether this route has completed a loader, including an undefined result. */
+    loaded?: boolean;
+    actionData?: unknown;
+    error?: Error;
+    state: "idle" | "loading" | "submitting";
+}
+/** Initial URL, browser history, and hydration configuration. */
+export interface RouterOptions {
+    url?: string;
+    /** Explicitly opt into browser history; leave off for SSR and tests. */
+    browser?: boolean;
+    hydrationData?: Snapshot;
+}
+/** Options for replacing rather than appending a browser history entry. */
+export interface NavigateOptions {
+    replace?: boolean;
+}
+/** HTTP method for a route action submission; defaults to POST. */
+export interface SubmitOptions {
+    method?: "POST" | "PUT" | "PATCH" | "DELETE";
+}
+/** A resolved operation result, with either data or a normalized Error. */
+export interface Result<T = unknown> {
+    data?: T;
+    error?: Error;
+}
+/** Independent fetcher data, error, and pending state. */
+export interface FetcherSnapshot extends Result {
+    state: Snapshot["state"];
+}
+/** An independent loader/action channel that does not navigate the page. */
+export interface Fetcher {
+    getSnapshot: () => FetcherSnapshot;
+    subscribe: (listener: () => void) => () => void;
+    load: (url: string) => Promise<Result>;
+    submit: (url: string, body: FormData, options?: SubmitOptions) => Promise<Result>;
+    /** Abort work and release subscriptions when this imperative fetcher is no longer used. */
+    dispose: () => void;
+}
+/** Route navigation, subscriptions, fetchers, and loader revalidation. */
+export interface Router {
+    routes: readonly Route[];
+    getSnapshot: () => Snapshot;
+    subscribe: (listener: () => void) => () => void;
+    start: () => () => void;
+    navigate: (url: string, options?: NavigateOptions) => Promise<void>;
+    revalidate: (reason?: RevalidationArgs["reason"], context?: RevalidationContext) => Promise<void>;
+    submit: (url: string, body: FormData, options?: SubmitOptions) => Promise<Result>;
+    /** Create an independent fetcher. Framework useFetcher hooks manage disposal automatically. */
+    createFetcher: () => Fetcher;
+    dispose: () => void;
+}

package/dist/internal/core/types.js

@@ -0,0 +1,5 @@
+/**
+ * Framework-independent route matching, data requests, and state.
+ * @module
+ */
+export {};

package/dist/internal/core/url.d.ts

@@ -0,0 +1,2 @@
+/** Resolve an internal URL; external links remain the browser's responsibility. */
+export declare function internalURL(base: string, href?: string): URL | undefined;

package/dist/internal/core/url.js

@@ -0,0 +1,6 @@
+/** Resolve an internal URL; external links remain the browser's responsibility. */
+export function internalURL(base, href = base) {
+    const url = new URL(href, base);
+    if (url.origin === new URL(base).origin)
+        return url;
+}

package/dist/internal/files/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Build-time discovery of flat file routes.
+ * @module
+ */
+/** A discovered flat route pattern and its module file path. */
+export interface RouteFile {
+    path: string;
+    file: string;
+}
+/** Read only flat files and immediate route folders. Colocated helpers are ignored. */
+export declare function flatRoutes(directory: string): Promise<RouteFile[] | Error>;

package/dist/internal/files/index.js

@@ -0,0 +1,77 @@
+/**
+ * Build-time discovery of flat file routes.
+ * @module
+ */
+import { readdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import { safeWrapAsync } from "../core/index.js";
+const routeFile = /^route\.[jt]sx?$/;
+const flatFile = /\.[jt]sx?$/;
+/** Read only flat files and immediate route folders. Colocated helpers are ignored. */
+export async function flatRoutes(directory) {
+    const result = await safeWrapAsync(async () => {
+        const entries = await readdir(directory, { withFileTypes: true });
+        const routes = [];
+        const patterns = new Set();
+        for (const entry of entries) {
+            let name = entry.name;
+            let file = resolve(directory, name);
+            if (entry.isDirectory()) {
+                const candidates = (await readdir(file)).filter((name) => routeFile.test(name));
+                if (candidates.length > 1)
+                    return new Error(`Multiple route files in ${file}`);
+                if (!candidates.length)
+                    continue;
+                file = resolve(file, candidates[0]);
+            }
+            else {
+                if (!entry.isFile() || !flatFile.test(name) || name.endsWith(".d.ts"))
+                    continue;
+                name = name.replace(flatFile, "");
+            }
+            if (/[()[\]:*?]/.test(name))
+                return new Error(`Unsupported flat route name: ${name}`);
+            const segments = name.split(".");
+            const parts = [];
+            for (const [index, segment] of segments.entries()) {
+                if (!segment)
+                    return new Error(`Empty route segment: ${name}`);
+                if (segment === "_index" && index !== segments.length - 1)
+                    return new Error(`_index must be last: ${name}`);
+                if (segment === "$" && index !== segments.length - 1)
+                    return new Error(`Splat must be last: ${name}`);
+                if (segment.startsWith("_"))
+                    continue;
+                const part = segment.replace(/_$/, "");
+                parts.push(part === "$" ? "*" : part.replace(/^\$/, ":"));
+            }
+            // Pathless grouping modules are not nested layouts in a flat router.
+            if (segments.at(-1)?.startsWith("_") && segments.at(-1) !== "_index")
+                continue;
+            const path = `/${parts.join("/")}`;
+            const pattern = path.replace(/:[^/]+/g, ":");
+            if (patterns.has(pattern))
+                return new Error(`Conflicting flat route: ${path}`);
+            patterns.add(pattern);
+            routes.push({ path, file });
+        }
+        return routes.sort((a, b) => {
+            const left = a.path.split("/");
+            const right = b.path.split("/");
+            const rank = (part) => part === "*"
+                ? 0
+                : part?.startsWith(":")
+                    ? 1
+                    : part === undefined
+                        ? 2
+                        : 3;
+            for (let index = 0; index < Math.max(left.length, right.length); index++) {
+                const difference = rank(right[index]) - rank(left[index]);
+                if (difference)
+                    return difference;
+            }
+            return a.path.localeCompare(b.path);
+        });
+    });
+    return result.error ?? result.data;
+}

package/dist/internal/preact/context.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Preact components and typed data hooks. Import from smolter/preact.
+ * @module
+ */
+import type { Router, Snapshot } from "../core/index.ts";
+import type { ReactNode } from "./runtime.ts";
+/** Router instance and children rendered within its context. */
+export interface RouterProviderProps {
+    router: Router;
+    children?: ReactNode;
+}
+/** Provide a router to descendant hooks and connect its browser lifecycle. */
+export declare function RouterProvider({ router, children, }: RouterProviderProps): ReactNode;
+/** Hooks require a RouterProvider. */
+export declare function useRouter(): Router;
+type SnapshotSelector<T> = (snapshot: Snapshot) => T;
+export declare function useSnapshot<T>(select: SnapshotSelector<T>): T;
+export {};

package/dist/internal/preact/context.js

@@ -0,0 +1,20 @@
+/**
+ * Preact components and typed data hooks. Import from smolter/preact.
+ * @module
+ */
+import { createContext, createElement, useContext, useEffect, useSyncExternalStore, } from "./runtime.js";
+const RouterContext = createContext(undefined);
+/** Provide a router to descendant hooks and connect its browser lifecycle. */
+export function RouterProvider({ router, children, }) {
+    useEffect(router.start, [router]);
+    return createElement(RouterContext.Provider, { value: router }, children);
+}
+/** Hooks require a RouterProvider. */
+export function useRouter() {
+    return useContext(RouterContext);
+}
+export function useSnapshot(select) {
+    const router = useRouter();
+    const getSnapshot = () => select(router.getSnapshot());
+    return useSyncExternalStore(router.subscribe, getSnapshot, getSnapshot);
+}

package/dist/internal/preact/fetcher.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Preact components and typed data hooks. Import from smolter/preact.
+ * @module
+ */
+import type { AnyDataFunction, DataFunction, DataOf, FetcherSnapshot, Result, Route as RouteDefinition, RouteModule, SubmitOptions } from "../core/index.ts";
+import { type FormProps } from "./form.ts";
+import type { ComponentType } from "./runtime.ts";
+/** Action method and optional explicit route URL for a fetcher submission. */
+export interface FetcherSubmitOptions extends SubmitOptions {
+    action?: string;
+}
+/** Typed independent request state, methods, and a bound Form component. */
+export interface TypedFetcher<T> extends Omit<FetcherSnapshot, "data"> {
+    data?: T;
+    Form: ComponentType<FormProps>;
+    load: (url?: string) => Promise<Result>;
+    submit: (body: FormData, options?: FetcherSubmitOptions) => Promise<Result>;
+}
+/** Create a fetcher for independent route reads and mutations; its data stays local. */
+export declare function useFetcher<T extends RouteModule>(route: RouteDefinition<T>): TypedFetcher<DataOf<Extract<T["action"] | T["clientAction"], AnyDataFunction>> | DataOf<Extract<T["loader"] | T["clientLoader"], AnyDataFunction>>>;
+/** Create a fetcher for independent route reads and mutations; its data stays local. */
+export declare function useFetcher<T extends AnyDataFunction = DataFunction>(): TypedFetcher<DataOf<T>>;

package/dist/internal/preact/fetcher.js

@@ -0,0 +1,28 @@
+/**
+ * Preact components and typed data hooks. Import from smolter/preact.
+ * @module
+ */
+import { useRouter } from "./context.js";
+import { Form } from "./form.js";
+import { createElement, useEffect, useMemo, useSyncExternalStore, } from "./runtime.js";
+/** Create a fetcher for independent route reads and mutations; its data stays local. */
+export function useFetcher(route) {
+    const router = useRouter();
+    const path = route?.path;
+    const fetcher = useMemo(() => {
+        const store = router.createFetcher();
+        const target = () => {
+            const snapshot = router.getSnapshot();
+            return path === undefined || path === snapshot.path ? snapshot.url : path;
+        };
+        return {
+            ...store,
+            Form: (props) => createElement(Form, { action: target(), ...props, fetcher: store }),
+            load: (url) => store.load(url ?? target()),
+            submit: (body, options) => store.submit(options?.action ?? target(), body, options),
+        };
+    }, [router, path]);
+    useEffect(() => fetcher.dispose, [fetcher]);
+    const state = useSyncExternalStore(fetcher.subscribe, fetcher.getSnapshot, fetcher.getSnapshot);
+    return { ...fetcher, ...state };
+}

package/dist/internal/preact/form.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Preact components and typed data hooks. Import from smolter/preact.
+ * @module
+ */
+import type { Fetcher } from "../core/index.ts";
+import type { FormHTMLAttributes, ReactNode } from "./runtime.ts";
+/** Form attributes with GET loader requests or POST, PUT, PATCH, and DELETE actions. */
+export interface FormProps extends Omit<FormHTMLAttributes<HTMLFormElement>, "action" | "method"> {
+    action?: string;
+    method?: "get" | "post" | "put" | "patch" | "delete";
+}
+interface InternalFormProps extends FormProps {
+    fetcher?: Fetcher;
+}
+/** Submit form data to a registered route without a document reload. */
+export declare function Form({ action, method, fetcher, onSubmit, ...props }: InternalFormProps): ReactNode;
+export {};

package/dist/internal/preact/form.js

@@ -0,0 +1,41 @@
+/**
+ * Preact components and typed data hooks. Import from smolter/preact.
+ * @module
+ */
+import { internalURL } from "../core/index.js";
+import { useRouter } from "./context.js";
+import { createElement } from "./runtime.js";
+/** Submit form data to a registered route without a document reload. */
+export function Form({ action, method = "post", fetcher, onSubmit, ...props }) {
+    const router = useRouter();
+    const submit = (event) => {
+        onSubmit?.(event);
+        if (event.defaultPrevented)
+            return;
+        const submitter = event.submitter;
+        const target = internalURL(router.getSnapshot().url, submitter?.getAttribute("formaction") ?? action);
+        if (!target)
+            return;
+        event.preventDefault();
+        const data = new FormData(event.currentTarget, submitter);
+        const verb = (submitter?.getAttribute("formmethod") ?? method).toUpperCase();
+        if (verb === "GET") {
+            const search = new URLSearchParams();
+            for (const [key, value] of data)
+                search.append(key, typeof value === "string" ? value : value.name);
+            target.search = String(search);
+            void (fetcher ? fetcher.load : router.navigate)(target.href);
+            return;
+        }
+        const options = {
+            method: verb,
+        };
+        void (fetcher ?? router).submit(target.href, data, options);
+    };
+    return createElement("form", {
+        ...props,
+        action,
+        method: method === "get" ? "get" : "post",
+        onSubmit: submit,
+    });
+}

package/dist/internal/preact/hooks.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Preact components and typed data hooks. Import from smolter/preact.
+ * @module
+ */
+import type { AnyDataFunction, DataOf, RouteModule, Router, Snapshot } from "../core/index.ts";
+/** A route module or loader function used for data inference. */
+export type LoaderSource = RouteModule | AnyDataFunction;
+/** Infer server and client loader data from a route module or function. */
+export type LoaderData<T> = T extends AnyDataFunction ? DataOf<T> : T extends RouteModule ? DataOf<Extract<T["loader"] | T["clientLoader"], AnyDataFunction>> : unknown;
+/** Infer server and client action data from a route module or function. */
+export type ActionData<T> = T extends AnyDataFunction ? DataOf<T> : T extends RouteModule ? DataOf<Extract<T["action"] | T["clientAction"], AnyDataFunction>> : unknown;
+/** Pass a route for inference, or use useLoaderData<typeof loader>() in its module. */
+export declare function useLoaderData<T extends LoaderSource = RouteModule>(route?: T): LoaderData<T> | undefined;
+/** Read the last page action result, optionally inferring its type from a route. */
+export declare function useActionData<T extends LoaderSource = RouteModule>(route?: T): ActionData<T> | undefined;
+/** Read path parameters for the active route. */
+export declare function useParams(): Snapshot["params"];
+/** Read the current path, search, and hash together with the navigate function. */
+export declare function useLocation(): readonly [string, Router["navigate"]];
+/** Get the function that revalidates the current loader subject to shouldRevalidate. */
+export declare function useRevalidator(): Router["revalidate"];

package/dist/internal/preact/hooks.js

@@ -0,0 +1,35 @@
+/**
+ * Preact components and typed data hooks. Import from smolter/preact.
+ * @module
+ */
+import { useRouter, useSnapshot } from "./context.js";
+function useData(key, route) {
+    const path = route?.path;
+    return useSnapshot((snapshot) => {
+        if (path !== undefined && path !== snapshot.path)
+            return undefined;
+        return snapshot[key];
+    });
+}
+/** Pass a route for inference, or use useLoaderData<typeof loader>() in its module. */
+export function useLoaderData(route) {
+    return useData("data", route);
+}
+/** Read the last page action result, optionally inferring its type from a route. */
+export function useActionData(route) {
+    return useData("actionData", route);
+}
+/** Read path parameters for the active route. */
+export function useParams() {
+    return useSnapshot((snapshot) => snapshot.params);
+}
+/** Read the current path, search, and hash together with the navigate function. */
+export function useLocation() {
+    const router = useRouter();
+    const url = useSnapshot((snapshot) => snapshot.url);
+    return [url.replace(/^\w+:\/\/[^/]+/, ""), router.navigate];
+}
+/** Get the function that revalidates the current loader subject to shouldRevalidate. */
+export function useRevalidator() {
+    return useRouter().revalidate;
+}

package/dist/internal/preact/index.d.ts

@@ -0,0 +1,9 @@
+/** Framework components and typed data hooks. @module */
+export type * from "../core/index.ts";
+export { createRouter, defineRoute } from "../core/index.ts";
+export { RouterProvider, type RouterProviderProps, useRouter, } from "./context.ts";
+export * from "./fetcher.ts";
+export * from "./form.ts";
+export * from "./hooks.ts";
+export * from "./link.ts";
+export * from "./routes.ts";

package/dist/internal/preact/index.js

@@ -0,0 +1,7 @@
+export { createRouter, defineRoute } from "../core/index.js";
+export { RouterProvider, useRouter, } from "./context.js";
+export * from "./fetcher.js";
+export * from "./form.js";
+export * from "./hooks.js";
+export * from "./link.js";
+export * from "./routes.js";

package/dist/internal/preact/link.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Preact components and typed data hooks. Import from smolter/preact.
+ * @module
+ */
+import type { AnchorHTMLAttributes, ReactNode } from "./runtime.ts";
+/** Anchor attributes with internal navigation and optional history replacement. */
+export interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    href: string;
+    replace?: boolean;
+}
+/** Render an anchor that handles internal navigation and preserves native modified clicks. */
+export declare function Link({ href, replace, onClick, ...props }: LinkProps): ReactNode;