ts-async-iterable-queue - npm Package Compare versions

Comparing version 2.1.0 to 3.0.0

dist/lib/createPushAsyncIterable.js

 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __generator = (this && this.__generator) || function (thisArg, body) {
@@ -49,47 +57,127 @@ var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
 Object.defineProperty(exports, "__esModule", { value: true });
-var createAsyncQueue_1 = require("./createAsyncQueue");
-function createPushAsyncIterable(subscriber) {
+var createPromiseResolver_1 = require("./createPromiseResolver");
+var createQueue_1 = require("./createQueue");
+/* istanbul ignore next */
+function createPushAsyncIterable(sub) {
     return __asyncGenerator(this, arguments, function createPushAsyncIterable_1() {
-        var e_1, _a, q, unsubscriptions, q_1, q_1_1, x, e_1_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var _a, e_1, _b, pullQueue, pushQueue, done, pushValue, pullValue, completionHandlers, complete, error, unsubscribe, it, it_1, it_1_1, x, e_1_1;
+        var _this = this;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
                 case 0:
-                    q = createAsyncQueue_1.createAsyncQueue();
-                    unsubscriptions = [];
-                    subscriber({
-                        next: q.enqueue,
-                        complete: q.complete,
-                        error: q.error,
-                        addCompletionHandler: function (handler) { return unsubscriptions.push(handler); }
-                    });
-                    _b.label = 1;
+                    pullQueue = createQueue_1.createQueue();
+                    pushQueue = createQueue_1.createQueue();
+                    done = false;
+                    pushValue = function (item) { return __awaiter(_this, void 0, void 0, function () {
+                        var resolver;
+                        return __generator(this, function (_a) {
+                            if (pullQueue.length > 0) {
+                                resolver = pullQueue.dequeue();
+                                resolver.resolve({ done: false, value: item });
+                            }
+                            else {
+                                pushQueue.enqueue(Promise.resolve({ done: false, value: item }));
+                            }
+                            return [2 /*return*/];
+                        });
+                    }); };
+                    pullValue = function () { return __awaiter(_this, void 0, void 0, function () {
+                        var item, resolver;
+                        return __generator(this, function (_a) {
+                            if (pushQueue.length > 0) {
+                                item = pushQueue.dequeue();
+                                return [2 /*return*/, item];
+                            }
+                            else {
+                                resolver = createPromiseResolver_1.createPromiseResolver();
+                                pullQueue.enqueue(resolver);
+                                return [2 /*return*/, resolver.promise];
+                            }
+                            return [2 /*return*/];
+                        });
+                    }); };
+                    completionHandlers = [];
+                    complete = function (val, immediate) {
+                        if (immediate === void 0) { immediate = false; }
+                        done = true;
+                        unsubscribe();
+                        if (immediate) {
+                            while (pullQueue.length > 0) {
+                                var x = pullQueue.dequeue();
+                                x.resolve({ done: done, value: val });
+                            }
+                        }
+                        else {
+                            pushQueue.enqueue(Promise.resolve({ done: done, value: val }));
+                        }
+                    };
+                    error = function (reason, immediate) {
+                        if (immediate === void 0) { immediate = false; }
+                        done = true;
+                        unsubscribe();
+                        if (immediate) {
+                            while (pullQueue.length > 0) {
+                                var x = pullQueue.dequeue();
+                                x.reject(reason);
+                            }
+                        }
+                        else {
+                            pushQueue.enqueue(Promise.reject(reason));
+                        }
+                    };
+                    unsubscribe = function () {
+                        done = true;
+                        completionHandlers.forEach(function (c) { return c(); });
+                    };
+                    sub({ next: pushValue, complete: complete, error: error, addCompletionHandler: function (h) { return completionHandlers.push(h); } });
+                    it = (_a = {},
+                        _a[Symbol.asyncIterator] = function () {
+                            return this;
+                        },
+                        _a.next = function () { return pullValue(); },
+                        _a.return = function (val) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                done = true;
+                                complete(val, true);
+                                return [2 /*return*/, { done: done }];
+                            });
+                        }); },
+                        _a.throw = function (reason) {
+                            done = true;
+                            error(reason, true);
+                            return Promise.resolve({
+                                done: done
+                            });
+                        },
+                        _a);
+                    _c.label = 1;
                 case 1:
-                    _b.trys.push([1, , 16, 17]);
-                    _b.label = 2;
+                    _c.trys.push([1, , 16, 17]);
+                    _c.label = 2;
                 case 2:
-                    _b.trys.push([2, 9, 10, 15]);
-                    q_1 = __asyncValues(q);
-                    _b.label = 3;
-                case 3: return [4 /*yield*/, __await(q_1.next())];
+                    _c.trys.push([2, 9, 10, 15]);
+                    it_1 = __asyncValues(it);
+                    _c.label = 3;
+                case 3: return [4 /*yield*/, __await(it_1.next())];
                 case 4:
-                    if (!(q_1_1 = _b.sent(), !q_1_1.done)) return [3 /*break*/, 8];
-                    x = q_1_1.value;
+                    if (!(it_1_1 = _c.sent(), !it_1_1.done)) return [3 /*break*/, 8];
+                    x = it_1_1.value;
                     return [4 /*yield*/, __await(x)];
-                case 5: return [4 /*yield*/, _b.sent()];
+                case 5: return [4 /*yield*/, _c.sent()];
                 case 6:
-                    _b.sent();
-                    _b.label = 7;
+                    _c.sent();
+                    _c.label = 7;
                 case 7: return [3 /*break*/, 3];
                 case 8: return [3 /*break*/, 15];
                 case 9:
-                    e_1_1 = _b.sent();
+                    e_1_1 = _c.sent();
                     e_1 = { error: e_1_1 };
                     return [3 /*break*/, 15];
                 case 10:
-                    _b.trys.push([10, , 13, 14]);
-                    if (!(q_1_1 && !q_1_1.done && (_a = q_1.return))) return [3 /*break*/, 12];
-                    return [4 /*yield*/, __await(_a.call(q_1))];
+                    _c.trys.push([10, , 13, 14]);
+                    if (!(it_1_1 && !it_1_1.done && (_b = it_1.return))) return [3 /*break*/, 12];
+                    return [4 /*yield*/, __await(_b.call(it_1))];
                 case 11:
-                    _b.sent();
-                    _b.label = 12;
+                    _c.sent();
+                    _c.label = 12;
                 case 12: return [3 /*break*/, 14];
@@ -102,3 +190,3 @@ case 13:
                 case 16:
-                    unsubscriptions.forEach(function (f) { return f(); });
+                    unsubscribe();
                     return [7 /*endfinally*/];
@@ -105,0 +193,0 @@ case 17: return [2 /*return*/];

dist/lib/ts-async-iterable-queue.js

@@ -8,4 +8,2 @@ "use strict";
 }
-var createAsyncQueue_1 = require("./createAsyncQueue");
-exports.createAsyncQueue = createAsyncQueue_1.createAsyncQueue;
 var createQueue_1 = require("./createQueue");
@@ -12,0 +10,0 @@ exports.createQueue = createQueue_1.createQueue;

dist/ts-async-iterable-queue.es5.js

