@wix/cli 1.1.192 → 1.1.194

package/build/{chunk-WSX7GEXO.js → chunk-NMCF7XG5.js}

@@ -3,9 +3,6 @@ const require = _createRequire(import.meta.url);
 import {
   require_isexe
 } from "./chunk-MHV22UIU.js";
-import {
-  onExit
-} from "./chunk-IBOXARGJ.js";
 import {
   __commonJS,
   __require,
@@ -440,7 +437,7 @@ var import_cross_spawn = __toESM(require_cross_spawn(), 1);
 import { Buffer as Buffer3 } from "node:buffer";
 import path2 from "node:path";
 import childProcess from "node:child_process";
-import process5 from "node:process";
+import process6 from "node:process";
 
 // ../../node_modules/strip-final-newline/index.js
 init_esm_shims();
@@ -887,8 +884,8 @@ var SIGNALS = [
 // ../../node_modules/human-signals/build/src/signals.js
 var getSignals = () => {
   const realtimeSignals = getRealtimeSignals();
-  const signals = [...SIGNALS, ...realtimeSignals].map(normalizeSignal);
-  return signals;
+  const signals2 = [...SIGNALS, ...realtimeSignals].map(normalizeSignal);
+  return signals2;
 };
 var normalizeSignal = ({
   name,
@@ -908,8 +905,8 @@ var normalizeSignal = ({
 
 // ../../node_modules/human-signals/build/src/main.js
 var getSignalsByName = () => {
-  const signals = getSignals();
-  return Object.fromEntries(signals.map(getSignalByName));
+  const signals2 = getSignals();
+  return Object.fromEntries(signals2.map(getSignalByName));
 };
 var getSignalByName = ({
   name,
@@ -922,16 +919,16 @@ var getSignalByName = ({
 }) => [name, { name, number, description, supported, action, forced, standard }];
 var signalsByName = getSignalsByName();
 var getSignalsByNumber = () => {
-  const signals = getSignals();
+  const signals2 = getSignals();
   const length = SIGRTMAX + 1;
   const signalsA = Array.from(
     { length },
-    (value, number) => getSignalByNumber(number, signals)
+    (value, number) => getSignalByNumber(number, signals2)
   );
   return Object.assign({}, ...signalsA);
 };
-var getSignalByNumber = (number, signals) => {
-  const signal = findSignalByNumber(number, signals);
+var getSignalByNumber = (number, signals2) => {
+  const signal = findSignalByNumber(number, signals2);
   if (signal === void 0) {
     return {};
   }
@@ -948,12 +945,12 @@ var getSignalByNumber = (number, signals) => {
     }
   };
 };
-var findSignalByNumber = (number, signals) => {
-  const signal = signals.find(({ name }) => constants2.signals[name] === number);
+var findSignalByNumber = (number, signals2) => {
+  const signal = signals2.find(({ name }) => constants2.signals[name] === number);
   if (signal !== void 0) {
     return signal;
   }
-  return signals.find((signalA) => signalA.number === number);
+  return signals2.find((signalA) => signalA.number === number);
 };
 var signalsByNumber = getSignalsByNumber();
 
@@ -1069,6 +1066,263 @@ var normalizeStdioNode = (options) => {
 // ../../node_modules/execa/lib/kill.js
 init_esm_shims();
 import os from "node:os";
+
+// ../../node_modules/execa/node_modules/signal-exit/dist/mjs/index.js
+init_esm_shims();
+
+// ../../node_modules/execa/node_modules/signal-exit/dist/mjs/signals.js
+init_esm_shims();
+var signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") {
+  signals.push(
+    "SIGALRM",
+    "SIGABRT",
+    "SIGVTALRM",
+    "SIGXCPU",
+    "SIGXFSZ",
+    "SIGUSR2",
+    "SIGTRAP",
+    "SIGSYS",
+    "SIGQUIT",
+    "SIGIOT"
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+  );
+}
+if (process.platform === "linux") {
+  signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+}
+
+// ../../node_modules/execa/node_modules/signal-exit/dist/mjs/index.js
+var processOk = (process7) => !!process7 && typeof process7 === "object" && typeof process7.removeListener === "function" && typeof process7.emit === "function" && typeof process7.reallyExit === "function" && typeof process7.listeners === "function" && typeof process7.kill === "function" && typeof process7.pid === "number" && typeof process7.on === "function";
+var kExitEmitter = Symbol.for("signal-exit emitter");
+var global = globalThis;
+var ObjectDefineProperty = Object.defineProperty.bind(Object);
+var Emitter = class {
+  emitted = {
+    afterExit: false,
+    exit: false
+  };
+  listeners = {
+    afterExit: [],
+    exit: []
+  };
+  count = 0;
+  id = Math.random();
+  constructor() {
+    if (global[kExitEmitter]) {
+      return global[kExitEmitter];
+    }
+    ObjectDefineProperty(global, kExitEmitter, {
+      value: this,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  on(ev, fn) {
+    this.listeners[ev].push(fn);
+  }
+  removeListener(ev, fn) {
+    const list = this.listeners[ev];
+    const i = list.indexOf(fn);
+    if (i === -1) {
+      return;
+    }
+    if (i === 0 && list.length === 1) {
+      list.length = 0;
+    } else {
+      list.splice(i, 1);
+    }
+  }
+  emit(ev, code, signal) {
+    if (this.emitted[ev]) {
+      return false;
+    }
+    this.emitted[ev] = true;
+    let ret = false;
+    for (const fn of this.listeners[ev]) {
+      ret = fn(code, signal) === true || ret;
+    }
+    if (ev === "exit") {
+      ret = this.emit("afterExit", code, signal) || ret;
+    }
+    return ret;
+  }
+};
+var SignalExitBase = class {
+};
+var signalExitWrap = (handler) => {
+  return {
+    onExit(cb, opts) {
+      return handler.onExit(cb, opts);
+    },
+    load() {
+      return handler.load();
+    },
+    unload() {
+      return handler.unload();
+    }
+  };
+};
+var SignalExitFallback = class extends SignalExitBase {
+  onExit() {
+    return () => {
+    };
+  }
+  load() {
+  }
+  unload() {
+  }
+};
+var SignalExit = class extends SignalExitBase {
+  // "SIGHUP" throws an `ENOSYS` error on Windows,
+  // so use a supported signal instead
+  /* c8 ignore start */
+  #hupSig = process4.platform === "win32" ? "SIGINT" : "SIGHUP";
+  /* c8 ignore stop */
+  #emitter = new Emitter();
+  #process;
+  #originalProcessEmit;
+  #originalProcessReallyExit;
+  #sigListeners = {};
+  #loaded = false;
+  constructor(process7) {
+    super();
+    this.#process = process7;
+    this.#sigListeners = {};
+    for (const sig of signals) {
+      this.#sigListeners[sig] = () => {
+        const listeners = this.#process.listeners(sig);
+        let { count } = this.#emitter;
+        const p = process7;
+        if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+          count += p.__signal_exit_emitter__.count;
+        }
+        if (listeners.length === count) {
+          this.unload();
+          const ret = this.#emitter.emit("exit", null, sig);
+          const s = sig === "SIGHUP" ? this.#hupSig : sig;
+          if (!ret)
+            process7.kill(process7.pid, s);
+        }
+      };
+    }
+    this.#originalProcessReallyExit = process7.reallyExit;
+    this.#originalProcessEmit = process7.emit;
+  }
+  onExit(cb, opts) {
+    if (!processOk(this.#process)) {
+      return () => {
+      };
+    }
+    if (this.#loaded === false) {
+      this.load();
+    }
+    const ev = opts?.alwaysLast ? "afterExit" : "exit";
+    this.#emitter.on(ev, cb);
+    return () => {
+      this.#emitter.removeListener(ev, cb);
+      if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+        this.unload();
+      }
+    };
+  }
+  load() {
+    if (this.#loaded) {
+      return;
+    }
+    this.#loaded = true;
+    this.#emitter.count += 1;
+    for (const sig of signals) {
+      try {
+        const fn = this.#sigListeners[sig];
+        if (fn)
+          this.#process.on(sig, fn);
+      } catch (_) {
+      }
+    }
+    this.#process.emit = (ev, ...a) => {
+      return this.#processEmit(ev, ...a);
+    };
+    this.#process.reallyExit = (code) => {
+      return this.#processReallyExit(code);
+    };
+  }
+  unload() {
+    if (!this.#loaded) {
+      return;
+    }
+    this.#loaded = false;
+    signals.forEach((sig) => {
+      const listener = this.#sigListeners[sig];
+      if (!listener) {
+        throw new Error("Listener not defined for signal: " + sig);
+      }
+      try {
+        this.#process.removeListener(sig, listener);
+      } catch (_) {
+      }
+    });
+    this.#process.emit = this.#originalProcessEmit;
+    this.#process.reallyExit = this.#originalProcessReallyExit;
+    this.#emitter.count -= 1;
+  }
+  #processReallyExit(code) {
+    if (!processOk(this.#process)) {
+      return 0;
+    }
+    this.#process.exitCode = code || 0;
+    this.#emitter.emit("exit", this.#process.exitCode, null);
+    return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+  }
+  #processEmit(ev, ...args) {
+    const og = this.#originalProcessEmit;
+    if (ev === "exit" && processOk(this.#process)) {
+      if (typeof args[0] === "number") {
+        this.#process.exitCode = args[0];
+      }
+      const ret = og.call(this.#process, ev, ...args);
+      this.#emitter.emit("exit", this.#process.exitCode, null);
+      return ret;
+    } else {
+      return og.call(this.#process, ev, ...args);
+    }
+  }
+};
+var process4 = globalThis.process;
+var {
+  /**
+   * Called when the process is exiting, whether via signal, explicit
+   * exit, or running out of stuff to do.
+   *
+   * If the global process object is not suitable for instrumentation,
+   * then this will be a no-op.
+   *
+   * Returns a function that may be used to unload signal-exit.
+   */
+  onExit,
+  /**
+   * Load the listeners.  Likely you never need to call this, unless
+   * doing a rather deep integration with signal-exit functionality.
+   * Mostly exposed for the benefit of testing.
+   *
+   * @internal
+   */
+  load,
+  /**
+   * Unload the listeners.  Likely you never need to call this, unless
+   * doing a rather deep integration with signal-exit functionality.
+   * Mostly exposed for the benefit of testing.
+   *
+   * @internal
+   */
+  unload
+} = signalExitWrap(processOk(process4) ? new SignalExit(process4) : new SignalExitFallback());
+
+// ../../node_modules/execa/lib/kill.js
 var DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
 var spawnedKill = (kill, signal = "SIGTERM", options = {}) => {
   const killResult = kill(signal);
@@ -1595,7 +1849,7 @@ var parseTemplates = (templates, expressions) => {
 // ../../node_modules/execa/lib/verbose.js
 init_esm_shims();
 import { debuglog } from "node:util";
-import process4 from "node:process";
+import process5 from "node:process";
 var verboseDefault = debuglog("execa").enabled;
 var padField = (field, padding) => String(field).padStart(padding, "0");
 var getTimestamp = () => {
@@ -1606,14 +1860,14 @@ var logCommand = (escapedCommand, { verbose }) => {
   if (!verbose) {
     return;
   }
-  process4.stderr.write(`[${getTimestamp()}] ${escapedCommand}
+  process5.stderr.write(`[${getTimestamp()}] ${escapedCommand}
 `);
 };
 
 // ../../node_modules/execa/index.js
 var DEFAULT_MAX_BUFFER = 1e3 * 1e3 * 100;
 var getEnv = ({ env: envOption, extendEnv, preferLocal, localDir, execPath }) => {
-  const env = extendEnv ? { ...process5.env, ...envOption } : envOption;
+  const env = extendEnv ? { ...process6.env, ...envOption } : envOption;
   if (preferLocal) {
     return npmRunPathEnv({ env, cwd: localDir, execPath });
   }
@@ -1630,8 +1884,8 @@ var handleArguments = (file, args, options = {}) => {
     stripFinalNewline: true,
     extendEnv: true,
     preferLocal: false,
-    localDir: options.cwd || process5.cwd(),
-    execPath: process5.execPath,
+    localDir: options.cwd || process6.cwd(),
+    execPath: process6.execPath,
     encoding: "utf8",
     reject: true,
     cleanup: true,
@@ -1642,7 +1896,7 @@ var handleArguments = (file, args, options = {}) => {
   };
   options.env = getEnv(options);
   options.stdio = normalizeStdio(options);
-  if (process5.platform === "win32" && path2.basename(file, ".exe") === "cmd") {
+  if (process6.platform === "win32" && path2.basename(file, ".exe") === "cmd") {
     args.unshift("/q");
   }
   return { file, args, options, parsed };
@@ -1827,9 +2081,9 @@ function execaNode(scriptPath, args, options = {}) {
     args = [];
   }
   const stdio = normalizeStdioNode(options);
-  const defaultExecArgv = process5.execArgv.filter((arg) => !arg.startsWith("--inspect"));
+  const defaultExecArgv = process6.execArgv.filter((arg) => !arg.startsWith("--inspect"));
   const {
-    nodePath = process5.execPath,
+    nodePath = process6.execPath,
     nodeOptions = defaultExecArgv
   } = options;
   return execa(
@@ -1858,4 +2112,4 @@ export {
   execaCommandSync,
   execaNode
 };
-//# sourceMappingURL=chunk-WSX7GEXO.js.map
+//# sourceMappingURL=chunk-NMCF7XG5.js.map