@adonisjs/inertia 1.2.2 → 2.0.0

package/build/chunk-AI7SD6T7.js

@@ -0,0 +1,374 @@
+// src/server_renderer.ts
+import { pathToFileURL } from "node:url";
+var ServerRenderer = class _ServerRenderer {
+  constructor(config, vite) {
+    this.config = config;
+    this.vite = vite;
+  }
+  static runtime;
+  /**
+   * Render the page on the server
+   *
+   * On development, we use the Vite Runtime API
+   * On production, we just import and use the SSR bundle generated by Vite
+   */
+  async render(pageObject) {
+    let render;
+    const devServer = this.vite?.getDevServer();
+    if (devServer) {
+      _ServerRenderer.runtime ??= await this.vite.createRuntime();
+      render = await _ServerRenderer.runtime.executeEntrypoint(this.config.ssr.entrypoint);
+    } else {
+      render = await import(pathToFileURL(this.config.ssr.bundle).href);
+    }
+    const result = await render.default(pageObject);
+    return { head: result.head, body: result.body };
+  }
+};
+
+// src/props.ts
+var ignoreFirstLoadSymbol = Symbol("ignoreFirstLoad");
+var MergeableProp = class {
+  shouldMerge = false;
+  merge() {
+    this.shouldMerge = true;
+    return this;
+  }
+};
+var OptionalProp = class {
+  constructor(callback) {
+    this.callback = callback;
+  }
+  [ignoreFirstLoadSymbol] = true;
+};
+var DeferProp = class extends MergeableProp {
+  constructor(callback, group) {
+    super();
+    this.callback = callback;
+    this.group = group;
+  }
+  [ignoreFirstLoadSymbol] = true;
+  getGroup() {
+    return this.group;
+  }
+};
+var MergeProp = class extends MergeableProp {
+  constructor(callback) {
+    super();
+    this.callback = callback;
+    this.shouldMerge = true;
+  }
+};
+var AlwaysProp = class extends MergeableProp {
+  constructor(callback) {
+    super();
+    this.callback = callback;
+  }
+};
+
+// src/headers.ts
+var InertiaHeaders = {
+  Inertia: "x-inertia",
+  Reset: "x-inertia-reset",
+  Version: "x-inertia-version",
+  Location: "x-inertia-location",
+  PartialOnly: "x-inertia-partial-data",
+  PartialExcept: "x-inertia-partial-except",
+  PartialComponent: "x-inertia-partial-component"
+};
+
+// src/inertia.ts
+var Inertia = class {
+  constructor(ctx, config, vite) {
+    this.ctx = ctx;
+    this.config = config;
+    this.vite = vite;
+    this.#sharedData = config.sharedData;
+    this.#serverRenderer = new ServerRenderer(config, vite);
+    this.#shouldClearHistory = false;
+    this.#shouldEncryptHistory = config.history.encrypt;
+  }
+  #sharedData = {};
+  #serverRenderer;
+  #shouldClearHistory = false;
+  #shouldEncryptHistory = false;
+  /**
+   * Check if the current request is a partial request
+   */
+  #isPartial(component) {
+    return this.ctx.request.header(InertiaHeaders.PartialComponent) === component;
+  }
+  /**
+   * Resolve the `only` partial request props.
+   * Only the props listed in the `x-inertia-partial-data` header
+   * will be returned
+   */
+  #resolveOnly(props) {
+    const partialOnlyHeader = this.ctx.request.header(InertiaHeaders.PartialOnly);
+    const only = partialOnlyHeader.split(",").filter(Boolean);
+    let newProps = {};
+    for (const key of only) newProps[key] = props[key];
+    return newProps;
+  }
+  /**
+   * Resolve the `except` partial request props.
+   * Remove the props listed in the `x-inertia-partial-except` header
+   */
+  #resolveExcept(props) {
+    const partialExceptHeader = this.ctx.request.header(InertiaHeaders.PartialExcept);
+    const except = partialExceptHeader.split(",").filter(Boolean);
+    for (const key of except) delete props[key];
+    return props;
+  }
+  /**
+   * Resolve the props for the current request
+   * by filtering out the props that are not needed
+   * based on the request headers
+   */
+  #pickPropsToResolve(component, props = {}) {
+    const isPartial = this.#isPartial(component);
+    let newProps = props;
+    if (!isPartial) {
+      newProps = Object.fromEntries(
+        Object.entries(props).filter(([_, value]) => {
+          if (value && value[ignoreFirstLoadSymbol]) return false;
+          return true;
+        })
+      );
+    }
+    const partialOnlyHeader = this.ctx.request.header(InertiaHeaders.PartialOnly);
+    if (isPartial && partialOnlyHeader) newProps = this.#resolveOnly(props);
+    const partialExceptHeader = this.ctx.request.header(InertiaHeaders.PartialExcept);
+    if (isPartial && partialExceptHeader) newProps = this.#resolveExcept(newProps);
+    for (const [key, value] of Object.entries(props)) {
+      if (value instanceof AlwaysProp) newProps[key] = props[key];
+    }
+    return newProps;
+  }
+  /**
+   * Resolve a single prop by calling the callback or resolving the promise
+   */
+  async #resolvePageProps(props = {}) {
+    return Object.fromEntries(
+      await Promise.all(
+        Object.entries(props).map(async ([key, value]) => {
+          if (typeof value === "function") {
+            return [key, await value(this.ctx)];
+          }
+          if (value instanceof OptionalProp || value instanceof MergeProp || value instanceof DeferProp || value instanceof AlwaysProp) {
+            return [key, await value.callback()];
+          }
+          return [key, value];
+        })
+      )
+    );
+  }
+  /**
+   * Resolve the deferred props listing. Will be returned only
+   * on the first visit to the page and will be used to make
+   * subsequent partial requests
+   */
+  #resolveDeferredProps(component, pageProps) {
+    if (this.#isPartial(component)) return {};
+    const deferredProps = Object.entries(pageProps || {}).filter(([_, value]) => value instanceof DeferProp).map(([key, value]) => ({ key, group: value.getGroup() })).reduce(
+      (groups, { key, group }) => {
+        if (!groups[group]) groups[group] = [];
+        groups[group].push(key);
+        return groups;
+      },
+      {}
+    );
+    return Object.keys(deferredProps).length ? { deferredProps } : {};
+  }
+  /**
+   * Resolve the props that should be merged
+   */
+  #resolveMergeProps(pageProps) {
+    const inertiaResetHeader = this.ctx.request.header(InertiaHeaders.Reset) || "";
+    const resetProps = new Set(inertiaResetHeader.split(",").filter(Boolean));
+    const mergeProps = Object.entries(pageProps || {}).filter(([_, value]) => value instanceof MergeableProp && value.shouldMerge).map(([key]) => key).filter((key) => !resetProps.has(key));
+    return mergeProps.length ? { mergeProps } : {};
+  }
+  /**
+   * Build the page object that will be returned to the client
+   *
+   * See https://inertiajs.com/the-protocol#the-page-object
+   */
+  async #buildPageObject(component, pageProps) {
+    const propsToResolve = this.#pickPropsToResolve(component, {
+      ...this.#sharedData,
+      ...pageProps
+    });
+    return {
+      component,
+      url: this.ctx.request.url(true),
+      version: this.config.versionCache.getVersion(),
+      props: await this.#resolvePageProps(propsToResolve),
+      clearHistory: this.#shouldClearHistory,
+      encryptHistory: this.#shouldEncryptHistory,
+      ...this.#resolveMergeProps(pageProps),
+      ...this.#resolveDeferredProps(component, pageProps)
+    };
+  }
+  /**
+   * If the page should be rendered on the server or not
+   *
+   * The ssr.pages config can be a list of pages or a function that returns a boolean
+   */
+  async #shouldRenderOnServer(component) {
+    const isSsrEnabled = this.config.ssr.enabled;
+    if (!isSsrEnabled) return false;
+    let isSsrEnabledForPage = false;
+    if (typeof this.config.ssr.pages === "function") {
+      isSsrEnabledForPage = await this.config.ssr.pages(this.ctx, component);
+    } else if (this.config.ssr.pages) {
+      isSsrEnabledForPage = this.config.ssr.pages?.includes(component);
+    } else {
+      isSsrEnabledForPage = true;
+    }
+    return isSsrEnabledForPage;
+  }
+  /**
+   * Resolve the root view
+   */
+  #resolveRootView() {
+    return typeof this.config.rootView === "function" ? this.config.rootView(this.ctx) : this.config.rootView;
+  }
+  /**
+   * Render the page on the server
+   */
+  async #renderOnServer(pageObject, viewProps) {
+    const { head, body } = await this.#serverRenderer.render(pageObject);
+    return this.ctx.view.render(this.#resolveRootView(), {
+      ...viewProps,
+      page: { ssrHead: head, ssrBody: body, ...pageObject }
+    });
+  }
+  /**
+   * Share data for the current request.
+   * This data will override any shared data defined in the config.
+   */
+  share(data) {
+    this.#sharedData = { ...this.#sharedData, ...data };
+  }
+  /**
+   * Render a page using Inertia
+   */
+  async render(component, pageProps, viewProps) {
+    const pageObject = await this.#buildPageObject(component, pageProps);
+    const isInertiaRequest = !!this.ctx.request.header(InertiaHeaders.Inertia);
+    if (!isInertiaRequest) {
+      const shouldRenderOnServer = await this.#shouldRenderOnServer(component);
+      if (shouldRenderOnServer) return this.#renderOnServer(pageObject, viewProps);
+      return this.ctx.view.render(this.#resolveRootView(), { ...viewProps, page: pageObject });
+    }
+    this.ctx.response.header(InertiaHeaders.Inertia, "true");
+    return pageObject;
+  }
+  /**
+   * Clear history state.
+   *
+   * See https://v2.inertiajs.com/history-encryption#clearing-history
+   */
+  clearHistory() {
+    this.#shouldClearHistory = true;
+  }
+  /**
+   * Encrypt history
+   *
+   * See https://v2.inertiajs.com/history-encryption
+   */
+  encryptHistory(encrypt = true) {
+    this.#shouldEncryptHistory = encrypt;
+  }
+  /**
+   * Create a lazy prop
+   *
+   * Lazy props are never resolved on first visit, but only when the client
+   * request a partial reload explicitely with this value.
+   *
+   * See https://inertiajs.com/partial-reloads#lazy-data-evaluation
+   *
+   * @deprecated use `optional` instead
+   */
+  lazy(callback) {
+    return new OptionalProp(callback);
+  }
+  /**
+   * Create an optional prop
+   *
+   * See https://inertiajs.com/partial-reloads#lazy-data-evaluation
+   */
+  optional(callback) {
+    return new OptionalProp(callback);
+  }
+  /**
+   * Create a mergeable prop
+   *
+   * See https://v2.inertiajs.com/merging-props
+   */
+  merge(callback) {
+    return new MergeProp(callback);
+  }
+  /**
+   * Create an always prop
+   *
+   * Always props are resolved on every request, no matter if it's a partial
+   * request or not.
+   *
+   * See https://inertiajs.com/partial-reloads#lazy-data-evaluation
+   */
+  always(callback) {
+    return new AlwaysProp(callback);
+  }
+  /**
+   * Create a deferred prop
+   *
+   * Deferred props feature allows you to defer the loading of certain
+   * page data until after the initial page render.
+   *
+   * See https://v2.inertiajs.com/deferred-props
+   */
+  defer(callback, group = "default") {
+    return new DeferProp(callback, group);
+  }
+  /**
+   * This method can be used to redirect the user to an external website
+   * or even a non-inertia route of your application.
+   *
+   * See https://inertiajs.com/redirects#external-redirects
+   */
+  async location(url) {
+    this.ctx.response.header(InertiaHeaders.Location, url);
+    this.ctx.response.status(409);
+  }
+};
+
+// src/inertia_middleware.ts
+var InertiaMiddleware = class {
+  constructor(config, vite) {
+    this.config = config;
+    this.vite = vite;
+  }
+  async handle(ctx, next) {
+    const { response, request } = ctx;
+    ctx.inertia = new Inertia(ctx, this.config, this.vite);
+    await next();
+    const isInertiaRequest = !!request.header("x-inertia");
+    if (!isInertiaRequest) return;
+    response.header("Vary", "Accept");
+    const method = request.method();
+    if (response.getStatus() === 302 && ["PUT", "PATCH", "DELETE"].includes(method)) {
+      response.status(303);
+    }
+    const version = this.config.versionCache.getVersion().toString();
+    if (method === "GET" && request.header("x-inertia-version", "") !== version) {
+      response.header("x-inertia-location", request.url());
+      response.status(409);
+    }
+  }
+};
+
+export {
+  InertiaMiddleware
+};

