hono-preact 0.2.0 → 0.4.0

package/dist/iso/internal.js

@@ -28,17 +28,26 @@ 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, } 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, } 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 } from './internal/route-change.js';
+export { ViewTransitionEvent, } from './internal/view-transition-event.js';
+export { useRender } 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 { 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, } from './internal/action-result-store.js';
 // Middleware dispatcher + observer fanout. Internal-stability subpath.
 export { dispatchServer, dispatchClient, } from './internal/middleware-runner.js';
 export { partitionUse } from './internal/use-partitioner.js';
@@ -49,3 +58,6 @@ export { fanStart, fanChunk, fanEnd, fanError, fanAbort, } from './internal/stre
 // (serverOnlyPlugin's loader stubs, guardStripPlugin's no-op replacement).
 // User code that imports them couples to plugin internals.
 export { __$createLoaderStub_hpiso } from './internal/loader-stub.js';
+// SSE decoder; useful in tests and advanced consumers that need to read
+// a streaming loader/action response as a sequence of typed SSE events.
+export { readSSE } from './internal/sse-decoder.js';

package/dist/iso/optimistic-action.d.ts

@@ -1,14 +1,23 @@
 import { type UseActionOptions, type UseActionResult, type ActionStub } from './action.js';
+import { type OptimisticHandle } from './optimistic.js';
 import type { LoaderRef } from './define-loader.js';
+export declare const OPTIMISTIC_BRAND: unique symbol;
+export type OptimisticBinding<TPayload, TBase> = {
+    apply: (current: TBase, payload: TPayload) => TBase;
+    addOptimistic: (payload: TPayload) => OptimisticHandle;
+};
 export type UseOptimisticActionOptions<TPayload, TResult, TBase, TChunk = never> = Omit<UseActionOptions<TPayload, TResult, TChunk>, 'invalidate' | 'onMutate' | 'onError' | 'onSuccess'> & {
     base: TBase;
     apply: (current: TBase, payload: TPayload) => TBase;
     invalidate?: 'auto' | ReadonlyArray<LoaderRef<unknown>>;
     onSuccess?: (data: TResult) => void;
     onError?: (err: Error) => void;
+    /** Forwarded to the internal `useOptimistic` call. */
+    transition?: boolean;
 };
