@adonisjs/inertia 3.1.1 → 4.0.0-next.1

package/build/chunk-DISC5OYC.js

@@ -0,0 +1,46 @@
+// src/headers.ts
+var InertiaHeaders = {
+  /**
+   * Header to identify Inertia.js requests.
+   * Set to 'true' by Inertia.js client to indicate an Inertia request.
+   */
+  Inertia: "x-inertia",
+  /**
+   * Header to drop a prop from the merge and deep merge object.
+   */
+  Reset: "x-inertia-reset",
+  /**
+   * Header containing the current asset version.
+   * Used for cache busting - if versions don't match, Inertia performs a full page reload.
+   */
+  Version: "x-inertia-version",
+  /**
+   * Header containing the target URL for redirects.
+   * Used when the server wants to redirect to a different URL than the current request.
+   */
+  Location: "x-inertia-location",
+  /**
+   * Header specifying the error bag name for validation errors.
+   * Allows multiple forms on the same page to have separate error handling.
+   */
+  ErrorBag: "x-inertia-error-bag",
+  /**
+   * Header containing comma-separated list of props to include in partial data requests.
+   * Only the specified props will be returned in the response.
+   */
+  PartialOnly: "x-inertia-partial-data",
+  /**
+   * Header containing comma-separated list of props to exclude in partial data requests.
+   * All props except the specified ones will be returned in the response.
+   */
+  PartialExcept: "x-inertia-partial-except",
+  /**
+   * Header specifying the component name for partial reloads.
+   * Used to identify which component is being partially reloaded.
+   */
+  PartialComponent: "x-inertia-partial-component"
+};
+
+export {
+  InertiaHeaders
+};

package/build/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/build/chunk-PDP56GPP.js

@@ -0,0 +1,75 @@
+// src/index_pages.ts
+var GLOB = {
+  vue3: ["**/*.vue"],
+  react: ["**/*.ts", "**/*.tsx"]
+};
+var SUPPORTED_FRAMEWORKS = Object.keys(GLOB);
+var TYPES_EXTRACTION_HELPER = {
+  vue3: `import type { VNodeProps, AllowedComponentProps, ComponentInstance } from 'vue'
+
+type ExtractProps<T> = Omit<
+  ComponentInstance<T>['$props'][K],
+  keyof VNodeProps | keyof AllowedComponentProps
+>`,
+  react: `import type React from 'react'
+
+type ExtractProps<T> = T extends React.FC<infer Props>
+? Props
+: T extends React.Component<infer Props>
+? Props
+: never`
+};
+var indexPages = function(config) {
+  if (!SUPPORTED_FRAMEWORKS.includes(config.framework)) {
+    throw new Error(
+      `Unsupported framework "${config.framework}". Types generation is available only for ${SUPPORTED_FRAMEWORKS.join(",")}`
+    );
+  }
+  return {
+    run(_, indexGenerator) {
+      indexGenerator.add("inertiaPages", {
+        source: "inertia/pages",
+        glob: GLOB[config.framework],
+        output: ".adonisjs/server/pages.d.ts",
+        as(vfs, buffer, __, helpers) {
+          const filesList = vfs.asList();
+          buffer.write(TYPES_EXTRACTION_HELPER[config.framework]);
+          buffer.write(`declare module '@adonisjs/inertia/types' {`).indent();
+          buffer.write(`export interface InertiaPages {`).indent();
+          Object.keys(filesList).forEach((key) => {
+            buffer.write(
+              `'${key}': ExtractProps<(typeof import('${helpers.toImportPath(filesList[key])}'))['default']>`
+            );
+          });
+          buffer.dedent().write(`}`);
+          buffer.dedent().write(`}`);
+        }
+      });
+    }
+  };
+};
+
+// src/define_config.ts
+import lodash from "@poppinss/utils/lodash";
+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"
+      }
+    },
+    config
+  );
+}
+
+export {
+  indexPages,
+  defineConfig
+};

package/build/factories/inertia_factory.d.ts

