@kasperrt/smolter 0.2.0 → 0.3.0

package/dist/preact/route-hooks.js

@@ -0,0 +1,94 @@
+import { submissionBody, submissionSearch } from "../core/submission.js";
+import { useContext, useMemo } from "./runtime.js";
+import { useRouter, useSnapshot } from "./context.js";
+import { pendingLocation } from "../core/presentation.js";
+import { useNavigationSnapshot } from "./navigation-state.js";
+import { OutletContext, useApplication } from "./root-context.js";
+import { useCallback } from "preact/hooks";
+//#region .generated/preact/route-hooks.tsx
+function useRootData() {
+	return useApplication().root;
+}
+/** Read root data or the active route's data by its manifest identifier. */
+function useRouteLoaderData(id) {
+	const app = useApplication();
+	const snapshot = useSnapshot();
+	if (id === "root") return app.root;
+	const route = app.routes.find((item) => item.id === id);
+	if (!route || route.path !== snapshot.path) return void 0;
+	return snapshot.data;
+}
+function useRouteError() {
+	return useSnapshot("error");
+}
+function useNavigation() {
+	const router = useRouter();
+	const snapshot = useSnapshot();
+	const location = pendingLocation(router);
+	return useMemo(() => ({
+		state: snapshot.state,
+		location
+	}), [snapshot.state, location?.href]);
+}
+function useMatches() {
+	const { routes } = useApplication();
+	const snapshot = useSnapshot();
+	return [{
+		id: routes.find((item) => item.path === snapshot.path)?.id ?? "",
+		data: snapshot.data,
+		params: snapshot.params
+	}];
+}
+function useOutletContext() {
+	return useContext(OutletContext);
+}
+function useSubmit() {
+	const router = useRouter();
+	return useCallback((value, options = {}) => {
+		const body = submissionBody(value, options.encType);
+		const method = options.method?.toUpperCase();
+		const target = options.action ?? router.getSnapshot().url;
+		if (method === "GET") {
+			const url = new URL(target, router.getSnapshot().url);
+			url.search = submissionSearch(body);
+			return router.navigate(url.href, options);
+		}
+		return router.submit(target, body, { method });
+	}, [router]);
+}
+function useURLLocation() {
+	const href = useSnapshot("url");
+	const snapshot = useNavigationSnapshot(useRouter());
+	return useMemo(() => Object.assign(new URL(href), {
+		state: snapshot.state,
+		key: snapshot.key
+	}), [
+		href,
+		snapshot.state,
+		snapshot.key
+	]);
+}
+function useNavigate() {
+	const router = useRouter();
+	return useCallback((to, options) => {
+		if (typeof to === "number") {
+			window.history.go(to);
+			return;
+		}
+		const current = new URL(router.getSnapshot().url);
+		const target = typeof to === "string" ? to : `${to.pathname ?? current.pathname}${to.search ?? current.search}${to.hash ?? current.hash}`;
+		router.navigate(target, options);
+	}, [router]);
+}
+function useSearchParams() {
+	const location = useURLLocation();
+	const navigate = useNavigate();
+	return [useMemo(() => new URLSearchParams(location.search), [location.search]), useCallback((value, options) => {
+		navigate(`${location.pathname}?${new URLSearchParams(value)}`, options);
+	}, [location.pathname, navigate])];
+}
+function useNavigationType() {
+	return useNavigationSnapshot(useRouter()).type;
+}
+//#endregion
+export { useMatches, useNavigate, useNavigation, useNavigationType, useOutletContext, useRootData, useRouteError, useRouteLoaderData, useSearchParams, useSnapshot, useSubmit, useURLLocation };

package/dist/preact/route-types.d.ts

