@catladder/cli 0.0.0-main-20c54c16 → 0.0.0-main-7d749f5d

package/dist/bundles/catci/index.js

@@ -377,7 +377,6 @@ exports.makeSecurityAuditOverview = makeSecurityAuditOverview;
 var _a;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const path = ((_a = require.main) === null || _a === void 0 ? void 0 : _a.path) + "/../package.json";
-// eslint-disable-next-line @typescript-eslint/no-var-requires
 const ownPkg = require(path);
 exports["default"] = ownPkg;
 //# sourceMappingURL=packageInfos.js.map
@@ -10880,6 +10879,18 @@ exports.UserStarredMetricsDashboard = UserStarredMetricsDashboard;
 exports.Users = Users;
 
 
+/***/ }),
+
+/***/ 5067:
+/***/ ((module) => {
+
+"use strict";
+
+module.exports = function () {
+	return /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]/g;
+};
+
+
 /***/ }),
 
 /***/ 7018:
@@ -22910,23 +22921,11 @@ module.exports = fill;
 
 "use strict";
 
-var ansiRegex = __nccwpck_require__(1082);
+var ansiRegex = __nccwpck_require__(5067);
 var re = new RegExp(ansiRegex().source); // remove the `g` flag
 module.exports = re.test.bind(re);
 
 
-/***/ }),
-
-/***/ 1082:
-/***/ ((module) => {
-
-"use strict";
-
-module.exports = function () {
-	return /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]/g;
-};
-
-
 /***/ }),
 
 /***/ 6324:
@@ -23317,7 +23316,7 @@ Separator.prototype.toString = function () {
 var rx = __nccwpck_require__(1099);
 var _ = __nccwpck_require__(6294);
 var chalk = __nccwpck_require__(4664);
-var ansiRegex = __nccwpck_require__(9);
+var ansiRegex = __nccwpck_require__(5067);
 var runAsync = __nccwpck_require__(2918);
 var Choices = __nccwpck_require__(4467);
 var ScreenManager = __nccwpck_require__(7522);
@@ -25445,18 +25444,6 @@ x.iTerm.setCwd = function (cwd) {
 };
 
 
-/***/ }),
-
-/***/ 9:
-/***/ ((module) => {
-
-"use strict";
-
-module.exports = function () {
-	return /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]/g;
-};
-
-
 /***/ }),
 
 /***/ 6695:
@@ -38040,7 +38027,7 @@ module.exports = function (str) {
 
 "use strict";
 
-var ansiRegex = __nccwpck_require__(9)();
+var ansiRegex = __nccwpck_require__(5067)();
 
 module.exports = function (str) {
 	return typeof str === 'string' ? str.replace(ansiRegex, '') : str;
@@ -69923,18 +69910,6 @@ x.iTerm.setCwd = function (cwd) {
 };
 
 
-/***/ }),
-
-/***/ 6901:
-/***/ ((module) => {
-
-"use strict";
-
-module.exports = function () {
-	return /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]/g;
-};
-
-
 /***/ }),
 
 /***/ 1982:
@@ -70296,7 +70271,7 @@ module.exports = function (str) {
 
 "use strict";
 
-var ansiRegex = __nccwpck_require__(6901)();
+var ansiRegex = __nccwpck_require__(5067)();
 
 module.exports = function (str) {
 	return typeof str === 'string' ? str.replace(ansiRegex, '') : str;
@@ -70909,6 +70884,191 @@ module.exports = require("util");
 
 /***/ }),
 
