@hono/vite-build 1.3.0 → 1.4.0

package/README.md

@@ -38,6 +38,7 @@ import build from '@hono/vite-build/bun'
 // import build from '@hono/vite-build/cloudflare-workers'
 // import build from '@hono/vite-build/node'
 // import build from '@hono/vite-build/netlify-functions'
+// import build from '@hono/vite-build/vercel'
 
 export default defineConfig({
   plugins: [

package/dist/adapter/vercel/index.d.ts

@@ -0,0 +1,14 @@
+import { Plugin } from 'vite';
+import { BuildOptions } from '../../base.js';
+import { VercelBuildConfigV3, VercelServerlessFunctionConfig } from './types.js';
+import '../../entry/index.js';
+
+type VercelBuildOptions = {
+    vercel?: {
+        config?: VercelBuildConfigV3;
+        function?: VercelServerlessFunctionConfig;
+    };
+} & Omit<BuildOptions, 'output' | 'outputDir'>;
+declare const vercelBuildPlugin: (pluginOptions?: VercelBuildOptions) => Plugin;
+
+export { VercelBuildOptions, vercelBuildPlugin as default };

package/dist/adapter/vercel/index.js

@@ -0,0 +1,85 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { cp, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import buildPlugin from "../../base.js";
+const BUNDLE_NAME = "index.js";
+const FUNCTION_NAME = "__hono";
+const writeJSON = (path, data) => {
+  const dir = resolve(path, "..");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return writeFile(path, JSON.stringify(data));
+};
+const getRuntimeVersion = () => {
+  try {
+    const systemNodeVersion = process.versions.node.split(".")[0];
+    return `nodejs${Number(systemNodeVersion)}.x`;
+  } catch {
+    return "nodejs22.x";
+  }
+};
+const vercelBuildPlugin = (pluginOptions) => {
+  let config;
+  return {
+    ...buildPlugin({
+      output: `functions/${FUNCTION_NAME}.func/${BUNDLE_NAME}`,
+      outputDir: ".vercel/output",
+      ...{
+        entryContentAfterHooks: [
+          // eslint-disable-next-line quotes
+          () => "import { handle } from '@hono/node-server/vercel'"
+        ],
+        entryContentDefaultExportHook: (appName) => `export default handle(${appName})`
+      },
+      ...pluginOptions
+    }),
+    configResolved: (resolvedConfig) => {
+      config = resolvedConfig;
+    },
+    writeBundle: async () => {
+      const outputDir = resolve(config.root, config.build.outDir);
+      const functionDir = resolve(outputDir, "functions", `${FUNCTION_NAME}.func`);
+      const buildConfig = {
+        ...pluginOptions?.vercel?.config,
+        version: 3,
+        routes: [
+          ...pluginOptions?.vercel?.config?.routes ?? [],
+          {
+            handle: "filesystem"
+          },
+          {
+            src: "/(.*)",
+            dest: `/${FUNCTION_NAME}`
+          }
+        ]
+      };
+      const functionConfig = {
+        ...pluginOptions?.vercel?.function,
+        runtime: getRuntimeVersion(),
+        launcherType: "Nodejs",
+        handler: BUNDLE_NAME,
+        shouldAddHelpers: true,
+        shouldAddSourcemapSupport: Boolean(config.build.sourcemap),
+        supportsResponseStreaming: true
+      };
+      await Promise.all([
+        // Copy static files to the .vercel/output/static directory
+        cp(resolve(config.root, config.publicDir), resolve(outputDir, "static"), {
+          recursive: true
+        }),
+        // Write the all necessary config files
+        writeJSON(resolve(outputDir, "config.json"), buildConfig),
+        writeJSON(resolve(functionDir, ".vc-config.json"), functionConfig),
+        writeJSON(resolve(functionDir, "package.json"), {
+          type: "module"
+        })
+      ]);
+    },
+    name: "@hono/vite-build/vercel"
+  };
+};
+var vercel_default = vercelBuildPlugin;
+export {
+  vercel_default as default
+};

package/dist/adapter/vercel/types.d.ts

@@ -0,0 +1,271 @@
+/**
+ * Main configuration type for Vercel Build Output API v3.
+ * This type represents the root configuration object that should be output in the `.vercel/output/config.json` file.
+ * @see https://vercel.com/docs/build-output-api/configuration
+ */
+type VercelBuildConfigV3 = {
+    /** Version identifier for the Build Output API. Must be 3. */
+    version?: 3;
+    /**
+     * Array of routing rules to handle incoming requests.
+     * Routes are evaluated in order, where the first matching route will be applied.
+     */
+    routes?: Route[];
+    /**
+     * Configuration for Vercel's Image Optimization feature.
+     * Defines how images should be optimized, cached, and served.
+     * @see https://vercel.com/docs/build-output-api/configuration#images
+     */
+    images?: ImagesConfig;
+    /**
+     * Custom domain wildcard configurations for internationalization.
+     * Maps domain names to values that can be referenced by the routes configuration.
+     * @see https://vercel.com/docs/build-output-api/configuration#wildcard
+     */
+    wildcard?: WildCard[];
+    /**
+     * File-specific overrides for static files in the `.vercel/output/static` directory.
+     * Allows overriding Content-Type headers and URL paths for static files.
+     * @see https://vercel.com/docs/build-output-api/configuration#overrides
+     */
+    overrides?: Record<string, Override>;
+    /**
+     * Array of file paths or glob patterns to be cached between builds.
+     * Only relevant when Vercel is building from source code.
+     * @see https://vercel.com/docs/build-output-api/configuration#cache
+     */
+    cache?: string[];
+    /**
+     * Scheduled tasks configuration for production deployments.
+     * Defines API routes that should be invoked on a schedule.
+     * @see https://vercel.com/docs/build-output-api/configuration#crons
+     */
+    crons?: Cron[];
+};
+/**
+ * Route configuration that can either be a Source route or a Handler route.
+ * Source routes match incoming requests, while Handler routes define special behaviors.
+ */
+type Route = Source | Handler;
+/**
+ * Source route configuration for matching and handling incoming requests.
+ * Provides detailed control over request matching and response handling.
+ */
+type Source = {
+    /** Regular expression pattern to match incoming request paths */
+    src: string;
+    /** Path to rewrite or redirect the matched request to */
+    dest?: string;
+    /** Custom HTTP headers to add to the response */
+    headers?: Record<string, string>;
+    /** Array of HTTP methods this route should match */
+    methods?: string[];
+    /** When true, matching will continue even after this route matches */
+    continue?: boolean;
+    /** When true, the src pattern will be matched case-sensitively */
+    caseSensitive?: boolean;
+    /** Additional validation flag for route matching */
+    check?: boolean;
+    /** HTTP status code to return (e.g., 308 for redirects) */
+    status?: number;
+    /** Conditions that must be present in the request for the route to match */
+    has?: Array<HostHasField | HeaderHasField | CookieHasField | QueryHasField>;
+    /** Conditions that must be absent from the request for the route to match */
+    missing?: Array<HostHasField | HeaderHasField | CookieHasField | QueryHasField>;
+    /** Configuration for locale-based routing and redirects */
+    locale?: Locale;
+    /** Raw source patterns used by middleware */
+    middlewareRawSrc?: string[];
+    /** Path to the middleware implementation file */
+    middlewarePath?: string;
+};
+/**
+ * Locale configuration for internationalization routing.
+ * Used to configure language-specific redirects and preferences.
+ */
+type Locale = {
+    /** Mapping of locale codes to their redirect destinations */
+    redirect?: Record<string, string>;
+    /** Name of the cookie used to store the user's locale preference */
+    cookie?: string;
+};
+/**
+ * Host-based condition for route matching.
+ * Used to match requests based on the Host header.
+ */
+type HostHasField = {
+    /** Identifies this as a host matching condition */
+    type: 'host';
+    /** Pattern to match against the Host header */
+    value: string;
+};
+/**
+ * Header-based condition for route matching.
+ * Used to match requests based on HTTP headers.
+ */
+type HeaderHasField = {
+    /** Identifies this as a header matching condition */
+    type: 'header';
+    /** Name of the header to match */
+    key: string;
+    /** Optional value the header should match */
+    value?: string;
+};
+/**
+ * Cookie-based condition for route matching.
+ * Used to match requests based on cookie values.
+ */
+type CookieHasField = {
+    /** Identifies this as a cookie matching condition */
+    type: 'cookie';
+    /** Name of the cookie to match */
+    key: string;
+    /** Optional value the cookie should match */
+    value?: string;
+};
+/**
+ * Query parameter condition for route matching.
+ * Used to match requests based on query string parameters.
+ */
+type QueryHasField = {
+    /** Identifies this as a query parameter matching condition */
+    type: 'query';
+    /** Name of the query parameter to match */
+    key: string;
+    /** Optional value the query parameter should match */
+    value?: string;
+};
+/**
+ * Special handler phases for request processing.
+ * Defines when and how requests should be processed in the routing pipeline.
+ */
+type HandleValue = 'rewrite' | 'filesystem' | 'resource' | 'miss' | 'hit' | 'error';
+/**
+ * Handler route configuration for special request processing phases.
+ * Used to define behavior at specific points in the request lifecycle.
+ */
+type Handler = {
+    /** The type of handler to process the request */
+    handle: HandleValue;
+    /** Optional pattern to match against the request path */
+    src?: string;
+    /** Optional path to handle the request with */
+    dest?: string;
+    /** HTTP status code to return in the response */
+    status?: number;
+};
+/**
+ * Supported image formats for the Image Optimization API.
+ * @see https://vercel.com/docs/build-output-api/configuration#images
+ */
+type ImageFormat = 'image/avif' | 'image/webp';
+/**
+ * Configuration for remote image sources in Image Optimization.
+ * Defines patterns for matching and processing external images.
+ */
+type RemotePattern = {
+    /** Protocol allowed for remote images (http or https) */
+    protocol?: 'http' | 'https';
+    /** Hostname pattern that remote images must match */
+    hostname: string;
+    /** Optional port number for remote image URLs */
+    port?: string;
+    /** Path pattern that remote image URLs must match */
+    pathname?: string;
+    /** Search query pattern that remote image URLs must match */
+    search?: string;
+};
+/**
+ * Configuration for local image patterns in Image Optimization.
+ * Defines patterns for matching and processing local images.
+ */
+type LocalPattern = {
+    /** Path pattern that local images must match */
+    pathname?: string;
+    /** Search query pattern that local image URLs must match */
+    search?: string;
+};
+/**
+ * Configuration for Vercel's Image Optimization feature.
+ * @see https://vercel.com/docs/build-output-api/configuration#images
+ */
+type ImagesConfig = {
+    /** Array of allowed image widths for resizing */
+    sizes: number[];
+    /** Array of allowed domains for remote images */
+    domains: string[];
+    /** Patterns for matching remote image sources */
+    remotePatterns?: RemotePattern[];
+    /** Patterns for matching local image sources */
+    localPatterns?: LocalPattern[];
+    /** Array of allowed quality values for image optimization */
+    qualities?: number[];
+    /** Minimum time (in seconds) to cache optimized images */
+    minimumCacheTTL?: number;
+    /** Array of supported output formats for optimization */
+    formats?: ImageFormat[];
+    /** Whether to allow processing of SVG images (use with caution) */
+    dangerouslyAllowSVG?: boolean;
+    /** Content Security Policy for optimized images */
+    contentSecurityPolicy?: string;
+    /** Content-Disposition header type for image responses */
+    contentDispositionType?: string;
+};
+/**
+ * Configuration for custom domain wildcards.
+ * Used for internationalization and dynamic routing based on domains.
+ * @see https://vercel.com/docs/build-output-api/configuration#wildcard
+ */
+type WildCard = {
+    /** Domain name to match for this wildcard configuration */
+    domain: string;
+    /** Value to use when this wildcard matches (available as $wildcard in routes) */
+    value: string;
+};
+/**
+ * Configuration for path or content-type overrides of static files.
+ * @see https://vercel.com/docs/build-output-api/configuration#overrides
+ */
+type Override = {
+    /** URL path where the static file will be accessible */
+    path?: string;
+    /** Content-Type header value for the static file */
+    contentType?: string;
+};
+/**
+ * Configuration for scheduled tasks (Cron Jobs).
+ * @see https://vercel.com/docs/build-output-api/configuration#crons
+ */
+type Cron = {
+    /** Path to the API route that handles the cron job */
+    path: string;
+    /** Cron schedule expression (e.g., "0 0 * * *" for daily at midnight) */
+    schedule: string;
+};
+/**
+ * Configuration for a serverless function in Vercel.
+ * This type **partially** represents the configuration object that should be output in the `.vercel/output/functions/<functionName>/config.json` file.
+ * @see https://vercel.com/docs/build-output-api/primitives#serverless-function-configuration
+ */
+type VercelServerlessFunctionConfig = {
+    /** Indicates the initial file where code will be executed for the Serverless Function. */
+    handler?: string;
+    /** Specifies which "launcher" will be used to execute the Serverless Function */
+    launcherType?: 'Nodejs';
+    /** Specifies which "runtime" will be used to execute the Serverless Function, only Node.js is supported currently */
+    runtime?: `nodejs${number}.x`;
+    /** The amount of memory allocated to the function in MB */
+    memory?: number;
+    /** The maximum duration of the function in seconds */
+    maxDuration?: number;
+    /** The regions the function is available in */
+    regions?: string[];
+    /** Whether the function supports response streaming */
+    supportsResponseStreaming?: boolean;
+    /** Enables request and response helpers methods */
+    shouldAddHelpers?: boolean;
+    /** Enables source map generation */
+    shouldAddSourcemapSupport?: boolean;
+};
+
+export { VercelBuildConfigV3, VercelServerlessFunctionConfig };

package/dist/base.js

@@ -34,7 +34,7 @@ const buildPlugin = (options) => {
     },
     async load(id) {
       if (id === resolvedVirtualEntryId) {
-        let staticPaths = [];
+        const staticPaths = options.staticPaths ?? [];
         const direntPaths = [];
         try {
           const publicDirPaths = readdirSync(resolve(config.root, config.publicDir), {
@@ -58,7 +58,7 @@ const buildPlugin = (options) => {
             uniqueStaticPaths.add(`/${p.name}`);
           }
         });
-        staticPaths = Array.from(uniqueStaticPaths);
+        staticPaths.push(...Array.from(uniqueStaticPaths));
         const entry = options.entry ?? defaultOptions.entry;
         return await getEntryContent({
           entry: Array.isArray(entry) ? entry : [entry],

package/dist/entry/index.js

@@ -28,7 +28,13 @@ const getEntryContent = async (options) => {
       let added = false
       for (const [, app] of Object.entries(modules)) {
         if (app) {
-          mainApp.route('/', app)
+          mainApp.all('*', (c) => {
+            let executionCtx
+            try {
+              executionCtx = c.executionCtx
+            } catch {}
+            return app.fetch(c.req.raw, c.env, executionCtx)
+          })
           mainApp.notFound((c) => {
             let executionCtx
             try {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hono/vite-build",
   "description": "Vite plugin to build your Hono app",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "types": "dist/index.d.ts",
   "module": "dist/index.js",
   "type": "module",
@@ -43,6 +43,10 @@
     "./deno": {
       "types": "./dist/adapter/deno/index.d.ts",
       "import": "./dist/adapter/deno/index.js"
+    },
+    "./vercel": {
+      "types": "./dist/adapter/vercel/index.d.ts",
+      "import": "./dist/adapter/vercel/index.js"
     }
   },
   "typesVersions": {
@@ -64,6 +68,12 @@
       ],
       "netlify-functions": [
         "./dist/adapter/netlify-functions/index.d.ts"
+      ],
+      "deno": [
+        "./dist/adapter/deno/index.d.ts"
+      ],
+      "vercel": [
+        "./dist/adapter/vercel/index.d.ts"
       ]
     }
   },
@@ -84,7 +94,7 @@
     "publint": "^0.1.12",
     "rimraf": "^5.0.1",
     "tsup": "^7.2.0",
-    "vite": "^5.4.12",
+    "vite": "^6.1.1",
     "vitest": "^2.1.1"
   },
   "peerDependencies": {