hono-preact 0.1.0

package/dist/iso/internal/streaming-ssr.d.ts

@@ -0,0 +1,17 @@
+export type ServerLoaderStream = {
+    loaderId: string;
+    gen: AsyncGenerator<unknown, unknown, unknown>;
+};
+/**
+ * Register a streaming loader's remaining generator iterations for the
+ * current request. Called from LoaderHost's server-side branch after the
+ * first chunk is already in the rendered HTML.
+ */
+export declare function registerServerStreamingLoader(loaderId: string, gen: AsyncGenerator<unknown, unknown, unknown>): void;
+/**
+ * Take ownership of the registered streaming loaders for the current
+ * request. After this returns, the registry is cleared. Called from
+ * `renderPage` after prerender resolves, while still inside
+ * `runRequestScope`.
+ */
+export declare function takeServerStreamingLoaders(): ServerLoaderStream[];

package/dist/iso/internal/streaming-ssr.js

@@ -0,0 +1,32 @@
+import { getRequestStore } from '../cache.js';
+const REGISTRY_KEY = Symbol.for('@hono-preact/streaming-ssr-registry');
+/**
+ * Register a streaming loader's remaining generator iterations for the
+ * current request. Called from LoaderHost's server-side branch after the
+ * first chunk is already in the rendered HTML.
+ */
+export function registerServerStreamingLoader(loaderId, gen) {
+    const store = getRequestStore();
+    if (!store)
+        return; // outside any request scope (e.g., client)
+    let list = store.get(REGISTRY_KEY);
+    if (!list) {
+        list = [];
+        store.set(REGISTRY_KEY, list);
+    }
+    list.push({ loaderId, gen });
+}
+/**
+ * Take ownership of the registered streaming loaders for the current
+ * request. After this returns, the registry is cleared. Called from
+ * `renderPage` after prerender resolves, while still inside
+ * `runRequestScope`.
+ */
+export function takeServerStreamingLoaders() {
+    const store = getRequestStore();
+    if (!store)
+        return [];
+    const list = store.get(REGISTRY_KEY) ?? [];
+    store.set(REGISTRY_KEY, []);
+    return list;
+}

package/dist/iso/internal/use-loader-runner.d.ts

@@ -0,0 +1,12 @@
+import type { RouteHook } from 'preact-iso';
+import type { LoaderRef } from '../define-loader.js';
+export type LoaderRunnerState<T> = {
+    reader: {
+        read: () => T;
+    };
+    overrideData: T | undefined;
+    error: Error | null;
+    reload: () => void;
+    reloading: boolean;
+};
+export declare function useLoaderRunner<T>(loaderRef: LoaderRef<T>, location: RouteHook, id: string): LoaderRunnerState<T>;

package/dist/iso/internal/use-loader-runner.js

