one/dist/cjs/cli/workerPool.js

One is a new React Framework that makes Vite serve both native and web.

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: !0 });
}, __copyProps = (to, from, except, desc) => {
  if (from && typeof from == "object" || typeof from == "function")
    for (let key of __getOwnPropNames(from))
      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
var workerPool_exports = {};
__export(workerPool_exports, {
  BuildWorkerPool: () => BuildWorkerPool,
  getWorkerPool: () => getWorkerPool,
  terminateWorkerPool: () => terminateWorkerPool
});
module.exports = __toCommonJS(workerPool_exports);
var import_node_worker_threads = require("node:worker_threads"), import_node_os = require("node:os"), import_node_url = require("node:url"), import_node_path = require("node:path");
const import_meta = {}, __filename = (0, import_node_url.fileURLToPath)(import_meta.url), __dirname = (0, import_node_path.dirname)(__filename);
class BuildWorkerPool {
  workers = [];
  available = [];
  taskQueue = [];
  pendingById = /* @__PURE__ */ new Map();
  nextId = 0;
  readyCount = 0;
  initCount = 0;
  _ready;
  _resolveReady;
  _initialized;
  _resolveInitialized;
  _terminated = !1;
  constructor(size = Math.max(1, (0, import_node_os.cpus)().length - 1)) {
    this._ready = new Promise((resolve) => {
      this._resolveReady = resolve;
    }), this._initialized = new Promise((resolve) => {
      this._resolveInitialized = resolve;
    });
    const workerPath = (0, import_node_path.join)(__dirname, "buildPageWorker.mjs");
    for (let i = 0; i < size; i++) {
      const worker = new import_node_worker_threads.Worker(workerPath);
      worker.on("message", (msg) => {
        if (msg.type === "ready")
          this.readyCount++, this.available.push(worker), this.readyCount === size && this._resolveReady();
        else if (msg.type === "init-done")
          this.initCount++, this.initCount === size && this._resolveInitialized(), this.dispatch();
        else if (msg.type === "done" || msg.type === "error") {
          const pending = this.pendingById.get(msg.id);
          pending && (this.pendingById.delete(msg.id), msg.type === "done" ? pending.resolve(msg.result) : pending.reject(new Error(msg.error))), this.available.push(worker), this.dispatch();
        }
      }), worker.on("error", (err) => {
        console.error("[BuildWorkerPool] Worker error:", err);
      }), this.workers.push(worker);
    }
  }
  get size() {
    return this.workers.length;
  }
  // initialize all workers - they load config themselves from vite.config
  async initialize() {
    await this._ready;
    for (const worker of this.workers)
      worker.postMessage({ type: "init", id: this.nextId++ });
    await this._initialized;
  }
  dispatch() {
    for (; this.available.length > 0 && this.taskQueue.length > 0; ) {
      const worker = this.available.shift(), { msg, pending } = this.taskQueue.shift();
      this.pendingById.set(pending.id, pending), worker.postMessage(msg);
    }
  }
  async buildPage(args) {
    if (this._terminated)
      throw new Error("Worker pool has been terminated");
    const serializedRoute = {
      type: args.foundRoute.type,
      file: args.foundRoute.file,
      // only keep serializable layout data
      layouts: args.foundRoute.layouts?.map((layout) => ({
        contextKey: layout.contextKey,
        loaderServerPath: layout.loaderServerPath,
        layoutRenderMode: layout.layoutRenderMode
      })),
      // only keep contextKey from middlewares
      middlewares: args.foundRoute.middlewares?.map((mw) => ({
        contextKey: mw.contextKey
      }))
    }, id = this.nextId++, msg = {
      type: "build",
      id,
      args: {
        ...args,
        foundRoute: serializedRoute
      }
    };
    return new Promise((resolve, reject) => {
      const pending = { id, resolve, reject };
      this.taskQueue.push({ msg, pending }), this.dispatch();
    });
  }
  async terminate() {
    this._terminated = !0, await Promise.all(this.workers.map((w) => w.terminate())), this.workers = [], this.available = [];
  }
}
let pool = null;
function getWorkerPool(size) {
  return pool || (pool = new BuildWorkerPool(size)), pool;
}
async function terminateWorkerPool() {
  pool && (await pool.terminate(), pool = null);
}
//# sourceMappingURL=workerPool.js.map