+/***/ 492:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AsyncOption = void 0;
+var asyncresult_js_1 = __nccwpck_require__(6861);
+var option_js_1 = __nccwpck_require__(6456);
+/**
+ * An async-aware `Option` counterpart.
+ *
+ * Can be combined with asynchronous code without having to ``await`` anything right until
+ * the moment when you're ready to extract the final ``Option`` out of it.
+ *
+ * Can also be combined with synchronous code for convenience.
+ */
+var AsyncOption = /** @class */ (function () {
+    /**
+     * Constructs an `AsyncOption` from an `Option` or a `Promise` of an `Option`.
+     *
+     * @example
+     * ```typescript
+     * const option = new AsyncOption(Promise.resolve(Some('username')))
+     * ```
+     */
+    function AsyncOption(start) {
+        this.promise = Promise.resolve(start);
+    }
+    /**
+     * Calls `mapper` if the option is `Some`, otherwise keeps the `None` value intact.
+     * This function can be used for control flow based on `Option` values.
+     *
+     * @example
+     * ```typescript
+     * let hasValue = Some(1).toAsyncOption()
+     * let noValue = None.toAsyncOption()
+     *
+     * await hasValue.andThen(async (value) => Some(value * 2)).promise // Some(2)
+     * await hasValue.andThen(async (value) => None).promise // None
+     * await noValue.andThen(async (value) => Ok(value * 2)).promise // None
+     * ```
+     */
+    AsyncOption.prototype.andThen = function (mapper) {
+        var _this = this;
+        return this.thenInternal(function (option) { return __awaiter(_this, void 0, void 0, function () {
+            var mapped;
+            return __generator(this, function (_a) {
+                if (option.isNone()) {
+                    return [2 /*return*/, option];
+                }
+                mapped = mapper(option.value);
+                return [2 /*return*/, mapped instanceof AsyncOption ? mapped.promise : mapped];
+            });
+        }); });
+    };
+    /**
+     * Maps an `AsyncOption<T>` to `AsyncOption<U>` by applying a function to a contained
+     * `Some` value, leaving a `None` value untouched.
+     *
+     * This function can be used to compose the results of two functions.
+     *
+     * @example
+     * ```typescript
+     * let hasValue = Ok(1).toAsyncOption()
+     * let noValue = None.toAsyncOption()
+     *
+     * await hasValue.map(async (value) => value * 2).promise // Some(2)
+     * await noValue.map(async (value) => value * 2).promise // None
+     * ```
+     */
+    AsyncOption.prototype.map = function (mapper) {
+        var _this = this;
+        return this.thenInternal(function (option) { return __awaiter(_this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (option.isNone()) {
+                            return [2 /*return*/, option];
+                        }
+                        _a = option_js_1.Some;
+                        return [4 /*yield*/, mapper(option.value)];
+                    case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent()])];
+                }
+            });
+        }); });
+    };
+    /**
+     * Returns the value from `other` if this `AsyncOption` contains `None`, otherwise returns self.
+     *
+     * If `other` is a result of a function call consider using `orElse` instead, it will
+     * only evaluate the function when needed.
+     *
+     * @example
+     * ```
+     * const noValue = new AsyncOption(None)
+     * const hasValue = new AsyncOption(Some(1))
+     *
+     * await noValue.or(Some(123)).promise // Some(123)
+     * await hasValue.or(Some(123)).promise // Some(1)
+     * ```
+     */
+    AsyncOption.prototype.or = function (other) {
+        return this.orElse(function () { return other; });
+    };
+    /**
+     * Returns the value obtained by calling `other` if this `AsyncOption` contains `None`, otherwise
+     * returns self.
+     *
+     * @example
+     * ```
+     * const noValue = new AsyncOption(None)
+     * const hasValue = new AsyncOption(Some(1))
+     *
+     * await noValue.orElse(() => Some(123)).promise // Some(123)
+     * await hasValue.orElse(() => Some(123)).promise // Some(1)
+     * ```
+     */
+    AsyncOption.prototype.orElse = function (other) {
+        var _this = this;
+        return this.thenInternal(function (option) { return __awaiter(_this, void 0, void 0, function () {
+            var otherValue;
+            return __generator(this, function (_a) {
+                if (option.isSome()) {
+                    return [2 /*return*/, option];
+                }
+                otherValue = other();
+                return [2 /*return*/, otherValue instanceof AsyncOption ? otherValue.promise : otherValue];
+            });
+        }); });
+    };
+    /**
+     * Converts an `AsyncOption<T>` to an `AsyncResult<T, E>` so that `None` is converted to
+     * `Err(error)` and `Some` is converted to `Ok`.
+     */
+    AsyncOption.prototype.toResult = function (error) {
+        return new asyncresult_js_1.AsyncResult(this.promise.then(function (option) { return option.toResult(error); }));
+    };
+    AsyncOption.prototype.thenInternal = function (mapper) {
+        return new AsyncOption(this.promise.then(mapper));
+    };
+    return AsyncOption;
+}());
+exports.AsyncOption = AsyncOption;
+//# sourceMappingURL=asyncoption.js.map
+
+/***/ }),
+
 /***/ 6861:
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
@@ -70952,6 +71112,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.AsyncResult = void 0;
+var asyncoption_js_1 = __nccwpck_require__(492);
 var result_js_1 = __nccwpck_require__(9293);
 /**
  * An async-aware `Result` counterpart.
@@ -71035,42 +71196,87 @@ var AsyncResult = /** @class */ (function () {
             });
         }); });
     };