@@ -0,0 +1,54 @@
+import type { DataArgs, RevalidationArgs, Route, Snapshot } from "../core/index.ts";
+import type { DataResponse } from "../core/responses.ts";
+import type { ComponentType, ReactNode } from "preact/compat";
+export interface LoaderFunctionArgs extends DataArgs {
+    context?: unknown;
+}
+export type ActionFunctionArgs = LoaderFunctionArgs;
+export interface ClientLoaderFunctionArgs extends LoaderFunctionArgs {
+    serverLoader: <T = unknown>() => Promise<T>;
+}
+export interface ClientActionFunctionArgs extends LoaderFunctionArgs {
+    serverAction: <T = unknown>() => Promise<T>;
+}
+export type ShouldRevalidateFunctionArgs = RevalidationArgs;
+type UnwrapData<T> = T extends DataResponse<infer V> ? V : T;
+export type RouteData<T> = T extends (...args: never[]) => infer R ? UnwrapData<Exclude<Awaited<R>, Response | Error>> : T;
+export type MetaDescriptor = Record<string, unknown>;
+export interface MetaArgs<T> {
+    data: RouteData<T> | undefined;
+    loaderData: RouteData<T> | undefined;
+    error?: unknown;
+    params: Record<string, string>;
+    location: URL;
+}
+export type MetaFunction<T = unknown> = (args: MetaArgs<T>) => MetaDescriptor[];
+export type LinksFunction = () => Record<string, string>[];
+export interface AppRoute extends Route {
+    resolveComponent?: () => ComponentType | undefined;
+    preload?: () => Promise<void>;
+    id?: string;
+    routePath?: string;
+    meta?: MetaFunction;
+}
+export interface RootModule {
+    /** Route identity used by targeted revalidation. Defaults to root. */
+    id?: string;
+    /** Optional registered route URL used to revalidate root data after mutations. */
+    loaderPath?: string;
+    ErrorBoundary?: ComponentType;
+    default: ComponentType;
+    Layout: ComponentType<{
+        children: ReactNode;
+    }>;
+    loader?: (args: LoaderFunctionArgs) => unknown;
+    links?: LinksFunction;
+    meta?: MetaFunction;
+    shouldRevalidate?: (args: RevalidationArgs) => boolean;
+}
+export interface Hydration {
+    root: unknown;
+    snapshot: Snapshot;
+}
+export type HandleDataRequestFunction = (response: Response, args: LoaderFunctionArgs) => Response | Promise<Response>;
+export {};

package/dist/preact/router.d.ts

@@ -0,0 +1,16 @@
+/** @jsxImportSource preact */
+import type { ReactNode } from "preact/compat";
+import { type ApplicationContext } from "./root-context.ts";
+import { createRootStore } from "./root-data.ts";
+import type { AppRoute } from "./route-types.ts";
+export interface OutletProps {
+    context?: unknown;
+    children?: ReactNode;
+}
+export declare function Outlet({ context, children, }: OutletProps): import("preact").JSX.Element;
+export interface ApplicationProps extends ApplicationContext {
+    document?: boolean;
+    rootStore?: ReturnType<typeof createRootStore>;
+}
+export declare function RouterApplication(props: ApplicationProps): import("preact").JSX.Element;
+export declare function prepareRoutes(routes: AppRoute[]): AppRoute[];

package/dist/preact/router.js

@@ -0,0 +1,63 @@
+import { normalizeResult } from "../core/responses.js";
+import { useContext, useMemo, useSyncExternalStore } from "./runtime.js";
+import { RouterProvider } from "./context.js";
+import { createStore } from "../core/store.js";
+import { Application, OutletContext } from "./root-context.js";
+import { Routes } from "./routes.js";
+import { jsx } from "preact/jsx-runtime";
+//#region .generated/preact/router.tsx
+function Outlet({ context, children }) {
+	const current = useContext(OutletContext);
+	return /* @__PURE__ */ jsx(OutletContext, {
+		value: context ?? current,
+		children: children ?? /* @__PURE__ */ jsx(Routes, { fallback: /* @__PURE__ */ jsx("p", {
+			role: "status",
+			children: "Loading…"
+		}) })
+	});
+}
+function RouterApplication(props) {
+	const rootStore = useMemo(() => props.rootStore ?? createStore(props.root), [props.rootStore, props.root]);
+	const root = useSyncExternalStore(rootStore.subscribe, rootStore.getSnapshot);
+	const snapshot = useSyncExternalStore(props.router.subscribe, props.router.getSnapshot);
+	const route = props.routes.find((item) => item.path === snapshot.path);
+	const Root = snapshot.error && !route?.ErrorBoundary ? props.rootModule?.ErrorBoundary ?? Outlet : props.rootModule?.default ?? Outlet;
+	const Layout = props.rootModule?.Layout;
+	const children = /* @__PURE__ */ jsx(Root, {});
+	return /* @__PURE__ */ jsx(RouterProvider, {
+		router: props.router,
+		children: /* @__PURE__ */ jsx(Application, {
+			value: {
+				...props,
+				root
+			},
+			children: props.document ? Layout && /* @__PURE__ */ jsx(Layout, { children }) : children
+		})
+	});
+}
+function prepareRoutes(routes) {
+	return routes.map((route) => {
+		const wrapped = {
+			...route,
+			path: route.routePath ?? route.path,
+			shouldRevalidate: (args) => {
+				const { currentUrl, nextUrl } = args;
+				if (args.reason === "navigation" && currentUrl.pathname === nextUrl.pathname && currentUrl.search === nextUrl.search && currentUrl.hash !== nextUrl.hash) return false;
+				return route.shouldRevalidate?.(args) ?? args.defaultShouldRevalidate;
+			}
+		};
+		for (const key of [
+			"loader",
+			"action",
+			"clientLoader",
+			"clientAction"
+		]) {
+			const handler = route[key];
+			if (!handler) continue;
+			wrapped[key] = (args) => Promise.resolve().then(() => handler(args)).then(normalizeResult, normalizeResult);
+		}
+		return wrapped;
+	});
+}
+//#endregion
+export { Outlet, RouterApplication, prepareRoutes };

