hono-preact 0.1.0

package/dist/iso/define-page.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+import { Page } from './page.js';
+export function definePage(Component, bindings) {
+    const PageRoute = (location) => (_jsx(Page, { Wrapper: bindings?.Wrapper, errorFallback: bindings?.errorFallback, guards: bindings?.guards, location: location, children: _jsx(Component, {}) }));
+    PageRoute.displayName = `definePage(${Component.displayName ?? Component.name ?? 'Anonymous'})`;
+    return PageRoute;
+}

package/dist/iso/define-routes.d.ts

@@ -0,0 +1,34 @@
+import type { ComponentChildren, ComponentType } from 'preact';
+import type { RouteHook } from 'preact-iso';
+export type LayoutProps = {
+    children: ComponentChildren;
+};
+export type ViewProps = RouteHook;
+type LazyImport<T> = () => Promise<{
+    default: T;
+}>;
+type LazyServerImport = () => Promise<unknown>;
+export type RouteDef = {
+    path: string;
+    view?: LazyImport<ComponentType<ViewProps>>;
+    layout?: LazyImport<ComponentType<LayoutProps>>;
+    server?: LazyServerImport;
+    children?: RouteDef[];
+};
+export type FlatRoute = {
+    path: string;
+    component: ComponentType<ViewProps>;
+    key: string;
+};
+export type RoutesManifest = {
+    tree: ReadonlyArray<RouteDef>;
+    flat: ReadonlyArray<FlatRoute>;
+    serverImports: ReadonlyArray<LazyServerImport>;
+};
+export declare function defineRoutes(tree: RouteDef[]): RoutesManifest;
+export type RoutesProps = {
+    routes: RoutesManifest;
+    onRouteChange?: (url: string) => void;
+};
+export declare const Routes: ComponentType<RoutesProps>;
+export {};

package/dist/iso/define-routes.js