@@ -0,0 +1,185 @@
+import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
+import { isBrowser } from '../is-browser.js';
+import { getPreloadedData, deletePreloadedData } from './preload.js';
+import wrapPromise from './wrap-promise.js';
+import { subscribeToLoaderStream } from './stream-registry.js';
+import { runLoader } from './loader-runner.js';
+import { serializeLocationForCache } from './cache-key.js';
+export function useLoaderRunner(loaderRef, location, id) {
+    const [reloading, setReloading] = useState(false);
+    const [overrideData, setOverrideData] = useState(undefined);
+    const [loadError, setLoadError] = useState(null);
+    const locationRef = useRef(location);
+    locationRef.current = location;
+    const abortRef = useRef(null);
+    function newAbortSignal() {
+        // Abort the previous controller (cancels any in-flight loader),
+        // then allocate a fresh one whose signal is passed to the new fn call.
+        if (abortRef.current)
+            abortRef.current.abort();
+        abortRef.current = new AbortController();
+        return abortRef.current.signal;
+    }
+    useEffect(() => () => {
+        if (abortRef.current)
+            abortRef.current.abort();
+    }, []);
+    // Cleanup of the SSR preload attribute is deferred to after commit so
+    // we never mutate the DOM during the render pass (Preact reconciliation
+    // doesn't formally support that, and re-renders could observe a phantom
+    // half-cleared element). The render path sets `preloadConsumedRef` when
+    // it reads the payload; this effect clears the attribute exactly once,
+    // on the first commit that consumed it.
+    const preloadConsumedRef = useRef(false);
+    const preloadClearedRef = useRef(false);
+    useEffect(() => {
+        if (preloadConsumedRef.current && !preloadClearedRef.current) {
+            preloadClearedRef.current = true;
+            deletePreloadedData(id);
+        }
+    });
+    // True while either the initial Suspense fetch or an explicit reload is in
+    // flight. Tracked via a ref so reload() can read it without recapturing on
+    // every state change, and so the wrapPromise branch below can flip it
+    // during render without scheduling an extra setState.
+    const inFlightRef = useRef(false);
+    const queuedReloadRef = useRef(false);
+    const runReloadRef = useRef(() => { });
+    const runReload = useCallback(() => {
+        inFlightRef.current = true;
+        setReloading(true);
+        setLoadError(null);
+        const promise = runLoader(loaderRef, locationRef.current, id, newAbortSignal(), {
+            onChunk: (value) => {
+                setOverrideData(value);
+                if (isBrowser()) {
+                    loaderRef.cache.set(value, serializeLocationForCache(locationRef.current, loaderRef.params));
+                }
+            },
+            onError: (err) => setLoadError(err),
+            onEnd: () => {
+                /* nothing to do */
+            },
+        });
+        promise
+            .then((result) => {
+            if (isBrowser())
+                loaderRef.cache.set(result, serializeLocationForCache(locationRef.current, loaderRef.params));
+            setOverrideData(result);
+            setReloading(false);
+            inFlightRef.current = false;
+            if (queuedReloadRef.current) {
+                queuedReloadRef.current = false;
+                runReloadRef.current();
+            }
+        })
+            .catch((err) => {
+            setLoadError(err instanceof Error ? err : new Error(String(err)));
+            setReloading(false);
+            inFlightRef.current = false;
+            queuedReloadRef.current = false;
+        });
+    }, [loaderRef]);
+    runReloadRef.current = runReload;
+    const reload = useCallback(() => {
+        if (inFlightRef.current) {
+            queuedReloadRef.current = true;
+            return;
+        }
+        runReloadRef.current();
+    }, []);
+    // Stable reader: only rebuilt when location or loader identity changes.
+    // Without this, every re-render (e.g. from setReloading) would call
+    // wrapPromise(...) again, fire a duplicate XHR, and throw a fresh promise
+    // into Suspense — unmounting the children and wiping any optimistic UI
+    // state below.
+    //
+    // The location key includes path AND searchParams so /movies?genre=action →
+    // /movies?genre=drama refetches even though preact-iso doesn't remount on
+    // querystring changes.
+    const readerRef = useRef(null);
+    const locKey = serializeLocationForCache(location, loaderRef.params);
+    const prevLocKey = useRef(locKey);
+    const prevLoaderId = useRef(loaderRef.__id);
+    const locationChanged = prevLocKey.current !== locKey;
+    const loaderChanged = prevLoaderId.current !== loaderRef.__id;
+    if (readerRef.current === null || locationChanged || loaderChanged) {
+        prevLocKey.current = locKey;
+        prevLoaderId.current = loaderRef.__id;
+        if (locationChanged || loaderChanged)
+            setOverrideData(undefined);
+        const preloaded = getPreloadedData(id);
+        const isFirstRender = readerRef.current === null;
+        if (preloaded !== null) {
+            // Record that we consumed the SSR preload payload so the useEffect
+            // below can clear the DOM attribute AFTER commit instead of mutating
+            // the DOM during render.
+            preloadConsumedRef.current = true;
+            loaderRef.cache.set(preloaded, locKey);
+            readerRef.current = { read: () => preloaded };
+            if (isBrowser()) {
+                const unsub = subscribeToLoaderStream(id, {
+                    push: (value) => {
+                        setOverrideData(value);
+                        loaderRef.cache.set(value, locKey);
+                    },
+                    end: () => {
+                        /* nothing to do */
+                    },
+                    error: (err) => setLoadError(err),
+                });
+                // Unsubscribe on unmount: attach to the abortRef signal.
+                if (abortRef.current) {
+                    abortRef.current.signal.addEventListener('abort', unsub);
+                }
+                else {
+                    abortRef.current = new AbortController();
+                    abortRef.current.signal.addEventListener('abort', unsub);
+                }
+            }
+        }
+        else if (isBrowser() && isFirstRender && loaderRef.cache.has(locKey)) {
+            const cached = loaderRef.cache.get(locKey);
+            readerRef.current = { read: () => cached };
+        }
+        else {
+            inFlightRef.current = true;
+            const settle = () => {
+                inFlightRef.current = false;
+                if (queuedReloadRef.current) {
+                    queuedReloadRef.current = false;
+                    runReloadRef.current();
+                }
+            };
+            const fetchPromise = runLoader(loaderRef, location, id, newAbortSignal(), {
+                onChunk: (value) => {
+                    setOverrideData(value);
+                    if (isBrowser())
+                        loaderRef.cache.set(value, locKey);
+                },
+                onError: (err) => setLoadError(err),
+                onEnd: () => {
+                    /* nothing to do */
+                },
+            });
+            readerRef.current = wrapPromise(fetchPromise
+                .then((r) => {
+                if (isBrowser())
+                    loaderRef.cache.set(r, locKey);
+                settle();
+                return r;
+            })
+                .catch((err) => {
+                settle();
+                throw err;
+            }));
+        }
+    }
+    return {
+        reader: readerRef.current,
+        overrideData,
+        error: loadError,
+        reload,
+        reloading,
+    };
+}

