exit-signal/dist/index.cjs

A Node.js library for handling graceful process exits and shutdown signals.

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  gracefullyExit: () => gracefullyExit,
  onExit: () => onExit
});
module.exports = __toCommonJS(index_exports);
var import_node_process = __toESM(require("process"), 1);
var import_node_timers = require("timers");
var import_deasync = require("@se-oss/deasync");
var isRegistered = false;
var isCalled = false;
var shouldManuallyExit = true;
var exitHooks = new Array();
function addHook(handler, options = {}) {
  if (!isRegistered) {
    isRegistered = true;
    import_node_process.default.once("beforeExit", exit.bind(void 0, 0));
    import_node_process.default.once("SIGINT", exit.bind(void 0, 130));
    import_node_process.default.once("SIGTERM", exit.bind(void 0, 143));
    import_node_process.default.once("exit", () => {
      shouldManuallyExit = false;
    });
    import_node_process.default.on("message", (message) => {
      if (message === "shutdown") {
        exit(130);
      }
    });
  }
  const index = exitHooks.push({ handler, options });
  return index - 1;
}
function removeHook(index) {
  exitHooks[index] = null;
}
async function exit(exitCode) {
  if (isCalled) {
    return;
  }
  isCalled = true;
  let isDone = false;
  import_node_process.default.exitCode = exitCode;
  import_node_process.default.channel?.unref();
  const handlers = exitHooks.filter((hook) => hook !== null);
  let forceAfter = Math.max(
    ...handlers.map(({ options }) => options.timeout).filter((timeout) => typeof timeout === "number")
  );
  if (forceAfter <= 0 || !Number.isFinite(forceAfter)) {
    forceAfter = Infinity;
    const hasAsyncHandlers = handlers.some(
      ({ handler }) => typeof handler === "function" && handler.constructor.name !== "Function"
    );
    if (hasAsyncHandlers) {
      import_node_process.default.emitWarning(
        "No timeout was specified for the exit signal handler.\nIf the handler fails to resolve, it can result in a hanging process, potentially leading to a deadlock.\nManual termination of the process may then be necessary.",
        "Warning",
        "NES-WARN002"
      );
    }
  }
  const promises = [];
  for (const { handler } of handlers) {
    if (typeof handler === "function") {
      if (handler.constructor.name === "Function") {
        handler(exitCode);
      } else {
        promises.push(Promise.resolve(handler(exitCode)));
      }
    }
  }
  const done = (force = false) => {
    if (force) {
      import_node_process.default.emitWarning(
        "Process forcefully exited.\nThe process was terminated abruptly due to reaching the execution timeout.",
        "Warning",
        "NES-WARN001"
      );
    }
    if (force || shouldManuallyExit) {
      import_node_process.default.exit(exitCode);
    }
  };
  await Promise.all(promises).finally(() => {
    isDone = true;
  });
  if (forceAfter === Infinity) {
    (0, import_deasync.loopWhile)(() => !isDone);
    return done();
  }
  const asyncTimer = (0, import_node_timers.setTimeout)(() => done(true), forceAfter);
  (0, import_node_timers.clearTimeout)(asyncTimer);
  const start = Date.now();
  (0, import_deasync.loopWhile)(() => !isDone && Date.now() - start < forceAfter);
  return done();
}
function onExit(handler, options = {}) {
  const index = addHook(handler, options);
  return () => {
    removeHook(index);
  };
}
function gracefullyExit() {
  exit(0).then(() => {
  });
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  gracefullyExit,
  onExit
});