-export type UseOptimisticActionResult<TPayload, TResult, TBase> = UseActionResult<TPayload, TResult> & {
+export type UseOptimisticActionResult<TPayload, TResult, TBase> = ActionStub<TPayload, TResult, never> & UseActionResult<TPayload, TResult> & {
     value: TBase;
+    readonly [OPTIMISTIC_BRAND]: OptimisticBinding<TPayload, TBase>;
 };
 /**
  * Like `useAction`, but with an optimistic-update wrapper. `TChunk` defaults

package/dist/iso/optimistic-action.js

@@ -1,5 +1,6 @@
 import { useAction, } from './action.js';
 import { useOptimistic } from './optimistic.js';
+export const OPTIMISTIC_BRAND = Symbol('hono-preact.optimistic');
 /**
  * Like `useAction`, but with an optimistic-update wrapper. `TChunk` defaults
  * to `never` so existing non-streaming call sites are unaffected. Pass the
@@ -7,8 +8,8 @@ import { useOptimistic } from './optimistic.js';
  * when the action is streaming and you need a typed `onChunk` callback.
  */
 export function useOptimisticAction(stub, options) {
-    const { base, apply, onSuccess, onError, ...actionOpts } = options;
-    const [value, addOptimistic] = useOptimistic(base, apply);
+    const { base, apply, onSuccess, onError, transition, ...actionOpts } = options;
+    const [value, addOptimistic] = useOptimistic(base, apply, { transition });
     const action = useAction(stub, {
         ...actionOpts,
         onMutate: (payload) => addOptimistic(payload),
@@ -21,5 +22,12 @@ export function useOptimisticAction(stub, options) {
             onError?.(err);
         },
     });
-    return { ...action, value };
+    return {
+        __module: stub.__module,
+        __action: stub.__action,
+        useAction: stub.useAction,
+        ...action,
+        value,
+        [OPTIMISTIC_BRAND]: { apply, addOptimistic },
+    };
 }

package/dist/iso/optimistic.d.ts

@@ -2,4 +2,13 @@ export type OptimisticHandle = {
     settle: () => void;
     revert: () => void;
 };
-export declare function useOptimistic<TBase, TPayload>(base: TBase, reducer: (current: TBase, payload: TPayload) => TBase): [TBase, (payload: TPayload) => OptimisticHandle];
+export type UseOptimisticOptions = {
+    /**
+     * When true, the settle and revert paths are wrapped in
+     * `document.startViewTransition`. The initial optimistic update is never
+     * wrapped (it must paint same-frame). Falls back to a synchronous update
+     * when `document.startViewTransition` is unavailable.
+     */
+    transition?: boolean;
+};
+export declare function useOptimistic<TBase, TPayload>(base: TBase, reducer: (current: TBase, payload: TPayload) => TBase, options?: UseOptimisticOptions): [TBase, (payload: TPayload) => OptimisticHandle];

package/dist/iso/optimistic.js

@@ -1,14 +1,50 @@
 import { useCallback, useReducer, useRef } from 'preact/hooks';
-export function useOptimistic(base, reducer) {
+export function useOptimistic(base, reducer, options) {
     const queueRef = useRef([]);
     const lastBaseRef = useRef(base);
     const idRef = useRef(0);
     const [, forceRender] = useReducer((c) => c + 1, 0);
+    const transitionRef = useRef(options?.transition === true);
+    transitionRef.current = options?.transition === true;
     if (!Object.is(lastBaseRef.current, base)) {
         queueRef.current = queueRef.current.filter((e) => e.status !== 'ready');
         lastBaseRef.current = base;
     }
     const value = queueRef.current.reduce((acc, e) => reducer(acc, e.payload), base);
+    // Reads `transitionRef.current` at invocation time, not capture time, so it
+    // is safe to close over from the memoized `addOptimistic` (useCallback([]))
+    // below. Each render rebinds this function and writes the latest option
+    // value into the ref; settle/revert created by the stale memoized callback
+    // still see the up-to-date `transition` setting through the ref.
+    //
+    // The callback returns a promise that resolves on the next animation frame
+    // so the browser snapshots Preact's POST-render DOM as "new state". Without
+    // the rAF wait, `forceRender()` (an async dispatch through useReducer) has
+    // not yet flushed when `startViewTransition` snapshots, and the transition
+    // captures identical before/after frames with no visible animation.
+    const runWithTransition = (mutator) => {
+        if (transitionRef.current &&
+            typeof document !== 'undefined' &&
+            typeof document.startViewTransition === 'function') {
+            document.startViewTransition(async () => {
+                mutator();
+                await new Promise((resolve) => {
+                    if (typeof requestAnimationFrame === 'function') {
+                        requestAnimationFrame(() => resolve());
+                    }
+                    else {
+                        // Non-DOM environment (shouldn't reach this branch given the
+                        // outer check, but defensive). Resolve on next microtask so
+                        // Preact's scheduled render runs.
+                        queueMicrotask(resolve);
+                    }
+                });
+            });
+        }
+        else {
+            mutator();
+        }
+    };
     const addOptimistic = useCallback((payload) => {
         const id = ++idRef.current;
         queueRef.current = [...queueRef.current, { id, payload, status: 'active' }];
@@ -17,13 +53,17 @@ export function useOptimistic(base, reducer) {
             settle: () => {
                 const entry = queueRef.current.find((e) => e.id === id);
                 if (entry && entry.status === 'active') {
-                    entry.status = 'ready';
-                    forceRender();
+                    runWithTransition(() => {
+                        entry.status = 'ready';
+                        forceRender();
+                    });
                 }
             },
             revert: () => {
-                queueRef.current = queueRef.current.filter((e) => e.id !== id);
-                forceRender();
+                runWithTransition(() => {
+                    queueRef.current = queueRef.current.filter((e) => e.id !== id);
+                    forceRender();
+                });
             },
         };
     }, []);

package/dist/iso/outcomes.d.ts

@@ -13,12 +13,17 @@ export type DenyOutcome = {
     status: ErrorStatusCode;
     message: string;
     headers: Record<string, string> | undefined;
+    data?: unknown;
 };
 export type RenderOutcome = {
     __outcome: 'render';
     Component: FunctionComponent;
 };
-export type Outcome = RedirectOutcome | DenyOutcome | RenderOutcome;
+export type TimeoutOutcome = {
+    __outcome: 'timeout';
+    timeoutMs: number;
+};
+export type Outcome = RedirectOutcome | DenyOutcome | RenderOutcome | TimeoutOutcome;
 type RedirectInput = string | {
     to: string;
     status?: RedirectStatusCode;
@@ -29,10 +34,17 @@ type DenyInput = {
     status: ErrorStatusCode;
     message?: string;
     headers?: Record<string, string>;
+    data?: unknown;
+};
+type DenyOpts = {
+    headers?: Record<string, string>;
+    data?: unknown;
 };
-export declare function deny(status: ErrorStatusCode, message?: string): DenyOutcome;
+export declare function deny(status: ErrorStatusCode, message?: string, opts?: DenyOpts): DenyOutcome;
 export declare function deny(spec: DenyInput): DenyOutcome;
 export declare function isOutcome(value: unknown): value is Outcome;
 export declare function isRedirect(value: unknown): value is RedirectOutcome;
 export declare function isDeny(value: unknown): value is DenyOutcome;
 export declare function isRender(value: unknown): value is RenderOutcome;
+export declare function timeoutOutcome(timeoutMs: number): TimeoutOutcome;
+export declare function isTimeout(value: unknown): value is TimeoutOutcome;

package/dist/iso/outcomes.js

@@ -14,7 +14,7 @@ export function redirect(input) {
         headers: input.headers,
     };
 }
-export function deny(a, b) {
+export function deny(a, b, c) {
     // `JSON.stringify` drops `undefined` properties, so a deny outcome with no
     // message would arrive at the client without a `message` field and the
     // client decoders would fall back to a generic "Loader/Action failed with
@@ -28,13 +28,15 @@ export function deny(a, b) {
             status: a.status,
             message: a.message ?? `Request denied (${a.status})`,
             headers: a.headers,
+            ...(a.data !== undefined ? { data: a.data } : {}),
         };
     }
     return {
         __outcome: 'deny',
         status: a,
         message: b ?? `Request denied (${a})`,
-        headers: undefined,
+        headers: c?.headers,
+        ...(c?.data !== undefined ? { data: c.data } : {}),
     };
 }
 export function isOutcome(value) {
@@ -43,7 +45,10 @@ export function isOutcome(value) {
     if (!('__outcome' in value))
         return false;
     const tag = value.__outcome;
-    return tag === 'redirect' || tag === 'deny' || tag === 'render';
+    return (tag === 'redirect' ||
+        tag === 'deny' ||
+        tag === 'render' ||
+        tag === 'timeout');
 }
 export function isRedirect(value) {
     return isOutcome(value) && value.__outcome === 'redirect';
@@ -54,3 +59,9 @@ export function isDeny(value) {
 export function isRender(value) {
     return isOutcome(value) && value.__outcome === 'render';
 }
+export function timeoutOutcome(timeoutMs) {
+    return { __outcome: 'timeout', timeoutMs };
+}
+export function isTimeout(value) {
+    return isOutcome(value) && value.__outcome === 'timeout';
+}

package/dist/iso/persist.d.ts

@@ -0,0 +1,14 @@
+import type { ComponentChildren, VNode } from 'preact';
+export interface PersistProps {
+    id: string;
+    viewTransitionName?: string;
+    children?: ComponentChildren;
+}
+export declare function Persist(props: PersistProps): VNode;
+export declare namespace Persist {
+    var displayName: string;
+}
+export declare function PersistHost(): VNode;
+export declare namespace PersistHost {
+    var displayName: string;
+}

package/dist/iso/persist.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+import { Fragment, h } from 'preact';
+import { useLayoutEffect, useReducer } from 'preact/hooks';
+import { __persistRegistryWrite, __persistRegistryRead, __persistRegistrySubscribe, } from './internal/persist-registry.js';
+import { useViewTransitionName } from './view-transition-name.js';
+import { isBrowser } from './is-browser.js';
+export function Persist(props) {
+    const browser = isBrowser();
+    // Hook is called unconditionally. The effect short-circuits on the server,
+    // so SSR's render output (children inline) remains the only side effect.
+    // No deps array: runs after every render so children/viewTransitionName
+    // updates flow through without stale captures.
+    useLayoutEffect(() => {
+        if (!browser)
+            return;
+        const entry = {
+            children: props.children,
+            viewTransitionName: props.viewTransitionName,
+        };
+        __persistRegistryWrite(props.id, entry);
+        // Intentionally no cleanup: Persist does NOT clear the registry on unmount.
+        // Keeping the last-known children lets PersistHost continue to render
+        // across route changes where Persist temporarily disappears.
+    });
+    // SSR renders children inline so first paint matches steady state;
+    // the client renders nothing inline because PersistHost owns the DOM.
+    return browser ? h(Fragment, null) : h(Fragment, null, props.children);
+}
+Persist.displayName = 'Persist';
+function PersistSlot(props) {
+    const ref = useViewTransitionName(props.entry.viewTransitionName);
+    return (_jsx("div", { "data-hp-persist-slot": props.id, ref: ref, children: props.entry.children }));
+}
+PersistSlot.displayName = 'PersistSlot';
+export function PersistHost() {
+    // useReducer instead of useState: guarantees a re-render on each dispatch
+    // even if an intermediate render has already drained the "new" state.
+    // This matters for the ordering race: Persist's useLayoutEffect may run
+    // either before or after PersistHost's. Using useReducer ensures the
+    // forced tick after subscribe always queues a fresh render regardless of
+    // React/Preact batching.
+    const [, forceUpdate] = useReducer((x) => x + 1, 0);
+    // useLayoutEffect (not useEffect) so the subscription is in place before
+    // sibling effects run. The immediate forceUpdate after subscribe re-reads
+    // the registry to catch any Persist sibling whose useLayoutEffect already
+    // wrote between PersistHost's render and this subscribe call (sibling order
+    // is render order, but effect order can differ per host).
+    useLayoutEffect(() => {
+        const unsub = __persistRegistrySubscribe(() => forceUpdate(undefined));
+        forceUpdate(undefined);
+        return unsub;
+    }, []);
+    const map = __persistRegistryRead();
+    return (_jsx(Fragment, { children: Array.from(map.entries()).map(([id, entry]) => (_jsx(PersistSlot, { id: id, entry: entry }, id))) }));
+}
+PersistHost.displayName = 'PersistHost';

package/dist/iso/use-action-result.d.ts

@@ -0,0 +1,25 @@
+import type { ActionStub } from './action.js';
+export type ActionResult<TPayload, TResult> = {
+    kind: 'success';
+    data: TResult;
+    submittedPayload: TPayload;
+} | {
+    kind: 'deny';
+    status: number;
+    message: string;
+    data?: unknown;
+    /**
+     * The payload as parsed from the request. For form submissions, this is
+     * a `Record<string, FormDataEntryValue | FormDataEntryValue[]>` where
+     * each value is a string or File (never a parsed primitive like `number`
+     * or `boolean`). The `TPayload` typing reflects the dev-declared shape,
+     * not the runtime structural shape. Read individual fields knowing they
+     * arrive as form-data entries.
+     */
+    submittedPayload: TPayload;
+} | {
+    kind: 'error';
+    message: string;
+    submittedPayload: TPayload | null;
+} | null;
+export declare function useActionResult<TPayload = unknown, TResult = unknown>(stub?: ActionStub<TPayload, TResult, never>): ActionResult<TPayload, TResult>;

package/dist/iso/use-action-result.js

@@ -0,0 +1,39 @@
+import { useContext } from 'preact/hooks';
+import { useSyncExternalStore } from 'preact/compat';
+import { ActionResultContext } from './action-result-context.js';
+import { getLastActionResult, subscribeActionResults, } from './internal/action-result-store.js';
+import { isBrowser } from './is-browser.js';
+export function useActionResult(stub) {
+    const ssr = useContext(ActionResultContext);
+    const client = useSyncExternalStore(subscribeActionResults, () => isBrowser() ? getLastActionResult(stub) : null);
+    // Client store wins when populated: a JS-on submit has produced a result.
+    // SSR context is the fallback for the PE deny re-render path (no JS state).
+    const source = client ?? ssr;
+    if (!source)
+        return null;
+    if (stub &&
+        (source.module !== stub.__module || source.action !== stub.__action)) {
+        return null;
+    }
+    if (source.kind === 'success') {
+        return {
+            kind: 'success',
+            data: source.data,
+            submittedPayload: source.submittedPayload,
+        };
+    }
+    if (source.kind === 'deny') {
+        return {
+            kind: 'deny',
+            status: source.status,
+            message: source.message,
+            data: source.data,
+            submittedPayload: source.submittedPayload,
+        };
+    }
+    return {
+        kind: 'error',
+        message: source.message,
+        submittedPayload: source.submittedPayload,
+    };
+}

package/dist/iso/use-form-status.d.ts

@@ -0,0 +1,5 @@
+import type { ActionStub } from './action.js';
+export type FormStatus = {
+    pending: boolean;
+};
+export declare function useFormStatus<TPayload = unknown, TResult = unknown>(stub?: ActionStub<TPayload, TResult, never>): FormStatus;

package/dist/iso/use-form-status.js

@@ -0,0 +1,13 @@
+import { useSyncExternalStore } from 'preact/compat';
+import { isPending, subscribe } from './internal/form-submit-store.js';
+import { isBrowser } from './is-browser.js';
+// Generic over the stub's payload/result so callers can pass any
+// `ActionStub<TPayload, TResult, never>` without contravariant-position
+// assignment errors. The hook only reads `__module` and `__action`.
+export function useFormStatus(stub) {
+    // preact/compat (10.29) ships only the 2-arg signature of useSyncExternalStore.
+    // The SSR "always idle" behavior that React 18's getServerSnapshot would
+    // provide is achieved via the isBrowser() guard inside getSnapshot.
+    const pending = useSyncExternalStore(subscribe, () => isBrowser() ? isPending(stub) : false);
+    return { pending };
+}

package/dist/iso/view-transition-lifecycle.d.ts

@@ -0,0 +1,9 @@
+import type { ViewTransitionEvent } from './internal/view-transition-event.js';
+export type ViewTransitionPhaseCallback = (event: ViewTransitionEvent) => void | Promise<void>;
+export interface ViewTransitionLifecycle {
+    onBeforeTransition?: ViewTransitionPhaseCallback;
+    onBeforeSwap?: ViewTransitionPhaseCallback;
+    onAfterSwap?: ViewTransitionPhaseCallback;
+    onAfterTransition?: ViewTransitionPhaseCallback;
+}
+export declare function useViewTransitionLifecycle(lifecycle: ViewTransitionLifecycle): void;

package/dist/iso/view-transition-lifecycle.js

@@ -0,0 +1,18 @@
+import { useEffect, useRef } from 'preact/hooks';
+import { __subscribePhase } from './internal/route-change.js';
+export function useViewTransitionLifecycle(lifecycle) {
+    const ref = useRef(lifecycle);
+    ref.current = lifecycle;
+    useEffect(() => {
+        const unsubs = [
+            __subscribePhase('beforeTransition', (e) => ref.current.onBeforeTransition?.(e)),
+            __subscribePhase('beforeSwap', (e) => ref.current.onBeforeSwap?.(e)),
+            __subscribePhase('afterSwap', (e) => ref.current.onAfterSwap?.(e)),
+            __subscribePhase('afterTransition', (e) => ref.current.onAfterTransition?.(e)),
+        ];
+        return () => {
+            for (const u of unsubs)
+                u();
+        };
+    }, []);
+}

package/dist/iso/view-transition-name.d.ts

@@ -0,0 +1,17 @@
+import type { ComponentChildren, VNode } from 'preact';
+import { type UseRenderRender } from './internal/use-render.js';
+export declare function useViewTransitionName(name: string | null | undefined): (node: Element | null) => void;
+export declare function useViewTransitionClass(cls: string | string[] | null | undefined): (node: Element | null) => void;
+export interface ViewTransitionNameProps {
+    name: string | null | undefined;
+    groupClass?: string | string[];
+    render?: UseRenderRender;
+    children?: ComponentChildren;
+}
+export declare function ViewTransitionName(props: ViewTransitionNameProps): VNode;
+export interface ViewTransitionGroupProps {
+    class: string | string[];
+    render?: UseRenderRender;
+    children?: ComponentChildren;
+}
+export declare function ViewTransitionGroup(props: ViewTransitionGroupProps): VNode;

package/dist/iso/view-transition-name.js

@@ -0,0 +1,79 @@
+import { useCallback, useLayoutEffect, useRef } from 'preact/hooks';
+import { mergeRefs } from './internal/merge-refs.js';
+import { useRender } from './internal/use-render.js';
+function isStyledElement(node) {
+    return (node !== null && (node instanceof HTMLElement || node instanceof SVGElement));
+}
+function applyCssProp(node, property, value) {
+    if (!node)
+        return;
+    if (value == null || value === '') {
+        node.style.removeProperty(property);
+    }
+    else {
+        node.style.setProperty(property, value);
+    }
+}
+export function useViewTransitionName(name) {
+    const nodeRef = useRef(null);
+    const nameRef = useRef(name);
+    nameRef.current = name;
+    // Sync when name changes on a node we already hold.
+    useLayoutEffect(() => {
+        applyCssProp(nodeRef.current, 'view-transition-name', name);
+    }, [name]);
+    // Stable ref callback: applies on attach, clears the previous node on swap.
+    return useCallback((node) => {
+        if (nodeRef.current && nodeRef.current !== node) {
+            nodeRef.current.style.removeProperty('view-transition-name');
+        }
+        if (isStyledElement(node)) {
+            nodeRef.current = node;
+            applyCssProp(node, 'view-transition-name', nameRef.current);
+        }
+        else {
+            nodeRef.current = null;
+        }
+    }, []);
+}
+export function useViewTransitionClass(cls) {
+    const value = cls == null ? null : Array.isArray(cls) ? cls.join(' ') : cls;
+    const nodeRef = useRef(null);
+    const valueRef = useRef(value);
+    valueRef.current = value;
+    useLayoutEffect(() => {
+        applyCssProp(nodeRef.current, 'view-transition-class', value);
+    }, [value]);
+    return useCallback((node) => {
+        if (nodeRef.current && nodeRef.current !== node) {
+            nodeRef.current.style.removeProperty('view-transition-class');
+        }
+        if (isStyledElement(node)) {
+            nodeRef.current = node;
+            applyCssProp(node, 'view-transition-class', valueRef.current);
+        }
+        else {
+            nodeRef.current = null;
+        }
+    }, []);
+}
+export function ViewTransitionName(props) {
+    const nameRef = useViewTransitionName(props.name);
+    const classRef = useViewTransitionClass(props.groupClass);
+    const ref = mergeRefs(nameRef, classRef);
+    return useRender({
+        render: props.render,
+        defaultTag: 'div',
+        props: { ref },
+        children: props.children,
+    });
+}
+export function ViewTransitionGroup(props) {
+    const classRef = useViewTransitionClass(props.class);
+    return useRender({
+        render: props.render,
+        defaultTag: 'div',
+        props: { ref: classRef },
+        children: props.children,
+    });
+}

package/dist/iso/view-transition-types.d.ts

@@ -0,0 +1,8 @@
+import type { NavDirection } from './internal/view-transition-event.js';
+export interface ViewTransitionTypesNav {
+    to: string;
+    from: string | undefined;
+    direction: NavDirection;
+}
+export type ViewTransitionTypesInput = string | string[] | ((nav: ViewTransitionTypesNav) => string | string[] | null | undefined);
+export declare function useViewTransitionTypes(input: ViewTransitionTypesInput): void;

package/dist/iso/view-transition-types.js

@@ -0,0 +1,21 @@
+import { useEffect, useRef } from 'preact/hooks';
+import { __subscribePhase } from './internal/route-change.js';
+export function useViewTransitionTypes(input) {
+    const ref = useRef(input);
+    ref.current = input;
+    useEffect(() => {
+        return __subscribePhase('beforeTransition', (event) => {
+            const v = ref.current;
+            const resolved = typeof v === 'function'
+                ? v({ to: event.to, from: event.from, direction: event.direction })
+                : v;
+            if (resolved == null)
+                return;
+            if (typeof resolved === 'string')
+                event.types.push(resolved);
+            else
+                for (const t of resolved)
+                    event.types.push(t);
+        });
+    }, []);
+}

package/dist/server/actions-handler.d.ts

@@ -42,6 +42,13 @@ export interface ActionsHandlerOptions {
      * awaits the result either way. Default returns an empty array.
      */
     resolvePageUse?: (moduleKey: string) => ReadonlyArray<unknown> | Promise<ReadonlyArray<unknown>>;
+    /**
+     * Default action timeout in milliseconds applied when an action does not
+     * declare its own `timeoutMs`. Defaults to 30000 (30 seconds). Pass
+     * `false` to disable the default (only action-level `timeoutMs` enforces
+     * a deadline).
+     */
+    defaultTimeoutMs?: number | false;
 }
 export declare function actionsHandler(glob: LazyGlob | EagerGlob, opts?: ActionsHandlerOptions): MiddlewareHandler;
 export {};