vxrn 0.1.50 → 0.1.52

package/dist/esm/utils/swapPrebuiltReactModules.native.js

@@ -0,0 +1,248 @@
+import { readFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { buildReact, buildReactJSX, buildReactNative } from "@vxrn/react-native-prebuilt";
+import { resolveFile } from "./resolveFile";
+import FSExtra from "fs-extra";
+import { isBuildingNativeBundle } from "./isBuildingNativeBundle";
+function asyncGeneratorStep(gen, resolve2, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg), value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  info.done ? resolve2(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+  return function() {
+    var self = this, args = arguments;
+    return new Promise(function(resolve2, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve2, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve2, reject, _next, _throw, "throw", err);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _ts_generator(thisArg, body) {
+  var f, y, t, g, _ = {
+    label: 0,
+    sent: function() {
+      if (t[0] & 1)
+        throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  };
+  return g = {
+    next: verb(0),
+    throw: verb(1),
+    return: verb(2)
+  }, typeof Symbol == "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([
+        n,
+        v
+      ]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    for (; _; )
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y.return : op[0] ? y.throw || ((t = y.return) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        switch (y = 0, t && (op = [
+          op[0] & 2,
+          t.value
+        ]), op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            return _.label++, {
+              value: op[1],
+              done: !1
+            };
+          case 5:
+            _.label++, y = op[1], op = [
+              0
+            ];
+            continue;
+          case 7:
+            op = _.ops.pop(), _.trys.pop();
+            continue;
+          default:
+            if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1], t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2], _.ops.push(op);
+              break;
+            }
+            t[2] && _.ops.pop(), _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [
+          6,
+          e
+        ], y = 0;
+      } finally {
+        f = t = 0;
+      }
+    if (op[0] & 5)
+      throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: !0
+    };
+  }
+}
+function swapPrebuiltReactModules(cacheDir) {
+  return _swapPrebuiltReactModules.apply(this, arguments);
+}
+function _swapPrebuiltReactModules() {
+  return _swapPrebuiltReactModules = _async_to_generator(function(cacheDir) {
+    var prebuilds, jsxRuntime, _tmp, virtualModules, _tmp1, _, _tmp2, _tmp3;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return prebuilds = {
+            reactJSX: join(cacheDir, "react-jsx-runtime.js"),
+            react: join(cacheDir, "react.js"),
+            reactNative: join(cacheDir, "react-native.js")
+          }, [
+            4,
+            FSExtra.pathExists(prebuilds.reactNative)
+          ];
+        case 1:
+          return _state.sent() ? [
+            3,
+            3
+          ] : (console.info("Pre-building react, react-native react/jsx-runtime (one time cost)..."), [
+            4,
+            Promise.all([
+              buildReactNative({
+                entryPoints: [
+                  resolveFile("react-native")
+                ],
+                outfile: prebuilds.reactNative
+              }),
+              buildReact({
+                entryPoints: [
+                  resolveFile("react")
+                ],
+                outfile: prebuilds.react
+              }),
+              buildReactJSX({
+                entryPoints: [
+                  resolveFile("react/jsx-dev-runtime")
+                ],
+                outfile: prebuilds.reactJSX
+              })
+            ])
+          ]);
+        case 2:
+          _state.sent(), _state.label = 3;
+        case 3:
+          return _tmp = {
+            // alias: 'virtual:react-jsx',
+            alias: prebuilds.reactJSX
+          }, [
+            4,
+            readFile(prebuilds.reactJSX, "utf-8")
+          ];
+        case 4:
+          return jsxRuntime = (_tmp.contents = _state.sent(), _tmp), _tmp1 = {}, _ = "react-native", _tmp2 = {
+            // alias: 'virtual:react-native',
+            alias: prebuilds.reactNative
+          }, [
+            4,
+            readFile(prebuilds.reactNative, "utf-8")
+          ];
+        case 5:
+          return _tmp1[_] = (_tmp2.contents = _state.sent(), _tmp2), _tmp3 = {
+            // alias: 'virtual:react',
+            alias: prebuilds.react
+          }, [
+            4,
+            readFile(prebuilds.react, "utf-8")
+          ];
+        case 6:
+          return virtualModules = (_tmp1.react = (_tmp3.contents = _state.sent(), _tmp3), _tmp1["react/jsx-runtime"] = jsxRuntime, _tmp1["react/jsx-dev-runtime"] = jsxRuntime, _tmp1), [
+            2,
+            {
+              name: "swap-react-native",
+              enforce: "pre",
+              resolveId: function(id) {
+                var importer = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+                if (id.startsWith("react-native/Libraries"))
+                  return "virtual:rn-internals:".concat(id);
+                if (id === "react-native-web")
+                  return prebuilds.reactNative;
+                for (var targetId in virtualModules)
+                  if (id === targetId || id.includes("node_modules/".concat(targetId, "/"))) {
+                    var info = virtualModules[targetId];
+                    return info.alias;
+                  }
+                if (isBuildingNativeBundle && id[0] === ".") {
+                  var absolutePath = resolve(dirname(importer), id), nativePath = absolutePath.replace(/(.m?js)/, ".native.js");
+                  if (nativePath === id)
+                    return;
+                  try {
+                    var directoryPath = absolutePath + "/index.native.js", directoryNonNativePath = absolutePath + "/index.js";
+                    if (FSExtra.pathExistsSync(directoryPath))
+                      return directoryPath;
+                    if (FSExtra.pathExistsSync(directoryNonNativePath))
+                      return directoryNonNativePath;
+                    if (FSExtra.pathExistsSync(nativePath))
+                      return nativePath;
+                  } catch (err) {
+                    console.warn("error probably fine", err);
+                  }
+                }
+              },
+              load: function(id) {
+                if (id.startsWith("virtual:rn-internals")) {
+                  var idOut = id.replace("virtual:rn-internals:", ""), out = 'const ___val = __cachedModules["'.concat(idOut, `"]
+        const ___defaultVal = ___val ? ___val.default || ___val : ___val
+        export default ___defaultVal`);
+                  return out;
+                }
+                for (var targetId in virtualModules) {
+                  var info = virtualModules[targetId];
+                  if (id === info.alias)
+                    return info.contents;
+                }
+              }
+            }
+          ];
+      }
+    });
+  }), _swapPrebuiltReactModules.apply(this, arguments);
+}
+export {
+  swapPrebuiltReactModules
+};
+//# sourceMappingURL=swapPrebuiltReactModules.js.map

