@adonisjs/inertia 3.1.1 → 4.0.0-next.1

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 "node:crypto";
-import { readFile } from "node: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-PDP56GPP.js";
+import {
+  Inertia,
+  InertiaManager,
+  ServerRenderer,
+  symbols_exports
+} from "./chunk-74S2VAL7.js";
+import {
+  InertiaHeaders
+} from "./chunk-DISC5OYC.js";
+import "./chunk-4EZ2J6OA.js";
+import "./chunk-MLKGABMK.js";
 export {
-  configure,
+  Inertia,
+  InertiaHeaders,
+  InertiaManager,
+  ServerRenderer,
   defineConfig,
-  stubsRoot
+  indexPages,
+  symbols_exports as symbols
 };

package/build/providers/inertia_provider.d.ts

@@ -1,33 +1,106 @@
-import { Route } from '@adonisjs/core/http';
-import { ApplicationService } from '@adonisjs/core/types';
-
+import { type Route } from '@adonisjs/core/http';
+import type { ApplicationService } from '@adonisjs/core/types';
+import type { AsPageProps, InertiaPages } from '../src/types.js';
 declare module '@adonisjs/core/http' {
     interface BriskRoute {
         /**
-         * Render an inertia page without defining an
-         * explicit route handler
+         * Render an inertia page without defining an explicit route handler
+         *
+         * This method allows you to render Inertia pages directly from route definitions
+         * without creating separate controller methods.
+         *
+         * @param component - The name of the Inertia component to render
+         * @param props - Props to pass to the component
+         * @param viewProps - Additional props to pass to the root view template
+         * @returns The route instance for method chaining
+         *
+         * @example
+         * ```js
+         * // Basic usage
+         * router.get('/dashboard', []).renderInertia('Dashboard', {
+         *   user: auth.user
+         * })
+         *
+         * // With view props
+         * router.get('/home', []).renderInertia('Home', {
+         *   posts: posts
+         * }, {
+         *   title: 'Welcome Home'
+         * })
+         * ```
          */
-        renderInertia(component: string, props?: Record<string, any>, viewProps?: Record<string, any>): Route;
+        renderInertia<Page extends keyof InertiaPages>(component: Page, props: AsPageProps<InertiaPages[Page]>, viewProps?: Record<string, any>): Route;
     }
 }
 /**
- * Inertia provider
+ * AdonisJS service provider for Inertia.js integration
+ *
+ * This provider handles the registration and configuration of Inertia.js
+ * within an AdonisJS application. It sets up the middleware, Edge.js plugin,
+ * and route macros needed for Inertia functionality.
+ *
+ * @example
+ * ```js
+ * // Automatically registered when package is installed
+ * // Configuration in config/inertia.ts:
+ *
+ * import { defineConfig } from '@adonisjs/inertia'
+ *
+ * export default defineConfig({
+ *   rootView: 'inertia_layout',
+ *   ssr: { enabled: true }
+ * })
+ * ```
  */
-declare class InertiaProvider {
+export default class InertiaProvider {
     protected app: ApplicationService;
+    /**
+     * Creates a new InertiaProvider instance
+     *
+     * @param app - The AdonisJS application service instance
+     */
     constructor(app: ApplicationService);
     /**
-     * Registers edge plugin when edge is installed
+     * Registers the Inertia Edge.js plugin when Edge.js is available
+     *
+     * This method conditionally registers the Edge plugin that provides
+     * @inertia and @inertiaHead tags for rendering Inertia pages.
+     *
+     * @example
+     * ```edge
+     * {{-- Templates can then use --}}
+     * @inertia(page)
+     * @inertiaHead(page)
+     * ```
      */
     protected registerEdgePlugin(): Promise<void>;
     /**
-     * Register inertia middleware
+     * Registers the InertiaManager as a singleton in the IoC container
+     *
+     * This method sets up the core Inertia manager with the application's
+     * configuration and Vite integration. The manager handles page rendering,
+     * asset management, and SSR functionality.
+     *
+     * @example
+     * ```js
+     * // The manager is automatically available for injection:
+     * const inertiaManager = await app.container.make(InertiaManager)
+     * ```
      */
     register(): Promise<void>;
     /**
-     * Register edge plugin and brisk route macro
+     * Boot the provider by registering Edge plugin and route macros
+     *
+     * This method completes the Inertia setup by registering the Edge plugin
+     * and adding the renderInertia macro to BriskRoute for convenient route definitions.
+     *
+     * @example
+     * ```js
+     * // Routes can now use the renderInertia macro
+     * router.get('/dashboard', []).renderInertia('Dashboard', {
+     *   user: getCurrentUser()
+     * })
+     * ```
      */
     boot(): Promise<void>;
 }
-
-export { InertiaProvider as default };

package/build/providers/inertia_provider.js

@@ -1,42 +1,72 @@
 import {
-  InertiaMiddleware
-} from "../chunk-W7TVEB4V.js";
+  InertiaManager
+} from "../chunk-74S2VAL7.js";
+import "../chunk-DISC5OYC.js";
+import "../chunk-4EZ2J6OA.js";
+import "../chunk-MLKGABMK.js";
 
 // providers/inertia_provider.ts
