hono-preact 0.1.0 → 0.2.0

package/dist/vite/adapter.d.ts

@@ -0,0 +1,29 @@
+import type { Plugin } from 'vite';
+/**
+ * Static context the framework hands an adapter. `command` and `outDir`
+ * are intentionally absent: they are not known when honoPreact() builds its
+ * plugin array. Adapters that need them read them from their own plugin
+ * hooks (config / configResolved).
+ */
+export interface HonoPreactAdapterContext {
+    /** Vite project root (process.cwd() when honoPreact() is called). */
+    root: string;
+    /** Absolute path of the framework-generated core Hono app module. */
+    coreAppModuleId: string;
+    /** Absolute path where the adapter's wrapEntry() output is written. */
+    entryWrapperId: string;
+    /** Absolute path of the user's api module, if it exists. Used by adapters
+     *  that need to reach api-module exports (e.g. the Node adapter's
+     *  WebSocket `injectWebSocket`). Undefined when the project has no api.ts. */
+    apiModuleId?: string;
+}
+/**
+ * A deployment target. `vitePlugins()` contributes the terminal build/dev
+ * plugins; `wrapEntry()` returns the platform tail that imports the core
+ * Hono app module and adapts it to the runtime.
+ */
+export interface HonoPreactAdapter {
+    name: string;
+    vitePlugins(ctx: HonoPreactAdapterContext): Plugin[];
+    wrapEntry(ctx: HonoPreactAdapterContext): string;
+}

package/dist/vite/adapter.js

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

package/dist/vite/client-shim.js