-    // TODO:
-    // mapErr()
-    // mapOr()
-    // mapOrElse()
-    // or()
-    // orElse()
-    // mapErr<F>(mapper: (val: E) => F | Promise<F>): AsyncResult<T, F> {
-    //     return this.thenInternal(async (result) => {
-    //         if (result.isOk()) {
-    //             return result
-    //         }
-    //         return Err(await mapper(result.error))
-    //     })
-    // }
-    // async mapOr<U>(default_: U, mapper: (val: T) => U | Promise<U>): Promise<U> {
-    //     return this.mapOrElse(() => default_, mapper)
-    // }
-    // async mapOrElse<U>(default_: (error: E) => U | Promise<U>, mapper: (val: T) => U | Promise<U>): Promise<U> {
-    //     const result = await this.promise
-    //     if (result.isErr()) {
-    //         return default_(result.error)
-    //     }
-    //     return mapper(result.value)
-    // }
-    // or<E2>(other: Result<T, E2> | AsyncResult<T, E2> | Promise<Result<T, E2>>): AsyncResult<T, E2> {
-    //     return this.orElse(() => other)
-    // }
-    // orElse<E2>(other: (error: E) => Result<T, E2> | AsyncResult<T, E2> | Promise<Result<T, E2>>): AsyncResult<T, E2> {
-    //     return this.thenInternal(async (result) => {
-    //         if (result.isOk()) {
-    //             return result
-    //         }
-    //         const otherValue = other(result.error)
-    //         return otherValue instanceof AsyncResult ? otherValue.promise : otherValue
-    //     })
-    // }
+    /**
+     * Maps an `AsyncResult<T, E>` to `AsyncResult<T, F>` by applying `mapper` to the `Err` value,
+     * leaving `Ok` value untouched.
+     *
+     * @example
+     * ```typescript
+     * let goodResult = Ok(1).toAsyncResult()
+     * let badResult = Err('boo').toAsyncResult()
+     *
+     * await goodResult.mapErr(async (error) => `Error is ${error}`).promise // Ok(1)
+     * await badResult.mapErr(async (error) => `Error is ${error}`).promise // Err('Error is boo')
+     * ```
+     */
+    AsyncResult.prototype.mapErr = function (mapper) {
+        var _this = this;
+        return this.thenInternal(function (result) { return __awaiter(_this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (result.isOk()) {
+                            return [2 /*return*/, result];
+                        }
+                        _a = result_js_1.Err;
+                        return [4 /*yield*/, mapper(result.error)];
+                    case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent()])];
+                }
+            });
+        }); });
+    };
+    /**
+     * Returns the value from `other` if this `AsyncResult` contains `Err`, otherwise returns self.
+     *
+     * If `other` is a result of a function call consider using `orElse` instead, it will
+     * only evaluate the function when needed.
+     *
+     * @example
+     * ```
+     * const badResult = new AsyncResult(Err('Error message'))
+     * const goodResult = new AsyncResult(Ok(1))
+     *
+     * await badResult.or(Ok(123)).promise // Ok(123)
+     * await goodResult.or(Ok(123)).promise // Ok(1)
+     * ```
+     */
+    AsyncResult.prototype.or = function (other) {
+        return this.orElse(function () { return other; });
+    };
+    /**
+     * Returns the value obtained by calling `other` if this `AsyncResult` contains `Err`, otherwise
+     * returns self.
+     *
+     * @example
+     * ```
+     * const badResult = new AsyncResult(Err('Error message'))
+     * const goodResult = new AsyncResult(Ok(1))
+     *
+     * await badResult.orElse(() => Ok(123)).promise // Ok(123)
+     * await goodResult.orElse(() => Ok(123)).promise // Ok(1)
+     * ```
+     */
+    AsyncResult.prototype.orElse = function (other) {
+        var _this = this;
+        return this.thenInternal(function (result) { return __awaiter(_this, void 0, void 0, function () {
+            var otherValue;
+            return __generator(this, function (_a) {
+                if (result.isOk()) {
+                    return [2 /*return*/, result];
+                }
+                otherValue = other(result.error);
+                return [2 /*return*/, otherValue instanceof AsyncResult ? otherValue.promise : otherValue];
+            });
+        }); });
+    };
+    /**
+     * Converts from `AsyncResult<T, E>` to `AsyncOption<T>` so that `Err` is converted to `None`
+     * and `Ok` is converted to `Some`.
+     */
+    AsyncResult.prototype.toOption = function () {
+        return new asyncoption_js_1.AsyncOption(this.promise.then(function (result) { return result.toOption(); }));
+    };
     AsyncResult.prototype.thenInternal = function (mapper) {
         return new AsyncResult(this.promise.then(mapper));
     };
