@wener/utils 1.1.51 → 1.1.54

package/lib/asyncs/createAsyncIterator.js

@@ -1,41 +1,331 @@
-import { createLazyPromise } from './createLazyPromise.js';
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length)
+        len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr))
+        return arr;
+}
+function _async_generator(gen) {
+    var front, back;
+    function send(key, arg) {
+        return new Promise(function (resolve, reject) {
+            var request = {
+                key: key,
+                arg: arg,
+                resolve: resolve,
+                reject: reject,
+                next: null
+            };
+            if (back)
+                back = back.next = request;
+            else {
+                front = back = request;
+                resume(key, arg);
+            }
+        });
+    }
+    function resume(key, arg) {
+        try {
+            var result = gen[key](arg);
+            var value = result.value;
+            var overloaded = value instanceof _overload_yield;
+            Promise.resolve(overloaded ? value.v : value).then(function (arg) {
+                if (overloaded) {
+                    var nextKey = key === "return" ? "return" : "next";
+                    if (!value.k || arg.done)
+                        return resume(nextKey, arg);
+                    else
+                        arg = gen[nextKey](arg).value;
+                }
+                settle(result.done ? "return" : "normal", arg);
+            }, function (err) {
+                resume("throw", err);
+            });
+        }
+        catch (err) {
+            settle("throw", err);
+        }
+    }
+    function settle(type, value) {
+        switch (type) {
+            case "return":
+                front.resolve({
+                    value: value,
+                    done: true
+                });
+                break;
+            case "throw":
+                front.reject(value);
+                break;
+            default:
+                front.resolve({
+                    value: value,
+                    done: false
+                });
+                break;
+        }
+        front = front.next;
+        if (front)
+            resume(front.key, front.arg);
+        else
+            back = null;
+    }
+    this._invoke = send;
+    if (typeof gen.return !== "function")
+        this.return = undefined;
+}
+_async_generator.prototype[typeof Symbol === "function" && Symbol.asyncIterator || "@@asyncIterator"] = function () {
+    return this;
+};
+_async_generator.prototype.next = function (arg) {
+    return this._invoke("next", arg);
+};
+_async_generator.prototype.throw = function (arg) {
+    return this._invoke("throw", arg);
+};
+_async_generator.prototype.return = function (arg) {
+    return this._invoke("return", arg);
+};
+function _await_async_generator(value) {
+    return new _overload_yield(value, 0);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null)
+        return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+            _arr.push(_s.value);
+            if (i && _arr.length === i)
+                break;
+        }
+    }
+    catch (err) {
+        _d = true;
+        _e = err;
+    }
+    finally {
+        try {
+            if (!_n && _i["return"] != null)
+                _i["return"]();
+        }
+        finally {
+            if (_d)
+                throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _overload_yield(value, kind) {
+    this.v = value;
+    this.k = kind;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o)
+        return;
+    if (typeof o === "string")
+        return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor)
+        n = o.constructor.name;
+    if (n === "Map" || n === "Set")
+        return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _array_like_to_array(o, minLen);
+}
+function _wrap_async_generator(fn) {
+    return function () {
+        return new _async_generator(fn.apply(this, arguments));
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function () {
+            if (t[0] & 1)
+                throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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
+        };
+    }
+}
+import { createLazyPromise } from "./createLazyPromise.js";
 export function createAsyncIterator(fn) {
-    const values = [];
-    let recv;
+    var values = [];
+    var recv;
     {
-        let next;
+        var next;
         values.push(next = createLazyPromise());
-        recv = (val, err)=>{
+        recv = function (val, err) {
             if (err !== undefined) {
                 next.resolve([
                     undefined,
                     true,
                     err
                 ]);
-            } else if (val !== undefined) {
+            }
+            else if (val !== undefined) {
                 next.resolve(val);
-            } else {
+            }
+            else {
                 return;
             }
             values.push(next = createLazyPromise());
         };
     }
     fn(recv);
-    return async function*() {
-        let value;
-        let err;
-        for(let i = 0, done = false; !done; i++){
-            let result = await values[i];
-            delete values[i];
-            [value, done, err] = result;
-            if (err) {
-                throw err;
-            }
-            if (value !== undefined) {
-                yield value;
-            }
-        }
+    return function () {
+        return _wrap_async_generator(function () {
+            var value, err, i, done, result, ref;
+            return _ts_generator(this, function (_state) {
+                switch (_state.label) {
+                    case 0:
+                        i = 0, done = false;
+                        _state.label = 1;
+                    case 1:
+                        if (!!done)
+                            return [
+                                3,
+                                5
+                            ];
+                        return [
+                            4,
+                            _await_async_generator(values[i])
+                        ];
+                    case 2:
+                        result = _state.sent();
+                        delete values[i];
+                        ref = _sliced_to_array(result, 3), value = ref[0], done = ref[1], err = ref[2], ref;
+                        if (err) {
+                            throw err;
+                        }
+                        if (!(value !== undefined))
+                            return [
+                                3,
+                                4
+                            ];
+                        return [
+                            4,
+                            value
+                        ];
+                    case 3:
+                        _state.sent();
+                        _state.label = 4;
+                    case 4:
+                        i++;
+                        return [
+                            3,
+                            1
+                        ];
+                    case 5:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
     }();
 }
-
-//# sourceMappingURL=createAsyncIterator.js.map

package/lib/asyncs/createLazyPromise.js

@@ -1,73 +1,114 @@
-import { isPromise } from './isPromise.js';
-import { Promises } from './Promises.js';
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length)
+        len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr))
+        return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+        return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o)
+        return;
+    if (typeof o === "string")
+        return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor)
+        n = o.constructor.name;
+    if (n === "Map" || n === "Set")
+        return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _array_like_to_array(o, minLen);
+}
+import { isPromise } from "./isPromise.js";
+import { Promises } from "./Promises.js";
 /**
  * createLazyPromise return a promise that can be resolved or rejected manually.
  * if you pass a function to it, it will be executed when the promise try to resolve.
  */ export function createLazyPromise(executor) {
-    const { promise, resolve, reject } = Promises.withResolvers();
-    const lazy = Object.assign(promise, {
-        resolve,
-        reject
+    var _lazy_finally;
+    var _Promises_withResolvers = Promises.withResolvers(), promise = _Promises_withResolvers.promise, resolve = _Promises_withResolvers.resolve, reject = _Promises_withResolvers.reject;
+    var lazy = Object.assign(promise, {
+        resolve: resolve,
+        reject: reject
     });
-    let executed = false;
-    let pending = true;
-    let status = 'pending';
-    let value;
-    let error;
-    const _resolve = (v)=>{
+    var executed = false;
+    var pending = true;
+    var status = "pending";
+    var value;
+    var error;
+    var _resolve = function (v) {
         resolve(v);
-        if (!pending) return;
+        if (!pending)
+            return;
         pending = false;
         // do not delay this for sync status peek
-        status = 'resolved';
+        status = "resolved";
         value = v;
     };
-    const _reject = (v)=>{
+    var _reject = function (v) {
         reject(v);
-        if (!pending) return;
+        if (!pending)
+            return;
         pending = false;
-        status = 'rejected';
+        status = "rejected";
         error = v;
     };
-    const like = Object.assign({
-        get status () {
+    var like = Object.assign({
+        get status() {
             return status;
         },
-        get value () {
+        get value() {
             return value;
         },
-        get error () {
+        get error() {
             return error;
         }
     }, {
         cache: lazy.catch.bind(lazy),
-        finally: lazy.finally?.bind(lazy),
+        finally: (_lazy_finally = lazy.finally) === null || _lazy_finally === void 0 ? void 0 : _lazy_finally.bind(lazy),
         resolve: _resolve,
         reject: _reject,
-        then: (...args)=>{
+        then: function () {
+            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+                args[_key] = arguments[_key];
+            }
+            var _lazy;
             if (executor && !executed) {
                 executed = true;
                 try {
-                    const result = executor(_resolve, _reject);
+                    var result = executor(_resolve, _reject);
                     // ensure resolve/reject is called
                     if (isPromise(result)) {
                         result.then(_resolve, _reject);
-                    } else if (result !== undefined) {
+                    }
+                    else if (result !== undefined) {
                         _resolve(result);
                     }
-                } catch (e) {
+                }
+                catch (e) {
                     _reject(e);
                 }
             }
-            return lazy.then(...args);
+            return (_lazy = lazy).then.apply(_lazy, _to_consumable_array(args));
         }
     });
-    if ('toStringTag' in Symbol) {
+    if ("toStringTag" in Symbol) {
         Object.defineProperty(like, Symbol.toStringTag, {
-            value: 'LazyPromise'
+            value: "LazyPromise"
         });
     }
     return like;
 }
-
-//# sourceMappingURL=createLazyPromise.js.map