@@ -17,10 +17,11 @@ export function clientShimPlugin(clientEntry) {
     return {
         name: 'hono-preact:client-shim',
         enforce: 'pre',
-        apply(_, { command, mode }) {
-            // Inject during dev (`vite serve`) and the client build only. The SSR
-            // build runs in Node/Workers and does not need the shim.
-            return command === 'serve' || (command === 'build' && mode === 'client');
+        apply(_, { command }) {
+            // The shim is needed for dev and for the build. The `transform` hook
+            // below self-gates to the client entry module, so it never injects
+            // into SSR/worker code regardless of build environment.
+            return command === 'serve' || command === 'build';
         },
         configResolved(config) {
             resolvedEntry = path.resolve(config.root, clientEntry);

package/dist/vite/guard-strip.js

@@ -2,10 +2,33 @@ import { parse } from '@babel/parser';
 import MagicString from 'magic-string';
 import { BABEL_PARSER_PLUGINS } from './parser-options.js';
 const ISO_PACKAGE_SOURCES = new Set(['../iso/index.js', 'hono-preact']);
-const NOOP_IMPORT_SOURCE = 'hono-preact/internal';
-const NOOP_LOCAL_NAME = '__$guardNoop_hpiso';
-function collectLocalBindings(ast, targets) {
+// In the server bundle we strip anything client-only. The replacement
+// `fn` arity matches the documented `(ctx, next) => Promise<void | Outcome>`
+// shape so any user introspecting `mw.fn` sees the right signature; the
+// framework path filters on `runs` before invoking and never executes a
+// wrong-env body.
+const SERVER_BUNDLE_STRIPS = [
+    {
+        name: 'defineClientMiddleware',
+        replacement: `{ __kind: 'middleware', runs: 'client', fn: (_ctx, next) => next() }`,
+    },
+];
+// In the client bundle we strip anything server-only. Stream observers
+// fire on the server-side streaming pipeline (start/chunk/end/error/abort)
+// so they're server-only too.
+const CLIENT_BUNDLE_STRIPS = [
+    {
+        name: 'defineServerMiddleware',
+        replacement: `{ __kind: 'middleware', runs: 'server', fn: (_ctx, next) => next() }`,
+    },
+    {
+        name: 'defineStreamObserver',
+        replacement: `{ __kind: 'observer' }`,
+    },
+];
+function collectLocalBindings(ast, strips) {
     const bindings = new Map();
+    const byName = new Map(strips.map((s) => [s.name, s]));
     for (const node of ast.program.body) {
         if (node.type !== 'ImportDeclaration')
             continue;
@@ -17,11 +40,9 @@ function collectLocalBindings(ast, targets) {
                 continue;
             if (spec.imported.type !== 'Identifier')
                 continue;
-            const name = spec.imported.name;
-            if (name === 'defineServerGuard' || name === 'defineClientGuard') {
-                if (targets.has(name)) {
-                    bindings.set(spec.local.name, name);
-                }
+            const strategy = byName.get(spec.imported.name);
+            if (strategy) {
+                bindings.set(spec.local.name, strategy);
             }
         }
     }
@@ -38,18 +59,15 @@ function findCallsByLocalName(node, bindings, hits) {
     const n = node;
     if (n.type === 'CallExpression' &&
         n.callee?.type === 'Identifier' &&
-        n.callee.name &&
-        bindings.has(n.callee.name) &&
-        n.arguments &&
-        n.arguments.length >= 1 &&
-        n.arguments[0].start !== undefined &&
-        n.arguments[0].end !== undefined) {
-        hits.push({
-            start: n.start,
-            end: n.end,
-            argStart: n.arguments[0].start,
-            argEnd: n.arguments[0].end,
-        });
+        n.callee.name) {
+        const strategy = bindings.get(n.callee.name);
+        if (strategy && n.start !== undefined && n.end !== undefined) {
+            hits.push({
+                strategy,
+                start: n.start,
+                end: n.end,
+            });
+        }
     }
     for (const key of Object.keys(node)) {
         if (key === 'loc' ||
@@ -66,19 +84,27 @@ export function guardStripPlugin() {
         transform(code, id, options) {
             if (!/\.[jt]sx?$/.test(id))
                 return;
+            // F7: `.server.*` files are intentionally skipped in both bundles.
+            // In the client bundle the server-only stub plugin already rewrites
+            // imports of these files; in the server bundle the file's own
+            // body stays as-authored. The validation plugin restricts a
+            // `.server.*` module's named exports to the allowlist, so a user
+            // cannot land a `defineClientMiddleware(...)` value as a recognized
+            // export and ship it to the server.
             if (/\.server\.[jt]sx?$/.test(id))
                 return;
-            const stripping = options?.ssr
-                ? 'defineClientGuard'
-                : 'defineServerGuard';
-            if (!code.includes(stripping))
+            const strips = options?.ssr ? SERVER_BUNDLE_STRIPS : CLIENT_BUNDLE_STRIPS;
+            // Cheap pre-filter: only parse files that mention at least one of the
+            // symbols we strip. Avoids parsing the entire dep graph just to
+            // confirm no strips apply.
+            if (!strips.some((s) => code.includes(s.name)))
                 return;
             const ast = parse(code, {
                 sourceType: 'module',
                 plugins: BABEL_PARSER_PLUGINS,
                 errorRecovery: true,
             });
-            const bindings = collectLocalBindings(ast, new Set([stripping]));
+            const bindings = collectLocalBindings(ast, strips);
             if (bindings.size === 0)
                 return;
             const hits = [];
@@ -87,9 +113,8 @@ export function guardStripPlugin() {
                 return;
             const s = new MagicString(code);
             for (const hit of [...hits].reverse()) {
-                s.overwrite(hit.argStart, hit.argEnd, NOOP_LOCAL_NAME);
+                s.overwrite(hit.start, hit.end, hit.strategy.replacement);
             }
-            s.prepend(`import { ${NOOP_LOCAL_NAME} } from '${NOOP_IMPORT_SOURCE}';\n`);
             return { code: s.toString(), map: s.generateMap({ hires: true }) };
         },
     };

package/dist/vite/hono-preact.d.ts

@@ -1,12 +1,12 @@
-import { type BuildEnvironmentOptions, type Plugin } from 'vite';
+import { type Plugin } from 'vite';
+import type { HonoPreactAdapter } from './adapter.js';
 export interface HonoPreactOptions {
+    /** Deployment target. Required. See hono-preact/adapter-cloudflare. */
+    adapter: HonoPreactAdapter;
     layout?: string;
     routes?: string;
     api?: string;
+    appConfig?: string;
     clientEntry?: string;
-    entry?: string;
-    clientBuild?: BuildEnvironmentOptions;
-    serverBuild?: BuildEnvironmentOptions;
-    sharedBuild?: BuildEnvironmentOptions;
 }
-export declare function honoPreact(options?: HonoPreactOptions): Plugin[];
+export declare function honoPreact(options: HonoPreactOptions): Plugin[];

package/dist/vite/hono-preact.js

@@ -1,6 +1,3 @@
-import build from '@hono/vite-build/cloudflare-workers';
-import devServer, { defaultOptions } from '@hono/vite-dev-server';
-import cloudflareAdapter from '@hono/vite-dev-server/cloudflare';
 import preact from '@preact/preset-vite';
 import { clientShimPlugin } from './client-shim.js';
 import { clientEntryPlugin, VIRTUAL_CLIENT_ENTRY_ID } from './client-entry.js';
@@ -8,68 +5,56 @@ import { serverLoaderValidationPlugin } from './server-loader-validation.js';
 import { moduleKeyPlugin } from './module-key-plugin.js';
 import { serverOnlyPlugin } from './server-only.js';
 import { guardStripPlugin } from './guard-strip.js';
-import { GENERATED_SERVER_ENTRY_RELATIVE, generatedServerEntryAbsPath, serverEntryPlugin, } from './server-entry.js';
-export function honoPreact(options = {}) {
-    const { layout = 'src/Layout.tsx', routes = 'src/routes.ts', api = 'src/api.ts', clientEntry = VIRTUAL_CLIENT_ENTRY_ID, entry, clientBuild = {}, serverBuild = {}, sharedBuild = {}, } = options;
-    const useGeneratedEntry = entry === undefined;
-    const resolvedEntry = entry ?? GENERATED_SERVER_ENTRY_RELATIVE;
+import { generatedCoreAppAbsPath, generatedEntryWrapperAbsPath, serverEntryPlugin, } from './server-entry.js';
+export function honoPreact(options) {
+    // `?? {}` is deliberate: TypeScript types `options` as required, but a
+    // zero-arg `honoPreact()` call still reaches here at runtime. Without the
+    // fallback, destructuring `undefined` throws a cryptic TypeError; with it,
+    // the friendly `adapter`-required guard below fires instead.
+    const { adapter, layout = 'src/Layout.tsx', routes = 'src/routes.ts', api = 'src/api.ts', appConfig = 'src/app-config.ts', clientEntry = VIRTUAL_CLIENT_ENTRY_ID, } = options ?? {};
+    if (!adapter) {
+        throw new Error('[hono-preact] honoPreact() requires an `adapter` option. ' +
+            "Import one, e.g. `import { cloudflareAdapter } from 'hono-preact/adapter-cloudflare'`, " +
+            'and pass `honoPreact({ adapter: cloudflareAdapter() })`.');
+    }
+    const coreAppPath = generatedCoreAppAbsPath();
+    const entryWrapperPath = generatedEntryWrapperAbsPath();
+    const ctx = {
+        root: process.cwd(),
+        coreAppModuleId: coreAppPath,
+        entryWrapperId: entryWrapperPath,
+    };
+    // Shared config plus the `client` build environment's input. The worker
+    // environment is configured by the adapter's plugins; the `client`
+    // environment's entry is framework-owned (every adapter needs the same
+    // browser bundle) so it lives here. Without it, the client environment has
+    // no input and `vite build` emits no client JavaScript. The
+    // `static/client.js` entry name is the URL the SSR layer references and
+    // must stay stable.
     const configPlugin = {
         name: 'hono-preact:config',
-        config(_, { mode }) {
-            const shared = {
+        config() {
+            return {
                 resolve: {
                     dedupe: ['preact', 'preact/compat', 'preact/hooks', 'preact-iso'],
                 },
                 build: {
                     target: 'esnext',
                     assetsDir: 'static',
-                    ssrEmitAssets: true,
-                    minify: true,
-                    ...sharedBuild,
                 },
-            };
-            if (mode === 'client') {
-                const { rollupOptions: userRollup, ...restClientBuild } = clientBuild;
-                return {
-                    ...shared,
-                    build: {
-                        ...shared.build,
-                        sourcemap: true,
-                        cssCodeSplit: true,
-                        copyPublicDir: false,
-                        ...restClientBuild,
-                        rollupOptions: {
-                            input: userRollup?.input ?? [clientEntry],
-                            output: {
-                                entryFileNames: 'static/client.js',
-                                chunkFileNames: 'static/[name]-[hash].js',
-                                assetFileNames: 'static/[name]-[hash].[ext]',
-                                // Array-form output is not supported; use an OutputOptions object to
-                                // override individual fields (entryFileNames, chunkFileNames, etc.).
-                                ...(userRollup?.output && !Array.isArray(userRollup.output)
-                                    ? userRollup.output
-                                    : {}),
+                environments: {
+                    client: {
+                        build: {
+                            rollupOptions: {
+                                input: [clientEntry],
+                                output: {
+                                    entryFileNames: 'static/client.js',
+                                    chunkFileNames: 'static/[name]-[hash].js',
+                                    assetFileNames: 'static/[name]-[hash].[ext]',
+                                },
                             },
                         },
                     },
-                };
-            }
-            return {
-                ...shared,
-                ssr: {
-                    noExternal: ['preact-render-to-string', 'preact-iso', 'hono-preact'],
-                },
-                build: {
-                    ...shared.build,
-                    // Inline sourcemaps so SSR error stacks point at user source
-                    // (e.g. `pages/issue.server.ts:42`) instead of the rolled-up
-                    // Worker chunk. We pick `inline` over a separate .map file because
-                    // SSR is a single bundle and Workers tooling will not look at a
-                    // sibling .map. Bundle size grows; for typical app server bundles
-                    // this is a few hundred KB at most and is worth the debuggability.
-                    // Users can override by passing `serverBuild.sourcemap: false`.
-                    sourcemap: 'inline',
-                    ...serverBuild,
                 },
             };
         },
@@ -78,34 +63,20 @@ export function honoPreact(options = {}) {
         configPlugin,
         clientShimPlugin(clientEntry),
         clientEntryPlugin({ routes }),
-        ...(useGeneratedEntry
-            ? [
-                serverEntryPlugin({
-                    layout,
-                    routes,
-                    api,
-                    outputPath: generatedServerEntryAbsPath(),
-                }),
-            ]
-            : []),
+        serverEntryPlugin({
+            layout,
+            routes,
+            api,
+            appConfig,
+            adapter,
+            coreAppPath,
+            entryWrapperPath,
+        }),
         serverLoaderValidationPlugin(),
         moduleKeyPlugin(),
         serverOnlyPlugin(),
         guardStripPlugin(),
-        Object.assign(build({ entry: resolvedEntry }), {
-            apply: (_, { command, mode }) => command === 'build' && mode !== 'client',
-        }),
-        Object.assign(devServer({
-            entry: resolvedEntry,
-            exclude: [
-                ...defaultOptions.exclude,
-                /\.scss/,
-                /\.css/,
-                /\?url/,
-                /\?inline/,
-            ],
-            adapter: cloudflareAdapter,
-        }), { apply: 'serve' }),
+        ...adapter.vitePlugins(ctx),
         ...preact(),
     ];
 }

package/dist/vite/index.d.ts

@@ -2,6 +2,7 @@ export { honoPreact } from './hono-preact.js';
 export { serverLoaderValidationPlugin } from './server-loader-validation.js';
 export { serverOnlyPlugin, VITE_ROOT_ACCESSOR } from './server-only.js';
 export { moduleKeyPlugin } from './module-key-plugin.js';
-export { GENERATED_SERVER_ENTRY_RELATIVE, generatedServerEntryAbsPath, serverEntryPlugin, } from './server-entry.js';
+export { GENERATED_CORE_APP_RELATIVE, GENERATED_ENTRY_WRAPPER_RELATIVE, generatedCoreAppAbsPath, generatedEntryWrapperAbsPath, serverEntryPlugin, } from './server-entry.js';
+export type { HonoPreactAdapter, HonoPreactAdapterContext } from './adapter.js';
 export { clientEntryPlugin, VIRTUAL_CLIENT_ENTRY_ID } from './client-entry.js';
 export { guardStripPlugin } from './guard-strip.js';

package/dist/vite/index.js

@@ -2,6 +2,6 @@ export { honoPreact } from './hono-preact.js';
 export { serverLoaderValidationPlugin } from './server-loader-validation.js';
 export { serverOnlyPlugin, VITE_ROOT_ACCESSOR } from './server-only.js';
 export { moduleKeyPlugin } from './module-key-plugin.js';
-export { GENERATED_SERVER_ENTRY_RELATIVE, generatedServerEntryAbsPath, serverEntryPlugin, } from './server-entry.js';
+export { GENERATED_CORE_APP_RELATIVE, GENERATED_ENTRY_WRAPPER_RELATIVE, generatedCoreAppAbsPath, generatedEntryWrapperAbsPath, serverEntryPlugin, } from './server-entry.js';
 export { clientEntryPlugin, VIRTUAL_CLIENT_ENTRY_ID } from './client-entry.js';
 export { guardStripPlugin } from './guard-strip.js';

package/dist/vite/node-dev-server.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from 'vite';
+import type { HonoPreactAdapterContext } from './adapter.js';
+export declare function nodeBuildPlugin(ctx: HonoPreactAdapterContext): Plugin;
+export declare function nodeDevServerPlugin(ctx: HonoPreactAdapterContext): Plugin;

package/dist/vite/node-dev-server.js

@@ -0,0 +1,121 @@
+import { createServerModuleRunner } from 'vite';
+export function nodeBuildPlugin(ctx) {
+    return {
+        name: 'hono-preact:node-build',
+        config() {
+            return {
+                environments: {
+                    // The Node target has no Cloudflare-style plugin to set the client
+                    // outDir, so set it here. wrapEntry()'s serveStatic expects the
+                    // client bundle at dist/client.
+                    client: {
+                        build: { outDir: 'dist/client' },
+                    },
+                    ssr: {
+                        build: {
+                            outDir: 'dist/server',
+                            ssr: true,
+                            rollupOptions: {
+                                input: [ctx.entryWrapperId],
+                            },
+                        },
+                    },
+                },
+                builder: {
+                    async buildApp(builder) {
+                        await builder.build(builder.environments.client);
+                        await builder.build(builder.environments.ssr);
+                    },
+                },
+            };
+        },
+    };
+}
+export function nodeDevServerPlugin(ctx) {
+    return {
+        name: 'hono-preact:node-dev-server',
+        apply: 'serve',
+        configureServer(server) {
+            const runner = createServerModuleRunner(server.environments.ssr);
+            // Wire the WebSocket upgrade. @hono/node-ws's injectWebSocket(target)
+            // just calls target.on('upgrade', fn); we pass a shim that captures
+            // that handler so we can invoke it with Node's real upgrade args.
+            // Multiple 'upgrade' listeners coexist fine with Vite's own HMR one.
+            server.httpServer?.on('upgrade', async (req, socket, head) => {
+                try {
+                    const { injectWebSocket } = await runner.import(ctx.entryWrapperId);
+                    if (!injectWebSocket)
+                        return;
+                    let handler;
+                    injectWebSocket({
+                        on(event, fn) {
+                            if (event === 'upgrade')
+                                handler = fn;
+                        },
+                    });
+                    handler?.(req, socket, head);
+                }
+                catch (err) {
+                    console.error('[hono-preact] dev ws upgrade error', err);
+                    socket.destroy();
+                }
+            });
+            // Register the SSR middleware synchronously (not via the returned post
+            // hook). The post hook runs after Vite's spaFallbackMiddleware, which
+            // rewrites req.url to /index.html and makes the SSR app 404. Synchronous
+            // registration puts this ahead of Vite's HTML/SPA middlewares.
+            server.middlewares.use(async (req, res, next) => {
+                try {
+                    // Vite-internal requests (its HMR client, source modules under
+                    // /@fs and /@id, optimized deps) must reach Vite's later
+                    // middlewares, or client hydration and HMR break. The SSR app only
+                    // owns application routes, so pass these through. Same model as
+                    // @hono/vite-dev-server's `exclude` option.
+                    const path = (req.url ?? '').split('?')[0];
+                    if (path.startsWith('/@') || path.startsWith('/node_modules/')) {
+                        return next();
+                    }
+                    const { default: app } = (await runner.import(ctx.entryWrapperId));
+                    const url = `http://${req.headers.host}${req.url}`;
+                    const method = req.method ?? 'GET';
+                    const headers = new Headers();
+                    for (const [k, v] of Object.entries(req.headers)) {
+                        if (typeof v === 'string')
+                            headers.set(k, v);
+                        else if (Array.isArray(v))
+                            v.forEach((vv) => headers.append(k, vv));
+                    }
+                    let body;
+                    if (method !== 'GET' && method !== 'HEAD') {
+                        const chunks = [];
+                        for await (const c of req)
+                            chunks.push(c);
+                        if (chunks.length) {
+                            const buf = Buffer.concat(chunks);
+                            // Copy into a fresh ArrayBuffer: BodyInit accepts ArrayBuffer,
+                            // and this sidesteps Buffer<ArrayBufferLike> typing friction.
+                            body = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+                        }
+                    }
+                    const request = new Request(url, { method, headers, body });
+                    const response = await app.fetch(request);
+                    res.statusCode = response.status;
+                    response.headers.forEach((value, key) => res.setHeader(key, value));
+                    if (response.body) {
+                        const reader = response.body.getReader();
+                        for (;;) {
+                            const { done, value } = await reader.read();
+                            if (done)
+                                break;
+                            res.write(value);
+                        }
+                    }
+                    res.end();
+                }
+                catch (err) {
+                    next(err);
+                }
+            });
+        },
+    };
+}

package/dist/vite/server-entry.d.ts

@@ -1,26 +1,49 @@
 import type { Plugin } from 'vite';
-export interface GenerateServerEntrySourceOptions {
+import type { HonoPreactAdapter } from './adapter.js';
+export interface GenerateCoreAppModuleOptions {
     layoutAbsPath: string;
     routesAbsPath: string;
     apiAbsPath: string | undefined;
+    appConfigAbsPath: string | undefined;
 }
-export declare function generateServerEntrySource(opts: GenerateServerEntrySourceOptions): string;
-export type CatchAllWarning = {
+export declare function generateCoreAppModule(opts: GenerateCoreAppModuleOptions): string;
+export type ApiShadowingRoute = {
     kind: 'wildcard';
     method: string;
     pattern: string;
     line: number | undefined;
+    severity: 'error';
+} | {
+    kind: 'reserved';
+    method: string;
+    pattern: string;
+    line: number | undefined;
+    severity: 'error';
 } | {
     kind: 'notFound';
     line: number | undefined;
+    severity: 'warning';
 };
-export declare function findApiCatchAllRoutes(source: string): CatchAllWarning[];
-export declare const GENERATED_SERVER_ENTRY_RELATIVE = "node_modules/.vite/hono-preact/server-entry.tsx";
-export declare function generatedServerEntryAbsPath(cwd?: string): string;
+export declare function findApiShadowingRoutes(source: string): ApiShadowingRoute[];
+export declare const GENERATED_CORE_APP_RELATIVE = "node_modules/.vite/hono-preact/core-app.tsx";
+export declare const GENERATED_ENTRY_WRAPPER_RELATIVE = "node_modules/.vite/hono-preact/server-entry.tsx";
+export declare function generatedCoreAppAbsPath(cwd?: string): string;
+export declare function generatedEntryWrapperAbsPath(cwd?: string): string;
 export interface ServerEntryPluginOptions {
     layout: string;
     routes: string;
     api: string;
-    outputPath: string;
+    /**
+     * Project-relative or absolute path to the user's app-config file. The
+     * `hono-preact` umbrella plugin always supplies a default
+     * (`src/app-config.ts`), so this is required here even though it's
+     * optional from the user's perspective: missing the file on disk is
+     * allowed (an inline `{ use: [] }` falls back into the generated core
+     * app), but the option name itself must be supplied.
+     */
+    appConfig: string;
+    adapter: HonoPreactAdapter;
+    coreAppPath: string;
+    entryWrapperPath: string;
 }
 export declare function serverEntryPlugin(opts: ServerEntryPluginOptions): Plugin;