package/dist/iso/internal/wrap-promise.d.ts

@@ -0,0 +1,4 @@
+export declare function wrapPromise<T>(promise: Promise<T>): {
+    read: () => T;
+};
+export default wrapPromise;

package/dist/iso/internal/wrap-promise.js

@@ -0,0 +1,24 @@
+export function wrapPromise(promise) {
+    let status = 'pending';
+    let result;
+    let error;
+    const suspender = promise.then((res) => {
+        status = 'success';
+        result = res;
+    }, (err) => {
+        status = 'error';
+        error = err;
+    });
+    const read = () => {
+        switch (status) {
+            case 'pending':
+                throw suspender;
+            case 'error':
+                throw error;
+            default:
+                return result;
+        }
+    };
+    return { read };
+}
+export default wrapPromise;

package/dist/iso/internal.d.ts

@@ -0,0 +1,19 @@
+export { Loader } from './internal/loader.js';
+export { Envelope } from './internal/envelope.js';
+export { RouteBoundary } from './internal/route-boundary.js';
+export { Guards, GuardGate, useGuardResult } from './internal/guards.js';
+export { OptimisticOverlay } from './internal/optimistic-overlay.js';
+export { LoaderIdContext, LoaderDataContext, GuardResultContext, } 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 { default as wrapPromise } from './internal/wrap-promise.js';
+export { runServerGuards, runClientGuards } from './guard.js';
+export { HonoRequestContext } from './internal/contexts.js';
+export { __dispatchRouteChange, __subscribeRouteChange, } from './internal/route-change.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 { __$createLoaderStub_hpiso } from './internal/loader-stub.js';
+export { __$guardNoop_hpiso } from './internal/guard-noop.js';

package/dist/iso/internal.js