package/dist/esm/utils/swapPrebuiltReactModules.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/Users/n8/vxrn/packages/vxrn/src/utils/swapPrebuiltReactModules.ts"],
+  "mappings": "AAAA,SAASA,gBAAgB;AACzB,SAASC,SAASC,MAAMC,eAAe;AACvC,SAASC,YAAYC,eAAeC,wBAAwB;AAE5D,SAASC,mBAAmB;AAC5B,OAAOC,aAAa;AACpB,SAASC,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKvC,SAAsBC,yBAAyBC,UAAgB;SAAzCD,0BAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,4BAAAA;AAAAA,qCAAf,oBAAA,SAAwCC,UAAgB;QACvDC,WAyBAC,YAAAA,MAMAC,gBAAAA,OAAAA,GAAAA,OAAAA;;;;AA/BAF,6BAAY;YAChBG,UAAUb,KAAKS,UAAU,sBAAA;YACzBK,OAAOd,KAAKS,UAAU,UAAA;YACtBM,aAAaf,KAAKS,UAAU,iBAAA;UAC9B,GAEM;;YAAMH,QAAQU,WAAWN,UAAUK,WAAW;;;iBAA9C,OAAA,KAAA,IAAF;;;eACFE,QAAQC,KAAK,uEAAA,GACb;;YAAMC,QAAQC,IAAG;cACfhB,iBAAiB;gBACfiB,aAAW;kBAAGhB,YAAY,cAAA;;gBAC1BiB,SAASZ,UAAUK;cACrB,CAAA;cACAb,WAAW;gBACTmB,aAAW;kBAAGhB,YAAY,OAAA;;gBAC1BiB,SAASZ,UAAUI;cACrB,CAAA;cACAX,cAAc;gBACZkB,aAAW;kBAAGhB,YAAY,uBAAA;;gBAC1BiB,SAASZ,UAAUG;cACrB,CAAA;;;;AAZF,iBAAA,KAAA;;;;YAmBAU,OAAOb,UAAUG;aACP;;YAAMf,SAASY,UAAUG,UAAU,OAAA;;;AAHzCF,+BAAAA,KAGJa,WAAU,OAAA,KAAA,GAAA,uBAIV;;YAEED,OAAOb,UAAUK;aACP;;YAAMjB,SAASY,UAAUK,aAAa,OAAA;;;mCAAhDS,WAAU,OAAA,KAAA,GAAA;;YAIVD,OAAOb,UAAUI;aACP;;YAAMhB,SAASY,UAAUI,OAAO,OAAA;;;AATxCF,mCAAAA,MAMJE,SAAAA,MAGEU,WAAU,OAAA,KAAA,GAAA,QAAA,MAEZ,mBAAA,IAAqBb,YAAAA,MACrB,uBAAA,IAAyBA,YAAAA,QAG3B;;YAAO;cACLc,MAAO;cACPC,SAAS;cAETC,WAAAA,SAAUC,IAAE;oBAAEC,WAAAA,UAAAA,SAAAA,KAAAA,UAAAA,CAAAA,MAAAA,SAAAA,UAAAA,CAAAA,IAAW;AACvB,oBAAID,GAAGE,WAAW,wBAAA;AAChB,yBAAQ,wBAA0B,OAAHF,EAAAA;AAIjC,oBAAIA,OAAO;AACT,yBAAOlB,UAAUK;AAGnB,yBAAWgB,YAAYnB;AACrB,sBAAIgB,OAAOG,YAAYH,GAAGI,SAAU,gBAAwB,OAATD,UAAS,GAAA,CAAA,GAAK;AAC/D,wBAAMb,OAAON,eAAemB,QAAAA;AAE5B,2BAAOb,KAAKK;kBACd;AAOF,oBAAIhB,0BACEqB,GAAG,CAAA,MAAO,KAAK;AACjB,sBAAMK,eAAehC,QAAQF,QAAQ8B,QAAAA,GAAWD,EAAAA,GAC1CM,aAAaD,aAAaE,QAAQ,WAAW,YAAA;AACnD,sBAAID,eAAeN;AAAI;AACvB,sBAAI;AACF,wBAAMQ,gBAAgBH,eAAe,oBAC/BI,yBAAyBJ,eAAe;AAC9C,wBAAI3B,QAAQgC,eAAeF,aAAAA;AACzB,6BAAOA;AAET,wBAAI9B,QAAQgC,eAAeD,sBAAAA;AACzB,6BAAOA;AAET,wBAAI/B,QAAQgC,eAAeJ,UAAAA;AACzB,6BAAOA;kBAEX,SAASK,KAAK;AACZtB,4BAAQuB,KAAM,uBAAsBD,GAAAA;kBACtC;gBACF;cAEJ;cAEAE,MAAAA,SAAKb,IAAE;AACL,oBAAIA,GAAGE,WAAW,sBAAA,GAAyB;AACzC,sBAAMY,QAAQd,GAAGO,QAAQ,yBAAyB,EAAA,GAC9CQ,MAAO,mCAAwC,OAAND,OAAM;;qCAAA;AAGnD,yBAAOC;gBACT;AAEA,yBAAWZ,YAAYnB,gBAAgB;AACrC,sBAAMM,OAAON,eAAemB,QAAAA;AAC5B,sBAAIH,OAAOV,KAAKK;AACd,2BAAOL,KAAKM;gBAEhB;cACF;YACF;;;;EACF,CAAA,GAlHsBhB,0BAAAA,MAAAA,MAAAA,SAAAA;;",
+  "names": ["readFile", "dirname", "join", "resolve", "buildReact", "buildReactJSX", "buildReactNative", "resolveFile", "FSExtra", "isBuildingNativeBundle", "swapPrebuiltReactModules", "cacheDir", "prebuilds", "jsxRuntime", "virtualModules", "reactJSX", "react", "reactNative", "pathExists", "console", "info", "Promise", "all", "entryPoints", "outfile", "alias", "contents", "name", "enforce", "resolveId", "id", "importer", "startsWith", "targetId", "includes", "absolutePath", "nativePath", "replace", "directoryPath", "directoryNonNativePath", "pathExistsSync", "err", "warn", "load", "idOut", "out"]
+}

