honox 0.1.21 → 0.1.23

package/README.md

@@ -93,6 +93,7 @@ There are three ways to define routes.
 Each route should return an array of `Handler | MiddlewareHandler`. `createRoute()` is a helper function to return it. You can write a route for a GET request with `default export`.
 
 ```tsx
+// app/routes/index.tsx
 // `createRoute()` helps you create handlers
 import { createRoute } from 'honox/factory'
 
@@ -108,6 +109,7 @@ export default createRoute((c) => {
 You can also handle methods other than GET by `export` `POST`, `PUT`, and `DELETE`.
 
 ```tsx
+// app/routes/index.tsx
 import { createRoute } from 'honox/factory'
 import { getCookie, setCookie } from 'hono/cookie'
 
@@ -157,6 +159,7 @@ export default app
 Or simply, you can just return JSX.
 
 ```tsx
+// app/routes/index.tsx
 export default function Home(_c: Context) {
   return <h1>Welcome!</h1>
 }
@@ -660,21 +663,17 @@ Finally, add `vite.config.ts` configuration to output assets for the production.
 ```ts
 import honox from 'honox/vite'
 import { defineConfig } from 'vite'
+import pages from '@hono/vite-cloudflare-pages'
 
-export default defineConfig(({ mode }) => {
-  if (mode === 'client') {
-    return {
-      build: {
-        rollupOptions: {
-          input: ['/app/style.css'],
-        },
+export default defineConfig({
+  plugins: [
+    honox({
+      client: {
+        input: ['/app/style.css'],
       },
-    }
-  } else {
-    return {
-      plugins: [honox()],
-    }
-  }
+    }),
+    pages(),
+  ],
 })
 ```
 
@@ -690,13 +689,10 @@ import remarkFrontmatter from 'remark-frontmatter'
 import remarkMdxFrontmatter from 'remark-mdx-frontmatter'
 import { defineConfig } from 'vite'
 
-const entry = './app/server.ts'
-
 export default defineConfig(() => {
   return {
     plugins: [
       honox(),
-      devServer({ entry }),
       mdx({
         jsxImportSource: 'hono/jsx',
         remarkPlugins: [remarkFrontmatter, remarkMdxFrontmatter],
@@ -800,28 +796,6 @@ export default defineConfig({
 })
 ```
 
-If you want to include client-side scripts and assets:
-
-```ts
-// vite.config.ts
-import pages from '@hono/vite-cloudflare-pages'
-import honox from 'honox/vite'
-import client from 'honox/vite/client'
-import { defineConfig } from 'vite'
-
-export default defineConfig(({ mode }) => {
-  if (mode === 'client') {
-    return {
-      plugins: [client()],
-    }
-  } else {
-    return {
-      plugins: [honox(), pages()],
-    }
-  }
-})
-```
-
 Build command (including a client):
 
 ```txt

package/dist/server/server.js

@@ -49,6 +49,7 @@ const createApp = (options) => {
     paths.sort((a, b) => a.split("/").length - b.split("/").length);
     return paths;
   };
+  const errorHandlerMap = {};
   for (const map of routesMap) {
     for (const [dir, content] of Object.entries(map)) {
       const subApp = new Hono();
@@ -105,7 +106,16 @@ const createApp = (options) => {
           });
         }
       }
-      applyError(subApp, dir, errorMap);
+      const errorHandler = getErrorHandler(dir, errorMap);
+      if (errorHandler) {
+        errorHandlerMap[dir] = errorHandler;
+      }
+      for (const [path, errorHandler2] of Object.entries(errorHandlerMap)) {
+        const regExp = new RegExp(`^${path}`);
+        if (regExp.test(dir) && errorHandler2) {
+          subApp.onError(errorHandler2);
+        }
+      }
       let rootPath = getRootPath(dir);
       if (trailingSlash) {
         rootPath = /\/$/.test(rootPath) ? rootPath : rootPath + "/";
@@ -143,20 +153,23 @@ function applyNotFound(app, dir, map) {
     }
   }
 }
-function applyError(app, dir, map) {
+function getErrorHandler(dir, map) {
   for (const [mapDir, content] of Object.entries(map)) {
     if (dir === mapDir) {
       const errorFile = content[ERROR_FILENAME];
       if (errorFile) {
-        const errorHandler = errorFile.default;
-        app.onError(async (error, c) => {
-          const importingIslands = errorFile[IMPORTING_ISLANDS_ID];
-          if (importingIslands) {
-            c.set(IMPORTING_ISLANDS_ID, importingIslands);
-          }
-          c.status(500);
-          return errorHandler(error, c);
-        });
+        const matchedErrorHandler = errorFile.default;
+        if (matchedErrorHandler) {
+          const errorHandler = async (error, c) => {
+            const importingIslands = errorFile[IMPORTING_ISLANDS_ID];
+            if (importingIslands) {
+              c.set(IMPORTING_ISLANDS_ID, importingIslands);
+            }
+            c.status(500);
+            return matchedErrorHandler(error, c);
+          };
+          return errorHandler;
+        }
       }
     }
   }

package/dist/server/with-defaults.js

@@ -19,8 +19,8 @@ const createApp = (options) => {
     }),
     ROUTES: options?.ROUTES ?? import.meta.glob(
       [
-        "/app/routes/**/!(_*|*.test|*.spec).(ts|tsx|md|mdx)",
-        "/app/routes/.well-known/!(_*|*.test|*.spec).(ts|tsx|md|mdx)"
+        "/app/routes/**/!(_*|$*|*.test|*.spec).(ts|tsx|md|mdx)",
+        "/app/routes/.well-known/!(_*|$*|*.test|*.spec).(ts|tsx|md|mdx)"
       ],
       {
         eager: true

package/dist/vite/client.d.ts

@@ -1,10 +1,11 @@
 import { Plugin } from 'vite';
 
-type Options = {
+type ClientOptions = {
     jsxImportSource?: string;
     assetsDir?: string;
+    input?: string[];
 };
-declare const defaultOptions: Options;
-declare function client(options?: Options): Plugin;
+declare const defaultOptions: ClientOptions;
+declare function client(options?: ClientOptions): Plugin;
 
-export { client as default, defaultOptions };
+export { type ClientOptions, client as default, defaultOptions };

package/dist/vite/client.js

@@ -1,15 +1,23 @@
 const defaultOptions = {
   jsxImportSource: "hono/jsx/dom",
-  assetsDir: "static"
+  assetsDir: "static",
+  input: []
 };
 function client(options) {
   return {
     name: "honox-vite-client",
+    apply: (_config, { command, mode }) => {
+      if (command === "build" && mode === "client") {
+        return true;
+      }
+      return false;
+    },
     config: () => {
+      const input = options?.input ?? defaultOptions.input ?? [];
       return {
         build: {
           rollupOptions: {
-            input: ["/app/client.ts"]
+            input: ["/app/client.ts", ...input]
           },
           assetsDir: options?.assetsDir ?? defaultOptions.assetsDir,
           manifest: true

package/dist/vite/index.d.ts

@@ -3,12 +3,14 @@ export { defaultOptions as devServerDefaultOptions } from '@hono/vite-dev-server
 import { PluginOption } from 'vite';
 import { IslandComponentsOptions } from './island-components.js';
 export { islandComponents } from './island-components.js';
+import { ClientOptions } from './client.js';
 
 type Options = {
     islands?: boolean;
     entry?: string;
     devServer?: DevServerOptions;
     islandComponents?: IslandComponentsOptions;
+    client?: ClientOptions;
     external?: string[];
 };
 declare const defaultOptions: Options;

package/dist/vite/index.js

@@ -3,6 +3,7 @@ import devServer, { defaultOptions as devServerDefaultOptions } from "@hono/vite
 import { injectImportingIslands } from "./inject-importing-islands.js";
 import { islandComponents } from "./island-components.js";
 import { restartOnAddUnlink } from "./restart-on-add-unlink.js";
+import client from "./client.js";
 const defaultOptions = {
   islands: true,
   entry: path.join(process.cwd(), "./app/server.ts")
@@ -27,6 +28,7 @@ function honox(options) {
   }
   plugins.push(injectImportingIslands());
   plugins.push(restartOnAddUnlink());
+  plugins.push(client(options?.client));
   return [
     {
       name: "honox-vite-config",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "honox",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "main": "dist/index.js",
   "type": "module",
   "scripts": {
@@ -112,7 +112,7 @@
     "@babel/parser": "^7.23.6",
     "@babel/traverse": "^7.23.6",
     "@babel/types": "^7.23.6",
-    "@hono/vite-dev-server": "^0.12.1",
+    "@hono/vite-dev-server": "^0.12.2",
     "jsonc-parser": "^3.2.1",
     "precinct": "^12.0.2"
   },