@@ -0,0 +1,49 @@
+// @hono-preact/iso/internal -- escape hatch for advanced consumers.
+//
+// These primitives compose the default <Page> pipeline. They're kept
+// behind a subpath so the front door (@hono-preact/iso) stays small.
+// Use them when definePage bindings or <Page> props don't express
+// what you need (e.g. distinct fallbacks for guards vs. loader, custom
+// pipeline ordering, advanced SSR work).
+//
+// STABILITY: this subpath is intentionally less stable than the package's
+// main surface. Symbols may be renamed, retyped, or removed in any
+// non-major release. Pin a specific framework version if your code reaches
+// in here.
+//
+// The file is split into two sections:
+//
+//   1. ADVANCED USER ESCAPE HATCHES — primitives users may reasonably
+//      compose by hand when `definePage` bindings aren't enough. Reach for
+//      these knowingly; expect to read the source.
+//
+//   2. FRAMEWORK-EMITTED (DO NOT IMPORT FROM USER CODE) — symbols the
+//      framework's own Vite plugins emit `import` statements for, then
+//      reference in code they generate. They're exported here only because
+//      the emitted code needs a real import target. Importing them
+//      yourself bypasses everything the public API does and your code
+//      will break at a non-major upgrade.
+// ─── Section 1: advanced user escape hatches ─────────────────────────────
+export { Loader } from './internal/loader.js';
+export { Envelope } from './internal/envelope.js';
+export { RouteBoundary } from './internal/route-boundary.js';
+export { Guards, GuardGate, useGuardResult } from './internal/guards.js';
+export { OptimisticOverlay } from './internal/optimistic-overlay.js';
+export { LoaderIdContext, LoaderDataContext, GuardResultContext, } 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 { default as wrapPromise } from './internal/wrap-promise.js';
+export { runServerGuards, runClientGuards } from './guard.js';
+export { HonoRequestContext } from './internal/contexts.js';
+export { __dispatchRouteChange, __subscribeRouteChange, } from './internal/route-change.js';
+export { installStreamRegistry, subscribeToLoaderStream, } from './internal/stream-registry.js';
+export { registerServerStreamingLoader, takeServerStreamingLoaders, } from './internal/streaming-ssr.js';
+// ─── Section 2: framework-emitted (DO NOT IMPORT FROM USER CODE) ─────────
+// The `__$..._hpiso` naming makes the convention visible at every grep:
+// these symbols are referenced by code the framework's Vite plugins emit
+// (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';
+export { __$guardNoop_hpiso } from './internal/guard-noop.js';

package/dist/iso/is-browser.d.ts

@@ -0,0 +1,4 @@
+export declare let env: {
+    current: 'browser' | 'server';
+};
+export declare function isBrowser(): boolean;

package/dist/iso/is-browser.js

@@ -0,0 +1,6 @@
+export let env = {
+    current: 'browser',
+};
+export function isBrowser() {
+    return env.current === 'browser';
+}

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

@@ -0,0 +1,19 @@
+import { type UseActionOptions, type UseActionResult, type ActionStub } from './action.js';
+import type { LoaderRef } from './define-loader.js';
+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;
+};
+export type UseOptimisticActionResult<TPayload, TResult, TBase> = UseActionResult<TPayload, TResult> & {
+    value: TBase;
+};
+/**
+ * Like `useAction`, but with an optimistic-update wrapper. `TChunk` defaults
+ * to `never` so existing non-streaming call sites are unaffected. Pass the
+ * stub's chunk type explicitly (or infer it via the stub's third generic)
+ * when the action is streaming and you need a typed `onChunk` callback.
+ */
+export declare function useOptimisticAction<TPayload, TResult, TBase, TChunk = never>(stub: ActionStub<TPayload, TResult, TChunk>, options: UseOptimisticActionOptions<TPayload, TResult, TBase, TChunk>): UseOptimisticActionResult<TPayload, TResult, TBase>;

package/dist/iso/optimistic-action.js

