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

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-5QRJHXXQ.js";
+import {
+  Inertia,
+  ServerRenderer
+} from "../chunk-YQ72YL64.js";
+import "../chunk-4EZ2J6OA.js";
+import {
+  InertiaHeaders
+} from "../chunk-DISC5OYC.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';

package/build/index.js

@@ -1,310 +1,24 @@
-// configure.ts
-import string from "@poppinss/utils/string";
-
-// stubs/main.ts
-import { getDirname } from "@poppinss/utils";
-var stubsRoot = getDirname(import.meta.url);
-
-// configure.ts
-var ADAPTERS = ["vue", "react", "svelte", "solid"];
-var ADAPTERS_INFO = {
-  vue: {
-    stubFolder: "vue",
-    appExtension: "ts",
-    componentsExtension: "vue",
-    dependencies: [
-      { name: "@inertiajs/vue3", isDevDependency: false },
-      { name: "vue", isDevDependency: false },
-      { name: "@vitejs/plugin-vue", isDevDependency: true }
-    ],
-    ssrDependencies: [{ name: "@vue/server-renderer", isDevDependency: false }],
-    viteRegister: {
-      pluginCall: "vue()",
-      importDeclarations: [{ isNamed: false, module: "@vitejs/plugin-vue", identifier: "vue" }]
-    },
-    ssrEntrypoint: "inertia/app/ssr.ts"
-  },
-  react: {
-    stubFolder: "react",
-    appExtension: "tsx",
-    componentsExtension: "tsx",
-    dependencies: [
-      { name: "@inertiajs/react", isDevDependency: false },
-      { name: "react", isDevDependency: false },
-      { name: "react-dom", isDevDependency: false },
-      { name: "@vitejs/plugin-react", isDevDependency: true },
-      { name: "@types/react", isDevDependency: true },
-      { name: "@types/react-dom", isDevDependency: true }
-    ],
-    viteRegister: {
-      pluginCall: "react()",
-      importDeclarations: [{ isNamed: false, module: "@vitejs/plugin-react", identifier: "react" }]
-    },
-    ssrEntrypoint: "inertia/app/ssr.tsx"
-  },
-  svelte: {
-    stubFolder: "svelte",
-    appExtension: "ts",
-    componentsExtension: "svelte",
-    dependencies: [
-      { name: "@inertiajs/svelte", isDevDependency: false },
-      { name: "svelte", isDevDependency: false },
-      { name: "@sveltejs/vite-plugin-svelte", isDevDependency: true }
-    ],
-    viteRegister: {
-      pluginCall: "svelte()",
-      ssrPluginCall: "svelte({ compilerOptions: { hydratable: true } })",
-      importDeclarations: [
-        { isNamed: true, module: "@sveltejs/vite-plugin-svelte", identifier: "svelte" }
-      ]
-    },
-    ssrEntrypoint: "inertia/app/ssr.ts"
-  },
-  solid: {
-    stubFolder: "solid",
-    appExtension: "tsx",
-    componentsExtension: "tsx",
-    dependencies: [
-      { name: "solid-js", isDevDependency: false },
-      { name: "inertia-adapter-solid", isDevDependency: false },
-      { name: "vite-plugin-solid", isDevDependency: true },
-      { name: "@solidjs/meta", isDevDependency: false }
-    ],
-    viteRegister: {
-      pluginCall: "solid()",
-      ssrPluginCall: "solid({ ssr: true })",
-      importDeclarations: [{ isNamed: false, module: "vite-plugin-solid", identifier: "solid" }]
-    },
-    ssrEntrypoint: "inertia/app/ssr.tsx"
-  }
-};
-async function defineExampleRoute(command, codemods) {
-  const tsMorph = await codemods.getTsMorphProject();
-  const routesFile = tsMorph?.getSourceFile(command.app.makePath("./start/routes.ts"));
-  if (!routesFile) {
-    return command.logger.warning("Unable to find the routes file");
-  }
-  const action = command.logger.action("update start/routes.ts file");
-  try {
-    routesFile?.addStatements((writer) => {
-      writer.writeLine(`router.on('/').renderInertia('home')`);
-    });
-    await tsMorph?.save();
-    action.succeeded();
-  } catch (error) {
-    codemods.emit("error", error);
-    action.failed(error.message);
-  }
-}
-async function configure(command) {
-  let adapter = command.parsedFlags.adapter;
-  let ssr = command.parsedFlags.ssr;
-  let shouldInstallPackages = command.parsedFlags.install;
-  let shouldSkipExampleRoute = command.parsedFlags["skip-example-route"];
-  if (adapter === void 0) {
-    adapter = await command.prompt.choice(
-      "Select the Inertia adapter you want to use",
-      ADAPTERS.map((adapterName) => string.capitalCase(adapterName)),
-      { name: "adapter", result: (value) => value.toLowerCase() }
-    );
-  }
-  if (ssr === void 0) {
-    ssr = await command.prompt.confirm("Do you want to use server-side rendering?", {
-      name: "ssr"
-    });
-  }
-  if (adapter in ADAPTERS_INFO === false) {
-    command.logger.error(
-      `The selected adapter "${adapter}" is invalid. Select one from: ${string.sentence(
-        Object.keys(ADAPTERS_INFO)
-      )}`
-    );
-    command.exitCode = 1;
-    return;
-  }
-  const adapterInfo = ADAPTERS_INFO[adapter];
-  const codemods = await command.createCodemods();
-  await codemods.updateRcFile((rcFile) => {
-    rcFile.addProvider("@adonisjs/inertia/inertia_provider");
-  });
-  await codemods.registerMiddleware("server", [
-    { path: "@adonisjs/inertia/inertia_middleware", position: "after" }
-  ]);
-  const appExt = adapterInfo.appExtension;
-  const stubFolder = adapterInfo.stubFolder;
-  const compExt = adapterInfo.componentsExtension;
-  await codemods.makeUsingStub(stubsRoot, "config.stub", {
-    ssr,
-    ssrEntrypoint: adapterInfo.ssrEntrypoint
-  });
-  await codemods.makeUsingStub(stubsRoot, `app.css.stub`, {});
-  await codemods.makeUsingStub(stubsRoot, `${stubFolder}/root.edge.stub`, {});
-  await codemods.makeUsingStub(stubsRoot, `${stubFolder}/tsconfig.json.stub`, {});
-  await codemods.makeUsingStub(stubsRoot, `${stubFolder}/app.${appExt}.stub`, { ssr });
-  await codemods.makeUsingStub(stubsRoot, `${stubFolder}/home.${compExt}.stub`, {});
-  await codemods.makeUsingStub(stubsRoot, `${stubFolder}/errors/not_found.${compExt}.stub`, {});
-  await codemods.makeUsingStub(stubsRoot, `${stubFolder}/errors/server_error.${compExt}.stub`, {});
-  if (ssr) {
-    await codemods.makeUsingStub(stubsRoot, `${stubFolder}/ssr.${appExt}.stub`, {});
-  }
-  const inertiaPluginCall = ssr ? `inertia({ ssr: { enabled: true, entrypoint: 'inertia/app/ssr.${appExt}' } })` : `inertia({ ssr: { enabled: false } })`;
-  await codemods.registerVitePlugin(inertiaPluginCall, [
-    { isNamed: false, module: "@adonisjs/inertia/client", identifier: "inertia" }
-  ]);
-  await codemods.registerVitePlugin(
-    ssr && adapterInfo.viteRegister.ssrPluginCall ? adapterInfo.viteRegister.ssrPluginCall : adapterInfo.viteRegister.pluginCall,
-    adapterInfo.viteRegister.importDeclarations
-  );
-  const adonisjsPluginCall = `adonisjs({ entrypoints: ['inertia/app/app.${appExt}'], reload: ['resources/views/**/*.edge'] })`;
-  await codemods.registerVitePlugin(adonisjsPluginCall, [
-    { isNamed: false, module: "@adonisjs/vite/client", identifier: "adonisjs" }
-  ]);
-  if (shouldSkipExampleRoute !== true) {
-    await defineExampleRoute(command, codemods);
-  }
-  const pkgToInstall = adapterInfo.dependencies;
-  if (ssr && adapterInfo.ssrDependencies) {
-    pkgToInstall.push(...adapterInfo.ssrDependencies);
-  }
-  if (shouldInstallPackages === void 0) {
-    shouldInstallPackages = await command.prompt.confirm(
-      `Do you want to install dependencies ${pkgToInstall.map((pkg) => pkg.name).join(", ")}?`,
-      { name: "install" }
-    );
-  }
-  if (shouldInstallPackages) {
-    await codemods.installPackages(pkgToInstall);
-  } else {
-    await codemods.listPackagesToInstall(pkgToInstall);
-  }
-}
-
-// src/define_config.ts
-import { slash } from "@poppinss/utils";
-import { configProvider } from "@adonisjs/core";
-
-// src/version_cache.ts
-import { createHash } from "crypto";
-import { readFile } from "fs/promises";
-var VersionCache = class {
-  constructor(appRoot, assetsVersion) {
-    this.appRoot = appRoot;
-    this.assetsVersion = assetsVersion;
-    this.#cachedVersion = assetsVersion;
-  }
-  #cachedVersion;
-  /**
-   * Compute the hash of the manifest file and cache it
-   */
-  async #getManifestHash() {
-    try {
-      const manifestPath = new URL("public/assets/.vite/manifest.json", this.appRoot);
-      const manifestFile = await readFile(manifestPath, "utf-8");
-      this.#cachedVersion = createHash("md5").update(manifestFile).digest("hex");
-      return this.#cachedVersion;
-    } catch {
-      this.#cachedVersion = "1";
-      return this.#cachedVersion;
-    }
-  }
-  /**
-   * Pre-compute the version
-   */
-  async computeVersion() {
-    if (!this.assetsVersion) await this.#getManifestHash();
-    return this;
-  }
-  /**
-   * Returns the current assets version
-   */
-  getVersion() {
-    if (!this.#cachedVersion) throw new Error("Version has not been computed yet");
-    return this.#cachedVersion;
-  }
-  /**
-   * Set the assets version
-   */
-  async setVersion(version) {
-    this.#cachedVersion = version;
-  }
-};
-
-// src/files_detector.ts
-import { locatePath } from "locate-path";
-var FilesDetector = class {
-  constructor(app) {
-    this.app = app;
-  }
-  /**
-   * Try to locate the entrypoint file based
-   * on the conventional locations
-   */
-  async detectEntrypoint(defaultPath) {
-    const possiblesLocations = [
-      "./inertia/app/app.ts",
-      "./inertia/app/app.tsx",
-      "./resources/app.ts",
-      "./resources/app.tsx",
-      "./resources/app.jsx",
-      "./resources/app.js",
-      "./inertia/app/app.jsx"
-    ];
-    const path = await locatePath(possiblesLocations, { cwd: this.app.appRoot });
-    return this.app.makePath(path || defaultPath);
-  }
-  /**
-   * Try to locate the SSR entrypoint file based
-   * on the conventional locations
-   */
-  async detectSsrEntrypoint(defaultPath) {
-    const possiblesLocations = [
-      "./inertia/app/ssr.ts",
-      "./inertia/app/ssr.tsx",
-      "./resources/ssr.ts",
-      "./resources/ssr.tsx",
-      "./resources/ssr.jsx",
-      "./resources/ssr.js",
-      "./inertia/app/ssr.jsx"
-    ];
-    const path = await locatePath(possiblesLocations, { cwd: this.app.appRoot });
-    return this.app.makePath(path || defaultPath);
-  }
-  /**
-   * Try to locate the SSR bundle file based
-   * on the conventional locations
-   */
-  async detectSsrBundle(defaultPath) {
-    const possiblesLocations = ["./ssr/ssr.js", "./ssr/ssr.mjs"];
-    const path = await locatePath(possiblesLocations, { cwd: this.app.appRoot });
-    return this.app.makePath(path || defaultPath);
-  }
-};
-
-// src/define_config.ts
-function defineConfig(config) {
-  return configProvider.create(async (app) => {
-    const detector = new FilesDetector(app);
-    const versionCache = new VersionCache(app.appRoot, config.assetsVersion);
-    await versionCache.computeVersion();
-    return {
-      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")
-      ),
-      ssr: {
-        enabled: config.ssr?.enabled ?? false,
-        pages: config.ssr?.pages,
-        entrypoint: config.ssr?.entrypoint ?? await detector.detectSsrEntrypoint("inertia/app/ssr.ts"),
-        bundle: config.ssr?.bundle ?? await detector.detectSsrBundle("ssr/ssr.js")
-      }
-    };
-  });
-}
+import {
+  defineConfig,
+  indexPages
+} from "./chunk-5QRJHXXQ.js";
+import {
+  Inertia,
+  InertiaManager,
+  ServerRenderer,
+  symbols_exports
+} from "./chunk-YQ72YL64.js";
+import "./chunk-4EZ2J6OA.js";
+import {
+  InertiaHeaders
+} from "./chunk-DISC5OYC.js";
+import "./chunk-MLKGABMK.js";
 export {
-  configure,
+  Inertia,
+  InertiaHeaders,
+  InertiaManager,
+  ServerRenderer,
   defineConfig,
-  stubsRoot
+  indexPages,
+  symbols_exports as symbols
 };