@@ -0,1 +1,33 @@
+function createQueue(trimLimit) {
+    if (trimLimit === void 0) { trimLimit = 10000; }
+    var store = [];
+    var front = 0;
+    var end = 0;
+    var enqueue = function (data) {
+        store[end] = data;
+        end++;
+    };
+    var dequeue = function () {
+        if (front === end)
+            return undefined;
+        var data = store[front];
+        delete store[front];
+        ++front;
+        if (front > trimLimit) {
+            store.splice(0, trimLimit);
+            front -= trimLimit;
+            end -= trimLimit;
+        }
+        return data;
+    };
+    var length = function () { return end - front; };
+    return {
+        enqueue: enqueue,
+        dequeue: dequeue,
+        get length() {
+            return length();
+        }
+    };
+}
+
 /*! *****************************************************************************
@@ -102,171 +134,125 @@ Copyright (c) Microsoft Corporation. All rights reserved.
 
-function createQueue(trimLimit) {
-    if (trimLimit === void 0) { trimLimit = 10000; }
-    var store = [];
-    var front = 0;
-    var end = 0;
-    var enqueue = function (data) {
-        store[end] = data;
-        end++;
-    };
-    var dequeue = function () {
-        if (front === end)
-            return undefined;
-        var data = store[front];
-        delete store[front];
-        ++front;
-        if (front > trimLimit) {
-            store.splice(0, trimLimit);
-            front -= trimLimit;
-            end -= trimLimit;
-        }
-        return data;
-    };
-    var length = function () { return end - front; };
-    return {
-        enqueue: enqueue,
-        dequeue: dequeue,
-        get length() {
-            return length();
-        }
-    };
-}
-
-function createAsyncQueue() {
-    var _this = this;
-    var _a;
-    var pendingResolvers = createQueue();
-    var resultsWaitingForResolvers = createQueue();
-    var next = function () {
-        var pr = createPromiseResolver();
-        if (resultsWaitingForResolvers.length > 0) {
-            var f = resultsWaitingForResolvers.dequeue();
-            f.resolve(pr);
-        }
-        else {
-            pendingResolvers.enqueue(pr);
-        }
-        return pr.promise;
-    };
-    var dequeue = function () { return __awaiter(_this, void 0, void 0, function () {
-        var result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, next()];
-                case 1:
-                    result = _a.sent();
-                    if (result.done) {
-                        throw Error('queue is complete');
-                    }
-                    return [2 /*return*/, result.value];
-            }
-        });
-    }); };
-    var getNextResultResolver = function () { return __awaiter(_this, void 0, void 0, function () {
-        var resolver, pr;
-        return __generator(this, function (_a) {
-            if (pendingResolvers.length > 0) {
-                resolver = pendingResolvers.dequeue();
-                return [2 /*return*/, resolver];
-            }
-            else {
-                pr = createPromiseResolver();
-                resultsWaitingForResolvers.enqueue(pr);
-                return [2 /*return*/, pr.promise];
-            }
-            return [2 /*return*/];
-        });
-    }); };
-    var enqueue = function (value) { return __awaiter(_this, void 0, void 0, function () {
-        var resolveResult;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getNextResultResolver()];
-                case 1:
-                    resolveResult = _a.sent();
-                    resolveResult.resolve({ value: value, done: false });
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    var complete = function () { return __awaiter(_this, void 0, void 0, function () {
-        var resolveResult;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getNextResultResolver()];
-                case 1:
-                    resolveResult = _a.sent();
-                    resolveResult.resolve({ done: true });
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    var error = function (reason) { return __awaiter(_this, void 0, void 0, function () {
-        var resolveResult;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getNextResultResolver()];
-                case 1:
-                    resolveResult = _a.sent();
-                    resolveResult.reject(reason);
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    return _a = {},
-        _a[Symbol.asyncIterator] = function () {
-            return this;
-        },
-        _a.next = next,
-        _a.dequeue = dequeue,
-        _a.enqueue = enqueue,
-        _a.complete = complete,
-        _a.error = error,
-        _a;
-}
-
-function createPushAsyncIterable(subscriber) {
+/* istanbul ignore next */
+function createPushAsyncIterable(sub) {
     return __asyncGenerator(this, arguments, function createPushAsyncIterable_1() {
-        var e_1, _a, q, unsubscriptions, q_1, q_1_1, x, e_1_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var _a, e_1, _b, pullQueue, pushQueue, done, pushValue, pullValue, completionHandlers, complete, error, unsubscribe, it, it_1, it_1_1, x, e_1_1;
+        var _this = this;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
                 case 0:
-                    q = createAsyncQueue();
-                    unsubscriptions = [];
-                    subscriber({
-                        next: q.enqueue,
-                        complete: q.complete,
-                        error: q.error,
-                        addCompletionHandler: function (handler) { return unsubscriptions.push(handler); }
-                    });
-                    _b.label = 1;
+                    pullQueue = createQueue();
+                    pushQueue = createQueue();
+                    done = false;
+                    pushValue = function (item) { return __awaiter(_this, void 0, void 0, function () {
+                        var resolver;
+                        return __generator(this, function (_a) {
+                            if (pullQueue.length > 0) {
+                                resolver = pullQueue.dequeue();
+                                resolver.resolve({ done: false, value: item });
+                            }
+                            else {
+                                pushQueue.enqueue(Promise.resolve({ done: false, value: item }));
+                            }
+                            return [2 /*return*/];
+                        });
+                    }); };
+                    pullValue = function () { return __awaiter(_this, void 0, void 0, function () {
+                        var item, resolver;
+                        return __generator(this, function (_a) {
+                            if (pushQueue.length > 0) {
+                                item = pushQueue.dequeue();
+                                return [2 /*return*/, item];
+                            }
+                            else {
+                                resolver = createPromiseResolver();
+                                pullQueue.enqueue(resolver);
+                                return [2 /*return*/, resolver.promise];
+                            }
+                            return [2 /*return*/];
+                        });
+                    }); };
+                    completionHandlers = [];
+                    complete = function (val, immediate) {
+                        if (immediate === void 0) { immediate = false; }
+                        done = true;
+                        unsubscribe();
+                        if (immediate) {
+                            while (pullQueue.length > 0) {
+                                var x = pullQueue.dequeue();
+                                x.resolve({ done: done, value: val });
+                            }
+                        }
+                        else {
+                            pushQueue.enqueue(Promise.resolve({ done: done, value: val }));
+                        }
+                    };
+                    error = function (reason, immediate) {
+                        if (immediate === void 0) { immediate = false; }
+                        done = true;
+                        unsubscribe();
+                        if (immediate) {
+                            while (pullQueue.length > 0) {
+                                var x = pullQueue.dequeue();
+                                x.reject(reason);
+                            }
+                        }
+                        else {
+                            pushQueue.enqueue(Promise.reject(reason));
+                        }
+                    };
+                    unsubscribe = function () {
+                        done = true;
+                        completionHandlers.forEach(function (c) { return c(); });
+                    };
+                    sub({ next: pushValue, complete: complete, error: error, addCompletionHandler: function (h) { return completionHandlers.push(h); } });
+                    it = (_a = {},
+                        _a[Symbol.asyncIterator] = function () {
+                            return this;
+                        },
+                        _a.next = function () { return pullValue(); },
+                        _a.return = function (val) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                done = true;
+                                complete(val, true);
+                                return [2 /*return*/, { done: done }];
+                            });
+                        }); },
+                        _a.throw = function (reason) {
+                            done = true;
+                            error(reason, true);
+                            return Promise.resolve({
+                                done: done
+                            });
+                        },
+                        _a);
+                    _c.label = 1;
                 case 1:
-                    _b.trys.push([1, , 16, 17]);
-                    _b.label = 2;
+                    _c.trys.push([1, , 16, 17]);
+                    _c.label = 2;
                 case 2:
-                    _b.trys.push([2, 9, 10, 15]);
-                    q_1 = __asyncValues(q);
-                    _b.label = 3;
-                case 3: return [4 /*yield*/, __await(q_1.next())];
+                    _c.trys.push([2, 9, 10, 15]);
+                    it_1 = __asyncValues(it);
+                    _c.label = 3;
+                case 3: return [4 /*yield*/, __await(it_1.next())];
                 case 4:
-                    if (!(q_1_1 = _b.sent(), !q_1_1.done)) return [3 /*break*/, 8];
-                    x = q_1_1.value;
+                    if (!(it_1_1 = _c.sent(), !it_1_1.done)) return [3 /*break*/, 8];
+                    x = it_1_1.value;
                     return [4 /*yield*/, __await(x)];
-                case 5: return [4 /*yield*/, _b.sent()];
+                case 5: return [4 /*yield*/, _c.sent()];
                 case 6:
-                    _b.sent();
-                    _b.label = 7;
+                    _c.sent();
+                    _c.label = 7;
                 case 7: return [3 /*break*/, 3];
                 case 8: return [3 /*break*/, 15];
                 case 9:
-                    e_1_1 = _b.sent();
+                    e_1_1 = _c.sent();
                     e_1 = { error: e_1_1 };
                     return [3 /*break*/, 15];
                 case 10:
-                    _b.trys.push([10, , 13, 14]);
-                    if (!(q_1_1 && !q_1_1.done && (_a = q_1.return))) return [3 /*break*/, 12];
-                    return [4 /*yield*/, __await(_a.call(q_1))];
+                    _c.trys.push([10, , 13, 14]);
+                    if (!(it_1_1 && !it_1_1.done && (_b = it_1.return))) return [3 /*break*/, 12];
+                    return [4 /*yield*/, __await(_b.call(it_1))];
                 case 11:
-                    _b.sent();
-                    _b.label = 12;
+                    _c.sent();
+                    _c.label = 12;
                 case 12: return [3 /*break*/, 14];
@@ -279,3 +265,3 @@ case 13:
                 case 16:
-                    unsubscriptions.forEach(function (f) { return f(); });
+                    unsubscribe();
                     return [7 /*endfinally*/];
@@ -294,3 +280,3 @@ case 17: return [2 /*return*/];
 
-export { createAsyncQueue, createPromiseResolver, createPushAsyncIterable, createQueue };
+export { createPromiseResolver, createPushAsyncIterable, createQueue };
 //# sourceMappingURL=ts-async-iterable-queue.es5.js.map

dist/ts-async-iterable-queue.umd.js

 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = global || self, factory(global.tsAsyncIterableQueue = {}));
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = global || self, factory(global.tsAsyncIterableQueue = {}));
 }(this, function (exports) { 'use strict';
 
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation. All rights reserved.
-    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-    this file except in compliance with the License. You may obtain a copy of the
-    License at http://www.apache.org/licenses/LICENSE-2.0
+  function createQueue(trimLimit) {
+      if (trimLimit === void 0) { trimLimit = 10000; }
+      var store = [];
+      var front = 0;
+      var end = 0;
+      var enqueue = function (data) {
+          store[end] = data;
+          end++;
+      };
+      var dequeue = function () {
+          if (front === end)
+              return undefined;
+          var data = store[front];
+          delete store[front];
+          ++front;
+          if (front > trimLimit) {
+              store.splice(0, trimLimit);
+              front -= trimLimit;
+              end -= trimLimit;
+          }
+          return data;
+      };
+      var length = function () { return end - front; };
+      return {
+          enqueue: enqueue,
+          dequeue: dequeue,
+          get length() {
+              return length();
+          }
+      };
+  }
 
-    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-    MERCHANTABLITY OR NON-INFRINGEMENT.
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation. All rights reserved.
+  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of the
+  License at http://www.apache.org/licenses/LICENSE-2.0
 
-    See the Apache Version 2.0 License for specific language governing permissions
-    and limitations under the License.
-    ***************************************************************************** */
+  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+  MERCHANTABLITY OR NON-INFRINGEMENT.
 
-    function __awaiter(thisArg, _arguments, P, generator) {
-        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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-            step((generator = generator.apply(thisArg, _arguments || [])).next());
-        });
-    }
+  See the Apache Version 2.0 License for specific language governing permissions
+  and limitations under the License.
+  ***************************************************************************** */
 
-    function __generator(thisArg, body) {
-        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-        function verb(n) { return function (v) { return step([n, v]); }; }
-        function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (_) 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 };
-        }
-    }
+  function __awaiter(thisArg, _arguments, P, generator) {
+      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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+  }
 
