vxrn 0.1.49 → 0.1.51

package/src/exports/build.ts

@@ -1,17 +1,14 @@
-import { build as esbuild } from 'esbuild'
+import FSExtra from 'fs-extra'
 import { resolve as importMetaResolve } from 'import-meta-resolve'
-import fs from 'node:fs'
-import { tmpdir } from 'node:os'
-import Path from 'node:path'
+import { rm } from 'node:fs/promises'
+import type { RollupOutput } from 'rollup'
 import { mergeConfig, build as viteBuild, type UserConfig } from 'vite'
-import FSExtra from 'fs-extra'
-import type { OutputAsset, OutputChunk, RollupOutput } from 'rollup'
 import type { VXRNConfig } from '../types'
 import { getBaseViteConfig } from '../utils/getBaseViteConfig'
-import { getHtml } from '../utils/getHtml'
 import { getOptimizeDeps } from '../utils/getOptimizeDeps'
-import { getOptionsFilled, type VXRNConfigFilled } from '../utils/getOptionsFilled'
-import { assertIsError } from '../utils/assert'
+import { getOptionsFilled } from '../utils/getOptionsFilled'
+
+const { existsSync } = FSExtra
 
 Error.stackTraceLimit = Infinity
 
@@ -23,20 +20,21 @@ export const resolveFile = (path: string) => {
   }
 }
 
-const { ensureDir, existsSync, readFile, pathExists } = FSExtra
-
 type BuildOptions = { step?: string; page?: string }
 
