@adonisjs/inertia 4.0.0-next.1 → 4.0.0-next.10

package/build/{chunk-PDP56GPP.js → chunk-5QRJHXXQ.js}

@@ -8,16 +8,18 @@ var TYPES_EXTRACTION_HELPER = {
   vue3: `import type { VNodeProps, AllowedComponentProps, ComponentInstance } from 'vue'
 
 type ExtractProps<T> = Omit<
-  ComponentInstance<T>['$props'][K],
+  ComponentInstance<T>['$props'],
   keyof VNodeProps | keyof AllowedComponentProps
 >`,
   react: `import type React from 'react'
+import type { Prettify } from '@adonisjs/core/types/common'
 
-type ExtractProps<T> = T extends React.FC<infer Props>
-? Props
-: T extends React.Component<infer Props>
-? Props
-: never`
+type ExtractProps<T> =
+  T extends React.FC<infer Props>
+    ? Prettify<Omit<Props, 'children'>>
+    : T extends React.Component<infer Props>
+      ? Prettify<Omit<Props, 'children'>>
+      : never`
 };
 var indexPages = function(config) {
   if (!SUPPORTED_FRAMEWORKS.includes(config.framework)) {
@@ -26,14 +28,29 @@ var indexPages = function(config) {
     );
   }
   return {
+    /**
+     * Executes the page indexing process to generate TypeScript definitions.
+     *
+     * @param _ - Unused first parameter (assembler context)
+     * @param indexGenerator - The index generator instance used to register the pages type generation
+     */
     run(_, indexGenerator) {
       indexGenerator.add("inertiaPages", {
         source: "inertia/pages",
         glob: GLOB[config.framework],
         output: ".adonisjs/server/pages.d.ts",
+        /**
+         * Generates the TypeScript module declaration for Inertia pages.
+         *
+         * @param vfs - Virtual file system containing the scanned page files
+         * @param buffer - Buffer instance for writing the generated TypeScript code
+         * @param __ - Unused third parameter
+         * @param helpers - Helper utilities for path manipulation and imports
+         */
         as(vfs, buffer, __, helpers) {
           const filesList = vfs.asList();
-          buffer.write(TYPES_EXTRACTION_HELPER[config.framework]);
+          buffer.writeLine(`import '@adonisjs/inertia/types'`);
+          buffer.writeLine(TYPES_EXTRACTION_HELPER[config.framework]);
           buffer.write(`declare module '@adonisjs/inertia/types' {`).indent();
           buffer.write(`export interface InertiaPages {`).indent();
           Object.keys(filesList).forEach((key) => {
@@ -55,14 +72,13 @@ function defineConfig(config) {
   return lodash.merge(
     {
       rootView: "inertia_layout",
-      entrypoint: "inertia/app/app.ts",
       history: {
         encrypt: false
       },
       ssr: {
         enabled: false,
         bundle: "ssr/ssr.js",
-        entrypoint: "inertia/app/ssr.ts"
+        entrypoint: "inertia/ssr.tsx"
       }
     },
     config

package/build/{chunk-74S2VAL7.js → chunk-YQ72YL64.js}

@@ -1,9 +1,9 @@
-import {
-  InertiaHeaders
-} from "./chunk-DISC5OYC.js";
 import {
   debug_default
 } from "./chunk-4EZ2J6OA.js";
+import {
+  InertiaHeaders
+} from "./chunk-DISC5OYC.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";
@@ -79,10 +79,10 @@ function isAlwaysProp(propValue) {
 function isOptionalProp(propValue) {
   return OPTIONAL_PROP in propValue;
 }
-async function unpackPropValue(value) {
-  return serialize(value);
+async function unpackPropValue(value, containerResolver) {
+  return serialize(value, containerResolver);
 }
-async function buildStandardVisitProps(pageProps) {
+async function buildStandardVisitProps(pageProps, containerResolver) {
   const mergeProps = [];
   const deepMergeProps = [];
   const newProps = {};
@@ -141,11 +141,11 @@ async function buildStandardVisitProps(pageProps) {
   await Promise.all(
     unpackedValues.map(async ({ key, value }) => {
       if (typeof value === "function") {
-        return Promise.resolve(value()).then((r) => unpackPropValue(r)).then((jsonValue) => {
+        return Promise.resolve(value()).then((r) => unpackPropValue(r, containerResolver)).then((jsonValue) => {
           newProps[key] = jsonValue;
         });
       } else {
-        return unpackPropValue(value).then((jsonValue) => {
+        return unpackPropValue(value, containerResolver).then((jsonValue) => {
           newProps[key] = jsonValue;
         });
       }
@@ -158,7 +158,7 @@ async function buildStandardVisitProps(pageProps) {
     deferredProps
   };
 }
-async function buildPartialRequestProps(pageProps, cherryPickProps) {
+async function buildPartialRequestProps(pageProps, cherryPickProps, containerResolver) {
   const mergeProps = [];
   const deepMergeProps = [];
   const newProps = {};
@@ -208,11 +208,11 @@ async function buildPartialRequestProps(pageProps, cherryPickProps) {
   await Promise.all(
     unpackedValues.map(async ({ key, value }) => {
       if (typeof value === "function") {
-        return Promise.resolve(value()).then((r) => unpackPropValue(r)).then((jsonValue) => {
+        return Promise.resolve(value()).then((r) => unpackPropValue(r, containerResolver)).then((jsonValue) => {
           newProps[key] = jsonValue;
         });
       } else {
-        return unpackPropValue(value).then((jsonValue) => {
+        return unpackPropValue(value, containerResolver).then((jsonValue) => {
           newProps[key] = jsonValue;
         });
       }
@@ -260,7 +260,7 @@ var Inertia = class {
     this.#shouldEncryptHistory = config.encryptHistory ?? false;
     this.#cachedVersion = this.config.assetsVersion ? String(this.config.assetsVersion) : void 0;
   }
-  #sharedState;
+  #sharedStateProviders;
   #cachedRequestInfo;
   /**
    * Optional server-side renderer for SSR functionality
@@ -341,6 +341,12 @@ var Inertia = class {
    * Resolve the root view template
    *
    * Handles both static strings and dynamic functions for the root view.
+   *
+   * @example
+   * ```js
+   * const viewName = this.#resolveRootView()
+   * this.ctx.view.render(viewName, { page: pageObject })
+   * ```
    */
   #resolveRootView() {
     return typeof this.config.rootView === "function" ? this.config.rootView(this.ctx) : this.config.rootView;
@@ -349,13 +355,37 @@ var Inertia = class {
    * Constructs and serializes the page props for a given component
    *
    * Handles both full page loads and partial requests with prop filtering.
+   * Merges shared state providers with page-specific props, and handles
+   * prop cherry-picking for partial reloads based on the `only` and `except` parameters.
    *
    * @param component - The component name being rendered
    * @param requestInfo - Information about the current request
    * @param pageProps - Raw page props to be processed
+   *
+   * @example
+   * ```js
+   * const result = await this.#buildPageProps('Dashboard', requestInfo, {
+   *   user: { name: 'John' },
+   *   posts: defer(() => getPosts())
+   * })
+   * ```
    */
-  #buildPageProps(component, requestInfo, pageProps) {
-    const finalProps = { ...this.#sharedState, ...pageProps };
+  async #buildPageProps(component, requestInfo, pageProps) {
+    let finalProps;
+    if (this.#sharedStateProviders) {
+      const sharedState = await Promise.all(
+        this.#sharedStateProviders.map((provider) => {
+          return typeof provider === "function" ? provider() : provider;
+        })
+      ).then((resolvedSharedState) => {
+        return resolvedSharedState.reduce((result, state) => {
+          return { ...result, ...state };
+        }, {});
+      });
+      finalProps = { ...sharedState, ...pageProps };
+    } else {
+      finalProps = { ...pageProps };
+    }
     if (requestInfo.partialComponent === component) {
       const only = requestInfo.onlyProps;
       const except = requestInfo.exceptProps ?? [];
@@ -367,15 +397,24 @@ var Inertia = class {
       });
       debug_default("building props for a partial reload %O", requestInfo);
       debug_default("cherry picking props %s", cherryPickProps);
-      return buildPartialRequestProps(finalProps, cherryPickProps);
+      return buildPartialRequestProps(finalProps, cherryPickProps, this.ctx.containerResolver);
     }
     debug_default("building props for a standard visit %O", requestInfo);
-    return buildStandardVisitProps(finalProps);
+    return buildStandardVisitProps(finalProps, this.ctx.containerResolver);
   }
   /**
-   * Handle Inertia request by setting headers and returning page object
+   * Handle Inertia AJAX request by setting appropriate headers
+   *
+   * Sets the `X-Inertia` header to 'true' indicating this is an Inertia response,
+   * then returns the page object which will be serialized as JSON.
    *
    * @param pageObject - The page object to return
+   *
+   * @example
+   * ```js
+   * const pageObj = await this.page('Dashboard', props)
+   * return this.#handleInertiaRequest(pageObj)
+   * ```
    */
   #handleInertiaRequest(pageObject) {
     this.ctx.response.header(InertiaHeaders.Inertia, "true");
@@ -386,6 +425,7 @@ var Inertia = class {
    *
    * @param pageObject - The page object to render
    * @param viewProps - Additional props to pass to the root view template
+   * @returns Promise resolving to the rendered HTML string
    */
   async #renderWithSSR(pageObject, viewProps) {
     if (!this.#serverRenderer) {
@@ -403,6 +443,7 @@ var Inertia = class {
    *
    * @param pageObject - The page object to render
    * @param viewProps - Additional props to pass to the root view template
+   * @returns Promise resolving to the rendered HTML string
    */
   async #renderClientSide(pageObject, viewProps) {
     debug_default("rendering shell for SPA %O", pageObject);
@@ -413,6 +454,9 @@ var Inertia = class {
    *
    * Parses various Inertia headers to determine request type and props filtering.
    *
+   * @param reCompute - Whether to recompute the request info instead of using cached version
+   * @returns The request information object containing Inertia-specific data
+   *
    * @example
    * ```js
    * const info = inertia.requestInfo()
@@ -441,13 +485,15 @@ var Inertia = class {
    * Compute and cache the assets version
    *
    * Uses Vite manifest hash when available, otherwise defaults to '1'.
+   *
+   * @returns The computed version string for asset versioning
    */
   getVersion() {
     if (this.#cachedVersion) {
       return this.#cachedVersion;
     }
     if (this.#vite?.hasManifestFile) {
-      this.#cachedVersion = createHash("md5").update(JSON.stringify(this.#vite.manifest)).digest("hex");
+      this.#cachedVersion = createHash("md5").update(JSON.stringify(this.#vite.manifest())).digest("hex");
     } else {
       this.#cachedVersion = "1";
     }
@@ -459,6 +505,7 @@ var Inertia = class {
    * Checks global SSR settings and component-specific configuration.
    *
    * @param component - The component name to check
+   * @returns Promise resolving to true if SSR is enabled for the component
    *
    * @example
    * ```js
@@ -488,6 +535,7 @@ var Inertia = class {
    * in every page render alongside page-specific props.
    *
    * @param sharedState - Props to share across all pages
+   * @returns The Inertia instance for method chaining
    *
    * @example
    * ```js
@@ -504,7 +552,10 @@ var Inertia = class {
    * ```
    */
   share(sharedState) {
-    this.#sharedState = { ...this.#sharedState, ...sharedState };
+    if (!this.#sharedStateProviders) {
+      this.#sharedStateProviders = [];
+    }
+    this.#sharedStateProviders.push(sharedState);
     return this;
   }
   /**
@@ -514,6 +565,7 @@ var Inertia = class {
    *
    * @param page - The page component name
    * @param pageProps - Props to pass to the page component
+   * @returns Promise resolving to the complete page object
    *
    * @example
    * ```js
@@ -553,8 +605,7 @@ var Inertia = class {
    * @param page - The page component name to render
    * @param pageProps - Props to pass to the page component
    * @param viewProps - Additional props to pass to the root view template
-   *
-   * @returns PageObject for Inertia requests, HTML string for initial page loads
+   * @returns Promise resolving to PageObject for Inertia requests, HTML string for initial page loads
    *
    * @example
    * ```js
@@ -678,7 +729,7 @@ var ServerRenderer = class {
    * @returns Promise resolving to an object with rendered head and body HTML
    *
    * @example
-   * ```typescript
+   * ```js
    * const pageObject = {
    *   component: 'Home',
    *   props: { user: { name: 'John' } },
@@ -741,6 +792,7 @@ var InertiaManager = class {
    * Creates a new Inertia instance for a specific HTTP request
    *
    * @param ctx - HTTP context for the current request
+   * @returns A new Inertia instance configured for the given request
    *
    * @example
    * ```js

package/build/factories/main.js

@@ -1,14 +1,14 @@
 import {
   defineConfig
-} from "../chunk-PDP56GPP.js";
+} from "../chunk-5QRJHXXQ.js";
 import {
   Inertia,
   ServerRenderer
-} from "../chunk-74S2VAL7.js";
+} from "../chunk-YQ72YL64.js";
+import "../chunk-4EZ2J6OA.js";
 import {
   InertiaHeaders
 } from "../chunk-DISC5OYC.js";
-import "../chunk-4EZ2J6OA.js";
 import "../chunk-MLKGABMK.js";
 
 // factories/inertia_factory.ts

package/build/index.js

@@ -1,17 +1,17 @@
 import {
   defineConfig,
   indexPages
-} from "./chunk-PDP56GPP.js";
+} from "./chunk-5QRJHXXQ.js";
 import {
   Inertia,
   InertiaManager,
   ServerRenderer,
   symbols_exports
-} from "./chunk-74S2VAL7.js";
+} from "./chunk-YQ72YL64.js";
+import "./chunk-4EZ2J6OA.js";
 import {
   InertiaHeaders
 } from "./chunk-DISC5OYC.js";
-import "./chunk-4EZ2J6OA.js";
 import "./chunk-MLKGABMK.js";
 export {
   Inertia,

package/build/providers/inertia_provider.d.ts

@@ -1,6 +1,6 @@
 import { type Route } from '@adonisjs/core/http';
 import type { ApplicationService } from '@adonisjs/core/types';
-import type { AsPageProps, InertiaPages } from '../src/types.js';
+import type { AsPageProps, ComponentProps, InertiaPages, SharedProps } from '../src/types.js';
 declare module '@adonisjs/core/http' {
     interface BriskRoute {
         /**
@@ -29,7 +29,7 @@ declare module '@adonisjs/core/http' {
          * })
          * ```
          */
-        renderInertia<Page extends keyof InertiaPages>(component: Page, props: AsPageProps<InertiaPages[Page]>, viewProps?: Record<string, any>): Route;
+        renderInertia<Page extends keyof InertiaPages>(component: Page, props: InertiaPages[Page] extends ComponentProps ? AsPageProps<Omit<InertiaPages[Page], keyof SharedProps>> : never, viewProps?: Record<string, any>): Route;
     }
 }
 /**

package/build/providers/inertia_provider.js

@@ -1,8 +1,8 @@
 import {
   InertiaManager
-} from "../chunk-74S2VAL7.js";
-import "../chunk-DISC5OYC.js";
+} from "../chunk-YQ72YL64.js";
 import "../chunk-4EZ2J6OA.js";
+import "../chunk-DISC5OYC.js";
 import "../chunk-MLKGABMK.js";
 
 // providers/inertia_provider.ts

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

@@ -0,0 +1,27 @@
+/**
+ * Resolves a page component from a given path or array of paths by looking up
+ * the component in the provided pages registry. Supports both direct promises
+ * and lazy-loaded functions that return promises.
+ *
+ * @param path - The page path(s) to resolve. Can be a single string or array of strings
+ * @param pages - Registry of page components where keys are paths and values are either promises or functions returning promises
+ * @param layout - Optional layout component to assign to the resolved page
+ * @returns Promise resolving to the page component
+ *
+ * @example
+ * ```js
+ * // Single path resolution
+ * const component = await resolvePageComponent('Home', {
+ *   'Home': () => import('./pages/Home.vue'),
+ *   'About': () => import('./pages/About.vue')
+ * })
+ *
+ * // Multiple path resolution (fallback)
+ * const component = await resolvePageComponent(['Dashboard/Admin', 'Dashboard'], {
+ *   'Dashboard': () => import('./pages/Dashboard.vue')
+ * })
+ * ```
+ *
+ * @throws Error When none of the provided paths can be resolved in the pages registry
+ */
+export declare function resolvePageComponent<T>(path: string | string[], pages: Record<string, Promise<T> | (() => Promise<T>) | T>, layout?: any): Promise<T>;

package/build/src/client/helpers.js

@@ -0,0 +1,30 @@
+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}"`);
+}
+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 { AdonisRegistry } 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 AdonisRegistry>(props: {
+    children: React.ReactNode;
+    client: Tuyau<R>;
+}): React.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>;

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

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

package/build/src/client/react/index.js

@@ -0,0 +1,72 @@
+import "../../../chunk-MLKGABMK.js";
+
+// src/client/react/context.tsx
+import React from "react";
+var TuyauContext = React.createContext(null);
+function TuyauProvider(props) {
+  return /* @__PURE__ */ React.createElement(TuyauContext.Provider, { value: props.client }, props.children);
+}
+function useTuyau() {
+  const context = React.useContext(TuyauContext);
+  if (!context) throw new Error("You must wrap your app in a TuyauProvider");
+  return context;
+}
+
+// src/client/react/router.ts
+import { router as InertiaRouter } from "@inertiajs/react";
+function useRouter() {
+  const tuyau = useTuyau();
+  return {
+    /**
+     * Navigate to a route with type-safe parameters and options.
+     *
+     * Automatically resolves the route URL and HTTP method based on the
+     * route definition, then performs the navigation using Inertia's router.
+     *
+     * @param props - Route navigation parameters including route name and params
+     * @param options - Optional Inertia visit options for controlling navigation behavior
+     *
+     * @example
+     * ```tsx
+     * // Navigate to a simple route
+     * router.visit({ route: 'dashboard' })
+     *
+     * // Navigate with parameters
+     * router.visit({ route: 'user.edit', params: { id: userId } })
+     * ```
+     */
+    visit: (props, options) => {
+      const routeInfo = tuyau.getRoute(props.route, { params: props.params });
+      const url = routeInfo.url;
+      return InertiaRouter.visit(url, {
+        ...options,
+        method: routeInfo.methods[0].toLowerCase()
+      });
+    }
+  };
+}
+
+// src/client/react/link.tsx
+import React2 from "react";
+import { Link as InertiaLink } from "@inertiajs/react";
+function LinkInner(props, ref) {
+  const { route, params, ...linkProps } = props;
+  const tuyau = useTuyau();
+  const routeInfo = tuyau.getRoute(props.route, { params });
+  return /* @__PURE__ */ React2.createElement(
+    InertiaLink,
+    {
+      ...linkProps,
+      href: routeInfo.url,
+      method: routeInfo.methods[0].toLowerCase(),
+      ref
+    }
+  );
+}
+var Link = React2.forwardRef(LinkInner);
+export {
+  Link,
+  TuyauProvider,
+  useRouter,
+  useTuyau
+};

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

@@ -0,0 +1,64 @@
+import React from 'react';
+import type { UserRegistry } from '@tuyau/core/types';
+import { Link as InertiaLink } from '@inertiajs/react';
+import { AreAllOptional } from '@poppinss/utils/types';
+/**
+ * Get parameter tuple type for a route
+ */
+type ExtractParamsTuple<Route extends keyof UserRegistry> = UserRegistry[Route]['types']['paramsTuple'];
+/**
+ * Get parameter object type for a route
+ */
+type ExtractParamsObject<Route extends keyof UserRegistry> = UserRegistry[Route]['types']['params'];
+/**
+ * Get params format for a route
+ */
+type RouteParamsFormats<Route extends keyof UserRegistry> = ExtractParamsObject<Route> extends Record<string, never> ? never : ExtractParamsTuple<Route> | ExtractParamsObject<Route>;
+/**
+ * Parameters required for route navigation with proper type safety.
+ */
+export type LinkParams<Route extends keyof UserRegistry> = {
+    route: Route;
+} & (RouteParamsFormats<Route> extends never ? {
+    params?: never;
+} : AreAllOptional<ExtractParamsObject<Route>> extends true ? {
+    params?: RouteParamsFormats<Route>;
+} : {
+    params: RouteParamsFormats<Route>;
+});
+/**
+ * Props for the Link component extending InertiaLink props
+ * with route-specific type safety and parameter validation.
+ */
+type LinkProps<Route extends keyof UserRegistry> = Omit<React.ComponentPropsWithoutRef<typeof InertiaLink>, 'href' | 'method'> & LinkParams<Route>;
+/**
+ * Internal Link component implementation with forward ref support.
+ * Resolves route parameters and generates the appropriate URL and HTTP method
+ * for Inertia navigation.
+ *
+ * @param props - Link properties including route and parameters
+ * @param ref - Forward ref for the underlying InertiaLink component
+ */
+declare function LinkInner<Route extends keyof UserRegistry>(props: LinkProps<Route>, ref?: React.ForwardedRef<React.ElementRef<typeof InertiaLink>>): React.JSX.Element;
+/**
+ * Type-safe Link component for Inertia.js navigation.
+ *
+ * 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.
+ *
+ * @example
+ * ```tsx
+ * // Link to a route without parameters
+ * <Link route="home">Home</Link>
+ *
+ * // Link to a route with required parameters
+ * <Link route="user.show" params={{ id: 1 }}>
+ *   View User
+ * </Link>
+ * ```
+ */
+export declare const Link: <Route extends keyof UserRegistry>(props: LinkProps<Route> & {
+    ref?: React.Ref<React.ElementRef<typeof InertiaLink>>;
+}) => ReturnType<typeof LinkInner>;
+export {};

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

@@ -0,0 +1,33 @@
+import type { UserRegistry } from '@tuyau/core/types';
+import { router as InertiaRouter } from '@inertiajs/react';
+import type { LinkParams } from './link.tsx';
+/**
+ * Custom hook providing type-safe navigation utilities for Inertia.js.
+ *
+ * Returns an enhanced router object with type-safe navigation methods
+ * that automatically resolve route URLs and HTTP methods based on
+ * your application's route definitions.
+ *
+ * @returns Router object with type-safe navigation methods
+ */
+export declare function useRouter(): {
+    /**
+     * Navigate to a route with type-safe parameters and options.
+     *
+     * Automatically resolves the route URL and HTTP method based on the
+     * route definition, then performs the navigation using Inertia's router.
+     *
+     * @param props - Route navigation parameters including route name and params
+     * @param options - Optional Inertia visit options for controlling navigation behavior
+     *
+     * @example
+     * ```tsx
+     * // Navigate to a simple route
+     * router.visit({ route: 'dashboard' })
+     *
+     * // Navigate with parameters
+     * router.visit({ route: 'user.edit', params: { id: userId } })
+     * ```
+     */
+    visit: <Route extends keyof UserRegistry>(props: LinkParams<Route>, options?: Parameters<typeof InertiaRouter.visit>[1]) => any;
+};

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

@@ -21,6 +21,8 @@ export type InertiaPluginOptions = {
         output?: string;
     } | {
         enabled: false;
+        entrypoint?: string;
+        output?: string;
     };
 };
 /**
@@ -52,7 +54,7 @@ export type InertiaPluginOptions = {
  *     inertia({
  *       ssr: {
  *         enabled: true,
- *         entrypoint: 'inertia/app/ssr.ts',
+ *         entrypoint: 'inertia/ssr.tsx',
  *         output: 'build/ssr'
  *       }
  *     })

package/build/src/define_config.d.ts

@@ -6,6 +6,7 @@ import type { InertiaConfig, InertiaConfigInput } from './types.js';
  * to create a complete Inertia configuration object.
  *
  * @param config - User configuration input to override defaults
+ * @returns Complete Inertia configuration object with defaults applied
  *
  * @example
  * ```js

package/build/src/index_pages.d.ts

@@ -1,5 +1,32 @@
+/**
+ * Creates an AdonisJS assembler hook to automatically generate TypeScript definitions
+ * for Inertia.js pages based on the specified framework.
+ *
+ * This function scans page components in the 'inertia/pages' directory and generates
+ * type definitions that map page names to their component props.
+ *
+ * @param config - Configuration object specifying the frontend framework
+ * @param config.framework - The frontend framework ('vue3' or 'react')
+ * @returns Assembler hook object with run method for generating page types
+ *
+ * @example
+ * ```js
+ * // In your adonisrc.ts file
+ * export default defineConfig({
+ *   assembler: {
+ *     onBuildStarting: [indexPages({ framework: 'vue3' })]
+ *   }
+ * })
+ * ```
+ */
 export declare const indexPages: (config: {
     framework: "vue3" | "react";
 }) => {
+    /**
+     * Executes the page indexing process to generate TypeScript definitions.
+     *
+     * @param _ - Unused first parameter (assembler context)
+     * @param indexGenerator - The index generator instance used to register the pages type generation
+     */
     run(_: import("@adonisjs/assembler").DevServer | import("@adonisjs/assembler").TestRunner | import("@adonisjs/assembler").Bundler, indexGenerator: import("@adonisjs/assembler/index_generator").IndexGenerator): void;
 };