-    function __values(o) {
-        var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
-        if (m) return m.call(o);
-        return {
-            next: function () {
-                if (o && i >= o.length) o = void 0;
-                return { value: o && o[i++], done: !o };
-            }
-        };
-    }
+  function __generator(thisArg, body) {
+      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+      function verb(n) { return function (v) { return step([n, v]); }; }
+      function step(op) {
+          if (f) throw new TypeError("Generator is already executing.");
+          while (_) 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 };
+      }
+  }
 
-    function __await(v) {
-        return this instanceof __await ? (this.v = v, this) : new __await(v);
-    }
+  function __values(o) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+      if (m) return m.call(o);
+      return {
+          next: function () {
+              if (o && i >= o.length) o = void 0;
+              return { value: o && o[i++], done: !o };
+          }
+      };
+  }
 
-    function __asyncGenerator(thisArg, _arguments, generator) {
-        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-        var g = generator.apply(thisArg, _arguments || []), i, q = [];
-        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-        function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
-        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-        function fulfill(value) { resume("next", value); }
-        function reject(value) { resume("throw", value); }
-        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-    }
+  function __await(v) {
+      return this instanceof __await ? (this.v = v, this) : new __await(v);
+  }
 
-    function __asyncValues(o) {
-        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-        var m = o[Symbol.asyncIterator], i;
-        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-    }
+  function __asyncGenerator(thisArg, _arguments, generator) {
+      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+      var g = generator.apply(thisArg, _arguments || []), i, q = [];
+      return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+      function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+      function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+      function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+      function fulfill(value) { resume("next", value); }
+      function reject(value) { resume("throw", value); }
+      function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+  }
 
