@hono/vite-build 1.11.0 → 1.11.1

package/dist/adapter/bun/index.js

@@ -1,55 +0,0 @@
-import buildPlugin, { defaultOptions as baseDefaultOptions } from "../../base.js";
-import { serveStaticHook } from "../../entry/serve-static.js";
-const defaultOptions = {
-  ...baseDefaultOptions,
-  entryContentAfterHooks: [
-    () => `
-      let websocket
-      for (const [, app] of Object.entries(modules)) {
-        if (
-          app &&
-          typeof app === 'object' &&
-          'websocket' in app &&
-          app.websocket !== undefined
-        ) {
-          if (websocket !== undefined) {
-            throw new Error(
-              \`Handler "websocket" is defined in multiple entry files. Please ensure each handler is defined only once.\`
-            )
-          }
-          websocket = app.websocket
-        }
-      }
-    `
-  ],
-  entryContentDefaultExportHook: (appName) => `export default websocket !== undefined ? { fetch: ${appName}.fetch.bind(${appName}), websocket } : ${appName}`
-};
-const bunBuildPlugin = (pluginOptions) => {
-  return {
-    ...buildPlugin({
-      ssrTarget: "node",
-      ...{
-        entryContentBeforeHooks: [
-          async (appName, options) => {
-            let code = "import { serveStatic } from 'hono/bun'\n";
-            code += serveStaticHook(appName, {
-              filePaths: options?.staticPaths,
-              root: pluginOptions?.staticRoot
-            });
-            return code;
-          }
-        ]
-      },
-      ...pluginOptions,
-      external: ["bun", ...pluginOptions?.external ?? []],
-      entryContentAfterHooks: pluginOptions?.entryContentAfterHooks ?? defaultOptions.entryContentAfterHooks,
-      entryContentDefaultExportHook: pluginOptions?.entryContentDefaultExportHook ?? defaultOptions.entryContentDefaultExportHook
-    }),
-    name: "@hono/vite-build/bun"
-  };
-};
-var bun_default = bunBuildPlugin;
-export {
-  bun_default as default,
-  defaultOptions
-};

package/dist/adapter/cloudflare-pages/index.js