-import { configProvider } from "@adonisjs/core";
-import { RuntimeException } from "@poppinss/utils";
 import { BriskRoute } from "@adonisjs/core/http";
 var InertiaProvider = class {
+  /**
+   * Creates a new InertiaProvider instance
+   *
+   * @param app - The AdonisJS application service instance
+   */
   constructor(app) {
     this.app = app;
   }
   /**
-   * Registers edge plugin when edge is installed
+   * Registers the Inertia Edge.js plugin when Edge.js is available
+   *
+   * This method conditionally registers the Edge plugin that provides
+   * @inertia and @inertiaHead tags for rendering Inertia pages.
+   *
+   * @example
+   * ```edge
+   * {{-- Templates can then use --}}
+   * @inertia(page)
+   * @inertiaHead(page)
+   * ```
    */
   async registerEdgePlugin() {
-    if (!this.app.usingEdgeJS) return;
     const edgeExports = await import("edge.js");
     const { edgePluginInertia } = await import("../src/plugins/edge/plugin.js");
     edgeExports.default.use(edgePluginInertia());
   }
   /**
-   * Register inertia middleware
+   * Registers the InertiaManager as a singleton in the IoC container
+   *
+   * This method sets up the core Inertia manager with the application's
+   * configuration and Vite integration. The manager handles page rendering,
+   * asset management, and SSR functionality.
+   *
+   * @example
+   * ```js
+   * // The manager is automatically available for injection:
+   * const inertiaManager = await app.container.make(InertiaManager)
+   * ```
    */
   async register() {
-    this.app.container.singleton(InertiaMiddleware, async () => {
-      const inertiaConfigProvider = this.app.config.get("inertia");
-      const config = await configProvider.resolve(this.app, inertiaConfigProvider);
-      const vite = await this.app.container.make("vite");
-      if (!config) {
-        throw new RuntimeException(
-          'Invalid "config/inertia.ts" file. Make sure you are using the "defineConfig" method'
-        );
-      }
-      return new InertiaMiddleware(config, vite);
+    this.app.container.singleton(InertiaManager, async (resolver) => {
+      const config = this.app.config.get("inertia", {});
+      const vite = await resolver.make("vite");
+      return new InertiaManager(config, vite);
     });
   }
   /**
-   * Register edge plugin and brisk route macro
+   * Boot the provider by registering Edge plugin and route macros
+   *
+   * This method completes the Inertia setup by registering the Edge plugin
+   * and adding the renderInertia macro to BriskRoute for convenient route definitions.
+   *
+   * @example
+   * ```js
+   * // Routes can now use the renderInertia macro
+   * router.get('/dashboard', []).renderInertia('Dashboard', {
+   *   user: getCurrentUser()
+   * })
+   * ```
    */
   async boot() {
     await this.registerEdgePlugin();

package/build/src/client/vite.d.ts

@@ -0,0 +1,63 @@
+import type { PluginOption } from 'vite';
+/**
+ * Configuration options for the Inertia Vite plugin
+ */
+export type InertiaPluginOptions = {
+    /**
+     * Server-side rendering configuration
+     */
+    ssr?: {
+        /**
+         * Whether or not to enable server-side rendering
+         */
+        enabled: true;
+        /**
+         * The entrypoint for the server-side rendering
+         */
+        entrypoint: string;
+        /**
+         * The output directory for the server-side rendering bundle
+         */
+        output?: string;
+    } | {
+        enabled: false;
+    };
+};
+/**
+ * Inertia plugin for Vite that is tailored for AdonisJS
+ *
+ * Configures Vite for Inertia.js development with proper build settings,
+ * SSR support, and AdonisJS-specific optimizations.
+ *
+ * @param options - Configuration options for the plugin
+ * @returns Vite plugin configuration object
+ *
+ * @example
+ * ```js
+ * // Basic configuration
+ * import inertia from '@adonisjs/inertia/plugins/vite'
+ *
+ * export default defineConfig({
+ *   plugins: [inertia()]
+ * })
+ * ```
+ *
+ * @example
+ * ```js
+ * // With SSR enabled
+ * import inertia from '@adonisjs/inertia/plugins/vite'
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     inertia({
+ *       ssr: {
+ *         enabled: true,
+ *         entrypoint: 'inertia/app/ssr.ts',
+ *         output: 'build/ssr'
+ *       }
+ *     })
+ *   ]
+ * })
+ * ```
+ */
+export default function inertia(options?: InertiaPluginOptions): PluginOption;

package/build/src/{plugins → client}/vite.js

@@ -1,23 +1,19 @@
-// src/plugins/vite.ts
+import "../../chunk-MLKGABMK.js";
+
+// src/client/vite.ts
 function inertia(options) {
   return {
     name: "vite-plugin-inertia",
     config: (_, { command }) => {
-      if (!options?.ssr?.enabled) return {};
       if (command === "build") {
         process.env.NODE_ENV = "production";
       }
       return {
-        buildSteps: [
-          {
-            name: "build-client",
-            description: "build inertia client bundle",
-            config: { build: { outDir: "build/public/assets/" } }
-          },
-          {
-            name: "build-ssr",
-            description: "build inertia server bundle",
-            config: {
+        builder: {},
+        build: { outDir: "build/public/assets" },
+        environments: {
+          ...options?.ssr?.enabled && {
+            ssr: {
               build: {
                 ssr: true,
                 outDir: options.ssr.output || "build/ssr",
@@ -25,7 +21,7 @@ function inertia(options) {
               }
             }
           }
-        ]
+        }
       };
     }
   };

package/build/src/debug.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Debug logger for Inertia.js package
+ *
+ * Provides debugging functionality using Node.js built-in debuglog.
+ * Enable debugging by setting the NODE_DEBUG environment variable to 'adonisjs:inertia'.
+ *
+ * @example
+ * ```js
+ * import debug from './debug.js'
+ *
+ * debug('Processing Inertia request')
+ * debug('Component: %s, Props: %o', componentName, props)
+ * ```
+ *
+ * @example
+ * ```bash
+ * # Enable debugging
+ * NODE_DEBUG=adonisjs:inertia node server.js
+ * ```
+ */
+declare const _default: import("util").DebugLogger;
+export default _default;