@@ -0,0 +1,137 @@
+import { type Vite } from '@adonisjs/vite';
+import { type HttpContext } from '@adonisjs/core/http';
+import { Inertia } from '../src/inertia.js';
+import { type AssetsVersion, type InertiaConfig, type ComponentProps, type InertiaConfigInput } from '../src/types.js';
+/**
+ * Parameters for configuring the Inertia factory
+ */
+type FactoryParameters = {
+    /** HTTP context for the request */
+    ctx: HttpContext;
+    /** Inertia configuration object */
+    config: InertiaConfig;
+};
+/**
+ * Inertia factory to quickly create a new instance of Inertia
+ * for testing purposes
+ *
+ * @example
+ * ```typescript
+ * const factory = new InertiaFactory()
+ * const inertia = factory
+ *   .merge({ config: { ssr: { enabled: true } } })
+ *   .withVersion('1.0.0')
+ *   .create()
+ * ```
+ */
+export declare class InertiaFactory<Pages extends Record<string, ComponentProps>> {
+    #private;
+    /**
+     * Creates a new InertiaFactory instance with default Inertia headers
+     *
+     * @example
+     * ```typescript
+     * const factory = new InertiaFactory()
+     * ```
+     */
+    constructor();
+    /**
+     * Merges additional parameters into the factory configuration
+     *
+     * @param parameters - Partial factory parameters to merge
+     *
+     * @example
+     * ```typescript
+     * factory.merge({
+     *   config: { ssr: { enabled: true } },
+     *   ctx: customContext
+     * })
+     * ```
+     */
+    merge(parameters: Omit<Partial<FactoryParameters>, 'config'> & {
+        config?: InertiaConfigInput;
+    }): this;
+    /**
+     * Removes the X-Inertia header from the request headers
+     *
+     * @example
+     * ```typescript
+     * const inertia = factory.withoutInertia().create()
+     * ```
+     */
+    withoutInertia(): this;
+    /**
+     * Configures the factory for partial reloads of a specific component
+     *
+     * @param component - Name of the component to partially reload
+     *
+     * @example
+     * ```typescript
+     * const inertia = factory
+     *   .partialReload('UserProfile')
+     *   .only(['name', 'email'])
+     *   .create()
+     * ```
+     */
+    partialReload<Page extends keyof Pages & string>(component: Page): {
+        /**
+         * Specifies which props to include in the partial reload
+         *
+         * @param props - Array of property names to include
+         */
+        only(props: string[]): /*elided*/ any;
+        /**
+         * Specifies which props to exclude from the partial reload
+         *
+         * @param props - Array of property names to exclude
+         */
+        except(props: string[]): /*elided*/ any;
+        /**
+         * Specifies which props should be reset during the partial reload
+         *
+         * @param props - Array of property names to reset
+         */
+        reset(props: string[]): /*elided*/ any;
+        /**
+         * Creates the Inertia instance with partial reload configuration
+         */
+        create(): Inertia<Pages>;
+    };
+    /**
+     * Sets the assets version for cache busting
+     *
+     * @param version - Version string or function for asset versioning
+     *
+     * @example
+     * ```typescript
+     * factory.withVersion('1.0.0')
+     * // or
+     * factory.withVersion(() => Date.now().toString())
+     * ```
+     */
+    withVersion(version: AssetsVersion): this;
+    /**
+     * Sets the Vite instance for asset handling
+     *
+     * @param options - Vite configuration object
+     *
+     * @example
+     * ```typescript
+     * factory.withVite(viteInstance)
+     * ```
+     */
+    withVite(options: Vite): this;
+    /**
+     * Creates a new Inertia instance with the configured parameters
+     *
+     * @example
+     * ```typescript
+     * const inertia = factory
+     *   .merge({ config: customConfig })
+     *   .withVersion('1.0.0')
+     *   .create()
+     * ```
+     */
+    create(): Inertia<Pages>;
+}
+export {};

package/build/factories/main.d.ts

@@ -0,0 +1 @@
+export { InertiaFactory } from './inertia_factory.ts';

package/build/factories/main.js

