@pulumi/query - npm Package Compare versions

Comparing version 0.2.0 to 0.3.0

asyncQueryable.js

@@ -15,15 +15,2 @@ "use strict";
 // limitations under the License.
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -37,29 +24,2 @@ return new (P || (P = Promise))(function (resolve, reject) {
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) 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 };
-    }
-};
 var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
@@ -84,20 +44,9 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 };
-var __values = (this && this.__values) || function (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 };
-        }
-    };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var base_1 = require("./base");
-var operators_1 = require("./operators");
-var sources_1 = require("./sources");
-var AsyncQueryableImpl = /** @class */ (function (_super) {
-    __extends(AsyncQueryableImpl, _super);
-    function AsyncQueryableImpl(source) {
-        return _super.call(this, source) || this;
+const base_1 = require("./base");
+const operators_1 = require("./operators");
+const sources_1 = require("./sources");
+class AsyncQueryableImpl extends base_1.IterableBase {
+    constructor(source) {
+        super(source);
     }
@@ -107,326 +56,228 @@ //
     //
-    AsyncQueryableImpl.from = function (source) {
+    static from(source) {
         return new AsyncQueryableImpl(sources_1.from(source));
-    };
+    }
     //
     // Restriction operators.
     //
-    AsyncQueryableImpl.prototype.filter = function (f) {
+    filter(f) {
         return this.pipe(operators_1.filter(f));
-    };
+    }
     //
     // Projection operators.
     //
-    AsyncQueryableImpl.prototype.flatMap = function (selector, resultSelector) {
-        if (resultSelector === void 0) { resultSelector = function (t, ti) {
-            return ti;
-        }; }
+    flatMap(selector, resultSelector = (t, ti) => ti) {
         return this.pipe(operators_1.flatMap(selector, resultSelector));
-    };
-    AsyncQueryableImpl.prototype.map = function (f) {
+    }
+    map(f) {
         return this.pipe(operators_1.map(f));
-    };
+    }
     //
     // Partitioning operators.
     //
-    AsyncQueryableImpl.prototype.skip = function (n) {
+    skip(n) {
         return this.pipe(operators_1.skip(n));
-    };
-    AsyncQueryableImpl.prototype.skipWhile = function (predicate) {
+    }
+    skipWhile(predicate) {
         return this.pipe(operators_1.skipWhile(predicate));
-    };
-    AsyncQueryableImpl.prototype.take = function (n) {
+    }
+    take(n) {
         return this.pipe(operators_1.take(n));
-    };
-    AsyncQueryableImpl.prototype.takeWhile = function (predicate) {
+    }
+    takeWhile(predicate) {
         return this.pipe(operators_1.takeWhile(predicate));
-    };
+    }
     //
     // Join operators.
     //
-    AsyncQueryableImpl.prototype.join = function (inner, outerKeySelector, innerKeySelector, resultSelector) {
+    join(inner, outerKeySelector, innerKeySelector, resultSelector) {
         return this.pipe(operators_1.join(sources_1.from(inner), outerKeySelector, innerKeySelector, resultSelector));
-    };
-    AsyncQueryableImpl.prototype.groupJoin = function (inner, outerKeySelector, innerKeySelector, resultSelector) {
+    }
+    groupJoin(inner, outerKeySelector, innerKeySelector, resultSelector) {
         return this.pipe(operators_1.groupJoin(sources_1.from(inner), outerKeySelector, innerKeySelector, resultSelector));
-    };
+    }
     //
     // Concatenation operators.
     //
-    AsyncQueryableImpl.prototype.concat = function (iter) {
+    concat(iter) {
         return this.pipe(operators_1.concat(sources_1.from(iter)));
-    };
+    }
     //
     // Ordering operators.
     //
-    AsyncQueryableImpl.prototype.reverse = function () {
+    reverse() {
         return this.pipe(operators_1.reverse());
-    };
-    AsyncQueryableImpl.prototype.orderBy = function (keySelector) {
+    }
+    orderBy(keySelector) {
         return this.pipe(operators_1.orderBy(keySelector));
-    };
-    AsyncQueryableImpl.prototype.orderByDescending = function (keySelector) {
+    }
+    orderByDescending(keySelector) {
         return this.pipe(operators_1.orderByDescending(keySelector));
-    };
+    }
     //
     // Grouping operators.
     //
-    AsyncQueryableImpl.prototype.groupBy = function (keySelector, elementSelector) {
+    groupBy(keySelector, elementSelector) {
         return this.pipe(function (source) {
-            return __asyncGenerator(this, arguments, function () {
-                var groups, groups_1, groups_1_1, group, e_1_1;
+            return __asyncGenerator(this, arguments, function* () {
                 var e_1, _a;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0: return [4 /*yield*/, __await(operators_1.groupBy(keySelector, elementSelector)(source))];
-                        case 1:
-                            groups = _b.sent();
-                            _b.label = 2;
-                        case 2:
-                            _b.trys.push([2, 9, 10, 15]);
-                            groups_1 = __asyncValues(groups);
-                            _b.label = 3;
-                        case 3: return [4 /*yield*/, __await(groups_1.next())];
-                        case 4:
-                            if (!(groups_1_1 = _b.sent(), !groups_1_1.done)) return [3 /*break*/, 8];
-                            group = groups_1_1.value;
-                            return [4 /*yield*/, __await(new GroupingImpl(group.key, sources_1.from(group)))];
-                        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 (!(groups_1_1 && !groups_1_1.done && (_a = groups_1.return))) return [3 /*break*/, 12];
-                            return [4 /*yield*/, __await(_a.call(groups_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 [2 /*return*/];
+                const groups = yield __await(operators_1.groupBy(keySelector, elementSelector)(source));
+                try {
+                    for (var groups_1 = __asyncValues(groups), groups_1_1; groups_1_1 = yield __await(groups_1.next()), !groups_1_1.done;) {
+                        const group = groups_1_1.value;
+                        yield yield __await(new GroupingImpl(group.key, sources_1.from(group)));
                     }
-                });
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (groups_1_1 && !groups_1_1.done && (_a = groups_1.return)) yield __await(_a.call(groups_1));
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
             });
         });
-    };
+    }
     //
     // Set operators.
     //
-    AsyncQueryableImpl.prototype.distinct = function () {
+    distinct() {
         return this.pipe(operators_1.distinct());
-    };
-    AsyncQueryableImpl.prototype.union = function (second) {
+    }
+    union(second) {
         return this.pipe(operators_1.union(sources_1.from(second)));
-    };
-    AsyncQueryableImpl.prototype.intersect = function (second) {
+    }
+    intersect(second) {
         return this.pipe(operators_1.intersect(sources_1.from(second)));
-    };
-    AsyncQueryableImpl.prototype.except = function (second) {
+    }
+    except(second) {
         return this.pipe(operators_1.except(sources_1.from(second)));
-    };
+    }
     //
     // Element operators.
     //
-    AsyncQueryableImpl.prototype.first = function (predicate) {
+    first(predicate) {
         return operators_1.first(predicate)(this);
-    };
-    AsyncQueryableImpl.prototype.firstOrDefault = function (defaultValue, predicate) {
+    }
+    firstOrDefault(defaultValue, predicate) {
         return operators_1.firstOrDefault(defaultValue, predicate)(this);
-    };
-    AsyncQueryableImpl.prototype.last = function (predicate) {
+    }
+    last(predicate) {
         return operators_1.last(predicate)(this);
-    };
-    AsyncQueryableImpl.prototype.lastOrDefault = function (defaultValue, predicate) {
+    }
+    lastOrDefault(defaultValue, predicate) {
         return operators_1.lastOrDefault(defaultValue, predicate)(this);
-    };
-    AsyncQueryableImpl.prototype.single = function (predicate) {
+    }
+    single(predicate) {
         return operators_1.single(predicate)(this);
-    };
-    AsyncQueryableImpl.prototype.singleOrDefault = function (defaultValue, predicate) {
+    }
+    singleOrDefault(defaultValue, predicate) {
         return operators_1.singleOrDefault(defaultValue, predicate)(this);
-    };
-    AsyncQueryableImpl.prototype.elementAt = function (index) {
+    }
+    elementAt(index) {
         return operators_1.elementAt(index)(this);
-    };
-    AsyncQueryableImpl.prototype.elementAtOrDefault = function (defaultValue, index) {
+    }
+    elementAtOrDefault(defaultValue, index) {
         return operators_1.elementAtOrDefault(defaultValue, index)(this);
-    };
-    AsyncQueryableImpl.prototype.defaultIfEmpty = function (defaultValue) {
+    }
+    defaultIfEmpty(defaultValue) {
         return this.pipe(operators_1.defaultIfEmpty(defaultValue));
-    };
+    }
     //
     // Quantifiers.
     //
-    AsyncQueryableImpl.prototype.any = function (predicate) {
+    any(predicate) {
         return operators_1.any(predicate)(this);
-    };
-    AsyncQueryableImpl.prototype.all = function (predicate) {
+    }
+    all(predicate) {
         return operators_1.all(predicate)(this);
-    };
-    AsyncQueryableImpl.prototype.contains = function (value) {
+    }
+    contains(value) {
         return operators_1.contains(value)(this);
-    };
+    }
     //
     // Aggregate operators.
     //
-    AsyncQueryableImpl.prototype.count = function (predicate) {
+    count(predicate) {
         return operators_1.count(predicate)(this);
-    };
-    AsyncQueryableImpl.prototype.sum = function (selector) {
+    }
+    sum(selector) {
         return operators_1.sum(selector)(this);
-    };
-    AsyncQueryableImpl.prototype.min = function (selector) {
+    }
+    min(selector) {
         return operators_1.min(selector)(this);
-    };
-    AsyncQueryableImpl.prototype.max = function (selector) {
+    }
+    max(selector) {
         return operators_1.max(selector)(this);
-    };
-    AsyncQueryableImpl.prototype.average = function (selector) {
+    }
+    average(selector) {
         return operators_1.average(selector)(this);
-    };
-    AsyncQueryableImpl.prototype.aggregate = function (seed, func) {
+    }
+    aggregate(seed, func) {
         return operators_1.aggregate(seed, func)(this);
-    };
+    }
     //
     // Eval operators.
     //
-    AsyncQueryableImpl.prototype.toArray = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, operators_1.toArray()(this)];
-            });
+    toArray() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return operators_1.toArray()(this);
         });
-    };
-    AsyncQueryableImpl.prototype.toMap = function (keySelector, elementSelector) {
+    }
+    toMap(keySelector, elementSelector) {
         return operators_1.toMap(keySelector, elementSelector)(this);
-    };
-    AsyncQueryableImpl.prototype.ofType = function (typeGuard) {
+    }
+    ofType(typeGuard) {
         return this.pipe(operators_1.ofType(typeGuard));
-    };
-    AsyncQueryableImpl.prototype.forEach = function (f) {
+    }
+    forEach(f) {
         var e_2, _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var _b, _c, t, e_2_1;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        _d.trys.push([0, 5, 6, 11]);
-                        _b = __asyncValues(this);
-                        _d.label = 1;
-                    case 1: return [4 /*yield*/, _b.next()];
-                    case 2:
-                        if (!(_c = _d.sent(), !_c.done)) return [3 /*break*/, 4];
-                        t = _c.value;
-                        f(t);
-                        _d.label = 3;
-                    case 3: return [3 /*break*/, 1];
-                    case 4: return [3 /*break*/, 11];
-                    case 5:
-                        e_2_1 = _d.sent();
-                        e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 11];
-                    case 6:
-                        _d.trys.push([6, , 9, 10]);
-                        if (!(_c && !_c.done && (_a = _b.return))) return [3 /*break*/, 8];
-                        return [4 /*yield*/, _a.call(_b)];
-                    case 7:
-                        _d.sent();
-                        _d.label = 8;
-                    case 8: return [3 /*break*/, 10];
-                    case 9:
-                        if (e_2) throw e_2.error;
-                        return [7 /*endfinally*/];
-                    case 10: return [7 /*endfinally*/];
-                    case 11: return [2 /*return*/];
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                for (var _b = __asyncValues(this), _c; _c = yield _b.next(), !_c.done;) {
+                    const t = _c.value;
+                    f(t);
                 }
-            });
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
         });
