pubo-utils 1.0.129 → 1.0.142

package/es/emitter/index.js

@@ -1,171 +1,197 @@
-var __extends = this && this.__extends || function () {
-  var _extendStatics = function extendStatics(d, b) {
-    _extendStatics = Object.setPrototypeOf || {
-      __proto__: []
-    } instanceof Array && function (d, b) {
-      d.__proto__ = b;
-    } || function (d, b) {
-      for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
-    };
-    return _extendStatics(d, b);
-  };
-  return function (d, b) {
-    if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    _extendStatics(d, b);
-    function __() {
-      this.constructor = d;
+function _empty() {}
+function _awaitIgnored(value, direct) {
+  if (!direct) {
+    return value && value.then ? value.then(_empty) : Promise.resolve();
+  }
+}
+function _invokeIgnored(body) {
+  var result = body();
+  if (result && result.then) {
+    return result.then(_empty);
+  }
+}
+var _iteratorSymbol = /*#__PURE__*/typeof Symbol !== "undefined" ? Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator")) : "@@iterator";
+function _settle(pact, state, value) {
+  if (!pact.s) {
+    if (value instanceof _Pact) {
+      if (value.s) {
+        if (state & 1) {
+          state = value.s;
+        }
+        value = value.v;
+      } else {
+        value.o = _settle.bind(null, pact, state);
+        return;
+      }
     }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  };
-}();
-var __assign = this && this.__assign || function () {
-  __assign = Object.assign || function (t) {
-    for (var s, i = 1, n = arguments.length; i < n; i++) {
-      s = arguments[i];
-      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    if (value && value.then) {
+      value.then(_settle.bind(null, pact, state), _settle.bind(null, pact, 2));
+      return;
+    }
+    pact.s = state;
+    pact.v = value;
+    var observer = pact.o;
+    if (observer) {
+      observer(pact);
     }
-    return t;
-  };
-  return __assign.apply(this, arguments);
-};
-var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function (resolve) {
-      resolve(value);
-    });
   }
-  return new (P || (P = Promise))(function (resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
+}
+var _Pact = /*#__PURE__*/function () {
+  function _Pact() {}
+  _Pact.prototype.then = function (onFulfilled, onRejected) {
+    var result = new _Pact();
+    var state = this.s;
+    if (state) {
+      var callback = state & 1 ? onFulfilled : onRejected;
+      if (callback) {
+        try {
+          _settle(result, 1, callback(this.v));
+        } catch (e) {
+          _settle(result, 2, e);
+        }
+        return result;
+      } else {
+        return this;
       }
     }
-    function rejected(value) {
+    this.o = function (_this) {
       try {
-        step(generator["throw"](value));
+        var value = _this.v;
+        if (_this.s & 1) {
+          _settle(result, 1, onFulfilled ? onFulfilled(value) : value);
+        } else if (onRejected) {
+          _settle(result, 1, onRejected(value));
+        } else {
+          _settle(result, 2, value);
+        }
       } catch (e) {
-        reject(e);
+        _settle(result, 2, e);
       }
-    }
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-};
-var __generator = this && this.__generator || function (thisArg, body) {
-  var _ = {
-      label: 0,
-      sent: function sent() {
-        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 (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;
+    return result;
+  };
+  return _Pact;
+}();
+function _isSettledPact(thenable) {
+  return thenable instanceof _Pact && thenable.s & 1;
+}
+function _forTo(array, body, check) {
+  var i = -1,
+    pact,
+    reject;
+  function _cycle(result) {
+    try {
+      while (++i < array.length && (!check || !check())) {
+        result = body(i);
+        if (result && result.then) {
+          if (_isSettledPact(result)) {
+            result = result.v;
+          } else {
+            result.then(_cycle, reject || (reject = _settle.bind(null, pact = new _Pact(), 2)));
+            return;
           }
-          if (t[2]) _.ops.pop();
-          _.trys.pop();
-          continue;
+        }
+      }
+      if (pact) {
+        _settle(pact, 1, result);
+      } else {
+        pact = result;
       }
-      op = body.call(thisArg, _);
     } catch (e) {
-      op = [6, e];
-      y = 0;
-    } finally {
-      f = t = 0;
+      _settle(pact || (pact = new _Pact()), 2, e);
     }
-    if (op[0] & 5) throw op[1];
-    return {
-      value: op[0] ? op[1] : void 0,
-      done: true
-    };
   }
-};
-var __values = this && this.__values || function (o) {
-  var s = typeof Symbol === "function" && Symbol.iterator,
-    m = s && o[s],
-    i = 0;
-  if (m) return m.call(o);
-  if (o && typeof o.length === "number") return {
-    next: function next() {
-      if (o && i >= o.length) o = void 0;
-      return {
-        value: o && o[i++],
-        done: !o
+  _cycle();
+  return pact;
+}
+function _forOf(target, body, check) {
+  if (typeof target[_iteratorSymbol] === "function") {
+    var _cycle = function _cycle(result) {
+      try {
+        while (!(step = iterator.next()).done && (!check || !check())) {
+          result = body(step.value);
+          if (result && result.then) {
+            if (_isSettledPact(result)) {
+              result = result.v;
+            } else {
+              result.then(_cycle, reject || (reject = _settle.bind(null, pact = new _Pact(), 2)));
+              return;
+            }
+          }
+        }
+        if (pact) {
+          _settle(pact, 1, result);
+        } else {
+          pact = result;
+        }
+      } catch (e) {
+        _settle(pact || (pact = new _Pact()), 2, e);
+      }
+    };
+    var iterator = target[_iteratorSymbol](),
+      step,
+      pact,
+      reject;
+    _cycle();
+    if (iterator["return"]) {
+      var _fixup = function _fixup(value) {
+        try {
+          if (!step.done) {
+            iterator["return"]();
+          }
+        } catch (e) {}
+        return value;
       };
+      if (pact && pact.then) {
+        return pact.then(_fixup, function (e) {
+          throw _fixup(e);
+        });
+      }
+      _fixup();
     }
-  };
-  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
+    return pact;
+  }
+  // No support for Symbol.iterator
+  if (!("length" in target)) {
+    throw new TypeError("Object is not iterable");
+  }
+  // Handle live collections properly
+  var values = [];
+  for (var i = 0; i < target.length; i++) {
+    values.push(target[i]);
+  }
+  return _forTo(values, function (i) {
+    return body(values[i]);
+  }, check);
+}
+function _continueIgnored(value) {
+  if (value && value.then) {
+    return value.then(_empty);
+  }
+}
+function _await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(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(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(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; }
 import { random } from '../random';
-var Emitter = /** @class */function () {
+export var Emitter = /*#__PURE__*/function () {
   function Emitter() {
     this.state = {};
     this.ids = {};
   }
-  Emitter.prototype.on = function (event, func) {
+  var _proto = Emitter.prototype;
+  _proto.on = function on(event, func) {
     if (!this.state[event]) {
       this.state[event] = [];
     }
@@ -180,15 +206,15 @@ var Emitter = /** @class */function () {
     };
     return key;
   };
-  Emitter.prototype.cancel = function (id) {
+  _proto.cancel = function cancel(id) {
     var _this = this;
     if (!id) {
       this.clear();
       return;
     }
-    var _a = this.ids[id] || {},
-      event = _a.event,
-      index = _a.index;
+    var _ref = this.ids[id] || {},
+      event = _ref.event,
+      index = _ref.index;
     if (!event) {
       return;
     }
@@ -203,105 +229,67 @@ var Emitter = /** @class */function () {
       }
     });
   };
-  Emitter.prototype.clear = function () {
+  _proto.clear = function clear() {
     this.state.length = 0;
   };
-  Emitter.prototype.emit = function (event, payload) {
-    var e_1, _a;
+  _proto.emit = function emit(event, payload) {
     if (Array.isArray(this.state[event])) {
-      try {
-        for (var _b = __values(this.state[event]), _c = _b.next(); !_c.done; _c = _b.next()) {
-          var func = _c.value;
-          if (typeof func === 'function') {
-            func(payload);
-          }
-        }
-      } catch (e_1_1) {
-        e_1 = {
-          error: e_1_1
-        };
-      } finally {
-        try {
-          if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
-        } finally {
-          if (e_1) throw e_1.error;
+      for (var _iterator = _createForOfIteratorHelperLoose(this.state[event]), _step; !(_step = _iterator()).done;) {
+        var func = _step.value;
+        if (typeof func === 'function') {
+          func(payload);
         }
       }
     }
   };
-  Emitter.prototype.emitSync = function (event, payload) {
-    return __awaiter(this, void 0, void 0, function () {
-      var _a, _b, func, e_2_1;
-      var e_2, _c;
-      return __generator(this, function (_d) {
-        switch (_d.label) {
-          case 0:
-            if (!Array.isArray(this.state[event])) return [3 /*break*/, 8];
-            _d.label = 1;
-          case 1:
-            _d.trys.push([1, 6, 7, 8]);
-            _a = __values(this.state[event]), _b = _a.next();
-            _d.label = 2;
-          case 2:
-            if (!!_b.done) return [3 /*break*/, 5];
-            func = _b.value;
-            if (!(typeof func === 'function')) return [3 /*break*/, 4];
-            return [4 /*yield*/, func(payload)];
-          case 3:
-            _d.sent();
-            _d.label = 4;
-          case 4:
-            _b = _a.next();
-            return [3 /*break*/, 2];
-          case 5:
-            return [3 /*break*/, 8];
-          case 6:
-            e_2_1 = _d.sent();
-            e_2 = {
-              error: e_2_1
-            };
-            return [3 /*break*/, 8];
-          case 7:
-            try {
-              if (_b && !_b.done && (_c = _a["return"])) _c.call(_a);
-            } finally {
-              if (e_2) throw e_2.error;
-            }
-            return [7 /*endfinally*/];
-          case 8:
-            return [2 /*return*/];
+  _proto.emitSync = function emitSync(event, payload) {
+    try {
+      var _this2 = this;
+      return _await(_invokeIgnored(function () {
+        if (Array.isArray(_this2.state[event])) {
+          return _continueIgnored(_forOf(_this2.state[event], function (func) {
+            return _invokeIgnored(function () {
+              if (typeof func === 'function') {
+                return _awaitIgnored(func(payload));
+              }
+            });
+          }));
         }
-      });
-    });
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
   };
-
-  Emitter.prototype.clone = function () {
+  _proto.clone = function clone() {
     return {
-      state: __assign({}, this.state),
-      ids: __assign({}, this.ids)
+      state: _extends({}, this.state),
+      ids: _extends({}, this.ids)
     };
   };
-  Emitter.prototype.restore = function (snapshot) {
+  _proto.restore = function restore(snapshot) {
     this.state = snapshot.state;
     this.ids = snapshot.ids;
   };
   return Emitter;
 }();
-export { Emitter };
-var CacheEmitter = /** @class */function (_super) {
-  __extends(CacheEmitter, _super);
+export var CacheEmitter = /*#__PURE__*/function (_Emitter) {
+  _inheritsLoose(CacheEmitter, _Emitter);
   function CacheEmitter() {
-    var _this = _super !== null && _super.apply(this, arguments) || this;
-    _this._cache = {};
-    return _this;
+    var _this3;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this3 = _Emitter.call.apply(_Emitter, [this].concat(args)) || this;
+    _this3._cache = {};
+    return _this3;
   }
-  CacheEmitter.prototype.emit = function (event, payload) {
+  var _proto2 = CacheEmitter.prototype;
+  _proto2.emit = function emit(event, payload) {
     this._cache[event] = payload;
-    _super.prototype.emit.call(this, event, payload);
+    _Emitter.prototype.emit.call(this, event, payload);
   };
-  CacheEmitter.prototype.getState = function (event) {
+  _proto2.getState = function getState(event) {
     return this._cache[event];
   };
   return CacheEmitter;
-}(Emitter);
-export { CacheEmitter };
+}(Emitter);

package/es/factory/index.js

@@ -1,19 +1,3 @@
-var __values = this && this.__values || function (o) {
-  var s = typeof Symbol === "function" && Symbol.iterator,
-    m = s && o[s],
-    i = 0;
-  if (m) return m.call(o);
-  if (o && typeof o.length === "number") return {
-    next: function next() {
-      if (o && i >= o.length) o = void 0;
-      return {
-        value: o && o[i++],
-        done: !o
-      };
-    }
-  };
-  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 /**
  * Creates a factory function that takes another factory function and returns a new function that creates a product object based on the options passed in.
  *
@@ -22,23 +6,10 @@ var __values = this && this.__values || function (o) {
  */
 export var superFactory = function superFactory(factory) {
   return function (options) {
-    var e_1, _a;
     var product = {};
-    try {
-      for (var _b = __values(Object.keys(options)), _c = _b.next(); !_c.done; _c = _b.next()) {
-        var key = _c.value;
-        product[key] = factory(options[key], key);
-      }
-    } catch (e_1_1) {
-      e_1 = {
-        error: e_1_1
-      };
-    } finally {
-      try {
-        if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
-      } finally {
-        if (e_1) throw e_1.error;
-      }
+    for (var _i = 0, _Object$keys = Object.keys(options); _i < _Object$keys.length; _i++) {
+      var key = _Object$keys[_i];
+      product[key] = factory(options[key], key);
     }
     return product;
   };