@@ -0,0 +1,251 @@
+import { h } from 'preact';
+import { lazy, Route, Router, useLocation } from 'preact-iso';
+import { RouteLocationsProvider } from './internal/route-locations.js';
+function wrapWithRouteLocations(serverMod, location, node) {
+    const moduleKey = serverMod
+        ?.__moduleKey;
+    return moduleKey
+        ? h(RouteLocationsProvider, { moduleKey, location }, node)
+        : node;
+}
+// preact-iso's `Route<P>` and `Router` carry strict generics that reject our
+// heterogeneous route components (leaves take `ViewProps`, layout-group
+// wrappers take `()`). We erase the generic at every `h(Route, ...)` /
+// `h(Router, ...)` call site through this single helper so the rationale lives
+// in one place.
+const asRouteComponent = (c) => c;
+// preact-iso's `lazy()` returns a wrapper whose component-type generic is
+// loose. We know the underlying default export conforms to `ViewProps` (or to
+// our layout-group wrapper which renders an inner Router); assert that here so
+// `FlatRoute.component` stays strongly typed.
+const asViewComponent = (c) => c;
+function validate(routes, parentPath = '', context = 'top') {
+    for (const r of routes) {
+        const here = parentPath + (r.path.startsWith('/') ? r.path : '/' + r.path);
+        const hasView = !!r.view;
+        const hasLayout = !!r.layout;
+        const hasChildren = !!(r.children && r.children.length > 0);
+        if (hasView && hasLayout) {
+            throw new Error(`Route ${here}: cannot declare both \`view\` and \`layout\`.`);
+        }
+        if (hasView && hasChildren) {
+            throw new Error(`Route ${here}: \`view\` route cannot have \`children\`.`);
+        }
+        if (hasLayout && !hasChildren) {
+            throw new Error(`Route ${here}: \`layout\` requires \`children\`.`);
+        }
+        if (!hasView && !hasLayout && !hasChildren) {
+            throw new Error(`Route ${here}: must declare \`view\`, \`layout\`+\`children\`, or \`children\`.`);
+        }
+        if (parentPath !== '' && r.path.startsWith('/')) {
+            throw new Error(`Route ${here}: child path must not start with \`/\`.`);
+        }
+        if (context === 'layout-grouping' && (hasLayout || hasChildren)) {
+            throw new Error(`Route ${here}: a path-grouping inside a layout group may only contain view leaves at v0.1. ` +
+                `Move this route up a level (direct child of the layout group) or restructure as its own layout group.`);
+        }
+        if (hasChildren) {
+            const childContext = hasLayout
+                ? 'layout'
+                : context === 'layout'
+                    ? 'layout-grouping'
+                    : 'top';
+            validate(r.children, here === '/' ? '' : here, childContext);
+        }
+    }
+}
+function collectServerImports(routes) {
+    const out = [];
+    const walk = (rs) => {
+        for (const r of rs) {
+            if (r.server)
+                out.push(r.server);
+            if (r.children)
+                walk(r.children);
+        }
+    };
+    walk(routes);
+    return out;
+}
+/**
+ * Memoize `lazy(view)` per view-thunk identity. When the same `view` thunk is
+ * referenced by multiple route registrations (e.g. `/docs` and `/docs/*`),
+ * they should share one component reference so preact-iso's Router does not
+ * treat the navigation as a route change and remount the layout.
+ *
+ * When `server` is provided, the loaded view is wrapped in a
+ * RouteLocationsProvider so that loaders in the server module can read the
+ * route's location from context.
+ */
+function getOrCreateLazyView(view, server, cache) {
+    let component = cache.get(view);
+    if (!component) {
+        if (!server) {
+            component = asViewComponent(lazy(view));
+        }
+        else {
+            component = asViewComponent(lazy(async () => {
+                const [{ default: View }, serverMod] = await Promise.all([
+                    view(),
+                    server(),
+                ]);
+                // `location` from the inner Router has a relative path (e.g. `/123`
+                // when the route is nested inside a layout at `/movies/*`). Use
+                // `useLocation()` to get the full window path and searchParams so the
+                // stored location reflects the actual URL the loader runs against.
+                const Wrapped = (location) => {
+                    const { path, searchParams } = useLocation();
+                    const fullLocation = { ...location, path, searchParams };
+                    return wrapWithRouteLocations(serverMod, fullLocation, h(View, location));
+                };
+                return { default: Wrapped };
+            }));
+        }
+        cache.set(view, component);
+    }
+    return component;
+}
+/**
+ * Build the component for a layout group: <Layout><Router>{childRoutes}</Router></Layout>.
+ * Returned via preact-iso's lazy so the layout module loads only when matched.
+ * Children are themselves wrapped in preact-iso's lazy via their own `view`/`layout`,
+ * so each child remains a separate code-split chunk.
+ *
+ * When the layout declares a `server` module, a RouteLocationsProvider is
+ * installed around the layout with the layout's own matched location
+ * (i.e. the path up to and including the layout's own segments, not the
+ * inner wildcard/child segments).
+ */
+function makeLayoutGroupComponent(layoutImport, server, layoutPathPattern, children, viewCache) {
+    return asViewComponent(lazy(async () => {
+        const [{ default: Layout }, serverMod] = await Promise.all([
+            layoutImport(),
+            server ? server() : Promise.resolve(undefined),
+        ]);
+        const inner = buildInnerRoutes(children, viewCache);
+        const Wrapper = (location) => {
+            const layoutLocation = deriveLayoutLocation(location, layoutPathPattern);
+            const layoutNode = h(Layout, null, h(Router, null, ...inner));
+            return wrapWithRouteLocations(serverMod, layoutLocation, layoutNode);
+        };
+        return { default: Wrapper };
+    }));
+}
+/**
+ * Derive the layout's own matched location from the active (inner) RouteHook.
+ *
+ * When a layout matches `/movies/*`, the wildcard portion (`rest` or `0`) is
+ * the child segment. The layout's location should be the path up to and
+ * including the layout's own segments, with the wildcard stripped.
+ */
+function deriveLayoutLocation(active, layoutPathPattern) {
+    const params = active.pathParams ?? {};
+    const path = layoutPathPattern
+        .split('/')
+        .map((seg) => seg.startsWith(':')
+        ? String(params[seg.slice(1)] ?? '')
+        : seg.startsWith('*')
+            ? ''
+            : seg)
+        .filter(Boolean)
+        .join('/');
+    const finalPath = '/' + path;
+    const filteredParams = {};
+    for (const k of Object.keys(params)) {
+        if (k !== 'rest' && k !== '0')
+            filteredParams[k] = params[k];
+    }
+    return {
+        ...active,
+        path: finalPath === '/' ? '/' : finalPath,
+        pathParams: filteredParams,
+    };
+}
+/**
+ * Build the inner <Route> children for a layout group's <Router>. Each child
+ * is either a leaf (registered under its relative path) or another layout
+ * group (registered under bare + wildcard paths within the inner router).
+ */
+function buildInnerRoutes(children, viewCache) {
+    const nodes = [];
+    for (const child of children) {
+        if (child.view) {
+            nodes.push(h(Route, {
+                path: child.path,
+                component: asRouteComponent(getOrCreateLazyView(child.view, child.server, viewCache)),
+            }));
+        }
+        else if (child.layout && child.children) {
+            const Group = makeLayoutGroupComponent(child.layout, child.server, child.path, child.children, viewCache);
+            // Same shared-component trick at this nesting level.
+            nodes.push(h(Route, { path: child.path, component: asRouteComponent(Group) }));
+            nodes.push(h(Route, {
+                path: child.path + '/*',
+                component: asRouteComponent(Group),
+            }));
+        }
+        else if (child.children) {
+            // Path-grouping inside a layout. `validate()` already enforces that all
+            // descendants here are view leaves, so we only inline grandchild views.
+            for (const grand of child.children) {
+                const joined = child.path === '' ? grand.path : child.path + '/' + grand.path;
+                if (grand.view) {
+                    nodes.push(h(Route, {
+                        path: joined,
+                        component: asRouteComponent(getOrCreateLazyView(grand.view, grand.server, viewCache)),
+                    }));
+                }
+            }
+        }
+    }
+    return nodes;
+}
+function flattenTree(routes, viewCache, keyCache, parentPath = '') {
+    const keyFor = (c) => {
+        let k = keyCache.get(c);
+        if (!k) {
+            k = `r${keyCache.size}`;
+            keyCache.set(c, k);
+        }
+        return k;
+    };
+    const out = [];
+    for (const r of routes) {
+        const here = parentPath === ''
+            ? r.path
+            : parentPath + (r.path === '' ? '' : '/' + r.path);
+        if (r.view) {
+            const component = getOrCreateLazyView(r.view, r.server, viewCache);
+            out.push({ path: here, component, key: keyFor(component) });
+        }
+        else if (r.layout && r.children) {
+            const Group = makeLayoutGroupComponent(r.layout, r.server, here, r.children, viewCache);
+            const key = keyFor(Group);
+            out.push({ path: here, component: Group, key });
+            out.push({ path: here + '/*', component: Group, key });
+        }
+        else if (r.children) {
+            // Path-grouping at top level: recurse with the prefix.
+            const childParent = here === '/' ? '' : here;
+            out.push(...flattenTree(r.children, viewCache, keyCache, childParent));
+        }
+    }
+    return out;
+}
+export function defineRoutes(tree) {
+    validate(tree);
+    const viewCache = new Map();
+    const keyCache = new Map();
+    return {
+        tree,
+        flat: flattenTree(tree, viewCache, keyCache),
+        serverImports: collectServerImports(tree),
+    };
+}
+export const Routes = ({ routes, onRouteChange, }) => {
+    return h(asRouteComponent(Router), onRouteChange ? { onRouteChange } : null, ...routes.flat.map((r) => h(Route, {
+        key: r.key,
+        path: r.path,
+        component: asRouteComponent(r.component),
+    })));
+};