-    var createPromiseResolver = function () {
-        var resolve = null;
-        var reject = null;
-        var promise = new Promise(function (res, rej) {
-            resolve = res;
-            reject = rej;
-        });
-        return {
-            resolve: resolve,
-            reject: reject,
-            promise: promise
-        };
-    };
+  function __asyncValues(o) {
+      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+      var m = o[Symbol.asyncIterator], i;
+      return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+      function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+      function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+  }
 
-    function createQueue(trimLimit) {
-        if (trimLimit === void 0) { trimLimit = 10000; }
-        var store = [];
-        var front = 0;
-        var end = 0;
-        var enqueue = function (data) {
-            store[end] = data;
-            end++;
-        };
-        var dequeue = function () {
-            if (front === end)
-                return undefined;
-            var data = store[front];
-            delete store[front];
-            ++front;
-            if (front > trimLimit) {
-                store.splice(0, trimLimit);
-                front -= trimLimit;
-                end -= trimLimit;
-            }
-            return data;
-        };
-        var length = function () { return end - front; };
-        return {
-            enqueue: enqueue,
-            dequeue: dequeue,
-            get length() {
-                return length();
-            }
-        };
-    }
+  var createPromiseResolver = function () {
+      var resolve = null;
+      var reject = null;
+      var promise = new Promise(function (res, rej) {
+          resolve = res;
+          reject = rej;
+      });
+      return {
+          resolve: resolve,
+          reject: reject,
+          promise: promise
+      };
+  };
 
