@difizen/libro-common 0.0.2-alpha.0

package/es/polling/poll.js

@@ -0,0 +1,501 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _Symbol$asyncIterator;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return exports; }; var exports = {}, Op = Object.prototype, hasOwn = Op.hasOwnProperty, defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; }, $Symbol = "function" == typeof Symbol ? Symbol : {}, iteratorSymbol = $Symbol.iterator || "@@iterator", asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; function define(obj, key, value) { return Object.defineProperty(obj, key, { value: value, enumerable: !0, configurable: !0, writable: !0 }), obj[key]; } try { define({}, ""); } catch (err) { define = function define(obj, key, value) { return obj[key] = value; }; } function wrap(innerFn, outerFn, self, tryLocsList) { var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, generator = Object.create(protoGenerator.prototype), context = new Context(tryLocsList || []); return defineProperty(generator, "_invoke", { value: makeInvokeMethod(innerFn, self, context) }), generator; } function tryCatch(fn, obj, arg) { try { return { type: "normal", arg: fn.call(obj, arg) }; } catch (err) { return { type: "throw", arg: err }; } } exports.wrap = wrap; var ContinueSentinel = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var IteratorPrototype = {}; define(IteratorPrototype, iteratorSymbol, function () { return this; }); var getProto = Object.getPrototypeOf, NativeIteratorPrototype = getProto && getProto(getProto(values([]))); NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); function defineIteratorMethods(prototype) { ["next", "throw", "return"].forEach(function (method) { define(prototype, method, function (arg) { return this._invoke(method, arg); }); }); } function AsyncIterator(generator, PromiseImpl) { function invoke(method, arg, resolve, reject) { var record = tryCatch(generator[method], generator, arg); if ("throw" !== record.type) { var result = record.arg, value = result.value; return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) { invoke("next", value, resolve, reject); }, function (err) { invoke("throw", err, resolve, reject); }) : PromiseImpl.resolve(value).then(function (unwrapped) { result.value = unwrapped, resolve(result); }, function (error) { return invoke("throw", error, resolve, reject); }); } reject(record.arg); } var previousPromise; defineProperty(this, "_invoke", { value: function value(method, arg) { function callInvokeWithMethodAndArg() { return new PromiseImpl(function (resolve, reject) { invoke(method, arg, resolve, reject); }); } return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(innerFn, self, context) { var state = "suspendedStart"; return function (method, arg) { if ("executing" === state) throw new Error("Generator is already running"); if ("completed" === state) { if ("throw" === method) throw arg; return doneResult(); } for (context.method = method, context.arg = arg;;) { var delegate = context.delegate; if (delegate) { var delegateResult = maybeInvokeDelegate(delegate, context); if (delegateResult) { if (delegateResult === ContinueSentinel) continue; return delegateResult; } } if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) { if ("suspendedStart" === state) throw state = "completed", context.arg; context.dispatchException(context.arg); } else "return" === context.method && context.abrupt("return", context.arg); state = "executing"; var record = tryCatch(innerFn, self, context); if ("normal" === record.type) { if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue; return { value: record.arg, done: context.done }; } "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg); } }; } function maybeInvokeDelegate(delegate, context) { var methodName = context.method, method = delegate.iterator[methodName]; if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel; var record = tryCatch(method, delegate.iterator, context.arg); if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel; var info = record.arg; return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel); } function pushTryEntry(locs) { var entry = { tryLoc: locs[0] }; 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); } function resetTryEntry(entry) { var record = entry.completion || {}; record.type = "normal", delete record.arg, entry.completion = record; } function Context(tryLocsList) { this.tryEntries = [{ tryLoc: "root" }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0); } function values(iterable) { if (iterable) { var iteratorMethod = iterable[iteratorSymbol]; if (iteratorMethod) return iteratorMethod.call(iterable); if ("function" == typeof iterable.next) return iterable; if (!isNaN(iterable.length)) { var i = -1, next = function next() { for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; return next.value = undefined, next.done = !0, next; }; return next.next = next; } } return { next: doneResult }; } function doneResult() { return { value: undefined, done: !0 }; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", { value: GeneratorFunctionPrototype, configurable: !0 }), defineProperty(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) { var ctor = "function" == typeof genFun && genFun.constructor; return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name)); }, exports.mark = function (genFun) { return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun; }, exports.awrap = function (arg) { return { __await: arg }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { return this; }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { void 0 === PromiseImpl && (PromiseImpl = Promise); var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { return result.done ? result.value : iter.next(); }); }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () { return this; }), define(Gp, "toString", function () { return "[object Generator]"; }), exports.keys = function (val) { var object = Object(val), keys = []; for (var key in object) keys.push(key); return keys.reverse(), function next() { for (; keys.length;) { var key = keys.pop(); if (key in object) return next.value = key, next.done = !1, next; } return next.done = !0, next; }; }, exports.values = values, Context.prototype = { constructor: Context, reset: function reset(skipTempReset) { if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined); }, stop: function stop() { this.done = !0; var rootRecord = this.tryEntries[0].completion; if ("throw" === rootRecord.type) throw rootRecord.arg; return this.rval; }, dispatchException: function dispatchException(exception) { if (this.done) throw exception; var context = this; function handle(loc, caught) { return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught; } for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i], record = entry.completion; if ("root" === entry.tryLoc) return handle("end"); if (entry.tryLoc <= this.prev) { var hasCatch = hasOwn.call(entry, "catchLoc"), hasFinally = hasOwn.call(entry, "finallyLoc"); if (hasCatch && hasFinally) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } else if (hasCatch) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); } else { if (!hasFinally) throw new Error("try statement without catch or finally"); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } } } }, abrupt: function abrupt(type, arg) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { var finallyEntry = entry; break; } } finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); var record = finallyEntry ? finallyEntry.completion : {}; return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); }, complete: function complete(record, afterLoc) { if ("throw" === record.type) throw record.arg; return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; }, finish: function finish(finallyLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; } }, catch: function _catch(tryLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc === tryLoc) { var record = entry.completion; if ("throw" === record.type) { var thrown = record.arg; resetTryEntry(entry); } return thrown; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(iterable, resultName, nextLoc) { return this.delegate = { iterator: values(iterable), resultName: resultName, nextLoc: nextLoc }, "next" === this.method && (this.arg = undefined), ContinueSentinel; } }, exports; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _awaitAsyncGenerator(value) { return new _OverloadYield(value, 0); }
+function _wrapAsyncGenerator(fn) { return function () { return new _AsyncGenerator(fn.apply(this, arguments)); }; }
+function _AsyncGenerator(gen) { var front, back; function resume(key, arg) { try { var result = gen[key](arg), value = result.value, overloaded = value instanceof _OverloadYield; Promise.resolve(overloaded ? value.v : value).then(function (arg) { if (overloaded) { var nextKey = "return" === key ? "return" : "next"; if (!value.k || arg.done) return resume(nextKey, arg); arg = gen[nextKey](arg).value; } settle(result.done ? "return" : "normal", arg); }, function (err) { resume("throw", err); }); } catch (err) { settle("throw", err); } } function settle(type, value) { switch (type) { case "return": front.resolve({ value: value, done: !0 }); break; case "throw": front.reject(value); break; default: front.resolve({ value: value, done: !1 }); } (front = front.next) ? resume(front.key, front.arg) : back = null; } this._invoke = function (key, arg) { return new Promise(function (resolve, reject) { var request = { key: key, arg: arg, resolve: resolve, reject: reject, next: null }; back ? back = back.next = request : (front = back = request, resume(key, arg)); }); }, "function" != typeof gen.return && (this.return = void 0); }
+_AsyncGenerator.prototype["function" == typeof Symbol && Symbol.asyncIterator || "@@asyncIterator"] = function () { return this; }, _AsyncGenerator.prototype.next = function (arg) { return this._invoke("next", arg); }, _AsyncGenerator.prototype.throw = function (arg) { return this._invoke("throw", arg); }, _AsyncGenerator.prototype.return = function (arg) { return this._invoke("return", arg); };
+function _OverloadYield(value, kind) { this.v = value, this.k = kind; }
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/* eslint-disable no-param-reassign */
+/* eslint-disable @typescript-eslint/no-namespace */
+
+import { Emitter, Deferred } from '@difizen/mana-common';
+import { deepEqual } from "../json.js";
+_Symbol$asyncIterator = Symbol.asyncIterator;
+/**
+ * A class that wraps an asynchronous function to poll at a regular interval
+ * with exponential increases to the interval length if the poll fails.
+ *
+ * @typeparam T - The resolved type of the factory's promises.
+ * Defaults to `any`.
+ *
+ * @typeparam U - The rejected type of the factory's promises.
+ * Defaults to `any`.
+ *
+ * @typeparam V - An optional type to extend the phases supported by a poll.
+ * Defaults to `standby`, which already exists in the `Phase` type.
+ */
+export var Poll = /*#__PURE__*/function () {
+  /**
+   * Instantiate a new poll with exponential backoff in case of failure.
+   *
+   * @param options - The poll instantiation options.
+   */
+  function Poll(options) {
+    var _this2 = this;
+    _classCallCheck(this, Poll);
+    this.disposeEmitter = new Emitter();
+    this._tick = new Deferred();
+    this.tickedEmitter = new Emitter();
+    // Support node and browser.
+    this.disposed = false;
+    var frequency = options.frequency || {};
+    var max = Math.max(frequency.interval || 0, frequency.max || 0, Private.DEFAULT_FREQUENCY.max);
+    this._frequency = _objectSpread(_objectSpread(_objectSpread({}, Private.DEFAULT_FREQUENCY), frequency), {
+      max: max
+    });
+    this._factory = options.factory;
+    this._standby = options.standby || Private.DEFAULT_STANDBY;
+    this._state = _objectSpread(_objectSpread({}, Private.DEFAULT_STATE), {}, {
+      timestamp: new Date().getTime()
+    });
+
+    // Normalize poll frequency `max` to be the greater of
+    // default `max`, `options.frequency.max`, or `options.frequency.interval`.
+
+    this.name = options.name || Private.DEFAULT_NAME;
+    if ('auto' in options ? options.auto : true) {
+      setTimeout(function () {
+        return _this2.start();
+      });
+    }
+  }
+
+  /**
+   * The name of the poll.
+   */
+  _createClass(Poll, [{
+    key: "onDispose",
+    get:
+    /**
+     * A signal emitted when the poll is disposed.
+     */
+    function get() {
+      return this.disposeEmitter.event;
+    }
+
+    /**
+     * The polling frequency parameters.
+     */
+  }, {
+    key: "frequency",
+    get: function get() {
+      return this._frequency;
+    },
+    set: function set(frequency) {
+      if (this.isDisposed || deepEqual(frequency, this.frequency || {})) {
+        return;
+      }
+      var interval = frequency.interval,
+        max = frequency.max;
+      var backoff = frequency.backoff;
+      interval = Math.round(interval);
+      max = Math.round(max);
+      if (typeof backoff === 'number' && backoff < 1) {
+        throw new Error('Poll backoff growth factor must be at least 1');
+      }
+      if ((interval < 0 || interval > max) && interval !== Poll.NEVER) {
+        throw new Error('Poll interval must be between 0 and max');
+      }
+      if (max > Poll.MAX_INTERVAL && max !== Poll.NEVER) {
+        throw new Error("Max interval must be less than ".concat(Poll.MAX_INTERVAL));
+      }
+      this._frequency = {
+        backoff: backoff,
+        interval: interval,
+        max: max
+      };
+    }
+
+    /**
+     * Whether the poll is disposed.
+     */
+  }, {
+    key: "isDisposed",
+    get: function get() {
+      return this.state.phase === 'disposed';
+    }
+
+    /**
+     * Indicates when the poll switches to standby.
+     */
+  }, {
+    key: "standby",
+    get: function get() {
+      return this._standby;
+    },
+    set: function set(standby) {
+      if (this.isDisposed || this.standby === standby) {
+        return;
+      }
+      this._standby = standby;
+    }
+
+    /**
+     * The poll state, which is the content of the current poll tick.
+     */
+  }, {
+    key: "state",
+    get: function get() {
+      return this._state;
+    }
+
+    /**
+     * A promise that resolves when the poll next ticks.
+     */
+  }, {
+    key: "tick",
+    get: function get() {
+      return this._tick.promise;
+    }
+
+    /**
+     * A signal emitted when the poll ticks and fires off a new request.
+     */
+  }, {
+    key: "ticked",
+    get: function get() {
+      return this.tickedEmitter.event;
+    }
+
+    /**
+     * Return an async iterator that yields every tick.
+     */
+  }, {
+    key: _Symbol$asyncIterator,
+    value: function value() {
+      var _this = this;
+      return _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (_this.isDisposed) {
+                _context.next = 7;
+                break;
+              }
+              _context.next = 3;
+              return _this.state;
+            case 3:
+              _context.next = 5;
+              return _awaitAsyncGenerator(_this.tick.catch(function () {
+                return undefined;
+              }));
+            case 5:
+              _context.next = 0;
+              break;
+            case 7:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }))();
+    }
+
+    /**
+     * Dispose the poll.
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      if (this.isDisposed) {
+        return;
+      }
+      this._state = _objectSpread(_objectSpread({}, Private.DISPOSED_STATE), {}, {
+        timestamp: new Date().getTime()
+      });
+      this._tick.promise.catch(function () {
+        return undefined;
+      });
+      this._tick.reject(new Error("Poll (".concat(this.name, ") is disposed.")));
+      this.disposeEmitter.fire(undefined);
+      this.tickedEmitter.dispose();
+      this.disposed = true;
+      this.disposeEmitter.dispose();
+    }
+
+    /**
+     * Refreshes the poll. Schedules `refreshed` tick if necessary.
+     *
+     * @returns A promise that resolves after tick is scheduled and never rejects.
+     *
+     * #### Notes
+     * The returned promise resolves after the tick is scheduled, but before
+     * the polling action is run. To wait until after the poll action executes,
+     * await the `poll.tick` promise: `await poll.refresh(); await poll.tick;`
+     */
+  }, {
+    key: "refresh",
+    value: function refresh() {
+      return this.schedule({
+        cancel: function cancel(_ref) {
+          var phase = _ref.phase;
+          return phase === 'refreshed';
+        },
+        interval: Poll.IMMEDIATE,
+        phase: 'refreshed'
+      });
+    }
+
+    /**
+     * Schedule the next poll tick.
+     *
+     * @param next - The next poll state data to schedule. Defaults to standby.
+     *
+     * @param next.cancel - Cancels state transition if function returns `true`.
+     *
+     * @returns A promise that resolves when the next poll state is active.
+     *
+     * #### Notes
+     * This method is not meant to be invoked by user code typically. It is public
+     * to allow poll instances to be composed into classes that schedule ticks.
+     */
+  }, {
+    key: "schedule",
+    value: function () {
+      var _schedule = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+        var _this3 = this;
+        var next,
+          pending,
+          scheduled,
+          state,
+          execute,
+          _args2 = arguments;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              next = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : {};
+              if (!this.isDisposed) {
+                _context2.next = 3;
+                break;
+              }
+              return _context2.abrupt("return");
+            case 3:
+              if (!(next.cancel && next.cancel(this.state))) {
+                _context2.next = 5;
+                break;
+              }
+              return _context2.abrupt("return");
+            case 5:
+              // Update poll state.
+              pending = this._tick;
+              scheduled = new Deferred();
+              state = _objectSpread({
+                interval: this.frequency.interval,
+                payload: null,
+                phase: 'standby',
+                timestamp: new Date().getTime()
+              }, next);
+              this._state = state;
+              this._tick = scheduled;
+
+              // Clear the schedule if possible.
+              clearTimeout(this._timeout);
+
+              // Emit ticked signal, resolve pending promise, and await its settlement.
+              this.tickedEmitter.fire(this.state);
+              pending.resolve(this);
+              _context2.next = 15;
+              return pending.promise;
+            case 15:
+              if (!(state.interval === Poll.NEVER)) {
+                _context2.next = 18;
+                break;
+              }
+              this._timeout = undefined;
+              return _context2.abrupt("return");
+            case 18:
+              // Schedule next execution and cache its timeout handle.
+              execute = function execute() {
+                if (_this3.isDisposed || _this3.tick !== scheduled.promise) {
+                  return;
+                }
+                _this3._execute();
+              };
+              this._timeout = setTimeout(execute, state.interval);
+            case 20:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function schedule() {
+        return _schedule.apply(this, arguments);
+      }
+      return schedule;
+    }()
+    /**
+     * Starts the poll. Schedules `started` tick if necessary.
+     *
+     * @returns A promise that resolves after tick is scheduled and never rejects.
+     */
+  }, {
+    key: "start",
+    value: function start() {
+      return this.schedule({
+        cancel: function cancel(_ref2) {
+          var phase = _ref2.phase;
+          return phase !== 'constructed' && phase !== 'standby' && phase !== 'stopped';
+        },
+        interval: Poll.IMMEDIATE,
+        phase: 'started'
+      });
+    }
+
+    /**
+     * Stops the poll. Schedules `stopped` tick if necessary.
+     *
+     * @returns A promise that resolves after tick is scheduled and never rejects.
+     */
+  }, {
+    key: "stop",
+    value: function stop() {
+      return this.schedule({
+        cancel: function cancel(_ref3) {
+          var phase = _ref3.phase;
+          return phase === 'stopped';
+        },
+        interval: Poll.NEVER,
+        phase: 'stopped'
+      });
+    }
+
+    /**
+     * Execute a new poll factory promise or stand by if necessary.
+     */
+  }, {
+    key: "_execute",
+    value: function _execute() {
+      var _this4 = this;
+      var standby = typeof this.standby === 'function' ? this.standby() : this.standby;
+      standby = standby === 'never' ? false : standby === 'when-hidden' ? !!(typeof document !== 'undefined' && document && document.hidden) : standby;
+
+      // If in standby mode schedule next tick without calling the factory.
+      if (standby) {
+        void this.schedule();
+        return;
+      }
+      var pending = this.tick;
+      this._factory(this.state).then(function (resolved) {
+        if (_this4.isDisposed || _this4.tick !== pending) {
+          return;
+        }
+        void _this4.schedule({
+          payload: resolved,
+          phase: _this4.state.phase === 'rejected' ? 'reconnected' : 'resolved'
+        });
+        return;
+      }).catch(function (rejected) {
+        if (_this4.isDisposed || _this4.tick !== pending) {
+          return;
+        }
+        void _this4.schedule({
+          interval: Private.sleep(_this4.frequency, _this4.state),
+          payload: rejected,
+          phase: 'rejected'
+        });
+      });
+    }
+  }]);
+  return Poll;
+}();
+
+/**
+ * A namespace for `Poll` types, interfaces, and statics.
+ */
+(function (_Poll) {
+  /**
+   * A promise factory that returns an individual poll request.
+   *
+   * @typeparam T - The resolved type of the factory's promises.
+   *
+   * @typeparam U - The rejected type of the factory's promises.
+   *
+   * @typeparam V - The type to extend the phases supported by a poll.
+   */
+
+  /**
+   * Indicates when the poll switches to standby.
+   */
+
+  /**
+   * Instantiation options for polls.
+   *
+   * @typeparam T - The resolved type of the factory's promises.
+   *
+   * @typeparam U - The rejected type of the factory's promises.
+   *
+   * @typeparam V - The type to extend the phases supported by a poll.
+   */
+
+  /**
+   * An interval value (0ms) that indicates the poll should tick immediately.
+   */
+  var IMMEDIATE = _Poll.IMMEDIATE = 0;
+  var MAX_INTERVAL = _Poll.MAX_INTERVAL = 2147483647;
+  var NEVER = _Poll.NEVER = Infinity;
+})(Poll || (Poll = {}));
+/**
+ * A namespace for protected module data.
+ */
+var Private;
+(function (_Private) {
+  var DEFAULT_BACKOFF = _Private.DEFAULT_BACKOFF = 3;
+  var DEFAULT_FREQUENCY = _Private.DEFAULT_FREQUENCY = {
+    backoff: true,
+    interval: 1000,
+    max: 30 * 1000
+  };
+  var DEFAULT_NAME = _Private.DEFAULT_NAME = 'unknown';
+  var DEFAULT_STANDBY = _Private.DEFAULT_STANDBY = 'when-hidden';
+  var DEFAULT_STATE = _Private.DEFAULT_STATE = {
+    interval: Poll.NEVER,
+    payload: null,
+    phase: 'constructed',
+    timestamp: new Date(0).getTime()
+  };
+  var DISPOSED_STATE = _Private.DISPOSED_STATE = {
+    interval: Poll.NEVER,
+    payload: null,
+    phase: 'disposed',
+    timestamp: new Date(0).getTime()
+  };
+  function sleep(frequency, last) {
+    var backoff = frequency.backoff,
+      interval = frequency.interval,
+      max = frequency.max;
+    if (interval === Poll.NEVER) {
+      return interval;
+    }
+    var growth = backoff === true ? DEFAULT_BACKOFF : backoff === false ? 1 : backoff;
+    var random = getRandomIntInclusive(interval, last.interval * growth);
+    return Math.min(max, random);
+  }
+  _Private.sleep = sleep;
+})(Private || (Private = {}));
+/**
+ * Get a random integer between min and max, inclusive of both.
+ *
+ * #### Notes
+ * From
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random#Getting_a_random_integer_between_two_values_inclusive
+ *
+ * From the MDN page: It might be tempting to use Math.round() to accomplish
+ * that, but doing so would cause your random numbers to follow a non-uniform
+ * distribution, which may not be acceptable for your needs.
+ */
+function getRandomIntInclusive(min, max) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}