package/build/index.d.ts

@@ -1,9 +1,8 @@
 import Configure from '@adonisjs/core/commands/configure';
 import { ConfigProvider } from '@adonisjs/core/types';
-import { S as SharedData, I as InertiaConfig, R as ResolvedConfig } from './types-YRkkep62.js';
+import { S as SharedData, I as InertiaConfig, R as ResolvedConfig } from './types-AyvioK68.js';
 import '@adonisjs/core/http';
 import '@tuyau/utils/types';
-import '@adonisjs/vite';
 
 /**
  * Configures the package

package/build/index.js

@@ -290,6 +290,7 @@ function defineConfig(config) {
       versionCache,
       rootView: config.rootView ?? "inertia_layout",
       sharedData: config.sharedData || {},
+      history: { encrypt: config.history?.encrypt ?? false },
       entrypoint: slash(
         config.entrypoint ?? await detector.detectEntrypoint("inertia/app/app.ts")
       ),

package/build/providers/inertia_provider.js

@@ -1,6 +1,6 @@
 import {
   InertiaMiddleware
-} from "../chunk-G6UKVO4B.js";
+} from "../chunk-AI7SD6T7.js";
 
 // providers/inertia_provider.ts
 import { configProvider } from "@adonisjs/core";

package/build/src/inertia_middleware.d.ts

@@ -1,10 +1,90 @@
 import { Vite } from '@adonisjs/vite';
 import { HttpContext } from '@adonisjs/core/http';
 import { NextFn } from '@adonisjs/core/types/http';
-import { a as Inertia, R as ResolvedConfig } from '../types-YRkkep62.js';
+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-AyvioK68.js';
 import '@adonisjs/core/types';
 import '@tuyau/utils/types';
 
+/**
+ * Main class used to interact with Inertia
+ */
+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>>;
+    /**
+     * Clear history state.
+     *
+     * See https://v2.inertiajs.com/history-encryption#clearing-history
+     */
+    clearHistory(): void;
+    /**
+     * Encrypt history
+     *
+     * See https://v2.inertiajs.com/history-encryption
+     */
+    encryptHistory(encrypt?: boolean): void;
+    /**
+     * Create a lazy prop
+     *
+     * Lazy props are never resolved on first visit, but only when the client
+     * request a partial reload explicitely with this value.
+     *
+     * See https://inertiajs.com/partial-reloads#lazy-data-evaluation
+     *
+     * @deprecated use `optional` instead
+     */
+    lazy<T>(callback: () => MaybePromise<T>): OptionalProp<() => MaybePromise<T>>;
+    /**
+     * Create an optional prop
+     *
+     * See https://inertiajs.com/partial-reloads#lazy-data-evaluation
+     */
+    optional<T>(callback: () => MaybePromise<T>): OptionalProp<() => MaybePromise<T>>;
+    /**
+     * Create a mergeable prop
+     *
+     * 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.
+     *
+     * See https://inertiajs.com/partial-reloads#lazy-data-evaluation
+     */
+    always<T>(callback: () => MaybePromise<T>): AlwaysProp<() => MaybePromise<T>>;
+    /**
+     * Create a deferred prop
+     *
+     * Deferred props feature allows you to defer the loading of certain
+     * page data until after the initial page render.
+     *
+     * 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.
+     *
+     * See https://inertiajs.com/redirects#external-redirects
+     */
+    location(url: string): Promise<void>;
+}
+
 /**
  * HttpContext augmentations
  */

