npm - @hono/vite-build - Versions diffs - 1.0.0 - Mend

@hono/vite-build 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/README.md +221 -0
package/dist/adapter/bun/index.d.ts +10 -0
package/dist/adapter/bun/index.js +26 -0
package/dist/adapter/cloudflare-pages/index.d.ts +8 -0
package/dist/adapter/cloudflare-pages/index.js +53 -0
package/dist/adapter/cloudflare-workers/index.d.ts +8 -0
package/dist/adapter/cloudflare-workers/index.js +13 -0
package/dist/adapter/node/index.d.ts +10 -0
package/dist/adapter/node/index.js +33 -0
package/dist/base.d.ts +25 -0
package/dist/base.js +100 -0
package/dist/entry/index.d.ts +13 -0
package/dist/entry/index.js +53 -0
package/dist/entry/serve-static.d.ts +7 -0
package/dist/entry/serve-static.js +11 -0
package/dist/index.d.ts +8 -0
package/dist/index.js +7 -0
package/package.json +85 -0

package/README.md ADDED Viewed

@@ -0,0 +1,221 @@
+# @hono/vite-build
+`@hono/vite-build` is a set of Vite plugins for building Hono applications with Vite. It supports multiple runtimes and platforms, allowing you to build a project that includes JavaScript files for these platforms from a Hono app.
+Here are the modules included:
+- `@hono/vite-build/base`
+- `@hono/vite-build/cloudflare-pages`
+- `@hono/vite-build/cloudflare-workers`
+- `@hono/vite-build/bun`
+- `@hono/vite-build/node`
+## Usage
+### Install
+You can install `vite` and `@hono/vite-build` via the npm.
+```bash
+npm i -D vite @hono/vite-build
+```
+Or you can install them with Bun.
+```bash
+bun add -D vite @hono/vite-build
+```
+### Settings
+Add `"type": "module"` to your package.json. Then, create `vite.config.ts` and edit it. The following is for Bun.
+```ts
+import { defineConfig } from 'vite'
+import build from '@hono/vite-build/bun'
+// import build from '@hono/vite-build/cloudflare-pages'
+// import build from '@hono/vite-build/cloudflare-workers'
+// import build from '@hono/vite-build/node'
+export default defineConfig({
+  plugins: [
+    build({
+      // Defaults are `src/index.ts`,`./src/index.tsx`,`./app/server.ts`
+      entry: './src/index.tsx',
+    }),
+  ],
+})
+```
+### Build
+Just run `vite build`.
+```bash
+npm exec vite build
+```
+Or
+```bash
+bunx --bun vite build
+```
+### Run
+Run with the command on your runtime. For examples:
+Cloudflare Pages:
+```bash
+wrangler pages dev ./dist
+```
+Bun:
+```bash
+cd ./dist
+bun run ./index.js
+```
+Node.js:
+```bash
+cd ./dist
+node ./index.js
+```
+## Common Options
+```ts
+type BuildOptions = {
+  entry?: string | string[]
+  output?: string
+  outputDir?: string
+  external?: string[]
+  minify?: boolean
+  emptyOutDir?: boolean
+}
+```
+Default values:
+```ts
+export const defaultOptions = {
+  entry: ['src/index.ts', './src/index.tsx', './app/server.ts'],
+  output: 'index.js',
+  outputDir: './dist',
+  external: [],
+  minify: true,
+  emptyOutDir: false,
+  staticPaths: [],
+}
+```
+## Platform specific things
+### Cloudflare Pages
+This plugin generates `_routes.json` automatically. The automatic generation can be overridden by creating a `public/_routes.json`. See [Create a `_routes.json` file](https://developers.cloudflare.com/pages/functions/routing/#create-a-_routesjson-file) on Cloudflare Docs for more details.
+## Example project
+`src/index.tsx`:
+```tsx
+import { Hono } from 'hono'
+const app = new Hono()
+app.get('/', (c) => {
+  return c.html(
+    <html>
+      <head>
+        <link href='/static/style.css' rel='stylesheet' />
+      </head>
+      <body>
+        <h1>Hello!</h1>
+      </body>
+    </html>
+  )
+})
+export default app
+```
+`public/static/style.css`:
+```css
+h1 {
+  font-family: Arial, Helvetica, sans-serif;
+}
+```
+The project with those file will be built to the following files with `@hono/vite-build/bun`:
+```txt
+dist
+├── index.js
+└── static
+ └── style.css
+```
+## Build a client
+If you also want to build a client-side script, you can configure it as follows.
+```ts
+export default defineConfig(({ mode }) => {
+  if (mode === 'client') {
+    return {
+      build: {
+        rollupOptions: {
+          input: './src/client.ts',
+          output: {
+            dir: './dist/static',
+            entryFileNames: 'client.js',
+          },
+        },
+        copyPublicDir: false,
+      },
+    }
+  } else {
+    return {
+      plugins: [build()],
+    }
+  }
+})
+```
+The build command:
+```bash
+vite build --mode client && vite build
+```
+`import.meta.env.PROD` is helpful in detecting whether it is in development or production mode if you are using it on a Vite dev server.
+```tsx
+app.get('/', (c) => {
+  return c.html(
+    <html>
+      <head>
+        {import.meta.env.PROD ? (
+          <script type='module' src='/static/client.js'></script>
+        ) : (
+          <script type='module' src='/src/client.ts'></script>
+        )}
+      </head>
+      <body>Hello!</body>
+    </html>
+  )
+})
+```
+## Authors
+- Yusuke Wada <https://github.com/yusukebe>
+## License
+MIT

package/dist/adapter/bun/index.d.ts ADDED Viewed

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

package/dist/adapter/bun/index.js ADDED Viewed

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

package/dist/adapter/cloudflare-pages/index.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import { Plugin } from 'vite';
+import { BuildOptions } from '../../base.js';
+import '../../entry/index.js';
+type CloudflarePagesBuildOptions = BuildOptions;
+declare const cloudflarePagesBuildPlugin: (pluginOptions?: CloudflarePagesBuildOptions) => Plugin;
+export { CloudflarePagesBuildOptions, cloudflarePagesBuildPlugin as default };

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

@@ -0,0 +1,53 @@
+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.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import { Plugin } from 'vite';
+import { BuildOptions } from '../../base.js';
+import '../../entry/index.js';
+type CloudflareWorkersBuildOptions = BuildOptions;
+declare const cloudflareWorkersBuildPlugin: (pluginOptions?: CloudflareWorkersBuildOptions) => Plugin;
+export { CloudflareWorkersBuildOptions, cloudflareWorkersBuildPlugin as default };

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

@@ -0,0 +1,13 @@
+import buildPlugin from "../../base.js";
+const cloudflareWorkersBuildPlugin = (pluginOptions) => {
+  return {
+    ...buildPlugin({
+      ...pluginOptions
+    }),
+    name: "@hono/vite-build/cloudflare-workers"
+  };
+};
+var cloudflare_workers_default = cloudflareWorkersBuildPlugin;
+export {
+  cloudflare_workers_default as default
+};

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

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

package/dist/adapter/node/index.js ADDED Viewed

@@ -0,0 +1,33 @@
+import buildPlugin from "../../base.js";
+import { serveStaticHook } from "../../entry/serve-static.js";
+const nodeBuildPlugin = (pluginOptions) => {
+  return {
+    ...buildPlugin({
+      ...{
+        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";
+            code += `serve(${appName})`;
+            return code;
+          }
+        ]
+      },
+      ...pluginOptions
+    }),
+    name: "@hono/vite-build/node"
+  };
+};
+var node_default = nodeBuildPlugin;
+export {
+  node_default as default
+};