-    function createAsyncQueue() {
-        var _this = this;
-        var _a;
-        var pendingResolvers = createQueue();
-        var resultsWaitingForResolvers = createQueue();
-        var next = function () {
-            var pr = createPromiseResolver();
-            if (resultsWaitingForResolvers.length > 0) {
-                var f = resultsWaitingForResolvers.dequeue();
-                f.resolve(pr);
-            }
-            else {
-                pendingResolvers.enqueue(pr);
-            }
-            return pr.promise;
-        };
-        var dequeue = function () { return __awaiter(_this, void 0, void 0, function () {
-            var result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, next()];
-                    case 1:
-                        result = _a.sent();
-                        if (result.done) {
-                            throw Error('queue is complete');
-                        }
-                        return [2 /*return*/, result.value];
-                }
-            });
-        }); };
-        var getNextResultResolver = function () { return __awaiter(_this, void 0, void 0, function () {
-            var resolver, pr;
-            return __generator(this, function (_a) {
-                if (pendingResolvers.length > 0) {
-                    resolver = pendingResolvers.dequeue();
-                    return [2 /*return*/, resolver];
-                }
-                else {
-                    pr = createPromiseResolver();
-                    resultsWaitingForResolvers.enqueue(pr);
-                    return [2 /*return*/, pr.promise];
-                }
-                return [2 /*return*/];
-            });
-        }); };
-        var enqueue = function (value) { return __awaiter(_this, void 0, void 0, function () {
-            var resolveResult;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, getNextResultResolver()];
-                    case 1:
-                        resolveResult = _a.sent();
-                        resolveResult.resolve({ value: value, done: false });
-                        return [2 /*return*/];
-                }
-            });
-        }); };
-        var complete = function () { return __awaiter(_this, void 0, void 0, function () {
-            var resolveResult;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, getNextResultResolver()];
-                    case 1:
-                        resolveResult = _a.sent();
-                        resolveResult.resolve({ done: true });
-                        return [2 /*return*/];
-                }
-            });
-        }); };
-        var error = function (reason) { return __awaiter(_this, void 0, void 0, function () {
-            var resolveResult;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, getNextResultResolver()];
-                    case 1:
-                        resolveResult = _a.sent();
-                        resolveResult.reject(reason);
-                        return [2 /*return*/];
-                }
-            });
-        }); };
-        return _a = {},
-            _a[Symbol.asyncIterator] = function () {
-                return this;
-            },
-            _a.next = next,
-            _a.dequeue = dequeue,
-            _a.enqueue = enqueue,
-            _a.complete = complete,
-            _a.error = error,
-            _a;
-    }
+  /* istanbul ignore next */
+  function createPushAsyncIterable(sub) {
+      return __asyncGenerator(this, arguments, function createPushAsyncIterable_1() {
+          var _a, e_1, _b, pullQueue, pushQueue, done, pushValue, pullValue, completionHandlers, complete, error, unsubscribe, it, it_1, it_1_1, x, e_1_1;
+          var _this = this;
+          return __generator(this, function (_c) {
+              switch (_c.label) {
+                  case 0:
+                      pullQueue = createQueue();
+                      pushQueue = createQueue();
+                      done = false;
+                      pushValue = function (item) { return __awaiter(_this, void 0, void 0, function () {
+                          var resolver;
+                          return __generator(this, function (_a) {
+                              if (pullQueue.length > 0) {
+                                  resolver = pullQueue.dequeue();
+                                  resolver.resolve({ done: false, value: item });
+                              }
+                              else {
+                                  pushQueue.enqueue(Promise.resolve({ done: false, value: item }));
+                              }
+                              return [2 /*return*/];
+                          });
+                      }); };
+                      pullValue = function () { return __awaiter(_this, void 0, void 0, function () {
+                          var item, resolver;
+                          return __generator(this, function (_a) {
+                              if (pushQueue.length > 0) {
+                                  item = pushQueue.dequeue();
+                                  return [2 /*return*/, item];
+                              }
+                              else {
+                                  resolver = createPromiseResolver();
+                                  pullQueue.enqueue(resolver);
+                                  return [2 /*return*/, resolver.promise];
+                              }
+                              return [2 /*return*/];
+                          });
+                      }); };
+                      completionHandlers = [];
+                      complete = function (val, immediate) {
+                          if (immediate === void 0) { immediate = false; }
+                          done = true;
+                          unsubscribe();
+                          if (immediate) {
+                              while (pullQueue.length > 0) {
+                                  var x = pullQueue.dequeue();
+                                  x.resolve({ done: done, value: val });
+                              }
+                          }
+                          else {
+                              pushQueue.enqueue(Promise.resolve({ done: done, value: val }));
+                          }
+                      };
+                      error = function (reason, immediate) {
+                          if (immediate === void 0) { immediate = false; }
+                          done = true;
+                          unsubscribe();
+                          if (immediate) {
+                              while (pullQueue.length > 0) {
+                                  var x = pullQueue.dequeue();
+                                  x.reject(reason);
+                              }
+                          }
+                          else {
+                              pushQueue.enqueue(Promise.reject(reason));
+                          }
+                      };
+                      unsubscribe = function () {
+                          done = true;
+                          completionHandlers.forEach(function (c) { return c(); });
+                      };
+                      sub({ next: pushValue, complete: complete, error: error, addCompletionHandler: function (h) { return completionHandlers.push(h); } });
+                      it = (_a = {},
+                          _a[Symbol.asyncIterator] = function () {
+                              return this;
+                          },
+                          _a.next = function () { return pullValue(); },
+                          _a.return = function (val) { return __awaiter(_this, void 0, void 0, function () {
+                              return __generator(this, function (_a) {
+                                  done = true;
+                                  complete(val, true);
+                                  return [2 /*return*/, { done: done }];
+                              });
+                          }); },
+                          _a.throw = function (reason) {
+                              done = true;
+                              error(reason, true);
+                              return Promise.resolve({
+                                  done: done
+                              });
+                          },
+                          _a);
+                      _c.label = 1;
+                  case 1:
+                      _c.trys.push([1, , 16, 17]);
+                      _c.label = 2;
+                  case 2:
+                      _c.trys.push([2, 9, 10, 15]);
+                      it_1 = __asyncValues(it);
+                      _c.label = 3;
+                  case 3: return [4 /*yield*/, __await(it_1.next())];
+                  case 4:
+                      if (!(it_1_1 = _c.sent(), !it_1_1.done)) return [3 /*break*/, 8];
+                      x = it_1_1.value;
+                      return [4 /*yield*/, __await(x)];
+                  case 5: return [4 /*yield*/, _c.sent()];
+                  case 6:
+                      _c.sent();
+                      _c.label = 7;
+                  case 7: return [3 /*break*/, 3];
+                  case 8: return [3 /*break*/, 15];
+                  case 9:
+                      e_1_1 = _c.sent();
+                      e_1 = { error: e_1_1 };
+                      return [3 /*break*/, 15];
+                  case 10:
+                      _c.trys.push([10, , 13, 14]);
+                      if (!(it_1_1 && !it_1_1.done && (_b = it_1.return))) return [3 /*break*/, 12];
+                      return [4 /*yield*/, __await(_b.call(it_1))];
+                  case 11:
+                      _c.sent();
+                      _c.label = 12;
+                  case 12: return [3 /*break*/, 14];
+                  case 13:
+                      if (e_1) throw e_1.error;
+                      return [7 /*endfinally*/];
+                  case 14: return [7 /*endfinally*/];
+                  case 15: return [3 /*break*/, 17];
+                  case 16:
+                      unsubscribe();
+                      return [7 /*endfinally*/];
+                  case 17: return [2 /*return*/];
+              }
+          });
+      });
+  }
 