package/dist/{internal/preact → preact}/routes.d.ts

@@ -3,7 +3,7 @@
  * @module
  */
 import type { RouteModule } from "../core/index.ts";
-import type { ComponentType, ReactNode } from "./runtime.ts";
+import { type ComponentType, type ReactNode } from "./runtime.ts";
 /** Renderable route module with optional loading and error components. */
 export interface ViewModule extends RouteModule {
     default?: ComponentType;

package/dist/preact/routes.js

@@ -0,0 +1,12 @@
+import { createElement, useMemo } from "./runtime.js";
+import { useRouter, useSnapshot } from "./context.js";
+//#region .generated/preact/routes.ts
+/** Renders the first matching registered module. */
+function Routes({ fallback }) {
+	const router = useRouter();
+	const state = useSnapshot();
+	const component = router.routes.find((route) => route.path === state.path)?.[state.error ? "ErrorBoundary" : state.state === "loading" && !state.loaded ? "HydrateFallback" : "default"];
+	return useMemo(() => component && createElement(component, { error: state.error }), [component, state.error]) ?? state.error?.message ?? fallback;
+}
+//#endregion
+export { Routes };

package/dist/{internal/preact → preact}/runtime.js

@@ -1 +1 @@
-export { createContext, createElement, useContext, useEffect, useMemo, useSyncExternalStore, } from "preact/compat";
+export { createContext, createElement, useContext, useEffect, useMemo, useSyncExternalStore } from "preact/compat";

package/dist/react/context.d.ts

@@ -0,0 +1,18 @@
+/**
+ * React components and typed data hooks. Import from @kasperrt/smolter/react.
+ * @module
+ */
+import type { NavigationRouter, Snapshot } from "../core/index.ts";
+import { type ReactNode } from "./runtime.ts";
+/** Router instance and children rendered within its context. */
+export interface RouterProviderProps {
+    router: NavigationRouter;
+    children?: ReactNode;
+}
+/** Provide a router to descendant hooks and connect its browser lifecycle. */
+export declare function RouterProvider({ router, children, }: RouterProviderProps): ReactNode;
+/** Hooks require a RouterProvider. */
+export declare function useRouter<T extends NavigationRouter = NavigationRouter>(): T;
+export declare function useSnapshot(): Snapshot;
+export declare function useSnapshot<K extends keyof Snapshot>(key: K): Snapshot[K];
+export declare function useSnapshot<K extends keyof Snapshot>(key: K, path: string | undefined): Snapshot[K] | undefined;

package/dist/react/context.js

@@ -0,0 +1,23 @@
+import { createContext, createElement, useContext, useEffect, useSyncExternalStore } from "./runtime.js";
+//#region .generated/react/context.ts
+var RouterContext = createContext(void 0);
+/** Provide a router to descendant hooks and connect its browser lifecycle. */
+function RouterProvider({ router, children }) {
+	useEffect(router.start, [router]);
+	return createElement(RouterContext.Provider, { value: router }, children);
+}
+/** Hooks require a RouterProvider. */
+function useRouter() {
+	return useContext(RouterContext);
+}
+function useSnapshot(key, path) {
+	const router = useRouter();
+	const getSnapshot = () => {
+		const snapshot = router.getSnapshot();
+		if (path !== void 0 && path !== snapshot.path) return void 0;
+		return key ? snapshot[key] : snapshot;
+	};
+	return useSyncExternalStore(router.subscribe, getSnapshot, getSnapshot);
+}
+//#endregion
+export { RouterProvider, useRouter, useSnapshot };

package/dist/react/data.d.ts

@@ -0,0 +1,5 @@
+/** Resource subscriptions independent of URL navigation. @module */
+export type { ActionFunctionArgs as ResourceActionArgs, DataResult as ResourceResult, LoaderFunctionArgs as ResourceLoaderArgs, ShouldRevalidateFunctionArgs as ResourceRevalidationArgs, } from "../core/resource-types.ts";
+export { createResourceRouter, ResourceRouter, } from "../core/resources.ts";
+export type { ResourceRouteModule } from "./resources/components.tsx";
+export { Form as ResourceForm, Route as Resource, RouterProvider as ResourceProvider, useActionData as useResourceActionData, useFetcher as useResourceFetcher, useLoaderData as useResourceData, useNavigation as useResourceNavigation, useRevalidator as useResourceRevalidator, useRouteLoaderData, useRouter as useResourceRouter, useSubmit as useResourceSubmit, } from "./resources/components.tsx";

package/dist/react/data.js

@@ -0,0 +1,3 @@
+import { ResourceRouter, createResourceRouter } from "../core/resources.js";
+import { Form, Route, RouterProvider, useActionData, useFetcher, useLoaderData, useNavigation, useRevalidator, useRouteLoaderData, useRouter, useSubmit } from "./resources/components.js";
+export { Route as Resource, Form as ResourceForm, RouterProvider as ResourceProvider, ResourceRouter, createResourceRouter, useActionData as useResourceActionData, useLoaderData as useResourceData, useFetcher as useResourceFetcher, useNavigation as useResourceNavigation, useRevalidator as useResourceRevalidator, useRouter as useResourceRouter, useSubmit as useResourceSubmit, useRouteLoaderData };

package/dist/{internal/react → react}/fetcher.d.ts

@@ -2,9 +2,9 @@
  * React components and typed data hooks. Import from @kasperrt/smolter/react.
  * @module
  */
-import type { AnyDataFunction, DataFunction, DataOf, FetcherSnapshot, Result, Route as RouteDefinition, RouteModule, SubmitOptions } from "../core/index.ts";
+import { type AnyDataFunction, type DataFunction, type DataOf, type FetcherSnapshot, type Result, type Route as RouteDefinition, type RouteModule, type SubmitOptions } from "../core/index.ts";
 import { type FormProps } from "./form.ts";
-import type { ComponentType } from "./runtime.ts";
+import { type ComponentType } from "./runtime.ts";
 /** Action method and optional explicit route URL for a fetcher submission. */
 export interface FetcherSubmitOptions extends SubmitOptions {
     action?: string;

package/dist/react/fetcher.js

@@ -0,0 +1,34 @@
+import { createElement, useEffect, useMemo, useSyncExternalStore } from "./runtime.js";
+import { useRouter } from "./context.js";
+import { Form } from "./form.js";
+//#region .generated/react/fetcher.ts
+/** Create a fetcher for independent route reads and mutations; its data stays local. */
+function useFetcher(route) {
+	const router = useRouter();
+	const path = route?.path;
+	const fetcher = useMemo(() => {
+		const store = router.createFetcher();
+		const target = () => {
+			const snapshot = router.getSnapshot();
+			return path === void 0 || path === snapshot.path ? snapshot.url : path;
+		};
+		return {
+			...store,
+			Form: (props) => createElement(Form, {
+				action: target(),
+				...props,
+				fetcher: store
+			}),
+			load: (url) => store.load(url ?? target()),
+			submit: (body, options) => store.submit(options?.action ?? target(), body, options)
+		};
+	}, [router, path]);
+	useEffect(() => fetcher.dispose, [fetcher]);
+	const state = useSyncExternalStore(fetcher.subscribe, fetcher.getSnapshot, fetcher.getSnapshot);
+	return {
+		...fetcher,
+		...state
+	};
+}
+//#endregion
+export { useFetcher };

package/dist/{internal/react → react}/form.d.ts

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

package/dist/react/form.js

@@ -0,0 +1,21 @@
+import { createElement } from "./runtime.js";
+import { useRouter } from "./context.js";
+import { submitForm } from "../core/submission.js";
+//#region .generated/react/form.ts
+/** Submit form data to a registered route without a document reload. */
+function Form(options) {
+	const { action, method, fetcher, onSubmit, reloadDocument, preventScrollReset, replace, ...props } = options;
+	const router = useRouter();
+	const submit = (event) => {
+		onSubmit?.(event);
+		submitForm(router, event, event.nativeEvent.submitter, options, fetcher);
+	};
+	return createElement("form", {
+		...props,
+		action,
+		method: method === "get" ? "get" : "post",
+		onSubmit: submit
+	});
+}
+//#endregion
+export { Form };

package/dist/react/hooks.js

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

package/dist/{internal/react → react}/index.d.ts

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

package/dist/react/index.js

@@ -0,0 +1,10 @@
+import { defineRoute } from "../core/match.js";
+import { createRouter } from "../core/navigation-router.js";
+import { createDataRouter } from "../core/router.js";
+import { RouterProvider, useRouter } from "./context.js";
+import { Form } from "./form.js";
+import { useFetcher } from "./fetcher.js";
+import { useActionData, useLoaderData, useLocation, useParams, useRevalidator } from "./hooks.js";
+import { Link } from "./link.js";
+import { Routes } from "./routes.js";
+export { Form, Link, RouterProvider, Routes, createDataRouter, createRouter, defineRoute, useActionData, useFetcher, useLoaderData, useLocation, useParams, useRevalidator, useRouter };

package/dist/{internal/react → react}/link.d.ts

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

package/dist/react/link.js

@@ -0,0 +1,27 @@
+import { internalURL, navigationClick } from "../core/url.js";
+import { createElement } from "./runtime.js";
+import { useRouter } from "./context.js";
+//#region .generated/react/link.ts
+/**
+* React components and typed data hooks. Import from @kasperrt/smolter/react.
+* @module
+*/
+/** Render an anchor that handles internal navigation and preserves native modified clicks. */
+function Link(options) {
+	const { href, replace, onClick, ...props } = options;
+	const router = useRouter();
+	const click = (event) => {
+		onClick?.(event);
+		if (!navigationClick(event, event.currentTarget)) return;
+		if (!internalURL(router.getSnapshot().url, href)) return;
+		event.preventDefault();
+		router.navigate(href, options);
+	};
+	return createElement("a", {
+		...props,
+		href,
+		onClick: click
+	});
+}
+//#endregion
+export { Link };

package/dist/react/resources/components.d.ts

@@ -0,0 +1,64 @@
+/** @jsxImportSource react */
+import type { DataResult, NavigationState, Params, ResourceModule, RouteState } from "../../core/resource-types.ts";
+import type { ResourceRouter } from "../../core/resources.ts";
+import { type ComponentType, type PropsWithChildren } from "react";
+export interface ResourceRouteModule extends ResourceModule {
+    default?: ComponentType;
+    ErrorBoundary?: ComponentType<{
+        retry: () => void;
+    }>;
+    HydrateFallback?: ComponentType;
+}
+interface RouterProviderProps extends PropsWithChildren {
+    initialMatches?: readonly {
+        params?: Params;
+        routeId: string;
+    }[];
+    router: ResourceRouter;
+}
+export declare function RouterProvider({ children, initialMatches, router, }: RouterProviderProps): import("react").JSX.Element;
+interface RouteProps extends PropsWithChildren {
+    params?: Params;
+    persistent?: boolean;
+    routeId: string;
+}
+export declare function Route({ children, params, persistent, routeId, }: RouteProps): import("react").JSX.Element;
+export declare function useLoaderData<Data>(): Data | null;
+export declare function useRouteLoaderData<Data>(routeId: string, params?: Params): Data | null;
+export declare function useActionData<Data>(): Data | null;
+export declare function useNavigation(): {
+    state: NavigationState;
+};
+export declare function useRevalidator(): {
+    revalidate: () => Promise<DataResult<unknown>>;
+    state: string;
+};
+interface FetcherOptions {
+    params?: Params;
+    routeId?: string;
+}
+interface FetcherTarget {
+    params?: Params;
+    routeId?: string;
+}
+interface FormProps extends PropsWithChildren {
+    action?: string;
+    input?: unknown;
+    params?: Params;
+}
+export declare function Form({ action, children, input, params, }: FormProps): import("react").JSX.Element;
+export declare function useSubmit(): (input?: unknown) => Promise<DataResult<unknown>>;
+export declare function useFetcher<Data = unknown>(options?: FetcherOptions): readonly [
+    {
+        data: Data | null;
+        error: string;
+        state: NavigationState;
+    },
+    {
+        Form: ({ children, input, }: Pick<FormProps, "children" | "input">) => import("react").JSX.Element;
+        load: (target?: FetcherTarget) => Promise<DataResult<Data>>;
+        submit: (input: unknown, target?: FetcherTarget) => Promise<DataResult<Data>>;
+    }
+];
+export declare function useRouter(): ResourceRouter;
+export type { NavigationState, RouteState };