-// web only for now
-
-// TODO:
-//  - make this only build native or web bundles
-//  - move router stuff into router package
-//  - generateStaticPages becomes a vite 'post' postbuild callback in router plugin
-
 export const build = async (optionsIn: VXRNConfig, buildOptions: BuildOptions = {}) => {
   const options = await getOptionsFilled(optionsIn)
 
+  // lets always clean dist folder for now to be sure were correct
+  if (existsSync('dist')) {
+    await rm('dist', { recursive: true, force: true })
+  }
+
+  // lets always clean dist folder for now to be sure were correct
+  if (existsSync('node_modules/.vite')) {
+    await rm('node_modules/.vite', { recursive: true, force: true })
+  }
+
   // TODO?
   process.env.NODE_ENV = 'production'
 
@@ -50,15 +48,14 @@ export const build = async (optionsIn: VXRNConfig, buildOptions: BuildOptions =
       root: options.root,
       clearScreen: false,
       optimizeDeps,
-    }
-  ) satisfies UserConfig
+    } satisfies UserConfig
+  )
 
   if (options.webConfig) {
     webBuildConfig = mergeConfig(webBuildConfig, options.webConfig) as any
   }
 
   if (buildOptions.step !== 'generate') {
-    console.info(`build client`)
     await viteBuild(
       mergeConfig(webBuildConfig, {
         build: {
@@ -72,12 +69,6 @@ export const build = async (optionsIn: VXRNConfig, buildOptions: BuildOptions =
   console.info(`build server`)
   const { output } = (await viteBuild(
     mergeConfig(webBuildConfig, {
-      // optimizeDeps: {
-      //   esbuildOptions: {
-      //     format: 'cjs',
-      //   },
-      // },
-
       ssr: {
         noExternal: optimizeDeps.include,
         optimizeDeps,
@@ -95,155 +86,7 @@ export const build = async (optionsIn: VXRNConfig, buildOptions: BuildOptions =
     } satisfies UserConfig)
   )) as RollupOutput
 
-  console.info(`generating static pages`)
-  await generateStaticPages(options, output)
-}
-
-async function generateStaticPages(
-  options: VXRNConfigFilled,
-  serverOutput: (OutputChunk | OutputAsset)[]
-) {
-  const toAbsolute = (p) => Path.resolve(options.root, p)
-
-  const staticDir = toAbsolute(`dist/static`)
-  await ensureDir(staticDir)
-  const template = fs.readFileSync(toAbsolute('index.html'), 'utf-8')
-
-  const render = (await import(`${options.root}/dist/server/entry-server.js`)).render
-
-  // load routes
-  // const entry = serverOutput.find(
-  //   (x) => x.type === 'chunk' && x.facadeModuleId?.includes('entry-server')
-  // )
-
-  const assets: OutputAsset[] = []
-
-  const allRoutes: {
-    path: string
-    params: Object
-    loaderData: any
-  }[] = []
-
-  for (const output of serverOutput) {
-    if (output.type === 'asset') {
-      assets.push(output)
-      continue
-    }
-
-    const id = output.facadeModuleId || ''
-    const file = Path.basename(id)
-    const name = file.replace(/\.[^/.]+$/, '')
-
-    if (!id || file[0] === '_' || file.includes('entry-server')) {
-      continue
-    }
-    if (id.includes('+api')) {
-      continue
-    }
-
-    const endpointPath = Path.join(options.root, 'dist/server', output.fileName)
-
-    let exported
-    try {
-      exported = await import(endpointPath)
-    } catch (err) {
-      console.error(`Error importing page (original error)`, err)
-      // err cause not showing in vite or something
-      throw new Error(`Error importing page: ${endpointPath}`, {
-        cause: err,
-      })
-    }
-
-    const paramsList = ((await exported.generateStaticParams?.()) ?? [{}]) as Object[]
-
-    for (const params of paramsList) {
-      const path = getUrl(params)
-      const loaderData = (await exported.loader?.({ path, params })) ?? {}
-      allRoutes.push({ path, params, loaderData })
-    }
-
-    function getUrl(_params = {}) {
-      if (name === 'index') {
-        return '/'
-      }
-      if (name.startsWith('[...')) {
-        const part = name.replace('[...', '').replace(']', '')
-        return `/${_params[part]}`
-      }
-      return `/${name
-        .split('/')
-        .map((part) => {
-          if (part[0] === '[') {
-            const found = _params[part.slice(1, part.length - 1)]
-            if (!found) {
-              console.warn('not found', { _params, part })
-            }
-            return found
-          }
-          return part
-        })
-        .join('/')}`
-    }
-  }
-
-  // can build them in parallel
-  // const allRoutes = (
-  //   await Promise.all(
-  //   )
-  // ).flat()
-
-  // for now just inline
-  const cssStringRaw = assets
-    .filter((x) => x.name?.endsWith('.css'))
-    .map((x) => x.source)
-    .join('\n\n')
-
-  // awkward way to get prefixes:
-  const tmpCssFile = Path.join(tmpdir(), 'tmp.css')
-  await FSExtra.writeFile(tmpCssFile, cssStringRaw, 'utf-8')
-  await esbuild({
-    entryPoints: [tmpCssFile],
-    target: 'safari17',
-    bundle: true,
-    minifyWhitespace: true,
-    sourcemap: false,
-    outfile: tmpCssFile,
-    loader: { '.css': 'css' },
-  })
-  const cssString = await FSExtra.readFile(tmpCssFile, 'utf-8')
-
-  // pre-render each route...
-  for (const { path, loaderData, params } of allRoutes) {
-    try {
-      const loaderProps = { params }
-      globalThis['__vxrnLoaderProps__'] = loaderProps
-      console.info(`render`, path)
-      const { appHtml, headHtml } = await render({ path })
-      const slashFileName = `${path === '/' ? '/index' : path}.html`
-      const clientHtmlPath = toAbsolute(`dist/client${slashFileName}`)
-      const clientHtml = existsSync(clientHtmlPath) ? await readFile(clientHtmlPath, 'utf-8') : null
-      const html = getHtml({
-        template: clientHtml || template,
-        appHtml,
-        headHtml,
-        loaderData,
-        loaderProps,
-        css: cssString,
-      })
-      const filePath = toAbsolute(`dist/static${slashFileName}`)
-      await ensureDir(Path.dirname(filePath))
-      fs.writeFileSync(toAbsolute(filePath), html)
-    } catch (err) {
-      assertIsError(err)
-      console.error(`og error because cause not working`, err)
-      throw new Error(
-        `Error building static page: ${path} with:
-  loaderData: ${JSON.stringify(loaderData || null)}
-  params: ${JSON.stringify(params || null)}`,
-        {
-          cause: err,
-        }
-      )
-    }
+  if (options.afterBuild) {
+    await options.afterBuild(options, output)
   }
 }

package/src/exports/serve.ts

@@ -13,6 +13,10 @@ export const serve = async (optionsIn: VXRNConfig) => {
     gzip: true,
   })
 
+  if (options.serve) {
+    options.serve(options, app)
+  }
+
   app.use(
     defineEventHandler(async ({ node: { req, res } }) => {
       await new Promise<void>((response) => {

package/src/index.ts

@@ -1,4 +1,9 @@
 export { build } from './exports/build'
 export { dev } from './exports/dev'
 
+export * from './utils/getHtml'
+export * from './utils/getOptionsFilled'
+export * from './utils/getOptimizeDeps'
+export * from './utils/getBaseViteConfig'
+
 export * from './types'

package/src/types.ts

@@ -1,4 +1,6 @@
 import type { Options as FlowOptions } from '@vxrn/vite-flow'
+import type { App } from 'h3'
+import type { OutputAsset, OutputChunk } from 'rollup'
 import type { InlineConfig } from 'vite'
 
 export type VXRNConfig = {
@@ -19,6 +21,13 @@ export type VXRNConfig = {
   webConfig?: InlineConfig
   nativeConfig?: InlineConfig
   flow?: FlowOptions
+
+  afterBuild?: (
+    options: VXRNConfig,
+    output: [OutputChunk, ...(OutputChunk | OutputAsset)[]]
+  ) => void | Promise<void>
+
+  serve?: (options: VXRNConfig, app: App) => void
 }
 
 export type HMRListener = (update: { file: string; contents: string }) => void

package/src/utils/getOptionsFilled.ts

@@ -19,7 +19,6 @@ export async function getOptionsFilled(options: VXRNConfig) {
   })
 
   const packageRootDir = join(require.resolve('vxrn'), '../../..')
-
   const cacheDir = join(root, 'node_modules', '.vxrn')
   const internalPatchesDir = join(packageRootDir, 'patches')
   const userPatchesDir = join(root, 'patches')

package/src/utils/getVitePath.ts

@@ -1,7 +1,6 @@
 import { join, relative, dirname } from 'node:path'
+import { createRequire } from 'node:module'
 
-// @ts-ignore
-import resolve from 'esm-resolve'
 import FSExtra from 'fs-extra'
 
 export async function getVitePath(
@@ -31,7 +30,8 @@ export async function getVitePath(
   }
 
   const sourceFile = join(process.cwd(), 'index.js')
-  const resolved = resolve(sourceFile)(moduleName)
+  const require = createRequire(moduleName)
+  const resolved = require.resolve(sourceFile)
   // figure out symlinks
   if (!resolved) {
     throw new Error(

package/src/utils/readVXRNConfig.ts

@@ -1,42 +1,35 @@
 import FSExtra from 'fs-extra'
 import type { VXRNConfig } from '../types'
-import { createServer } from 'vite'
-import jiti from 'jiti'
+import { join } from 'node:path'
+import { build } from 'esbuild'
 
 export async function readVXRNConfig(): Promise<VXRNConfig> {
   if (!(await FSExtra.pathExists('vxrn.config.ts'))) {
     return {}
   }
 
-  if (process.env.VXRN_CJS) {
-    const requireFile = jiti(process.cwd(), {
-      esmResolve: true,
-    })
-    const userConfig = requireFile('./vxrn.config.ts')
-    return resolveOptionalAsyncFunction(userConfig?.default ?? {})
-  }
+  const outfile = join(process.cwd(), 'vxrn.config.js')
 
-  // try esm load
   try {
-    // somewhat hacky creating a server just to read config?
-    const vite = await createServer({
-      logLevel: 'silent',
-      appType: 'custom',
-    })
-
-    const userConfig = await vite.ssrLoadModule('./vxrn.config.ts', {
-      fixStacktrace: true,
+    // output to same place so paths and relative things work
+    await build({
+      entryPoints: ['vxrn.config.ts'],
+      bundle: false,
+      outfile,
+      platform: 'node',
+      format: 'esm',
+      sourcemap: false,
+      minify: false,
     })
 
-    await vite.close()
-    return resolveOptionalAsyncFunction(userConfig?.default ?? {})
-  } catch (err: any) {
-    console.info(` [vxrn] Error loading config via ESM:
+    const exportedConfig = (await import(outfile)).default
 
-${err.stack}
-    
- To load as CommonJS, set VXRN_CJS=1`)
+    return await resolveOptionalAsyncFunction(exportedConfig)
+  } catch (err) {
+    console.error(` [vxrn] Error building vxrn.config.ts`)
     throw err
+  } finally {
+    FSExtra.removeSync(outfile)
   }
 }
 

package/types/index.d.ts

@@ -1,4 +1,8 @@
 export { build } from './exports/build';
 export { dev } from './exports/dev';
+export * from './utils/getHtml';
+export * from './utils/getOptionsFilled';
+export * from './utils/getOptimizeDeps';
+export * from './utils/getBaseViteConfig';
 export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/types/types.d.ts

@@ -1,4 +1,6 @@
 import type { Options as FlowOptions } from '@vxrn/vite-flow';
+import type { App } from 'h3';
+import type { OutputAsset, OutputChunk } from 'rollup';
 import type { InlineConfig } from 'vite';
 export type VXRNConfig = {
     /**
@@ -18,6 +20,8 @@ export type VXRNConfig = {
     webConfig?: InlineConfig;
     nativeConfig?: InlineConfig;
     flow?: FlowOptions;
+    afterBuild?: (options: VXRNConfig, output: [OutputChunk, ...(OutputChunk | OutputAsset)[]]) => void | Promise<void>;
+    serve?: (options: VXRNConfig, app: App) => void;
 };
 export type HMRListener = (update: {
     file: string;

package/types/utils/getOptionsFilled.d.ts

@@ -17,6 +17,8 @@ export declare function getOptionsFilled(options: VXRNConfig): Promise<{
     webConfig?: import("vite").InlineConfig | undefined;
     nativeConfig?: import("vite").InlineConfig | undefined;
     flow?: import("@vxrn/vite-flow").Options | undefined;
+    afterBuild?: ((options: VXRNConfig, output: [import("rollup").OutputChunk, ...(import("rollup").OutputChunk | import("rollup").OutputAsset)[]]) => void | Promise<void>) | undefined;
+    serve?: ((options: VXRNConfig, app: import("h3").App) => void) | undefined;
 }>;
 type State = {
     applyPatches?: boolean;