@wix/cli 1.1.56 → 1.1.57

package/build/{chunk-3UYDT5ZT.js → chunk-BHINMCY7.js}

@@ -11,16 +11,14 @@ import {
   require_supports_color
 } from "./chunk-W423UTD3.js";
 import {
-  cli_cursor_default,
   isUnicodeSupported,
   require_cli_spinners,
-  require_signal_exit,
   source_default,
   stripAnsi
-} from "./chunk-ZS2473DH.js";
+} from "./chunk-6F2RSXHN.js";
 import {
   getTestOverrides
-} from "./chunk-NEB7POM3.js";
+} from "./chunk-53UCEZFU.js";
 import {
   CliError,
   CliErrorCode,
@@ -660,6 +658,206 @@ var require_throttle = __commonJS({
   }
 });
 
+// ../../node_modules/signal-exit/signals.js
+var require_signals = __commonJS({
+  "../../node_modules/signal-exit/signals.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    module.exports = [
+      "SIGABRT",
+      "SIGALRM",
+      "SIGHUP",
+      "SIGINT",
+      "SIGTERM"
+    ];
+    if (process.platform !== "win32") {
+      module.exports.push(
+        "SIGVTALRM",
+        "SIGXCPU",
+        "SIGXFSZ",
+        "SIGUSR2",
+        "SIGTRAP",
+        "SIGSYS",
+        "SIGQUIT",
+        "SIGIOT"
+        // should detect profiler and enable/disable accordingly.
+        // see #21
+        // 'SIGPROF'
+      );
+    }
+    if (process.platform === "linux") {
+      module.exports.push(
+        "SIGIO",
+        "SIGPOLL",
+        "SIGPWR",
+        "SIGSTKFLT",
+        "SIGUNUSED"
+      );
+    }
+  }
+});
+
+// ../../node_modules/signal-exit/index.js
+var require_signal_exit = __commonJS({
+  "../../node_modules/signal-exit/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var process12 = global.process;
+    var processOk = function(process13) {
+      return process13 && typeof process13 === "object" && typeof process13.removeListener === "function" && typeof process13.emit === "function" && typeof process13.reallyExit === "function" && typeof process13.listeners === "function" && typeof process13.kill === "function" && typeof process13.pid === "number" && typeof process13.on === "function";
+    };
+    if (!processOk(process12)) {
+      module.exports = function() {
+        return function() {
+        };
+      };
+    } else {
+      assert = __require("assert");
+      signals = require_signals();
+      isWin = /^win/i.test(process12.platform);
+      EE = __require("events");
+      if (typeof EE !== "function") {
+        EE = EE.EventEmitter;
+      }
+      if (process12.__signal_exit_emitter__) {
+        emitter = process12.__signal_exit_emitter__;
+      } else {
+        emitter = process12.__signal_exit_emitter__ = new EE();
+        emitter.count = 0;
+        emitter.emitted = {};
+      }
+      if (!emitter.infinite) {
+        emitter.setMaxListeners(Infinity);
+        emitter.infinite = true;
+      }
+      module.exports = function(cb, opts) {
+        if (!processOk(global.process)) {
+          return function() {
+          };
+        }
+        assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
+        if (loaded === false) {
+          load();
+        }
+        var ev = "exit";
+        if (opts && opts.alwaysLast) {
+          ev = "afterexit";
+        }
+        var remove = function() {
+          emitter.removeListener(ev, cb);
+          if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
+            unload();
+          }
+        };
+        emitter.on(ev, cb);
+        return remove;
+      };
+      unload = function unload2() {
+        if (!loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = false;
+        signals.forEach(function(sig) {
+          try {
+            process12.removeListener(sig, sigListeners[sig]);
+          } catch (er) {
+          }
+        });
+        process12.emit = originalProcessEmit;
+        process12.reallyExit = originalProcessReallyExit;
+        emitter.count -= 1;
+      };
+      module.exports.unload = unload;
+      emit = function emit2(event, code, signal) {
+        if (emitter.emitted[event]) {
+          return;
+        }
+        emitter.emitted[event] = true;
+        emitter.emit(event, code, signal);
+      };
+      sigListeners = {};
+      signals.forEach(function(sig) {
+        sigListeners[sig] = function listener() {
+          if (!processOk(global.process)) {
+            return;
+          }
+          var listeners = process12.listeners(sig);
+          if (listeners.length === emitter.count) {
+            unload();
+            emit("exit", null, sig);
+            emit("afterexit", null, sig);
+            if (isWin && sig === "SIGHUP") {
+              sig = "SIGINT";
+            }
+            process12.kill(process12.pid, sig);
+          }
+        };
+      });
+      module.exports.signals = function() {
+        return signals;
+      };
+      loaded = false;
+      load = function load2() {
+        if (loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = true;
+        emitter.count += 1;
+        signals = signals.filter(function(sig) {
+          try {
+            process12.on(sig, sigListeners[sig]);
+            return true;
+          } catch (er) {
+            return false;
+          }
+        });
+        process12.emit = processEmit;
+        process12.reallyExit = processReallyExit;
+      };
+      module.exports.load = load;
+      originalProcessReallyExit = process12.reallyExit;
+      processReallyExit = function processReallyExit2(code) {
+        if (!processOk(global.process)) {
+          return;
+        }
+        process12.exitCode = code || /* istanbul ignore next */
+        0;
+        emit("exit", process12.exitCode, null);
+        emit("afterexit", process12.exitCode, null);
+        originalProcessReallyExit.call(process12, process12.exitCode);
+      };
+      originalProcessEmit = process12.emit;
+      processEmit = function processEmit2(ev, arg) {
+        if (ev === "exit" && processOk(global.process)) {
+          if (arg !== void 0) {
+            process12.exitCode = arg;
+          }
+          var ret = originalProcessEmit.apply(this, arguments);
+          emit("exit", process12.exitCode, null);
+          emit("afterexit", process12.exitCode, null);
+          return ret;
+        } else {
+          return originalProcessEmit.apply(this, arguments);
+        }
+      };
+    }
+    var assert;
+    var signals;
+    var isWin;
+    var EE;
+    var emitter;
+    var unload;
+    var emit;
+    var sigListeners;
+    var loaded;
+    var load;
+    var originalProcessReallyExit;
+    var processReallyExit;
+    var originalProcessEmit;
+    var processEmit;
+  }
+});
+
 // ../../node_modules/scheduler/cjs/scheduler.production.min.js
 var require_scheduler_production_min = __commonJS({
   "../../node_modules/scheduler/cjs/scheduler.production.min.js"(exports) {
@@ -5928,6 +6126,61 @@ var require_cli_boxes = __commonJS({
   }
 });
 
+// ../../node_modules/onetime/node_modules/mimic-fn/index.js
+var require_mimic_fn = __commonJS({
+  "../../node_modules/onetime/node_modules/mimic-fn/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var mimicFn = (to, from) => {
+      for (const prop of Reflect.ownKeys(from)) {
+        Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
+      }
+      return to;
+    };
+    module.exports = mimicFn;
+    module.exports.default = mimicFn;
+  }
+});
+
+// ../../node_modules/onetime/index.js
+var require_onetime = __commonJS({
+  "../../node_modules/onetime/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var mimicFn = require_mimic_fn();
+    var calledFunctions = /* @__PURE__ */ new WeakMap();
+    var onetime2 = (function_, options = {}) => {
+      if (typeof function_ !== "function") {
+        throw new TypeError("Expected a function");
+      }
+      let returnValue;
+      let callCount = 0;
+      const functionName = function_.displayName || function_.name || "<anonymous>";
+      const onetime3 = function(...arguments_) {
+        calledFunctions.set(onetime3, ++callCount);
+        if (callCount === 1) {
+          returnValue = function_.apply(this, arguments_);
+          function_ = null;
+        } else if (options.throw === true) {
+          throw new Error(`Function \`${functionName}\` can only be called once`);
+        }
+        return returnValue;
+      };
+      mimicFn(onetime3, function_);
+      calledFunctions.set(onetime3, callCount);
+      return onetime3;
+    };
+    module.exports = onetime2;
+    module.exports.default = onetime2;
+    module.exports.callCount = (function_) => {
+      if (!calledFunctions.has(function_)) {
+        throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+      }
+      return calledFunctions.get(function_);
+    };
+  }
+});
+
 // ../../node_modules/stack-utils/node_modules/escape-string-regexp/index.js
 var require_escape_string_regexp = __commonJS({
   "../../node_modules/stack-utils/node_modules/escape-string-regexp/index.js"(exports, module) {
@@ -6314,13 +6567,13 @@ init_esm_shims();
 // ../../node_modules/ink/build/render.js
 init_esm_shims();
 import { Stream } from "node:stream";
-import process9 from "node:process";
+import process11 from "node:process";
 
 // ../../node_modules/ink/build/ink.js
 init_esm_shims();
 var import_react10 = __toESM(require_react(), 1);
 var import_throttle = __toESM(require_throttle(), 1);
-import process8 from "node:process";
+import process10 from "node:process";
 
 // ../../node_modules/ink/node_modules/ansi-escapes/index.js
 init_esm_shims();
@@ -6483,7 +6736,7 @@ function autoBind(self2, { include, exclude } = {}) {
 }
 
 // ../../node_modules/ink/build/ink.js
-var import_signal_exit = __toESM(require_signal_exit(), 1);
+var import_signal_exit2 = __toESM(require_signal_exit(), 1);
 
 // ../../node_modules/patch-console/dist/index.js
 init_esm_shims();
@@ -9217,6 +9470,54 @@ var renderer_default = renderer;
 
 // ../../node_modules/ink/build/log-update.js
 init_esm_shims();
+
+// ../../node_modules/ink/node_modules/cli-cursor/index.js
+init_esm_shims();
+import process5 from "node:process";
+
+// ../../node_modules/ink/node_modules/restore-cursor/index.js
+init_esm_shims();
+var import_onetime = __toESM(require_onetime(), 1);
+var import_signal_exit = __toESM(require_signal_exit(), 1);
+import process4 from "node:process";
+var restoreCursor = (0, import_onetime.default)(() => {
+  (0, import_signal_exit.default)(() => {
+    process4.stderr.write("\x1B[?25h");
+  }, { alwaysLast: true });
+});
+var restore_cursor_default = restoreCursor;
+
+// ../../node_modules/ink/node_modules/cli-cursor/index.js
+var isHidden = false;
+var cliCursor = {};
+cliCursor.show = (writableStream = process5.stderr) => {
+  if (!writableStream.isTTY) {
+    return;
+  }
+  isHidden = false;
+  writableStream.write("\x1B[?25h");
+};
+cliCursor.hide = (writableStream = process5.stderr) => {
+  if (!writableStream.isTTY) {
+    return;
+  }
+  restore_cursor_default();
+  isHidden = true;
+  writableStream.write("\x1B[?25l");
+};
+cliCursor.toggle = (force, writableStream) => {
+  if (force !== void 0) {
+    isHidden = force;
+  }
+  if (isHidden) {
+    cliCursor.show(writableStream);
+  } else {
+    cliCursor.hide(writableStream);
+  }
+};
+var cli_cursor_default = cliCursor;
+
+// ../../node_modules/ink/build/log-update.js
 var create = (stream, { showCursor = false } = {}) => {
   let previousLineCount = 0;
   let previousOutput = "";
@@ -9260,7 +9561,7 @@ var instances_default = instances;
 // ../../node_modules/ink/build/components/App.js
 init_esm_shims();
 var import_react9 = __toESM(require_react(), 1);
-import process7 from "node:process";
+import process9 from "node:process";
 
 // ../../node_modules/ink/build/components/AppContext.js
 init_esm_shims();
@@ -9275,9 +9576,9 @@ var AppContext_default = AppContext;
 // ../../node_modules/ink/build/components/StdinContext.js
 init_esm_shims();
 var import_react2 = __toESM(require_react(), 1);
-import process4 from "node:process";
+import process6 from "node:process";
 var StdinContext = (0, import_react2.createContext)({
-  stdin: process4.stdin,
+  stdin: process6.stdin,
   setRawMode() {
   },
   isRawModeSupported: false,
@@ -9290,9 +9591,9 @@ var StdinContext_default = StdinContext;
 // ../../node_modules/ink/build/components/StdoutContext.js
 init_esm_shims();
 var import_react3 = __toESM(require_react(), 1);
-import process5 from "node:process";
+import process7 from "node:process";
 var StdoutContext = (0, import_react3.createContext)({
-  stdout: process5.stdout,
+  stdout: process7.stdout,
   write() {
   }
 });
@@ -9302,9 +9603,9 @@ var StdoutContext_default = StdoutContext;
 // ../../node_modules/ink/build/components/StderrContext.js
 init_esm_shims();
 var import_react4 = __toESM(require_react(), 1);
-import process6 from "node:process";
+import process8 from "node:process";
 var StderrContext = (0, import_react4.createContext)({
-  stderr: process6.stderr,
+  stderr: process8.stderr,
   write() {
   }
 });
@@ -9571,7 +9872,7 @@ var App = class extends import_react9.PureComponent {
       value: (isEnabled) => {
         const { stdin } = this.props;
         if (!this.isRawModeSupported()) {
-          if (stdin === process7.stdin) {
+          if (stdin === process9.stdin) {
             throw new Error("Raw mode is not supported on the current process.stdin, which Ink uses as input stream by default.\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported");
           } else {
             throw new Error("Raw mode is not supported on the stdin provided to Ink.\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported");
@@ -9889,7 +10190,7 @@ Object.defineProperty(App, "displayName", {
 });
 
 // ../../node_modules/ink/build/ink.js
-var isCi = process8.env["CI"] === "false" ? false : import_is_ci.default;
+var isCi = process10.env["CI"] === "false" ? false : import_is_ci.default;
 var noop = () => {
 };
 var Ink = class {
@@ -10072,8 +10373,8 @@ var Ink = class {
       },
       null
     );
-    this.unsubscribeExit = (0, import_signal_exit.default)(this.unmount, { alwaysLast: false });
-    if (process8.env["DEV"] === "true") {
+    this.unsubscribeExit = (0, import_signal_exit2.default)(this.unmount, { alwaysLast: false });
+    if (process10.env["DEV"] === "true") {
       reconciler_default.injectIntoDevTools({
         bundleType: 0,
         // Reporting React DOM's version, not Ink's
@@ -10192,9 +10493,9 @@ var Ink = class {
 // ../../node_modules/ink/build/render.js
 var render = (node, options) => {
   const inkOptions = {
-    stdout: process9.stdout,
-    stdin: process9.stdin,
-    stderr: process9.stderr,
+    stdout: process11.stdout,
+    stdin: process11.stdin,
+    stderr: process11.stderr,
     debug: false,
     exitOnCtrlC: true,
     patchConsole: true,
@@ -10217,7 +10518,7 @@ var getOptions = (stdout = {}) => {
   if (stdout instanceof Stream) {
     return {
       stdout,
-      stdin: process9.stdin
+      stdin: process11.stdin
     };
   }
   return stdout;
@@ -18222,4 +18523,4 @@ react-reconciler/cjs/react-reconciler-constants.production.min.js:
    * LICENSE file in the root directory of this source tree.
    *)
 */
-//# sourceMappingURL=chunk-3UYDT5ZT.js.map
+//# sourceMappingURL=chunk-BHINMCY7.js.map