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

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/client/vite.js

@@ -1,31 +1,18 @@
-import "../../chunk-MLKGABMK.js";
-
-// src/client/vite.ts
 function inertia(options) {
-  return {
-    name: "vite-plugin-inertia",
-    config: (_, { command }) => {
-      if (command === "build") {
-        process.env.NODE_ENV = "production";
-      }
-      return {
-        builder: {},
-        build: { outDir: "build/public/assets" },
-        environments: {
-          ...options?.ssr?.enabled && {
-            ssr: {
-              build: {
-                ssr: true,
-                outDir: options.ssr.output || "build/ssr",
-                rollupOptions: { input: options.ssr.entrypoint }
-              }
-            }
-          }
-        }
-      };
-    }
-  };
+	return {
+		name: "vite-plugin-inertia",
+		config: (_, { command }) => {
+			if (command === "build") process.env.NODE_ENV = "production";
+			return {
+				builder: {},
+				build: { outDir: "build/public/assets" },
+				environments: { ...options?.ssr?.enabled && { ssr: { build: {
+					ssr: true,
+					outDir: options.ssr.output || "build/ssr",
+					rollupOptions: { input: options.ssr.entrypoint }
+				} } } }
+			};
+		}
+	};
 }
-export {
-  inertia as default
-};
+export { inertia as default };

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,113 +1,47 @@
-import {
-  InertiaManager
-} from "../chunk-74S2VAL7.js";
-import {
-  InertiaHeaders
-} from "../chunk-DISC5OYC.js";
-import {
-  debug_default
-} from "../chunk-4EZ2J6OA.js";
-import "../chunk-MLKGABMK.js";
-
-// src/inertia_middleware.ts
-var MUTATION_METHODS = ["PUT", "PATCH", "DELETE"];
+import { t as InertiaManager } from "../inertia_manager-Di3J3hSG.js";
+import { t as InertiaHeaders } from "../headers-DafWEpBh.js";
+import { t as debug_default } from "../debug-CBMTuPUm.js";
+const MUTATION_METHODS = [
+	"PUT",
+	"PATCH",
+	"DELETE"
+];
 var BaseInertiaMiddleware = class {
-  /**
-   * Extract validation errors from the session and format them for Inertia
-   *
-   * Retrieves validation errors from the session flash messages and formats
-   * them according to Inertia's error bag conventions. Supports both simple
-   * error objects and error bags for multi-form scenarios.
-   *
-   * @param ctx - The HTTP context containing session data
-   * @returns Formatted validation errors, either as a simple object or error bags
-   *
-   * @example
-   * ```js
-   * const errors = middleware.getValidationErrors(ctx)
-   * // Returns: { email: 'Email is required', password: 'Password too short' }
-   * // Or with error bags: { login: { email: 'Email is required' } }
-   * ```
-   */
-  getValidationErrors(ctx) {
-    if (!ctx.session) {
-      return {};
-    }
-    const inputErrors = ctx.session.flashMessages.get("inputErrorsBag");
-    const errors = Object.entries(inputErrors).reduce(
-      (result, [field, messages]) => {
-        result[field] = Array.isArray(messages) ? messages[0] : messages;
-        return result;
-      },
-      {}
-    );
-    const errorBag = ctx.request.header(InertiaHeaders.ErrorBag);
-    if (errorBag) {
-      return { [errorBag]: errors };
-    }
-    return errors;
-  }
-  /**
-   * Initialize the Inertia instance for the current request
-   *
-   * This method creates an Inertia instance and attaches it to the
-   * HTTP context, making it available throughout the request lifecycle.
-   *
-   * @param ctx - The HTTP context object
-   *
-   * @example
-   * ```ts
-   * await middleware.init(ctx)
-   * ```
-   */
-  async init(ctx) {
-    debug_default("initiating inertia");
-    const inertiaContainer = await ctx.containerResolver.make(InertiaManager);
-    ctx.inertia = inertiaContainer.createForRequest(ctx);
-    if (this.share) {
-      ctx.inertia.share(await this.share(ctx));
-    }
-  }
-  /**
-   * Clean up and finalize the Inertia response
-   *
-   * This method handles the final processing of Inertia requests including:
-   * - Setting appropriate response headers
-   * - Handling redirects for mutation methods (PUT/PATCH/DELETE)
-   * - Managing asset versioning conflicts
-   *
-   * @param ctx - The HTTP context object
-   *
-   * @example
-   * ```ts
-   * await middleware.dispose(ctx)
-   * ```
-   */
-  dispose(ctx) {
-    const requestInfo = ctx.inertia.requestInfo();
-    if (!requestInfo.isInertiaRequest) {
-      return;
-    }
-    debug_default("disposing as inertia request");
-    ctx.response.header("Vary", InertiaHeaders.Inertia);
-    const method = ctx.request.method();
-    if (ctx.response.getStatus() === 302 && MUTATION_METHODS.includes(method)) {
-      debug_default("upgrading response status from 302 to 303");
-      ctx.response.status(303);
-    }
-    const version = ctx.inertia.getVersion();
-    const clientVersion = requestInfo.version ?? "";
-    if (method === "GET" && clientVersion !== version) {
-      debug_default("version mis-match. Reloading page");
-      if (ctx.session) {
-        ctx.session.reflash();
-      }
-      ctx.response.removeHeader(InertiaHeaders.Inertia);
-      ctx.response.header(InertiaHeaders.Location, ctx.request.url(true));
-      ctx.response.status(409);
-    }
-  }
-};
-export {
-  BaseInertiaMiddleware as default
+	getValidationErrors(ctx) {
+		if (!ctx.session) return {};
+		const inputErrors = ctx.session.flashMessages.get("inputErrorsBag", {});
+		const errors = Object.entries(inputErrors).reduce((result, [field, messages]) => {
+			result[field] = Array.isArray(messages) ? messages[0] : messages;
+			return result;
+		}, {});
+		const errorBag = ctx.request.header(InertiaHeaders.ErrorBag);
+		if (errorBag) return { [errorBag]: errors };
+		return errors;
+	}
+	async init(ctx) {
+		debug_default("initiating inertia");
+		ctx.inertia = (await ctx.containerResolver.make(InertiaManager)).createForRequest(ctx);
+		if (this.share) ctx.inertia.share(() => this.share(ctx));
+	}
+	dispose(ctx) {
+		const requestInfo = ctx.inertia.requestInfo();
+		if (!requestInfo.isInertiaRequest) return;
+		debug_default("disposing as inertia request");
+		ctx.response.header("Vary", InertiaHeaders.Inertia);
+		const method = ctx.request.method();
+		if (ctx.response.getStatus() === 302 && MUTATION_METHODS.includes(method)) {
+			debug_default("upgrading response status from 302 to 303");
+			ctx.response.status(303);
+		}
+		const version = ctx.inertia.getVersion();
+		const clientVersion = requestInfo.version ?? "";
+		if (method === "GET" && clientVersion !== version) {
+			debug_default("version mis-match. Reloading page");
+			if (ctx.session) ctx.session.reflash();
+			ctx.response.removeHeader(InertiaHeaders.Inertia);
+			ctx.response.header(InertiaHeaders.Location, ctx.request.url(true));
+			ctx.response.status(409);
+		}
+	}
 };
