@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/spinner/spinner.js

@@ -0,0 +1,802 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"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, desc2) => {
+  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: !(desc2 = __getOwnPropDesc(from, key)) || desc2.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);
+var spinner_exports = {};
+__export(spinner_exports, {
+  Spinner: () => Spinner
+});
+module.exports = __toCommonJS(spinner_exports);
+var import_convert = require("../colors/convert");
+var import_abort = require("../process/abort");
+var import_namespace = require("../debug/namespace");
+var import_shimmer = require("../effects/shimmer");
+var import_shimmer_terminal = require("../effects/shimmer-terminal");
+var import_ci = require("../env/ci");
+var import_yocto_spinner = __toESM(require("../external/@socketregistry/yocto-spinner"));
+var import_default = require("../logger/default");
+var import_symbols = require("../logger/symbols");
+var import_array = require("../primordials/array");
+var import_error = require("../primordials/error");
+var import_math = require("../primordials/math");
+var import_object = require("../primordials/object");
+var import_predicates = require("../strings/predicates");
+var import_width = require("../strings/width");
+var import_context = require("../themes/context");
+var import_themes = require("../themes/themes");
+var import_resolve = require("../themes/resolve");
+var import_default2 = require("./default");
+var import_format = require("./format");
+let _Spinner;
+let _defaultSpinner;
+// @__NO_SIDE_EFFECTS__
+function Spinner(options) {
+  if (_Spinner === void 0) {
+    const YoctoCtor = import_yocto_spinner.default;
+    const tempInstance = YoctoCtor({});
+    const YoctoSpinnerClass = tempInstance.constructor;
+    const logger = (0, import_default.getDefaultLogger)();
+    _Spinner = class SpinnerClass extends YoctoSpinnerClass {
+      #baseText = "";
+      #indentation = "";
+      #progress;
+      #shimmer;
+      #shimmerSavedConfig;
+      constructor(options2) {
+        const opts = { __proto__: null, ...options2 };
+        let theme = (0, import_context.getTheme)();
+        if (opts.theme) {
+          if (typeof opts.theme === "string") {
+            theme = import_themes.THEMES[opts.theme] ?? theme;
+          } else {
+            theme = opts.theme;
+          }
+        }
+        let defaultColor = theme.colors.primary;
+        if (theme.effects?.spinner?.color) {
+          const resolved = (0, import_resolve.resolveColor)(
+            theme.effects.spinner.color,
+            theme.colors
+          );
+          if (resolved === "inherit" || (0, import_array.ArrayIsArray)(resolved[0])) {
+            defaultColor = theme.colors.primary;
+          } else {
+            defaultColor = resolved;
+          }
+        }
+        const spinnerColor = opts.color ?? defaultColor;
+        if ((0, import_convert.isRgbTuple)(spinnerColor) && (spinnerColor.length !== 3 || !spinnerColor.every(
+          (n) => typeof n === "number" && n >= 0 && n <= 255
+        ))) {
+          throw new import_error.TypeErrorCtor(
+            "RGB color must be an array of 3 numbers between 0 and 255"
+          );
+        }
+        const spinnerColorRgb = (0, import_convert.toRgb)(spinnerColor);
+        let shimmerInfo;
+        if (opts.shimmer) {
+          let shimmerDir;
+          let shimmerColor;
+          let shimmerSpeed = 1 / 3;
+          if (typeof opts.shimmer === "string") {
+            shimmerDir = opts.shimmer;
+            shimmerColor = import_format.COLOR_INHERIT;
+          } else {
+            const shimmerConfig = {
+              __proto__: null,
+              ...opts.shimmer
+            };
+            shimmerDir = shimmerConfig.dir ?? "ltr";
+            shimmerColor = shimmerConfig.color ?? import_format.COLOR_INHERIT;
+            shimmerSpeed = shimmerConfig.speed ?? 1 / 3;
+          }
+          shimmerInfo = {
+            __proto__: null,
+            color: shimmerColor,
+            direction: shimmerDir,
+            speed: shimmerSpeed,
+            frame: 0
+          };
+        }
+        super({
+          signal: (0, import_abort.getAbortSignal)(),
+          ...opts,
+          // Pass RGB color directly to yocto-spinner (it now supports RGB).
+          color: spinnerColorRgb,
+          // onRenderFrame callback provides full control over frame + text layout.
+          // Calculates spacing based on frame width to prevent text jumping.
+          onRenderFrame: (frame, text, applyColor) => {
+            const width = (0, import_width.stringWidth)(frame);
+            const spacing = width === 1 ? "  " : " ";
+            return frame ? `${applyColor(frame)}${spacing}${text}` : text;
+          },
+          // onFrameUpdate callback is called by yocto-spinner whenever a frame advances.
+          // This ensures shimmer updates are perfectly synchronized with animation beats.
+          onFrameUpdate: shimmerInfo ? () => {
+            if (this.#baseText) {
+              super.text = this.#buildDisplayText();
+            }
+          } : void 0
+        });
+        this.#shimmer = shimmerInfo;
+        this.#shimmerSavedConfig = shimmerInfo;
+      }
+      // Override color getter to ensure it's always RGB.
+      get color() {
+        const value = super.color;
+        return (0, import_convert.isRgbTuple)(value) ? value : (0, import_convert.toRgb)(value);
+      }
+      // Override color setter to always convert to RGB before passing to yocto-spinner.
+      set color(value) {
+        super.color = (0, import_convert.isRgbTuple)(value) ? value : (0, import_convert.toRgb)(value);
+      }
+      // Getter to expose current shimmer state.
+      get shimmerState() {
+        if (!this.#shimmer) {
+          return void 0;
+        }
+        return {
+          __proto__: null,
+          color: this.#shimmer.color,
+          direction: this.#shimmer.direction,
+          speed: this.#shimmer.speed,
+          frame: this.#shimmer.frame
+        };
+      }
+      /**
+       * Apply a yocto-spinner method and update logger state. Handles text
+       * normalization, extra arguments, and logger tracking.
+       *
+       * @private
+       */
+      #apply(methodName, args) {
+        let extras;
+        let text = (0, import_array.ArrayPrototypeAt)(args, 0);
+        if (typeof text === "string") {
+          extras = (0, import_array.ArrayPrototypeSlice)(args, 1);
+        } else {
+          extras = args;
+          text = "";
+        }
+        const wasSpinning = this.isSpinning;
+        const normalized = (0, import_format.normalizeText)(text);
+        if (methodName === "stop" && !normalized) {
+          super[methodName]();
+        } else {
+          super[methodName](normalized);
+        }
+        if (methodName === "stop") {
+          if (wasSpinning && normalized) {
+            logger[import_symbols.lastWasBlankSymbol]((0, import_predicates.isBlankString)(normalized));
+            logger[import_symbols.incLogCallCountSymbol]();
+          }
+        } else {
+          logger[import_symbols.lastWasBlankSymbol](false);
+          logger[import_symbols.incLogCallCountSymbol]();
+        }
+        if (extras.length) {
+          logger.log(...extras);
+          logger[import_symbols.lastWasBlankSymbol](false);
+        }
+        return this;
+      }
+      /**
+       * Build the complete display text with progress, shimmer, and
+       * indentation. Combines base text, progress bar, shimmer effects, and
+       * indentation.
+       *
+       * @private
+       */
+      #buildDisplayText() {
+        let displayText = this.#baseText;
+        if (this.#progress) {
+          const progressText = (0, import_format.formatProgress)(this.#progress);
+          displayText = displayText ? `${displayText} ${progressText}` : progressText;
+        }
+        if (displayText && this.#shimmer) {
+          let shimmerColor;
+          if (this.#shimmer.color === import_format.COLOR_INHERIT) {
+            shimmerColor = this.color;
+          } else if ((0, import_array.ArrayIsArray)(this.#shimmer.color[0])) {
+            shimmerColor = this.#shimmer.color;
+          } else {
+            shimmerColor = (0, import_convert.toRgb)(this.#shimmer.color);
+          }
+          if (!(0, import_ci.getCI)() && this.#shimmer.direction !== "none") {
+            const chars = [...displayText];
+            const spec = (0, import_shimmer.configToSpec)(
+              {
+                color: shimmerColor,
+                dir: this.#shimmer.direction,
+                speed: this.#shimmer.speed
+              },
+              chars.length
+            );
+            const colors = (0, import_shimmer.frameColors)(spec, chars.length, this.#shimmer.frame);
+            displayText = (0, import_shimmer_terminal.colorsToAnsi)(displayText, colors);
+            this.#shimmer.frame++;
+          }
+        }
+        if (this.#indentation && displayText) {
+          displayText = this.#indentation + displayText;
+        }
+        return displayText;
+      }
+      /**
+       * Show a status message without stopping the spinner. Outputs the symbol
+       * and message to stderr, then continues spinning.
+       *
+       * @private
+       */
+      #showStatusAndKeepSpinning(symbolType, args) {
+        let text = (0, import_array.ArrayPrototypeAt)(args, 0);
+        let extras;
+        if (typeof text === "string") {
+          extras = (0, import_array.ArrayPrototypeSlice)(args, 1);
+        } else {
+          extras = args;
+          text = "";
+        }
+        logger.error(`${import_symbols.LOG_SYMBOLS[symbolType]} ${text}`, ...extras);
+        return this;
+      }
+      /**
+       * Update the spinner's displayed text. Rebuilds display text and triggers
+       * render.
+       *
+       * @private
+       */
+      #updateSpinnerText() {
+        super.text = this.#buildDisplayText();
+      }
+      /**
+       * Show a debug message (ℹ) without stopping the spinner. Only displays if
+       * debug mode is enabled via environment variable. Outputs to stderr and
+       * continues spinning.
+       *
+       * @param text - Debug message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      debug(text, ...extras) {
+        if ((0, import_namespace.isDebug)()) {
+          return this.#showStatusAndKeepSpinning("info", [text, ...extras]);
+        }
+        return this;
+      }
+      /**
+       * Show a debug message (ℹ) and stop the spinner. Only displays if debug
+       * mode is enabled via environment variable. Auto-clears the spinner line
+       * before displaying the message.
+       *
+       * @param text - Debug message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      debugAndStop(text, ...extras) {
+        if ((0, import_namespace.isDebug)()) {
+          return this.#apply("info", [text, ...extras]);
+        }
+        return this;
+      }
+      /**
+       * Decrease indentation level by removing spaces from the left. Pass 0 to
+       * reset indentation to zero completely.
+       *
+       * @default spaces=2
+       *
+       * @param spaces - Number of spaces to remove.
+       *
+       * @returns This spinner for chaining
+       */
+      dedent(spaces) {
+        if (spaces === 0) {
+          this.#indentation = "";
+        } else {
+          const amount = spaces ?? 2;
+          const newLength = (0, import_math.MathMax)(0, this.#indentation.length - amount);
+          this.#indentation = this.#indentation.slice(0, newLength);
+        }
+        this.#updateSpinnerText();
+        return this;
+      }
+      /**
+       * Disable shimmer effect. Preserves config for later re-enable via
+       * enableShimmer().
+       *
+       * @example
+       *   spinner.disableShimmer()
+       *
+       * @returns This spinner for chaining
+       */
+      disableShimmer() {
+        this.#shimmer = void 0;
+        this.#updateSpinnerText();
+        return this;
+      }
+      /**
+       * Show a done/success message (✓) without stopping the spinner. Alias for
+       * `success()` with a shorter name.
+       *
+       * DESIGN DECISION: Unlike yocto-spinner, our `done()` does NOT stop the
+       * spinner. Use `doneAndStop()` if you want to stop the spinner.
+       *
+       * @param text - Message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      done(text, ...extras) {
+        return this.#showStatusAndKeepSpinning("success", [text, ...extras]);
+      }
+      /**
+       * Show a done/success message (✓) and stop the spinner. Auto-clears the
+       * spinner line before displaying the success message.
+       *
+       * @param text - Message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      doneAndStop(text, ...extras) {
+        return this.#apply("success", [text, ...extras]);
+      }
+      /**
+       * Enable shimmer effect. Restores saved config or uses defaults if no
+       * saved config exists.
+       *
+       * @example
+       *   spinner.enableShimmer()
+       *
+       * @returns This spinner for chaining
+       */
+      enableShimmer() {
+        if (this.#shimmerSavedConfig) {
+          this.#shimmer = { ...this.#shimmerSavedConfig, frame: 0 };
+        } else {
+          this.#shimmer = {
+            __proto__: null,
+            color: import_format.COLOR_INHERIT,
+            direction: "ltr",
+            speed: 1 / 3,
+            frame: 0
+          };
+          this.#shimmerSavedConfig = this.#shimmer;
+        }
+        this.#updateSpinnerText();
+        return this;
+      }
+      /**
+       * Show a failure message (✗) without stopping the spinner. DESIGN
+       * DECISION: Unlike yocto-spinner, our `fail()` does NOT stop the spinner.
+       * This allows displaying errors while continuing to spin. Use
+       * `failAndStop()` if you want to stop the spinner.
+       *
+       * @param text - Error message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      fail(text, ...extras) {
+        return this.#showStatusAndKeepSpinning("fail", [text, ...extras]);
+      }
+      /**
+       * Show a failure message (✗) and stop the spinner. Auto-clears the
+       * spinner line before displaying the error message.
+       *
+       * @param text - Error message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      failAndStop(text, ...extras) {
+        return this.#apply("error", [text, ...extras]);
+      }
+      /**
+       * Increase indentation level by adding spaces to the left. Pass 0 to
+       * reset indentation to zero completely.
+       *
+       * @default spaces=2
+       *
+       * @param spaces - Number of spaces to add.
+       *
+       * @returns This spinner for chaining
+       */
+      indent(spaces) {
+        if (spaces === 0) {
+          this.#indentation = "";
+        } else {
+          const amount = spaces ?? 2;
+          this.#indentation += " ".repeat(amount);
+        }
+        this.#updateSpinnerText();
+        return this;
+      }
+      /**
+       * Show an info message (ℹ) without stopping the spinner. Outputs to
+       * stderr and continues spinning.
+       *
+       * @param text - Info message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      info(text, ...extras) {
+        return this.#showStatusAndKeepSpinning("info", [text, ...extras]);
+      }
+      /**
+       * Show an info message (ℹ) and stop the spinner. Auto-clears the spinner
+       * line before displaying the message.
+       *
+       * @param text - Info message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      infoAndStop(text, ...extras) {
+        return this.#apply("info", [text, ...extras]);
+      }
+      /**
+       * Log a message to stdout without stopping the spinner. Unlike other
+       * status methods, this outputs to stdout for data logging.
+       *
+       * @param args - Values to log to stdout.
+       *
+       * @returns This spinner for chaining
+       */
+      log(...args) {
+        logger.log(...args);
+        return this;
+      }
+      /**
+       * Log a message to stdout and stop the spinner. Auto-clears the spinner
+       * line before displaying the message.
+       *
+       * @param text - Message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      logAndStop(text, ...extras) {
+        return this.#apply("stop", [text, ...extras]);
+      }
+      /**
+       * Update progress information displayed with the spinner. Shows a
+       * progress bar with percentage and optional unit label.
+       *
+       * @param current - Current progress value.
+       * @param total - Total/maximum progress value.
+       * @param unit - Optional unit label (e.g., 'files', 'items')
+       *
+       * @returns This spinner for chaining
+       */
+      progress = (current, total, unit) => {
+        this.#progress = {
+          __proto__: null,
+          current,
+          total,
+          ...unit ? { unit } : {}
+        };
+        this.#updateSpinnerText();
+        return this;
+      };
+      /**
+       * Increment progress by a specified amount. Updates the progress bar
+       * displayed with the spinner. Clamps the result between 0 and the total
+       * value.
+       *
+       * @default amount=1
+       *
+       * @param amount - Amount to increment by.
+       *
+       * @returns This spinner for chaining
+       */
+      progressStep(amount = 1) {
+        if (this.#progress) {
+          const newCurrent = this.#progress.current + amount;
+          this.#progress = {
+            __proto__: null,
+            current: (0, import_math.MathMax)(0, Math.min(newCurrent, this.#progress.total)),
+            total: this.#progress.total,
+            ...this.#progress.unit ? { unit: this.#progress.unit } : {}
+          };
+          this.#updateSpinnerText();
+        }
+        return this;
+      }
+      /**
+       * Show a skip message (↻) without stopping the spinner. Outputs to stderr
+       * and continues spinning.
+       *
+       * @param text - Skip message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      skip(text, ...extras) {
+        return this.#showStatusAndKeepSpinning("skip", [text, ...extras]);
+      }
+      /**
+       * Show a skip message (↻) and stop the spinner. Auto-clears the spinner
+       * line before displaying the message.
+       *
+       * Implementation note: Unlike other *AndStop methods (successAndStop,
+       * failAndStop, etc.), this method cannot use #apply() with a 'skip'
+       * method name because yocto-spinner doesn't have a built-in 'skip'
+       * method. Instead, we manually stop the spinner then log the message with
+       * the skip symbol.
+       *
+       * @param text - Skip message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      skipAndStop(text, ...extras) {
+        this.#apply("stop", []);
+        const normalized = (0, import_format.normalizeText)(text);
+        if (normalized) {
+          logger.error(`${import_symbols.LOG_SYMBOLS["skip"]} ${normalized}`, ...extras);
+        }
+        return this;
+      }
+      /**
+       * Set complete shimmer configuration. Replaces any existing shimmer
+       * config with the provided values. Undefined properties will use default
+       * values.
+       *
+       * @example
+       *   spinner.setShimmer({
+       *     color: [255, 0, 0],
+       *     dir: 'rtl',
+       *     speed: 0.5,
+       *   })
+       *
+       * @param config - Complete shimmer configuration.
+       *
+       * @returns This spinner for chaining
+       */
+      setShimmer(config) {
+        this.#shimmer = {
+          __proto__: null,
+          color: config.color ?? import_format.COLOR_INHERIT,
+          direction: config.dir ?? "ltr",
+          speed: config.speed ?? 1 / 3,
+          frame: 0
+        };
+        this.#shimmerSavedConfig = this.#shimmer;
+        this.#updateSpinnerText();
+        return this;
+      }
+      /**
+       * Start the spinner animation with optional text. Begins displaying the
+       * animated spinner on stderr.
+       *
+       * @param text - Optional text to display with the spinner.
+       *
+       * @returns This spinner for chaining
+       */
+      start(...args) {
+        if (args.length) {
+          const text = (0, import_array.ArrayPrototypeAt)(args, 0);
+          const normalized = (0, import_format.normalizeText)(text);
+          if (!normalized) {
+            this.#baseText = "";
+            super.text = "";
+          } else {
+            this.#baseText = normalized;
+          }
+        }
+        this.#updateSpinnerText();
+        return this.#apply("start", []);
+      }
+      /**
+       * Log a main step message to stderr without stopping the spinner. Adds a
+       * blank line before the message for visual separation. Aligns with
+       * `logger.step()` to use stderr for status messages.
+       *
+       * @param text - Step message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      step(text, ...extras) {
+        if (typeof text === "string") {
+          logger.error("");
+          logger.error(text, ...extras);
+        }
+        return this;
+      }
+      /**
+       * Stop the spinner animation and clear internal state. Auto-clears the
+       * spinner line via yocto-spinner.stop(). Resets progress, shimmer, and
+       * text state.
+       *
+       * @param text - Optional final text to display after stopping.
+       *
+       * @returns This spinner for chaining
+       */
+      stop(...args) {
+        this.#baseText = "";
+        this.#progress = void 0;
+        this.#shimmer = void 0;
+        const result = this.#apply("stop", args);
+        return result;
+      }
+      /**
+       * Log an indented substep message to stderr without stopping the spinner.
+       * Adds 2-space indentation to the message. Aligns with `logger.substep()`
+       * to use stderr for status messages.
+       *
+       * @param text - Substep message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      substep(text, ...extras) {
+        if (typeof text === "string") {
+          logger.error(`  ${text}`, ...extras);
+        }
+        return this;
+      }
+      /**
+       * Show a success message (✓) without stopping the spinner. DESIGN
+       * DECISION: Unlike yocto-spinner, our `success()` does NOT stop the
+       * spinner. This allows displaying success messages while continuing to
+       * spin for multi-step operations. Use `successAndStop()` if you want to
+       * stop the spinner.
+       *
+       * @param text - Success message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      success(text, ...extras) {
+        return this.#showStatusAndKeepSpinning("success", [text, ...extras]);
+      }
+      /**
+       * Show a success message (✓) and stop the spinner. Auto-clears the
+       * spinner line before displaying the success message.
+       *
+       * @param text - Success message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      successAndStop(text, ...extras) {
+        return this.#apply("success", [text, ...extras]);
+      }
+      text(value) {
+        if (arguments.length === 0) {
+          return this.#baseText;
+        }
+        this.#baseText = value ?? "";
+        this.#updateSpinnerText();
+        return this;
+      }
+      /**
+       * Update partial shimmer configuration. Merges with existing config,
+       * enabling shimmer if currently disabled.
+       *
+       * @example
+       *   // Update just the speed
+       *   spinner.updateShimmer({ speed: 0.5 })
+       *
+       *   // Update direction
+       *   spinner.updateShimmer({ dir: 'rtl' })
+       *
+       *   // Update multiple properties
+       *   spinner.updateShimmer({ color: [255, 0, 0], speed: 0.8 })
+       *
+       * @param config - Partial shimmer configuration to merge.
+       *
+       * @returns This spinner for chaining
+       */
+      updateShimmer(config) {
+        const partialConfig = {
+          __proto__: null,
+          ...config
+        };
+        const update = {
+          __proto__: null
+        };
+        if (partialConfig.color !== void 0) {
+          update.color = partialConfig.color;
+        }
+        if (partialConfig.dir !== void 0) {
+          update.direction = partialConfig.dir;
+        }
+        if (partialConfig.speed !== void 0) {
+          update.speed = partialConfig.speed;
+        }
+        if (this.#shimmer) {
+          this.#shimmer = { ...this.#shimmer, ...update };
+        } else if (this.#shimmerSavedConfig) {
+          this.#shimmer = {
+            ...this.#shimmerSavedConfig,
+            ...update,
+            frame: 0
+          };
+        } else {
+          this.#shimmer = {
+            __proto__: null,
+            color: import_format.COLOR_INHERIT,
+            direction: "ltr",
+            speed: 1 / 3,
+            frame: 0,
+            ...update
+          };
+        }
+        this.#shimmerSavedConfig = this.#shimmer;
+        this.#updateSpinnerText();
+        return this;
+      }
+      /**
+       * Show a warning message (⚠) without stopping the spinner. Outputs to
+       * stderr and continues spinning.
+       *
+       * @param text - Warning message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      warn(text, ...extras) {
+        return this.#showStatusAndKeepSpinning("warn", [text, ...extras]);
+      }
+      /**
+       * Show a warning message (⚠) and stop the spinner. Auto-clears the
+       * spinner line before displaying the warning message.
+       *
+       * @param text - Warning message to display.
+       * @param extras - Additional values to log.
+       *
+       * @returns This spinner for chaining
+       */
+      warnAndStop(text, ...extras) {
+        return this.#apply("warning", [text, ...extras]);
+      }
+    };
+    (0, import_object.ObjectDefineProperties)(_Spinner.prototype, {
+      error: (0, import_format.desc)(_Spinner.prototype.fail),
+      errorAndStop: (0, import_format.desc)(_Spinner.prototype.failAndStop),
+      warning: (0, import_format.desc)(_Spinner.prototype.warn),
+      warningAndStop: (0, import_format.desc)(_Spinner.prototype.warnAndStop)
+    });
+    _defaultSpinner = (0, import_ci.getCI)() ? import_format.ciSpinner : (0, import_default2.getCliSpinners)("socket");
+  }
+  return new _Spinner({
+    spinner: _defaultSpinner,
+    ...options
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Spinner
+});