@adonisjs/inertia 4.0.0-next.9 → 4.0.0

package/build/inertia_manager-Ra2dhBKa.js

@@ -0,0 +1,410 @@
+import { t as InertiaHeaders } from "./headers-DafWEpBh.js";
+import { t as debug_default } from "./debug-CBMTuPUm.js";
+import "node:module";
+import { createHash } from "node:crypto";
+import { BaseSerializer } from "@adonisjs/core/transformers";
+import { pathToFileURL } from "node:url";
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var symbols_exports = /* @__PURE__ */ __exportAll({
+	ALWAYS_PROP: () => ALWAYS_PROP,
+	DEEP_MERGE: () => DEEP_MERGE,
+	DEFERRED_PROP: () => DEFERRED_PROP,
+	OPTIONAL_PROP: () => OPTIONAL_PROP,
+	TO_BE_MERGED: () => TO_BE_MERGED
+});
+const ALWAYS_PROP = Symbol.for("ALWAYS_PROP");
+const OPTIONAL_PROP = Symbol.for("OPTIONAL_PROP");
+const TO_BE_MERGED = Symbol.for("TO_BE_MERGED");
+const DEFERRED_PROP = Symbol.for("DEFERRED_PROP");
+const DEEP_MERGE = Symbol.for("DEEP_MERGE");
+var InertiaSerializer = class extends BaseSerializer {
+	wrap = void 0;
+	definePaginationMetaData(metaData) {
+		return metaData;
+	}
+};
+const inertiaSerializer = new InertiaSerializer();
+function isObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function defer(fn, group = "default") {
+	return {
+		group,
+		compute: fn,
+		merge() {
+			return merge(this);
+		},
+		[DEFERRED_PROP]: true
+	};
+}
+function optional(fn) {
+	return {
+		compute: fn,
+		[OPTIONAL_PROP]: true
+	};
+}
+function always(value) {
+	return {
+		value,
+		[ALWAYS_PROP]: true
+	};
+}
+function merge(value) {
+	return {
+		value,
+		[TO_BE_MERGED]: true,
+		[DEEP_MERGE]: false
+	};
+}
+function deepMerge(value) {
+	return {
+		value,
+		[TO_BE_MERGED]: true,
+		[DEEP_MERGE]: true
+	};
+}
+function isDeferredProp(propValue) {
+	return DEFERRED_PROP in propValue;
+}
+function isMergeableProp(propValue) {
+	return TO_BE_MERGED in propValue;
+}
+function isAlwaysProp(propValue) {
+	return ALWAYS_PROP in propValue;
+}
+function isOptionalProp(propValue) {
+	return OPTIONAL_PROP in propValue;
+}
+async function unpackPropValue(value, containerResolver) {
+	return inertiaSerializer.serialize(value, containerResolver);
+}
+async function buildStandardVisitProps(pageProps, containerResolver) {
+	const mergeProps = [];
+	const deepMergeProps = [];
+	const newProps = {};
+	const deferredProps = {};
+	const unpackedValues = [];
+	for (const [key, value] of Object.entries(pageProps)) if (isObject(value)) {
+		if (isDeferredProp(value)) {
+			deferredProps[value.group] = deferredProps[value.group] ?? [];
+			deferredProps[value.group].push(key);
+			continue;
+		}
+		if (isOptionalProp(value)) continue;
+		if (isAlwaysProp(value)) {
+			unpackedValues.push({
+				key,
+				value: value.value
+			});
+			continue;
+		}
+		if (isMergeableProp(value)) {
+			if (value[DEEP_MERGE]) deepMergeProps.push(key);
+			else mergeProps.push(key);
+			if (isObject(value.value) && isDeferredProp(value.value)) {
+				deferredProps[value.value.group] = deferredProps[value.value.group] ?? [];
+				deferredProps[value.value.group].push(key);
+				unpackedValues.push({
+					key,
+					value: value.value.compute
+				});
+			} else unpackedValues.push({
+				key,
+				value: value.value
+			});
+			continue;
+		}
+		unpackedValues.push({
+			key,
+			value
+		});
+	} else {
+		if (typeof value === "function") {
+			unpackedValues.push({
+				key,
+				value
+			});
+			continue;
+		}
+		newProps[key] = value;
+	}
+	await Promise.all(unpackedValues.map(async ({ key, value }) => {
+		if (typeof value === "function") return Promise.resolve(value()).then((r) => unpackPropValue(r, containerResolver)).then((jsonValue) => {
+			newProps[key] = jsonValue;
+		});
+		else return unpackPropValue(value, containerResolver).then((jsonValue) => {
+			newProps[key] = jsonValue;
+		});
+	}));
+	return {
+		props: newProps,
+		mergeProps,
+		deepMergeProps,
+		deferredProps
+	};
+}
+async function buildPartialRequestProps(pageProps, cherryPickProps, containerResolver) {
+	const mergeProps = [];
+	const deepMergeProps = [];
+	const newProps = {};
+	const unpackedValues = [];
+	for (const [key, value] of Object.entries(pageProps)) if (isObject(value)) {
+		if (isAlwaysProp(value)) {
+			unpackedValues.push({
+				key,
+				value: value.value
+			});
+			continue;
+		}
+		if (!cherryPickProps.includes(key)) continue;
+		if (isDeferredProp(value)) {
+			unpackedValues.push({
+				key,
+				value: value.compute
+			});
+			continue;
+		}
+		if (isOptionalProp(value)) {
+			unpackedValues.push({
+				key,
+				value: value.compute
+			});
+			continue;
+		}
+		if (isMergeableProp(value)) {
+			if (value[DEEP_MERGE]) deepMergeProps.push(key);
+			else mergeProps.push(key);
+			if (isObject(value.value) && isDeferredProp(value.value)) unpackedValues.push({
+				key,
+				value: value.value.compute
+			});
+			else unpackedValues.push({
+				key,
+				value: value.value
+			});
+			continue;
+		}
+		unpackedValues.push({
+			key,
+			value
+		});
+	} else {
+		if (!cherryPickProps.includes(key)) continue;
+		if (typeof value === "function") {
+			unpackedValues.push({
+				key,
+				value
+			});
+			continue;
+		}
+		newProps[key] = value;
+	}
+	await Promise.all(unpackedValues.map(async ({ key, value }) => {
+		if (typeof value === "function") return Promise.resolve(value()).then((r) => unpackPropValue(r, containerResolver)).then((jsonValue) => {
+			newProps[key] = jsonValue;
+		});
+		else return unpackPropValue(value, containerResolver).then((jsonValue) => {
+			newProps[key] = jsonValue;
+		});
+	}));
+	return {
+		props: newProps,
+		mergeProps,
+		deepMergeProps,
+		deferredProps: {}
+	};
+}
+var Inertia = class {
+	#sharedStateProviders;
+	#cachedRequestInfo;
+	#serverRenderer;
+	#vite;
+	#shouldClearHistory;
+	#shouldEncryptHistory;
+	#cachedVersion;
+	defer = defer;
+	always = always;
+	merge = merge;
+	optional = optional;
+	deepMerge = deepMerge;
+	constructor(ctx, config, vite, serverRenderer) {
+		this.ctx = ctx;
+		this.config = config;
+		if (debug_default.enabled) debug_default("instantiating inertia instance for request \"%s\" using config %O", ctx.request.url(), this.config);
+		this.#shouldClearHistory = false;
+		this.#vite = vite;
+		this.#serverRenderer = serverRenderer;
+		this.#shouldEncryptHistory = config.encryptHistory ?? false;
+		this.#cachedVersion = this.config.assetsVersion ? String(this.config.assetsVersion) : void 0;
+	}
+	#resolveRootView() {
+		return typeof this.config.rootView === "function" ? this.config.rootView(this.ctx) : this.config.rootView;
+	}
+	async #buildPageProps(component, requestInfo, pageProps) {
+		let finalProps;
+		if (this.#sharedStateProviders) finalProps = {
+			...await Promise.all(this.#sharedStateProviders.map((provider) => {
+				return typeof provider === "function" ? provider() : provider;
+			})).then((resolvedSharedState) => {
+				return resolvedSharedState.reduce((result, state) => {
+					return {
+						...result,
+						...state
+					};
+				}, {});
+			}),
+			...pageProps
+		};
+		else finalProps = { ...pageProps };
+		if (requestInfo.partialComponent === component) {
+			const only = requestInfo.onlyProps;
+			const except = requestInfo.exceptProps ?? [];
+			const cherryPickProps = Object.keys(finalProps).filter((propName) => {
+				if (only) return only.includes(propName) && !except.includes(propName);
+				return !except.includes(propName);
+			});
+			debug_default("building props for a partial reload %O", requestInfo);
+			debug_default("cherry picking props %s", cherryPickProps);
+			return buildPartialRequestProps(finalProps, cherryPickProps, this.ctx.containerResolver);
+		}
+		debug_default("building props for a standard visit %O", requestInfo);
+		return buildStandardVisitProps(finalProps, this.ctx.containerResolver);
+	}
+	#handleInertiaRequest(pageObject) {
+		this.ctx.response.header(InertiaHeaders.Inertia, "true");
+		return pageObject;
+	}
+	async #renderWithSSR(pageObject, viewProps) {
+		if (!this.#serverRenderer) throw new Error("Cannot server render pages without a server renderer");
+		debug_default("server-side rendering %O", pageObject);
+		const { head, body } = await this.#serverRenderer.render(pageObject);
+		return this.ctx.view.render(this.#resolveRootView(), {
+			page: {
+				ssrHead: head,
+				ssrBody: body,
+				...pageObject
+			},
+			...viewProps
+		});
+	}
+	async #renderClientSide(pageObject, viewProps) {
+		debug_default("rendering shell for SPA %O", pageObject);
+		return this.ctx.view.render(this.#resolveRootView(), {
+			page: pageObject,
+			...viewProps
+		});
+	}
+	requestInfo(reCompute) {
+		if (reCompute) this.#cachedRequestInfo = void 0;
+		this.#cachedRequestInfo = this.#cachedRequestInfo ?? {
+			version: this.ctx.request.header(InertiaHeaders.Version),
+			isInertiaRequest: !!this.ctx.request.header(InertiaHeaders.Inertia),
+			isPartialRequest: !!this.ctx.request.header(InertiaHeaders.PartialComponent),
+			partialComponent: this.ctx.request.header(InertiaHeaders.PartialComponent),
+			onlyProps: this.ctx.request.header(InertiaHeaders.PartialOnly)?.split(","),
+			exceptProps: this.ctx.request.header(InertiaHeaders.PartialExcept)?.split(","),
+			resetProps: this.ctx.request.header(InertiaHeaders.Reset)?.split(","),
+			errorBag: this.ctx.request.header(InertiaHeaders.ErrorBag)
+		};
+		return this.#cachedRequestInfo;
+	}
+	getVersion() {
+		if (this.#cachedVersion) return this.#cachedVersion;
+		if (this.#vite?.hasManifestFile) this.#cachedVersion = createHash("md5").update(JSON.stringify(this.#vite.manifest())).digest("hex");
+		else this.#cachedVersion = "1";
+		return this.#cachedVersion;
+	}
+	async ssrEnabled(component) {
+		if (!this.config.ssr.enabled) return false;
+		if (typeof this.config.ssr.pages === "function") return this.config.ssr.pages(this.ctx, component);
+		if (this.config.ssr.pages) return this.config.ssr.pages?.includes(component);
+		return true;
+	}
+	share(sharedState) {
+		if (!this.#sharedStateProviders) this.#sharedStateProviders = [];
+		this.#sharedStateProviders.push(sharedState);
+		return this;
+	}
+	async page(page, pageProps) {
+		const requestInfo = this.requestInfo();
+		const { props, mergeProps, deferredProps, deepMergeProps } = await this.#buildPageProps(page, requestInfo, pageProps);
+		return {
+			component: page,
+			url: this.ctx.request.url(true),
+			version: this.getVersion(),
+			clearHistory: this.#shouldClearHistory,
+			encryptHistory: this.#shouldEncryptHistory,
+			props,
+			deferredProps,
+			mergeProps,
+			deepMergeProps
+		};
+	}
+	async render(page, pageProps, viewProps) {
+		const requestInfo = this.requestInfo();
+		const pageObject = await this.page(page, pageProps);
+		if (requestInfo.isInertiaRequest) return this.#handleInertiaRequest(pageObject);
+		if (await this.ssrEnabled(page)) return this.#renderWithSSR(pageObject, viewProps);
+		return this.#renderClientSide(pageObject, viewProps);
+	}
+	clearHistory() {
+		this.#shouldClearHistory = true;
+	}
+	encryptHistory(encrypt = true) {
+		this.#shouldEncryptHistory = encrypt;
+	}
+	location(url) {
+		this.ctx.response.header(InertiaHeaders.Location, url);
+		this.ctx.response.status(409);
+	}
+};
+var ServerRenderer = class {
+	#runtime;
+	#config;
+	#vite;
+	constructor(config, vite) {
+		this.#config = config;
+		this.#vite = vite;
+	}
+	async render(pageObject) {
+		let render;
+		if (this.#vite.getDevServer()) {
+			debug_default("creating SSR bundle using dev-server");
+			this.#runtime ??= await this.#vite.createModuleRunner();
+			this.#runtime.clearCache();
+			render = await this.#runtime.import(this.#config.ssr.entrypoint);
+		} else {
+			debug_default("creating SSR bundle using production build");
+			render = await import(pathToFileURL(this.#config.ssr.bundle).href);
+		}
+		const result = await render.default(pageObject);
+		debug_default("SSR bundle %o", result);
+		return {
+			head: result.head,
+			body: result.body
+		};
+	}
+};
+var InertiaManager = class {
+	#vite;
+	#config;
+	#serverRenderer;
+	constructor(config, vite) {
+		this.#config = config;
+		this.#vite = vite;
+		this.#serverRenderer = this.#vite ? new ServerRenderer(this.#config, this.#vite) : void 0;
+	}
+	createForRequest(ctx) {
+		return new Inertia(ctx, this.#config, this.#vite, this.#serverRenderer);
+	}
+};
+export { symbols_exports as i, ServerRenderer as n, Inertia as r, InertiaManager as t };

package/build/providers/inertia_provider.js

@@ -1,82 +1,28 @@
-import {
-  InertiaManager
-} from "../chunk-XXMTGYB5.js";
-import "../chunk-DISC5OYC.js";
-import "../chunk-4EZ2J6OA.js";
-import "../chunk-MLKGABMK.js";
-
-// providers/inertia_provider.ts
+import { t as InertiaManager } from "../inertia_manager-Ra2dhBKa.js";
+import "../headers-DafWEpBh.js";
+import "../debug-CBMTuPUm.js";
 import { BriskRoute } from "@adonisjs/core/http";
 var InertiaProvider = class {
-  /**
-   * Creates a new InertiaProvider instance
-   *
-   * @param app - The AdonisJS application service instance
-   */
-  constructor(app) {
-    this.app = app;
-  }
-  /**
-   * Registers the Inertia Edge.js plugin when Edge.js is available
-   *
-   * This method conditionally registers the Edge plugin that provides
-   * @inertia and @inertiaHead tags for rendering Inertia pages.
-   *
-   * @example
-   * ```edge
-   * {{-- Templates can then use --}}
-   * @inertia(page)
-   * @inertiaHead(page)
-   * ```
-   */
-  async registerEdgePlugin() {
-    const edgeExports = await import("edge.js");
-    const { edgePluginInertia } = await import("../src/plugins/edge/plugin.js");
-    edgeExports.default.use(edgePluginInertia());
-  }
-  /**
-   * Registers the InertiaManager as a singleton in the IoC container
-   *
-   * This method sets up the core Inertia manager with the application's
-   * configuration and Vite integration. The manager handles page rendering,
-   * asset management, and SSR functionality.
-   *
-   * @example
-   * ```js
-   * // The manager is automatically available for injection:
-   * const inertiaManager = await app.container.make(InertiaManager)
-   * ```
-   */
-  async register() {
-    this.app.container.singleton(InertiaManager, async (resolver) => {
-      const config = this.app.config.get("inertia", {});
-      const vite = await resolver.make("vite");
-      return new InertiaManager(config, vite);
-    });
-  }
-  /**
-   * Boot the provider by registering Edge plugin and route macros
-   *
-   * This method completes the Inertia setup by registering the Edge plugin
-   * and adding the renderInertia macro to BriskRoute for convenient route definitions.
-   *
-   * @example
-   * ```js
-   * // Routes can now use the renderInertia macro
-   * router.get('/dashboard', []).renderInertia('Dashboard', {
-   *   user: getCurrentUser()
-   * })
-   * ```
-   */
-  async boot() {
-    await this.registerEdgePlugin();
-    BriskRoute.macro("renderInertia", function(template, props, viewProps) {
-      return this.setHandler(({ inertia }) => {
-        return inertia.render(template, props, viewProps);
-      });
-    });
-  }
-};
-export {
-  InertiaProvider as default
+	constructor(app) {
+		this.app = app;
+	}
+	async registerEdgePlugin() {
+		const edgeExports = await import("edge.js");
+		const { edgePluginInertia } = await import("../src/plugins/edge/plugin.js");
+		edgeExports.default.use(edgePluginInertia());
+	}
+	async register() {
+		this.app.container.singleton(InertiaManager, async (resolver) => {
+			return new InertiaManager(this.app.config.get("inertia", {}), await resolver.make("vite"));
+		});
+	}
+	async boot() {
+		await this.registerEdgePlugin();
+		BriskRoute.macro("renderInertia", function(template, props, viewProps) {
+			return this.setHandler(({ inertia }) => {
+				return inertia.render(template, props, viewProps);
+			});
+		});
+	}
 };
+export { InertiaProvider as default };

package/build/src/client/common.d.ts

@@ -0,0 +1,27 @@
+import type { UserRegistry, InferRoutes } from '@tuyau/core/types';
+import type { AreAllOptional } from '@poppinss/utils/types';
+export type Routes = InferRoutes<UserRegistry>;
+/**
+ * Get parameter tuple type for a route
+ */
+export type ExtractParamsTuple<Route extends keyof Routes> = Routes[Route]['types']['paramsTuple'];
+/**
+ * Get parameter object type for a route
+ */
+export type ExtractParamsObject<Route extends keyof Routes> = Routes[Route]['types']['params'];
+/**
+ * Get params format for a route
+ */
+export type RouteParamsFormats<Route extends keyof Routes> = ExtractParamsObject<Route> extends Record<string, never> ? never : ExtractParamsTuple<Route> | ExtractParamsObject<Route>;
+/**
+ * Parameters required for route navigation with proper type safety.
+ */
+export type RouteParams<Route extends keyof Routes> = {
+    route: Route;
+} & (RouteParamsFormats<Route> extends never ? {
+    routeParams?: never;
+} : AreAllOptional<ExtractParamsObject<Route>> extends true ? {
+    routeParams?: RouteParamsFormats<Route>;
+} : {
+    routeParams: RouteParamsFormats<Route>;
+});

package/build/src/client/helpers.js

@@ -1,30 +1,13 @@
-import "../../chunk-MLKGABMK.js";
-
-// src/client/helpers.ts
 async function resolvePageComponent(path, pages, layout) {
-  for (const p of Array.isArray(path) ? path : [path]) {
-    const page = pages[p];
-    if (typeof page === "undefined") {
-      continue;
-    }
-    const resolvedPage = await (typeof page === "function" ? page() : page);
-    if (!resolvedPage) {
-      throw new Error(
-        `Invalid page exported from "${path}". Make sure to default export a function`
-      );
-    }
-    if ("default" in resolvedPage === false) {
-      throw new Error(
-        `Invalid page exported from "${path}". Make sure to default export a function`
-      );
-    }
-    if (layout && !resolvedPage.default.layout) {
-      resolvedPage.default.layout = layout;
-    }
-    return resolvedPage;
-  }
-  throw new Error(`Page not found: "${path}"`);
+	for (const p of Array.isArray(path) ? path : [path]) {
+		const page = pages[p];
+		if (typeof page === "undefined") continue;
+		const resolvedPage = await (typeof page === "function" ? page() : page);
+		if (!resolvedPage) throw new Error(`Invalid page exported from "${path}". Make sure to default export a function`);
+		if ("default" in resolvedPage === false) throw new Error(`Invalid page exported from "${path}". Make sure to default export a function`);
+		if (layout && !resolvedPage.default.layout) resolvedPage.default.layout = layout;
+		return resolvedPage;
+	}
+	throw new Error(`Page not found: "${path}"`);
 }
-export {
-  resolvePageComponent
-};
+export { resolvePageComponent };

package/build/src/client/react/context.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { Tuyau } from '@tuyau/core/client';
+import type { TuyauRegistry } from '@tuyau/core/types';
+/**
+ * Provider component that makes the Tuyau client available to child components.
+ *
+ * This component should wrap your entire application or the part of your
+ * application that needs access to type-safe routing functionality.
+ *
+ */
+export declare function TuyauProvider<R extends TuyauRegistry>(props: {
+    children: React.ReactNode;
+    client: Tuyau<R>;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access the Tuyau client from any component within a TuyauProvider.
+ *
+ * Provides type-safe access to route generation and navigation utilities.
+ * Must be used within a component tree wrapped by TuyauProvider.
+ *
+ * @returns The Tuyau client instance with full type safety
+ * @throws Error if used outside of a TuyauProvider
+ */
+export declare function useTuyau(): Tuyau<any, any>;

package/build/src/client/react/form.d.ts

@@ -0,0 +1,76 @@
+import React from 'react';
+import { Form as InertiaForm } from '@inertiajs/react';
+import type { RouteParams, Routes } from '../common.ts';
+/**
+ * Parameters required for route navigation with proper type safety.
+ */
+export type FormParams<Route extends keyof Routes> = RouteParams<Route>;
+/**
+ * Props for the Form component when using route-based navigation
+ */
+type FormRouteProps<Route extends keyof Routes> = Omit<React.ComponentPropsWithoutRef<typeof InertiaForm>, 'action' | 'method'> & FormParams<Route> & {
+    action?: never;
+};
+/**
+ * Props for the Form component when using direct action
+ */
+type FormActionProps = Omit<React.ComponentPropsWithoutRef<typeof InertiaForm>, 'route'> & {
+    route?: never;
+};
+/**
+ * Union type for Form component props - either route-based or direct action
+ */
+type FormProps<Route extends keyof Routes = keyof Routes> = FormRouteProps<Route> | FormActionProps;
+/**
+ * Internal Form component implementation with forward ref support.
+ * Resolves route parameters and generates the appropriate URL and HTTP method
+ * for Inertia form submission when using route-based navigation.
+ * Falls back to standard InertiaForm when action is provided directly.
+ */
+declare function FormInner<Route extends keyof Routes>(props: FormProps<Route>, ref?: React.ForwardedRef<React.ElementRef<typeof InertiaForm>>): import("react/jsx-runtime").JSX.Element;
+/**
+ * Type-safe Form component for Inertia.js form submissions.
+ *
+ * Provides compile-time route validation and automatic parameter type checking
+ * based on your application's route definitions. Automatically resolves the
+ * correct URL and HTTP method for each route. Alternatively, you can use
+ * the standard action prop for direct form submission.
+ *
+ * @example
+ * ```tsx
+ * // Form to a route without parameters
+ * <Form route="users.store">
+ *   {({ processing }) => (
+ *     <>
+ *       <input type="text" name="name" />
+ *       <button type="submit" disabled={processing}>Create</button>
+ *     </>
+ *   )}
+ * </Form>
+ *
+ * // Form to a route with required parameters
+ * <Form route="users.update" routeParams={{ id: 1 }}>
+ *   {({ errors }) => (
+ *     <>
+ *       <input type="text" name="name" />
+ *       {errors.name && <div>{errors.name}</div>}
+ *       <button type="submit">Update</button>
+ *     </>
+ *   )}
+ * </Form>
+ *
+ * // Form with direct action
+ * <Form action={{ url: '/users', method: 'post' }}>
+ *   {({ processing }) => (
+ *     <>
+ *       <input type="text" name="name" />
+ *       <button type="submit" disabled={processing}>Create</button>
+ *     </>
+ *   )}
+ * </Form>
+ * ```
+ */
+export declare const Form: <Route extends keyof Routes>(props: FormProps<Route> & {
+    ref?: React.Ref<React.ElementRef<typeof InertiaForm>>;
+}) => ReturnType<typeof FormInner>;
+export {};

package/build/src/client/react/index.d.ts

@@ -0,0 +1,4 @@
+export * from './context.tsx';
+export * from './router.ts';
+export * from './link.tsx';
+export * from './form.tsx';