-    };
-    AsyncQueryableImpl.prototype.pipe = function () {
-        var ops = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            ops[_i] = arguments[_i];
-        }
+    }
+    pipe(...ops) {
         return new AsyncQueryableImpl((function (source) {
-            return __asyncGenerator(this, arguments, function () {
-                var newSource, ops_1, ops_1_1, op, newSource_1, newSource_1_1, t, e_3_1;
-                var e_4, _a;
-                var e_3, _b;
-                return __generator(this, function (_c) {
-                    switch (_c.label) {
-                        case 0:
-                            newSource = source;
-                            try {
-                                for (ops_1 = __values(ops), ops_1_1 = ops_1.next(); !ops_1_1.done; ops_1_1 = ops_1.next()) {
-                                    op = ops_1_1.value;
-                                    newSource = op(newSource);
-                                }
-                            }
-                            catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                            finally {
-                                try {
-                                    if (ops_1_1 && !ops_1_1.done && (_a = ops_1.return)) _a.call(ops_1);
-                                }
-                                finally { if (e_4) throw e_4.error; }
-                            }
-                            _c.label = 1;
-                        case 1:
-                            _c.trys.push([1, 8, 9, 14]);
-                            newSource_1 = __asyncValues(newSource);
-                            _c.label = 2;
-                        case 2: return [4 /*yield*/, __await(newSource_1.next())];
-                        case 3:
-                            if (!(newSource_1_1 = _c.sent(), !newSource_1_1.done)) return [3 /*break*/, 7];
-                            t = newSource_1_1.value;
-                            return [4 /*yield*/, __await(t)];
-                        case 4: return [4 /*yield*/, _c.sent()];
-                        case 5:
-                            _c.sent();
-                            _c.label = 6;
-                        case 6: return [3 /*break*/, 2];
-                        case 7: return [3 /*break*/, 14];
-                        case 8:
-                            e_3_1 = _c.sent();
-                            e_3 = { error: e_3_1 };
-                            return [3 /*break*/, 14];
-                        case 9:
-                            _c.trys.push([9, , 12, 13]);
-                            if (!(newSource_1_1 && !newSource_1_1.done && (_b = newSource_1.return))) return [3 /*break*/, 11];
-                            return [4 /*yield*/, __await(_b.call(newSource_1))];
-                        case 10:
-                            _c.sent();
-                            _c.label = 11;
-                        case 11: return [3 /*break*/, 13];
-                        case 12:
-                            if (e_3) throw e_3.error;
-                            return [7 /*endfinally*/];
-                        case 13: return [7 /*endfinally*/];
-                        case 14: return [2 /*return*/];
+            return __asyncGenerator(this, arguments, function* () {
+                var e_3, _a;
+                let newSource = source;
+                for (const op of ops) {
+                    newSource = op(newSource);
+                }
+                try {
+                    for (var newSource_1 = __asyncValues(newSource), newSource_1_1; newSource_1_1 = yield __await(newSource_1.next()), !newSource_1_1.done;) {
+                        const t = newSource_1_1.value;
+                        yield yield __await(t);
                     }
-                });
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (newSource_1_1 && !newSource_1_1.done && (_a = newSource_1.return)) yield __await(_a.call(newSource_1));
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
             });
         })(this));
-    };
-    return AsyncQueryableImpl;
-}(base_1.IterableBase));
+    }
+}
 exports.AsyncQueryableImpl = AsyncQueryableImpl;