package/es/polling/protocol.d.ts

@@ -0,0 +1,120 @@
+import type { Event } from '@difizen/mana-common';
+/**
+ * A readonly poll that calls an asynchronous function with each tick.
+ *
+ * @typeparam T - The resolved type of the factory's promises.
+ *
+ * @typeparam U - The rejected type of the factory's promises.
+ *
+ * @typeparam V - The type to extend the phases supported by a poll.
+ */
+export interface IPoll<T, U, V extends string> extends AsyncIterable<IPoll.State<T, U, V>> {
+    /**
+     * A signal emitted when the poll is disposed.
+     */
+    readonly onDispose: Event<void>;
+    /**
+     * The polling frequency data.
+     */
+    readonly frequency: IPoll.Frequency;
+    /**
+     * Whether the poll is disposed.
+     */
+    readonly disposed: boolean;
+    /**
+     * The name of the poll.
+     */
+    readonly name: string;
+    /**
+     * The poll state, which is the content of the currently-scheduled poll tick.
+     */
+    readonly state: IPoll.State<T, U, V>;
+    /**
+     * A promise that resolves when the currently-scheduled tick completes.
+     *
+     * #### Notes
+     * Usually this will resolve after `state.interval` milliseconds from
+     * `state.timestamp`. It can resolve earlier if the user starts or refreshes
+     * the poll, etc.
+     */
+    readonly tick: Promise<IPoll<T, U, V>>;
+    /**
+     * A signal emitted when the poll state changes, i.e., a new tick is scheduled.
+     */
+    readonly ticked: Event<IPoll.State<T, U, V>>;
+}
+/**
+ * A namespace for `IPoll` types.
+ */
+export declare namespace IPoll {
+    /**
+     * The polling frequency parameters.
+     *
+     * #### Notes
+     * We implement the "decorrelated jitter" strategy from
+     * https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/.
+     * Essentially, if consecutive retries are needed, we choose an integer:
+     * `sleep = min(max, rand(interval, backoff * sleep))`
+     * This ensures that the poll is never less than `interval`, and nicely
+     * spreads out retries for consecutive tries. Over time, if (interval < max),
+     * the random number will be above `max` about (1 - 1/backoff) of the time
+     * (sleeping the `max`), and the rest of the time the sleep will be a random
+     * number below `max`, decorrelating our trigger time from other pollers.
+     */
+    type Frequency = {
+        /**
+         * Whether poll frequency backs off (boolean) or the backoff growth rate
+         * (float > 1).
+         *
+         * #### Notes
+         * If `true`, the default backoff growth rate is `3`.
+         */
+        readonly backoff: boolean | number;
+        /**
+         * The basic polling interval in milliseconds (integer).
+         */
+        readonly interval: number;
+        /**
+         * The maximum milliseconds (integer) between poll requests.
+         */
+        readonly max: number;
+    };
+    /**
+     * The phase of the poll when the current tick was scheduled.
+     *
+     * @typeparam T - A type for any additional tick phases a poll supports.
+     */
+    type Phase<T extends string> = T | 'constructed' | 'disposed' | 'reconnected' | 'refreshed' | 'rejected' | 'resolved' | 'standby' | 'started' | 'stopped';
+    /**
+     * Definition of poll state at any given time.
+     *
+     * @typeparam T - The resolved type of the factory's promises.
+     *
+     * @typeparam U - The rejected type of the factory's promises.
+     *
+     * @typeparam V - The type to extend the phases supported by a poll.
+     */
+    type State<T, U, V extends string> = {
+        /**
+         * The number of milliseconds until the current tick resolves.
+         */
+        readonly interval: number;
+        /**
+         * The payload of the last poll resolution or rejection.
+         *
+         * #### Notes
+         * The payload is `null` unless the `phase` is `'reconnected`, `'resolved'`,
+         * or `'rejected'`. Its type is `T` for resolutions and `U` for rejections.
+         */
+        readonly payload: T | U | null;
+        /**
+         * The current poll phase.
+         */
+        readonly phase: Phase<V>;
+        /**
+         * The timestamp for when this tick was scheduled.
+         */
+        readonly timestamp: number;
+    };
+}
+//# sourceMappingURL=protocol.d.ts.map

