hono-preact 0.1.0 → 0.3.0

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;