package/dist/iso/form.d.ts

@@ -0,0 +1,7 @@
+import type { JSX, ComponentChildren } from 'preact';
+export type FormProps<TPayload extends Record<string, unknown>> = Omit<JSX.HTMLAttributes<HTMLFormElement>, 'onSubmit'> & {
+    mutate: (payload: TPayload) => Promise<unknown> | unknown;
+    pending?: boolean;
+    children?: ComponentChildren;
+};
+export declare function Form<TPayload extends Record<string, unknown>>({ mutate, pending, children, ...rest }: FormProps<TPayload>): JSX.Element;

package/dist/iso/form.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+/**
+ * Collect a FormData into a plain payload object.
+ *
+ * Repeated field names (checkboxes sharing a name, multi-select, multiple
+ * `<input type="file" multiple>` entries) collect into an array. The old
+ * `Object.fromEntries(fd)` produced the LAST value only, which was silent
+ * data loss: a four-checkbox group would submit one value with no warning.
+ *
+ * Single-value fields stay scalar. Files survive as `File` instances.
+ *
+ * Consumers should type their `defineAction<TPayload, ...>` to match:
+ * `tags: string[]`, `photos: File[]`, etc. for fields that may have multiple
+ * values; scalar types for fields that won't.
+ */
+function collectFormData(fd) {
+    const payload = {};
+    for (const [key, value] of fd.entries()) {
+        if (key in payload) {
+            const existing = payload[key];
+            payload[key] = Array.isArray(existing)
+                ? [...existing, value]
+                : [existing, value];
+        }
+        else {
+            payload[key] = value;
+        }
+    }
+    return payload;
+}
+export function Form({ mutate, pending, children, ...rest }) {
+    const handleSubmit = (e) => {
+        e.preventDefault();
+        const formEl = e.currentTarget;
+        const formData = new FormData(formEl);
+        const payload = collectFormData(formData);
+        void mutate(payload);
+    };
+    return (_jsx("form", { ...rest, onSubmit: handleSubmit, children: _jsx("fieldset", { disabled: pending, class: "hp-form-fieldset", children: children }) }));
+}