package/dist/esm/utils/uniq.js

@@ -0,0 +1,7 @@
+function uniq(a) {
+  return [...new Set(a)];
+}
+export {
+  uniq
+};
+//# sourceMappingURL=uniq.js.map

package/dist/esm/utils/uniq.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/uniq.ts"],
+  "mappings": "AAAO,SAAS,KAAK,GAAU;AAC7B,SAAO,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC;AACvB;",
+  "names": []
+}

package/dist/esm/utils/uniq.mjs

@@ -0,0 +1,4 @@
+function uniq(a) {
+  return [...new Set(a)];
+}
+export { uniq };

package/dist/esm/utils/uniq.native.js

@@ -0,0 +1,38 @@
+function _array_like_to_array(arr, len) {
+  (len == null || len > arr.length) && (len = arr.length);
+  for (var i = 0, arr2 = new Array(len); i < len; i++)
+    arr2[i] = arr[i];
+  return arr2;
+}
+function _array_without_holes(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+  if (typeof Symbol < "u" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _non_iterable_spread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+  return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+  if (o) {
+    if (typeof o == "string")
+      return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor && (n = o.constructor.name), n === "Map" || n === "Set")
+      return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+      return _array_like_to_array(o, minLen);
+  }
+}
+function uniq(a) {
+  return _to_consumable_array(new Set(a));
+}
+export {
+  uniq
+};
+//# sourceMappingURL=uniq.js.map