-var GroupingImpl = /** @class */ (function (_super) {
-    __extends(GroupingImpl, _super);
-    function GroupingImpl(key, group) {
-        var _this = _super.call(this, group) || this;
-        _this.key = key;
-        return _this;
+class GroupingImpl extends AsyncQueryableImpl {
+    constructor(key, group) {
+        super(group);
+        this.key = key;
     }
-    return GroupingImpl;
-}(AsyncQueryableImpl));
+}
 exports.GroupingImpl = GroupingImpl;

base.js

@@ -15,38 +15,21 @@ "use strict";
 // limitations under the License.
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-var IterableBase = /** @class */ (function () {
-    function IterableBase(core) {
+class IterableBase {
+    constructor(core) {
         this.core = core;
     }
-    IterableBase.prototype[Symbol.asyncIterator] = function () {
+    [Symbol.asyncIterator]() {
         return this;
-    };
-    IterableBase.prototype.next = function (value) {
+    }
+    next(value) {
         return this.core.next(value);
-    };
-    return IterableBase;
-}());
+    }
+}
 exports.IterableBase = IterableBase;
-var GroupedAsyncIterableIteratorImpl = /** @class */ (function (_super) {
-    __extends(GroupedAsyncIterableIteratorImpl, _super);
-    function GroupedAsyncIterableIteratorImpl(key, core) {
-        var _this = _super.call(this, core) || this;
-        _this.key = key;
-        return _this;
+class GroupedAsyncIterableIteratorImpl extends IterableBase {
+    constructor(key, core) {
+        super(core);
+        this.key = key;
     }
-    return GroupedAsyncIterableIteratorImpl;
-}(IterableBase));
+}
 exports.GroupedAsyncIterableIteratorImpl = GroupedAsyncIterableIteratorImpl;

index.js

@@ -15,29 +15,2 @@ "use strict";
 // limitations under the License.
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) 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 };
-    }
-};
 var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
