@hono/cli 0.1.2 → 0.1.4

package/README.md

@@ -255,6 +255,8 @@ hono optimize [entry] [options]
 **Options:**
 
 - `-o, --outfile <outfile>` - Output file
+- `-m, --minify` - minify output file
+- `-t, --target [target]` - environment target
 
 **Examples:**
 
@@ -267,6 +269,9 @@ hono optimize -o dist/app.js src/app.ts
 
 # Export bundled file with minification
 hono optimize -m
+
+# Specify environment target
+hono optimize -t es2024
 ```
 
 ## Tips

package/dist/cli.js

@@ -70,114 +70,147 @@ import { dirname, join, resolve } from "path";
 
 // src/utils/build.ts
 import * as esbuild from "esbuild";
-import { extname } from "path";
-import { pathToFileURL } from "url";
-async function buildAndImportApp(filePath, options = {}) {
-  const ext = extname(filePath);
-  if ([".ts", ".tsx", ".jsx"].includes(ext)) {
-    const result = await esbuild.build({
-      entryPoints: [filePath],
-      bundle: true,
-      write: false,
-      format: "esm",
-      target: "node20",
-      jsx: "automatic",
-      jsxImportSource: "hono/jsx",
-      platform: "node",
-      external: options.external || []
+async function* buildAndImportApp(filePath, options = {}) {
+  let resolveApp;
+  let appPromise;
+  const preparePromise = () => {
+    appPromise = new Promise((resolve4) => {
+      resolveApp = resolve4;
     });
-    const code = result.outputFiles[0].text;
-    const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
-    const module = await import(dataUrl);
-    return module.default;
-  } else {
-    const module = await import(pathToFileURL(filePath).href);
-    return module.default;
+  };
+  preparePromise();
+  const context2 = await esbuild.context({
+    entryPoints: [filePath],
+    bundle: true,
+    write: false,
+    format: "esm",
+    target: "node20",
+    jsx: "automatic",
+    jsxImportSource: "hono/jsx",
+    platform: "node",
+    external: options.external || [],
+    plugins: [
+      {
+        name: "watch",
+        setup(build2) {
+          build2.onEnd(async (result) => {
+            try {
+              const code = result.outputFiles?.[0]?.text || "";
+              const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
+              const module = await import(dataUrl);
+              const app = module.default;
+              if (!app) {
+                throw new Error("Failed to build app");
+              }
+              if (!app || typeof app.request !== "function") {
+                throw new Error("No valid Hono app exported from the file");
+              }
+              try {
+                resolveApp(app);
+              } catch {
+              }
+            } catch (error) {
+              console.error("Error building app", error);
+            }
+          });
+        }
+      }
+    ]
+  });
+  await context2.watch();
+  if (!options.watch) {
+    await context2.dispose();
   }
+  do {
+    yield await appPromise;
+    preparePromise();
+  } while (options.watch);
 }
 
 // src/commands/optimize/index.ts
 var DEFAULT_ENTRY_CANDIDATES = ["src/index.ts", "src/index.tsx", "src/index.js", "src/index.jsx"];
 function optimizeCommand(program2) {
-  program2.command("optimize").description("Build optimized Hono class").argument("[entry]", "entry file").option("-o, --outfile [outfile]", "output file", "dist/index.js").option("-m, --minify", "minify output file").action(async (entry, options) => {
-    if (!entry) {
-      entry = DEFAULT_ENTRY_CANDIDATES.find((entry2) => existsSync(entry2)) ?? DEFAULT_ENTRY_CANDIDATES[0];
-    }
-    const appPath = resolve(process.cwd(), entry);
-    if (!existsSync(appPath)) {
-      throw new Error(`Entry file ${entry} does not exist`);
-    }
-    const appFilePath = realpathSync(appPath);
-    const app = await buildAndImportApp(appFilePath, {
-      external: ["@hono/node-server"]
-    });
-    let routerName;
-    let importStatement;
-    let assignRouterStatement;
-    try {
-      const serialized = serializeInitParams(
-        buildInitParams({
-          paths: app.routes.map(({ path }) => path)
-        })
-      );
-      const hasPreparedRegExpRouter = await new Promise((resolve4) => {
-        const child = execFile(process.execPath, [
-          "--input-type=module",
-          "-e",
-          "try { (await import('hono/router/reg-exp-router')).PreparedRegExpRouter && process.exit(0) } finally { process.exit(1) }"
-        ]);
-        child.on("exit", (code) => {
-          resolve4(code === 0);
-        });
+  program2.command("optimize").description("Build optimized Hono class").argument("[entry]", "entry file").option("-o, --outfile [outfile]", "output file", "dist/index.js").option("-m, --minify", "minify output file").option("-t, --target [target]", "environment target (e.g., node24, deno2, es2024)", "node20").action(
+    async (entry, options) => {
+      if (!entry) {
+        entry = DEFAULT_ENTRY_CANDIDATES.find((entry2) => existsSync(entry2)) ?? DEFAULT_ENTRY_CANDIDATES[0];
+      }
+      const appPath = resolve(process.cwd(), entry);
+      if (!existsSync(appPath)) {
+        throw new Error(`Entry file ${entry} does not exist`);
+      }
+      const appFilePath = realpathSync(appPath);
+      const buildIterator = buildAndImportApp(appFilePath, {
+        external: ["@hono/node-server"]
       });
-      if (hasPreparedRegExpRouter) {
-        routerName = "PreparedRegExpRouter";
-        importStatement = "import { PreparedRegExpRouter } from 'hono/router/reg-exp-router'";
-        assignRouterStatement = `const routerParams = ${serialized}
+      const app = (await buildIterator.next()).value;
+      let routerName;
+      let importStatement;
+      let assignRouterStatement;
+      try {
+        const serialized = serializeInitParams(
+          buildInitParams({
+            paths: app.routes.map(({ path }) => path)
+          })
+        );
+        const hasPreparedRegExpRouter = await new Promise((resolve4) => {
+          const child = execFile(process.execPath, [
+            "--input-type=module",
+            "-e",
+            "try { (await import('hono/router/reg-exp-router')).PreparedRegExpRouter && process.exit(0) } finally { process.exit(1) }"
+          ]);
+          child.on("exit", (code) => {
+            resolve4(code === 0);
+          });
+        });
+        if (hasPreparedRegExpRouter) {
+          routerName = "PreparedRegExpRouter";
+          importStatement = "import { PreparedRegExpRouter } from 'hono/router/reg-exp-router'";
+          assignRouterStatement = `const routerParams = ${serialized}
     this.router = new PreparedRegExpRouter(...routerParams)`;
-      } else {
-        routerName = "RegExpRouter";
-        importStatement = "import { RegExpRouter } from 'hono/router/reg-exp-router'";
-        assignRouterStatement = "this.router = new RegExpRouter()";
+        } else {
+          routerName = "RegExpRouter";
+          importStatement = "import { RegExpRouter } from 'hono/router/reg-exp-router'";
+          assignRouterStatement = "this.router = new RegExpRouter()";
+        }
+      } catch {
+        routerName = "TrieRouter";
+        importStatement = "import { TrieRouter } from 'hono/router/trie-router'";
+        assignRouterStatement = "this.router = new TrieRouter()";
       }