@@ -0,0 +1,175 @@
+import {
+  defineConfig
+} from "../chunk-PDP56GPP.js";
+import {
+  Inertia,
+  ServerRenderer
+} from "../chunk-74S2VAL7.js";
+import {
+  InertiaHeaders
+} from "../chunk-DISC5OYC.js";
+import "../chunk-4EZ2J6OA.js";
+import "../chunk-MLKGABMK.js";
+
+// factories/inertia_factory.ts
+import { HttpContextFactory } from "@adonisjs/core/factories/http";
+var InertiaFactory = class {
+  /** Optional Vite instance for asset handling */
+  #vite;
+  /** Internal parameters for factory configuration */
+  #parameters = {
+    ctx: new HttpContextFactory().create(),
+    config: defineConfig({})
+  };
+  /**
+   * Creates a new InertiaFactory instance with default Inertia headers
+   *
+   * @example
+   * ```typescript
+   * const factory = new InertiaFactory()
+   * ```
+   */
+  constructor() {
+    this.#parameters.ctx.request.request.headers[InertiaHeaders.Inertia] = "true";
+  }
+  /**
+   * Merges additional parameters into the factory configuration
+   *
+   * @param parameters - Partial factory parameters to merge
+   *
+   * @example
+   * ```typescript
+   * factory.merge({
+   *   config: { ssr: { enabled: true } },
+   *   ctx: customContext
+   * })
+   * ```
+   */
+  merge(parameters) {
+    if (parameters.ctx) {
+      this.#parameters.ctx = parameters.ctx;
+    }
+    if (parameters.config) {
+      this.#parameters.config = defineConfig(parameters.config);
+    }
+    this.#parameters.ctx.request.request.headers[InertiaHeaders.Inertia] = "true";
+    return this;
+  }
+  /**
+   * Removes the X-Inertia header from the request headers
+   *
+   * @example
+   * ```typescript
+   * const inertia = factory.withoutInertia().create()
+   * ```
+   */
+  withoutInertia() {
+    delete this.#parameters.ctx.request.request.headers[InertiaHeaders.Inertia];
+    return this;
+  }
+  /**
+   * Configures the factory for partial reloads of a specific component
+   *
+   * @param component - Name of the component to partially reload
+   *
+   * @example
+   * ```typescript
+   * const inertia = factory
+   *   .partialReload('UserProfile')
+   *   .only(['name', 'email'])
+   *   .create()
+   * ```
+   */
+  partialReload(component) {
+    const self = this;
+    const request = this.#parameters.ctx.request;
+    request.request.headers[InertiaHeaders.PartialComponent] = component;
+    return {
+      /**
+       * Specifies which props to include in the partial reload
+       *
+       * @param props - Array of property names to include
+       */
+      only(props) {
+        request.request.headers[InertiaHeaders.PartialOnly] = props.join(",");
+        return this;
+      },
+      /**
+       * Specifies which props to exclude from the partial reload
+       *
+       * @param props - Array of property names to exclude
+       */
+      except(props) {
+        request.request.headers[InertiaHeaders.PartialExcept] = props.join(",");
+        return this;
+      },
+      /**
+       * Specifies which props should be reset during the partial reload
+       *
+       * @param props - Array of property names to reset
+       */
+      reset(props) {
+        request.request.headers[InertiaHeaders.Reset] = props.join(",");
+        return this;
+      },
+      /**
+       * Creates the Inertia instance with partial reload configuration
+       */
+      create() {
+        return self.create();
+      }
+    };
+  }
+  /**
+   * Sets the assets version for cache busting
+   *
+   * @param version - Version string or function for asset versioning
+   *
+   * @example
+   * ```typescript
+   * factory.withVersion('1.0.0')
+   * // or
+   * factory.withVersion(() => Date.now().toString())
+   * ```
+   */
+  withVersion(version) {
+    this.#parameters.config = { ...this.#parameters.config, assetsVersion: version };
+    return this;
+  }
+  /**
+   * Sets the Vite instance for asset handling
+   *
+   * @param options - Vite configuration object
+   *
+   * @example
+   * ```typescript
+   * factory.withVite(viteInstance)
+   * ```
+   */
+  withVite(options) {
+    this.#vite = options;
+    return this;
+  }
+  /**
+   * Creates a new Inertia instance with the configured parameters
+   *
+   * @example
+   * ```typescript
+   * const inertia = factory
+   *   .merge({ config: customConfig })
+   *   .withVersion('1.0.0')
+   *   .create()
+   * ```
+   */
+  create() {
+    return new Inertia(
+      this.#parameters.ctx,
+      this.#parameters.config,
+      this.#vite,
+      this.#vite ? new ServerRenderer(this.#parameters.config, this.#vite) : void 0
+    );
+  }
+};
+export {
+  InertiaFactory
+};

package/build/index.d.ts

@@ -1,19 +1,7 @@
-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-DVqEHBD1.js';
-import '@adonisjs/core/http';
-import '@tuyau/utils/types';
-
-/**
- * Configures the package
- */
-declare function configure(command: Configure): Promise<void>;
-
-/**
- * Define the Inertia configuration
- */
-declare function defineConfig<T extends SharedData>(config: InertiaConfig<T>): ConfigProvider<ResolvedConfig<T>>;
-
-declare const stubsRoot: string;
-
-export { configure, defineConfig, stubsRoot };
+export { Inertia } from './src/inertia.ts';
+export * as symbols from './src/symbols.ts';
+export { InertiaHeaders } from './src/headers.ts';
+export { indexPages } from './src/index_pages.ts';
+export { defineConfig } from './src/define_config.js';
+export { InertiaManager } from './src/inertia_manager.ts';
+export { ServerRenderer } from './src/server_renderer.ts';