package/dist/iso/guard.d.ts

@@ -0,0 +1,33 @@
+import { type FunctionComponent } from 'preact';
+import type { Context } from 'hono';
+import { type RouteHook } from 'preact-iso';
+export type GuardRunsOn = 'server' | 'client';
+export type GuardResult = {
+    redirect: string;
+} | {
+    render: FunctionComponent;
+} | void;
+export type ServerGuardContext = {
+    c: Context;
+    location: RouteHook;
+};
+export type ClientGuardContext = {
+    location: RouteHook;
+};
+export type ServerGuardFn = {
+    readonly runs: 'server';
+    readonly fn: (ctx: ServerGuardContext, next: () => Promise<GuardResult>) => GuardResult | Promise<GuardResult>;
+};
+export type ClientGuardFn = {
+    readonly runs: 'client';
+    readonly fn: (ctx: ClientGuardContext, next: () => Promise<GuardResult>) => GuardResult | Promise<GuardResult>;
+};
+export type GuardFn = ServerGuardFn | ClientGuardFn;
+export declare const defineServerGuard: (fn: ServerGuardFn["fn"]) => ServerGuardFn;
+export declare const defineClientGuard: (fn: ClientGuardFn["fn"]) => ClientGuardFn;
+export declare const runServerGuards: (guards: ServerGuardFn[], ctx: ServerGuardContext) => Promise<GuardResult>;
+export declare const runClientGuards: (guards: ClientGuardFn[], ctx: ClientGuardContext) => Promise<GuardResult>;
+export declare class GuardRedirect extends Error {
+    readonly location: string;
+    constructor(location: string);
+}

package/dist/iso/guard.js

@@ -0,0 +1,32 @@
+export const defineServerGuard = (fn) => ({
+    runs: 'server',
+    fn,
+});
+export const defineClientGuard = (fn) => ({
+    runs: 'client',
+    fn,
+});
+export const runServerGuards = async (guards, ctx) => {
+    const run = async (index) => {
+        if (index >= guards.length)
+            return;
+        return guards[index].fn(ctx, () => run(index + 1));
+    };
+    return run(0);
+};
+export const runClientGuards = async (guards, ctx) => {
+    const run = async (index) => {
+        if (index >= guards.length)
+            return;
+        return guards[index].fn(ctx, () => run(index + 1));
+    };
+    return run(0);
+};
+export class GuardRedirect extends Error {
+    location;
+    constructor(location) {
+        super(`Guard redirect to ${location}`);
+        this.location = location;
+        this.name = 'GuardRedirect';
+    }
+}