-    } catch {
-      routerName = "TrieRouter";
-      importStatement = "import { TrieRouter } from 'hono/router/trie-router'";
-      assignRouterStatement = "this.router = new TrieRouter()";
-    }
-    console.log("[Optimized]");
-    console.log(`  Router: ${routerName}`);
-    const outfile = resolve(process.cwd(), options.outfile);
-    await esbuild2.build({
-      entryPoints: [appFilePath],
-      outfile,
-      bundle: true,
-      minify: options.minify,
-      format: "esm",
-      target: "node20",
-      platform: "node",
-      jsx: "automatic",
-      jsxImportSource: "hono/jsx",
-      plugins: [
-        {
-          name: "hono-optimize",
-          setup(build3) {
-            const honoPseudoImportPath = "hono-optimized-pseudo-import-path";
-            build3.onResolve({ filter: /^hono$/ }, async (args) => {
-              if (!args.importer) {
-                return void 0;
-              }
-              const resolved = await build3.resolve(args.path, {
-                kind: "import-statement",
-                resolveDir: args.resolveDir
+      console.log("[Optimized]");
+      console.log(`  Router: ${routerName}`);
+      const outfile = resolve(process.cwd(), options.outfile);
+      await esbuild2.build({
+        entryPoints: [appFilePath],
+        outfile,
+        bundle: true,
+        minify: options.minify,
+        format: "esm",
+        target: options.target,
+        platform: "node",
+        jsx: "automatic",
+        jsxImportSource: "hono/jsx",
+        plugins: [
+          {
+            name: "hono-optimize",
+            setup(build2) {
+              const honoPseudoImportPath = "hono-optimized-pseudo-import-path";
+              build2.onResolve({ filter: /^hono$/ }, async (args) => {
+                if (!args.importer) {
+                  return void 0;
+                }
+                const resolved = await build2.resolve(args.path, {
+                  kind: "import-statement",
+                  resolveDir: args.resolveDir
+                });
+                return {
+                  path: join(dirname(resolved.path), honoPseudoImportPath)
+                };
               });
-              return {
-                path: join(dirname(resolved.path), honoPseudoImportPath)
-              };
-            });
-            build3.onLoad({ filter: new RegExp(`/${honoPseudoImportPath}$`) }, async () => {
-              return {
-                contents: `
+              build2.onLoad({ filter: new RegExp(`/${honoPseudoImportPath}$`) }, async () => {
+                return {
+                  contents: `
 import { HonoBase } from 'hono/hono-base'
 ${importStatement}
 export class Hono extends HonoBase {
@@ -187,15 +220,16 @@ export class Hono extends HonoBase {
   }
 }
 `
-              };
-            });
+                };
+              });
+            }
           }
-        }
-      ]
-    });
-    const outfileStat = statSync(outfile);
-    console.log(`  Output: ${options.outfile} (${(outfileStat.size / 1024).toFixed(2)} KB)`);
-  });
+        ]
+      });
+      const outfileStat = statSync(outfile);
+      console.log(`  Output: ${options.outfile} (${(outfileStat.size / 1024).toFixed(2)} KB)`);
+    }
+  );
 }
 
 // src/commands/request/index.ts
@@ -203,7 +237,7 @@ import { existsSync as existsSync2, realpathSync as realpathSync2 } from "fs";
 import { resolve as resolve2 } from "path";
 var DEFAULT_ENTRY_CANDIDATES2 = ["src/index.ts", "src/index.tsx", "src/index.js", "src/index.jsx"];
 function requestCommand(program2) {
-  program2.command("request").description("Send request to Hono app using app.request()").argument("[file]", "Path to the Hono app file").option("-P, --path <path>", "Request path", "/").option("-X, --method <method>", "HTTP method", "GET").option("-d, --data <data>", "Request body data").option(
+  program2.command("request").description("Send request to Hono app using app.request()").argument("[file]", "Path to the Hono app file").option("-P, --path <path>", "Request path", "/").option("-X, --method <method>", "HTTP method", "GET").option("-d, --data <data>", "Request body data").option("-w, --watch", "Watch for changes and resend request", false).option(
     "-H, --header <header>",
     "Custom headers",
     (value, previous) => {
@@ -212,11 +246,15 @@ function requestCommand(program2) {
     []
   ).action(async (file, options) => {
     const path = options.path || "/";
-    const result = await executeRequest(file, path, options);
-    console.log(JSON.stringify(result, null, 2));
+    const watch = options.watch;
+    const buildIterator = getBuildIterator(file, watch);
+    for await (const app of buildIterator) {
+      const result = await executeRequest(app, path, options);
+      console.log(JSON.stringify(result, null, 2));
+    }
   });
 }
-async function executeRequest(appPath, requestPath, options) {
+function getBuildIterator(appPath, watch) {
   let entry;
   let resolvedAppPath;
   if (appPath) {
@@ -230,12 +268,12 @@ async function executeRequest(appPath, requestPath, options) {
     throw new Error(`Entry file ${entry} does not exist`);
   }
   const appFilePath = realpathSync2(resolvedAppPath);
-  const app = await buildAndImportApp(appFilePath, {
-    external: ["@hono/node-server"]
+  return buildAndImportApp(appFilePath, {
+    external: ["@hono/node-server"],
+    watch
   });
-  if (!app || typeof app.request !== "function") {
-    throw new Error("No valid Hono app exported from the file");
-  }
+}
+async function executeRequest(app, requestPath, options) {
   const url = new URL(requestPath, "http://localhost");
   const requestInit = {
     method: options.method || "GET"
@@ -495,9 +533,10 @@ function serveCommand(program2) {
           app = new Hono();
         } else {
           const appFilePath = realpathSync3(appPath);
-          app = await buildAndImportApp(appFilePath, {
+          const buildIterator = buildAndImportApp(appFilePath, {
             external: ["@hono/node-server"]
           });
+          app = (await buildIterator.next()).value;
         }
       }
       const allFunctions = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hono/cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "bin": {
     "hono": "dist/cli.js"