async-constructor
Version:
The helper functions for creating classes that require asynchronous constructors.
1,608 lines (1,472 loc) • 295 kB
JavaScript
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
function __awaiter(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 commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
var es2018$9 = {};
var extraPromise = {};
var __classPrivateFieldSet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet$k = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _Box_value;extraPromise.ExtraPromise = void 0;
var State;
(function (State) {
State[State["Pending"] = 0] = "Pending";
State[State["Fulfilled"] = 1] = "Fulfilled";
State[State["Rejected"] = 2] = "Rejected";
})(State || (State = {}));
class ExtraPromise extends Promise {
constructor(executor) {
const state = new Box(State.Pending);
super((resolve, reject) => {
executor(value => {
if (state.get() === State.Pending) {
state.set(State.Fulfilled);
resolve(value);
}
}, reason => {
if (state.get() === State.Pending) {
state.set(State.Rejected);
reject(reason);
}
});
});
this.state = state;
}
get pending() {
return this.state.get() === State.Pending;
}
get fulfilled() {
return this.state.get() === State.Fulfilled;
}
get rejected() {
return this.state.get() === State.Rejected;
}
}
extraPromise.ExtraPromise = ExtraPromise;
class Box {
constructor(value) {
_Box_value.set(this, void 0);
__classPrivateFieldSet$c(this, _Box_value, value, "f");
}
set(value) {
__classPrivateFieldSet$c(this, _Box_value, value, "f");
}
get() {
return __classPrivateFieldGet$k(this, _Box_value, "f");
}
}
_Box_value = new WeakMap();
var deferred = {};
var __classPrivateFieldSet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet$j = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _Deferred_resolve, _Deferred_reject, _Deferred_promise;deferred.Deferred = void 0;
class Deferred {
constructor() {
_Deferred_resolve.set(this, void 0);
_Deferred_reject.set(this, void 0);
_Deferred_promise.set(this, void 0);
__classPrivateFieldSet$b(this, _Deferred_promise, new Promise((resolve, reject) => {
__classPrivateFieldSet$b(this, _Deferred_resolve, resolve, "f");
__classPrivateFieldSet$b(this, _Deferred_reject, reject, "f");
}), "f");
}
get then() {
return __classPrivateFieldGet$j(this, _Deferred_promise, "f").then.bind(__classPrivateFieldGet$j(this, _Deferred_promise, "f"));
}
resolve(value) {
__classPrivateFieldGet$j(this, _Deferred_resolve, "f").call(this, value);
}
reject(reason) {
__classPrivateFieldGet$j(this, _Deferred_reject, "f").call(this, reason);
}
}
deferred.Deferred = Deferred;
_Deferred_resolve = new WeakMap(), _Deferred_reject = new WeakMap(), _Deferred_promise = new WeakMap();
var lazyPromise = {};
var __classPrivateFieldSet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet$i = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _LazyPromise_promise, _LazyPromise_executor;lazyPromise.LazyPromise = void 0;
class LazyPromise {
constructor(executor) {
_LazyPromise_promise.set(this, void 0);
_LazyPromise_executor.set(this, void 0);
__classPrivateFieldSet$a(this, _LazyPromise_executor, executor, "f");
}
get then() {
if (!__classPrivateFieldGet$i(this, _LazyPromise_promise, "f"))
__classPrivateFieldSet$a(this, _LazyPromise_promise, new Promise(__classPrivateFieldGet$i(this, _LazyPromise_executor, "f")), "f");
return __classPrivateFieldGet$i(this, _LazyPromise_promise, "f").then.bind(__classPrivateFieldGet$i(this, _LazyPromise_promise, "f"));
}
}
lazyPromise.LazyPromise = LazyPromise;
_LazyPromise_promise = new WeakMap(), _LazyPromise_executor = new WeakMap();
var signal = {};
var es2018$8 = {};
var customError = {};
customError.CustomError = void 0;
class CustomError extends Error {
get name() {
return this.constructor.name;
}
}
customError.CustomError = CustomError;
var expectedError = {};
expectedError.ExpectedError = void 0;
const custom_error_1$1 = customError;
class ExpectedError extends custom_error_1$1.CustomError {
}
expectedError.ExpectedError = ExpectedError;
var assertionError = {};
assertionError.AssertionError = void 0;
const custom_error_1 = customError;
class AssertionError extends custom_error_1.CustomError {
}
assertionError.AssertionError = AssertionError;
var normalize$2 = {};
normalize$2.normalize = void 0;
function normalize$1(err) {
var _a;
return {
name: err.name,
message: err.message,
stack: (_a = err.stack) !== null && _a !== void 0 ? _a : null
};
}
normalize$2.normalize = normalize$1;
var refute$1 = {};
refute$1.refute = void 0;
const expected_error_1 = expectedError;
function refute(condition, message) {
if (condition)
throw new expected_error_1.ExpectedError(message);
}
refute$1.refute = refute;
var assert$1 = {};
assert$1.assert = void 0;
const assertion_error_1 = assertionError;
function assert(condition, message) {
if (!condition)
throw new assertion_error_1.AssertionError(message);
}
assert$1.assert = assert;
(function (exports) {
var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};__exportStar(customError, exports);
__exportStar(expectedError, exports);
__exportStar(assertionError, exports);
__exportStar(normalize$2, exports);
__exportStar(refute$1, exports);
__exportStar(assert$1, exports);
}(es2018$8));
var __classPrivateFieldGet$h = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _Signal_deferred;signal.SignalDiscarded = signal.Signal = void 0;
const errors_1$o = es2018$8;
const deferred_1$1 = deferred;
class Signal {
constructor() {
_Signal_deferred.set(this, new deferred_1$1.Deferred());
}
get then() {
return __classPrivateFieldGet$h(this, _Signal_deferred, "f").then.bind(__classPrivateFieldGet$h(this, _Signal_deferred, "f"));
}
emit() {
__classPrivateFieldGet$h(this, _Signal_deferred, "f").resolve();
}
discard() {
Promise.resolve(__classPrivateFieldGet$h(this, _Signal_deferred, "f")).catch(() => { });
__classPrivateFieldGet$h(this, _Signal_deferred, "f").reject(new SignalDiscarded());
}
}
signal.Signal = Signal;
_Signal_deferred = new WeakMap();
class SignalDiscarded extends errors_1$o.CustomError {
}
signal.SignalDiscarded = SignalDiscarded;
var signalGroup = {};
var __classPrivateFieldGet$g = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _SignalGroup_group;signalGroup.SignalGroup = void 0;
class SignalGroup {
constructor() {
_SignalGroup_group.set(this, new Set());
}
add(signal) {
__classPrivateFieldGet$g(this, _SignalGroup_group, "f").add(signal);
}
remove(signal) {
__classPrivateFieldGet$g(this, _SignalGroup_group, "f").delete(signal);
}
emitAll() {
for (const signal of __classPrivateFieldGet$g(this, _SignalGroup_group, "f")) {
signal.emit();
}
}
discardAll() {
for (const signal of __classPrivateFieldGet$g(this, _SignalGroup_group, "f")) {
signal.discard();
}
}
}
signalGroup.SignalGroup = SignalGroup;
_SignalGroup_group = new WeakMap();
var semaphore = {};
var es2018$7 = {};
var go$1 = {};
go$1.go = void 0;
function go(fn) {
return fn();
}
go$1.go = go;
(function (exports) {
var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};__exportStar(go$1, exports);
}(es2018$7));
/**
* lodash (Custom Build) <https://lodash.com/>
* Build: `lodash modularize exports="npm" -o ./`
* Copyright jQuery Foundation and other contributors <https://jquery.org/>
* Released under MIT license <https://lodash.com/license>
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
*/
/** Used as the `TypeError` message for "Functions" methods. */
var FUNC_ERROR_TEXT = 'Expected a function';
/** Used as references for various `Number` constants. */
var INFINITY = 1 / 0,
MAX_INTEGER = 1.7976931348623157e+308,
NAN = 0 / 0;
/** `Object#toString` result references. */
var symbolTag = '[object Symbol]';
/** Used to match leading and trailing whitespace. */
var reTrim = /^\s+|\s+$/g;
/** Used to detect bad signed hexadecimal string values. */
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
/** Used to detect binary string values. */
var reIsBinary = /^0b[01]+$/i;
/** Used to detect octal string values. */
var reIsOctal = /^0o[0-7]+$/i;
/** Built-in method references without a dependency on `root`. */
var freeParseInt = parseInt;
/** Used for built-in method references. */
var objectProto = Object.prototype;
/**
* Used to resolve the
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
* of values.
*/
var objectToString = objectProto.toString;
/**
* Creates a function that invokes `func`, with the `this` binding and arguments
* of the created function, while it's called less than `n` times. Subsequent
* calls to the created function return the result of the last `func` invocation.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Function
* @param {number} n The number of calls at which `func` is no longer invoked.
* @param {Function} func The function to restrict.
* @returns {Function} Returns the new restricted function.
* @example
*
* jQuery(element).on('click', _.before(5, addContactToList));
* // => Allows adding up to 4 contacts to the list.
*/
function before(n, func) {
var result;
if (typeof func != 'function') {
throw new TypeError(FUNC_ERROR_TEXT);
}
n = toInteger(n);
return function() {
if (--n > 0) {
result = func.apply(this, arguments);
}
if (n <= 1) {
func = undefined;
}
return result;
};
}
/**
* Creates a function that is restricted to invoking `func` once. Repeat calls
* to the function return the value of the first invocation. The `func` is
* invoked with the `this` binding and arguments of the created function.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Function
* @param {Function} func The function to restrict.
* @returns {Function} Returns the new restricted function.
* @example
*
* var initialize = _.once(createApplication);
* initialize();
* initialize();
* // => `createApplication` is invoked once
*/
function once(func) {
return before(2, func);
}
/**
* Checks if `value` is the
* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
* @example
*
* _.isObject({});
* // => true
*
* _.isObject([1, 2, 3]);
* // => true
*
* _.isObject(_.noop);
* // => true
*
* _.isObject(null);
* // => false
*/
function isObject$7(value) {
var type = typeof value;
return !!value && (type == 'object' || type == 'function');
}
/**
* Checks if `value` is object-like. A value is object-like if it's not `null`
* and has a `typeof` result of "object".
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
* @example
*
* _.isObjectLike({});
* // => true
*
* _.isObjectLike([1, 2, 3]);
* // => true
*
* _.isObjectLike(_.noop);
* // => false
*
* _.isObjectLike(null);
* // => false
*/
function isObjectLike(value) {
return !!value && typeof value == 'object';
}
/**
* Checks if `value` is classified as a `Symbol` primitive or object.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
* @example
*
* _.isSymbol(Symbol.iterator);
* // => true
*
* _.isSymbol('abc');
* // => false
*/
function isSymbol$3(value) {
return typeof value == 'symbol' ||
(isObjectLike(value) && objectToString.call(value) == symbolTag);
}
/**
* Converts `value` to a finite number.
*
* @static
* @memberOf _
* @since 4.12.0
* @category Lang
* @param {*} value The value to convert.
* @returns {number} Returns the converted number.
* @example
*
* _.toFinite(3.2);
* // => 3.2
*
* _.toFinite(Number.MIN_VALUE);
* // => 5e-324
*
* _.toFinite(Infinity);
* // => 1.7976931348623157e+308
*
* _.toFinite('3.2');
* // => 3.2
*/
function toFinite(value) {
if (!value) {
return value === 0 ? value : 0;
}
value = toNumber(value);
if (value === INFINITY || value === -INFINITY) {
var sign = (value < 0 ? -1 : 1);
return sign * MAX_INTEGER;
}
return value === value ? value : 0;
}
/**
* Converts `value` to an integer.
*
* **Note:** This method is loosely based on
* [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to convert.
* @returns {number} Returns the converted integer.
* @example
*
* _.toInteger(3.2);
* // => 3
*
* _.toInteger(Number.MIN_VALUE);
* // => 0
*
* _.toInteger(Infinity);
* // => 1.7976931348623157e+308
*
* _.toInteger('3.2');
* // => 3
*/
function toInteger(value) {
var result = toFinite(value),
remainder = result % 1;
return result === result ? (remainder ? result - remainder : result) : 0;
}
/**
* Converts `value` to a number.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to process.
* @returns {number} Returns the number.
* @example
*
* _.toNumber(3.2);
* // => 3.2
*
* _.toNumber(Number.MIN_VALUE);
* // => 5e-324
*
* _.toNumber(Infinity);
* // => Infinity
*
* _.toNumber('3.2');
* // => 3.2
*/
function toNumber(value) {
if (typeof value == 'number') {
return value;
}
if (isSymbol$3(value)) {
return NAN;
}
if (isObject$7(value)) {
var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
value = isObject$7(other) ? (other + '') : other;
}
if (typeof value != 'string') {
return value === 0 ? value : +value;
}
value = value.replace(reTrim, '');
var isBinary = reIsBinary.test(value);
return (isBinary || reIsOctal.test(value))
? freeParseInt(value.slice(2), isBinary ? 2 : 8)
: (reIsBadHex.test(value) ? NAN : +value);
}
var lodash_once = once;
var __classPrivateFieldSet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet$f = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
var _Semaphore_locked, _Semaphore_count, _Semaphore_awaiting;semaphore.Semaphore = void 0;
const signal_1 = signal;
const signal_group_1 = signalGroup;
const go_1$n = es2018$7;
const lodash_once_1$1 = __importDefault$2(lodash_once);
class Semaphore {
constructor(count) {
_Semaphore_locked.set(this, 0);
_Semaphore_count.set(this, void 0);
_Semaphore_awaiting.set(this, new signal_group_1.SignalGroup());
__classPrivateFieldSet$9(this, _Semaphore_count, count, "f");
}
acquire(...args) {
if (args.length === 0) {
return new Promise(async (resolve) => {
await this.lock();
resolve((0, lodash_once_1$1.default)(() => this.unlock()));
});
}
else {
const [handler] = args;
return (0, go_1$n.go)(async () => {
await this.lock();
try {
const result = await handler();
return result;
}
finally {
this.unlock();
}
});
}
}
async lock() {
var _a;
while (this.isLocked()) {
const unlockSignal = new signal_1.Signal();
__classPrivateFieldGet$f(this, _Semaphore_awaiting, "f").add(unlockSignal);
await unlockSignal;
__classPrivateFieldGet$f(this, _Semaphore_awaiting, "f").remove(unlockSignal);
}
__classPrivateFieldSet$9(this, _Semaphore_locked, (_a = __classPrivateFieldGet$f(this, _Semaphore_locked, "f"), _a++, _a), "f");
}
unlock() {
var _a;
__classPrivateFieldSet$9(this, _Semaphore_locked, (_a = __classPrivateFieldGet$f(this, _Semaphore_locked, "f"), _a--, _a), "f");
__classPrivateFieldGet$f(this, _Semaphore_awaiting, "f").emitAll();
}
isLocked() {
return __classPrivateFieldGet$f(this, _Semaphore_count, "f") - __classPrivateFieldGet$f(this, _Semaphore_locked, "f") === 0;
}
}
semaphore.Semaphore = Semaphore;
_Semaphore_locked = new WeakMap(), _Semaphore_count = new WeakMap(), _Semaphore_awaiting = new WeakMap();
var mutex = {};
mutex.Mutex = void 0;
const semaphore_1 = semaphore;
class Mutex extends semaphore_1.Semaphore {
constructor() {
super(1);
}
}
mutex.Mutex = Mutex;
var debounceMicrotask = {};
var __classPrivateFieldGet$e = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _DebounceMicrotask_registry;debounceMicrotask.DebounceMicrotask = void 0;
class DebounceMicrotask {
constructor() {
_DebounceMicrotask_registry.set(this, new WeakSet());
}
queue(fn) {
if (__classPrivateFieldGet$e(this, _DebounceMicrotask_registry, "f").has(fn))
return;
__classPrivateFieldGet$e(this, _DebounceMicrotask_registry, "f").add(fn);
queueMicrotask(() => {
if (__classPrivateFieldGet$e(this, _DebounceMicrotask_registry, "f").has(fn)) {
// DebounceMicrotask的目的仅仅是避免多次调用queueMicrotaskh函数,
// 因此无论fn是同步函数还是异步函数都不会造成影响.
try {
fn();
}
finally {
__classPrivateFieldGet$e(this, _DebounceMicrotask_registry, "f").delete(fn);
}
}
});
}
cancel(fn) {
__classPrivateFieldGet$e(this, _DebounceMicrotask_registry, "f").delete(fn);
}
}
debounceMicrotask.DebounceMicrotask = DebounceMicrotask;
_DebounceMicrotask_registry = new WeakMap();
var channel = {};
var es2018$6 = {};
var getErrorResult$1 = {};
getErrorResult$1.getErrorResult = void 0;
function getErrorResult(fn) {
try {
const result = fn();
return [void 0, result];
}
catch (e) {
return [e, void 0];
}
}
getErrorResult$1.getErrorResult = getErrorResult;
var getErrorResultAsync$1 = {};
getErrorResultAsync$1.getErrorResultAsync = void 0;
async function getErrorResultAsync(fn) {
try {
const result = await fn();
return [void 0, result];
}
catch (e) {
return [e, void 0];
}
}
getErrorResultAsync$1.getErrorResultAsync = getErrorResultAsync;
var getErrorResultPromise$1 = {};
getErrorResultPromise$1.getErrorResultPromise = void 0;
async function getErrorResultPromise(promise) {
try {
const result = await promise;
return [void 0, result];
}
catch (e) {
return [e, void 0];
}
}
getErrorResultPromise$1.getErrorResultPromise = getErrorResultPromise;
var getResultError$1 = {};
getResultError$1.getResultError = void 0;
function getResultError(fn) {
try {
const result = fn();
return [result, void 0];
}
catch (e) {
return [void 0, e];
}
}
getResultError$1.getResultError = getResultError;
var getResultErrorAsync$1 = {};
getResultErrorAsync$1.getResultErrorAsync = void 0;
async function getResultErrorAsync(fn) {
try {
const result = await fn();
return [result, void 0];
}
catch (e) {
return [void 0, e];
}
}
getResultErrorAsync$1.getResultErrorAsync = getResultErrorAsync;
var getResultErrorPromise$1 = {};
getResultErrorPromise$1.getResultErrorPromise = void 0;
async function getResultErrorPromise(promise) {
try {
const result = await promise;
return [result, void 0];
}
catch (e) {
return [void 0, e];
}
}
getResultErrorPromise$1.getResultErrorPromise = getResultErrorPromise;
var getSuccess$1 = {};
getSuccess$1.getSuccess = void 0;
function getSuccess(fn) {
try {
const result = fn();
return [true, result];
}
catch (_a) {
return [false, void 0];
}
}
getSuccess$1.getSuccess = getSuccess;
var getSuccessAsync$1 = {};
getSuccessAsync$1.getSuccessAsync = void 0;
async function getSuccessAsync(fn) {
try {
const result = await fn();
return [true, result];
}
catch (_a) {
return [false, void 0];
}
}
getSuccessAsync$1.getSuccessAsync = getSuccessAsync;
var getSuccessPromise$1 = {};
getSuccessPromise$1.getSuccessPromise = void 0;
async function getSuccessPromise(promise) {
try {
const result = await promise;
return [true, result];
}
catch (_a) {
return [false, void 0];
}
}
getSuccessPromise$1.getSuccessPromise = getSuccessPromise;
var getFailure$1 = {};
getFailure$1.getFailure = void 0;
function getFailure(fn) {
try {
fn();
return [false, void 0];
}
catch (e) {
return [true, e];
}
}
getFailure$1.getFailure = getFailure;
var getFailureAsync$1 = {};
getFailureAsync$1.getFailureAsync = void 0;
async function getFailureAsync(fn) {
try {
await fn();
return [false, void 0];
}
catch (e) {
return [true, e];
}
}
getFailureAsync$1.getFailureAsync = getFailureAsync;
var getFailurePromise$1 = {};
getFailurePromise$1.getFailurePromise = void 0;
async function getFailurePromise(promise) {
try {
await promise;
return [false, void 0];
}
catch (e) {
return [true, e];
}
}
getFailurePromise$1.getFailurePromise = getFailurePromise;
var isSuccess$1 = {};
isSuccess$1.isSuccess = void 0;
function isSuccess(fn) {
try {
fn();
return true;
}
catch (_a) {
return false;
}
}
isSuccess$1.isSuccess = isSuccess;
var isSuccessAsync$1 = {};
isSuccessAsync$1.isSuccessAsync = void 0;
async function isSuccessAsync(fn) {
try {
await fn();
return true;
}
catch (_a) {
return false;
}
}
isSuccessAsync$1.isSuccessAsync = isSuccessAsync;
var isSuccessPromise$1 = {};
isSuccessPromise$1.isSuccessPromise = void 0;
async function isSuccessPromise(promise) {
try {
await promise;
return true;
}
catch (_a) {
return false;
}
}
isSuccessPromise$1.isSuccessPromise = isSuccessPromise;
var isFailure$1 = {};
isFailure$1.isFailure = void 0;
function isFailure(fn) {
try {
fn();
return false;
}
catch (_a) {
return true;
}
}
isFailure$1.isFailure = isFailure;
var isFailureAsync$1 = {};
isFailureAsync$1.isFailureAsync = void 0;
async function isFailureAsync(fn) {
try {
await fn();
return false;
}
catch (_a) {
return true;
}
}
isFailureAsync$1.isFailureAsync = isFailureAsync;
var isFailurePromise$1 = {};
isFailurePromise$1.isFailurePromise = void 0;
async function isFailurePromise(promise) {
try {
await promise;
return false;
}
catch (_a) {
return true;
}
}
isFailurePromise$1.isFailurePromise = isFailurePromise;
var getResult$1 = {};
getResult$1.getResult = void 0;
function getResult(fn) {
try {
return fn();
}
catch (_a) {
return;
}
}
getResult$1.getResult = getResult;
var getResultAsync$1 = {};
getResultAsync$1.getResultAsync = void 0;
async function getResultAsync(fn) {
try {
return await fn();
}
catch (_a) {
return undefined;
}
}
getResultAsync$1.getResultAsync = getResultAsync;
var getResultPromise$1 = {};
getResultPromise$1.getResultPromise = void 0;
async function getResultPromise(promise) {
try {
return await promise;
}
catch (_a) {
return;
}
}
getResultPromise$1.getResultPromise = getResultPromise;
var getError$1 = {};
getError$1.getError = void 0;
function getError(fn) {
try {
fn();
}
catch (syncError) {
return syncError;
}
return;
}
getError$1.getError = getError;
var getErrorAsync$1 = {};
getErrorAsync$1.getErrorAsync = void 0;
async function getErrorAsync(fn) {
try {
await fn();
}
catch (err) {
return err;
}
return;
}
getErrorAsync$1.getErrorAsync = getErrorAsync;
var getErrorPromise$1 = {};
getErrorPromise$1.getErrorPromise = void 0;
async function getErrorPromise(promise) {
try {
await promise;
}
catch (err) {
return err;
}
return;
}
getErrorPromise$1.getErrorPromise = getErrorPromise;
var getErrorAsyncIterable$1 = {};
getErrorAsyncIterable$1.getErrorAsyncIterable = void 0;
async function getErrorAsyncIterable(iterable) {
try {
for await (const _ of iterable) { }
}
catch (promiseError) {
return promiseError;
}
return;
}
getErrorAsyncIterable$1.getErrorAsyncIterable = getErrorAsyncIterable;
var toResult$1 = {};
var result = {};
var __classPrivateFieldSet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, privateMap, value) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to set private field on non-instance");
}
privateMap.set(receiver, value);
return value;
};
var __classPrivateFieldGet$d = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, privateMap) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to get private field on non-instance");
}
return privateMap.get(receiver);
};
var _value$1, _value_1;result.Result = void 0;
class Result$1 {
static Ok(value) {
return Ok.of(value);
}
static Err(error) {
return Err.of(error);
}
}
result.Result = Result$1;
class Ok extends Result$1 {
constructor(value) {
super();
_value$1.set(this, void 0);
__classPrivateFieldSet$8(this, _value$1, value);
}
static of(value) {
return new Ok(value);
}
isOk() {
return true;
}
isErr() {
return false;
}
onOk(callback) {
callback(__classPrivateFieldGet$d(this, _value$1));
return Ok.of(__classPrivateFieldGet$d(this, _value$1));
}
onErr() {
return Ok.of(__classPrivateFieldGet$d(this, _value$1));
}
orElse() {
return Ok.of(__classPrivateFieldGet$d(this, _value$1));
}
map(fn) {
return Ok.of(fn(__classPrivateFieldGet$d(this, _value$1)));
}
get() {
return __classPrivateFieldGet$d(this, _value$1);
}
}
_value$1 = new WeakMap();
class Err extends Result$1 {
constructor(err) {
super();
_value_1.set(this, void 0);
__classPrivateFieldSet$8(this, _value_1, err);
}
static of(error) {
return new Err(error);
}
isOk() {
return false;
}
isErr() {
return true;
}
onOk() {
return Err.of(__classPrivateFieldGet$d(this, _value_1));
}
onErr(callback) {
callback(__classPrivateFieldGet$d(this, _value_1));
return Err.of(__classPrivateFieldGet$d(this, _value_1));
}
orElse(defaultValue) {
return Ok.of(defaultValue);
}
map() {
return Err.of(__classPrivateFieldGet$d(this, _value_1));
}
get() {
throw __classPrivateFieldGet$d(this, _value_1);
}
}
_value_1 = new WeakMap();
toResult$1.toResult = void 0;
const result_1$1 = result;
function toResult(fn) {
try {
const result = fn();
return result_1$1.Result.Ok(result);
}
catch (e) {
return result_1$1.Result.Err(e);
}
}
toResult$1.toResult = toResult;
var toResultAsync$1 = {};
var asyncResult = {};
var __classPrivateFieldSet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, privateMap, value) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to set private field on non-instance");
}
privateMap.set(receiver, value);
return value;
};
var __classPrivateFieldGet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, privateMap) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to get private field on non-instance");
}
return privateMap.get(receiver);
};
var _promise;asyncResult.AsyncResult = void 0;
const go_1$m = es2018$7;
const result_1 = result;
const get_success_promise_1 = getSuccessPromise$1;
const get_failure_promise_1 = getFailurePromise$1;
const is_success_promise_1 = isSuccessPromise$1;
const is_failure_promise_1 = isFailurePromise$1;
class AsyncResult {
constructor(promise) {
_promise.set(this, void 0);
__classPrivateFieldSet$7(this, _promise, Promise.resolve(promise));
}
static Ok(value) {
return AsyncOk.of(value);
}
static Err(error) {
return AsyncErr.of(error);
}
get then() {
const promise = __classPrivateFieldGet$c(this, _promise).then(x => result_1.Result.Ok(x), x => result_1.Result.Err(x));
return promise.then.bind(promise);
}
onOk(callback) {
go_1$m.go(async () => {
const [succ, ret] = await get_success_promise_1.getSuccessPromise(__classPrivateFieldGet$c(this, _promise));
if (succ)
callback(ret);
});
return new AsyncResult(__classPrivateFieldGet$c(this, _promise));
}
onErr(callback) {
go_1$m.go(async () => {
const [fail, err] = await get_failure_promise_1.getFailurePromise(__classPrivateFieldGet$c(this, _promise));
if (fail)
callback(err);
});
return new AsyncResult(__classPrivateFieldGet$c(this, _promise));
}
async isOk() {
return await is_success_promise_1.isSuccessPromise(__classPrivateFieldGet$c(this, _promise));
}
async isErr() {
return await is_failure_promise_1.isFailurePromise(__classPrivateFieldGet$c(this, _promise));
}
orElse(defaultValue) {
const promise = go_1$m.go(async () => {
try {
return await __classPrivateFieldGet$c(this, _promise);
}
catch (_a) {
return defaultValue;
}
});
return new AsyncResult(promise);
}
map(mapper) {
const promise = go_1$m.go(async () => {
const result = await __classPrivateFieldGet$c(this, _promise);
return mapper(result);
});
return new AsyncResult(promise);
}
async get() {
return await __classPrivateFieldGet$c(this, _promise);
}
}
asyncResult.AsyncResult = AsyncResult;
_promise = new WeakMap();
class AsyncOk extends AsyncResult {
static of(value) {
return new AsyncOk(value);
}
constructor(value) {
super(Promise.resolve(value));
}
}
class AsyncErr extends AsyncResult {
static of(value) {
return new AsyncErr(value);
}
constructor(err) {
super(Promise.reject(err));
}
}
toResultAsync$1.toResultAsync = void 0;
const async_result_1$1 = asyncResult;
function toResultAsync(fn) {
try {
const result = fn();
return new async_result_1$1.AsyncResult(result);
}
catch (e) {
return async_result_1$1.AsyncResult.Err(e);
}
}
toResultAsync$1.toResultAsync = toResultAsync;
var toResultPromise$1 = {};
toResultPromise$1.toResultPromise = void 0;
const async_result_1 = asyncResult;
function toResultPromise(promise) {
return new async_result_1.AsyncResult(promise);
}
toResultPromise$1.toResultPromise = toResultPromise;
var toOptional$1 = {};
var optional = {};
var __classPrivateFieldSet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, privateMap, value) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to set private field on non-instance");
}
privateMap.set(receiver, value);
return value;
};
var __classPrivateFieldGet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, privateMap) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to get private field on non-instance");
}
return privateMap.get(receiver);
};
var _value;optional.Optional = void 0;
class Optional {
static Some(value) {
return Some.of(value);
}
static None() {
return None.of();
}
}
optional.Optional = Optional;
class Some extends Optional {
constructor(value) {
super();
_value.set(this, void 0);
__classPrivateFieldSet$6(this, _value, value);
}
static of(value) {
return new Some(value);
}
isSome() {
return true;
}
isNone() {
return false;
}
onSome(callback) {
callback(__classPrivateFieldGet$b(this, _value));
return Some.of(__classPrivateFieldGet$b(this, _value));
}
onNone() {
return Some.of(__classPrivateFieldGet$b(this, _value));
}
orElse() {
return Some.of(__classPrivateFieldGet$b(this, _value));
}
map(mapper) {
return Some.of(mapper(__classPrivateFieldGet$b(this, _value)));
}
filter(predicate) {
if (predicate(__classPrivateFieldGet$b(this, _value))) {
return Some.of(__classPrivateFieldGet$b(this, _value));
}
else {
return None.of();
}
}
get() {
return __classPrivateFieldGet$b(this, _value);
}
}
_value = new WeakMap();
class None extends Optional {
static of() {
return new None();
}
constructor() {
super();
}
isSome() {
return false;
}
isNone() {
return true;
}
onSome() {
return None.of();
}
onNone(callback) {
callback();
return None.of();
}
orElse(defaultValue) {
return Some.of(defaultValue);
}
map() {
return None.of();
}
filter() {
return None.of();
}
get() {
throw new Error('Cannot get value from None');
}
}
toOptional$1.toOptional = toOptional$1.toOptionalPartial = void 0;
const optional_1 = optional;
function toOptionalPartial(isNone) {
return (fn) => toOptional(fn, isNone);
}
toOptional$1.toOptionalPartial = toOptionalPartial;
function toOptional(fn, isNone) {
const result = fn();
if (isNone(result)) {
return optional_1.Optional.None();
}
else {
return optional_1.Optional.Some(result);
}
}
toOptional$1.toOptional = toOptional;
var toOptionalAsync$1 = {};
var asyncOptional = {};
(function (exports) {
var __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, privateMap, value) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to set private field on non-instance");
}
privateMap.set(receiver, value);
return value;
};
var __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, privateMap) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to get private field on non-instance");
}
return privateMap.get(receiver);
};
var _promise;exports.AsyncOptional = exports.Nil = void 0;
const go_1 = es2018$7;
const optional_1 = optional;
exports.Nil = Symbol();
class AsyncOptional {
constructor(promise) {
_promise.set(this, void 0);
__classPrivateFieldSet(this, _promise, Promise.resolve(promise));
}
static Some(value) {
return AsyncSome.of(value);
}
static None() {
return AsyncNone.of();
}
get then() {
const promise = __classPrivateFieldGet(this, _promise).then(x => x === exports.Nil
? optional_1.Optional.None()
: optional_1.Optional.Some(x));
return promise.then.bind(promise);
}
onSome(callback) {
go_1.go(async () => {
const result = await __classPrivateFieldGet(this, _promise);
if (result !== exports.Nil)
callback(result);
});
return new AsyncOptional(__classPrivateFieldGet(this, _promise));
}
onNone(callback) {
go_1.go(async () => {
const result = await __classPrivateFieldGet(this, _promise);
if (result === exports.Nil)
callback();
});
return new AsyncOptional(__classPrivateFieldGet(this, _promise));
}
async isSome() {
const result = await __classPrivateFieldGet(this, _promise);
return result !== exports.Nil;
}
async isNone() {
const result = await __classPrivateFieldGet(this, _promise);
return result === exports.Nil;
}
orElse(defaultValue) {
const promise = go_1.go(async () => {
const result = await __classPrivateFieldGet(this, _promise);
if (result === exports.Nil)
return defaultValue;
return result;
});
return new AsyncOptional(promise);
}
map(mapper) {
const promise = go_1.go(async () => {
const result = await __classPrivateFieldGet(this, _promise);
if (result === exports.Nil)
return exports.Nil;
return mapper(result);
});
return new AsyncOptional(promise);
}
filter(predicate) {
const promise = go_1.go(async () => {
const result = await __classPrivateFieldGet(this, _promise);
if (result === exports.Nil)
return exports.Nil;
if (predicate(result))
return result;
return exports.Nil;
});
return new AsyncOptional(promise);
}
async get() {
const result = await __classPrivateFieldGet(this, _promise);
if (result === exports.Nil)
throw new Error('Cannot get value from None');
return result;
}
}
exports.AsyncOptional = AsyncOptional;
_promise = new WeakMap();
class AsyncNone extends AsyncOptional {
static of() {
return new AsyncNone();
}
constructor() {
super(Promise.resolve(exports.Nil));
}
}
class AsyncSome extends AsyncOptional {
static of(value) {
return new AsyncSome(value);
}
constructor(value) {
super(Promise.resolve(value));
}
}
}(asyncOptional));
toOptionalAsync$1.toOptionalAsync = toOptionalAsync$1.toOptionalAsyncPartial = void 0;
const go_1$l = es2018$7;
const async_optional_1$1 = asyncOptional;
function toOptionalAsyncPartial(isNone) {
return (fn) => toOptionalAsync(fn, isNone);
}
toOptionalAsync$1.toOptionalAsyncPartial = toOptionalAsyncPartial;
function toOptionalAsync(fn, isNone) {
const promise = go_1$l.go(async () => {
const result = await fn();
if (isNone(result))
return async_optional_1$1.Nil;
return result;
});
return new async_optional_1$1.AsyncOptional(promise);
}
toOptionalAsync$1.toOptionalAsync = toOptionalAsync;
var toOptionalPromise$1 = {};
toOptionalPromise$1.toOptionalPromise = toOptionalPromise$1.toOptionalPromisePartial = void 0;
const go_1$k = es2018$7;
const async_optional_1 = asyncOptional;
function toOptionalPromisePartial(isNone) {
return (promise) => toOptionalPromise(promise, isNone);
}
toOptionalPromise$1.toOptionalPromisePartial = toOptionalPromisePartial;
function toOptionalPromise(promise, isNone) {
return new async_optional_1.AsyncOptional(go_1$k.go(async () => {
const result = await promise;
if (isNone(result))
return async_optional_1.Nil;
return result;
}));
}
toOptionalPromise$1.toOptionalPromise = toOptionalPromise;
(function (exports) {
exports.toOptionalPromisePartial = exports.toOptionalPromise = exports.toOptionalAsyncPartial = exports.toOptionalAsync = exports.toOptionalPartial = exports.toOptional = exports.toResultPromise = exports.toResultAsync = exports.toResult = exports.getErrorAsyncIterable = exports.getErrorPromise = exports.getErrorAsync = exports.getError = exports.getResultPromise = exports.getResultAsync = exports.getResult = exports.isFailurePromise = exports.isFailureAsync = exports.isFailure = exports.isSuccessPromise = exports.isSuccessAsync = exports.isSuccess = exports.getFailurePromise = exports.getFailureAsync = exports.getFailure = exports.getSuccessPromise = exports.getSuccessAsync = exports.getSuccess = exports.getResultErrorPromise = exports.getResultErrorAsync = exports.getResultError = exports.getErrorResultPromise = exports.getErrorResultAsync = exports.getErrorResult = void 0;
var get_error_result_1 = getErrorResult$1;
Object.defineProperty(exports, "getErrorResult", { enumerable: true, get: function () { return get_error_result_1.getErrorResult; } });
var get_error_result_async_1 = getErrorResultAsync$1;
Object.defineProperty(exports, "getErrorResultAsync", { enumerable: true, get: function () { return get_error_result_async_1.getErrorResultAsync; } });
var get_error_result_promise_1 = getErrorResultPromise$1;
Object.defineProperty(exports, "getErrorResultPromise", { enumerable: true, get: function () { return get_error_result_promise_1.getErrorResultPromise; } });
var get_result_error_1 = getResultError$1;
Object.defineProperty(exports, "getResultError", { enumerable: true, get: function () { return get_result_error_1.getResultError; } });
var get_result_error_async_1 = getResultErrorAsync$1;
Object.defineProperty(exports, "getResultErrorAsync", { enumerable: true, get: function () { return get