package/dist/iso/head.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentChildren, VNode } from 'preact';
+export interface HeadProps {
+    defaultTitle?: string;
+    children?: ComponentChildren;
+}
+export declare function Head({ defaultTitle, children }: HeadProps): VNode;

package/dist/iso/head.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+export function Head({ defaultTitle, children }) {
+    return (_jsxs("head", { children: [_jsx("meta", { charset: "utf-8" }), _jsx("meta", { name: "viewport", content: "width=device-width,initial-scale=1.0" }), _jsx("title", { children: defaultTitle ?? '' }), children] }));
+}

package/dist/iso/index.d.ts

@@ -0,0 +1,30 @@
+export { Page } from './page.js';
+export type { PageProps, WrapperProps } from './page.js';
+export { definePage } from './define-page.js';
+export type { PageBindings } from './define-page.js';
+export { Route, Router, lazy, useLocation, useRoute } from 'preact-iso';
+export { defineRoutes, Routes } from './define-routes.js';
+export type { RouteDef, RoutesManifest, FlatRoute, LayoutProps, ViewProps, } from './define-routes.js';
+export { defineLoader } from './define-loader.js';
+export type { LoaderRef, LoaderCtx, Loader as LoaderFn, } from './define-loader.js';
+export { defineAction, useAction } from './action.js';
+export type { ActionStub, UseActionOptions, UseActionResult, MutateResult, ActionGuardContext, ActionGuardFn, } from './action.js';
+export { ActionGuardError, defineActionGuard } from './action.js';
+export type { ContentfulStatusCode } from 'hono/utils/http-status';
+export { useReload } from './reload-context.js';
+export { useOptimistic } from './optimistic.js';
+export type { OptimisticHandle } from './optimistic.js';
+export { useOptimisticAction } from './optimistic-action.js';
+export type { UseOptimisticActionOptions, UseOptimisticActionResult, } from './optimistic-action.js';
+export { Form } from './form.js';
+export { createCache } from './cache.js';
+export type { LoaderCache } from './cache.js';
+export { defineServerGuard, defineClientGuard, GuardRedirect, runServerGuards, runClientGuards, } from './guard.js';
+export type { GuardFn, ServerGuardFn, ClientGuardFn, GuardResult, ServerGuardContext, ClientGuardContext, GuardRunsOn, } from './guard.js';
+export { prefetch } from './prefetch.js';
+export { isBrowser, env } from './is-browser.js';
+export { useRouteChange } from './route-change.js';
+export type { RouteChangeHandler } from './route-change.js';
+export { Head } from './head.js';
+export type { HeadProps } from './head.js';
+export { ClientScript } from './client-script.js';

package/dist/iso/index.js

@@ -0,0 +1,29 @@
+// Page declaration and the <Page> escape hatch.
+export { Page } from './page.js';
+export { definePage } from './define-page.js';
+// Routing primitives — trivial re-exports of preact-iso. Listed here so
+// consumers have a single import surface for everything they need.
+export { Route, Router, lazy, useLocation, useRoute } from 'preact-iso';
+// Declarative route tree.
+export { defineRoutes, Routes } from './define-routes.js';
+// Server bindings.
+export { defineLoader } from './define-loader.js';
+export { defineAction, useAction } from './action.js';
+export { ActionGuardError, defineActionGuard } from './action.js';
+// Hooks.
+export { useReload } from './reload-context.js';
+export { useOptimistic } from './optimistic.js';
+export { useOptimisticAction } from './optimistic-action.js';
+// Forms.
+export { Form } from './form.js';
+// Cache + invalidation.
+export { createCache } from './cache.js';
+// Guards.
+export { defineServerGuard, defineClientGuard, GuardRedirect, runServerGuards, runClientGuards, } from './guard.js';
+// Utilities.
+export { prefetch } from './prefetch.js';
+export { isBrowser, env } from './is-browser.js';
+// Client entry primitives (item 4 of v0.1).
+export { useRouteChange } from './route-change.js';
+export { Head } from './head.js';
+export { ClientScript } from './client-script.js';

package/dist/iso/internal/cache-key.d.ts

