honox 0.0.0 → 0.0.1

package/dist/constants.js

@@ -0,0 +1,6 @@
+const COMPONENT_NAME = "component-name";
+const DATA_SERIALIZED_PROPS = "data-serialized-props";
+export {
+  COMPONENT_NAME,
+  DATA_SERIALIZED_PROPS
+};

package/dist/factory/factory.d.ts

@@ -0,0 +1,19 @@
+import * as hono_types from 'hono/types';
+import * as hono from 'hono';
+import { Env, Hono } from 'hono';
+
+declare const createRoute: {
+    <I extends hono.Input = {}>(handler1: hono_types.H<Env, any, I>): [hono_types.H<Env, any, I>];
+    <I_1 extends hono.Input = {}, I2 extends hono.Input = I_1, R extends hono_types.HandlerResponse<any> = any>(handler1: hono_types.H<Env, any, I_1, R>, handler2: hono_types.H<Env, any, I2, R>): [hono_types.H<Env, any, I_1, R>, hono_types.H<Env, any, I2, R>];
+    <I_2 extends hono.Input = {}, I2_1 extends hono.Input = I_2, I3 extends hono.Input = I_2 & I2_1, R_1 extends hono_types.HandlerResponse<any> = any>(handler1: hono_types.H<Env, any, I_2, R_1>, handler2: hono_types.H<Env, any, I2_1, R_1>, handler3: hono_types.H<Env, any, I3, R_1>): [hono_types.H<Env, any, I_2, R_1>, hono_types.H<Env, any, I2_1, R_1>, hono_types.H<Env, any, I3, R_1>];
+    <I_3 extends hono.Input = {}, I2_2 extends hono.Input = I_3, I3_1 extends hono.Input = I_3 & I2_2, I4 extends hono.Input = I_3 & I2_2 & I3_1, R_2 extends hono_types.HandlerResponse<any> = any>(handler1: hono_types.H<Env, any, I_3, R_2>, handler2: hono_types.H<Env, any, I2_2, R_2>, handler3: hono_types.H<Env, any, I3_1, R_2>, handler4: hono_types.H<Env, any, I4, R_2>): [hono_types.H<Env, any, I_3, R_2>, hono_types.H<Env, any, I2_2, R_2>, hono_types.H<Env, any, I3_1, R_2>, hono_types.H<Env, any, I4, R_2>];
+    <I_4 extends hono.Input = {}, I2_3 extends hono.Input = I_4, I3_2 extends hono.Input = I_4 & I2_3, I4_1 extends hono.Input = I_4 & I2_3 & I3_2, I5 extends hono.Input = I_4 & I2_3 & I3_2 & I4_1, R_3 extends hono_types.HandlerResponse<any> = any>(handler1: hono_types.H<Env, any, I_4, R_3>, handler2: hono_types.H<Env, any, I2_3, R_3>, handler3: hono_types.H<Env, any, I3_2, R_3>, handler4: hono_types.H<Env, any, I4_1, R_3>, handler5: hono_types.H<Env, any, I5, R_3>): [hono_types.H<Env, any, I_4, R_3>, hono_types.H<Env, any, I2_3, R_3>, hono_types.H<Env, any, I3_2, R_3>, hono_types.H<Env, any, I4_1, R_3>, hono_types.H<Env, any, I5, R_3>];
+    <I_5 extends hono.Input = {}, I2_4 extends hono.Input = I_5, I3_3 extends hono.Input = I_5 & I2_4, I4_2 extends hono.Input = I_5 & I2_4 & I3_3, I5_1 extends hono.Input = I_5 & I2_4 & I3_3 & I4_2, I6 extends hono.Input = I_5 & I2_4 & I3_3 & I4_2 & I5_1, R_4 extends hono_types.HandlerResponse<any> = any>(handler1: hono_types.H<Env, any, I_5, R_4>, handler2: hono_types.H<Env, any, I2_4, R_4>, handler3: hono_types.H<Env, any, I3_3, R_4>, handler4: hono_types.H<Env, any, I4_2, R_4>, handler5: hono_types.H<Env, any, I5_1, R_4>, handler6: hono_types.H<Env, any, I6, R_4>): [hono_types.H<Env, any, I_5, R_4>, hono_types.H<Env, any, I2_4, R_4>, hono_types.H<Env, any, I3_3, R_4>, hono_types.H<Env, any, I4_2, R_4>, hono_types.H<Env, any, I5_1, R_4>, hono_types.H<Env, any, I6, R_4>];
+    <I_6 extends hono.Input = {}, I2_5 extends hono.Input = I_6, I3_4 extends hono.Input = I_6 & I2_5, I4_3 extends hono.Input = I_6 & I2_5 & I3_4, I5_2 extends hono.Input = I_6 & I2_5 & I3_4 & I4_3, I6_1 extends hono.Input = I_6 & I2_5 & I3_4 & I4_3 & I5_2, I7 extends hono.Input = I_6 & I2_5 & I3_4 & I4_3 & I5_2 & I6_1, R_5 extends hono_types.HandlerResponse<any> = any>(handler1: hono_types.H<Env, any, I_6, R_5>, handler2: hono_types.H<Env, any, I2_5, R_5>, handler3: hono_types.H<Env, any, I3_4, R_5>, handler4: hono_types.H<Env, any, I4_3, R_5>, handler5: hono_types.H<Env, any, I5_2, R_5>, handler6: hono_types.H<Env, any, I6_1, R_5>, handler7: hono_types.H<Env, any, I7, R_5>): [hono_types.H<Env, any, I_6, R_5>, hono_types.H<Env, any, I2_5, R_5>, hono_types.H<Env, any, I3_4, R_5>, hono_types.H<Env, any, I4_3, R_5>, hono_types.H<Env, any, I5_2, R_5>, hono_types.H<Env, any, I6_1, R_5>, hono_types.H<Env, any, I7, R_5>];
+    <I_7 extends hono.Input = {}, I2_6 extends hono.Input = I_7, I3_5 extends hono.Input = I_7 & I2_6, I4_4 extends hono.Input = I_7 & I2_6 & I3_5, I5_3 extends hono.Input = I_7 & I2_6 & I3_5 & I4_4, I6_2 extends hono.Input = I_7 & I2_6 & I3_5 & I4_4 & I5_3, I7_1 extends hono.Input = I_7 & I2_6 & I3_5 & I4_4 & I5_3 & I6_2, I8 extends hono.Input = I_7 & I2_6 & I3_5 & I4_4 & I5_3 & I6_2 & I7_1, R_6 extends hono_types.HandlerResponse<any> = any>(handler1: hono_types.H<Env, any, I_7, R_6>, handler2: hono_types.H<Env, any, I2_6, R_6>, handler3: hono_types.H<Env, any, I3_5, R_6>, handler4: hono_types.H<Env, any, I4_4, R_6>, handler5: hono_types.H<Env, any, I5_3, R_6>, handler6: hono_types.H<Env, any, I6_2, R_6>, handler7: hono_types.H<Env, any, I7_1, R_6>, handler8: hono_types.H<Env, any, I8, R_6>): [hono_types.H<Env, any, I_7, R_6>, hono_types.H<Env, any, I2_6, R_6>, hono_types.H<Env, any, I3_5, R_6>, hono_types.H<Env, any, I4_4, R_6>, hono_types.H<Env, any, I5_3, R_6>, hono_types.H<Env, any, I6_2, R_6>, hono_types.H<Env, any, I7_1, R_6>, hono_types.H<Env, any, I8, R_6>];
+    <I_8 extends hono.Input = {}, I2_7 extends hono.Input = I_8, I3_6 extends hono.Input = I_8 & I2_7, I4_5 extends hono.Input = I_8 & I2_7 & I3_6, I5_4 extends hono.Input = I_8 & I2_7 & I3_6 & I4_5, I6_3 extends hono.Input = I_8 & I2_7 & I3_6 & I4_5 & I5_4, I7_2 extends hono.Input = I_8 & I2_7 & I3_6 & I4_5 & I5_4 & I6_3, I8_1 extends hono.Input = I_8 & I2_7 & I3_6 & I4_5 & I5_4 & I6_3 & I7_2, I9 extends hono.Input = I_8 & I2_7 & I3_6 & I4_5 & I5_4 & I6_3 & I7_2 & I8_1, R_7 extends hono_types.HandlerResponse<any> = any>(handler1: hono_types.H<Env, any, I_8, R_7>, handler2: hono_types.H<Env, any, I2_7, R_7>, handler3: hono_types.H<Env, any, I3_6, R_7>, handler4: hono_types.H<Env, any, I4_5, R_7>, handler5: hono_types.H<Env, any, I5_4, R_7>, handler6: hono_types.H<Env, any, I6_3, R_7>, handler7: hono_types.H<Env, any, I7_2, R_7>, handler8: hono_types.H<Env, any, I8_1, R_7>, handler9: hono_types.H<Env, any, I9, R_7>): [hono_types.H<Env, any, I_8, R_7>, hono_types.H<Env, any, I2_7, R_7>, hono_types.H<Env, any, I3_6, R_7>, hono_types.H<Env, any, I4_5, R_7>, hono_types.H<Env, any, I5_4, R_7>, hono_types.H<Env, any, I6_3, R_7>, hono_types.H<Env, any, I7_2, R_7>, hono_types.H<Env, any, I8_1, R_7>, hono_types.H<Env, any, I9, R_7>];
+    <I_9 extends hono.Input = {}, I2_8 extends hono.Input = I_9, I3_7 extends hono.Input = I_9 & I2_8, I4_6 extends hono.Input = I_9 & I2_8 & I3_7, I5_5 extends hono.Input = I_9 & I2_8 & I3_7 & I4_6, I6_4 extends hono.Input = I_9 & I2_8 & I3_7 & I4_6 & I5_5, I7_3 extends hono.Input = I_9 & I2_8 & I3_7 & I4_6 & I5_5 & I6_4, I8_2 extends hono.Input = I_9 & I2_8 & I3_7 & I4_6 & I5_5 & I6_4 & I7_3, I9_1 extends hono.Input = I_9 & I2_8 & I3_7 & I4_6 & I5_5 & I6_4 & I7_3 & I8_2, I10 extends hono.Input = I_9 & I2_8 & I3_7 & I4_6 & I5_5 & I6_4 & I7_3 & I8_2 & I9_1, R_8 extends hono_types.HandlerResponse<any> = any>(handler1: hono_types.H<Env, any, I_9, R_8>, handler2: hono_types.H<Env, any, I2_8, R_8>, handler3: hono_types.H<Env, any, I3_7, R_8>, handler4: hono_types.H<Env, any, I4_6, R_8>, handler5: hono_types.H<Env, any, I5_5, R_8>, handler6: hono_types.H<Env, any, I6_4, R_8>, handler7: hono_types.H<Env, any, I7_3, R_8>, handler8: hono_types.H<Env, any, I8_2, R_8>, handler9: hono_types.H<Env, any, I9_1, R_8>, handler10: hono_types.H<Env, any, I10, R_8>): [hono_types.H<Env, any, I_9, R_8>, hono_types.H<Env, any, I2_8, R_8>, hono_types.H<Env, any, I3_7, R_8>, hono_types.H<Env, any, I4_6, R_8>, hono_types.H<Env, any, I5_5, R_8>, hono_types.H<Env, any, I6_4, R_8>, hono_types.H<Env, any, I7_3, R_8>, hono_types.H<Env, any, I8_2, R_8>, hono_types.H<Env, any, I9_1, R_8>, hono_types.H<Env, any, I10, R_8>];
+};
+declare const createHono: () => Hono<Env, hono_types.BlankSchema, "/">;
+
+export { createHono, createRoute };

