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

package/build/src/index_pages.d.ts

@@ -0,0 +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

@@ -0,0 +1,261 @@
+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, 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
+ *
+ * Provides a complete interface for handling Inertia.js requests, rendering pages,
+ * managing props, and controlling page navigation behavior.
+ *
+ * @example
+ * ```js
+ * const inertia = new Inertia(ctx, config, vite, serverRenderer)
+ *
+ * // Render a page
+ * const result = await inertia.render('Home', { user: { name: 'John' } })
+ *
+ * // Clear browser history
+ * inertia.clearHistory()
+ *
+ * // Redirect to a different location
+ * inertia.location('/dashboard')
+ * ```
+ */
+export declare class Inertia<Pages> {
+    #private;
+    protected ctx: HttpContext;
+    protected config: InertiaConfig;
+    /**
+     * Defer prop evaluation until client-side rendering
+     *
+     * @example
+     * ```js
+     * {
+     *   expensiveData: inertia.defer(() => computeExpensiveData())
+     * }
+     * ```
+     */
+    defer: typeof defer;
+    /**
+     * Always include prop in both server and client renders
+     *
+     * @example
+     * ```js
+     * {
+     *   currentUser: inertia.always(() => getCurrentUser())
+     * }
+     * ```
+     */
+    always: typeof always;
+    /**
+     * Merge prop with existing client-side data
+     *
+     * @example
+     * ```js
+     * {
+     *   posts: inertia.merge(() => getPosts())
+     * }
+     * ```
+     */
+    merge: typeof merge;
+    /**
+     * Include prop only when specifically requested
+     *
+     * @example
+     * ```js
+     * {
+     *   optionalData: inertia.optional(() => getOptionalData())
+     * }
+     * ```
+     */
+    optional: typeof optional;
+    /**
+     * Deep merge prop with existing client-side data
+     *
+     * @example
+     * ```js
+     * {
+     *   settings: inertia.deepMerge(() => getSettings())
+     * }
+     * ```
+     */
+    deepMerge: typeof deepMerge;
+    /**
+     * Creates a new Inertia instance
+     *
+     * @param ctx - HTTP context for the current request
+     * @param config - Inertia configuration object
+     * @param vite - Vite instance for asset management
+     * @param serverRenderer - Optional server renderer for SSR
+     *
+     * @example
+     * ```js
+     * const inertia = new Inertia(ctx, {
+     *   rootView: 'app',
+     *   ssr: { enabled: true }
+     * }, vite, serverRenderer)
+     * ```
+     */
+    constructor(ctx: HttpContext, config: InertiaConfig, vite?: Vite, serverRenderer?: ServerRenderer);
+    /**
+     * Extract Inertia-specific information from request headers
+     *
+     * 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()
+     * if (info.isInertiaRequest) {
+     *   // Handle as Inertia request
+     * }
+     * ```
+     */
+    requestInfo(reCompute?: boolean): RequestInfo;
+    /**
+     * 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;
+    /**
+     * Determine if server-side rendering is enabled for a specific component
+     *
+     * 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
+     * const shouldSSR = await inertia.ssrEnabled('UserProfile')
+     * if (shouldSSR) {
+     *   // Render on server
+     * }
+     * ```
+     */
+    ssrEnabled<Page extends keyof Pages & string>(component: Page): Promise<boolean>;
+    /**
+     * Share props across all pages
+     *
+     * Merges the provided props with existing shared state, making them available
+     * to all pages rendered by this Inertia instance. Shared props are included
+     * 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
+     * // Share user data across all pages
+     * inertia.share({
+     *   user: getCurrentUser(),
+     *   flash: getFlashMessages()
+     * })
+     *
+     * // Chain multiple shares
+     * inertia
+     *   .share({ currentUser: user })
+     *   .share({ permissions: userPermissions })
+     * ```
+     */
+    share(sharedState: PageProps | (() => AsyncOrSync<PageProps>)): this;
+    /**
+     * Build a page object with processed props and metadata
+     *
+     * Creates the complete page object that will be sent to the client or used for SSR.
+     *
+     * @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
+     * const pageObject = await inertia.page('Dashboard', {
+     *   user: { name: 'John' },
+     *   posts: defer(() => getPosts())
+     * })
+     * ```
+     */
+    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
+     *
+     * This method handles three distinct rendering scenarios:
+     * 1. Inertia requests - Returns JSON page object for client-side navigation
+     * 2. Initial page loads with SSR - Returns HTML with server-rendered content
+     * 3. Initial page loads without SSR - Returns HTML for client-side hydration
+     *
+     * @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 Promise resolving to PageObject for Inertia requests, HTML string for initial page loads
+     *
+     * @example
+     * ```js
+     * // For Inertia requests, returns PageObject
+     * const result = await inertia.render('Profile', {
+     *   user: getCurrentUser(),
+     *   posts: defer(() => getUserPosts())
+     * })
+     *
+     * // For initial page loads, returns HTML string
+     * const html = await inertia.render('Home', { welcome: 'Hello World' })
+     * ```
+     */
+    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
+     *
+     * Instructs the client to clear the browser history stack when navigating.
+     *
+     * @example
+     * ```js
+     * inertia.clearHistory()
+     * return inertia.render('Dashboard', props)
+     * ```
+     */
+    clearHistory(): void;
+    /**
+     * Control whether browser history should be encrypted
+     *
+     * Enables or disables encryption of sensitive data in browser history.
+     *
+     * @param encrypt - Whether to encrypt history (defaults to true)
+     *
+     * @example
+     * ```js
+     * // Enable encryption for sensitive pages
+     * inertia.encryptHistory(true)
+     *
+     * // Disable encryption for public pages
+     * inertia.encryptHistory(false)
+     * ```
+     */
+    encryptHistory(encrypt?: boolean): void;
+    /**
+     * Redirect to a different location
+     *
+     * Sets the appropriate headers to redirect the client to a new URL.
+     * Uses a 409 status code which Inertia.js interprets as a redirect instruction.
+     *
+     * @param url - The URL to redirect to
+     *
+     * @example
+     * ```js
+     * // Redirect after login
+     * inertia.location('/dashboard')
+     *
+     * // Redirect with full URL
+     * inertia.location('https://example.com/external')
+     * ```
+     */
+    location(url: string): void;
+}