@@ -0,0 +1,2 @@
+import type { RouteHook } from 'preact-iso';
+export declare function serializeLocationForCache(loc: RouteHook, params: string[] | '*'): string;

package/dist/iso/internal/cache-key.js

@@ -0,0 +1,8 @@
+export function serializeLocationForCache(loc, params) {
+    const sp = (loc.searchParams ?? {});
+    const keys = params === '*'
+        ? Object.keys(sp).sort()
+        : params.filter((k) => k in sp).sort();
+    const sortedSearch = keys.map((k) => `${k}=${sp[k]}`).join('&');
+    return `${loc.path}?${sortedSearch}`;
+}

package/dist/iso/internal/contexts.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from 'hono';
+import type { GuardResult } from '../guard.js';
+export declare const HonoRequestContext: import("preact").Context<{
+    context?: Context;
+}>;
+export declare const LoaderIdContext: import("preact").Context<string | null>;
+export declare const LoaderDataContext: import("preact").Context<{
+    data: unknown;
+} | null>;
+export declare const GuardResultContext: import("preact").Context<GuardResult | null>;
+export declare const ActiveLoaderIdContext: import("preact").Context<symbol | null>;
+export declare const LoaderErrorContext: import("preact").Context<Error | null>;

package/dist/iso/internal/contexts.js

@@ -0,0 +1,7 @@
+import { createContext } from 'preact';
+export const HonoRequestContext = createContext({});
+export const LoaderIdContext = createContext(null);
+export const LoaderDataContext = createContext(null);
+export const GuardResultContext = createContext(null);
+export const ActiveLoaderIdContext = createContext(null);
+export const LoaderErrorContext = createContext(null);

package/dist/iso/internal/envelope.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentChildren, ComponentType, FunctionComponent, JSX } from 'preact';
+import type { WrapperProps } from '../page.js';
+type EnvelopeProps = {
+    as?: ComponentType<WrapperProps> | keyof JSX.IntrinsicElements;
+    children: ComponentChildren;
+};
+export declare const Envelope: FunctionComponent<EnvelopeProps>;
+export {};

package/dist/iso/internal/envelope.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+import { useContext } from 'preact/hooks';
+import { isBrowser } from '../is-browser.js';
+import { LoaderDataContext, LoaderIdContext } from './contexts.js';
+export const Envelope = ({ as = 'section', children, }) => {
+    const id = useContext(LoaderIdContext);
+    const ctx = useContext(LoaderDataContext);
+    if (!id || !ctx)
+        throw new Error('<Envelope> must be inside a <Loader>');
+    // Coerce undefined → null so JSON.stringify(undefined) (which returns
+    // undefined and serializes as the literal string "undefined") never
+    // reaches the wire. Loaders that return undefined should hydrate to null.
+    const dataLoader = isBrowser() ? 'null' : JSON.stringify(ctx.data ?? null);
+    if (typeof as === 'string') {
+        const Tag = as;
+        const props = { id, 'data-loader': dataLoader };
+        return (_jsx(Tag, { ...props, children: children }));
+    }
+    const Wrapper = as;
+    return (_jsx(Wrapper, { id: id, "data-loader": dataLoader, children: children }));
+};

package/dist/iso/internal/guard-noop.d.ts

@@ -0,0 +1,7 @@
+import type { GuardResult } from '../guard.js';
+/**
+ * Passthrough guard body used by the Vite `guardStripPlugin` to replace
+ * opposite-env guard bodies at build time. Importing this in user code is
+ * supported but unnecessary; the plugin handles the substitution.
+ */
+export declare const __$guardNoop_hpiso: (_ctx: unknown, next: () => Promise<GuardResult>) => Promise<GuardResult>;

package/dist/iso/internal/guard-noop.js

@@ -0,0 +1,6 @@
+/**
+ * Passthrough guard body used by the Vite `guardStripPlugin` to replace
+ * opposite-env guard bodies at build time. Importing this in user code is
+ * supported but unnecessary; the plugin handles the substitution.
+ */
+export const __$guardNoop_hpiso = (_ctx, next) => next();

package/dist/iso/internal/guards.d.ts