package/dist/factory/factory.js

@@ -0,0 +1,11 @@
+import { Hono } from "hono";
+import { createFactory } from "hono/factory";
+const factory = createFactory();
+const createRoute = factory.createHandlers;
+const createHono = () => {
+  return new Hono();
+};
+export {
+  createHono,
+  createRoute
+};

package/dist/factory/index.d.ts

@@ -0,0 +1,3 @@
+export { createHono, createRoute } from './factory.js';
+import 'hono/types';
+import 'hono';

package/dist/factory/index.js

@@ -0,0 +1,5 @@
+import { createRoute, createHono } from "./factory.js";
+export {
+  createHono,
+  createRoute
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/server/index.d.ts

@@ -0,0 +1,3 @@
+export { ServerOptions, createApp } from './server.js';
+import 'hono/types';
+import 'hono';

package/dist/server/index.js

@@ -0,0 +1,4 @@
+import { createApp } from "./server.js";
+export {
+  createApp
+};

package/dist/server/server.d.ts

@@ -0,0 +1,32 @@
+import * as hono_types from 'hono/types';
+import { H } from 'hono/types';
+import { Env, Hono, MiddlewareHandler, NotFoundHandler, ErrorHandler } from 'hono';
+
+declare const METHODS: readonly ["GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"];
+type RouteFile = {
+    default?: Function;
+} & {
+    [M in (typeof METHODS)[number]]?: H[];
+};
+type RendererFile = {
+    default: MiddlewareHandler;
+};
+type NotFoundFile = {
+    default: NotFoundHandler;
+};
+type ErrorFile = {
+    default: ErrorHandler;
+};
+type InitFunction<E extends Env = Env> = (app: Hono<E>) => void;
+type ServerOptions<E extends Env = Env> = {
+    ROUTES?: Record<string, RouteFile>;
+    RENDERER?: Record<string, RendererFile>;
+    NOT_FOUND?: Record<string, NotFoundFile>;
+    ERROR?: Record<string, ErrorFile>;
+    root?: string;
+    app?: Hono<E>;
+    init?: InitFunction<E>;
+};
+declare const createApp: <E extends Env>(options?: ServerOptions<E> | undefined) => Hono<E, hono_types.BlankSchema, "/">;
+
+export { type ServerOptions, createApp };

package/dist/server/server.js

@@ -0,0 +1,124 @@
+import { Hono } from "hono";
+import {
+  filePathToPath,
+  groupByDirectory,
+  listByDirectory,
+  pathToDirectoryPath,
+  sortDirectoriesByDepth
+} from "../utils/file.js";
+const NOTFOUND_FILENAME = "_404.tsx";
+const ERROR_FILENAME = "_error.tsx";
+const METHODS = ["GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"];
+const createApp = (options) => {
+  const root = options?.root ?? "/app/routes";
+  const rootRegExp = new RegExp(`^${root}`);
+  const app = options?.app ?? new Hono();
+  if (options?.init) {
+    options.init(app);
+  }
+  const NOT_FOUND_FILE = options?.NOT_FOUND ?? import.meta.glob("/app/routes/**/_404.(ts|tsx)", {
+    eager: true
+  });
+  const notFoundMap = groupByDirectory(NOT_FOUND_FILE);
+  const ERROR_FILE = options?.ERROR ?? import.meta.glob("/app/routes/**/_error.(ts|tsx)", {
+    eager: true
+  });
+  const errorMap = groupByDirectory(ERROR_FILE);
+  const RENDERER_FILE = options?.RENDERER ?? import.meta.glob("/app/routes/**/_renderer.tsx", {
+    eager: true
+  });
+  const rendererList = listByDirectory(RENDERER_FILE);
+  const applyRenderer = (rendererFile) => {
+    const renderer = RENDERER_FILE[rendererFile];
+    const path = pathToDirectoryPath(rendererFile).replace(rootRegExp, "");
+    app.all(`${filePathToPath(path)}*`, renderer.default);
+  };
+  const ROUTES_FILE = options?.ROUTES ?? import.meta.glob("/app/routes/**/[!_]*.(ts|tsx|mdx)", {
+    eager: true
+  });
+  const routesMap = sortDirectoriesByDepth(groupByDirectory(ROUTES_FILE));
+  for (const map of routesMap) {
+    for (const [dir, content] of Object.entries(map)) {
+      const subApp = new Hono();
+      let rendererFiles = rendererList[dir];
+      if (rendererFiles) {
+        applyRenderer(rendererFiles[0]);
+      }
+      if (!rendererFiles) {
+        const dirPaths = dir.split("/");
+        const getRendererPaths = (paths) => {
+          rendererFiles = rendererList[paths.join("/")];
+          if (!rendererFiles) {
+            paths.pop();
+            if (paths.length) {
+              getRendererPaths(paths);
+            }
+          }
+          return rendererFiles;
+        };
+        rendererFiles = getRendererPaths(dirPaths);
+        if (rendererFiles) {
+          applyRenderer(rendererFiles[0]);
+        }
+      }
+      let rootPath = dir.replace(rootRegExp, "");
+      rootPath = filePathToPath(rootPath);
+      for (const [filename, route] of Object.entries(content)) {
+        const routeDefault = route.default;
+        const path = filePathToPath(filename);
+        if (routeDefault && "fetch" in routeDefault) {
+          subApp.route(path, routeDefault);
+        }
+        for (const m of METHODS) {
+          const handlers = route[m];
+          if (handlers) {
+            subApp.on(m, path, ...handlers);
+          }
+        }
+        if (routeDefault && Array.isArray(routeDefault)) {
+          subApp.get(path, ...routeDefault);
+        }
+        if (typeof routeDefault === "function") {
+          subApp.get(path, (c) => {
+            return c.render(routeDefault(), route);
+          });
+        }
+      }
+      applyNotFound(subApp, dir, notFoundMap);
+      applyError(subApp, dir, errorMap);
+      app.route(rootPath, subApp);
+    }
+  }
+  return app;
+};
+function applyNotFound(app, dir, map) {
+  for (const [mapDir, content] of Object.entries(map)) {
+    if (dir === mapDir) {
+      const notFound = content[NOTFOUND_FILENAME];
+      if (notFound) {
+        const notFoundHandler = notFound.default;
+        app.get("*", (c) => {
+          c.status(404);
+          return notFoundHandler(c);
+        });
+      }
+    }
+  }
+}
+function applyError(app, dir, map) {
+  for (const [mapDir, content] of Object.entries(map)) {
+    if (dir === mapDir) {
+      const error = content[ERROR_FILENAME];
+      if (error) {
+        const errorHandler = error.default;
+        app.onError((error2, c) => {
+          c.status(500);
+          return errorHandler(error2, c);
+        });
+      }
+    }
+  }
+}
+export {
+  createApp
+};

package/dist/types.d.ts

@@ -0,0 +1,5 @@
+/** JSX */
+type CreateElement = (type: any, props: any, ...children: any[]) => Node | Promise<Node>;
+type Hydrate = (children: Node, parent: Element) => void | Promise<void>;
+
+export type { CreateElement, Hydrate };

package/dist/utils/file.d.ts

@@ -0,0 +1,7 @@
+declare const filePathToPath: (filePath: string) => string;
+declare const groupByDirectory: <T = unknown>(files: Record<string, T>) => Record<string, Record<string, T>>;
+declare const sortDirectoriesByDepth: <T>(directories: Record<string, T>) => Record<string, T>[];
+declare const listByDirectory: <T = unknown>(files: Record<string, T>) => Record<string, string[]>;
+declare const pathToDirectoryPath: (path: string) => string;
+
+export { filePathToPath, groupByDirectory, listByDirectory, pathToDirectoryPath, sortDirectoriesByDepth };

package/dist/utils/file.js

@@ -0,0 +1,77 @@
+const filePathToPath = (filePath) => {
+  filePath = filePath.replace(/\.tsx?$/g, "").replace(/\.mdx$/g, "").replace(/^\/?index/, "/").replace(/\/index/, "").replace(/\[\.{3}.+\]/, "*").replace(/\[(.+)\]/, ":$1");
+  return /^\//.test(filePath) ? filePath : "/" + filePath;
+};
+const groupByDirectory = (files) => {
+  const organizedFiles = {};
+  for (const [path, content] of Object.entries(files)) {
+    const pathParts = path.split("/");
+    const fileName = pathParts.pop();
+    const directory = pathParts.join("/");
+    if (!organizedFiles[directory]) {
+      organizedFiles[directory] = {};
+    }
+    if (fileName) {
+      organizedFiles[directory][fileName] = content;
+    }
+  }
+  for (const [directory, files2] of Object.entries(organizedFiles)) {
+    const sortedEntries = Object.entries(files2).sort(([keyA], [keyB]) => {
+      if (keyA[0] === "[" && keyB[0] !== "[") {
+        return 1;
+      }
+      if (keyA[0] !== "[" && keyB[0] === "[") {
+        return -1;
+      }
+      return keyA.localeCompare(keyB);
+    });
+    organizedFiles[directory] = Object.fromEntries(sortedEntries);
+  }
+  return organizedFiles;
+};
+const sortDirectoriesByDepth = (directories) => {
+  const sortedKeys = Object.keys(directories).sort((a, b) => {
+    const depthA = a.split("/").length;
+    const depthB = b.split("/").length;
+    return depthB - depthA;
+  });
+  const sortedDirectories = sortedKeys.map((key) => {
+    return { [key]: directories[key] };
+  });
+  return sortedDirectories;
+};
+const listByDirectory = (files) => {
+  const organizedFiles = {};
+  for (const path of Object.keys(files)) {
+    const pathParts = path.split("/");
+    pathParts.pop();
+    const directory = pathParts.join("/");
+    if (!organizedFiles[directory]) {
+      organizedFiles[directory] = [];
+    }
+    if (!organizedFiles[directory].includes(path)) {
+      organizedFiles[directory].push(path);
+    }
+  }
+  const directories = Object.keys(organizedFiles).sort((a, b) => b.length - a.length);
+  for (const dir of directories) {
+    for (const subDir of directories) {
+      if (subDir.startsWith(dir) && subDir !== dir) {
+        const uniqueFiles = /* @__PURE__ */ new Set([...organizedFiles[subDir], ...organizedFiles[dir]]);
+        organizedFiles[subDir] = [...uniqueFiles];
+      }
+    }
+  }
+  return organizedFiles;
+};
+const pathToDirectoryPath = (path) => {
+  const dirPath = path.replace(/[^\/]+$/, "");
+  return dirPath;
+};
+export {
+  filePathToPath,
+  groupByDirectory,
+  listByDirectory,
+  pathToDirectoryPath,
+  sortDirectoriesByDepth
+};

package/dist/vite/index.d.ts

@@ -0,0 +1,15 @@
+import { DevServerOptions } from '@hono/vite-dev-server';
+export { defaultOptions as devServerDefaultOptions } from '@hono/vite-dev-server';
+import { PluginOption } from 'vite';
+export { islandComponents } from './island-components.js';
+
+type HonoXOptions = {
+    islands?: boolean;
+    entry?: string;
+    devServer?: DevServerOptions;
+    external?: string[];
+};
+declare const defaultOptions: HonoXOptions;
+declare function honox(options?: HonoXOptions): PluginOption[];
+
+export { honox as default, defaultOptions };

package/dist/vite/index.js

@@ -0,0 +1,39 @@
+import path from "path";
+import devServer, { defaultOptions as devServerDefaultOptions } from "@hono/vite-dev-server";
+import { islandComponents } from "./island-components.js";
+const defaultOptions = {
+  islands: true,
+  entry: path.join(process.cwd(), "./app/server.ts")
+};
+function honox(options) {
+  const plugins = [];
+  const entry = options?.entry ?? defaultOptions.entry;
+  plugins.push(
+    devServer({
+      entry,
+      exclude: [
+        ...devServerDefaultOptions.exclude,
+        /^\/app\/.+/,
+        /^\/favicon.ico/,
+        /^\/static\/.+/
+      ],
+      ...options?.devServer
+    })
+  );
+  if (options?.islands !== false) {
+    plugins.push(islandComponents());
+  }
+  return [
+    {
+      name: "honox-vite-config"
+    },
+    ...plugins
+  ];
+}
+var vite_default = honox;
+export {
+  vite_default as default,
+  defaultOptions,
+  devServerDefaultOptions,
+  islandComponents
+};

package/dist/vite/island-components.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from 'vite';
+
+declare const transformJsxTags: (contents: string, componentName: string) => string | undefined;
+declare function islandComponents(): Plugin;
+
+export { islandComponents, transformJsxTags };

package/dist/vite/island-components.js

@@ -0,0 +1,128 @@
+import fs from "fs/promises";
+import _generate from "@babel/generator";
+const generate = _generate.default ?? _generate;
+import { parse } from "@babel/parser";
+import _traverse from "@babel/traverse";
+const traverse = _traverse.default ?? _traverse;
+import {
+  identifier,
+  jsxAttribute,
+  jsxClosingElement,
+  jsxElement,
+  jsxIdentifier,
+  jsxOpeningElement,
+  stringLiteral,
+  callExpression,
+  variableDeclarator,
+  variableDeclaration,
+  functionExpression,
+  blockStatement,
+  returnStatement,
+  jsxSpreadAttribute,
+  jsxExpressionContainer,
+  exportDefaultDeclaration,
+  conditionalExpression,
+  memberExpression
+} from "@babel/types";
+import { COMPONENT_NAME, DATA_SERIALIZED_PROPS } from "../constants.js";
+function addSSRCheck(funcName, componentName, isAsync = false) {
+  const isSSR = memberExpression(
+    memberExpression(identifier("import"), identifier("meta")),
+    identifier("env.SSR")
+  );
+  const serializedProps = callExpression(identifier("JSON.stringify"), [identifier("props")]);
+  const ssrElement = jsxElement(
+    jsxOpeningElement(
+      jsxIdentifier("honox-island"),
+      [
+        jsxAttribute(jsxIdentifier(COMPONENT_NAME), stringLiteral(componentName)),
+        jsxAttribute(jsxIdentifier(DATA_SERIALIZED_PROPS), jsxExpressionContainer(serializedProps))
+      ],
+      false
+    ),
+    jsxClosingElement(jsxIdentifier("honox-island")),
+    [
+      jsxElement(
+        jsxOpeningElement(
+          jsxIdentifier(funcName),
+          [jsxSpreadAttribute(identifier("props"))],
+          false
+        ),
+        jsxClosingElement(jsxIdentifier(funcName)),
+        []
+      )
+    ]
+  );
+  const clientElement = jsxElement(
+    jsxOpeningElement(jsxIdentifier(funcName), [jsxSpreadAttribute(identifier("props"))], false),
+    jsxClosingElement(jsxIdentifier(funcName)),
+    []
+  );
+  const returnStmt = returnStatement(conditionalExpression(isSSR, ssrElement, clientElement));
+  const functionExpr = functionExpression(null, [identifier("props")], blockStatement([returnStmt]));
+  if (isAsync) {
+    functionExpr.async = true;
+  }
+  return functionExpr;
+}
+const transformJsxTags = (contents, componentName) => {
+  const ast = parse(contents, {
+    sourceType: "module",
+    plugins: ["typescript", "jsx"]
+  });
+  if (ast) {
+    traverse(ast, {
+      ExportDefaultDeclaration(path) {
+        if (path.node.declaration.type === "FunctionDeclaration") {
+          const functionId = path.node.declaration.id;
+          if (!functionId)
+            return;
+          const isAsync = path.node.declaration.async;
+          const originalFunctionId = identifier(functionId.name + "Original");
+          const originalFunction = functionExpression(
+            null,
+            path.node.declaration.params,
+            path.node.declaration.body
+          );
+          if (isAsync) {
+            originalFunction.async = true;
+          }
+          path.insertBefore(
+            variableDeclaration("const", [variableDeclarator(originalFunctionId, originalFunction)])
+          );
+          const wrappedFunction = addSSRCheck(originalFunctionId.name, componentName, isAsync);
+          const wrappedFunctionId = identifier("Wrapped" + functionId.name);
+          path.replaceWith(
+            variableDeclaration("const", [variableDeclarator(wrappedFunctionId, wrappedFunction)])
+          );
+          path.insertAfter(exportDefaultDeclaration(wrappedFunctionId));
+        }
+      }
+    });
+    const { code } = generate(ast);
+    return code;
+  }
+};
+function islandComponents() {
+  return {
+    name: "transform-island-components",
+    async load(id) {
+      const match = id.match(/\/islands\/(.+?\.tsx)$/);
+      if (match) {
+        const componentName = match[1];
+        const contents = await fs.readFile(id, "utf-8");
+        const code = transformJsxTags(contents, componentName);
+        if (code) {
+          return {
+            code,
+            map: null
+          };
+        }
+      }
+    }
+  };
+}
+export {
+  islandComponents,
+  transformJsxTags
+};

package/package.json

@@ -1,6 +1,116 @@
 {
   "name": "honox",
-  "version": "0.0.0",
-  "main": "index.js",
-  "license": "MIT"
-}
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "type": "module",
+  "scripts": {
+    "test": "bun typecheck && bun test:unit && bun test:integration && bun test:e2e",
+    "test:unit": "vitest --run test/unit",
+    "test:integration": "bun test:integration:api && bun test:integration:hono-jsx",
+    "test:integration:hono-jsx": "vitest run -c ./test/hono-jsx/vitest.config.ts ./test/hono-jsx/integration.test.ts",
+    "test:integration:api": "vitest run -c ./test/api/vitest.config.ts ./test/api/integration.test.ts",
+    "test:e2e": "playwright test -c ./test/hono-jsx/playwright.config.ts ./test/hono-jsx/e2e.test.ts",
+    "typecheck": "tsc --noEmit",
+    "build": "tsup && publint",
+    "watch": "tsup --watch",
+    "lint": "eslint src/**.ts",
+    "lint:fix": "eslint src/**.ts --fix",
+    "prerelease": "yarn test && yarn build",
+    "release": "np --no-yarn"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js"
+    },
+    "./factory": {
+      "types": "./dist/factory/index.d.ts",
+      "import": "./dist/factory/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js"
+    },
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "import": "./dist/client/index.js"
+    },
+    "./utils/*": {
+      "types": "./dist/utils/*.d.ts",
+      "import": "./dist/utils/*.js"
+    },
+    "./vite": {
+      "types": "./dist/vite/index.d.ts",
+      "import": "./dist/vite/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "types": [
+        "./dist/types"
+      ],
+      "factory": [
+        "./dist/factory"
+      ],
+      "server": [
+        "./dist/server"
+      ],
+      "client": [
+        "./dist/client"
+      ],
+      "utils/*": [
+        "./dist/utils/*"
+      ],
+      "vite": [
+        "./dist/vite"
+      ]
+    }
+  },
+  "author": "Yusuke Wada <yusuke@kamawada.com> (https://github.com/yusukebe)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/honojs/honox.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "homepage": "https://hono.dev",
+  "dependencies": {
+    "@babel/generator": "^7.23.6",
+    "@babel/parser": "^7.23.6",
+    "@babel/traverse": "^7.23.6",
+    "@babel/types": "^7.23.6",
+    "@hono/vite-dev-server": "^0.4.1"
+  },
+  "devDependencies": {
+    "@hono/eslint-config": "^0.0.3",
+    "@mdx-js/rollup": "^3.0.0",
+    "@playwright/test": "^1.41.0",
+    "@types/babel__generator": "^7",
+    "@types/babel__traverse": "^7",
+    "@types/node": "^20.10.5",
+    "eslint": "^8.56.0",
+    "glob": "^10.3.10",
+    "hono": "4.0.0-rc.2",
+    "np": "^9.2.0",
+    "prettier": "^3.1.1",
+    "publint": "^0.2.7",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vite": "^5.0.12",
+    "vitest": "^1.2.1"
+  },
+  "packageManager": "yarn@4.0.2",
+  "engines": {
+    "node": ">=18.14.1"
+  }
+}