vite-ssg-optimized 0.24.2-optimized.5 → 0.24.2-optimized.50

package/dist/shared/{vite-ssg-optimized.46e3caf6.cjs → vite-ssg-optimized.e58a8d97.cjs}

@@ -839,35 +839,6 @@ class PQueue extends EventEmitter {
     }
 }
 
-async function getBeastiesOrCritters(outDir, options = {}) {
-  try {
-    const BeastiesClass = (await import('beasties')).default;
-    return new BeastiesClass({
-      path: outDir,
-      logLevel: "warn",
-      external: true,
-      inlineFonts: true,
-      preloadFonts: true,
-      ...options
-    });
-  } catch {
-  }
-  try {
-    const CrittersClass = (await import('critters')).default;
-    console.warn("`critters` is deprecated. Please use `beasties` instead.");
-    return new CrittersClass({
-      path: outDir,
-      logLevel: "warn",
-      external: true,
-      inlineFonts: true,
-      preloadFonts: true,
-      ...options
-    });
-  } catch {
-    return void 0;
-  }
-}
-
 function isMatchOption(node, opts) {
   if (opts.match.tag && !(node.name === opts.match.tag)) {
     return false;
@@ -1053,15 +1024,16 @@ class BuildWorkerProxy {
   constructor(path, options) {
     __publicField(this, "worker");
     __publicField(this, "pending", /* @__PURE__ */ new Map());
+    __publicField(this, "_id");
     this.worker = new node_worker_threads.Worker(path, options);
+    this._id = options.workerData.workerId;
     this.worker.on("message", (message) => {
       const { type, level = "info", args = [] } = message;
       if (type !== "log")
         return;
       const fn = console[level]?.bind(console);
-      let msg = args.map((arg) => typeof arg === "object" && !!arg ? "[object]" : arg).join(" ");
       const workerId = options.workerData.workerId;
-      fn?.(`[woker #${workerId}] ${msg}`);
+      fn?.(`[woker #${workerId}] `, ...args, kolorist.reset(""));
     });
     this.worker.on("message", (message) => {
       const { id, type, result = void 0, error = void 0 } = message;
@@ -1076,12 +1048,18 @@ class BuildWorkerProxy {
       }
     });
   }
+  get id() {
+    return this._id;
+  }
   on(type, listener) {
     this.worker.on(type, listener);
   }
   off(type, listener) {
     this.worker.off(type, listener);
   }
+  once(type, listener) {
+    this.worker.once(type, listener);
+  }
   async send(type, args) {
     const id = crypto.randomUUID();
     const promise = new Promise((resolve, reject) => {
@@ -1094,7 +1072,9 @@ class BuildWorkerProxy {
     return promise;
   }
   terminate() {
-    this.worker.terminate();
+    return this.worker.terminate().finally(() => {
+      this.pending.clear();
+    });
   }
 }
 
@@ -1122,10 +1102,14 @@ async function buildClient(config, viteConfig) {
     mode: config.mode
   }));
 }
-async function buildServer(config, viteConfig, { ssrEntry, ssgOut, format }) {
+async function buildServer(config, viteConfig, { ssrEntry, ssgOut, format, mock }) {
   buildLog("Build for server...");
   process__default.env.VITE_SSG = "true";
   const { base } = config;
+  if (mock) {
+    const { jsdomGlobal } = await import('../chunks/jsdomGlobal.cjs');
+    jsdomGlobal();
+  }
   await vite.build(vite.mergeConfig(viteConfig, {
     base,
     build: {
@@ -1146,6 +1130,19 @@ async function buildServer(config, viteConfig, { ssrEntry, ssgOut, format }) {
     mode: config.mode
   }));
 }
+function createProxy(options) {
+  const workerExt = options.format === "esm" ? ".mjs" : ".cjs";
+  const workerProxy = new BuildWorkerProxy(new URL(`./build.worker${workerExt}`, (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/vite-ssg-optimized.e58a8d97.cjs', document.baseURI).href))), {
+    env: process__default.env,
+    workerData: options
+  });
+  process__default.once("SIGINT", workerProxy.terminate.bind(workerProxy));
+  process__default.once("SIGTERM", workerProxy.terminate.bind(workerProxy));
+  process__default.once("SIGBREAK", workerProxy.terminate.bind(workerProxy));
+  process__default.once("beforeExit", workerProxy.terminate.bind(workerProxy));
+  process__default.once("exit", workerProxy.terminate.bind(workerProxy));
+  return workerProxy;
+}
 async function build(ssgOptions = {}, viteConfig = {}) {
   const nodeEnv = process__default.env.NODE_ENV || "production";
   const mode = process__default.env.MODE || ssgOptions.mode || nodeEnv;
@@ -1160,12 +1157,13 @@ async function build(ssgOptions = {}, viteConfig = {}) {
     ssgOut: _ssgOutDir = node_path.join(root, ".vite-ssg-temp", Math.random().toString(36).substring(2, 12)),
     formatting = "none",
     minifyOptions = {},
-    crittersOptions = {},
+    // crittersOptions = {},
     beastiesOptions = {},
     includedRoutes: configIncludedRoutes = DefaultIncludedRoutes,
-    onBeforePageRender,
-    onPageRendered,
-    onDonePageRender,
+    // onBeforePageRender,
+    // onPageRendered,
+    // onDonePageRender,
+    numberOfWorkers: _numberOfWorkers = 5,
     onFinished,
     dirStyle = "flat",
     includeAllRoutes = false,
@@ -1174,6 +1172,14 @@ async function build(ssgOptions = {}, viteConfig = {}) {
     rootContainerId = "app"
   } = Object.assign({}, config.ssgOptions || {}, ssgOptions);
   const ssgOut = node_path.isAbsolute(_ssgOutDir) ? _ssgOutDir : node_path.join(root, _ssgOutDir);
+  const createProxyOptions = {
+    format,
+    out,
+    dirStyle,
+    viteConfig: {
+      configFile: config.configFile
+    }
+  };
   let willRunBuild = true;
   if (fs__default.existsSync(ssgOut)) {
     willRunBuild = !ssgOptions["skip-build"];
@@ -1181,28 +1187,87 @@ async function build(ssgOptions = {}, viteConfig = {}) {
       await fs__default.remove(ssgOut);
     }
   }
-  if (willRunBuild)
-    await buildClient(config, viteConfig);
-  if (mock) {
-    const { jsdomGlobal } = await import('../chunks/jsdomGlobal.cjs');
-    jsdomGlobal();
+  const buildPromises = [];
+  if (willRunBuild) {
+    const clientWorker = createProxy({
+      ...createProxyOptions,
+      workerId: "client"
+    });
+    clientWorker.on("unhandledRejection", (error) => {
+      console.error(error);
+      clientWorker.terminate();
+    });
+    const cpBuildClient = execInWorker(clientWorker, buildClient, config, viteConfig).finally(() => clientWorker.terminate());
+    buildPromises.push(cpBuildClient);
   }
   const ssrEntry = await resolveAlias(config, entry);
-  if (willRunBuild)
-    await buildServer(config, viteConfig, { ssrEntry, ssgOut, format });
+  if (willRunBuild) {
+    const serverWorker = createProxy({
+      ...createProxyOptions,
+      workerId: "server"
+    });
+    const cpBuildServer = execInWorker(serverWorker, buildServer, config, viteConfig, { ssrEntry, ssgOut, format, mock }).finally(() => serverWorker.terminate());
+    buildPromises.push(cpBuildServer);
+  }
+  await Promise.all(buildPromises);
   const prefix = format === "esm" && process__default.platform === "win32" ? "file://" : "";
   const ext = format === "esm" ? ".mjs" : ".cjs";
+  const numberOfWorkers = Math.max(1, _numberOfWorkers);
+  console.log(`${kolorist.gray("[vite-ssg]")} ${kolorist.blue(`Using ${numberOfWorkers} workers`)}`);
+  const workers = Array.from({ length: numberOfWorkers }, (_, index) => createProxy({
+    ...createProxyOptions,
+    workerId: index
+  }));
+  const workersInUse = /* @__PURE__ */ new Map();
+  const terminateWorker = async (worker, onFinished2) => {
+    if (onFinished2) {
+      await execInWorker(worker, onFinished2);
+    }
+    const foundIndex = workers.indexOf(worker);
+    if (foundIndex > -1) {
+      workers.splice(foundIndex, 1);
+    }
+    await worker.terminate().finally(() => {
+      workersInUse.delete(worker);
+    });
+  };
+  const terminateWorkers = async (onFinished2) => {
+    await Promise.all(workers.map((worker) => terminateWorker(worker, onFinished2)));
+  };
+  let workerIndex = 0;
+  const maxTasksPerWorker = Math.ceil(concurrency / numberOfWorkers);
+  const workerTasksRunning = (w) => workersInUse.get(w)?.length || 0;
+  const selectIdleWorker = () => workers.filter((w) => workerTasksRunning(w) < maxTasksPerWorker).sort((a, b) => workerTasksRunning(a) - workerTasksRunning(b))[0];
+  const selectWorker = async (workerIndex2) => {
+    const index = workerIndex2 ?? Math.round(Math.random() * numberOfWorkers);
+    const maybeWorker = workers[index % numberOfWorkers];
+    const worker = maybeWorker && workerTasksRunning(maybeWorker) < maxTasksPerWorker ? maybeWorker : selectIdleWorker();
+    if (!worker) {
+      await Promise.race(Array.from(workersInUse.values()).flat());
+      return selectWorker(workerIndex2);
+    }
+    const workerPromises = workersInUse.get(worker) || [];
+    const delayPromise = new Promise((resolve) => setImmediate(resolve));
+    workerPromises.push(delayPromise);
+    workersInUse.set(worker, workerPromises);
+    delayPromise.finally(() => {
+      const workerPromises2 = workersInUse.get(worker) || [];
+      const foundIndex = workerPromises2.indexOf(delayPromise);
+      if (foundIndex > -1) {
+        workerPromises2.splice(foundIndex, 1);
+      }
+      workersInUse.set(worker, workerPromises2);
+    });
+    return worker;
+  };
   const serverEntry = prefix + node_path.join(ssgOut, node_path.parse(ssrEntry).name + ext).replace(/\\/g, "/");
-  const _require = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/vite-ssg-optimized.46e3caf6.cjs', document.baseURI).href)));
+  const _require = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/vite-ssg-optimized.e58a8d97.cjs', document.baseURI).href)));
   const { createApp, includedRoutes: serverEntryIncludedRoutes } = format === "esm" ? await import(serverEntry) : _require(serverEntry);
   const includedRoutes = serverEntryIncludedRoutes || configIncludedRoutes;
   const { routes } = await createApp(false);
   let routesPaths = includeAllRoutes ? routesToPaths(routes) : await includedRoutes(routesToPaths(routes), routes || []);
   routesPaths = Array.from(new Set(routesPaths));
   buildLog("Rendering Pages...", routesPaths.length);
-  const beasties = beastiesOptions !== false ? await getBeastiesOrCritters(outDir, beastiesOptions) : void 0;
-  if (beasties)
-    console.log(`${kolorist.gray("[vite-ssg]")} ${kolorist.blue("Critical CSS generation enabled via `beasties`")}`);
   const {
     path: _ssrManifestPath,
     content: ssrManifestRaw
@@ -1217,46 +1282,76 @@ async function build(ssgOptions = {}, viteConfig = {}) {
   indexHTML = rewriteScripts(indexHTML, script);
   const IS_PROD = nodeEnv === "production";
   indexHTML = await formatHtml(indexHTML, IS_PROD ? "minify" : formatting, minifyOptions);
+  const workerRunCount = /* @__PURE__ */ new WeakMap();
+  const MAX_RUNS_PER_WORKER = 100;
+  let lastWorkerIndex = workers.length - 1;
+  function replaceWorker(workerProxy) {
+    const index = workers.indexOf(workerProxy);
+    if (index === -1) {
+      return workerProxy;
+    }
+    ++lastWorkerIndex;
+    config.logger.info(`${kolorist.blue("[vite-ssg]")} ${kolorist.yellow(`Replace worker #${workerProxy.id} => #${lastWorkerIndex}`)}`);
+    const workerPromises = workersInUse.get(workerProxy) || [];
+    const newWorkerProxy = createProxy({
+      ...createProxyOptions,
+      workerId: lastWorkerIndex
+    });
+    workers[index] = newWorkerProxy;
+    Promise.allSettled([...workerPromises, Promise.resolve()]).then(async () => {
+      await terminateWorker(workerProxy, onFinished);
+    });
+    return newWorkerProxy;
+  }
   const queue = new PQueue({ concurrency });
-  const workerExt = format === "esm" ? ".mjs" : ".cjs";
-  const createProxy = (index) => {
-    const workerProxy = new BuildWorkerProxy(new URL(`./build.worker${workerExt}`, (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/vite-ssg-optimized.46e3caf6.cjs', document.baseURI).href))), {
-      env: process__default.env,
-      workerData: {
-        workerId: index,
-        serverEntry,
+  for (const route of routesPaths) {
+    await queue.onSizeLessThan(concurrency);
+    queue.add(async () => {
+      let workerProxy = await selectWorker(workerIndex++ % numberOfWorkers);
+      const currentCount = (workerRunCount.get(workerProxy) ?? 0) + 1;
+      workerRunCount.set(workerProxy, currentCount);
+      if (currentCount > MAX_RUNS_PER_WORKER) {
+        workerRunCount.delete(workerProxy);
+        workerProxy = replaceWorker(workerProxy);
+      }
+      let retryCount = 0;
+      const maxRetries = 3;
+      const execOpts = {
+        route,
         ssrManifest,
-        format,
-        out,
-        beastiesOptions,
-        dirStyle,
         indexHTML,
         rootContainerId,
         formatting,
         minifyOptions,
-        viteConfig: {
-          configFile: config.configFile || "vite.config.ts"
+        // out,
+        // dirStyle,
+        beastiesOptions,
+        serverEntry
+      };
+      const taskPromise = executeTaskInWorker(workerProxy, execOpts);
+      const workerPromises = workersInUse.get(workerProxy) || [];
+      workerPromises.push(taskPromise);
+      workersInUse.set(workerProxy, workerPromises);
+      const retryFn = async (e) => {
+        if (retryCount++ < maxRetries) {
+          console.log(`${kolorist.gray("[vite-ssg]")} ${kolorist.yellow(`Retrying ${retryCount} of ${maxRetries} for route: ${kolorist.cyan(route)}`)}`);
+          return await executeTaskInWorker(workerProxy, execOpts).catch(retryFn);
         }
-      }
-    });
-    return workerProxy;
-  };
-  const numberOfWorkers = 5;
-  const workers = Array.from({ length: numberOfWorkers }, (_, index) => createProxy(index));
-  let workerIndex = 0;
-  for (const route of routesPaths) {
-    await queue.onSizeLessThan(concurrency + 5);
-    const workerProxy = workers[workerIndex];
-    workerIndex = (workerIndex + 1) % numberOfWorkers;
-    queue.add(async () => {
-      const taskPromise = executeTaskInWorker(workerProxy, {
-        route
+        throw e;
+      };
+      taskPromise.catch(retryFn).finally(() => {
+        const workerPromises2 = workersInUse.get(workerProxy) || [];
+        const foundIndex = workerPromises2.indexOf(taskPromise);
+        if (foundIndex > -1) {
+          workerPromises2.splice(foundIndex, 1);
+        }
+        workersInUse.set(workerProxy, workerPromises2);
       });
       return taskPromise;
     });
   }
   await queue.start().onIdle();
-  workers.forEach((worker) => worker.terminate());
+  await terminateWorkers(onFinished);
   if (!ssgOptions["skip-build"]) {
     await fs__default.remove(ssgOut);
   }
@@ -1276,14 +1371,10 @@ ${kolorist.gray("[vite-ssg]")} ${kolorist.green("Build finished.")}`);
   timeout.unref();
 }
 function executeTaskInWorker(worker, opts) {
-  opts = Object.entries(opts).reduce((acc, [key, value]) => {
-    if (typeof value === "function")
-      return acc;
-    const newKey = key;
-    acc[newKey] = value;
-    return acc;
-  }, {});
-  return worker.send("executeTaskFn", [opts]);
+  return execInWorker(worker, executeTaskFn, opts);
+}
+async function execInWorker(worker, fn, ...args) {
+  return await worker.send(fn.name, plainify(args ?? []));
 }
 async function executeTaskFn(opts) {
   const {
@@ -1292,7 +1383,7 @@ async function executeTaskFn(opts) {
     renderToString,
     indexHTML,
     onBeforePageRender,
-    onDonePageRender,
+    // onDonePageRender, 
     onPageRendered,
     ssrManifest,
     rootContainerId,
@@ -1352,7 +1443,6 @@ async function executeTaskFn(opts) {
       config.logger.info(
         `${kolorist.dim(`${outDir}/`)}${kolorist.cyan(filename.padEnd(15, " "))}  ${kolorist.dim(getSize(formatted))}`
       );
-      onDonePageRender?.(route, html, appCtx);
       return { route, html };
     });
   } catch (err) {
@@ -1360,6 +1450,27 @@ async function executeTaskFn(opts) {
 ${err.stack}`);
   }
 }
+function plainify(m) {
+  if (m instanceof Function) {
+    return void 0;
+  }
+  if (Array.isArray(m)) {
+    return m.map(plainify);
+  }
+  if (typeof m === "object" && m !== null) {
+    if (m instanceof Error || "stack" in m) {
+      return {
+        message: m.message,
+        stack: m.stack
+      };
+    }
+    return Object.entries(m).reduce((acc, [key, value]) => {
+      acc[key] = plainify(value);
+      return acc;
+    }, {});
+  }
+  return m;
+}
 async function detectEntry(root) {
   const scriptSrcReg = /<script.*?src=["'](.+?)["'](?!<).*>\s*<\/script>/gi;
   const html = await fs__default.readFile(node_path.join(root, "index.html"), "utf-8");
@@ -1459,5 +1570,7 @@ async function readFiles(...paths) {
 }
 
 exports.build = build;
+exports.buildClient = buildClient;
+exports.buildServer = buildServer;
 exports.executeTaskFn = executeTaskFn;
-exports.getBeastiesOrCritters = getBeastiesOrCritters;
+exports.plainify = plainify;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-ssg-optimized",
-  "version": "0.24.2-optimized.5",
+  "version": "0.24.2-optimized.50",
   "description": "Server-side generation for Vite",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",

package/dist/shared/vite-ssg-optimized.12fd9d22.d.cts

@@ -1,9 +0,0 @@
-import { InlineConfig } from 'vite';
-import { b as ViteSSGOptions } from './vite-ssg-optimized.cf5cb4ee.cjs';
-
-type Manifest = Record<string, string[]>;
-declare function build(ssgOptions?: Partial<ViteSSGOptions & {
-    'skip-build'?: boolean;
-}>, viteConfig?: InlineConfig): Promise<void>;
-
-export { type Manifest as M, build as b };

package/dist/shared/vite-ssg-optimized.892682c8.d.mts

@@ -1,9 +0,0 @@
-import { InlineConfig } from 'vite';
-import { b as ViteSSGOptions } from './vite-ssg-optimized.cf5cb4ee.mjs';
-
-type Manifest = Record<string, string[]>;
-declare function build(ssgOptions?: Partial<ViteSSGOptions & {
-    'skip-build'?: boolean;
-}>, viteConfig?: InlineConfig): Promise<void>;
-
-export { type Manifest as M, build as b };

package/dist/shared/vite-ssg-optimized.950926bc.d.ts

@@ -1,9 +0,0 @@
-import { InlineConfig } from 'vite';
-import { b as ViteSSGOptions } from './vite-ssg-optimized.cf5cb4ee.js';
-
-type Manifest = Record<string, string[]>;
-declare function build(ssgOptions?: Partial<ViteSSGOptions & {
-    'skip-build'?: boolean;
-}>, viteConfig?: InlineConfig): Promise<void>;
-
-export { type Manifest as M, build as b };