async-constructor
Version:
The helper functions for creating classes that require asynchronous constructors.
1,586 lines (1,453 loc) • 302 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.AsyncConstructor = {}));
})(this, (function (exports) { 'use strict';
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