vxrn 0.1.62 → 0.1.64

package/src/exports/createServer.ts

@@ -1,41 +1,60 @@
-import { createApp, defineEventHandler } from 'h3'
-import sirv from 'sirv'
+import { Hono } from 'hono'
+import { compress } from 'hono/compress'
+// import { cache } from 'hono/cache'
+import { serveStatic } from '@hono/node-server/serve-static'
+
 import type { VXRNConfig } from '../types'
 
 export const createProdServer = async (options: VXRNConfig) => {
-  const app = createApp()
-
-  const sirvStaticMiddleware = sirv('dist/static', {
-    gzip: true,
-  })
+  const app = new Hono()
 
-  if (options.serve) {
-    options.serve(options, app)
-  }
+  app.use(compress())
 
   app.use(
-    defineEventHandler(async ({ node: { req, res } }) => {
-      await new Promise<void>((response) => {
-        sirvStaticMiddleware(req, res, () => {
-          response()
-        })
-      })
+    '*',
+    serveStatic({
+      root: './dist/client',
     })
   )
 
-  const sirvMiddleware = sirv('dist/client', {
-    gzip: true,
-  })
+  // app.get(
+  //   '*',
+  //   cache({
+  //     cacheName: 'my-app',
+  //     cacheControl: 'max-age=3600',
+  //   })
+  // )
 
-  app.use(
-    defineEventHandler(async ({ node: { req, res } }) => {
-      await new Promise<void>((response) => {
-        sirvMiddleware(req, res, () => {
-          response()
-        })
-      })
-    })
-  )
+  if (options.serve) {
+    options.serve(options, app)
+  }
 
   return app
 }
+
+// // testing cache
+// const caches = {}
+// function createCache(name: string) {
+//   if (caches[name]) return caches[name] as any
+//   const store = {}
+//   const cache = {
+//     async match(key: string) {
+//       console.log('matching', key)
+//       return store[key]
+//     },
+//     async put(key: string, val) {
+//       store[key] = val
+//     },
+//     async delete(key: string) {
+//       delete store[key]
+//     },
+//   }
+//   caches[name] = cache
+//   return cache
+// }
+// globalThis.caches = {
+//   ...createCache(''),
+//   async open(name: string) {
+//     return createCache(name)
+//   },
+// }

package/src/exports/serve.ts

@@ -1,5 +1,5 @@
-import { toNodeListener } from 'h3'
-import { createServer } from 'node:http'
+import { serve as honoServe } from '@hono/node-server'
+
 import type { VXRNConfig } from '../types'
 import { createProdServer } from './createServer'
 import { getOptionsFilled } from '../utils/getOptionsFilled'
@@ -7,10 +7,14 @@ import { getOptionsFilled } from '../utils/getOptionsFilled'
 export const serve = async (optionsIn: VXRNConfig) => {
   const options = await getOptionsFilled(optionsIn, { mode: 'prod' })
   const app = await createProdServer(options)
-  const server = createServer(toNodeListener(app))
   // strange prevents a cant listen on port issue
   await new Promise((res) => setTimeout(res, 1))
-  server.listen(options.port, options.host)
+  const server = honoServe({
+    fetch: app.fetch,
+    port: options.port,
+    hostname: options.host,
+  })
+  // server.listen(options.port, options.host)
   console.info(`Listening on http://${options.host}:${options.port}`)
   await new Promise<void>((res) => {
     server.on('close', () => {

package/src/types.ts

@@ -1,5 +1,5 @@
 import type { Options as FlowOptions } from '@vxrn/vite-flow'
-import type { App } from 'h3'
+import type { Hono } from 'hono'
 import type { OutputAsset, OutputChunk } from 'rollup'
 import type { InlineConfig, UserConfig } from 'vite'
 
@@ -7,6 +7,17 @@ export type AfterBuildProps = {
   options: VXRNConfig
   output: [OutputChunk, ...(OutputChunk | OutputAsset)[]]
   webBuildConfig: UserConfig
+  clientManifest: {
+    // app/[user].tsx
+    [key: string]: {
+      file: string // assets/_user_-Bg0DW2rm.js
+      src?: string // app/[user].tsx
+      isDynamicEntry?: boolean // true for import.meta.globbed
+      isEntry?: boolean // true for index.html
+      name: string // _user_
+      imports: string[]
+    }
+  }
 }
 
 export type VXRNConfig = {
@@ -30,7 +41,7 @@ export type VXRNConfig = {
 
   afterBuild?: (props: AfterBuildProps) => void | Promise<void>
 
-  serve?: (options: VXRNConfig, app: App) => void
+  serve?: (options: VXRNConfig, app: Hono) => void
 }
 
 export type HMRListener = (update: { file: string; contents: string }) => void

package/src/utils/getHtml.ts

@@ -6,6 +6,7 @@ export function getHtml({
   appHtml,
   headHtml,
   css,
+  preloads,
 }: {
   css?: string
   template: string
@@ -13,6 +14,7 @@ export function getHtml({
   loaderProps?: any
   appHtml: string
   headHtml: string
+  preloads: string[]
 }) {
   if (!template.includes(`<!--ssr-outlet-->`)) {
     throw new Error(`No <!--ssr-outlet--> found in html to inject SSR contents`)
@@ -30,6 +32,13 @@ export function getHtml({
 
   return template
     .replace(/\s*<!--ssr-outlet-->\s*/, appHtml)
-    .replace(`<!--head-outlet-->`, `${headHtml}\n${css ? `<style>${css}</style>\n` : ``}`)
+    .replace(
+      `<!--head-outlet-->`,
+      [
+        headHtml,
+        `<style>${css}</style>\n`,
+        ...preloads.map((src) => `<link rel="modulepreload" href="${src}" />`),
+      ].join('\n  ')
+    )
     .replace('</body>', loaderDataString)
 }

package/types/exports/createServer.d.ts

@@ -1,3 +1,4 @@
+import { Hono } from 'hono';
 import type { VXRNConfig } from '../types';
-export declare const createProdServer: (options: VXRNConfig) => Promise<import("h3").App>;
+export declare const createProdServer: (options: VXRNConfig) => Promise<Hono<import("hono").Env, import("hono/types").BlankSchema, "/">>;
 //# sourceMappingURL=createServer.d.ts.map

package/types/types.d.ts

@@ -1,11 +1,21 @@
 import type { Options as FlowOptions } from '@vxrn/vite-flow';
-import type { App } from 'h3';
+import type { Hono } from 'hono';
 import type { OutputAsset, OutputChunk } from 'rollup';
 import type { InlineConfig, UserConfig } from 'vite';
 export type AfterBuildProps = {
     options: VXRNConfig;
     output: [OutputChunk, ...(OutputChunk | OutputAsset)[]];
     webBuildConfig: UserConfig;
+    clientManifest: {
+        [key: string]: {
+            file: string;
+            src?: string;
+            isDynamicEntry?: boolean;
+            isEntry?: boolean;
+            name: string;
+            imports: string[];
+        };
+    };
 };
 export type VXRNConfig = {
     /**
@@ -26,7 +36,7 @@ export type VXRNConfig = {
     nativeConfig?: InlineConfig;
     flow?: FlowOptions;
     afterBuild?: (props: AfterBuildProps) => void | Promise<void>;
-    serve?: (options: VXRNConfig, app: App) => void;
+    serve?: (options: VXRNConfig, app: Hono) => void;
 };
 export type HMRListener = (update: {
     file: string;

package/types/utils/getHtml.d.ts

@@ -1,9 +1,10 @@
-export declare function getHtml({ template, loaderData, loaderProps, appHtml, headHtml, css, }: {
+export declare function getHtml({ template, loaderData, loaderProps, appHtml, headHtml, css, preloads, }: {
     css?: string;
     template: string;
     loaderData: Object;
     loaderProps?: any;
     appHtml: string;
     headHtml: string;
+    preloads: string[];
 }): string;
 //# sourceMappingURL=getHtml.d.ts.map

package/types/utils/getOptionsFilled.d.ts

@@ -20,7 +20,7 @@ export declare function getOptionsFilled(options: VXRNConfig, internal?: {
     nativeConfig?: import("vite").InlineConfig | undefined;
     flow?: import("@vxrn/vite-flow").Options | undefined;
     afterBuild?: ((props: import("..").AfterBuildProps) => void | Promise<void>) | undefined;
-    serve?: ((options: VXRNConfig, app: import("h3").App) => void) | undefined;
+    serve?: ((options: VXRNConfig, app: import("hono").Hono<import("hono").Env, import("hono/types").BlankSchema, "/">) => void) | undefined;
 }>;
 type State = {
     applyPatches?: boolean;