@@ -67,4 +40,4 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
 }
-var asyncQueryable_1 = require("./asyncQueryable");
-var sources = require("./sources");
+const asyncQueryable_1 = require("./asyncQueryable");
+const sources = require("./sources");
 /**
@@ -109,15 +82,6 @@ * Creates an `AsyncQueryable` from things that look `Iterable` or `AsyncIterable`, even if they're
     asyncQueryable_1.AsyncQueryableImpl.from((function () {
-        return __asyncGenerator(this, arguments, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!true) return [3 /*break*/, 3];
-                        return [4 /*yield*/, __await(t)];
-                    case 1: return [4 /*yield*/, _a.sent()];
-                    case 2:
-                        _a.sent();
-                        return [3 /*break*/, 0];
-                    case 3: return [2 /*return*/];
-                }
-            });
+        return __asyncGenerator(this, arguments, function* () {
+            while (true) {
+                yield yield __await(t);
+            }
         });
@@ -124,0 +88,0 @@ })());

interfaces.d.ts

@@ -0,1 +1,6 @@
+declare global {
+    interface SymbolConstructor {
+        readonly asyncIterator: symbol;
+    }
+}
 export interface AsyncIterator<T> {
@@ -2,0 +7,0 @@ next(value?: any): Promise<IteratorResult<T>>;

package.json

 {
     "name": "@pulumi/query",
-    "version": "v0.2.0",
+    "version": "v0.3.0",
     "description": "An simple, relational SDK for querying TypeScript and JavaScript data structures",
@@ -5,0 +5,0 @@ "license": "Apache-2.0",

sources.js

@@ -15,29 +15,2 @@ "use strict";
 // limitations under the License.
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) 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 };
-    }
-};
 var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
