hono-preact 0.2.0 → 0.4.0

package/dist/iso/internal/loader-fetch.js

@@ -1,4 +1,5 @@
 import { readSSE } from './sse-decoder.js';
+import { TimeoutError } from '../action.js';
 /**
  * POST to /__loaders and consume the response.
  *
@@ -18,6 +19,9 @@ export async function fetchLoaderData(moduleKey, loaderName, location, signal, c
         // Try to parse a deny outcome envelope first; it carries `message`
         // rather than `error`. Fall back to the legacy `{ error }` shape.
         const body = (await res.json().catch(() => ({})));
+        if (body.__outcome === 'timeout' && typeof body.timeoutMs === 'number') {
+            throw new TimeoutError(body.timeoutMs);
+        }
         if (body.__outcome === 'deny') {
             // The `deny()` constructor defaults `message` for first-party
             // callers, but a hand-rolled envelope from custom server middleware
@@ -74,40 +78,7 @@ export async function fetchLoaderData(moduleKey, loaderName, location, signal, c
     // SSE: read the first message event synchronously (await first chunk),
     // then kick off an async loop that pushes subsequent chunks to callbacks.
     const iter = readSSE(res.body);
-    let firstChunk;
-    while (true) {
-        const step = await iter.next();
-        if (step.done) {
-            // Stream closed before any data event: error
-            throw new Error('Streaming loader closed before emitting any data');
-        }
-        const ev = step.value;
-        if (ev.event === 'message') {
-            try {
-                firstChunk = JSON.parse(ev.data);
-            }
-            catch {
-                throw new Error('Malformed first chunk in streaming loader');
-            }
-            break;
-        }
-        if (ev.event === 'error') {
-            try {
-                const parsed = JSON.parse(ev.data);
-                const err = new Error(parsed.message ?? 'Streamed error');
-                if (parsed.name)
-                    err.name = parsed.name;
-                throw err;
-            }
-            catch (e) {
-                if (e instanceof Error && e.message.startsWith('Malformed')) {
-                    throw new Error('Malformed error event in streaming loader');
-                }
-                throw e;
-            }
-        }
-        // Other events (result, etc.): ignore for loaders
-    }
+    const firstChunk = await readFirstChunk(iter);
     // Continue consuming chunks in the background. Each subsequent message
     // pushes a value via onChunk. Errors fire onError. End fires onEnd.
     (async () => {
@@ -127,6 +98,16 @@ export async function fetchLoaderData(moduleKey, loaderName, location, signal, c
                         // malformed mid-stream chunk: skip
                     }
                 }
+                else if (ev.event === 'timeout') {
+                    try {
+                        const parsed = JSON.parse(ev.data);
+                        callbacks.onError(new TimeoutError(parsed.timeoutMs ?? 0));
+                    }
+                    catch {
+                        callbacks.onError(new Error('Malformed timeout event in streaming loader'));
+                    }
+                    return;
+                }
                 else if (ev.event === 'error') {
                     try {
                         const parsed = JSON.parse(ev.data);
@@ -151,3 +132,53 @@ export async function fetchLoaderData(moduleKey, loaderName, location, signal, c
     })();
     return firstChunk;
 }
+/**
+ * Drain the SSE stream until the first `message` event and parse it as `T`.
+ * `timeout` / `error` events before the first message reject with the
+ * appropriate error. Other event types are ignored.
+ */
+async function readFirstChunk(iter) {
+    while (true) {
+        const step = await iter.next();
+        if (step.done) {
+            throw new Error('Streaming loader closed before emitting any data');
+        }
+        const ev = step.value;
+        if (ev.event === 'message') {
+            try {
+                return JSON.parse(ev.data);
+            }
+            catch {
+                throw new Error('Malformed first chunk in streaming loader');
+            }
+        }
+        if (ev.event === 'timeout') {
+            let timeoutMs = 0;
+            try {
+                const parsed = JSON.parse(ev.data);
+                timeoutMs = parsed.timeoutMs ?? 0;
+            }
+            catch (e) {
+                throw new Error(`Malformed timeout event in streaming loader: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            throw new TimeoutError(timeoutMs);
+        }
+        if (ev.event === 'error') {
+            let message = 'Streamed error';
+            let name;
+            try {
+                const parsed = JSON.parse(ev.data);
+                message = parsed.message ?? message;
+                name = parsed.name;
+            }
+            catch {
+                throw new Error('Malformed error event in streaming loader');
+            }
+            const err = new Error(message);
+            if (name)
+                err.name = name;
+            throw err;
+        }
+        // Other events (result, etc.): ignore for loaders
+    }
+}

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

@@ -1,13 +1,13 @@
-import type { ComponentChildren, JSX } from 'preact';
+import type { ComponentChildren } from 'preact';
 import type { RouteHook } from 'preact-iso';
 import type { LoaderRef } from '../define-loader.js';
 export { serializeLocationForCache } from './cache-key.js';
 type LoaderHostProps<T> = {
     loader: LoaderRef<T>;
     location?: RouteHook;
-    fallback?: JSX.Element;
+    fallback?: ComponentChildren;
     errorFallback?: ComponentChildren | ((err: Error, reset: () => void) => ComponentChildren);
     children: ComponentChildren;
 };
-export declare function LoaderHost<T>({ loader: loaderRef, location: locationProp, fallback, errorFallback, children, }: LoaderHostProps<T>): JSX.Element;
+export declare function LoaderHost<T>({ loader: loaderRef, location: locationProp, fallback, errorFallback, children, }: LoaderHostProps<T>): import("preact").JSX.Element;
 export { LoaderHost as Loader };

package/dist/iso/internal/merge-refs.d.ts

@@ -0,0 +1,4 @@
+import type { Ref } from 'preact';
+type AnyRef<T> = Ref<T> | null | undefined;
+export declare function mergeRefs<T>(...refs: AnyRef<T>[]): (node: T | null) => void;
+export {};

package/dist/iso/internal/merge-refs.js

@@ -0,0 +1,14 @@
+export function mergeRefs(...refs) {
+    return (node) => {
+        for (const ref of refs) {
+            if (ref == null)
+                continue;
+            if (typeof ref === 'function') {
+                ref(node);
+            }
+            else {
+                ref.current = node;
+            }
+        }
+    };
+}

package/dist/iso/internal/persist-registry.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentChildren } from 'preact';
+export interface PersistEntry {
+    children: ComponentChildren;
+    viewTransitionName: string | undefined;
+}
+export declare function __persistRegistryWrite(id: string, entry: PersistEntry): void;
+export declare function __persistRegistryRead(): ReadonlyMap<string, PersistEntry>;
+export declare function __persistRegistrySubscribe(sub: () => void): () => void;
+/** Test-only reset. Do not call from production code. */
+export declare function __persistRegistryResetForTesting(): void;

package/dist/iso/internal/persist-registry.js

@@ -0,0 +1,24 @@
+let map = new Map();
+const subs = new Set();
+export function __persistRegistryWrite(id, entry) {
+    // Replace the map reference so consumers using identity-checks can detect.
+    const next = new Map(map);
+    next.set(id, entry);
+    map = next;
+    for (const sub of subs)
+        sub();
+}
+export function __persistRegistryRead() {
+    return map;
+}
+export function __persistRegistrySubscribe(sub) {
+    subs.add(sub);
+    return () => {
+        subs.delete(sub);
+    };
+}
+/** Test-only reset. Do not call from production code. */
+export function __persistRegistryResetForTesting() {
+    map = new Map();
+    subs.clear();
+}

package/dist/iso/internal/route-boundary.d.ts

@@ -1,6 +1,6 @@
 import { Component } from 'preact';
-import type { ComponentChildren, FunctionComponent, JSX } from 'preact';
-type ErrorFallback = JSX.Element | ((error: Error, reset: () => void) => JSX.Element);
+import type { ComponentChildren, FunctionComponent } from 'preact';
+type ErrorFallback = ComponentChildren | ((error: Error, reset: () => void) => ComponentChildren);
 type ErrorBoundaryProps = {
     fallback?: ErrorFallback;
     children: ComponentChildren;
@@ -16,10 +16,10 @@ export declare class ErrorBoundary extends Component<ErrorBoundaryProps, {
     };
     componentDidCatch(error: unknown): void;
     reset: () => void;
-    render(): ComponentChildren;
+    render(): any;
 }
 export declare const RouteBoundary: FunctionComponent<{
-    fallback?: JSX.Element;
+    fallback?: ComponentChildren;
     errorFallback?: ErrorFallback;
     children: ComponentChildren;
 }>;

package/dist/iso/internal/route-change.d.ts

@@ -1,4 +1,10 @@
-type Sub = (to: string, from: string | undefined) => void;
+import { ViewTransitionEvent } from './view-transition-event.js';
+export type PhaseName = 'beforeTransition' | 'beforeSwap' | 'afterSwap' | 'afterTransition';
+type PhaseSub = (event: ViewTransitionEvent) => void | Promise<void>;
+type LegacySub = (to: string, from: string | undefined) => void;
+export declare function __subscribePhase(phase: PhaseName, sub: PhaseSub): () => void;
+export declare function __subscribeRouteChange(sub: LegacySub): () => void;
 export declare function __dispatchRouteChange(to: string, from: string | undefined): void;
-export declare function __subscribeRouteChange(sub: Sub): () => void;
+/** @internal Test-only reset for default-types installer. */
+export declare function resetDefaultTypesForTesting(): void;
 export {};

package/dist/iso/internal/route-change.js

@@ -1,18 +1,113 @@
 import { flushSync } from 'preact/compat';
-const subs = new Set();
-export function __dispatchRouteChange(to, from) {
-    for (const cb of subs)
-        cb(to, from);
-    if (typeof document === 'undefined')
-        return;
-    const startViewTransition = document.startViewTransition;
-    if (typeof startViewTransition !== 'function')
-        return;
-    startViewTransition.call(document, () => flushSync(() => { }));
+import { ViewTransitionEvent, } from './view-transition-event.js';
+import { getNavDirection } from './history-shim.js';
+const phaseSubs = {
+    beforeTransition: new Set(),
+    beforeSwap: new Set(),
+    afterSwap: new Set(),
+    afterTransition: new Set(),
+};
+const legacySubs = new Set();
+export function __subscribePhase(phase, sub) {
+    phaseSubs[phase].add(sub);
+    return () => {
+        phaseSubs[phase].delete(sub);
+    };
 }
 export function __subscribeRouteChange(sub) {
-    subs.add(sub);
+    legacySubs.add(sub);
     return () => {
-        subs.delete(sub);
+        legacySubs.delete(sub);
+    };
+}
+function fireLegacy(to, from) {
+    for (const sub of legacySubs)
+        sub(to, from);
+}
+function getStartViewTransition() {
+    if (typeof document === 'undefined')
+        return undefined;
+    const fn = document.startViewTransition;
+    return typeof fn === 'function' ? fn.bind(document) : undefined;
+}
+export function __dispatchRouteChange(to, from) {
+    ensureDefaultTypes();
+    const direction = getNavDirection();
+    const event = new ViewTransitionEvent({ to, from, direction });
+    for (const sub of phaseSubs.beforeTransition)
+        sub(event);
+    const fireAfterSwap = () => {
+        for (const sub of phaseSubs.afterSwap)
+            sub(event);
+        // Legacy subscribers fire at the afterSwap slot: after the DOM swap,
+        // before the browser begins animating the new frame.
+        fireLegacy(to, from);
     };
+    const fireAfterTransition = (reason) => {
+        if (reason !== undefined)
+            event.reason = reason;
+        for (const sub of phaseSubs.afterTransition)
+            sub(event);
+    };
+    if (event._skipped) {
+        flushSync(() => { });
+        fireAfterSwap();
+        fireAfterTransition('skipped');
+        return;
+    }
+    const start = getStartViewTransition();
+    if (!start) {
+        flushSync(() => { });
+        fireAfterSwap();
+        fireAfterTransition('unsupported');
+        return;
+    }
+    const transition = start(() => {
+        flushSync(() => { });
+    });
+    // Set event.transition before firing beforeSwap so all subsequent phase
+    // subscribers see a non-null transition. In real browsers startViewTransition
+    // invokes the callback asynchronously, meaning transition is set here before
+    // the browser calls the update function. In synchronous test mocks the
+    // callback returns before start() does, so we set transition here (after
+    // start() returns) and then fire the post-swap phases manually.
+    event.transition = transition;
+    for (const sub of phaseSubs.beforeSwap)
+        sub(event);
+    fireAfterSwap();
+    // Apply types accumulated across all phases. beforeTransition and beforeSwap
+    // have both run by this point, so the full set of types is available here.
+    const vtTypes = transition.types;
+    if (vtTypes && typeof vtTypes.add === 'function') {
+        for (const t of event.types)
+            vtTypes.add(t);
+    }
+    transition.finished.then(() => fireAfterTransition(), () => fireAfterTransition('aborted'));
+}
+let defaultTypesInstalled = false;
+let firstDispatchSeen = false;
+let defaultTypeUnsubscriber = null;
+function ensureDefaultTypes() {
+    if (defaultTypesInstalled)
+        return;
+    defaultTypesInstalled = true;
+    defaultTypeUnsubscriber = __subscribePhase('beforeTransition', (event) => {
+        if (!firstDispatchSeen) {
+            event.types.push('nav-initial');
+            firstDispatchSeen = true;
+        }
+        else {
+            event.types.push(`nav-${event.direction}`);
+        }
+        event.types.push('nav-same-origin');
+    });
+}
+/** @internal Test-only reset for default-types installer. */
+export function resetDefaultTypesForTesting() {
+    if (defaultTypeUnsubscriber) {
+        defaultTypeUnsubscriber();
+    }
+    defaultTypesInstalled = false;
+    firstDispatchSeen = false;
+    defaultTypeUnsubscriber = null;
 }

package/dist/iso/internal/safe-redirect.d.ts

@@ -0,0 +1,7 @@
+export declare function isSameOrigin(target: string): boolean;
+/**
+ * Navigate to `target` only when it resolves same-origin against the current
+ * window. Cross-origin targets log a console error and are not followed.
+ * Returns true when the navigation was issued.
+ */
+export declare function assignSafeRedirect(target: string): boolean;

package/dist/iso/internal/safe-redirect.js

@@ -0,0 +1,27 @@
+export function isSameOrigin(target) {
+    if (typeof window === 'undefined')
+        return true;
+    try {
+        // Relative URLs resolve against the current origin and are always same-origin.
+        const resolved = new URL(target, window.location.href);
+        return resolved.origin === window.location.origin;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Navigate to `target` only when it resolves same-origin against the current
+ * window. Cross-origin targets log a console error and are not followed.
+ * Returns true when the navigation was issued.
+ */
+export function assignSafeRedirect(target) {
+    if (typeof window === 'undefined')
+        return false;
+    if (!isSameOrigin(target)) {
+        console.error(`[hono-preact] refusing to navigate to cross-origin redirect target: ${target}`);
+        return false;
+    }
+    window.location.assign(target);
+    return true;
+}

package/dist/iso/internal/sse-decoder.d.ts

@@ -2,4 +2,4 @@ export type SSEEvent = {
     event: string;
     data: string;
 };
-export declare function readSSE(stream: ReadableStream<Uint8Array>): AsyncGenerator<SSEEvent, void, unknown>;
+export declare function readSSE(stream: ReadableStream<BufferSource>): AsyncGenerator<SSEEvent, void, unknown>;

package/dist/iso/internal/sse-decoder.js

@@ -1,39 +1,53 @@
-export async function* readSSE(stream) {
-    const reader = stream.getReader();
-    const decoder = new TextDecoder();
+function lineSplitTransform() {
     let buffer = '';
+    return new TransformStream({
+        transform(chunk, controller) {
+            buffer += chunk;
+            let nl;
+            while ((nl = buffer.indexOf('\n')) !== -1) {
+                controller.enqueue(buffer.slice(0, nl).replace(/\r$/, ''));
+                buffer = buffer.slice(nl + 1);
+            }
+        },
+        flush(controller) {
+            if (buffer.length) {
+                controller.enqueue(buffer.replace(/\r$/, ''));
+                buffer = '';
+            }
+        },
+    });
+}
+export async function* readSSE(stream) {
+    const lines = stream
+        .pipeThrough(new TextDecoderStream())
+        .pipeThrough(lineSplitTransform());
     let event = 'message';
     let dataLines = [];
+    const reader = lines.getReader();
     try {
         while (true) {
-            const { done, value } = await reader.read();
+            const { done, value: line } = await reader.read();
             if (done) {
-                buffer += decoder.decode();
-                if (dataLines.length)
+                if (dataLines.length) {
                     yield { event, data: dataLines.join('\n') };
+                }
                 return;
             }
-            buffer += decoder.decode(value, { stream: true });
-            let nl;
-            while ((nl = buffer.indexOf('\n')) !== -1) {
-                const line = buffer.slice(0, nl).replace(/\r$/, '');
-                buffer = buffer.slice(nl + 1);
-                if (line === '') {
-                    if (dataLines.length) {
-                        yield { event, data: dataLines.join('\n') };
-                    }
-                    event = 'message';
-                    dataLines = [];
-                }
-                else if (line.startsWith(':')) {
-                    // SSE comment / keepalive, ignore
-                }
-                else if (line.startsWith('event:')) {
-                    event = line.slice(6).trim();
-                }
-                else if (line.startsWith('data:')) {
-                    dataLines.push(line.slice(5).replace(/^ /, ''));
+            if (line === '') {
+                if (dataLines.length) {
+                    yield { event, data: dataLines.join('\n') };
                 }
+                event = 'message';
+                dataLines = [];
+            }
+            else if (line.startsWith(':')) {
+                // SSE comment / keepalive, ignore
+            }
+            else if (line.startsWith('event:')) {
+                event = line.slice(6).trim();
+            }
+            else if (line.startsWith('data:')) {
+                dataLines.push(line.slice(5).replace(/^ /, ''));
             }
         }
     }

package/dist/iso/internal/use-render.d.ts

@@ -0,0 +1,11 @@
+import { type ComponentChildren, type VNode } from 'preact';
+type Props = Record<string, unknown>;
+export type UseRenderRender = VNode | string | ((props: Props) => VNode) | undefined;
+interface UseRenderOptions {
+    render?: UseRenderRender;
+    defaultTag: string;
+    props: Props;
+    children?: ComponentChildren;
+}
+export declare function useRender(opts: UseRenderOptions): VNode;
+export {};

package/dist/iso/internal/use-render.js

@@ -0,0 +1,47 @@
+import { cloneElement, h, } from 'preact';
+import { mergeRefs } from './merge-refs.js';
+function joinClass(a, b) {
+    const parts = [];
+    if (typeof a === 'string' && a.length > 0)
+        parts.push(a);
+    if (typeof b === 'string' && b.length > 0)
+        parts.push(b);
+    if (parts.length === 0)
+        return undefined;
+    return parts.join(' ');
+}
+function mergeProps(user, framework) {
+    const out = { ...user };
+    for (const key of Object.keys(framework)) {
+        if (key === 'class' || key === 'className') {
+            const userClass = (user.class ?? user.className);
+            const merged = joinClass(userClass, framework[key]);
+            if (merged !== undefined)
+                out.class = merged;
+            delete out.className;
+        }
+        else if (key === 'ref') {
+            out.ref = mergeRefs(user.ref, framework.ref);
+        }
+        else {
+            out[key] = framework[key];
+        }
+    }
+    return out;
+}
+export function useRender(opts) {
+    const { render, defaultTag, props, children } = opts;
+    if (typeof render === 'function') {
+        return render(mergeProps({}, props));
+    }
+    if (render && typeof render === 'object' && 'type' in render) {
+        const merged = mergeProps((render.props ?? {}), props);
+        const mergedChildren = children !== undefined
+            ? children
+            : (render.props?.children ??
+                null);
+        return cloneElement(render, merged, mergedChildren);
+    }
+    const tag = typeof render === 'string' ? render : defaultTag;
+    return h(tag, props, children);
+}

package/dist/iso/internal/view-transition-event.d.ts

@@ -0,0 +1,23 @@
+export type NavDirection = 'initial' | 'push' | 'replace' | 'back' | 'forward';
+export type ViewTransitionReason = 'skipped' | 'unsupported' | 'aborted';
+interface ViewTransitionEventInit {
+    to: string;
+    from: string | undefined;
+    direction: NavDirection;
+}
+export declare class ViewTransitionEvent {
+    readonly to: string;
+    readonly from: string | undefined;
+    readonly direction: NavDirection;
+    readonly types: string[];
+    transition: ViewTransition | null;
+    reason: ViewTransitionReason | undefined;
+    /** @internal */
+    _skipped: boolean;
+    private readonly stash;
+    constructor(init: ViewTransitionEventInit);
+    skip(): void;
+    set(key: unknown, value: unknown): void;
+    get<T = unknown>(key: unknown): T | undefined;
+}
+export {};

package/dist/iso/internal/view-transition-event.js

@@ -0,0 +1,25 @@
+export class ViewTransitionEvent {
+    to;
+    from;
+    direction;
+    types = [];
+    transition = null;
+    reason = undefined;
+    /** @internal */
+    _skipped = false;
+    stash = new Map();
+    constructor(init) {
+        this.to = init.to;
+        this.from = init.from;
+        this.direction = init.direction;
+    }
+    skip() {
+        this._skipped = true;
+    }
+    set(key, value) {
+        this.stash.set(key, value);
+    }
+    get(key) {
+        return this.stash.get(key);
+    }
+}

package/dist/iso/internal.d.ts

@@ -2,19 +2,30 @@ export { Loader } from './internal/loader.js';
 export { Envelope } from './internal/envelope.js';
 export { RouteBoundary } from './internal/route-boundary.js';
 export { OptimisticOverlay } from './internal/optimistic-overlay.js';
+export { serializeActionOutcome, type ActionEnvelope, type ActionResolution, type SerializedEnvelope, } from './internal/action-envelope.js';
 export { LoaderIdContext, LoaderDataContext } from './internal/contexts.js';
 export { ReloadContext } from './reload-context.js';
 export { RouteLocationsContext, RouteLocationsProvider, } from './internal/route-locations.js';
 export { getPreloadedData, deletePreloadedData } from './internal/preload.js';
-export { runRequestScope, getRequestStore, captureRequestScope, } from './cache.js';
+export { runRequestScope, getRequestStore, captureRequestScope, getActionResultSlot, setActionResultSlot, type ActionResultSlot, } from './cache.js';
 export { default as wrapPromise } from './internal/wrap-promise.js';
 export { HonoRequestContext } from './internal/contexts.js';
 export { PageMiddlewareHost } from './internal/page-middleware-host.js';
 export { __dispatchRouteChange, __subscribeRouteChange, } from './internal/route-change.js';
+export { installHistoryShim, getNavDirection, } from './internal/history-shim.js';
+export { __subscribePhase, type PhaseName } from './internal/route-change.js';
+export { ViewTransitionEvent, type NavDirection, type ViewTransitionReason, } from './internal/view-transition-event.js';
+export { useRender, type UseRenderRender } from './internal/use-render.js';
+export { mergeRefs } from './internal/merge-refs.js';
 export { installStreamRegistry, subscribeToLoaderStream, } from './internal/stream-registry.js';
 export { registerServerStreamingLoader, takeServerStreamingLoaders, } from './internal/streaming-ssr.js';
 export type { ServerLoaderStream } from './internal/streaming-ssr.js';
+export { beginSubmit, endSubmit, isPending, subscribe as subscribeFormSubmit, } from './internal/form-submit-store.js';
+export { assignSafeRedirect, isSameOrigin } from './internal/safe-redirect.js';
+export { setLastActionResult, clearLastActionResult, getLastActionResult, subscribeActionResults, type StoredActionResult, } from './internal/action-result-store.js';
 export { dispatchServer, dispatchClient, type DispatchResult, } from './internal/middleware-runner.js';
 export { partitionUse } from './internal/use-partitioner.js';
 export { fanStart, fanChunk, fanEnd, fanError, fanAbort, } from './internal/stream-observer-runner.js';
 export { __$createLoaderStub_hpiso } from './internal/loader-stub.js';
+export { readSSE } from './internal/sse-decoder.js';
+export type { SSEEvent } from './internal/sse-decoder.js';