one/dist/esm/serve.native.js

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

import FSExtra from "fs-extra";
import { setServerGlobals } from "./server/setServerGlobals.native.js";
import { setupBuildInfo } from "./server/setupBuildOptions.native.js";
import { ensureExists } from "./utils/ensureExists.native.js";
process.on("uncaughtException", function (err) {
  console.error(`[one] Uncaught exception`, (err === null || err === void 0 ? void 0 : err.stack) || err);
});
async function serve() {
  var args = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
  if (args.cluster) {
    var {
      cpus,
      platform
    } = await import("os");
    var numWorkers = typeof args.cluster === "number" ? args.cluster : cpus().length;
    var isBun = typeof process.versions.bun !== "undefined";
    var canReusePort = !["win32", "darwin"].includes(platform()) && (isBun || function () {
      var [major, minor] = process.versions.node.split(".").map(Number);
      return major > 22 || major === 22 && minor >= 12 || major >= 23;
    }());
    if (canReusePort) {
      return await serveWithReusePort(args, numWorkers);
    } else if (!isBun) {
      return await serveWithCluster(args, numWorkers);
    } else {
      console.warn(`[one] cluster mode not supported on ${platform()} with bun, running single process`);
      return await startWorker(args);
    }
  }
  return await startWorker(args);
}
async function serveWithReusePort(args, numWorkers) {
  var {
    fork
  } = await import("child_process");
  console.info(`[one] cluster: starting ${numWorkers} workers (SO_REUSEPORT)`);
  var workers = [];
  var recentCrashes = 0;
  var lastCrashTime = 0;
  function spawnWorker() {
    var child = fork(process.argv[1], process.argv.slice(2).filter(function (a) {
      return !a.startsWith("--cluster");
    }), {
      env: {
        ...process.env,
        ONE_CLUSTER_WORKER: "1"
      },
      stdio: "inherit"
    });
    workers.push(child);
    child.on("exit", function (code, signal) {
      var idx = workers.indexOf(child);
      if (idx >= 0) workers.splice(idx, 1);
      if (code === 0 || signal === "SIGTERM" || signal === "SIGINT") return;
      var now = Date.now();
      if (now - lastCrashTime < 5e3) {
        recentCrashes++;
      } else {
        recentCrashes = 1;
      }
      lastCrashTime = now;
      if (recentCrashes > numWorkers * 2) {
        console.error(`[one] too many worker crashes, stopping`);
        process.exit(1);
      }
      console.error(`[one] worker ${child.pid} died (code ${code}, signal ${signal}), restarting`);
      setTimeout(spawnWorker, Math.min(recentCrashes * 500, 5e3));
    });
  }
  for (var i = 0; i < numWorkers; i++) {
    spawnWorker();
  }
  var shutdown = function () {
    var _iteratorNormalCompletion = true,
      _didIteratorError = false,
      _iteratorError = void 0;
    try {
      for (var _iterator = workers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var w = _step.value;
        w.kill("SIGTERM");
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return != null) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }
    setTimeout(function () {
      return process.exit(0);
    }, 5e3);
  };
  process.on("SIGINT", shutdown);
  process.on("SIGTERM", shutdown);
  await new Promise(function () {});
}
async function serveWithCluster(args, numWorkers) {
  var cluster = await import("cluster");
  if (cluster.default.isPrimary) {
    console.info(`[one] cluster: starting ${numWorkers} workers (IPC)`);
    for (var i = 0; i < numWorkers; i++) {
      cluster.default.fork();
    }
    var recentCrashes = 0;
    var lastCrashTime = 0;
    cluster.default.on("exit", function (worker, code, signal) {
      if (code === 0 || signal === "SIGTERM" || signal === "SIGINT") return;
      var now = Date.now();
      if (now - lastCrashTime < 5e3) {
        recentCrashes++;
      } else {
        recentCrashes = 1;
      }
      lastCrashTime = now;
      if (recentCrashes > numWorkers * 2) {
        console.error(`[one] too many worker crashes, stopping`);
        process.exit(1);
      }
      console.error(`[one] worker ${worker.process.pid} died (code ${code}, signal ${signal}), restarting`);
      setTimeout(function () {
        return cluster.default.fork();
      }, Math.min(recentCrashes * 500, 5e3));
    });
    var shutdown = function () {
      for (var id in cluster.default.workers) {
        var _cluster_default_workers_id;
        (_cluster_default_workers_id = cluster.default.workers[id]) === null || _cluster_default_workers_id === void 0 ? void 0 : _cluster_default_workers_id.process.kill("SIGTERM");
      }
      setTimeout(function () {
        return process.exit(0);
      }, 5e3);
    };
    process.on("SIGINT", shutdown);
    process.on("SIGTERM", shutdown);
    return;
  }
  return await startWorker(args);
}
async function startWorker(args) {
  var _oneOptions_server;
  var outDir = (args === null || args === void 0 ? void 0 : args.outDir) || (FSExtra.existsSync("buildInfo.json") ? "." : null) || "dist";
  var buildInfo = await FSExtra.readJSON(`${outDir}/buildInfo.json`);
  var {
    oneOptions
  } = buildInfo;
  setServerGlobals();
  setupBuildInfo(buildInfo);
  ensureExists(oneOptions);
  var {
    labelProcess
  } = await import("./cli/label-process.native.js");
  var {
    removeUndefined
  } = await import("./utils/removeUndefined.native.js");
  var {
    loadEnv,
    serve: vxrnServe,
    serveStaticAssets,
    compileCacheRules
  } = await import("vxrn/serve");
  var {
    oneServe
  } = await import("./server/oneServe.native.js");
  labelProcess("serve");
  if (args === null || args === void 0 ? void 0 : args.loadEnv) {
    await loadEnv("production");
  }
  var cacheRules = ((_oneOptions_server = oneOptions.server) === null || _oneOptions_server === void 0 ? void 0 : _oneOptions_server.cacheControl) ? compileCacheRules(oneOptions.server.cacheControl) : void 0;
  return await vxrnServe({
    outDir: buildInfo.outDir || outDir,
    app: args === null || args === void 0 ? void 0 : args.app,
    ...oneOptions.server,
    ...removeUndefined({
      port: (args === null || args === void 0 ? void 0 : args.port) ? +args.port : void 0,
      host: args === null || args === void 0 ? void 0 : args.host,
      compress: args === null || args === void 0 ? void 0 : args.compress
    }),
    async beforeRegisterRoutes(options, app) {
      await oneServe(oneOptions, buildInfo, app, {
        serveStaticAssets: function (ctx) {
          return serveStaticAssets({
            ...ctx,
            cacheRules
          });
        }
      });
    },
    async afterRegisterRoutes(options, app) {}
  });
}
export { serve };
//# sourceMappingURL=serve.native.js.map