@@ -0,0 +1,14 @@
+import type { ComponentChildren, FunctionComponent, JSX } from 'preact';
+import { type RouteHook } from 'preact-iso';
+import { type GuardFn, type GuardResult } from '../guard.js';
+export declare function useGuardResult(): GuardResult | null;
+export declare const GuardGate: FunctionComponent<{
+    result: GuardResult | null;
+    children: ComponentChildren;
+}>;
+export declare const Guards: FunctionComponent<{
+    guards?: GuardFn[];
+    location: RouteHook;
+    fallback?: JSX.Element;
+    children: ComponentChildren;
+}>;

package/dist/iso/internal/guards.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx, Fragment as _Fragment } from "preact/jsx-runtime";
+import { useLocation } from 'preact-iso';
+import { Suspense } from 'preact/compat';
+import { useContext, useRef } from 'preact/hooks';
+import { GuardRedirect, runServerGuards, runClientGuards, } from '../guard.js';
+import { isBrowser } from '../is-browser.js';
+import wrapPromise from './wrap-promise.js';
+import { GuardResultContext, HonoRequestContext } from './contexts.js';
+export function useGuardResult() {
+    return useContext(GuardResultContext);
+}
+export const GuardGate = ({ result, children }) => {
+    const { route } = useLocation();
+    if (result && 'redirect' in result) {
+        if (isBrowser()) {
+            route(result.redirect);
+            return null;
+        }
+        throw new GuardRedirect(result.redirect);
+    }
+    if (result && 'render' in result) {
+        const Fallback = result.render;
+        return _jsx(Fallback, {});
+    }
+    return _jsx(_Fragment, { children: children });
+};
+function GuardConsumer({ guardRef, children, }) {
+    const result = (guardRef.current.read() ?? null);
+    return (_jsx(GuardResultContext.Provider, { value: result, children: _jsx(GuardGate, { result: result, children: children }) }));
+}
+function startGuardChain(guards, location, honoCtx) {
+    if (isBrowser()) {
+        const active = guards.filter((g) => g.runs === 'client');
+        return runClientGuards(active, { location });
+    }
+    const active = guards.filter((g) => g.runs === 'server');
+    if (active.length === 0)
+        return Promise.resolve(undefined);
+    if (!honoCtx) {
+        throw new Error('<Guards> rendered server-side without a HonoContext.Provider. ' +
+            'renderPage must wrap the prerendered tree in <HonoContext.Provider value={{ context: c }}>.');
+    }
+    return runServerGuards(active, { c: honoCtx, location });
+}
+export const Guards = ({ guards = [], location, fallback, children }) => {
+    const honoCtx = useContext(HonoRequestContext).context;
+    const prevPath = useRef(location.path);
+    const guardRef = useRef(wrapPromise(startGuardChain(guards, location, honoCtx)));
+    if (prevPath.current !== location.path) {
+        prevPath.current = location.path;
+        guardRef.current = wrapPromise(startGuardChain(guards, location, honoCtx));
+    }
+    return (_jsx(Suspense, { fallback: fallback, children: _jsx(GuardConsumer, { guardRef: guardRef, children: children }) }));
+};

package/dist/iso/internal/loader-fetch.d.ts

@@ -0,0 +1,20 @@
+export type LoaderFetchCallbacks<T> = {
+    onChunk: (value: T) => void;
+    onError: (err: Error) => void;
+    onEnd: () => void;
+};
+type SerializedLocation = {
+    path: string;
+    pathParams: Record<string, string>;
+    searchParams: Record<string, string>;
+};
+/**
+ * POST to /__loaders and consume the response.
+ *
+ * Static loaders return JSON; the parsed value resolves the returned promise.
+ * Streaming loaders return SSE; the first chunk resolves the promise, and
+ * subsequent chunks fire callbacks.onChunk. Stream errors after the first
+ * chunk fire callbacks.onError. Stream end fires callbacks.onEnd.
+ */
+export declare function fetchLoaderData<T>(moduleKey: string, loaderName: string, location: SerializedLocation, signal: AbortSignal, callbacks: LoaderFetchCallbacks<T>): Promise<T>;
+export {};