package/es/polling/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/polling/protocol.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAElD;;;;;;;;GAQG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,MAAM,CAC3C,SAAQ,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3C;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;IAEhC;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC;IAEpC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAE3B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAErC;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAEvC;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;CAC9C;AAED;;GAEG;AACH,yBAAiB,KAAK,CAAC;IACrB;;;;;;;;;;;;;OAaG;IACH,KAAY,SAAS,GAAG;QACtB;;;;;;WAMG;QACH,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC;QAEnC;;WAEG;QACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAE1B;;WAEG;QACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;KACtB,CAAC;IAEF;;;;OAIG;IACH,KAAY,KAAK,CAAC,CAAC,SAAS,MAAM,IAC9B,CAAC,GACD,aAAa,GACb,UAAU,GACV,aAAa,GACb,WAAW,GACX,UAAU,GACV,UAAU,GACV,SAAS,GACT,SAAS,GACT,SAAS,CAAC;IAEd;;;;;;;;OAQG;IACH,KAAY,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI;QAC1C;;WAEG;QACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAE1B;;;;;;WAMG;QACH,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;QAE/B;;WAEG;QACH,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;QAEzB;;WAEG;QACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;KAC5B,CAAC;CACH"}

package/es/polling/protocol.js

@@ -0,0 +1,13 @@
+/**
+ * A readonly poll that calls an asynchronous function with each tick.
+ *
+ * @typeparam T - The resolved type of the factory's promises.
+ *
+ * @typeparam U - The rejected type of the factory's promises.
+ *
+ * @typeparam V - The type to extend the phases supported by a poll.
+ */
+/**
+ * A namespace for `IPoll` types.
+ */
+export var IPoll;

package/es/posix.d.ts

@@ -0,0 +1,2 @@
+export declare const join: (...args: string[]) => string;
+//# sourceMappingURL=posix.d.ts.map

package/es/posix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"posix.d.ts","sourceRoot":"","sources":["../src/posix.ts"],"names":[],"mappings":"AA0DA,eAAO,MAAM,IAAI,YAAsB,MAAM,EAAE,WAgB9C,CAAC"}