package/build/src/inertia.d.ts

@@ -1,8 +1,9 @@
 import { type Vite } from '@adonisjs/vite';
 import type { HttpContext } from '@adonisjs/core/http';
 import { type ServerRenderer } from './server_renderer.js';
-import type { PageProps, PageObject, AsPageProps, RequestInfo, InertiaConfig, ComponentProps } from './types.js';
+import type { PageProps, PageObject, AsPageProps, RequestInfo, InertiaConfig, ComponentProps, SharedProps } from './types.js';
 import { defer, merge, always, optional, deepMerge } from './props.ts';
+import { type AsyncOrSync } from '@poppinss/utils/types';
 /**
  * Main class used to interact with Inertia
  *
@@ -23,7 +24,7 @@ import { defer, merge, always, optional, deepMerge } from './props.ts';
  * inertia.location('/dashboard')
  * ```
  */
-export declare class Inertia<Pages extends Record<string, ComponentProps>> {
+export declare class Inertia<Pages> {
     #private;
     protected ctx: HttpContext;
     protected config: InertiaConfig;
@@ -104,6 +105,9 @@ export declare class Inertia<Pages extends Record<string, ComponentProps>> {
      *
      * Parses various Inertia headers to determine request type and props filtering.
      *
+     * @param reCompute - Whether to recompute the request info instead of using cached version
+     * @returns The request information object containing Inertia-specific data
+     *
      * @example
      * ```js
      * const info = inertia.requestInfo()
@@ -117,6 +121,8 @@ export declare class Inertia<Pages extends Record<string, ComponentProps>> {
      * Compute and cache the assets version
      *
      * Uses Vite manifest hash when available, otherwise defaults to '1'.
+     *
+     * @returns The computed version string for asset versioning
      */
     getVersion(): string;
     /**
@@ -125,6 +131,7 @@ export declare class Inertia<Pages extends Record<string, ComponentProps>> {
      * Checks global SSR settings and component-specific configuration.
      *
      * @param component - The component name to check
+     * @returns Promise resolving to true if SSR is enabled for the component
      *
      * @example
      * ```js
@@ -143,6 +150,7 @@ export declare class Inertia<Pages extends Record<string, ComponentProps>> {
      * in every page render alongside page-specific props.
      *
      * @param sharedState - Props to share across all pages
+     * @returns The Inertia instance for method chaining
      *
      * @example
      * ```js
@@ -158,7 +166,7 @@ export declare class Inertia<Pages extends Record<string, ComponentProps>> {
      *   .share({ permissions: userPermissions })
      * ```
      */
-    share(sharedState: PageProps): this;
+    share(sharedState: PageProps | (() => AsyncOrSync<PageProps>)): this;
     /**
      * Build a page object with processed props and metadata
      *
@@ -166,6 +174,7 @@ export declare class Inertia<Pages extends Record<string, ComponentProps>> {
      *
      * @param page - The page component name
      * @param pageProps - Props to pass to the page component
+     * @returns Promise resolving to the complete page object
      *
      * @example
      * ```js
@@ -175,7 +184,7 @@ export declare class Inertia<Pages extends Record<string, ComponentProps>> {
      * })
      * ```
      */
-    page<Page extends keyof Pages & string>(page: Page, pageProps: AsPageProps<Pages[Page]>): Promise<PageObject<Pages[Page]>>;
+    page<Page extends keyof Pages & string>(page: Page, pageProps: Pages[Page] extends ComponentProps ? AsPageProps<Omit<Pages[Page], keyof SharedProps>> : never): Promise<PageObject<Pages[Page]>>;
     /**
      * Render a page using Inertia
      *
@@ -187,8 +196,7 @@ export declare class Inertia<Pages extends Record<string, ComponentProps>> {
      * @param page - The page component name to render
      * @param pageProps - Props to pass to the page component
      * @param viewProps - Additional props to pass to the root view template
-     *
-     * @returns PageObject for Inertia requests, HTML string for initial page loads
+     * @returns Promise resolving to PageObject for Inertia requests, HTML string for initial page loads
      *
      * @example
      * ```js
@@ -202,7 +210,7 @@ export declare class Inertia<Pages extends Record<string, ComponentProps>> {
      * const html = await inertia.render('Home', { welcome: 'Hello World' })
      * ```
      */
-    render<Page extends keyof Pages & string>(page: Page, pageProps: AsPageProps<Pages[Page]>, viewProps?: Record<string, any>): Promise<string | PageObject<Pages[Page]>>;
+    render<Page extends keyof Pages & string>(page: Page, pageProps: Pages[Page] extends ComponentProps ? AsPageProps<Omit<Pages[Page], keyof SharedProps>> : never, viewProps?: Record<string, any>): Promise<string | PageObject<Pages[Page]>>;
     /**
      * Clear the browser history on the next navigation
      *

package/build/src/inertia_manager.d.ts

@@ -35,6 +35,7 @@ export declare class InertiaManager {
      * Creates a new Inertia instance for a specific HTTP request
      *
      * @param ctx - HTTP context for the current request
+     * @returns A new Inertia instance configured for the given request
      *
      * @example
      * ```js

package/build/src/inertia_middleware.d.ts

@@ -1,9 +1,9 @@
 import type { HttpContext } from '@adonisjs/core/http';
 import { type Inertia } from './inertia.js';
-import type { ComponentProps, InertiaPages, PageProps } from './types.js';
+import type { InertiaPages, PageProps } from './types.js';
 declare module '@adonisjs/core/http' {
     interface HttpContext {
-        inertia: Inertia<InertiaPages extends Record<string, ComponentProps> ? InertiaPages : never>;
+        inertia: Inertia<InertiaPages>;
     }
 }
 /**
@@ -51,8 +51,11 @@ export default abstract class BaseInertiaMiddleware {
      * This method should return an object containing data that will be
      * available to all Inertia pages as props.
      *
+     * @param ctx - The HTTP context object
+     * @returns Props to share across all pages
+     *
      * @example
-     * ```ts
+     * ```js
      * async share() {
      *   return {
      *     user: ctx.auth?.user,

package/build/src/inertia_middleware.js

@@ -1,12 +1,12 @@
 import {
   InertiaManager
-} from "../chunk-74S2VAL7.js";
-import {
-  InertiaHeaders
-} from "../chunk-DISC5OYC.js";
+} from "../chunk-YQ72YL64.js";
 import {
   debug_default
 } from "../chunk-4EZ2J6OA.js";
+import {
+  InertiaHeaders
+} from "../chunk-DISC5OYC.js";
 import "../chunk-MLKGABMK.js";
 
 // src/inertia_middleware.ts
@@ -33,7 +33,7 @@ var BaseInertiaMiddleware = class {
     if (!ctx.session) {
       return {};
     }
-    const inputErrors = ctx.session.flashMessages.get("inputErrorsBag");
+    const inputErrors = ctx.session.flashMessages.get("inputErrorsBag", {});
     const errors = Object.entries(inputErrors).reduce(
       (result, [field, messages]) => {
         result[field] = Array.isArray(messages) ? messages[0] : messages;
@@ -65,7 +65,7 @@ var BaseInertiaMiddleware = class {
     const inertiaContainer = await ctx.containerResolver.make(InertiaManager);
     ctx.inertia = inertiaContainer.createForRequest(ctx);
     if (this.share) {
-      ctx.inertia.share(await this.share(ctx));
+      ctx.inertia.share(() => this.share(ctx));
     }
   }
   /**

package/build/src/props.d.ts

@@ -1,5 +1,6 @@
-import { type AsyncOrSync } from '@poppinss/utils/types';
+import { type AsyncOrSync } from '@adonisjs/core/types/common';
 import { type DeferProp, type PageProps, type AlwaysProp, type OptionalProp, type MergeableProp, type ComponentProps, type UnPackedPageProps } from './types.ts';
+import { type ContainerResolver } from '@adonisjs/core/container';
 /**
  * Creates a deferred prop that is never included in standard visits but must be shared with
  * the client during standard visits. Can be explicitly requested and supports merging.
@@ -138,9 +139,10 @@ export declare function deepMerge<T extends UnPackedPageProps | DeferProp<UnPack
  * This function is useful for runtime type checking and conditional prop handling.
  *
  * @param propValue - The object to check for deferred prop characteristics
+ * @returns True if the prop value is a deferred prop
  *
  * @example
- * ```javascript
+ * ```js
  * const prop = defer(() => ({ data: 'value' }))
  *
  * if (isDeferredProp(prop)) {
@@ -157,9 +159,10 @@ export declare function isDeferredProp<T extends UnPackedPageProps>(propValue: O
  * existing props rather than replaced during updates.
  *
  * @param propValue - The object to check for mergeable prop characteristics
+ * @returns True if the prop value is a mergeable prop
  *
  * @example
- * ```javascript
+ * ```js
  * const prop = merge({ items: [1, 2, 3] })
  *
  * if (isMergeableProp(prop)) {
@@ -176,9 +179,10 @@ export declare function isMergeableProp<T extends UnPackedPageProps | DeferProp<
  * responses, regardless of cherry-picking or selective prop requests.
  *
  * @param propValue - The object to check for always prop characteristics
+ * @returns True if the prop value is an always prop
  *
  * @example
- * ```javascript
+ * ```js
  * const prop = always({ userId: 123, permissions: ['read', 'write'] })
  *
  * if (isAlwaysProp(prop)) {
@@ -195,9 +199,10 @@ export declare function isAlwaysProp<T extends UnPackedPageProps>(propValue: Obj
  * when explicitly requested by the client, never in standard visits.
  *
  * @param propValue - The object to check for optional prop characteristics
+ * @returns True if the prop value is an optional prop
  *
  * @example
- * ```javascript
+ * ```js
  * const prop = optional(() => ({ detailedData: 'expensive computation' }))
  *
  * if (isOptionalProp(prop)) {
@@ -218,7 +223,8 @@ export declare function isOptionalProp<T extends UnPackedPageProps>(propValue: O
  * - Regular props: Included normally
  *
  * @param pageProps - The page props to process
- * @returns Object containing processed props, deferred props list, and merge props list
+ * @param containerResolver - Container resolver for dependency injection
+ * @returns Promise resolving to object containing processed props, deferred props list, and merge props list
  *
  * @example
  * ```js
@@ -230,7 +236,7 @@ export declare function isOptionalProp<T extends UnPackedPageProps>(propValue: O
  * // Returns: { props: { user: {...} }, deferredProps: { default: ['posts'] }, mergeProps: ['settings'] }
  * ```
  */
-export declare function buildStandardVisitProps(pageProps: PageProps): Promise<{
+export declare function buildStandardVisitProps(pageProps: PageProps, containerResolver: ContainerResolver<any>): Promise<{
     props: ComponentProps;
     mergeProps: string[];
     deepMergeProps: string[];
@@ -250,7 +256,8 @@ export declare function buildStandardVisitProps(pageProps: PageProps): Promise<{
  *
  * @param pageProps - The page props to process
  * @param cherryPickProps - Array of prop names to include
- * @returns Object containing processed props and merge props list
+ * @param containerResolver - Container resolver for dependency injection
+ * @returns Promise resolving to object containing processed props and merge props list
  *
  * @example
  * ```js
@@ -261,7 +268,7 @@ export declare function buildStandardVisitProps(pageProps: PageProps): Promise<{
  * // Returns: { props: { posts: [...], stats: [...] }, mergeProps: [], deferredProps: {} }
  * ```
  */
-export declare function buildPartialRequestProps(pageProps: PageProps, cherryPickProps: string[]): Promise<{
+export declare function buildPartialRequestProps(pageProps: PageProps, cherryPickProps: string[], containerResolver: ContainerResolver<any>): Promise<{
     props: ComponentProps;
     mergeProps: string[];
     deepMergeProps: string[];

package/build/src/server_renderer.d.ts

@@ -36,7 +36,7 @@ export declare class ServerRenderer {
      * @returns Promise resolving to an object with rendered head and body HTML
      *
      * @example
-     * ```typescript
+     * ```js
      * const pageObject = {
      *   component: 'Home',
      *   props: { user: { name: 'John' } },
@@ -47,7 +47,7 @@ export declare class ServerRenderer {
      * const { head, body } = await renderer.render(pageObject)
      * ```
      */
-    render(pageObject: PageObject): Promise<{
+    render(pageObject: PageObject<any>): Promise<{
         head: string[];
         body: string;
     }>;

package/build/src/types.d.ts

@@ -1,7 +1,7 @@
 import type { HttpContext } from '@adonisjs/core/http';
 import { type ContainerResolver } from '@adonisjs/core/container';
 import type { JSONDataTypes } from '@adonisjs/core/types/transformers';
-import type { AsyncOrSync, DeepPartial, Prettify } from '@poppinss/utils/types';
+import type { AsyncOrSync, DeepPartial, Prettify } from '@adonisjs/core/types/common';
 import { type DEEP_MERGE, type ALWAYS_PROP, type OPTIONAL_PROP, type TO_BE_MERGED, type DEFERRED_PROP } from './symbols.ts';
 /**
  * Representation of a resource item, collection and paginator that can be serialized
@@ -242,10 +242,6 @@ export type InertiaConfig = {
      * application
      */
     rootView: string | ((ctx: HttpContext) => string);
-    /**
-     * The entrypoint file to load in order to boot the frontend application.
-     */
-    entrypoint: string;
     /**
      * A fixed asset version value to use. Otherwise, it will be read from the
      * Vite manifest file.
@@ -290,7 +286,7 @@ export type InertiaConfigInput = DeepPartial<InertiaConfig>;
  *
  * @template Props - The props type for the page component
  */
-export type PageObject<Props extends PageProps = PageProps> = {
+export type PageObject<Props> = {
     /**
      * The name/path of the component to render
      */
@@ -373,7 +369,7 @@ export interface InertiaPages {
  * @param page - The page object containing component and props data
  * @returns Promise resolving to an object with head tags and body HTML
  */
-export type RenderInertiaSsrApp = (page: PageObject) => Promise<{
+export type RenderInertiaSsrApp = (page: PageObject<any>) => Promise<{
     head: string[];
     body: string;
 }>;

package/build/tests/types/react.spec.d.ts

@@ -0,0 +1,65 @@
+declare const routes: {
+    readonly 'users.index': {
+        readonly methods: ["GET", "HEAD"];
+        readonly pattern: "/";
+        readonly tokens: [{
+            readonly old: "/";
+            readonly type: 0;
+            readonly val: "/";
+            readonly end: "";
+        }];
+        readonly types: {
+            body: {};
+            paramsTuple: [];
+            params: {};
+            query: {};
+            response: unknown;
+        };
+    };
+    readonly 'users.comments.edit': {
+        readonly methods: ["GET", "HEAD"];
+        readonly pattern: "/users/:id/comments/:comment_id/edit";
+        readonly tokens: [{
+            readonly old: "/users";
+            readonly type: 0;
+            readonly val: "users";
+            readonly end: "/";
+        }, {
+            readonly old: ":id";
+            readonly type: 1;
+            readonly val: "id";
+            readonly end: "/";
+        }, {
+            readonly old: "/comments";
+            readonly type: 0;
+            readonly val: "comments";
+            readonly end: "/";
+        }, {
+            readonly old: ":comment_id";
+            readonly type: 1;
+            readonly val: "comment_id";
+            readonly end: "/edit";
+        }, {
+            readonly old: "/edit";
+            readonly type: 0;
+            readonly val: "edit";
+            readonly end: "";
+        }];
+        readonly types: {
+            body: {};
+            paramsTuple: [string, string];
+            params: {
+                id: string;
+                comment_id: string;
+            };
+            query: {};
+            response: unknown;
+        };
+    };
+};
+declare module '@tuyau/core/types' {
+    type Registry = typeof routes;
+    interface UserRegistry extends Registry {
+    }
+}
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adonisjs/inertia",
   "description": "Official Inertia.js adapter for AdonisJS",
-  "version": "4.0.0-next.1",
+  "version": "4.0.0-next.10",
   "engines": {
     "node": ">=24.0.0"
   },
@@ -18,6 +18,8 @@
     "./plugins/edge": "./build/src/plugins/edge/plugin.js",
     "./plugins/api_client": "./build/src/plugins/japa/api_client.js",
     "./vite": "./build/src/client/vite.js",
+    "./helpers": "./build/src/client/helpers.js",
+    "./react": "./build/src/client/react/index.js",
     "./factories": "./build/factories/main.js"
   },
   "scripts": {
@@ -41,13 +43,14 @@
     "docs": "typedoc"
   },
   "devDependencies": {
-    "@adonisjs/assembler": "^8.0.0-next.9",
-    "@adonisjs/core": "^7.0.0-next.1",
-    "@adonisjs/eslint-config": "^3.0.0-next.1",
+    "@adonisjs/assembler": "^8.0.0-next.14",
+    "@adonisjs/core": "^7.0.0-next.10",
+    "@adonisjs/eslint-config": "^3.0.0-next.4",
     "@adonisjs/prettier-config": "^1.4.5",
     "@adonisjs/session": "^8.0.0-next.0",
-    "@adonisjs/tsconfig": "^2.0.0-next.0",
-    "@adonisjs/vite": "^5.0.1-next.0",
+    "@adonisjs/tsconfig": "^2.0.0-next.3",
+    "@adonisjs/vite": "^5.1.0-next.0",
+    "@inertiajs/react": "^2.2.15",
     "@japa/api-client": "^3.1.0",
     "@japa/assert": "4.1.1",
     "@japa/expect-type": "^2.0.3",
@@ -57,21 +60,24 @@
     "@japa/snapshot": "^2.0.9",
     "@poppinss/ts-exec": "^1.4.1",
     "@release-it/conventional-changelog": "^10.0.1",
-    "@types/node": "^24.3.1",
+    "@tuyau/core": "^1.0.0-beta.1",
+    "@types/node": "^24.8.1",
+    "@types/react": "^19.2.2",
     "@types/supertest": "^6.0.3",
     "c8": "^10.1.3",
     "copyfiles": "^2.4.1",
-    "cross-env": "^10.0.0",
-    "del-cli": "^6.0.0",
+    "cross-env": "^10.1.0",
+    "del-cli": "^7.0.0",
     "edge.js": "^6.3.0",
-    "eslint": "^9.35.0",
+    "eslint": "^9.38.0",
     "get-port": "^7.1.0",
     "prettier": "^3.6.2",
-    "release-it": "^19.0.4",
+    "react": "^19.2.0",
+    "release-it": "^19.0.5",
     "supertest": "^7.1.4",
     "tsup": "^8.5.0",
-    "typescript": "~5.9.2",
-    "vite": "^7.1.5"
+    "typescript": "~5.9.3",
+    "vite": "^7.1.10"
   },
   "dependencies": {
     "@poppinss/utils": "^7.0.0-next.3",
@@ -79,13 +85,16 @@
     "html-entities": "^2.6.0"
   },
   "peerDependencies": {
-    "@adonisjs/assembler": "^8.0.0-next.7",
-    "@adonisjs/core": "^7.0.0-next.0",
+    "@adonisjs/assembler": "^8.0.0-next.14",
+    "@adonisjs/core": "^7.0.0-next.10",
     "@adonisjs/session": "^8.0.0-next.0",
-    "@adonisjs/vite": "^5.0.1-next.0",
+    "@adonisjs/vite": "^5.1.0-next.0",
+    "@inertiajs/react": "^2.2.15",
     "@japa/api-client": "^3.1.0",
     "@japa/plugin-adonisjs": "^5.0.0-next.0",
-    "edge.js": "^6.0.0"
+    "@tuyau/core": "^1.0.0-beta.1",
+    "edge.js": "^6.0.0",
+    "react": "^19.2.0"
   },
   "peerDependenciesMeta": {
     "@adonisjs/assembler": {
@@ -96,6 +105,15 @@
     },
     "@japa/plugin-adonisjs": {
       "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "@tuyau/core": {
+      "optional": true
+    },
+    "@inertiajs/react": {
+      "optional": true
     }
   },
   "keywords": [
@@ -132,8 +150,7 @@
     },
     "npm": {
       "publish": true,
-      "skipChecks": true,
-      "tag": "latest"
+      "skipChecks": true
     },
     "plugins": {
       "@release-it/conventional-changelog": {
@@ -148,11 +165,13 @@
       "./index.ts",
       "./src/types.ts",
       "./src/client/vite.ts",
+      "./src/client/helpers.ts",
       "./factories/main.ts",
       "./src/inertia_middleware.ts",
       "./providers/inertia_provider.ts",
       "./src/plugins/edge/plugin.ts",
-      "./src/plugins/japa/api_client.ts"
+      "./src/plugins/japa/api_client.ts",
+      "./src/client/react/index.tsx"
     ],
     "outDir": "./build",
     "clean": true,