@@ -0,0 +1,25 @@
+import { useAction, } from './action.js';
+import { useOptimistic } from './optimistic.js';
+/**
+ * Like `useAction`, but with an optimistic-update wrapper. `TChunk` defaults
+ * to `never` so existing non-streaming call sites are unaffected. Pass the
+ * stub's chunk type explicitly (or infer it via the stub's third generic)
+ * 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 action = useAction(stub, {
+        ...actionOpts,
+        onMutate: (payload) => addOptimistic(payload),
+        onSuccess: (data, handle) => {
+            handle.settle();
+            onSuccess?.(data);
+        },
+        onError: (err, handle) => {
+            handle.revert();
+            onError?.(err);
+        },
+    });
+    return { ...action, value };
+}

package/dist/iso/optimistic.d.ts

@@ -0,0 +1,5 @@
+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];

package/dist/iso/optimistic.js

@@ -0,0 +1,31 @@
+import { useCallback, useReducer, useRef } from 'preact/hooks';
+export function useOptimistic(base, reducer) {
+    const queueRef = useRef([]);
+    const lastBaseRef = useRef(base);
+    const idRef = useRef(0);
+    const [, forceRender] = useReducer((c) => c + 1, 0);
+    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);
+    const addOptimistic = useCallback((payload) => {
+        const id = ++idRef.current;
+        queueRef.current = [...queueRef.current, { id, payload, status: 'active' }];
+        forceRender();
+        return {
+            settle: () => {
+                const entry = queueRef.current.find((e) => e.id === id);
+                if (entry && entry.status === 'active') {
+                    entry.status = 'ready';
+                    forceRender();
+                }
+            },
+            revert: () => {
+                queueRef.current = queueRef.current.filter((e) => e.id !== id);
+                forceRender();
+            },
+        };
+    }, []);
+    return [value, addOptimistic];
+}

package/dist/iso/page.d.ts

@@ -0,0 +1,16 @@
+import type { ComponentChildren, ComponentType, JSX } from 'preact';
+import type { RouteHook } from 'preact-iso';
+import type { GuardFn } from './guard.js';
+export type WrapperProps = {
+    id: string;
+    'data-loader': string;
+    children: ComponentChildren;
+};
+export type PageProps = {
+    location: RouteHook;
+    guards?: GuardFn[];
+    errorFallback?: JSX.Element | ((error: Error, reset: () => void) => JSX.Element);
+    Wrapper?: ComponentType<WrapperProps>;
+    children: ComponentChildren;
+};
+export declare function Page({ location, guards, errorFallback, Wrapper, children, }: PageProps): JSX.Element;

package/dist/iso/page.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+import { useId } from 'preact/hooks';
+import { Guards } from './internal/guards.js';
+import { RouteBoundary } from './internal/route-boundary.js';
+const DefaultWrapper = (props) => (_jsx("section", { ...props }));
+export function Page({ location, guards, errorFallback, Wrapper, children, }) {
+    const id = useId();
+    const W = Wrapper ?? DefaultWrapper;
+    return (_jsx(RouteBoundary, { errorFallback: errorFallback, children: _jsx(Guards, { guards: guards, location: location, children: _jsx(W, { id: id, "data-loader": "null", children: children }) }) }));
+}

package/dist/iso/prefetch.d.ts

@@ -0,0 +1,22 @@
+import type { RouteHook } from 'preact-iso';
+import type { LoaderCache } from './cache.js';
+import type { LoaderRef } from './define-loader.js';
+export interface PrefetchOptions<T> {
+    url?: string;
+    route?: string;
+    location?: RouteHook;
+    cache?: LoaderCache<T>;
+}
+/**
+ * Prefetch a loader's data and write the result into its cache.
+ *
+ * In the browser this delegates to the same RPC path that `loader.View()` uses
+ * at runtime: a POST to `/__loaders`. In SSR or test environments it falls
+ * back to invoking the loader function directly. This matches `runLoader`'s
+ * dispatch and means consumers do not need to know which side they are on.
+ *
+ * For non-streaming loaders the returned promise resolves with the final
+ * value. For streaming loaders it resolves with the first chunk; subsequent
+ * chunks update the cache as they arrive.
+ */
+export declare function prefetch<T>(ref: LoaderRef<T>, opts?: PrefetchOptions<T>): Promise<T>;

package/dist/iso/prefetch.js