@@ -71101,6 +71307,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
+__exportStar(__nccwpck_require__(492), exports);
 __exportStar(__nccwpck_require__(6861), exports);
 __exportStar(__nccwpck_require__(9293), exports);
 __exportStar(__nccwpck_require__(6456), exports);
@@ -71115,6 +71322,7 @@ __exportStar(__nccwpck_require__(6456), exports);
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Option = exports.Some = exports.None = void 0;
+var asyncoption_js_1 = __nccwpck_require__(492);
 var utils_js_1 = __nccwpck_require__(1414);
 var result_js_1 = __nccwpck_require__(9293);
 /**
@@ -71169,6 +71377,9 @@ var NoneImpl = /** @class */ (function () {
     NoneImpl.prototype.toString = function () {
         return 'None';
     };
+    NoneImpl.prototype.toAsyncOption = function () {
+        return new asyncoption_js_1.AsyncOption(exports.None);
+    };
     return NoneImpl;
 }());
 // Export None as a singleton, then freeze it so it can't be modified
@@ -71233,6 +71444,9 @@ var SomeImpl = /** @class */ (function () {
     SomeImpl.prototype.toResult = function (error) {
         return (0, result_js_1.Ok)(this.value);
     };
+    SomeImpl.prototype.toAsyncOption = function () {
+        return new asyncoption_js_1.AsyncOption(this);
+    };
     /**
      * Returns the contained `Some` value, but never throws.
      * Unlike `unwrap()`, this method doesn't throw and is only callable on an Some<T>
@@ -71293,7 +71507,7 @@ var Option;
                 return option;
             }
             else {
-                return option;
+                continue;
             }
         }
         // it must be None
@@ -71310,10 +71524,19 @@ var Option;
 /***/ }),
 
 /***/ 9293:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Result = exports.Ok = exports.OkImpl = exports.Err = exports.ErrImpl = void 0;
 var utils_js_1 = __nccwpck_require__(1414);
@@ -71523,15 +71746,12 @@ exports.OkImpl = OkImpl;
 exports.Ok = OkImpl;
 var Result;
 (function (Result) {
-    /**
-     * Parse a set of `Result`s, returning an array of all `Ok` values.
-     * Short circuits with the first `Err` found, if any
-     */
-    function all() {
-        var results = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            results[_i] = arguments[_i];
+    function all(arg0) {
+        var argN = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            argN[_i - 1] = arguments[_i];
         }
+        var results = arg0 === undefined ? [] : Array.isArray(arg0) ? arg0 : __spreadArray([arg0], argN, true);
         var okResult = [];
         for (var _a = 0, results_1 = results; _a < results_1.length; _a++) {
             var result = results_1[_a];
@@ -71545,15 +71765,12 @@ var Result;
         return new exports.Ok(okResult);
     }
     Result.all = all;
-    /**
-     * Parse a set of `Result`s, short-circuits when an input value is `Ok`.
-     * If no `Ok` is found, returns an `Err` containing the collected error values
-     */
-    function any() {
-        var results = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            results[_i] = arguments[_i];
+    function any(arg0) {
+        var argN = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            argN[_i - 1] = arguments[_i];
         }
+        var results = arg0 === undefined ? [] : Array.isArray(arg0) ? arg0 : __spreadArray([arg0], argN, true);
         var errResult = [];
         // short-circuits
         for (var _a = 0, results_2 = results; _a < results_2.length; _a++) {
@@ -71597,6 +71814,18 @@ var Result;
         }
     }
     Result.wrapAsync = wrapAsync;
+    /**
+     * Partitions a set of results, separating the `Ok` and `Err` values.
+     */
+    function partition(results) {
+        return results.reduce(function (_a, v) {
+            var oks = _a[0], errors = _a[1];
+            return v.isOk()
+                ? [__spreadArray(__spreadArray([], oks, true), [v.value], false), errors]
+                : [oks, __spreadArray(__spreadArray([], errors, true), [v.error], false)];
+        }, [[], []]);
+    }
+    Result.partition = partition;
     function isResult(val) {
         return val instanceof exports.Err || val instanceof exports.Ok;
     }