-    function createPushAsyncIterable(subscriber) {
-        return __asyncGenerator(this, arguments, function createPushAsyncIterable_1() {
-            var e_1, _a, q, unsubscriptions, q_1, q_1_1, x, e_1_1;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        q = createAsyncQueue();
-                        unsubscriptions = [];
-                        subscriber({
-                            next: q.enqueue,
-                            complete: q.complete,
-                            error: q.error,
-                            addCompletionHandler: function (handler) { return unsubscriptions.push(handler); }
-                        });
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, , 16, 17]);
-                        _b.label = 2;
-                    case 2:
-                        _b.trys.push([2, 9, 10, 15]);
-                        q_1 = __asyncValues(q);
-                        _b.label = 3;
-                    case 3: return [4 /*yield*/, __await(q_1.next())];
-                    case 4:
-                        if (!(q_1_1 = _b.sent(), !q_1_1.done)) return [3 /*break*/, 8];
-                        x = q_1_1.value;
-                        return [4 /*yield*/, __await(x)];
-                    case 5: return [4 /*yield*/, _b.sent()];
-                    case 6:
-                        _b.sent();
-                        _b.label = 7;
-                    case 7: return [3 /*break*/, 3];
-                    case 8: return [3 /*break*/, 15];
-                    case 9:
-                        e_1_1 = _b.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 15];
-                    case 10:
-                        _b.trys.push([10, , 13, 14]);
-                        if (!(q_1_1 && !q_1_1.done && (_a = q_1.return))) return [3 /*break*/, 12];
-                        return [4 /*yield*/, __await(_a.call(q_1))];
-                    case 11:
-                        _b.sent();
-                        _b.label = 12;
-                    case 12: return [3 /*break*/, 14];
-                    case 13:
-                        if (e_1) throw e_1.error;
-                        return [7 /*endfinally*/];
-                    case 14: return [7 /*endfinally*/];
-                    case 15: return [3 /*break*/, 17];
-                    case 16:
-                        unsubscriptions.forEach(function (f) { return f(); });
-                        return [7 /*endfinally*/];
-                    case 17: return [2 /*return*/];
-                }
-            });
-        });
-    }
+  /* istanbul ignore if */
+  if (!Symbol.asyncIterator) {
+      var aiKey = 'asyncIterator';
+      Symbol[aiKey] = Symbol.for('Symbol.asyncIterator');
+  }
 