@@ -1,53 +0,0 @@
-import { readdir, writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
-import buildPlugin, { defaultOptions } from "../../base.js";
-const WORKER_JS_NAME = "_worker.js";
-const ROUTES_JSON_NAME = "_routes.json";
-const cloudflarePagesBuildPlugin = (pluginOptions) => {
-  let config;
-  const staticPaths = [];
-  return {
-    ...buildPlugin({
-      ...pluginOptions,
-      output: WORKER_JS_NAME
-    }),
-    configResolved: async (resolvedConfig) => {
-      config = resolvedConfig;
-    },
-    writeBundle: async () => {
-      const paths = await readdir(resolve(config.root, config.build.outDir), {
-        withFileTypes: true
-      });
-      if (paths.some((p) => p.name === ROUTES_JSON_NAME)) {
-        return;
-      } else {
-        paths.forEach((p) => {
-          if (p.isDirectory()) {
-            staticPaths.push(`/${p.name}/*`);
-          } else {
-            if (p.name === WORKER_JS_NAME) {
-              return;
-            }
-            staticPaths.push(`/${p.name}`);
-          }
-        });
-        const staticRoutes = {
-          version: 1,
-          include: ["/*"],
-          exclude: staticPaths
-        };
-        const path = resolve(
-          config.root,
-          pluginOptions?.outputDir ?? defaultOptions.outputDir,
-          "_routes.json"
-        );
-        await writeFile(path, JSON.stringify(staticRoutes));
-      }
-    },
-    name: "@hono/vite-build/cloudflare-pages"
-  };
-};
-var cloudflare_pages_default = cloudflarePagesBuildPlugin;
-export {
-  cloudflare_pages_default as default
-};

package/dist/adapter/cloudflare-workers/index.js

@@ -1,37 +0,0 @@
-import buildPlugin, { defaultOptions as baseDefaultOptions } from "../../base.js";
-const defaultOptions = {
-  ...baseDefaultOptions,
-  entryContentAfterHooks: [
-    () => `
-      const merged = {}
-      const definedHandlers = new Set()
-      for (const [file, app] of Object.entries(modules)) {
-        for (const [key, handler] of Object.entries(app)) {
-          if (key !== 'fetch') {
-            if (definedHandlers.has(key)) {
-              throw new Error(\`Handler "\${key}" is defined in multiple entry files. Please ensure each handler (except fetch) is defined only once.\`);
-            }
-            definedHandlers.add(key)
-            merged[key] = handler
-          }
-        }
-      }
-    `
-  ],
-  entryContentDefaultExportHook: (appName) => `export default { ...merged, fetch: ${appName}.fetch }`
-};
-const cloudflareWorkersBuildPlugin = (pluginOptions) => {
-  return {
-    ...buildPlugin({
-      ...pluginOptions,
-      entryContentAfterHooks: pluginOptions?.entryContentAfterHooks ?? defaultOptions.entryContentAfterHooks,
-      entryContentDefaultExportHook: pluginOptions?.entryContentDefaultExportHook ?? defaultOptions.entryContentDefaultExportHook
-    }),
-    name: "@hono/vite-build/cloudflare-workers"
-  };
-};
-var cloudflare_workers_default = cloudflareWorkersBuildPlugin;
-export {
-  cloudflare_workers_default as default,
-  defaultOptions
-};

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

@@ -1,10 +0,0 @@
-import { Plugin } from 'vite';
-import { BuildOptions } from '../../base.js';
-import '../../entry/index.js';
-
-type DenoBuildOptions = {
-    staticRoot?: string | undefined;
-} & BuildOptions;
-declare const denoBuildPlugin: (pluginOptions?: DenoBuildOptions) => Plugin;
-
-export { DenoBuildOptions, denoBuildPlugin as default };

package/dist/adapter/deno/index.js

@@ -1,28 +0,0 @@
-import buildPlugin from "../../base.js";
-import { serveStaticHook } from "../../entry/serve-static.js";
-const denoBuildPlugin = (pluginOptions) => {
-  return {
-    ...buildPlugin({
-      ...{
-        entryContentBeforeHooks: [
-          async (appName, options) => {
-            const preset = pluginOptions?.preset ?? "hono";
-            let code = `import { serveStatic } from '${preset}/deno'
-`;
-            code += serveStaticHook(appName, {
-              filePaths: options?.staticPaths,
-              root: pluginOptions?.staticRoot
-            });
-            return code;
-          }
-        ]
-      },
-      ...pluginOptions
-    }),
-    name: "@hono/vite-build/deno"
-  };
-};
-var deno_default = denoBuildPlugin;
-export {
-  deno_default as default
-};

package/dist/adapter/netlify-functions/index.js

@@ -1,18 +0,0 @@
-import buildPlugin from "../../base.js";
-function netlifyFunctionsBuildPlugin(pluginOptions) {
-  return {
-    ...buildPlugin({
-      ssrTarget: "node",
-      ...{
-        entryContentBeforeHooks: [() => 'import { handle } from "hono/netlify"'],
-        entryContentAfterHooks: [() => 'export const config = { path: "/*", preferStatic: true }'],
-        entryContentDefaultExportHook: (appName) => `export default handle(${appName})`
-      },
-      ...pluginOptions
-    }),
-    name: "@hono/vite-build/netlify-functions"
-  };
-}
-export {
-  netlifyFunctionsBuildPlugin as default
-};

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

@@ -1,19 +0,0 @@
-import { Plugin } from 'vite';
-import { BuildOptions } from '../../base.js';
-import '../../entry/index.js';
-
-type NodeBuildOptions = {
-    staticRoot?: string | undefined;
-    port?: number | undefined;
-    /**
-     * Enable graceful shutdown on SIGINT and SIGTERM signals.
-     * Set to a number to specify the timeout in milliseconds before forcing shutdown.
-     * Set to 0 to wait indefinitely for connections to close.
-     * Leave undefined to disable graceful shutdown.
-     * @default undefined
-     */
-    shutdownTimeoutMs?: number | undefined;
-} & BuildOptions;
-declare const nodeBuildPlugin: (pluginOptions?: NodeBuildOptions) => Plugin;
-
-export { NodeBuildOptions, nodeBuildPlugin as default };

package/dist/adapter/node/index.js

@@ -1,50 +0,0 @@
-import buildPlugin from "../../base.js";
-import { serveStaticHook } from "../../entry/serve-static.js";
-const nodeBuildPlugin = (pluginOptions) => {
-  const port = pluginOptions?.port ?? 3e3;
-  const shutdownTimeoutMs = pluginOptions?.shutdownTimeoutMs;
-  return {
-    ...buildPlugin({
-      ssrTarget: "node",
-      ...{
-        entryContentBeforeHooks: [
-          async (appName, options) => {
-            let code = "import { serveStatic } from '@hono/node-server/serve-static'\n";
-            code += serveStaticHook(appName, {
-              filePaths: options?.staticPaths,
-              root: pluginOptions?.staticRoot
-            });
-            return code;
-          }
-        ],
-        entryContentAfterHooks: [
-          async (appName) => {
-            let code = "import { serve } from '@hono/node-server'\n";
-            if (shutdownTimeoutMs !== void 0) {
-              code += `const server = serve({ fetch: ${appName}.fetch, port: ${port.toString()} })
-`;
-              code += "const gracefulShutdown = () => {\n";
-              code += "  server.close(() => process.exit(0))\n";
-              if (shutdownTimeoutMs > 0) {
-                code += `  setTimeout(() => process.exit(1), ${shutdownTimeoutMs}).unref()
-`;
-              }
-              code += "}\n";
-              code += "process.on('SIGINT', gracefulShutdown)\n";
-              code += "process.on('SIGTERM', gracefulShutdown)";
-            } else {
-              code += `serve({ fetch: ${appName}.fetch, port: ${port.toString()} })`;
-            }
-            return code;
-          }
-        ]
-      },
-      ...pluginOptions
-    }),
-    name: "@hono/vite-build/node"
-  };
-};
-var node_default = nodeBuildPlugin;
-export {
-  node_default as default
-};

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

@@ -1,22 +0,0 @@
-import { Plugin } from 'vite';
-import { BuildOptions } from '../../base.js';
-import { VercelBuildConfigV3, VercelNodejsServerlessFunctionConfig } from './types.js';
-import '../../entry/index.js';
-
-type VercelSourceRoute = Extract<NonNullable<VercelBuildConfigV3['routes']>[number], {
-    src: string;
-}>;
-type VercelRouteConfig = Array<Omit<VercelSourceRoute, 'dest'> & {
-    dest?: string;
-}>;
-type VercelBuildOptions = {
-    vercel?: {
-        config?: VercelBuildConfigV3;
-        function?: Partial<VercelNodejsServerlessFunctionConfig>;
-        name?: string;
-        routes?: VercelRouteConfig;
-    };
-} & Omit<BuildOptions, 'output' | 'outputDir'>;
-declare const vercelBuildPlugin: (pluginOptions?: VercelBuildOptions) => Plugin;
-
-export { VercelBuildOptions, vercelBuildPlugin as default };

package/dist/adapter/vercel/index.js

@@ -1,213 +0,0 @@
-import { builtinModules } from "module";
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
-import { cp, writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
-import { defaultOptions } from "../../base.js";
-import { getEntryContent } from "../../entry/index.js";
-const BUNDLE_NAME = "index.js";
-const DEFAULT_FUNCTION_NAME = "__hono";
-const VIRTUAL_ENTRY_PREFIX = "virtual:build-entry-module-vercel-";
-const functionEntryHooks = {
-  entryContentAfterHooks: [
-    // eslint-disable-next-line quotes
-    () => "import { handle } from '@hono/node-server/vercel'"
-  ],
-  entryContentDefaultExportHook: (appName) => `export default handle(${appName})`
-};
-const configWriteQueues = /* @__PURE__ */ new Map();
-const writeJSON = (path, data) => {
-  const dir = resolve(path, "..");
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  return writeFile(path, JSON.stringify(data));
-};
-const readJSON = (path) => {
-  if (!existsSync(path)) {
-    return;
-  }
-  return JSON.parse(readFileSync(path, "utf-8"));
-};
-const enqueueConfigWrite = async (key, writeTask) => {
-  const previousTask = configWriteQueues.get(key);
-  if (previousTask) {
-    await previousTask;
-  }
-  const nextTask = writeTask();
-  configWriteQueues.set(key, nextTask);
-  try {
-    await nextTask;
-  } finally {
-    if (configWriteQueues.get(key) === nextTask) {
-      configWriteQueues.delete(key);
-    }
-  }
-};
-const getRuntimeVersion = () => {
-  try {
-    const systemNodeVersion = process.versions.node.split(".")[0];
-    return `nodejs${Number(systemNodeVersion)}.x`;
-  } catch {
-    return "nodejs22.x";
-  }
-};
-const escapeRouteSegment = (value) => {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-};
-const getDefaultRoutePattern = (functionName) => {
-  return `^/${escapeRouteSegment(functionName)}(?:/.*)?$`;
-};
-const appendRouteIfMissing = (target, seen, route) => {
-  const key = JSON.stringify(route);
-  if (seen.has(key)) {
-    return;
-  }
-  seen.add(key);
-  target.push(route);
-};
-const getFunctionConfig = (config, functionConfig) => {
-  return {
-    ...functionConfig,
-    runtime: getRuntimeVersion(),
-    launcherType: "Nodejs",
-    handler: BUNDLE_NAME,
-    shouldAddHelpers: Boolean(functionConfig?.shouldAddHelpers),
-    shouldAddSourcemapSupport: Boolean(config.build.sourcemap),
-    supportsResponseStreaming: true
-  };
-};
-const getRoutesForFunction = (functionName, configuredRoutes) => {
-  if (configuredRoutes && configuredRoutes.length > 0) {
-    return configuredRoutes;
-  }
-  if (functionName === DEFAULT_FUNCTION_NAME) {
-    return [{ src: "/(.*)", dest: `/${DEFAULT_FUNCTION_NAME}` }];
-  }
-  return [{ src: getDefaultRoutePattern(functionName), dest: `/${functionName}` }];
-};
-const mergeVercelConfig = async (configPath, routesToAdd, configOverride, functionName) => {
-  const existingConfig = readJSON(configPath);
-  const mergedRoutes = [];
-  const seenRoutes = /* @__PURE__ */ new Set();
-  for (const route of existingConfig?.routes ?? []) {
-    appendRouteIfMissing(mergedRoutes, seenRoutes, route);
-  }
-  for (const route of configOverride?.routes ?? []) {
-    appendRouteIfMissing(mergedRoutes, seenRoutes, route);
-  }
-  appendRouteIfMissing(mergedRoutes, seenRoutes, { handle: "filesystem" });
-  for (const route of routesToAdd) {
-    appendRouteIfMissing(mergedRoutes, seenRoutes, {
-      ...route,
-      dest: route.dest ?? `/${functionName}`
-    });
-  }
-  const buildConfig = {
-    ...existingConfig,
-    ...configOverride,
-    version: 3,
-    routes: mergedRoutes
-  };
-  await writeJSON(configPath, buildConfig);
-};
-const copyStaticFiles = async (publicDirPath, outputDir) => {
-  if (!existsSync(publicDirPath)) {
-    return;
-  }
-  try {
-    await cp(publicDirPath, resolve(outputDir, "static"), {
-      recursive: true,
-      force: true
-    });
-  } catch (error) {
-    if (error.code !== "EEXIST") {
-      throw error;
-    }
-  }
-};
-const vercelBuildPlugin = (pluginOptions) => {
-  let config;
-  const functionName = pluginOptions?.vercel?.name ?? DEFAULT_FUNCTION_NAME;
-  if (!functionName) {
-    throw new Error("`vercel.name` is required and cannot be empty.");
-  }
-  const virtualEntryId = `${VIRTUAL_ENTRY_PREFIX}${functionName}`;
-  const resolvedVirtualEntryId = `\0${virtualEntryId}`;
-  return {
-    name: "@hono/vite-build/vercel",
-    apply: pluginOptions?.apply ?? defaultOptions.apply,
-    resolveId(id) {
-      if (id === virtualEntryId) {
-        return resolvedVirtualEntryId;
-      }
-    },
-    async load(id) {
-      if (id !== resolvedVirtualEntryId) {
-        return;
-      }
-      const entry = pluginOptions?.entry ?? defaultOptions.entry;
-      return await getEntryContent({
-        entry: Array.isArray(entry) ? entry : [entry],
-        entryContentBeforeHooks: pluginOptions?.entryContentBeforeHooks,
-        entryContentAfterHooks: pluginOptions?.entryContentAfterHooks ?? functionEntryHooks.entryContentAfterHooks,
-        entryContentDefaultExportHook: pluginOptions?.entryContentDefaultExportHook ?? functionEntryHooks.entryContentDefaultExportHook,
-        staticPaths: pluginOptions?.staticPaths,
-        preset: pluginOptions?.preset
-      });
-    },
-    configResolved: (resolvedConfig) => {
-      config = resolvedConfig;
-    },
-    config: async () => {
-      return {
-        ssr: {
-          external: pluginOptions?.external ?? defaultOptions.external,
-          noExternal: true,
-          target: "node"
-        },
-        build: {
-          outDir: ".vercel/output",
-          emptyOutDir: pluginOptions?.emptyOutDir ?? defaultOptions.emptyOutDir,
-          minify: pluginOptions?.minify ?? defaultOptions.minify,
-          ssr: true,
-          rollupOptions: {
-            external: [...builtinModules, /^node:/],
-            input: {
-              [functionName]: virtualEntryId
-            },
-            output: {
-              entryFileNames: `functions/[name].func/${BUNDLE_NAME}`
-            }
-          }
-        }
-      };
-    },
-    writeBundle: async () => {
-      const outputDir = resolve(config.root, config.build.outDir);
-      const functionDir = resolve(outputDir, "functions", `${functionName}.func`);
-      const configPath = resolve(outputDir, "config.json");
-      const publicDirPath = resolve(config.root, config.publicDir);
-      const routesToAdd = getRoutesForFunction(functionName, pluginOptions?.vercel?.routes);
-      const functionConfig = getFunctionConfig(config, pluginOptions?.vercel?.function);
-      await copyStaticFiles(publicDirPath, outputDir);
-      await Promise.all([
-        writeJSON(resolve(functionDir, ".vc-config.json"), functionConfig),
-        writeJSON(resolve(functionDir, "package.json"), {
-          type: "module"
-        })
-      ]);
-      await enqueueConfigWrite(configPath, async () => {
-        await mergeVercelConfig(
-          configPath,
-          routesToAdd,
-          pluginOptions?.vercel?.config,
-          functionName
-        );
-      });
-    }
-  };
-};
-var vercel_default = vercelBuildPlugin;
-export {
-  vercel_default as default
-};