@@ -62,36 +35,14 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
 };
-var __values = (this && this.__values) || function (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 };
-        }
-    };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var interfaces_1 = require("./interfaces");
-var util_1 = require("./util");
+const interfaces_1 = require("./interfaces");
+const util_1 = require("./util");
 function range(start, end) {
-    return __asyncGenerator(this, arguments, function range_1() {
-        var i;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    i = start;
-                    _a.label = 1;
-                case 1:
-                    if (!true) return [3 /*break*/, 6];
-                    if (!(end !== undefined && i >= end)) return [3 /*break*/, 3];
-                    return [4 /*yield*/, __await(void 0)];
-                case 2: return [2 /*return*/, _a.sent()];
-                case 3: return [4 /*yield*/, __await(i++)];
-                case 4: return [4 /*yield*/, _a.sent()];
-                case 5:
-                    _a.sent();
-                    return [3 /*break*/, 1];
-                case 6: return [2 /*return*/];
+    return __asyncGenerator(this, arguments, function* range_1() {
+        let i = start;
+        while (true) {
+            if (end !== undefined && i >= end) {
+                return yield __await(void 0);
             }
-        });
+            yield yield __await(i++);
+        }
     });
@@ -101,82 +52,33 @@ }
 function from(source) {
-    return __asyncGenerator(this, arguments, function from_1() {
-        var iter, iter_1, iter_1_1, t, e_1_1, iter_2, iter_2_1, t, e_2_1;
+    return __asyncGenerator(this, arguments, function* from_1() {
         var e_1, _a;
-        var e_2, _b;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    if (!(util_1.isIterable(source) || interfaces_1.isAsyncIterable(source))) return [3 /*break*/, 1];
-                    iter = source;
-                    return [3 /*break*/, 3];
-                case 1: return [4 /*yield*/, __await(source)];
-                case 2:
-                    iter = _c.sent();
-                    _c.label = 3;
-                case 3:
-                    if (!util_1.isIterable(iter)) return [3 /*break*/, 13];
-                    _c.label = 4;
-                case 4:
-                    _c.trys.push([4, 10, 11, 12]);
-                    iter_1 = __values(iter), iter_1_1 = iter_1.next();
-                    _c.label = 5;
-                case 5:
-                    if (!!iter_1_1.done) return [3 /*break*/, 9];
-                    t = iter_1_1.value;
-                    return [4 /*yield*/, __await(t)];
-                case 6: return [4 /*yield*/, _c.sent()];
-                case 7:
-                    _c.sent();
-                    _c.label = 8;
-                case 8:
-                    iter_1_1 = iter_1.next();
-                    return [3 /*break*/, 5];
-                case 9: return [3 /*break*/, 12];
-                case 10:
-                    e_1_1 = _c.sent();
-                    e_1 = { error: e_1_1 };
-                    return [3 /*break*/, 12];
-                case 11:
-                    try {
-                        if (iter_1_1 && !iter_1_1.done && (_a = iter_1.return)) _a.call(iter_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                    return [7 /*endfinally*/];
-                case 12: return [3 /*break*/, 26];
-                case 13:
-                    _c.trys.push([13, 20, 21, 26]);
-                    iter_2 = __asyncValues(iter);
-                    _c.label = 14;
-                case 14: return [4 /*yield*/, __await(iter_2.next())];
-                case 15:
-                    if (!(iter_2_1 = _c.sent(), !iter_2_1.done)) return [3 /*break*/, 19];
-                    t = iter_2_1.value;
-                    return [4 /*yield*/, __await(t)];
-                case 16: return [4 /*yield*/, _c.sent()];
-                case 17:
-                    _c.sent();
-                    _c.label = 18;
-                case 18: return [3 /*break*/, 14];
-                case 19: return [3 /*break*/, 26];
-                case 20:
-                    e_2_1 = _c.sent();
-                    e_2 = { error: e_2_1 };
-                    return [3 /*break*/, 26];
-                case 21:
-                    _c.trys.push([21, , 24, 25]);
-                    if (!(iter_2_1 && !iter_2_1.done && (_b = iter_2.return))) return [3 /*break*/, 23];
-                    return [4 /*yield*/, __await(_b.call(iter_2))];
-                case 22:
-                    _c.sent();
-                    _c.label = 23;
-                case 23: return [3 /*break*/, 25];
-                case 24:
-                    if (e_2) throw e_2.error;
-                    return [7 /*endfinally*/];
-                case 25: return [7 /*endfinally*/];
-                case 26: return [2 /*return*/];
+        let iter;
+        if (util_1.isIterable(source) || interfaces_1.isAsyncIterable(source)) {
+            iter = source;
+        }
+        else {
+            iter = yield __await(source);
+        }
+        if (util_1.isIterable(iter)) {
+            for (const t of iter) {
+                yield yield __await(t);
             }
-        });
+        }
+        else {
+            try {
+                for (var iter_1 = __asyncValues(iter), iter_1_1; iter_1_1 = yield __await(iter_1.next()), !iter_1_1.done;) {
+                    const t = iter_1_1.value;
+                    yield yield __await(t);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (iter_1_1 && !iter_1_1.done && (_a = iter_1.return)) yield __await(_a.call(iter_1));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
     });
 }
 exports.from = from;

New alerts

Manifest confusion

Supply chain risk

This package has inconsistent metadata. This could be malicious or caused by an error when publishing the package.

Found 1 instance in 1 package

Fixed alerts

Manifest confusion

Supply chain risk

This package has inconsistent metadata. This could be malicious or caused by an error when publishing the package.

Found 1 instance in 1 package

Worsened metrics

Total package byte prevSize

174144

-51.74%

Lines of code

3475

-49.19%

No dependency changes