package/dist/base.d.ts ADDED Viewed

@@ -0,0 +1,25 @@
+import { UserConfig, ConfigEnv, Plugin } from 'vite';
+import { GetEntryContentOptions } from './entry/index.js';
+type BuildOptions = {
+    /**
+     * @default ['src/index.ts', './src/index.tsx', './app/server.ts']
+     */
+    entry?: string | string[];
+    /**
+     * @default './dist'
+     */
+    output?: string;
+    outputDir?: string;
+    external?: string[];
+    /**
+     * @default true
+     */
+    minify?: boolean;
+    emptyOutDir?: boolean;
+    apply?: ((this: void, config: UserConfig, env: ConfigEnv) => boolean) | undefined;
+} & Omit<GetEntryContentOptions, 'entry'>;
+declare const defaultOptions: Required<Omit<BuildOptions, 'entryContentAfterHooks' | 'entryContentBeforeHooks'>>;
+declare const buildPlugin: (options: BuildOptions) => Plugin;
+export { BuildOptions, buildPlugin as default, defaultOptions };

package/dist/base.js ADDED Viewed

@@ -0,0 +1,100 @@
+import { builtinModules } from "module";
+import { readdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { getEntryContent } from "./entry/index.js";
+const defaultOptions = {
+  entry: ["src/index.ts", "./src/index.tsx", "./app/server.ts"],
+  output: "index.js",
+  outputDir: "./dist",
+  external: [],
+  minify: true,
+  emptyOutDir: false,
+  apply: (_config, { command, mode }) => {
+    if (command === "build" && mode !== "client") {
+      return true;
+    }
+    return false;
+  },
+  staticPaths: []
+};
+const buildPlugin = (options) => {
+  const virtualEntryId = "virtual:build-entry-module";
+  const resolvedVirtualEntryId = "\0" + virtualEntryId;
+  let config;
+  const output = options.output ?? defaultOptions.output;
+  return {
+    name: "@hono/vite-build",
+    configResolved: async (resolvedConfig) => {
+      config = resolvedConfig;
+    },
+    resolveId(id) {
+      if (id === virtualEntryId) {
+        return resolvedVirtualEntryId;
+      }
+    },
+    async load(id) {
+      if (id === resolvedVirtualEntryId) {
+        let staticPaths = [];
+        const direntPaths = [];
+        try {
+          const publicDirPaths = readdirSync(resolve(config.root, config.publicDir), {
+            withFileTypes: true
+          });
+          direntPaths.push(...publicDirPaths);
+          const buildOutDirPaths = readdirSync(resolve(config.root, config.build.outDir), {
+            withFileTypes: true
+          });
+          direntPaths.push(...buildOutDirPaths);
+        } catch {
+        }
+        const uniqueStaticPaths = /* @__PURE__ */ new Set();
+        direntPaths.forEach((p) => {
+          if (p.isDirectory()) {
+            uniqueStaticPaths.add(`/${p.name}/*`);
+          } else {
+            if (p.name === output) {
+              return;
+            }
+            uniqueStaticPaths.add(`/${p.name}`);
+          }
+        });
+        staticPaths = Array.from(uniqueStaticPaths);
+        const entry = options.entry ?? defaultOptions.entry;
+        return await getEntryContent({
+          entry: Array.isArray(entry) ? entry : [entry],
+          entryContentBeforeHooks: options.entryContentBeforeHooks,
+          entryContentAfterHooks: options.entryContentAfterHooks,
+          staticPaths
+        });
+      }
+    },
+    apply: options?.apply ?? defaultOptions.apply,
+    config: async () => {
+      return {
+        ssr: {
+          external: options?.external ?? defaultOptions.external,
+          noExternal: true,
+          target: "webworker"
+        },
+        build: {
+          outDir: options?.outputDir ?? defaultOptions.outputDir,
+          emptyOutDir: options?.emptyOutDir ?? defaultOptions.emptyOutDir,
+          minify: options?.minify ?? defaultOptions.minify,
+          ssr: true,
+          rollupOptions: {
+            external: [...builtinModules, /^node:/],
+            input: virtualEntryId,
+            output: {
+              entryFileNames: output
+            }
+          }
+        }
+      };
+    }
+  };
+};
+var base_default = buildPlugin;
+export {
+  base_default as default,
+  defaultOptions
+};

package/dist/entry/index.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+type EntryContentHookOptions = {
+    staticPaths: string[];
+};
+type EntryContentHook = (appName: string, options?: EntryContentHookOptions) => string | Promise<string>;
+type GetEntryContentOptions = {
+    entry: string[];
+    entryContentBeforeHooks?: EntryContentHook[];
+    entryContentAfterHooks?: EntryContentHook[];
+    staticPaths?: string[];
+};
+declare const getEntryContent: (options: GetEntryContentOptions) => Promise<string>;
+export { EntryContentHook, EntryContentHookOptions, GetEntryContentOptions, getEntryContent };

package/dist/entry/index.js ADDED Viewed

@@ -0,0 +1,53 @@
+import { normalize } from "node:path";
+const normalizePaths = (paths) => {
+  return paths.map((p) => {
+    let normalizedPath = normalize(p).replace(/\\/g, "/");
+    if (normalizedPath.startsWith("./")) {
+      normalizedPath = normalizedPath.substring(2);
+    }
+    return "/" + normalizedPath;
+  });
+};
+const getEntryContent = async (options) => {
+  const staticPaths = options.staticPaths ?? [""];
+  const globStr = normalizePaths(options.entry).map((e) => `'${e}'`).join(",");
+  const hooksToString = async (appName, hooks) => {
+    if (hooks) {
+      const str = (await Promise.all(
+        hooks.map((hook) => {
+          return hook(appName, {
+            staticPaths
+          });
+        })
+      )).join("\n");
+      return str;
+    }
+    return "";
+  };
+  const appStr = `const modules = import.meta.glob([${globStr}], { import: 'default', eager: true })
+      let added = false
+      for (const [, app] of Object.entries(modules)) {
+        if (app) {
+          mainApp.route('/', app)
+          mainApp.notFound(app.notFoundHandler)
+          added = true
+        }
+      }
+      if (!added) {
+        throw new Error("Can't import modules from [${globStr}]")
+      }`;
+  const mainAppStr = `import { Hono } from 'hono'
+const mainApp = new Hono()
+${await hooksToString("mainApp", options.entryContentBeforeHooks)}
+${appStr}
+${await hooksToString("mainApp", options.entryContentAfterHooks)}
+export default mainApp`;
+  return mainAppStr;
+};
+export {
+  getEntryContent
+};

package/dist/entry/serve-static.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+type ServeStaticHookOptions = {
+    filePaths?: string[];
+    root?: string;
+};
+declare const serveStaticHook: (appName: string, options: ServeStaticHookOptions) => string;
+export { serveStaticHook };

package/dist/entry/serve-static.js ADDED Viewed

@@ -0,0 +1,11 @@
+const serveStaticHook = (appName, options) => {
+  let code = "";
+  for (const path of options.filePaths ?? []) {
+    code += `${appName}.use('${path}', serveStatic({ root: '${options.root ?? "./"}' }))
+`;
+  }
+  return code;
+};
+export {
+  serveStaticHook
+};

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import buildPlugin from './base.js';
+export { defaultOptions } from './base.js';
+import 'vite';
+import './entry/index.js';
+export { buildPlugin as default };

package/dist/index.js ADDED Viewed

@@ -0,0 +1,7 @@
+import { defaultOptions } from "./base.js";
+import basePlugin from "./base.js";
+var src_default = basePlugin;
+export {
+  src_default as default,
+  defaultOptions
+};

package/package.json ADDED Viewed

@@ -0,0 +1,85 @@
+{
+  "name": "@hono/vite-build",
+  "description": "Vite plugin to build your Hono app",
+  "version": "1.0.0",
+  "types": "dist/index.d.ts",
+  "module": "dist/index.js",
+  "type": "module",
+  "scripts": {
+    "test": "vitest --run",
+    "build": "rimraf dist && tsup && publint",
+    "watch": "tsup --watch",
+    "prerelease": "yarn build",
+    "release": "yarn publish"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./bun": {
+      "types": "./dist/adapter/bun/index.d.ts",
+      "import": "./dist/adapter/bun/index.js"
+    },
+    "./node": {
+      "types": "./dist/adapter/node/index.d.ts",
+      "import": "./dist/adapter/node/index.js"
+    },
+    "./cloudflare-pages": {
+      "types": "./dist/adapter/cloudflare-pages/index.d.ts",
+      "import": "./dist/adapter/cloudflare-pages/index.js"
+    },
+    "./cloudflare-workers": {
+      "types": "./dist/adapter/cloudflare-workers/index.d.ts",
+      "import": "./dist/adapter/cloudflare-workers/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "types": [
+        "./dist/types"
+      ],
+      "bun": [
+        "./dist/adapter/bun/index.d.ts"
+      ],
+      "node": [
+        "./dist/adapter/node/index.d.ts"
+      ],
+      "cloudflare-pages": [
+        "./dist/adapter/cloudflare-pages/index.d.ts"
+      ],
+      "cloudflare-workers": [
+        "./dist/adapter/cloudflare-workers/index.d.ts"
+      ]
+    }
+  },
+  "author": "Yusuke Wada <yusuke@kamawada.com> (https://github.com/yusukebe)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/honojs/vite-plugins.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "homepage": "https://github.com/honojs/vite-plugins",
+  "devDependencies": {
+    "glob": "^10.3.10",
+    "hono": "^4.6.1",
+    "publint": "^0.1.12",
+    "rimraf": "^5.0.1",
+    "tsup": "^7.2.0",
+    "vite": "^5.4.5",
+    "vitest": "^2.1.1"
+  },
+  "peerDependencies": {
+    "hono": "*"
+  },
+  "engines": {
+    "node": ">=18.14.1"
+  }
+}