-    /* istanbul ignore if */
-    if (!Symbol.asyncIterator) {
-        var aiKey = 'asyncIterator';
-        Symbol[aiKey] = Symbol.for('Symbol.asyncIterator');
-    }
+  exports.createPromiseResolver = createPromiseResolver;
+  exports.createPushAsyncIterable = createPushAsyncIterable;
+  exports.createQueue = createQueue;
 
-    exports.createAsyncQueue = createAsyncQueue;
-    exports.createPromiseResolver = createPromiseResolver;
-    exports.createPushAsyncIterable = createPushAsyncIterable;
-    exports.createQueue = createQueue;
+  Object.defineProperty(exports, '__esModule', { value: true });
 
-    Object.defineProperty(exports, '__esModule', { value: true });
-
 }));
 //# sourceMappingURL=ts-async-iterable-queue.umd.js.map

dist/types/createPushAsyncIterable.d.ts

 import { Subscription } from './Subscription';
-export declare function createPushAsyncIterable<T>(subscriber: (s: Subscription<T>) => void): AsyncIterableIterator<T>;
+export declare function createPushAsyncIterable<T>(sub: (subscription: Subscription<T>) => void): AsyncIterable<T>;

dist/types/Subscription.d.ts

 export interface Subscription<T> {
     next: (item: T) => void;
-    complete: () => void;
-    error: (reason: any) => void;
+    complete: (value?: any, immediate?: boolean) => void;
+    error: (reason?: any, immediate?: boolean) => void;
     addCompletionHandler: (handler: () => void) => void;
 }

dist/types/ts-async-iterable-queue.d.ts

@@ -1,3 +0,1 @@
-export { createAsyncQueue } from './createAsyncQueue';
-export { AsyncIterableQueue } from './AsyncIterableQueue';
 export { createQueue, Queue } from './createQueue';
@@ -4,0 +2,0 @@ export { createPushAsyncIterable } from './createPushAsyncIterable';

package.json

 {
   "name": "ts-async-iterable-queue",
-  "version": "2.1.0",
+  "version": "3.0.0",
   "description": "",
@@ -5,0 +5,0 @@ "keywords": [],

No alert changes

Worsened metrics

Total package byte prevSize

68296

decreased by-0.91%

Number of package files

25

decreased by-19.35%

Lines of code

828

decreased by-9.31%

No dependency changes