package/build/src/inertia_middleware.js

@@ -1,6 +1,6 @@
 import {
   InertiaMiddleware
-} from "../chunk-G6UKVO4B.js";
+} from "../chunk-AI7SD6T7.js";
 export {
   InertiaMiddleware as default
 };

package/build/src/plugins/japa/api_client.d.ts

@@ -1,9 +1,8 @@
 import { PluginFn } from '@japa/runner/types';
 import { ApplicationService } from '@adonisjs/core/types';
-import { P as PageProps } from '../../../types-YRkkep62.js';
+import { c as PageProps } from '../../../types-AyvioK68.js';
 import '@adonisjs/core/http';
 import '@tuyau/utils/types';
-import '@adonisjs/vite';
 
 declare module '@japa/api-client' {
     interface ApiRequest {

package/build/src/types.d.ts

@@ -1,5 +1,4 @@
 import '@adonisjs/core/types';
 import '@adonisjs/core/http';
 import '@tuyau/utils/types';
-export { A as AssetsVersion, D as Data, I as InertiaConfig, f as InferPageProps, d as InferSharedProps, M as MaybePromise, c as PageObject, P as PageProps, g as RenderInertiaSsrApp, R as ResolvedConfig, S as SharedData, b as SharedDatumFactory, e as SharedProps } from '../types-YRkkep62.js';
-import '@adonisjs/vite';
+export { e as AssetsVersion, D as Data, I as InertiaConfig, h as InferPageProps, f as InferSharedProps, M as MaybePromise, P as PageObject, c as PageProps, i as RenderInertiaSsrApp, R as ResolvedConfig, S as SharedData, d as SharedDatumFactory, g as SharedProps } from '../types-AyvioK68.js';

package/build/{types-YRkkep62.d.ts → types-AyvioK68.d.ts}

@@ -1,49 +1,6 @@
 import { ConfigProvider } from '@adonisjs/core/types';
 import { HttpContext } from '@adonisjs/core/http';
 import { Simplify, Serialize } from '@tuyau/utils/types';
-import { Vite } from '@adonisjs/vite';
-
-/**
- * Symbol used to identify lazy props
- */
-declare const kLazySymbol: unique symbol;
-/**
- * Main class used to interact with Inertia
- */
-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>>;
-    /**
-     * Create a lazy prop
-     *
-     * Lazy props are never resolved on first visit, but only when the client
-     * request a partial reload explicitely with this value.
-     *
-     * See https://inertiajs.com/partial-reloads#lazy-data-evaluation
-     */
-    lazy<T>(callback: () => MaybePromise<T>): {
-        [kLazySymbol]: () => MaybePromise<T>;
-    };
-    /**
-     * This method can be used to redirect the user to an external website
-     * or even a non-inertia route of your application.
-     *
-     * See https://inertiajs.com/redirects#external-redirects
-     */
-    location(url: string): Promise<void>;
-}
 
 /**
  * VersionCache is used to cache the version of the assets.
@@ -71,6 +28,47 @@ declare class VersionCache {
     setVersion(version: AssetsVersion): Promise<void>;
 }
 
+declare const ignoreFirstLoadSymbol: unique symbol;
+/**
+ * Base class for Mergeable props
+ */
+declare abstract class MergeableProp {
+    shouldMerge: boolean;
+    merge(): this;
+}
+/**
+ * Optional prop
+ */
+declare class OptionalProp<T extends MaybePromise<any>> {
+    callback: T;
+    [ignoreFirstLoadSymbol]: boolean;
+    constructor(callback: T);
+}
+/**
+ * Defer prop
+ */
+declare class DeferProp<T extends MaybePromise<any>> extends MergeableProp {
+    callback: T;
+    private group;
+    [ignoreFirstLoadSymbol]: true;
+    constructor(callback: T, group: string);
+    getGroup(): string;
+}
+/**
+ * Merge prop
+ */
+declare class MergeProp<T extends MaybePromise<any>> extends MergeableProp {
+    callback: T;
+    constructor(callback: T);
+}
+/**
+ * Always prop
+ */
+declare class AlwaysProp<T extends MaybePromise<any>> extends MergeableProp {
+    callback: T;
+    constructor(callback: T);
+}
+
 type MaybePromise<T> = T | Promise<T>;
 /**
  * Props that will be passed to inertia render method
@@ -105,6 +103,14 @@ interface InertiaConfig<T extends SharedData = SharedData> {
      * Data that should be shared with all rendered pages
      */
     sharedData?: T;
+    /**
+     * History encryption
+     *
+     * See https://v2.inertiajs.com/history-encryption
+     */
+    history?: {
+        encrypt?: boolean;
+    };
     /**
      * Options to configure SSR
      */
@@ -134,6 +140,9 @@ interface ResolvedConfig<T extends SharedData = SharedData> {
     rootView: string | ((ctx: HttpContext) => string);
     versionCache: VersionCache;
     sharedData: T;
+    history: {
+        encrypt: boolean;
+    };
     ssr: {
         enabled: boolean;
         entrypoint: string;
@@ -142,22 +151,50 @@ interface ResolvedConfig<T extends SharedData = SharedData> {
     };
 }
 interface PageObject<TPageProps extends PageProps = PageProps> {
+    ssrHead?: string;
+    ssrBody?: string;
+    /**
+     * The name of the JavaScript page component.
+     */
     component: string;
+    /**
+     * The current asset version.
+     */
     version: string | number;
+    /**
+     * The page props (data).
+     */
     props: TPageProps;
+    /**
+     * The page URL.
+     */
     url: string;
-    ssrHead?: string;
-    ssrBody?: string;
+    /**
+     * List of deferred props that will be loaded with subsequent requests
+     */
+    deferredProps?: Record<string, string[]>;
+    /**
+     * List of mergeable props that will be merged with subsequent requests
+     */
+    mergeProps?: string[];
+    /**
+     * Whether or not to encrypt the current page's history state.
+     */
+    encryptHistory?: boolean;
+    /**
+     *  Whether or not to clear any encrypted history state.
+     */
+    clearHistory?: boolean;
 }
-type IsLazyProp<T> = T extends {
-    [kLazySymbol]: () => MaybePromise<any>;
-} ? true : false;
+type IsOptionalProp<T> = T extends OptionalProp<any> ? true : T extends DeferProp<any> ? true : false;
 type InferProps<T> = {
-    [K in keyof T as IsLazyProp<T[K]> extends true ? K : never]+?: T[K] extends {
-        [kLazySymbol]: () => MaybePromise<infer U>;
+    [K in keyof T as IsOptionalProp<T[K]> extends true ? K : never]+?: T[K] extends {
+        callback: () => MaybePromise<infer U>;
     } ? U : T[K];
 } & {
-    [K in keyof T as IsLazyProp<T[K]> extends true ? never : K]: T[K];
+    [K in keyof T as IsOptionalProp<T[K]> extends true ? never : K]: T[K] extends {
+        callback: () => MaybePromise<infer U>;
+    } ? U : T[K];
 };
 type ReturnsTypesSharedData<T extends SharedData> = {} extends T ? {} : {
     [K in keyof T]: T[K] extends (...args: any[]) => MaybePromise<infer U> ? U : T[K];
@@ -200,4 +237,4 @@ type RenderInertiaSsrApp = (page: PageObject) => Promise<{
     body: string;
 }>;
 
-export { type AssetsVersion as A, type Data as D, type InertiaConfig as I, type MaybePromise as M, type PageProps as P, type ResolvedConfig as R, type SharedData as S, Inertia as a, type SharedDatumFactory as b, type PageObject as c, type InferSharedProps as d, type SharedProps as e, type InferPageProps as f, type RenderInertiaSsrApp as g };
+export { AlwaysProp as A, type Data as D, type InertiaConfig as I, type MaybePromise as M, OptionalProp as O, type PageObject as P, type ResolvedConfig as R, type SharedData as S, MergeProp as a, DeferProp as b, type PageProps as c, type SharedDatumFactory as d, type AssetsVersion as e, type InferSharedProps as f, type SharedProps as g, type InferPageProps as h, type RenderInertiaSsrApp as i };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adonisjs/inertia",
   "description": "Official Inertia.js adapter for AdonisJS",
-  "version": "1.2.2",
+  "version": "2.0.0",
   "engines": {
     "node": ">=20.6.0"
   },
@@ -27,7 +27,7 @@
     "typecheck": "tsc --noEmit",
     "lint": "eslint",
     "format": "prettier --write .",
-    "quick:test": "node --import=ts-node-maintained/register/esm bin/test.ts",
+    "quick:test": "node --enable-source-maps --import=ts-node-maintained/register/esm bin/test.ts",
     "pretest": "npm run lint",
     "test": "c8 npm run quick:test",
     "prebuild": "npm run lint && npm run clean",
@@ -94,6 +94,10 @@
       "optional": true
     }
   },
+  "publishConfig": {
+    "access": "public",
+    "tag": "beta"
+  },
   "author": "Julien Ripouteau <julien@ripouteau.com>,adonisjs",
   "license": "MIT",
   "keywords": [

package/build/chunk-G6UKVO4B.js

@@ -1,199 +0,0 @@
-// src/server_renderer.ts
-import { pathToFileURL } from "node:url";
-var ServerRenderer = class _ServerRenderer {
-  constructor(config, vite) {
-    this.config = config;
-    this.vite = vite;
-  }
-  static runtime;
-  /**
-   * Render the page on the server
-   *
-   * On development, we use the Vite Runtime API
-   * On production, we just import and use the SSR bundle generated by Vite
-   */
-  async render(pageObject) {
-    let render;
-    const devServer = this.vite?.getDevServer();
-    if (devServer) {
-      _ServerRenderer.runtime ??= await this.vite.createRuntime();
-      render = await _ServerRenderer.runtime.executeEntrypoint(this.config.ssr.entrypoint);
-    } else {
-      render = await import(pathToFileURL(this.config.ssr.bundle).href);
-    }
-    const result = await render.default(pageObject);
-    return { head: result.head, body: result.body };
-  }
-};
-
-// src/inertia.ts
-var kLazySymbol = Symbol("lazy");
-var Inertia = class {
-  constructor(ctx, config, vite) {
-    this.ctx = ctx;
-    this.config = config;
-    this.vite = vite;
-    this.#sharedData = config.sharedData;
-    this.#serverRenderer = new ServerRenderer(config, vite);
-  }
-  #sharedData = {};
-  #serverRenderer;
-  /**
-   * Check if a value is a lazy prop
-   */
-  #isLazyProps(value) {
-    return typeof value === "object" && value && kLazySymbol in value;
-  }
-  /**
-   * Pick props to resolve based on x-inertia-partial-data header
-   *
-   * If header is not present, resolve all props except lazy props
-   * If header is present, resolve only the props that are listed in the header
-   */
-  #pickPropsToResolve(component, props) {
-    const partialData = this.ctx.request.header("x-inertia-partial-data")?.split(",").filter(Boolean);
-    const partialComponent = this.ctx.request.header("x-inertia-partial-component");
-    let entriesToResolve = Object.entries(props);
-    if (partialData && partialComponent === component) {
-      entriesToResolve = entriesToResolve.filter(([key]) => partialData.includes(key));
-    } else {
-      entriesToResolve = entriesToResolve.filter(([key]) => !this.#isLazyProps(props[key]));
-    }
-    return entriesToResolve;
-  }
-  /**
-   * Resolve the props that will be sent to the client
-   */
-  async #resolvePageProps(component, props) {
-    const entriesToResolve = this.#pickPropsToResolve(component, props);
-    const entries = entriesToResolve.map(async ([key, value]) => {
-      if (typeof value === "function") {
-        return [key, await value(this.ctx)];
-      }
-      if (this.#isLazyProps(value)) {
-        const lazyValue = value[kLazySymbol];
-        return [key, await lazyValue()];
-      }
-      return [key, value];
-    });
-    return Object.fromEntries(await Promise.all(entries));
-  }
-  /**
-   * Build the page object that will be returned to the client
-   *
-   * See https://inertiajs.com/the-protocol#the-page-object
-   */
-  async #buildPageObject(component, pageProps) {
-    return {
-      component,
-      version: this.config.versionCache.getVersion(),
-      props: await this.#resolvePageProps(component, { ...this.#sharedData, ...pageProps }),
-      url: this.ctx.request.url(true)
-    };
-  }
-  /**
-   * If the page should be rendered on the server or not
-   *
-   * The ssr.pages config can be a list of pages or a function that returns a boolean
-   */
-  async #shouldRenderOnServer(component) {
-    const isSsrEnabled = this.config.ssr.enabled;
-    if (!isSsrEnabled) return false;
-    let isSsrEnabledForPage = false;
-    if (typeof this.config.ssr.pages === "function") {
-      isSsrEnabledForPage = await this.config.ssr.pages(this.ctx, component);
-    } else if (this.config.ssr.pages) {
-      isSsrEnabledForPage = this.config.ssr.pages?.includes(component);
-    } else {
-      isSsrEnabledForPage = true;
-    }
-    return isSsrEnabledForPage;
-  }
-  /**
-   * Resolve the root view
-   */
-  #resolveRootView() {
-    return typeof this.config.rootView === "function" ? this.config.rootView(this.ctx) : this.config.rootView;
-  }
-  /**
-   * Render the page on the server
-   */
-  async #renderOnServer(pageObject, viewProps) {
-    const { head, body } = await this.#serverRenderer.render(pageObject);
-    return this.ctx.view.render(this.#resolveRootView(), {
-      ...viewProps,
-      page: { ssrHead: head, ssrBody: body, ...pageObject }
-    });
-  }
-  /**
-   * Share data for the current request.
-   * This data will override any shared data defined in the config.
-   */
-  share(data) {
-    this.#sharedData = { ...this.#sharedData, ...data };
-  }
-  /**
-   * Render a page using Inertia
-   */
-  async render(component, pageProps, viewProps) {
-    const pageObject = await this.#buildPageObject(component, pageProps);
-    const isInertiaRequest = !!this.ctx.request.header("x-inertia");
-    if (!isInertiaRequest) {
-      const shouldRenderOnServer = await this.#shouldRenderOnServer(component);
-      if (shouldRenderOnServer) return this.#renderOnServer(pageObject, viewProps);
-      return this.ctx.view.render(this.#resolveRootView(), { ...viewProps, page: pageObject });
-    }
-    this.ctx.response.header("x-inertia", "true");
-    return pageObject;
-  }
-  /**
-   * Create a lazy prop
-   *
-   * Lazy props are never resolved on first visit, but only when the client
-   * request a partial reload explicitely with this value.
-   *
-   * See https://inertiajs.com/partial-reloads#lazy-data-evaluation
-   */
-  lazy(callback) {
-    return { [kLazySymbol]: callback };
-  }
-  /**
-   * This method can be used to redirect the user to an external website
-   * or even a non-inertia route of your application.
-   *
-   * See https://inertiajs.com/redirects#external-redirects
-   */
-  async location(url) {
-    this.ctx.response.header("X-Inertia-Location", url);
-    this.ctx.response.status(409);
-  }
-};
-
-// src/inertia_middleware.ts
-var InertiaMiddleware = class {
-  constructor(config, vite) {
-    this.config = config;
-    this.vite = vite;
-  }
-  async handle(ctx, next) {
-    const { response, request } = ctx;
-    ctx.inertia = new Inertia(ctx, this.config, this.vite);
-    await next();
-    const isInertiaRequest = !!request.header("x-inertia");
-    if (!isInertiaRequest) return;
-    response.header("Vary", "Accept");
-    const method = request.method();
-    if (response.getStatus() === 302 && ["PUT", "PATCH", "DELETE"].includes(method)) {
-      response.status(303);
-    }
-    const version = this.config.versionCache.getVersion().toString();
-    if (method === "GET" && request.header("x-inertia-version", "") !== version) {
-      response.header("x-inertia-location", request.url());
-      response.status(409);
-    }
-  }
-};
-
-export {
-  InertiaMiddleware
-};