@@ -0,0 +1,78 @@
+import { exec } from 'preact-iso';
+import { isBrowser } from './is-browser.js';
+import { runLoader } from './internal/loader-runner.js';
+import { serializeLocationForCache } from './internal/cache-key.js';
+function buildLocation(opts) {
+    if (!opts.url) {
+        return { path: '', searchParams: {}, pathParams: {} };
+    }
+    const parsed = new URL(opts.url, 'http://_');
+    let path = parsed.pathname;
+    if (path.length > 1 && path.endsWith('/'))
+        path = path.slice(0, -1);
+    const searchParams = {};
+    parsed.searchParams.forEach((value, key) => {
+        searchParams[key] = value;
+    });
+    let pathParams = {};
+    if (opts.route) {
+        const matched = exec(path, opts.route, {
+            path,
+            query: searchParams,
+            params: {},
+        });
+        if (matched && matched.pathParams) {
+            pathParams = matched.pathParams;
+        }
+    }
+    return { path, searchParams, pathParams };
+}
+let prefetchSeq = 0;
+/**
+ * Prefetch a loader's data and write the result into its cache.
+ *
+ * In the browser this delegates to the same RPC path that `loader.View()` uses
+ * at runtime: a POST to `/__loaders`. In SSR or test environments it falls
+ * back to invoking the loader function directly. This matches `runLoader`'s
+ * dispatch and means consumers do not need to know which side they are on.
+ *
+ * For non-streaming loaders the returned promise resolves with the final
+ * value. For streaming loaders it resolves with the first chunk; subsequent
+ * chunks update the cache as they arrive.
+ */
+export async function prefetch(ref, opts = {}) {
+    const location = opts.location ?? buildLocation({ url: opts.url, route: opts.route });
+    const cache = opts.cache ?? ref.cache;
+    // Compute the cache key the loader runtime would use, so a warm cache for
+    // THIS specific location short-circuits the fetch. Without this check, a
+    // hover handler that fires repeatedly (mouse over → off → back over the
+    // same link, an intersection observer re-entering visibility, an idle
+    // prefetch scheduled twice) would issue a redundant request every time.
+    // The docs already promise no-op-on-cache-hit behavior; this makes the
+    // code match.
+    const locKey = serializeLocationForCache(location, ref.params);
+    if (cache?.has(locKey)) {
+        const cached = cache.get(locKey);
+        if (cached !== null)
+            return cached;
+    }
+    const id = `prefetch:${++prefetchSeq}`;
+    const signal = new AbortController().signal;
+    const result = await runLoader(ref, location, id, signal, {
+        onChunk: (v) => {
+            cache?.set(v, locKey);
+        },
+        onError: () => {
+            // Errors after the first chunk are swallowed: prefetch is best-effort
+            // and the page itself will see the same failure when it actually loads.
+        },
+        onEnd: () => { },
+    });
+    // Key the final write on locKey so two prefetches for different URLs
+    // (hovering /movies/41 then /movies/42) don't collide on the legacy
+    // single-slot "locKey: null matches any" fallback the cache supports for
+    // back-compat.
+    if (isBrowser())
+        cache?.set(result, locKey);
+    return result;
+}

package/dist/iso/reload-context.d.ts

@@ -0,0 +1,6 @@
+export type ReloadContextValue = {
+    reload: () => void;
+    reloading: boolean;
+};
+export declare const ReloadContext: import("preact").Context<ReloadContextValue | undefined>;
+export declare function useReload(): ReloadContextValue;

package/dist/iso/reload-context.js

@@ -0,0 +1,9 @@
+import { createContext } from 'preact';
+import { useContext } from 'preact/hooks';
+export const ReloadContext = createContext(undefined);
+export function useReload() {
+    const ctx = useContext(ReloadContext);
+    if (!ctx)
+        throw new Error('useReload() must be called inside a `loader.View` render function or inside a `loader.Boundary`.');
+    return ctx;
+}

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

@@ -0,0 +1,2 @@
+export type RouteChangeHandler = (to: string, from: string | undefined) => void;
+export declare function useRouteChange(handler: RouteChangeHandler): void;

package/dist/iso/route-change.js

@@ -0,0 +1,10 @@
+import { useEffect, useRef } from 'preact/hooks';
+import { __subscribeRouteChange } from './internal/route-change.js';
+export function useRouteChange(handler) {
+    // Keep the latest handler in a ref so rerenders don't churn the subscription.
+    const ref = useRef(handler);
+    ref.current = handler;
+    useEffect(() => {
+        return __subscribeRouteChange((to, from) => ref.current(to, from));
+    }, []);
+}

package/dist/iso/view-transitions.d.ts

@@ -0,0 +1 @@
+export declare function ViewTransitions(): null;

package/dist/iso/view-transitions.js

@@ -0,0 +1,6 @@
+import { useEffect } from 'preact/hooks';
+import { __enableViewTransitions } from './internal/route-change.js';
+export function ViewTransitions() {
+    useEffect(() => __enableViewTransitions(), []);
+    return null;
+}