package/build/src/inertia_manager.d.ts

@@ -0,0 +1,47 @@
+import { type Vite } from '@adonisjs/vite';
+import { type HttpContext } from '@adonisjs/core/http';
+import { Inertia } from './inertia.ts';
+import { type ComponentProps, type InertiaConfig } from './types.ts';
+/**
+ * Manager class for managing Inertia instances
+ *
+ * Acts as a factory for creating Inertia instances with shared configuration
+ * and Vite integration.
+ *
+ * @example
+ * ```js
+ * const manager = new InertiaManager(config, vite)
+ * const inertia = manager.createForRequest(ctx)
+ * ```
+ */
+export declare class InertiaManager {
+    #private;
+    /**
+     * Creates a new InertiaManager instance
+     *
+     * @param config - Inertia configuration object
+     * @param vite - Optional Vite instance for development mode and SSR
+     *
+     * @example
+     * ```js
+     * const manager = new InertiaManager({
+     *   rootView: 'app',
+     *   ssr: { enabled: true }
+     * }, vite)
+     * ```
+     */
+    constructor(config: InertiaConfig, vite?: Vite);
+    /**
+     * 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
+     * const inertia = manager.createForRequest(ctx)
+     * await inertia.render('Home', { user: ctx.auth.user })
+     * ```
+     */
+    createForRequest<Pages extends Record<string, ComponentProps>>(ctx: HttpContext): Inertia<Pages>;
+}

package/build/src/inertia_middleware.d.ts

