@sprucelabs/spruce-cli 20.0.6 → 21.0.0

package/build/interfaces/SpyInterface.js

@@ -1,488 +1,260 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _spruceSkillUtils = require("@sprucelabs/spruce-skill-utils");
-var _testUtils = require("@sprucelabs/test-utils");
-var _test = _interopRequireDefault(require("../tests/utilities/test.utility"));
-var _duration = _interopRequireDefault(require("../utilities/duration.utility"));
-var _TerminalInterface = _interopRequireDefault(require("./TerminalInterface"));
-var SpyInterface = exports["default"] = /*#__PURE__*/function () {
-  function SpyInterface() {
-    var _this = this;
-    (0, _classCallCheck2["default"])(this, SpyInterface);
-    (0, _defineProperty2["default"])(this, "invocations", []);
-    (0, _defineProperty2["default"])(this, "cursorPosition", {
-      x: 0,
-      y: 0
-    });
-    (0, _defineProperty2["default"])(this, "promptResolver", void 0);
-    (0, _defineProperty2["default"])(this, "confirmResolver", void 0);
-    (0, _defineProperty2["default"])(this, "waitForEnterResolver", void 0);
-    (0, _defineProperty2["default"])(this, "promptDefaultValue", void 0);
-    (0, _defineProperty2["default"])(this, "term", void 0);
-    (0, _defineProperty2["default"])(this, "startTime", void 0);
-    (0, _defineProperty2["default"])(this, "promptTimeout", void 0);
-    (0, _defineProperty2["default"])(this, "error", void 0);
-    this.startTime = new Date().getTime();
-    this.term = this.shouldRenderTestLogs() ? new _TerminalInterface["default"](process.cwd(), true, function () {
-      for (var _len = arguments.length, strs = new Array(_len), _key = 0; _key < _len; _key++) {
-        strs[_key] = arguments[_key];
-      }
-      _this.optionallyRenderLine(strs.join(' '));
-    }) : undefined;
-  }
-  return (0, _createClass2["default"])(SpyInterface, [{
-    key: "setTitle",
-    value: function setTitle(_title) {}
-  }, {
-    key: "shouldRenderTestLogs",
-    value: function shouldRenderTestLogs() {
-      return process.env.SHOULD_RENDER_TEST_LOGS === 'true';
-    }
-  }, {
-    key: "renderWarning",
-    value: function renderWarning(message, effects) {
-      var _this$term;
-      this.trackInvocation('renderWarning', {
-        message: message,
-        effects: effects
-      });
-      (_this$term = this.term) === null || _this$term === void 0 || _this$term.renderWarning(message);
-    }
-  }, {
-    key: "renderHint",
-    value: function renderHint(message, effects) {
-      var _this$term2;
-      this.trackInvocation('renderHint', {
-        message: message,
-        effects: effects
-      });
-      this.optionallyRenderLine("Hint: ".concat(message));
-      (_this$term2 = this.term) === null || _this$term2 === void 0 || _this$term2.renderHint(message);
-    }
-  }, {
-    key: "trackInvocation",
-    value: function trackInvocation(command, options) {
-      // testUtil.log(command, JSON.stringify(options), '\n')
-      this.invocations.push({
-        command: command,
-        options: options
-      });
-    }
-  }, {
-    key: "isWaitingForInput",
-    value: function isWaitingForInput() {
-      return !!(this.promptResolver || this.confirmResolver || this.waitForEnterResolver);
-    }
-  }, {
-    key: "reset",
-    value: function reset() {
-      this.promptResolver = undefined;
-      this.confirmResolver = undefined;
-      this.waitForEnterResolver = undefined;
-      clearTimeout(this.promptTimeout);
-    }
-  }, {
-    key: "setError",
-    value: function setError(err) {
-      this.error = err;
-    }
-  }, {
-    key: "getLastInvocation",
-    value: function getLastInvocation() {
-      return this.invocations[this.invocations.length - 1];
-    }
-  }, {
-    key: "sendInput",
-    value: function () {
-      var _sendInput = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(input) {
-        var resolver, _resolver, _resolver2;
-        return _regenerator["default"].wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              this.trackInvocation('sendInput', input);
-              this.optionallyRenderLine("Sending input: \"".concat(input.path ? input.path : input.length > 0 ? input : 'ENTER', "\""));
-              if (!this.waitForEnterResolver) {
-                _context.next = 8;
-                break;
-              }
-              resolver = this.waitForEnterResolver;
-              this.waitForEnterResolver = undefined;
-              resolver();
-              _context.next = 21;
-              break;
-            case 8:
-              if (!this.promptResolver) {
-                _context.next = 14;
-                break;
-              }
-              _resolver = this.promptResolver;
-              this.promptResolver = undefined;
-              _resolver(input !== '\n' && input !== '' ? input : this.promptDefaultValue);
-              _context.next = 21;
-              break;
-            case 14:
-              if (!this.confirmResolver) {
-                _context.next = 20;
-                break;
-              }
-              _resolver2 = this.confirmResolver;
-              this.confirmResolver = undefined;
-              _resolver2(input === '\n' || input.length === 0 || typeof input === 'string' && input.toLowerCase() === 'y');
-              _context.next = 21;
-              break;
-            case 20:
-              throw new Error('Sent input before prompted for input');
-            case 21:
-              return _context.abrupt("return", new Promise(function (resolve) {
-                setTimeout(resolve, 50);
-              }));
-            case 22:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this);
-      }));
-      function sendInput(_x) {
-        return _sendInput.apply(this, arguments);
-      }
-      return sendInput;
-    }()
-  }, {
-    key: "renderSection",
-    value: function renderSection(options) {
-      var _this$term3;
-      this.trackInvocation('renderSection', options);
-      (_this$term3 = this.term) === null || _this$term3 === void 0 || _this$term3.renderSection(options);
-    }
-  }, {
-    key: "renderObject",
-    value: function renderObject(obj) {
-      var _this$term4;
-      this.trackInvocation('renderObject', obj);
-      (_this$term4 = this.term) === null || _this$term4 === void 0 || _this$term4.renderObject(obj);
-    }
-  }, {
-    key: "renderError",
-    value: function renderError(err) {
-      var _this$term5;
-      this.trackInvocation('renderError', err);
-      (_this$term5 = this.term) === null || _this$term5 === void 0 || _this$term5.renderError(err);
-    }
-  }, {
-    key: "renderCodeSample",
-    value: function renderCodeSample(code) {
-      var _this$term6;
-      this.trackInvocation('renderCodeSample', code);
-      (_this$term6 = this.term) === null || _this$term6 === void 0 || _this$term6.renderCodeSample(code);
-    }
-  }, {
-    key: "renderActionSummary",
-    value: function renderActionSummary(results) {
-      var _this$term7;
-      this.trackInvocation('renderCommandSummary', results);
-      (_this$term7 = this.term) === null || _this$term7 === void 0 || _this$term7.renderActionSummary(results);
-    }
-  }, {
-    key: "renderHero",
-    value: function renderHero(message, effects) {
-      var _this$term8;
-      this.trackInvocation('renderHero', {
-        message: message,
-        effects: effects
-      });
-      (_this$term8 = this.term) === null || _this$term8 === void 0 || _this$term8.renderHero(message, effects);
-    }
-  }, {
-    key: "renderHeadline",
-    value: function renderHeadline(message, effects, dividerEffects) {
-      var _this$term9;
-      this.trackInvocation('renderHeadline', {
-        message: message,
-        effects: effects,
-        dividerEffects: dividerEffects
-      });
-      (_this$term9 = this.term) === null || _this$term9 === void 0 || _this$term9.renderHeadline(message, effects, dividerEffects);
-    }
-  }, {
-    key: "renderDivider",
-    value: function renderDivider(effects) {
-      var _this$term10;
-      this.trackInvocation('renderDivider', effects);
-      (_this$term10 = this.term) === null || _this$term10 === void 0 || _this$term10.renderDivider(effects);
-    }
-  }, {
-    key: "renderLine",
-    value: function renderLine(message, effects) {
-      this.trackInvocation('renderLine', {
-        message: message,
-        effects: effects
-      });
-      message && message.length > 0 && this.optionallyRenderLine(message);
-    }
-  }, {
-    key: "optionallyRenderLine",
-    value: function optionallyRenderLine(message) {
-      if (this.shouldRenderTestLogs()) {
-        var _global$activeTest, _global$activeTest2;
-        var duration = new Date().getTime() - this.startTime;
-        var friendly = _duration["default"].msToFriendly(duration);
-        _spruceSkillUtils.testLog.info("".concat(
-        //@ts-ignore
-        (_global$activeTest = global.activeTest) !== null && _global$activeTest !== void 0 && _global$activeTest.test ? ((_global$activeTest2 = global.activeTest) === null || _global$activeTest2 === void 0 ? void 0 : _global$activeTest2.test) + ' :: ' : '').concat(friendly, " :: ").concat(message));
-      }
-    }
-  }, {
-    key: "renderImage",
-    value: function () {
-      var _renderImage = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(path, options) {
-        return _regenerator["default"].wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              this.trackInvocation('renderImage', {
-                path: path,
-                options: options
-              });
-            case 1:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this);
-      }));
-      function renderImage(_x2, _x3) {
-        return _renderImage.apply(this, arguments);
-      }
-      return renderImage;
-    }()
-  }, {
-    key: "renderLines",
-    value: function renderLines(messages, effects) {
-      var _this$term11;
-      this.trackInvocation('renderLines', {
-        messages: messages,
-        effects: effects
-      });
-      (_this$term11 = this.term) === null || _this$term11 === void 0 || _this$term11.renderLines(messages, effects);
-    }
-  }, {
-    key: "prompt",
-    value: function () {
-      var _prompt = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(definition) {
-        var _this2 = this;
-        var msg;
-        return _regenerator["default"].wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              this.trackInvocation('prompt', definition);
-              if (!this.promptResolver) {
-                _context3.next = 3;
-                break;
-              }
-              throw new Error('Tried to double prompt. Try this.term?.sendInput() before calling prompt next.');
-            case 3:
-              msg = "".concat(_spruceSkillUtils.namesUtil.toPascal(definition.type), " Prompt: ").concat(definition.label);
-              if (definition.type === 'select') {
-                msg += '\n\nChoices:\n';
-                definition.options.choices.forEach(function (choice) {
-                  msg += "\n".concat(choice.value, ": ").concat(choice.label);
-                });
-                msg += '\n';
-              }
-              this.optionallyRenderLine(msg);
-              return _context3.abrupt("return", new Promise(function (resolve, reject) {
-                _this2.promptResolver = function () {
-                  clearTimeout(_this2.promptTimeout);
-                  //@ts-ignore
-                  resolve.apply(void 0, arguments);
-                };
-                _this2.promptTimeout = setTimeout(function () {
-                  _this2.reset();
-                  try {
-                    _testUtils.assert.fail("Timed out waiting for input with label: '".concat(definition.label, "'\n\nConsider passing what you need to Action().execute({ something })"));
-                  } catch (err) {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
+const test_utils_1 = require("@sprucelabs/test-utils");
+const test_utility_1 = __importDefault(require("../tests/utilities/test.utility"));
+const duration_utility_1 = __importDefault(require("../utilities/duration.utility"));
+const TerminalInterface_1 = __importDefault(require("./TerminalInterface"));
+class SpyInterface {
+    invocations = [];
+    cursorPosition = { x: 0, y: 0 };
+    promptResolver;
+    confirmResolver;
+    waitForEnterResolver;
+    promptDefaultValue;
+    term;
+    startTime;
+    promptTimeout;
+    error;
+    constructor() {
+        this.startTime = new Date().getTime();
+        this.term = this.shouldRenderTestLogs()
+            ? new TerminalInterface_1.default(process.cwd(), true, (...strs) => {
+                this.optionallyRenderLine(strs.join(' '));
+            })
+            : undefined;
+    }
+    setTitle(_title) { }
+    shouldRenderTestLogs() {
+        return process.env.SHOULD_RENDER_TEST_LOGS === 'true';
+    }
+    renderWarning(message, effects) {
+        this.trackInvocation('renderWarning', { message, effects });
+        this.term?.renderWarning(message);
+    }
+    renderHint(message, effects) {
+        this.trackInvocation('renderHint', { message, effects });
+        this.optionallyRenderLine(`Hint: ${message}`);
+        this.term?.renderHint(message);
+    }
+    trackInvocation(command, options) {
+        // testUtil.log(command, JSON.stringify(options), '\n')
+        this.invocations.push({ command, options });
+    }
+    isWaitingForInput() {
+        return !!(this.promptResolver ||
+            this.confirmResolver ||
+            this.waitForEnterResolver);
+    }
+    reset() {
+        this.promptResolver = undefined;
+        this.confirmResolver = undefined;
+        this.waitForEnterResolver = undefined;
+        clearTimeout(this.promptTimeout);
+    }
+    setError(err) {
+        this.error = err;
+    }
+    getLastInvocation() {
+        return this.invocations[this.invocations.length - 1];
+    }
+    async sendInput(input) {
+        this.trackInvocation('sendInput', input);
+        this.optionallyRenderLine(`Sending input: "${input.path
+            ? input.path
+            : input.length > 0
+                ? input
+                : 'ENTER'}"`);
+        if (this.waitForEnterResolver) {
+            const resolver = this.waitForEnterResolver;
+            this.waitForEnterResolver = undefined;
+            resolver();
+        }
+        else if (this.promptResolver) {
+            const resolver = this.promptResolver;
+            this.promptResolver = undefined;
+            resolver(input !== '\n' && input !== '' ? input : this.promptDefaultValue);
+        }
+        else if (this.confirmResolver) {
+            const resolver = this.confirmResolver;
+            this.confirmResolver = undefined;
+            resolver(input === '\n' ||
+                input.length === 0 ||
+                (typeof input === 'string' && input.toLowerCase() === 'y'));
+        }
+        else {
+            throw new Error('Sent input before prompted for input');
+        }
+        return new Promise((resolve) => {
+            setTimeout(resolve, 50);
+        });
+    }
+    renderSection(options) {
+        this.trackInvocation('renderSection', options);
+        this.term?.renderSection(options);
+    }
+    renderObject(obj) {
+        this.trackInvocation('renderObject', obj);
+        this.term?.renderObject(obj);
+    }
+    renderError(err) {
+        this.trackInvocation('renderError', err);
+        this.term?.renderError(err);
+    }
+    renderCodeSample(code) {
+        this.trackInvocation('renderCodeSample', code);
+        this.term?.renderCodeSample(code);
+    }
+    renderActionSummary(results) {
+        this.trackInvocation('renderCommandSummary', results);
+        this.term?.renderActionSummary(results);
+    }
+    renderHero(message, effects) {
+        this.trackInvocation('renderHero', { message, effects });
+        this.term?.renderHero(message, effects);
+    }
+    renderHeadline(message, effects, dividerEffects) {
+        this.trackInvocation('renderHeadline', {
+            message,
+            effects,
+            dividerEffects,
+        });
+        this.term?.renderHeadline(message, effects, dividerEffects);
+    }
+    renderDivider(effects) {
+        this.trackInvocation('renderDivider', effects);
+        this.term?.renderDivider(effects);
+    }
+    renderLine(message, effects) {
+        this.trackInvocation('renderLine', { message, effects });
+        message && message.length > 0 && this.optionallyRenderLine(message);
+    }
+    optionallyRenderLine(message) {
+        if (this.shouldRenderTestLogs()) {
+            const duration = new Date().getTime() - this.startTime;
+            const friendly = duration_utility_1.default.msToFriendly(duration);
+            spruce_skill_utils_1.testLog.info(`${
+            //@ts-ignore
+            global.activeTest?.test
+                ? //@ts-ignore
+                    global.activeTest?.test + ' :: '
+                : ''}${friendly} :: ${message}`);
+        }
+    }
+    async renderImage(path, options) {
+        this.trackInvocation('renderImage', { path, options });
+    }
+    renderLines(messages, effects) {
+        this.trackInvocation('renderLines', { messages, effects });
+        this.term?.renderLines(messages, effects);
+    }
+    async prompt(definition) {
+        this.trackInvocation('prompt', definition);
+        if (this.promptResolver) {
+            throw new Error('Tried to double prompt. Try this.term?.sendInput() before calling prompt next.');
+        }
+        let msg = `${spruce_skill_utils_1.namesUtil.toPascal(definition.type)} Prompt: ${definition.label}`;
+        if (definition.type === 'select') {
+            msg += '\n\nChoices:\n';
+            definition.options.choices.forEach((choice) => {
+                msg += `\n${choice.value}: ${choice.label}`;
+            });
+            msg += '\n';
+        }
+        this.optionallyRenderLine(msg);
+        return new Promise((resolve, reject) => {
+            this.promptResolver = (...args) => {
+                clearTimeout(this.promptTimeout);
+                //@ts-ignore
+                resolve(...args);
+            };
+            this.promptTimeout = setTimeout(() => {
+                this.reset();
+                try {
+                    test_utils_1.assert.fail(`Timed out waiting for input with label: '${definition.label}'\n\nConsider passing what you need to Action().execute({ something })`);
+                }
+                catch (err) {
                     reject(err);
-                  }
-                }, 10000);
-                _this2.promptDefaultValue = definition.defaultValue;
-              }));
-            case 7:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this);
-      }));
-      function prompt(_x4) {
-        return _prompt.apply(this, arguments);
-      }
-      return prompt;
-    }()
-  }, {
-    key: "startLoading",
-    value: function startLoading(message) {
-      this.trackInvocation('startLoading', message);
-      this.optionallyRenderLine(message ? "".concat(message) : 'Start loading...');
-    }
-  }, {
-    key: "stopLoading",
-    value: function stopLoading() {
-      this.trackInvocation('stopLoading');
-      this.optionallyRenderLine('Stop loading...');
-    }
-  }, {
-    key: "waitForEnter",
-    value: function () {
-      var _waitForEnter = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(message) {
-        var _this3 = this;
-        return _regenerator["default"].wrap(function _callee4$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
-            case 0:
-              this.trackInvocation('waitForEnter', message);
-              this.optionallyRenderLine("".concat(message ? " ".concat(message, "\n\n") : "", "Waiting for enter..."));
-              return _context4.abrupt("return", new Promise(function (resolve) {
-                _this3.waitForEnterResolver = resolve;
-              }));
-            case 3:
-            case "end":
-              return _context4.stop();
-          }
-        }, _callee4, this);
-      }));
-      function waitForEnter(_x5) {
-        return _waitForEnter.apply(this, arguments);
-      }
-      return waitForEnter;
-    }()
-  }, {
-    key: "waitForInput",
-    value: function () {
-      var _waitForInput = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5() {
-        var ttl, checkInterval, loops, lastWriteCount, hasWritten;
-        return _regenerator["default"].wrap(function _callee5$(_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
-            case 0:
-              ttl = 1000 * 60 * 5;
-              checkInterval = 100;
-              loops = ttl / checkInterval;
-              lastWriteCount = this.invocations.length;
-            case 4:
-              if (this.isWaitingForInput()) {
-                _context5.next = 14;
-                break;
-              }
-              if (loops-- === 0) {
-                _testUtils.assert.fail("Waiting for input timed out.");
-              }
-              hasWritten = lastWriteCount != this.invocations.length;
-              if (hasWritten) {
+                }
+            }, 10000);
+            this.promptDefaultValue = definition.defaultValue;
+        });
+    }
+    startLoading(message) {
+        this.trackInvocation('startLoading', message);
+        this.optionallyRenderLine(message ? `${message}` : 'Start loading...');
+    }
+    stopLoading() {
+        this.trackInvocation('stopLoading');
+        this.optionallyRenderLine('Stop loading...');
+    }
+    async waitForEnter(message) {
+        this.trackInvocation('waitForEnter', message);
+        this.optionallyRenderLine(`${message ? ` ${message}\n\n` : ``}Waiting for enter...`);
+        return new Promise((resolve) => {
+            this.waitForEnterResolver = resolve;
+        });
+    }
+    async waitForInput() {
+        const ttl = 1000 * 60 * 2;
+        const checkInterval = 100;
+        let loops = ttl / checkInterval;
+        let lastWriteCount = this.invocations.length;
+        while (!this.isWaitingForInput()) {
+            if (loops-- === 0) {
+                test_utils_1.assert.fail(`Waiting for input timed out.`);
+            }
+            const hasWritten = lastWriteCount != this.invocations.length;
+            if (hasWritten) {
                 loops = ttl / checkInterval;
                 lastWriteCount = this.invocations.length;
                 if (this.shouldRenderTestLogs()) {
-                  _test["default"].log('waitForInput timeout reset because of new output.');
+                    test_utility_1.default.log('waitForInput timeout reset because of new output.');
                 }
-              }
-              if (!this.error) {
-                _context5.next = 10;
-                break;
-              }
-              throw this.error;
-            case 10:
-              _context5.next = 12;
-              return new Promise(function (resolve) {
-                return setTimeout(resolve, checkInterval);
-              });
-            case 12:
-              _context5.next = 4;
-              break;
-            case 14:
-            case "end":
-              return _context5.stop();
-          }
-        }, _callee5, this);
-      }));
-      function waitForInput() {
-        return _waitForInput.apply(this, arguments);
-      }
-      return waitForInput;
-    }()
-  }, {
-    key: "confirm",
-    value: function confirm(question) {
-      var _this4 = this;
-      this.trackInvocation('confirm', question);
-      this.optionallyRenderLine("".concat(question, " :: Y/N..."));
-      return new Promise(function (resolve) {
-        _this4.confirmResolver = resolve;
-      });
-    }
-  }, {
-    key: "clear",
-    value: function clear() {
-      this.trackInvocation('clear');
-    }
-  }, {
-    key: "renderProgressBar",
-    value: function renderProgressBar(options) {
-      this.trackInvocation('renderProgressBar', options);
-      this.optionallyRenderLine("Showing progress".concat(options.title ? " ".concat(options.title) : ""));
-    }
-  }, {
-    key: "updateProgressBar",
-    value: function updateProgressBar(options) {
-      this.trackInvocation('updateProgressBar', options);
-    }
-  }, {
-    key: "removeProgressBar",
-    value: function removeProgressBar() {
-      this.trackInvocation('removeProgressBar');
-      this.optionallyRenderLine("Hiding progress");
-    }
-  }, {
-    key: "getCursorPosition",
-    value: function () {
-      var _getCursorPosition = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6() {
-        return _regenerator["default"].wrap(function _callee6$(_context6) {
-          while (1) switch (_context6.prev = _context6.next) {
-            case 0:
-              this.trackInvocation('getCursorPosition');
-              return _context6.abrupt("return", this.cursorPosition);
-            case 2:
-            case "end":
-              return _context6.stop();
-          }
-        }, _callee6, this);
-      }));
-      function getCursorPosition() {
-        return _getCursorPosition.apply(this, arguments);
-      }
-      return getCursorPosition;
-    }()
-  }, {
-    key: "setCursorPosition",
-    value: function setCursorPosition(pos) {
-      this.cursorPosition = pos;
-    }
-  }, {
-    key: "moveCursorTo",
-    value: function moveCursorTo(x, y) {
-      this.trackInvocation('moveCursorTo', {
-        x: x,
-        y: y
-      });
-    }
-  }, {
-    key: "clearBelowCursor",
-    value: function clearBelowCursor() {
-      this.trackInvocation('clearBelowCursor');
-    }
-  }]);
-}();
+            }
+            if (this.error) {
+                throw this.error;
+            }
+            await new Promise((resolve) => setTimeout(resolve, checkInterval));
+        }
+    }
+    confirm(question) {
+        this.trackInvocation('confirm', question);
+        this.optionallyRenderLine(`${question} :: Y/N...`);
+        return new Promise((resolve) => {
+            this.confirmResolver = resolve;
+        });
+    }
+    clear() {
+        this.trackInvocation('clear');
+    }
+    renderProgressBar(options) {
+        this.trackInvocation('renderProgressBar', options);
+        this.optionallyRenderLine(`Showing progress${options.title ? ` ${options.title}` : ``}`);
+    }
+    updateProgressBar(options) {
+        this.trackInvocation('updateProgressBar', options);
+    }
+    removeProgressBar() {
+        this.trackInvocation('removeProgressBar');
+        this.optionallyRenderLine(`Hiding progress`);
+    }
+    async getCursorPosition() {
+        this.trackInvocation('getCursorPosition');
+        return this.cursorPosition;
+    }
+    setCursorPosition(pos) {
+        this.cursorPosition = pos;
+    }
+    moveCursorTo(x, y) {
+        this.trackInvocation('moveCursorTo', { x, y });
+    }
+    clearBelowCursor() {
+        this.trackInvocation('clearBelowCursor');
+    }
+}
+exports.default = SpyInterface;
 //# sourceMappingURL=SpyInterface.js.map