@adonisjs/inertia 1.0.0-0 → 1.0.0-1

package/build/chunk-TO74VVAR.js

@@ -0,0 +1,123 @@
+// src/inertia.ts
+var kLazySymbol = Symbol("lazy");
+var Inertia = class {
+  constructor(ctx, config) {
+    this.ctx = ctx;
+    this.config = config;
+  }
+  /**
+   * 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.config.sharedData, ...pageProps }),
+      url: this.ctx.request.url(true)
+    };
+  }
+  /**
+   * Render a page using Inertia
+   */
+  async render(component, pageProps) {
+    const pageObject = await this.#buildPageObject(component, pageProps);
+    const isInertiaRequest = !!this.ctx.request.header("x-inertia");
+    if (!isInertiaRequest) {
+      return this.ctx.view.render(this.config.rootView, { page: pageObject });
+    }
+    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) {
+    this.config = config;
+  }
+  async handle(ctx, next) {
+    const { response, request } = ctx;
+    ctx.inertia = new Inertia(ctx, this.config);
+    await next();
+    const isInertiaRequest = !!request.header("x-inertia");
+    if (!isInertiaRequest)
+      return;
+    response.header("Vary", "Accept");
+    response.header("X-Inertia", "true");
+    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,3 +1,18 @@
-export { configure } from './configure.js';
-export { stubsRoot } from './stubs/main.js';
-export { defineConfig } from './src/define_config.js';
+import Configure from '@adonisjs/core/commands/configure';
+import { ConfigProvider } from '@adonisjs/core/types';
+import { InertiaConfig, ResolvedConfig } from './src/types.js';
+import '@adonisjs/core/http';
+
+/**
+ * Configures the package
+ */
+declare function configure(command: Configure): Promise<void>;
+
+declare const stubsRoot: string;
+
+/**
+ * Define the Inertia configuration
+ */
+declare function defineConfig(config: InertiaConfig): ConfigProvider<ResolvedConfig>;
+
+export { configure, defineConfig, stubsRoot };

package/build/index.js

@@ -1,11 +1,135 @@
-/*
- * @adonisjs/inertia
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-export { configure } from './configure.js';
-export { stubsRoot } from './stubs/main.js';
-export { defineConfig } from './src/define_config.js';
+// configure.ts
+var ADAPTERS = ["Vue 3", "React", "Svelte"];
+var ADAPTERS_INFO = {
+  "Vue 3": {
+    dependencies: [
+      { name: "@inertiajs/vue3", isDevDependency: false },
+      { name: "vue", isDevDependency: false },
+      { name: "@vitejs/plugin-vue", isDevDependency: true }
+    ]
+  },
+  "React": {
+    dependencies: [
+      { name: "@inertiajs/inertia-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 }
+    ]
+  },
+  "Svelte": {
+    dependencies: [
+      { name: "@inertiajs/inertia-svelte", isDevDependency: false },
+      { name: "svelte", isDevDependency: false },
+      { name: "@sveltejs/vite-plugin-svelte", isDevDependency: true }
+    ]
+  }
+};
+async function configure(command) {
+  const adapter = await command.prompt.choice(
+    "Select the Inertia adapter you want to use",
+    ADAPTERS,
+    { name: "adapter" }
+  );
+  const pkgToInstall = ADAPTERS_INFO[adapter].dependencies;
+  const withSsr = await command.prompt.confirm("Do you want to enable server-side rendering?", {
+    name: "ssr"
+  });
+  if (withSsr) {
+    pkgToInstall.push(...ADAPTERS_INFO[adapter].ssrDependencies || []);
+  }
+  const codemods = await command.createCodemods();
+  await codemods.updateRcFile((rcFile) => {
+    rcFile.addProvider("@adonisjs/inertia/inertia_provider");
+  });
+  codemods.registerMiddleware("router", [
+    { path: "@adonisjs/inertia/inertia_middleware", position: "after" }
+  ]);
+  await command.publishStub("config.stub");
+  const shouldInstallPackages = await command.prompt.confirm(
+    `Do you want to install dependencies ${pkgToInstall.map((pkg) => pkg.name).join(", ")}?`,
+    { name: "install" }
+  );
+  if (shouldInstallPackages) {
+    command.installPackages(pkgToInstall);
+  } else {
+    command.listPackagesToInstall(pkgToInstall);
+  }
+  command.logger.success(
+    "Inertia was configured successfully. Please note that you still need to update your vite config, setup your Edge root view and others things. Read the docs for more info."
+  );
+}
+
+// stubs/main.ts
+import { getDirname } from "@poppinss/utils";
+var stubsRoot = getDirname(import.meta.url);
+
+// src/define_config.ts
+import { configProvider } from "@adonisjs/core";
+
+// src/version_cache.ts
+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 crc32 = await import("crc-32");
+      const manifestPath = new URL("public/assets/manifest.json", this.appRoot);
+      const manifestFile = await readFile(manifestPath, "utf-8");
+      this.#cachedVersion = crc32.default.str(manifestFile);
+      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/define_config.ts
+function defineConfig(config) {
+  return configProvider.create(async (app) => {
+    const versionCache = new VersionCache(app.appRoot, config.assetsVersion);
+    await versionCache.computeVersion();
+    return {
+      rootView: config.rootView ?? "root",
+      sharedData: config.sharedData || {},
+      versionCache
+    };
+  });
+}
+export {
+  configure,
+  defineConfig,
+  stubsRoot
+};

package/build/providers/inertia_provider.d.ts

@@ -1,17 +1,9 @@
-import type { ApplicationService } from '@adonisjs/core/types';
-import { Inertia } from '../src/inertia.js';
-/**
- * HttpContext augmentations
- */
-declare module '@adonisjs/core/http' {
-    interface HttpContext {
-        inertia: Inertia;
-    }
-}
+import { ApplicationService } from '@adonisjs/core/types';
+
 /**
  * Inertia provider
  */
-export default class InertiaProvider {
+declare class InertiaProvider {
     protected app: ApplicationService;
     constructor(app: ApplicationService);
     /**
@@ -19,8 +11,9 @@ export default class InertiaProvider {
      */
     protected registerEdgePlugin(): Promise<void>;
     /**
-     * Register Inertia middleware, edge plugin, and add
-     * `inertia` property to the HttpContext
+     * Register Inertia bindings
      */
-    boot(): Promise<void>;
+    register(): Promise<void>;
 }
+
+export { InertiaProvider as default };

package/build/providers/inertia_provider.js

@@ -1,46 +1,40 @@
-/*
- * @adonisjs/inertia
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { HttpContext } from '@adonisjs/core/http';
-import { Inertia } from '../src/inertia.js';
-import { VersionCache } from '../src/version_cache.js';
-import InertiaMiddleware from '../src/inertia_middleware.js';
-/**
- * Inertia provider
- */
-export default class InertiaProvider {
-    app;
-    constructor(app) {
-        this.app = app;
+import {
+  InertiaMiddleware
+} from "../chunk-TO74VVAR.js";
+
+// providers/inertia_provider.ts
+import { configProvider } from "@adonisjs/core";
+import { RuntimeException } from "@poppinss/utils";
+var InertiaProvider = class {
+  constructor(app) {
+    this.app = app;
+  }
+  /**
+   * Registers edge plugin when edge is installed
+   */
+  async registerEdgePlugin() {
+    try {
+      const edgeExports = await import("edge.js");
+      const { edgePluginInertia } = await import("../src/plugins/edge.js");
+      edgeExports.default.use(edgePluginInertia());
+    } catch {
     }
-    /**
-     * Registers edge plugin when edge is installed
-     */
-    async registerEdgePlugin() {
-        try {
-            const edgeExports = await import('edge.js');
-            const { edgePluginInertia } = await import('../src/plugins/edge.js');
-            edgeExports.default.use(edgePluginInertia());
-        }
-        catch { }
+  }
+  /**
+   * Register Inertia bindings
+   */
+  async register() {
+    const inertiaConfigProvider = this.app.config.get("inertia");
+    const config = await configProvider.resolve(this.app, inertiaConfigProvider);
+    if (!config) {
+      throw new RuntimeException(
+        'Invalid "config/inertia.ts" file. Make sure you are using the "defineConfig" method'
+      );
     }
-    /**
-     * Register Inertia middleware, edge plugin, and add
-     * `inertia` property to the HttpContext
-     */
-    async boot() {
-        const appRoot = this.app.appRoot;
-        const config = this.app.config.get('inertia', { view: 'app' });
-        const versionCache = await new VersionCache(appRoot, config.assetsVersion).computeVersion();
-        this.app.container.singleton(InertiaMiddleware, () => new InertiaMiddleware(versionCache));
-        HttpContext.getter('inertia', function inertia() {
-            return new Inertia(this, config, versionCache.getVersion());
-        }, false);
-        await this.registerEdgePlugin();
-    }
-}
+    this.app.container.singleton(InertiaMiddleware, () => new InertiaMiddleware(config));
+    await this.registerEdgePlugin();
+  }
+};
+export {
+  InertiaProvider as default
+};

package/build/src/inertia_middleware.d.ts

@@ -1,12 +1,64 @@
-import type { HttpContext } from '@adonisjs/core/http';
-import type { NextFn } from '@adonisjs/core/types/http';
-import type { VersionCache } from './version_cache.js';
+import { HttpContext } from '@adonisjs/core/http';
+import { NextFn } from '@adonisjs/core/types/http';
+import { ResolvedConfig, PageProps, MaybePromise } from './types.js';
+
+/**
+ * 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;
+    constructor(ctx: HttpContext, config: ResolvedConfig);
+    /**
+     * Render a page using Inertia
+     */
+    render<T extends PageProps>(component: string, pageProps?: T): Promise<string | {
+        component: string;
+        version: string | number;
+        props: any;
+        url: string;
+    }>;
+    /**
+     * 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: () => MaybePromise<any>): {
+        [kLazySymbol]: () => MaybePromise<any>;
+    };
+    /**
+     * 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
+ */
+declare module '@adonisjs/core/http' {
+    interface HttpContext {
+        inertia: Inertia;
+    }
+}
 /**
  * Inertia middleware to handle the Inertia requests and
  * set appropriate headers/status
  */
-export default class InertiaMiddleware {
-    protected version: VersionCache;
-    constructor(version: VersionCache);
-    handle({ request, response }: HttpContext, next: NextFn): Promise<void>;
+declare class InertiaMiddleware {
+    protected config: ResolvedConfig;
+    constructor(config: ResolvedConfig);
+    handle(ctx: HttpContext, next: NextFn): Promise<void>;
 }
+
+export { InertiaMiddleware as default };

package/build/src/inertia_middleware.js

@@ -1,47 +1,6 @@
-/*
- * @adonisjs/inertia
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-/**
- * Inertia middleware to handle the Inertia requests and
- * set appropriate headers/status
- */
-export default class InertiaMiddleware {
-    version;
-    constructor(version) {
-        this.version = version;
-    }
-    async handle({ request, response }, next) {
-        await next();
-        const isInertiaRequest = !!request.header('x-inertia');
-        if (!isInertiaRequest)
-            return;
-        response.header('Vary', 'Accept');
-        response.header('X-Inertia', 'true');
-        /**
-         * When redirecting a PUT/PATCH/DELETE request, we need to change the
-         * we must use a 303 status code instead of a 302 to force
-         * the browser to use a GET request after redirecting.
-         *
-         * See https://inertiajs.com/redirects
-         */
-        const method = request.method();
-        if (response.getStatus() === 302 && ['PUT', 'PATCH', 'DELETE'].includes(method)) {
-            response.status(303);
-        }
-        /**
-         * Handle version change
-         *
-         * See https://inertiajs.com/the-protocol#asset-versioning
-         */
-        const version = this.version.getVersion();
-        if (method === 'GET' && request.header('x-inertia-version', '') !== version) {
-            response.header('x-inertia-location', request.url());
-            response.status(409);
-        }
-    }
-}
+import {
+  InertiaMiddleware
+} from "../chunk-TO74VVAR.js";
+export {
+  InertiaMiddleware as default
+};

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

@@ -1,5 +1,8 @@
-import type { PluginFn } from '@japa/runner/types';
-import type { PageProps } from '../types.js';
+import { PluginFn } from '@japa/runner/types';
+import { PageProps } from '../types.js';
+import { ApplicationService } from '@adonisjs/core/types';
+import '@adonisjs/core/http';
+
 declare module '@japa/api-client' {
     interface ApiRequest {
         /**
@@ -19,7 +22,7 @@ declare module '@japa/api-client' {
         /**
          * The inertia response props
          */
-        inertiaProps: PageProps;
+        inertiaProps: Record<string, any>;
         /**
          * Assert component name of inertia response
          */
@@ -34,4 +37,6 @@ declare module '@japa/api-client' {
         assertInertiaPropsContains(props: PageProps): this;
     }
 }
-export declare function inertiaApiClient(): PluginFn;
+declare function inertiaApiClient(app: ApplicationService): PluginFn;
+
+export { inertiaApiClient };