package/dist/esm/utils/uniq.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/Users/n8/vxrn/packages/vxrn/src/utils/uniq.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAO,SAASA,KAAKC,GAAQ;AAC3B,SAAQ,qBAAG,IAAIC,IAAID,CAAAA,CAAAA;AACrB;",
+  "names": ["uniq", "a", "Set"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vxrn",
-  "version": "0.1.50",
+  "version": "0.1.52",
   "source": "src/index.ts",
   "types": "./types/index.d.ts",
   "type": "module",
@@ -29,13 +29,13 @@
     "@babel/code-frame": "^7.21.4",
     "@vitejs/plugin-react": "^4.2.1",
     "@vitejs/plugin-react-swc": "^3.6.0",
-    "@vxrn/react-native-prebuilt": "0.1.50",
-    "@vxrn/router": "0.1.50",
-    "@vxrn/safe-area": "0.1.50",
-    "@vxrn/vite-flow": "0.1.50",
-    "@vxrn/vite-native-client": "0.1.50",
-    "@vxrn/vite-native-hmr": "0.1.50",
-    "@vxrn/vite-native-swc": "0.1.50",
+    "@vxrn/react-native-prebuilt": "0.1.52",
+    "@vxrn/router": "0.1.52",
+    "@vxrn/safe-area": "0.1.52",
+    "@vxrn/vite-flow": "0.1.52",
+    "@vxrn/vite-native-client": "0.1.52",
+    "@vxrn/vite-native-hmr": "0.1.52",
+    "@vxrn/vite-native-swc": "0.1.52",
     "citty": "^0.1.6",
     "crossws": "^0.2.4",
     "es-module-lexer": "^1.3.0",

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,34 +48,47 @@ 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, {
+    let clientBuildConfig = mergeConfig(webBuildConfig, {
+      build: {
+        ssrManifest: true,
+        outDir: 'dist/client',
+      },
+    } satisfies UserConfig)
+
+    if (process.env.VXRN_DISABLE_PROD_OPTIMIZATION) {
+      clientBuildConfig = mergeConfig(clientBuildConfig, {
+        optimizeDeps: {
+          esbuildOptions: {
+            minify: false,
+          },
+        },
+
         build: {
-          ssrManifest: true,
-          outDir: 'dist/client',
+          minify: false,
+          rollupOptions: {
+            treeshake: false,
+            output: {
+              minifyInternalExports: false,
+            },
+          },
         },
-      } satisfies UserConfig)
-    )
+      })
+    }
+
+    await viteBuild(clientBuildConfig)
   }
 
   console.info(`build server`)
   const { output } = (await viteBuild(
     mergeConfig(webBuildConfig, {
-      // optimizeDeps: {
-      //   esbuildOptions: {
-      //     format: 'cjs',
-      //   },
-      // },
-
       ssr: {
         noExternal: optimizeDeps.include,
         optimizeDeps,
@@ -95,155 +106,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)
   }
 }