+export { BaseInertiaMiddleware as default };

package/build/src/plugins/edge/plugin.js

@@ -1,88 +1,56 @@
-import {
-  debug_default
-} from "../../../chunk-4EZ2J6OA.js";
-import "../../../chunk-MLKGABMK.js";
-
-// src/plugins/edge/plugin.ts
+import { t as debug_default } from "../../../debug-CBMTuPUm.js";
 import { encode } from "html-entities";
-
-// src/plugins/edge/tags.ts
 import { EdgeError } from "edge-error";
-
-// src/plugins/edge/utils.ts
 function isSubsetOf(expression, expressions, errorCallback) {
-  if (!expressions.includes(expression.type)) {
-    errorCallback();
-  }
+	if (!expressions.includes(expression.type)) errorCallback();
 }
-
-// src/plugins/edge/tags.ts
-var inertiaTag = {
-  block: false,
-  tagName: "inertia",
-  seekable: true,
-  compile(parser, buffer, { filename, loc, properties }) {
-    if (properties.jsArg.trim() === "") {
-      buffer.writeExpression(`out += state.inertia(state.page)`, filename, loc.start.line);
-      return;
-    }
-    properties.jsArg = `(${properties.jsArg})`;
-    const parsed = parser.utils.transformAst(
-      parser.utils.generateAST(properties.jsArg, loc, filename),
-      filename,
-      parser
-    );
-    isSubsetOf(parsed, ["ObjectExpression"], () => {
-      const { line, col } = parser.utils.getExpressionLoc(parsed);
-      throw new EdgeError(
-        `"${properties.jsArg}" is not a valid argument for @inertia`,
-        "E_UNALLOWED_EXPRESSION",
-        { line, col, filename }
-      );
-    });
-    const attributes = parser.utils.stringify(parsed);
-    buffer.outputExpression(
-      `state.inertia(state.page, ${attributes})`,
-      filename,
-      loc.start.line,
-      false
-    );
-  }
+const inertiaTag = {
+	block: false,
+	tagName: "inertia",
+	seekable: true,
+	compile(parser, buffer, { filename, loc, properties }) {
+		if (properties.jsArg.trim() === "") {
+			buffer.writeExpression(`out += state.inertia(state.page)`, filename, loc.start.line);
+			return;
+		}
+		properties.jsArg = `(${properties.jsArg})`;
+		const parsed = parser.utils.transformAst(parser.utils.generateAST(properties.jsArg, loc, filename), filename, parser);
+		isSubsetOf(parsed, ["ObjectExpression"], () => {
+			const { line, col } = parser.utils.getExpressionLoc(parsed);
+			throw new EdgeError(`"${properties.jsArg}" is not a valid argument for @inertia`, "E_UNALLOWED_EXPRESSION", {
+				line,
+				col,
+				filename
+			});
+		});
+		const attributes = parser.utils.stringify(parsed);
+		buffer.outputExpression(`state.inertia(state.page, ${attributes})`, filename, loc.start.line, false);
+	}
 };
-var inertiaHeadTag = {
-  block: false,
-  tagName: "inertiaHead",
-  seekable: false,
-  compile(_, buffer, { filename, loc }) {
-    buffer.outputExpression("state.inertiaHead(state.page)", filename, loc.start.line, false);
-  }
+const inertiaHeadTag = {
+	block: false,
+	tagName: "inertiaHead",
+	seekable: false,
+	compile(_, buffer, { filename, loc }) {
+		buffer.outputExpression("state.inertiaHead(state.page)", filename, loc.start.line, false);
+	}
 };
-
-// src/plugins/edge/plugin.ts
-var edgePluginInertia = () => {
-  return (edge) => {
-    debug_default("sharing globals and inertia tags with edge");
-    edge.global(
-      "inertia",
-      (page = {}, attributes = {}) => {
-        if (page.ssrBody) {
-          return page.ssrBody;
-        }
-        const className = attributes?.class ? ` class="${attributes.class}"` : "";
-        const id = attributes?.id ? ` id="${attributes.id}"` : ' id="app"';
-        const tag = attributes?.as || "div";
-        const dataPage = encode(JSON.stringify(page));
-        return `<${tag}${id}${className} data-page="${dataPage}"></${tag}>`;
-      }
-    );
-    edge.global("inertiaHead", (page) => {
-      const { ssrHead = [] } = page || {};
-      return ssrHead.join("\n");
-    });
-    edge.registerTag(inertiaHeadTag);
-    edge.registerTag(inertiaTag);
-  };
-};
-export {
-  edgePluginInertia
+const edgePluginInertia = () => {
+	return (edge) => {
+		debug_default("sharing globals and inertia tags with edge");
+		edge.global("inertia", (page = {}, attributes = {}) => {
+			if (page.ssrBody) return page.ssrBody;
+			const className = attributes?.class ? ` class="${attributes.class}"` : "";
+			const id = attributes?.id ? ` id="${attributes.id}"` : " id=\"app\"";
+			const tag = attributes?.as || "div";
+			return `<${tag}${id}${className} data-page="${encode(JSON.stringify(page))}"></${tag}>`;
+		});
+		edge.global("inertiaHead", (page) => {
+			const { ssrHead = [] } = page || {};
+			return ssrHead.join("\n");
+		});
+		edge.registerTag(inertiaHeadTag);
+		edge.registerTag(inertiaTag);
+	};
 };
+export { edgePluginInertia };