@@ -1,108 +1,98 @@
-import { Vite } from '@adonisjs/vite';
-import { HttpContext } from '@adonisjs/core/http';
-import { NextFn } from '@adonisjs/core/types/http';
-import { R as ResolvedConfig, D as Data, P as PageObject, M as MaybePromise, O as OptionalProp, a as MergeProp, A as AlwaysProp, b as DeferProp } from '../types-DVqEHBD1.js';
-import '@adonisjs/core/types';
-import '@tuyau/utils/types';
-
+import type { HttpContext } from '@adonisjs/core/http';
+import { type Inertia } from './inertia.js';
+import type { InertiaPages, PageProps } from './types.js';
+declare module '@adonisjs/core/http' {
+    interface HttpContext {
+        inertia: Inertia<InertiaPages>;
+    }
+}
 /**
- * Main class used to interact with Inertia
+ * Base middleware class for handling Inertia.js requests
+ *
+ * This middleware handles the initialization of the Inertia instance,
+ * manages request headers, handles redirects for mutation methods,
+ * and implements asset versioning.
+ *
+ * @example
+ * ```ts
+ * export default class InertiaMiddleware extends BaseInertiaMiddleware {
+ *   async share() {
+ *     return {
+ *       user: ctx.auth?.user
+ *     }
+ *   }
+ * }
+ * ```
  */
-declare class Inertia {
-    #private;
-    protected ctx: HttpContext;
-    protected config: ResolvedConfig;
-    protected vite?: Vite | undefined;
-    constructor(ctx: HttpContext, config: ResolvedConfig, vite?: Vite | undefined);
-    /**
-     * Share data for the current request.
-     * This data will override any shared data defined in the config.
-     */
-    share(data: Record<string, Data>): void;
-    /**
-     * Render a page using Inertia
-     */
-    render<TPageProps extends Record<string, any> = {}, TViewProps extends Record<string, any> = {}>(component: string, pageProps?: TPageProps, viewProps?: TViewProps): Promise<string | PageObject<TPageProps>>;
+export default abstract class BaseInertiaMiddleware {
     /**
-     * Clear history state.
+     * Extract validation errors from the session and format them for Inertia
      *
-     * See https://v2.inertiajs.com/history-encryption#clearing-history
-     */
-    clearHistory(): void;
-    /**
-     * Encrypt history
+     * 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
      *
-     * See https://v2.inertiajs.com/history-encryption
+     * @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' } }
+     * ```
      */
-    encryptHistory(encrypt?: boolean): void;
+    getValidationErrors(ctx: HttpContext): Record<string, string> | {
+        [errorBag: string]: Record<string, string>;
+    };
     /**
-     * Create a lazy prop
+     * Share data with all Inertia pages
      *
-     * Lazy props are never resolved on first visit, but only when the client
-     * request a partial reload explicitely with this value.
+     * This method should return an object containing data that will be
+     * available to all Inertia pages as props.
      *
-     * See https://inertiajs.com/partial-reloads#lazy-data-evaluation
+     * @param ctx - The HTTP context object
+     * @returns Props to share across all pages
      *
-     * @deprecated use `optional` instead
+     * @example
+     * ```js
+     * async share() {
+     *   return {
+     *     user: ctx.auth?.user,
+     *     flash: ctx.session?.flashMessages.all()
+     *   }
+     * }
+     * ```
      */
-    lazy<T>(callback: () => MaybePromise<T>): OptionalProp<() => MaybePromise<T>>;
+    abstract share?(ctx: HttpContext): PageProps | Promise<PageProps>;
     /**
-     * Create an optional prop
+     * Initialize the Inertia instance for the current request
      *
-     * See https://inertiajs.com/partial-reloads#lazy-data-evaluation
-     */
-    optional<T>(callback: () => MaybePromise<T>): OptionalProp<() => MaybePromise<T>>;
-    /**
-     * Create a mergeable prop
+     * This method creates an Inertia instance and attaches it to the
+     * HTTP context, making it available throughout the request lifecycle.
      *
-     * See https://v2.inertiajs.com/merging-props
-     */
-    merge<T>(callback: () => MaybePromise<T>): MergeProp<() => MaybePromise<T>>;
-    /**
-     * Create an always prop
-     *
-     * Always props are resolved on every request, no matter if it's a partial
-     * request or not.
+     * @param ctx - The HTTP context object
      *
-     * See https://inertiajs.com/partial-reloads#lazy-data-evaluation
+     * @example
+     * ```ts
+     * await middleware.init(ctx)
+     * ```
      */
-    always<T>(callback: () => MaybePromise<T>): AlwaysProp<() => MaybePromise<T>>;
+    init(ctx: HttpContext): Promise<void>;
     /**
-     * Create a deferred prop
+     * Clean up and finalize the Inertia response
      *
-     * Deferred props feature allows you to defer the loading of certain
-     * page data until after the initial page render.
+     * 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
      *
-     * See https://v2.inertiajs.com/deferred-props
-     */
-    defer<T>(callback: () => MaybePromise<T>, group?: string): DeferProp<() => MaybePromise<T>>;
-    /**
-     * This method can be used to redirect the user to an external website
-     * or even a non-inertia route of your application.
+     * @param ctx - The HTTP context object
      *
-     * See https://inertiajs.com/redirects#external-redirects
+     * @example
+     * ```ts
+     * await middleware.dispose(ctx)
+     * ```
      */
-    location(url: string): Promise<void>;
-}
-
-/**
- * HttpContext augmentations
- */
-declare module '@adonisjs/core/http' {
-    interface HttpContext {
-        inertia: Inertia;
-    }
-}
-/**
- * Inertia middleware to handle the Inertia requests and
- * set appropriate headers/status
- */
-declare class InertiaMiddleware {
-    #private;
-    protected config: ResolvedConfig;
-    protected vite?: Vite | undefined;
-    constructor(config: ResolvedConfig, vite?: Vite | undefined);
-    handle(ctx: HttpContext, next: NextFn): Promise<void>;
+    dispose(ctx: HttpContext): void;
 }
-
-export { InertiaMiddleware as default };

package/build/src/inertia_middleware.js

@@ -1,6 +1,113 @@
 import {
-  InertiaMiddleware
-} from "../chunk-AWCR2NAY.js";
+  InertiaManager
+} 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
+var 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(() => 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 {
-  InertiaMiddleware as default
+  BaseInertiaMiddleware as default
 };

package/build/src/plugins/edge/plugin.d.ts

@@ -1,8 +1,32 @@
-import { PluginFn } from 'edge.js/types';
-
+import type { PluginFn } from 'edge.js/types';
 /**
- * Register the Inertia tags and globals within Edge
+ * Edge.js plugin that registers Inertia.js tags and global functions
+ *
+ * This plugin adds the @inertia and @inertiaHead tags to Edge templates,
+ * along with global helper functions for rendering Inertia pages.
+ *
+ * @returns Edge plugin function that registers Inertia functionality
+ *
+ * @example
+ * ```js
+ * // Configure in config/edge.ts
+ * import { edgePluginInertia } from '@adonisjs/inertia/plugins/edge'
+ *
+ * edge.use(edgePluginInertia())
+ * ```
+ *
+ * @example
+ * ```edge
+ * {{-- Use in Edge templates --}}
+ * <!DOCTYPE html>
+ * <html>
+ * <head>
+ *   @inertiaHead()
+ * </head>
+ * <body>
+ *   @inertia({ id: 'app', class: 'min-h-screen' })
+ * </body>
+ * </html>
+ * ```
  */
-declare const edgePluginInertia: () => PluginFn<undefined>;
-
-export { edgePluginInertia };
+export declare const edgePluginInertia: () => PluginFn<undefined>;