@dr.pogodin/js-utils 0.0.17 → 0.1.0

package/README.md

@@ -52,6 +52,10 @@ and used in the same way):
 ### Classes
 - [Barrier] — A [Promise] with **resolve()** and **reject()** exposed as
   instance methods.
+
+- `Cached` — Implements a cache of (a)synchronously retrieved items with
+  timestamp-based expiration. _To be documented_.
+
 - [Emitter](https://dr.pogodin.studio/docs/react-utils/docs/api/classes/Emitter)
   — Simple listeneable data emitter.
 - [Semaphore](https://dr.pogodin.studio/docs/react-utils/docs/api/classes/Semaphore)
@@ -59,6 +63,13 @@ and used in the same way):
 - `Timer` — The core implementation of [timer()] functionality, allowing
   to create further customized timer objects. _To be documented_.
 
+---
+Repository of this library also hosts some documents, to be referenced from
+other projects, as needed:
+- [The Common Sense Versioning](./docs/common-sense-versioning.md) —
+  a lax description of a lax approach to product versioning that makes more
+  sense than [SemVer](https://semver.org).
+
 <!-- References -->
 
 [Barrier]: https://dr.pogodin.studio/docs/react-utils/docs/api/classes/Barrier

package/build/common/Barrier.js

@@ -34,7 +34,7 @@ var STATE = /*#__PURE__*/function (STATE) {
  * Docs: https://dr.pogodin.studio/docs/react-utils/docs/api/classes/Barrier
  */
 class Barrier extends Promise {
-  p_state = (() => STATE.PENDING)();
+  pState = STATE.PENDING;
   constructor(executor) {
     let resolveRef;
     let rejectRef;
@@ -42,7 +42,7 @@ class Barrier extends Promise {
       // Note: Enforcing `void` return type because of the BEWARE note below.
       resolveRef = value => {
         resolve(value);
-        this.p_state = STATE.RESOLVED;
+        this.pState = STATE.RESOLVED;
 
         // BEWARE: Don't try to return `this` here, it will easily cause
         // infinite loops in React Native, which are extremely difficult
@@ -54,7 +54,7 @@ class Barrier extends Promise {
       // Note: Enforcing `void` return type because of the BEWARE note below.
       rejectRef = reason => {
         reject(reason);
-        this.p_state = STATE.REJECTED;
+        this.pState = STATE.REJECTED;
       };
       if (executor) executor(resolveRef, rejectRef);
     });
@@ -63,40 +63,62 @@ class Barrier extends Promise {
     // the Barrier is constructed by a .then() call on a "parent" barrier,
     // and in that scenario .then() itself will replace .p_resolve by another
     // resolver immediately after this constructor returns.
-    this.p_resolve = resolveRef;
-    this.p_reject = rejectRef;
+    this.pResolve = resolveRef;
+    this.pReject = rejectRef;
   }
   get resolve() {
     return arg => {
-      this.p_resolve(arg);
+      this.pResolve(arg);
       return this;
     };
   }
   get reject() {
     return arg => {
-      this.p_reject(arg);
+      this.pReject(arg);
       return this;
     };
   }
   get resolved() {
-    return this.p_state === STATE.RESOLVED;
+    return this.pState === STATE.RESOLVED;
   }
   get rejected() {
-    return this.p_state === STATE.REJECTED;
+    return this.pState === STATE.REJECTED;
   }
   get settled() {
-    return this.p_state !== STATE.PENDING;
+    return this.pState !== STATE.PENDING;
   }
+
+  // TODO: For async functions TS requires the return type to be the global
+  // Promise, thus not allowing to return our Barrier type extending it.
+  // Thus, we don't mark this method async for now, disabling the rule,
+  // and we should think more about it in future.
+  // eslint-disable-next-line @typescript-eslint/promise-function-async
   catch(onRejected) {
     return super.catch(onRejected);
   }
+
+  // TODO: For async functions TS requires the return type to be the global
+  // Promise, thus not allowing to return our Barrier type extending it.
+  // Thus, we don't mark this method async for now, disabling the rule,
+  // and we should think more about it in future.
+  // eslint-disable-next-line @typescript-eslint/promise-function-async
   finally(onFinally) {
     return super.finally(onFinally);
   }
+
+  // TODO: For async functions TS requires the return type to be the global
+  // Promise, thus not allowing to return our Barrier type extending it.
+  // Thus, we don't mark this method async for now, disabling the rule,
+  // and we should think more about it in future.
+  // eslint-disable-next-line @typescript-eslint/promise-function-async
   then(onFulfilled, onRejected) {
     const res = super.then(onFulfilled, onRejected);
-    res.p_resolve = this.resolve;
-    res.p_reject = this.reject;
+    // TODO: Revise later.
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    res.pResolve = this.resolve;
+    // TODO: Revise later.
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    res.pReject = this.reject;
     return res;
   }
 }

package/build/common/Barrier.js.map

@@ -1 +1 @@
-{"version":3,"file":"Barrier.js","names":["STATE","Barrier","Promise","p_state","PENDING","constructor","executor","resolveRef","rejectRef","resolve","reject","value","RESOLVED","reason","REJECTED","p_resolve","p_reject","arg","resolved","rejected","settled","catch","onRejected","finally","onFinally","then","onFulfilled","res","exports","default"],"sources":["../../src/Barrier.ts"],"sourcesContent":["export type Executor<T> = ConstructorParameters<typeof Promise<T>>[0];\n\ntype Resolver<T> = Parameters<Executor<T>>[0];\ntype Rejecter = Parameters<Executor<unknown>>[1];\n\nenum STATE {\n  PENDING = 'PENDING',\n  REJECTED = 'REJECTED',\n  RESOLVED = 'RESOLVED',\n}\n\n/**\n * Barrier is just a Promise which has resolve and reject exposed as instance\n * methods.\n *\n * It has two generic arguments T and TR which correspond to the argument of\n * the .resolve() method, and to the value resolved by the promise (barrier).\n * For a simple barrier TR equals to T, however for barriers created via .then()\n * chain, T corresponds to the argument of the original barrier, and TR to\n * the value resolved by the latest promise in the chain. Consider this:\n *\n * const b = new Barrier<string>();\n * b.resolve('result');\n * const s = await b; // `s` has `string` type, and equals \"result\".\n *\n * const b = (new Barrier<string>()).then((s) => s.length);\n * b.resolve('result'); // Chained barrier exposes .resolve() method of\n *                      // the first barrier in the chain, which expects\n *                      // `string` arugment (T), but the chained barrier\n *                      // resolves to `number` (TR).\n * const n = await b; // `n` has `number` type, and equals 6.\n *\n * Docs: https://dr.pogodin.studio/docs/react-utils/docs/api/classes/Barrier\n */\nexport default class Barrier<T = unknown, TR = T> extends Promise<TR> {\n  private p_resolve: Resolver<T>;\n\n  private p_reject: Rejecter;\n\n  private p_state = STATE.PENDING;\n\n  constructor(executor?: Executor<TR>) {\n    let resolveRef: Resolver<TR>;\n    let rejectRef: Rejecter;\n\n    super((resolve, reject) => {\n      // Note: Enforcing `void` return type because of the BEWARE note below.\n      resolveRef = (value: TR | PromiseLike<TR>): void => {\n        resolve(value);\n        this.p_state = STATE.RESOLVED;\n\n        // BEWARE: Don't try to return `this` here, it will easily cause\n        // infinite loops in React Native, which are extremely difficult\n        // to troubleshoot (I wasn't able to figure out, are they due to\n        // internal Promise implementation in RN, or because of some bad\n        // patterns in the host code).\n      };\n\n      // Note: Enforcing `void` return type because of the BEWARE note below.\n      rejectRef = (reason?: any): void => {\n        reject(reason);\n        this.p_state = STATE.REJECTED;\n      };\n\n      if (executor) executor(resolveRef, rejectRef);\n    });\n\n    // NOTE: We assume, the only scenario where TR is not equal T is when\n    // the Barrier is constructed by a .then() call on a \"parent\" barrier,\n    // and in that scenario .then() itself will replace .p_resolve by another\n    // resolver immediately after this constructor returns.\n    this.p_resolve = resolveRef! as Resolver<T>;\n\n    this.p_reject = rejectRef!;\n  }\n\n  get resolve() {\n    return (arg: Parameters<Resolver<T>>[0]) => {\n      this.p_resolve(arg);\n      return this;\n    };\n  }\n\n  get reject() {\n    return (arg: Parameters<Rejecter>[0]) => {\n      this.p_reject(arg);\n      return this;\n    };\n  }\n\n  get resolved() { return this.p_state === STATE.RESOLVED; }\n\n  get rejected() { return this.p_state === STATE.REJECTED; }\n\n  get settled() { return this.p_state !== STATE.PENDING; }\n\n  catch<TR1>(\n    onRejected?: ((reason: any) => TR1 | PromiseLike<TR1>) | null,\n  ): Barrier<T, TR1> {\n    return <Barrier<T, TR1>> super.catch(onRejected);\n  }\n\n  finally(onFinally?: (() => void) | null): Barrier<TR> {\n    return <Barrier<TR>> super.finally(onFinally);\n  }\n\n  then<TR1, TR2>(\n    onFulfilled?: ((value: TR) => TR1 | PromiseLike<TR1>) | null,\n    onRejected?: ((reason: any) => TR2 | PromiseLike<TR2>) | null,\n  ): Barrier<T, TR1 | TR2> {\n    const res = <Barrier<T, TR1 | TR2>> super.then(onFulfilled, onRejected);\n    res.p_resolve = this.resolve;\n    res.p_reject = this.reject;\n    return res;\n  }\n}\n"],"mappings":";;;;;;IAKKA,KAAK,0BAALA,KAAK;EAALA,KAAK;EAALA,KAAK;EAALA,KAAK;EAAA,OAALA,KAAK;AAAA,EAALA,KAAK;AAMV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,MAAMC,OAAO,SAA8BC,OAAO,CAAK;EAK5DC,OAAO,UAAGH,KAAK,CAACI,OAAO;EAE/BC,WAAWA,CAACC,QAAuB,EAAE;IACnC,IAAIC,UAAwB;IAC5B,IAAIC,SAAmB;IAEvB,KAAK,CAAC,CAACC,OAAO,EAAEC,MAAM,KAAK;MACzB;MACAH,UAAU,GAAII,KAA2B,IAAW;QAClDF,OAAO,CAACE,KAAK,CAAC;QACd,IAAI,CAACR,OAAO,GAAGH,KAAK,CAACY,QAAQ;;QAE7B;QACA;QACA;QACA;QACA;MACF,CAAC;;MAED;MACAJ,SAAS,GAAIK,MAAY,IAAW;QAClCH,MAAM,CAACG,MAAM,CAAC;QACd,IAAI,CAACV,OAAO,GAAGH,KAAK,CAACc,QAAQ;MAC/B,CAAC;MAED,IAAIR,QAAQ,EAAEA,QAAQ,CAACC,UAAU,EAAEC,SAAS,CAAC;IAC/C,CAAC,CAAC;;IAEF;IACA;IACA;IACA;IACA,IAAI,CAACO,SAAS,GAAGR,UAA0B;IAE3C,IAAI,CAACS,QAAQ,GAAGR,SAAU;EAC5B;EAEA,IAAIC,OAAOA,CAAA,EAAG;IACZ,OAAQQ,GAA+B,IAAK;MAC1C,IAAI,CAACF,SAAS,CAACE,GAAG,CAAC;MACnB,OAAO,IAAI;IACb,CAAC;EACH;EAEA,IAAIP,MAAMA,CAAA,EAAG;IACX,OAAQO,GAA4B,IAAK;MACvC,IAAI,CAACD,QAAQ,CAACC,GAAG,CAAC;MAClB,OAAO,IAAI;IACb,CAAC;EACH;EAEA,IAAIC,QAAQA,CAAA,EAAG;IAAE,OAAO,IAAI,CAACf,OAAO,KAAKH,KAAK,CAACY,QAAQ;EAAE;EAEzD,IAAIO,QAAQA,CAAA,EAAG;IAAE,OAAO,IAAI,CAAChB,OAAO,KAAKH,KAAK,CAACc,QAAQ;EAAE;EAEzD,IAAIM,OAAOA,CAAA,EAAG;IAAE,OAAO,IAAI,CAACjB,OAAO,KAAKH,KAAK,CAACI,OAAO;EAAE;EAEvDiB,KAAKA,CACHC,UAA6D,EAC5C;IACjB,OAAyB,KAAK,CAACD,KAAK,CAACC,UAAU,CAAC;EAClD;EAEAC,OAAOA,CAACC,SAA+B,EAAe;IACpD,OAAqB,KAAK,CAACD,OAAO,CAACC,SAAS,CAAC;EAC/C;EAEAC,IAAIA,CACFC,WAA4D,EAC5DJ,UAA6D,EACtC;IACvB,MAAMK,GAAG,GAA2B,KAAK,CAACF,IAAI,CAACC,WAAW,EAAEJ,UAAU,CAAC;IACvEK,GAAG,CAACZ,SAAS,GAAG,IAAI,CAACN,OAAO;IAC5BkB,GAAG,CAACX,QAAQ,GAAG,IAAI,CAACN,MAAM;IAC1B,OAAOiB,GAAG;EACZ;AACF;AAACC,OAAA,CAAAC,OAAA,GAAA5B,OAAA","ignoreList":[]}
+{"version":3,"file":"Barrier.js","names":["STATE","Barrier","Promise","pState","PENDING","constructor","executor","resolveRef","rejectRef","resolve","reject","value","RESOLVED","reason","REJECTED","pResolve","pReject","arg","resolved","rejected","settled","catch","onRejected","finally","onFinally","then","onFulfilled","res","exports","default"],"sources":["../../src/Barrier.ts"],"sourcesContent":["export type Executor<T> = ConstructorParameters<typeof Promise<T>>[0];\n\ntype Resolver<T> = Parameters<Executor<T>>[0];\ntype Rejecter = Parameters<Executor<unknown>>[1];\n\nenum STATE {\n  PENDING = 'PENDING',\n  REJECTED = 'REJECTED',\n  RESOLVED = 'RESOLVED',\n}\n\n/**\n * Barrier is just a Promise which has resolve and reject exposed as instance\n * methods.\n *\n * It has two generic arguments T and TR which correspond to the argument of\n * the .resolve() method, and to the value resolved by the promise (barrier).\n * For a simple barrier TR equals to T, however for barriers created via .then()\n * chain, T corresponds to the argument of the original barrier, and TR to\n * the value resolved by the latest promise in the chain. Consider this:\n *\n * const b = new Barrier<string>();\n * b.resolve('result');\n * const s = await b; // `s` has `string` type, and equals \"result\".\n *\n * const b = (new Barrier<string>()).then((s) => s.length);\n * b.resolve('result'); // Chained barrier exposes .resolve() method of\n *                      // the first barrier in the chain, which expects\n *                      // `string` arugment (T), but the chained barrier\n *                      // resolves to `number` (TR).\n * const n = await b; // `n` has `number` type, and equals 6.\n *\n * Docs: https://dr.pogodin.studio/docs/react-utils/docs/api/classes/Barrier\n */\nexport default class Barrier<T = unknown, TR = T> extends Promise<TR> {\n  private pResolve: Resolver<T>;\n\n  private pReject: Rejecter;\n\n  private pState = STATE.PENDING;\n\n  constructor(executor?: Executor<TR>) {\n    let resolveRef: Resolver<TR>;\n    let rejectRef: Rejecter;\n\n    super((resolve, reject) => {\n      // Note: Enforcing `void` return type because of the BEWARE note below.\n      resolveRef = (value: TR | PromiseLike<TR>): void => {\n        resolve(value);\n        this.pState = STATE.RESOLVED;\n\n        // BEWARE: Don't try to return `this` here, it will easily cause\n        // infinite loops in React Native, which are extremely difficult\n        // to troubleshoot (I wasn't able to figure out, are they due to\n        // internal Promise implementation in RN, or because of some bad\n        // patterns in the host code).\n      };\n\n      // Note: Enforcing `void` return type because of the BEWARE note below.\n      rejectRef = (reason?: unknown): void => {\n        reject(reason);\n        this.pState = STATE.REJECTED;\n      };\n\n      if (executor) executor(resolveRef, rejectRef);\n    });\n\n    // NOTE: We assume, the only scenario where TR is not equal T is when\n    // the Barrier is constructed by a .then() call on a \"parent\" barrier,\n    // and in that scenario .then() itself will replace .p_resolve by another\n    // resolver immediately after this constructor returns.\n    this.pResolve = resolveRef! as Resolver<T>;\n\n    this.pReject = rejectRef!;\n  }\n\n  get resolve() {\n    return (arg: Parameters<Resolver<T>>[0]): this => {\n      this.pResolve(arg);\n      return this;\n    };\n  }\n\n  get reject() {\n    return (arg: Parameters<Rejecter>[0]): this => {\n      this.pReject(arg);\n      return this;\n    };\n  }\n\n  get resolved(): boolean {\n    return this.pState === STATE.RESOLVED;\n  }\n\n  get rejected(): boolean {\n    return this.pState === STATE.REJECTED;\n  }\n\n  get settled(): boolean {\n    return this.pState !== STATE.PENDING;\n  }\n\n  // TODO: For async functions TS requires the return type to be the global\n  // Promise, thus not allowing to return our Barrier type extending it.\n  // Thus, we don't mark this method async for now, disabling the rule,\n  // and we should think more about it in future.\n  // eslint-disable-next-line @typescript-eslint/promise-function-async\n  catch<TR1>(\n    onRejected?: ((reason: unknown) => TR1 | PromiseLike<TR1>) | null,\n  ): Barrier<T, TR1> {\n    return super.catch(onRejected) as Barrier<T, TR1>;\n  }\n\n  // TODO: For async functions TS requires the return type to be the global\n  // Promise, thus not allowing to return our Barrier type extending it.\n  // Thus, we don't mark this method async for now, disabling the rule,\n  // and we should think more about it in future.\n  // eslint-disable-next-line @typescript-eslint/promise-function-async\n  finally(onFinally?: (() => void) | null): Barrier<TR> {\n    return super.finally(onFinally) as Barrier<TR>;\n  }\n\n  // TODO: For async functions TS requires the return type to be the global\n  // Promise, thus not allowing to return our Barrier type extending it.\n  // Thus, we don't mark this method async for now, disabling the rule,\n  // and we should think more about it in future.\n  // eslint-disable-next-line @typescript-eslint/promise-function-async\n  then<TR1, TR2>(\n    onFulfilled?: ((value: TR) => TR1 | PromiseLike<TR1>) | null,\n    onRejected?: ((reason: unknown) => TR2 | PromiseLike<TR2>) | null,\n  ): Barrier<T, TR1 | TR2> {\n    const res = super.then(onFulfilled, onRejected) as Barrier<T, TR1 | TR2>;\n    // TODO: Revise later.\n    // eslint-disable-next-line @typescript-eslint/no-misused-promises\n    res.pResolve = this.resolve;\n    // TODO: Revise later.\n    // eslint-disable-next-line @typescript-eslint/no-misused-promises\n    res.pReject = this.reject;\n    return res;\n  }\n}\n"],"mappings":";;;;;;IAKKA,KAAK,0BAALA,KAAK;EAALA,KAAK;EAALA,KAAK;EAALA,KAAK;EAAA,OAALA,KAAK;AAAA,EAALA,KAAK;AAMV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,MAAMC,OAAO,SAA8BC,OAAO,CAAK;EAK5DC,MAAM,GAAGH,KAAK,CAACI,OAAO;EAE9BC,WAAWA,CAACC,QAAuB,EAAE;IACnC,IAAIC,UAAwB;IAC5B,IAAIC,SAAmB;IAEvB,KAAK,CAAC,CAACC,OAAO,EAAEC,MAAM,KAAK;MACzB;MACAH,UAAU,GAAII,KAA2B,IAAW;QAClDF,OAAO,CAACE,KAAK,CAAC;QACd,IAAI,CAACR,MAAM,GAAGH,KAAK,CAACY,QAAQ;;QAE5B;QACA;QACA;QACA;QACA;MACF,CAAC;;MAED;MACAJ,SAAS,GAAIK,MAAgB,IAAW;QACtCH,MAAM,CAACG,MAAM,CAAC;QACd,IAAI,CAACV,MAAM,GAAGH,KAAK,CAACc,QAAQ;MAC9B,CAAC;MAED,IAAIR,QAAQ,EAAEA,QAAQ,CAACC,UAAU,EAAEC,SAAS,CAAC;IAC/C,CAAC,CAAC;;IAEF;IACA;IACA;IACA;IACA,IAAI,CAACO,QAAQ,GAAGR,UAA0B;IAE1C,IAAI,CAACS,OAAO,GAAGR,SAAU;EAC3B;EAEA,IAAIC,OAAOA,CAAA,EAAG;IACZ,OAAQQ,GAA+B,IAAW;MAChD,IAAI,CAACF,QAAQ,CAACE,GAAG,CAAC;MAClB,OAAO,IAAI;IACb,CAAC;EACH;EAEA,IAAIP,MAAMA,CAAA,EAAG;IACX,OAAQO,GAA4B,IAAW;MAC7C,IAAI,CAACD,OAAO,CAACC,GAAG,CAAC;MACjB,OAAO,IAAI;IACb,CAAC;EACH;EAEA,IAAIC,QAAQA,CAAA,EAAY;IACtB,OAAO,IAAI,CAACf,MAAM,KAAKH,KAAK,CAACY,QAAQ;EACvC;EAEA,IAAIO,QAAQA,CAAA,EAAY;IACtB,OAAO,IAAI,CAAChB,MAAM,KAAKH,KAAK,CAACc,QAAQ;EACvC;EAEA,IAAIM,OAAOA,CAAA,EAAY;IACrB,OAAO,IAAI,CAACjB,MAAM,KAAKH,KAAK,CAACI,OAAO;EACtC;;EAEA;EACA;EACA;EACA;EACA;EACAiB,KAAKA,CACHC,UAAiE,EAChD;IACjB,OAAO,KAAK,CAACD,KAAK,CAACC,UAAU,CAAC;EAChC;;EAEA;EACA;EACA;EACA;EACA;EACAC,OAAOA,CAACC,SAA+B,EAAe;IACpD,OAAO,KAAK,CAACD,OAAO,CAACC,SAAS,CAAC;EACjC;;EAEA;EACA;EACA;EACA;EACA;EACAC,IAAIA,CACFC,WAA4D,EAC5DJ,UAAiE,EAC1C;IACvB,MAAMK,GAAG,GAAG,KAAK,CAACF,IAAI,CAACC,WAAW,EAAEJ,UAAU,CAA0B;IACxE;IACA;IACAK,GAAG,CAACZ,QAAQ,GAAG,IAAI,CAACN,OAAO;IAC3B;IACA;IACAkB,GAAG,CAACX,OAAO,GAAG,IAAI,CAACN,MAAM;IACzB,OAAOiB,GAAG;EACZ;AACF;AAACC,OAAA,CAAAC,OAAA,GAAA5B,OAAA","ignoreList":[]}

package/build/common/Cached.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Cached = void 0;
+/** Adds timestamp to the promise. */
+function addTimestamp(promise, timestamp) {
+  const res = promise;
+  res.timestamp = timestamp;
+  return res;
+}
+
+/** Gets entry timestamp. */
+function getTimestamp(e) {
+  return Array.isArray(e) ? e[1] : e.timestamp;
+}
+class Cached {
+  data = {};
+  oldestTimestamp = Number.MAX_SAFE_INTEGER;
+
+  /** For test use only. */
+  get _data() {
+    return this.data;
+  }
+
+  /** For test use only. */
+  get _oldestTimestamp() {
+    return this.oldestTimestamp;
+  }
+  constructor(maxage, getter) {
+    this.maxage = maxage;
+    this.getter = getter;
+  }
+
+  /** Removes stale items from the cache, and updates .oldestTimestamp. */
+  cleanCache() {
+    const deadline = Date.now() - this.maxage;
+    this.oldestTimestamp = Number.MAX_SAFE_INTEGER;
+    for (const [key, entry] of Object.entries(this.data)) {
+      const timestamp = getTimestamp(entry);
+      if (timestamp < deadline) delete this.data[key];else if (timestamp < this.oldestTimestamp) {
+        this.oldestTimestamp = timestamp;
+      }
+    }
+  }
+
+  /** Adds `datum` to the cache, and removes stale items from the cache. */
+  set(id, datum) {
+    const now = Date.now();
+    if (this.oldestTimestamp < now - this.maxage) this.cleanCache();
+    if (now < this.oldestTimestamp) this.oldestTimestamp = now;
+    const res = [datum, now];
+    this.data[id] = res;
+    return res;
+  }
+
+  /** Retrieves envelope of the specified datum, either read from the cache,
+   *  or retrieved using the getter provided at construction time. */
+  getEntry(id) {
+    const now = Date.now();
+    let cached = this.data[id];
+    if (cached && getTimestamp(cached) >= now - this.maxage) return cached;
+    const itemOrPromise = this.getter(id);
+    if (!(itemOrPromise instanceof Promise)) {
+      return this.set(id, itemOrPromise);
+    }
+    cached = addTimestamp(itemOrPromise.then(item => this.set(id, item)), now);
+    if (now < this.oldestTimestamp) this.oldestTimestamp = now;
+    this.data[id] = cached;
+    return cached;
+  }
+
+  /** Gets item. */
+  get(id) {
+    const entry = this.getEntry(id);
+    return Array.isArray(entry) ? entry[0] : entry.then(e => e[0]);
+  }
+}
+exports.Cached = Cached;
+//# sourceMappingURL=Cached.js.map

package/build/common/Cached.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cached.js","names":["addTimestamp","promise","timestamp","res","getTimestamp","e","Array","isArray","Cached","data","oldestTimestamp","Number","MAX_SAFE_INTEGER","_data","_oldestTimestamp","constructor","maxage","getter","cleanCache","deadline","Date","now","key","entry","Object","entries","set","id","datum","getEntry","cached","itemOrPromise","Promise","then","item","get","exports"],"sources":["../../src/Cached.ts"],"sourcesContent":["type CachedT<T> = [T, number];\ntype TimestampedPromise<T> = Promise<T> & { timestamp: number };\ntype EntryT<T> = CachedT<T> | TimestampedPromise<CachedT<T>>;\n\n/** Adds timestamp to the promise. */\nfunction addTimestamp<T>(\n  promise: Promise<T>,\n  timestamp: number,\n): TimestampedPromise<T> {\n  const res = promise as TimestampedPromise<T>;\n  res.timestamp = timestamp;\n  return res;\n}\n\n/** Gets entry timestamp. */\nfunction getTimestamp<T>(e: EntryT<T>): number {\n  return Array.isArray(e) ? e[1] : e.timestamp;\n}\n\nexport class Cached<T> {\n  private data: Record<string, EntryT<T>> = {};\n  private oldestTimestamp = Number.MAX_SAFE_INTEGER;\n\n  /** For test use only. */\n  get _data(): Readonly<Record<string, EntryT<T>>> {\n    return this.data;\n  }\n\n  /** For test use only. */\n  get _oldestTimestamp(): number {\n    return this.oldestTimestamp;\n  }\n\n  constructor(\n    public readonly maxage: number,\n    private getter: (id: string) => T | Promise<T>,\n  ) {}\n\n  /** Removes stale items from the cache, and updates .oldestTimestamp. */\n  private cleanCache() {\n    const deadline = Date.now() - this.maxage;\n    this.oldestTimestamp = Number.MAX_SAFE_INTEGER;\n    for (const [key, entry] of Object.entries(this.data)) {\n      const timestamp = getTimestamp(entry);\n      if (timestamp < deadline) delete this.data[key];\n      else if (timestamp < this.oldestTimestamp) {\n        this.oldestTimestamp = timestamp;\n      }\n    }\n  }\n\n  /** Adds `datum` to the cache, and removes stale items from the cache. */\n  private set(id: string, datum: T): CachedT<T> {\n    const now = Date.now();\n    if (this.oldestTimestamp < now - this.maxage) this.cleanCache();\n    if (now < this.oldestTimestamp) this.oldestTimestamp = now;\n    const res: CachedT<T> = [datum, now];\n    this.data[id] = res;\n    return res;\n  }\n\n  /** Retrieves envelope of the specified datum, either read from the cache,\n   *  or retrieved using the getter provided at construction time. */\n  private getEntry(id: string): EntryT<T> {\n    const now = Date.now();\n\n    let cached = this.data[id];\n    if (cached && getTimestamp(cached) >= now - this.maxage) return cached;\n\n    const itemOrPromise = this.getter(id);\n    if (!(itemOrPromise instanceof Promise)) {\n      return this.set(id, itemOrPromise);\n    }\n\n    cached = addTimestamp(\n      itemOrPromise.then((item) => this.set(id, item)),\n      now,\n    );\n    if (now < this.oldestTimestamp) this.oldestTimestamp = now;\n    this.data[id] = cached;\n    return cached;\n  }\n\n  /** Gets item. */\n  get(id: string): T | Promise<T> {\n    const entry = this.getEntry(id);\n    return Array.isArray(entry) ? entry[0] : entry.then((e) => e[0]);\n  }\n}\n"],"mappings":";;;;;;AAIA;AACA,SAASA,YAAYA,CACnBC,OAAmB,EACnBC,SAAiB,EACM;EACvB,MAAMC,GAAG,GAAGF,OAAgC;EAC5CE,GAAG,CAACD,SAAS,GAAGA,SAAS;EACzB,OAAOC,GAAG;AACZ;;AAEA;AACA,SAASC,YAAYA,CAAIC,CAAY,EAAU;EAC7C,OAAOC,KAAK,CAACC,OAAO,CAACF,CAAC,CAAC,GAAGA,CAAC,CAAC,CAAC,CAAC,GAAGA,CAAC,CAACH,SAAS;AAC9C;AAEO,MAAMM,MAAM,CAAI;EACbC,IAAI,GAA8B,CAAC,CAAC;EACpCC,eAAe,GAAGC,MAAM,CAACC,gBAAgB;;EAEjD;EACA,IAAIC,KAAKA,CAAA,EAAwC;IAC/C,OAAO,IAAI,CAACJ,IAAI;EAClB;;EAEA;EACA,IAAIK,gBAAgBA,CAAA,EAAW;IAC7B,OAAO,IAAI,CAACJ,eAAe;EAC7B;EAEAK,WAAWA,CACOC,MAAc,EACtBC,MAAsC,EAC9C;IAAA,KAFgBD,MAAc,GAAdA,MAAc;IAAA,KACtBC,MAAsC,GAAtCA,MAAsC;EAC7C;;EAEH;EACQC,UAAUA,CAAA,EAAG;IACnB,MAAMC,QAAQ,GAAGC,IAAI,CAACC,GAAG,CAAC,CAAC,GAAG,IAAI,CAACL,MAAM;IACzC,IAAI,CAACN,eAAe,GAAGC,MAAM,CAACC,gBAAgB;IAC9C,KAAK,MAAM,CAACU,GAAG,EAAEC,KAAK,CAAC,IAAIC,MAAM,CAACC,OAAO,CAAC,IAAI,CAAChB,IAAI,CAAC,EAAE;MACpD,MAAMP,SAAS,GAAGE,YAAY,CAACmB,KAAK,CAAC;MACrC,IAAIrB,SAAS,GAAGiB,QAAQ,EAAE,OAAO,IAAI,CAACV,IAAI,CAACa,GAAG,CAAC,CAAC,KAC3C,IAAIpB,SAAS,GAAG,IAAI,CAACQ,eAAe,EAAE;QACzC,IAAI,CAACA,eAAe,GAAGR,SAAS;MAClC;IACF;EACF;;EAEA;EACQwB,GAAGA,CAACC,EAAU,EAAEC,KAAQ,EAAc;IAC5C,MAAMP,GAAG,GAAGD,IAAI,CAACC,GAAG,CAAC,CAAC;IACtB,IAAI,IAAI,CAACX,eAAe,GAAGW,GAAG,GAAG,IAAI,CAACL,MAAM,EAAE,IAAI,CAACE,UAAU,CAAC,CAAC;IAC/D,IAAIG,GAAG,GAAG,IAAI,CAACX,eAAe,EAAE,IAAI,CAACA,eAAe,GAAGW,GAAG;IAC1D,MAAMlB,GAAe,GAAG,CAACyB,KAAK,EAAEP,GAAG,CAAC;IACpC,IAAI,CAACZ,IAAI,CAACkB,EAAE,CAAC,GAAGxB,GAAG;IACnB,OAAOA,GAAG;EACZ;;EAEA;AACF;EACU0B,QAAQA,CAACF,EAAU,EAAa;IACtC,MAAMN,GAAG,GAAGD,IAAI,CAACC,GAAG,CAAC,CAAC;IAEtB,IAAIS,MAAM,GAAG,IAAI,CAACrB,IAAI,CAACkB,EAAE,CAAC;IAC1B,IAAIG,MAAM,IAAI1B,YAAY,CAAC0B,MAAM,CAAC,IAAIT,GAAG,GAAG,IAAI,CAACL,MAAM,EAAE,OAAOc,MAAM;IAEtE,MAAMC,aAAa,GAAG,IAAI,CAACd,MAAM,CAACU,EAAE,CAAC;IACrC,IAAI,EAAEI,aAAa,YAAYC,OAAO,CAAC,EAAE;MACvC,OAAO,IAAI,CAACN,GAAG,CAACC,EAAE,EAAEI,aAAa,CAAC;IACpC;IAEAD,MAAM,GAAG9B,YAAY,CACnB+B,aAAa,CAACE,IAAI,CAAEC,IAAI,IAAK,IAAI,CAACR,GAAG,CAACC,EAAE,EAAEO,IAAI,CAAC,CAAC,EAChDb,GACF,CAAC;IACD,IAAIA,GAAG,GAAG,IAAI,CAACX,eAAe,EAAE,IAAI,CAACA,eAAe,GAAGW,GAAG;IAC1D,IAAI,CAACZ,IAAI,CAACkB,EAAE,CAAC,GAAGG,MAAM;IACtB,OAAOA,MAAM;EACf;;EAEA;EACAK,GAAGA,CAACR,EAAU,EAAkB;IAC9B,MAAMJ,KAAK,GAAG,IAAI,CAACM,QAAQ,CAACF,EAAE,CAAC;IAC/B,OAAOrB,KAAK,CAACC,OAAO,CAACgB,KAAK,CAAC,GAAGA,KAAK,CAAC,CAAC,CAAC,GAAGA,KAAK,CAACU,IAAI,CAAE5B,CAAC,IAAKA,CAAC,CAAC,CAAC,CAAC,CAAC;EAClE;AACF;AAAC+B,OAAA,CAAA5B,MAAA,GAAAA,MAAA","ignoreList":[]}

package/build/common/Emitter.js

@@ -8,17 +8,17 @@ exports.Emitter = void 0;
  * Simple listeneable data Emitter.
  */
 class Emitter {
-  p_listeners = [];
+  pListeners = [];
 
   /**
    * Returns "true" if any listener is connected; "false" otherwise.
    * @return {boolean}
    */
   get hasListeners() {
-    return !!this.p_listeners.length;
+    return !!this.pListeners.length;
   }
   get listeners() {
-    return this.p_listeners;
+    return this.pListeners;
   }
 
   /**
@@ -27,26 +27,28 @@ class Emitter {
    * @return {function} Unsubscribe function.
    */
   addListener(listener) {
-    if (!this.p_listeners.includes(listener)) {
-      this.p_listeners.push(listener);
+    if (!this.pListeners.includes(listener)) {
+      this.pListeners.push(listener);
     }
-    return () => this.removeListener(listener);
+    return () => {
+      this.removeListener(listener);
+    };
   }
 
   /**
    * Calls every connected listener with the given arguments.
    * @param args
    */
-  emit() {
-    const listeners = this.p_listeners.slice();
-    for (const listener of listeners) listener(...arguments);
+  emit(...args) {
+    const listeners = this.pListeners.slice();
+    for (const listener of listeners) listener(...args);
   }
 
   /**
    * Removes all connected listeners.
    */
   removeAllListeners() {
-    this.p_listeners = [];
+    this.pListeners = [];
   }
 
   /**
@@ -54,8 +56,8 @@ class Emitter {
    * @param listener
    */
   removeListener(listener) {
-    const idx = this.p_listeners.indexOf(listener);
-    if (idx >= 0) this.p_listeners.splice(idx, 1);
+    const idx = this.pListeners.indexOf(listener);
+    if (idx >= 0) this.pListeners.splice(idx, 1);
   }
 }
 exports.Emitter = Emitter;

package/build/common/Emitter.js.map

@@ -1 +1 @@
-{"version":3,"file":"Emitter.js","names":["Emitter","p_listeners","hasListeners","length","listeners","addListener","listener","includes","push","removeListener","emit","slice","arguments","removeAllListeners","idx","indexOf","splice","exports"],"sources":["../../src/Emitter.ts"],"sourcesContent":["export type Listener<T extends unknown[] = unknown[]> = (...args: T) => void;\n\n/**\n * Simple listeneable data Emitter.\n */\nexport class Emitter<T extends unknown[] = unknown[]> {\n  private p_listeners: Listener<T>[] = [];\n\n  /**\n   * Returns \"true\" if any listener is connected; \"false\" otherwise.\n   * @return {boolean}\n   */\n  get hasListeners(): boolean {\n    return !!this.p_listeners.length;\n  }\n\n  get listeners(): ReadonlyArray<Listener<T>> { return this.p_listeners; }\n\n  /**\n   * Adds `listener` if it is not already connected.\n   * @param {function} listener\n   * @return {function} Unsubscribe function.\n   */\n  addListener(listener: Listener<T>): () => void {\n    if (!this.p_listeners.includes(listener)) {\n      this.p_listeners.push(listener);\n    }\n    return () => this.removeListener(listener);\n  }\n\n  /**\n   * Calls every connected listener with the given arguments.\n   * @param args\n   */\n  emit(...args: T) {\n    const listeners = this.p_listeners.slice();\n    for (const listener of listeners) listener(...args);\n  }\n\n  /**\n   * Removes all connected listeners.\n   */\n  removeAllListeners() {\n    this.p_listeners = [];\n  }\n\n  /**\n   * Removes specified `listener`, if connected.\n   * @param listener\n   */\n  removeListener(listener: Listener<T>) {\n    const idx = this.p_listeners.indexOf(listener);\n    if (idx >= 0) this.p_listeners.splice(idx, 1);\n  }\n}\n"],"mappings":";;;;;;AAEA;AACA;AACA;AACO,MAAMA,OAAO,CAAkC;EAC5CC,WAAW,GAAkB,EAAE;;EAEvC;AACF;AACA;AACA;EACE,IAAIC,YAAYA,CAAA,EAAY;IAC1B,OAAO,CAAC,CAAC,IAAI,CAACD,WAAW,CAACE,MAAM;EAClC;EAEA,IAAIC,SAASA,CAAA,EAA+B;IAAE,OAAO,IAAI,CAACH,WAAW;EAAE;;EAEvE;AACF;AACA;AACA;AACA;EACEI,WAAWA,CAACC,QAAqB,EAAc;IAC7C,IAAI,CAAC,IAAI,CAACL,WAAW,CAACM,QAAQ,CAACD,QAAQ,CAAC,EAAE;MACxC,IAAI,CAACL,WAAW,CAACO,IAAI,CAACF,QAAQ,CAAC;IACjC;IACA,OAAO,MAAM,IAAI,CAACG,cAAc,CAACH,QAAQ,CAAC;EAC5C;;EAEA;AACF;AACA;AACA;EACEI,IAAIA,CAAA,EAAa;IACf,MAAMN,SAAS,GAAG,IAAI,CAACH,WAAW,CAACU,KAAK,CAAC,CAAC;IAC1C,KAAK,MAAML,QAAQ,IAAIF,SAAS,EAAEE,QAAQ,CAAC,GAAAM,SAAO,CAAC;EACrD;;EAEA;AACF;AACA;EACEC,kBAAkBA,CAAA,EAAG;IACnB,IAAI,CAACZ,WAAW,GAAG,EAAE;EACvB;;EAEA;AACF;AACA;AACA;EACEQ,cAAcA,CAACH,QAAqB,EAAE;IACpC,MAAMQ,GAAG,GAAG,IAAI,CAACb,WAAW,CAACc,OAAO,CAACT,QAAQ,CAAC;IAC9C,IAAIQ,GAAG,IAAI,CAAC,EAAE,IAAI,CAACb,WAAW,CAACe,MAAM,CAACF,GAAG,EAAE,CAAC,CAAC;EAC/C;AACF;AAACG,OAAA,CAAAjB,OAAA,GAAAA,OAAA","ignoreList":[]}
+{"version":3,"file":"Emitter.js","names":["Emitter","pListeners","hasListeners","length","listeners","addListener","listener","includes","push","removeListener","emit","args","slice","removeAllListeners","idx","indexOf","splice","exports"],"sources":["../../src/Emitter.ts"],"sourcesContent":["export type Listener<T extends unknown[] = unknown[]> = (...args: T) => void;\n\n/**\n * Simple listeneable data Emitter.\n */\nexport class Emitter<T extends unknown[] = unknown[]> {\n  private pListeners: Array<Listener<T>> = [];\n\n  /**\n   * Returns \"true\" if any listener is connected; \"false\" otherwise.\n   * @return {boolean}\n   */\n  get hasListeners(): boolean {\n    return !!this.pListeners.length;\n  }\n\n  get listeners(): ReadonlyArray<Listener<T>> {\n    return this.pListeners;\n  }\n\n  /**\n   * Adds `listener` if it is not already connected.\n   * @param {function} listener\n   * @return {function} Unsubscribe function.\n   */\n  addListener(listener: Listener<T>): () => void {\n    if (!this.pListeners.includes(listener)) {\n      this.pListeners.push(listener);\n    }\n    return () => {\n      this.removeListener(listener);\n    };\n  }\n\n  /**\n   * Calls every connected listener with the given arguments.\n   * @param args\n   */\n  emit(...args: T): void {\n    const listeners = this.pListeners.slice();\n    for (const listener of listeners) listener(...args);\n  }\n\n  /**\n   * Removes all connected listeners.\n   */\n  removeAllListeners(): void {\n    this.pListeners = [];\n  }\n\n  /**\n   * Removes specified `listener`, if connected.\n   * @param listener\n   */\n  removeListener(listener: Listener<T>): void {\n    const idx = this.pListeners.indexOf(listener);\n    if (idx >= 0) this.pListeners.splice(idx, 1);\n  }\n}\n"],"mappings":";;;;;;AAEA;AACA;AACA;AACO,MAAMA,OAAO,CAAkC;EAC5CC,UAAU,GAAuB,EAAE;;EAE3C;AACF;AACA;AACA;EACE,IAAIC,YAAYA,CAAA,EAAY;IAC1B,OAAO,CAAC,CAAC,IAAI,CAACD,UAAU,CAACE,MAAM;EACjC;EAEA,IAAIC,SAASA,CAAA,EAA+B;IAC1C,OAAO,IAAI,CAACH,UAAU;EACxB;;EAEA;AACF;AACA;AACA;AACA;EACEI,WAAWA,CAACC,QAAqB,EAAc;IAC7C,IAAI,CAAC,IAAI,CAACL,UAAU,CAACM,QAAQ,CAACD,QAAQ,CAAC,EAAE;MACvC,IAAI,CAACL,UAAU,CAACO,IAAI,CAACF,QAAQ,CAAC;IAChC;IACA,OAAO,MAAM;MACX,IAAI,CAACG,cAAc,CAACH,QAAQ,CAAC;IAC/B,CAAC;EACH;;EAEA;AACF;AACA;AACA;EACEI,IAAIA,CAAC,GAAGC,IAAO,EAAQ;IACrB,MAAMP,SAAS,GAAG,IAAI,CAACH,UAAU,CAACW,KAAK,CAAC,CAAC;IACzC,KAAK,MAAMN,QAAQ,IAAIF,SAAS,EAAEE,QAAQ,CAAC,GAAGK,IAAI,CAAC;EACrD;;EAEA;AACF;AACA;EACEE,kBAAkBA,CAAA,EAAS;IACzB,IAAI,CAACZ,UAAU,GAAG,EAAE;EACtB;;EAEA;AACF;AACA;AACA;EACEQ,cAAcA,CAACH,QAAqB,EAAQ;IAC1C,MAAMQ,GAAG,GAAG,IAAI,CAACb,UAAU,CAACc,OAAO,CAACT,QAAQ,CAAC;IAC7C,IAAIQ,GAAG,IAAI,CAAC,EAAE,IAAI,CAACb,UAAU,CAACe,MAAM,CAACF,GAAG,EAAE,CAAC,CAAC;EAC9C;AACF;AAACG,OAAA,CAAAjB,OAAA,GAAAA,OAAA","ignoreList":[]}

package/build/common/Semaphore.js

@@ -10,39 +10,42 @@ var _Barrier = _interopRequireDefault(require("./Barrier"));
  * Implements a simple semaphore for async code logic.
  */
 class Semaphore {
-  constructor() {
-    let ready = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-    this.p_ready = !!ready;
+  constructor(ready = false) {
+    // TODO: Boolean conversion is performed for backward compatibility with
+    // plain JS projects. Drop it in future.
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion
+    this.pReady = !!ready;
   }
   get ready() {
-    return this.p_ready;
+    return this.pReady;
   }
   setReady(ready) {
+    // TODO: Boolean conversion is performed for backward compatibility with
+    // plain JS projects. Drop it in future.
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion
     const bool = !!ready;
-    if (this.p_ready !== bool) {
-      this.p_ready = bool;
-      if (bool && !this.p_draining && this.p_queue.length) {
-        this.p_drainQueue();
+    if (this.pReady !== bool) {
+      this.pReady = bool;
+      if (bool && !this.pDraining && this.pQueue.length) {
+        void this.pDrainQueue();
       }
     }
   }
 
   /**
    * Waits until the semaphore is ready, and marks it as non-ready (seizes it).
-   * @return {Promise}
    */
   async seize() {
     return this.waitReady(true);
   }
-  async waitReady() {
-    let seize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-    if (!this.p_ready || this.p_queue.length) {
+  async waitReady(seize = false) {
+    if (!this.pReady || this.pQueue.length) {
       const barrier = new _Barrier.default();
-      this.p_queue.push(barrier);
+      this.pQueue.push(barrier);
       await barrier;
-      if (seize) this.p_ready = false;
-      this.p_drainLock.resolve();
-    } else if (seize) this.p_ready = false;
+      if (seize) this.pReady = false;
+      void this.pDrainLock.resolve();
+    } else if (seize) this.pReady = false;
   }
 
   // Private members below this point.
@@ -53,21 +56,21 @@ class Semaphore {
    * Otherwise, it breaks the queue draining loop, which will be restarted
    * the next time the semaphore is set ready.
    */
-  async p_drainQueue() {
-    this.p_draining = true;
-    while (this.p_ready && this.p_queue.length) {
-      this.p_drainLock = new _Barrier.default();
-      this.p_queue[0].resolve();
-      await this.p_drainLock; // eslint-disable-line no-await-in-loop
-      this.p_queue.shift();
+  async pDrainQueue() {
+    this.pDraining = true;
+    while (this.pReady && this.pQueue.length) {
+      this.pDrainLock = new _Barrier.default();
+      void this.pQueue[0].resolve();
+      await this.pDrainLock;
+      void this.pQueue.shift();
     }
-    this.p_draining = false;
-    this.p_drainLock = null;
+    this.pDraining = false;
+    this.pDrainLock = null;
   }
 
   // "true" when the drain queue process is running (and thus no need to start
   // a new one).
-  p_draining = false;
+  pDraining = false;
 
   // Each time a Promise from drain queue is resolved this drainLock is set
   // to block further queue draining until the promise resolution handler
@@ -75,11 +78,11 @@ class Semaphore {
   // to continue the draining. This is specifically important for .seize(),
   // which should have a chance to switch semaphore state to non-ready prior
   // to next Promise in the queue being unlocked.
-  p_drainLock = null;
+  pDrainLock = null;
 
   // The array of barriers set for each async code flow awaiting for
   // the Semaphore to become ready.
-  p_queue = [];
+  pQueue = [];
 }
 exports.default = Semaphore;
 //# sourceMappingURL=Semaphore.js.map

package/build/common/Semaphore.js.map

@@ -1 +1 @@
-{"version":3,"file":"Semaphore.js","names":["_Barrier","_interopRequireDefault","require","Semaphore","constructor","ready","arguments","length","undefined","p_ready","setReady","bool","p_draining","p_queue","p_drainQueue","seize","waitReady","barrier","Barrier","push","p_drainLock","resolve","shift","exports","default"],"sources":["../../src/Semaphore.ts"],"sourcesContent":["import Barrier from './Barrier';\n\n/**\n * Implements a simple semaphore for async code logic.\n */\nexport default class Semaphore {\n  constructor(ready = false) {\n    this.p_ready = !!ready;\n  }\n\n  get ready() { return this.p_ready; }\n\n  setReady(ready: boolean) {\n    const bool = !!ready;\n    if (this.p_ready !== bool) {\n      this.p_ready = bool;\n      if (bool && !this.p_draining && this.p_queue.length) {\n        this.p_drainQueue();\n      }\n    }\n  }\n\n  /**\n   * Waits until the semaphore is ready, and marks it as non-ready (seizes it).\n   * @return {Promise}\n   */\n  async seize() {\n    return this.waitReady(true);\n  }\n\n  async waitReady(seize = false) {\n    if (!this.p_ready || this.p_queue.length) {\n      const barrier = new Barrier<void>();\n      this.p_queue.push(barrier);\n      await barrier;\n      if (seize) this.p_ready = false;\n      this.p_drainLock!.resolve();\n    } else if (seize) this.p_ready = false;\n  }\n\n  // Private members below this point.\n\n  /**\n   * If semaphore is ready, it releases the next barrier in the queue, if any,\n   * and reschedules itself for a call in the next event loop iteration.\n   * Otherwise, it breaks the queue draining loop, which will be restarted\n   * the next time the semaphore is set ready.\n   */\n  async p_drainQueue() {\n    this.p_draining = true;\n    while (this.p_ready && this.p_queue.length) {\n      this.p_drainLock = new Barrier();\n      this.p_queue[0]!.resolve();\n      await this.p_drainLock; // eslint-disable-line no-await-in-loop\n      this.p_queue.shift();\n    }\n    this.p_draining = false;\n    this.p_drainLock = null;\n  }\n\n  // \"true\" when the drain queue process is running (and thus no need to start\n  // a new one).\n  private p_draining = false;\n\n  // Each time a Promise from drain queue is resolved this drainLock is set\n  // to block further queue draining until the promise resolution handler\n  // (.seize() or .waitReady()) unlocks it, thus confirming it is fine\n  // to continue the draining. This is specifically important for .seize(),\n  // which should have a chance to switch semaphore state to non-ready prior\n  // to next Promise in the queue being unlocked.\n  private p_drainLock: Barrier<void> | null = null;\n\n  // The array of barriers set for each async code flow awaiting for\n  // the Semaphore to become ready.\n  private p_queue: Barrier<void>[] = [];\n\n  private p_ready: boolean;\n}\n"],"mappings":";;;;;;;AAAA,IAAAA,QAAA,GAAAC,sBAAA,CAAAC,OAAA;AAEA;AACA;AACA;AACe,MAAMC,SAAS,CAAC;EAC7BC,WAAWA,CAAA,EAAgB;IAAA,IAAfC,KAAK,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,KAAK;IACvB,IAAI,CAACG,OAAO,GAAG,CAAC,CAACJ,KAAK;EACxB;EAEA,IAAIA,KAAKA,CAAA,EAAG;IAAE,OAAO,IAAI,CAACI,OAAO;EAAE;EAEnCC,QAAQA,CAACL,KAAc,EAAE;IACvB,MAAMM,IAAI,GAAG,CAAC,CAACN,KAAK;IACpB,IAAI,IAAI,CAACI,OAAO,KAAKE,IAAI,EAAE;MACzB,IAAI,CAACF,OAAO,GAAGE,IAAI;MACnB,IAAIA,IAAI,IAAI,CAAC,IAAI,CAACC,UAAU,IAAI,IAAI,CAACC,OAAO,CAACN,MAAM,EAAE;QACnD,IAAI,CAACO,YAAY,CAAC,CAAC;MACrB;IACF;EACF;;EAEA;AACF;AACA;AACA;EACE,MAAMC,KAAKA,CAAA,EAAG;IACZ,OAAO,IAAI,CAACC,SAAS,CAAC,IAAI,CAAC;EAC7B;EAEA,MAAMA,SAASA,CAAA,EAAgB;IAAA,IAAfD,KAAK,GAAAT,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,KAAK;IAC3B,IAAI,CAAC,IAAI,CAACG,OAAO,IAAI,IAAI,CAACI,OAAO,CAACN,MAAM,EAAE;MACxC,MAAMU,OAAO,GAAG,IAAIC,gBAAO,CAAO,CAAC;MACnC,IAAI,CAACL,OAAO,CAACM,IAAI,CAACF,OAAO,CAAC;MAC1B,MAAMA,OAAO;MACb,IAAIF,KAAK,EAAE,IAAI,CAACN,OAAO,GAAG,KAAK;MAC/B,IAAI,CAACW,WAAW,CAAEC,OAAO,CAAC,CAAC;IAC7B,CAAC,MAAM,IAAIN,KAAK,EAAE,IAAI,CAACN,OAAO,GAAG,KAAK;EACxC;;EAEA;;EAEA;AACF;AACA;AACA;AACA;AACA;EACE,MAAMK,YAAYA,CAAA,EAAG;IACnB,IAAI,CAACF,UAAU,GAAG,IAAI;IACtB,OAAO,IAAI,CAACH,OAAO,IAAI,IAAI,CAACI,OAAO,CAACN,MAAM,EAAE;MAC1C,IAAI,CAACa,WAAW,GAAG,IAAIF,gBAAO,CAAC,CAAC;MAChC,IAAI,CAACL,OAAO,CAAC,CAAC,CAAC,CAAEQ,OAAO,CAAC,CAAC;MAC1B,MAAM,IAAI,CAACD,WAAW,CAAC,CAAC;MACxB,IAAI,CAACP,OAAO,CAACS,KAAK,CAAC,CAAC;IACtB;IACA,IAAI,CAACV,UAAU,GAAG,KAAK;IACvB,IAAI,CAACQ,WAAW,GAAG,IAAI;EACzB;;EAEA;EACA;EACQR,UAAU,GAAG,KAAK;;EAE1B;EACA;EACA;EACA;EACA;EACA;EACQQ,WAAW,GAAyB,IAAI;;EAEhD;EACA;EACQP,OAAO,GAAoB,EAAE;AAGvC;AAACU,OAAA,CAAAC,OAAA,GAAArB,SAAA","ignoreList":[]}
+{"version":3,"file":"Semaphore.js","names":["_Barrier","_interopRequireDefault","require","Semaphore","constructor","ready","pReady","setReady","bool","pDraining","pQueue","length","pDrainQueue","seize","waitReady","barrier","Barrier","push","pDrainLock","resolve","shift","exports","default"],"sources":["../../src/Semaphore.ts"],"sourcesContent":["import Barrier from './Barrier';\n\n/**\n * Implements a simple semaphore for async code logic.\n */\nexport default class Semaphore {\n  constructor(ready = false) {\n    // TODO: Boolean conversion is performed for backward compatibility with\n    // plain JS projects. Drop it in future.\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion\n    this.pReady = !!ready;\n  }\n\n  get ready(): boolean {\n    return this.pReady;\n  }\n\n  setReady(ready: boolean): void {\n    // TODO: Boolean conversion is performed for backward compatibility with\n    // plain JS projects. Drop it in future.\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion\n    const bool = !!ready;\n    if (this.pReady !== bool) {\n      this.pReady = bool;\n      if (bool && !this.pDraining && this.pQueue.length) {\n        void this.pDrainQueue();\n      }\n    }\n  }\n\n  /**\n   * Waits until the semaphore is ready, and marks it as non-ready (seizes it).\n   */\n  async seize(): Promise<void> {\n    return this.waitReady(true);\n  }\n\n  async waitReady(seize = false): Promise<void> {\n    if (!this.pReady || this.pQueue.length) {\n      const barrier = new Barrier<void>();\n      this.pQueue.push(barrier);\n      await barrier;\n      if (seize) this.pReady = false;\n      void this.pDrainLock!.resolve();\n    } else if (seize) this.pReady = false;\n  }\n\n  // Private members below this point.\n\n  /**\n   * If semaphore is ready, it releases the next barrier in the queue, if any,\n   * and reschedules itself for a call in the next event loop iteration.\n   * Otherwise, it breaks the queue draining loop, which will be restarted\n   * the next time the semaphore is set ready.\n   */\n  async pDrainQueue(): Promise<void> {\n    this.pDraining = true;\n    while (this.pReady && this.pQueue.length) {\n      this.pDrainLock = new Barrier();\n      void this.pQueue[0]!.resolve();\n      await this.pDrainLock;\n      void this.pQueue.shift();\n    }\n    this.pDraining = false;\n    this.pDrainLock = null;\n  }\n\n  // \"true\" when the drain queue process is running (and thus no need to start\n  // a new one).\n  private pDraining = false;\n\n  // Each time a Promise from drain queue is resolved this drainLock is set\n  // to block further queue draining until the promise resolution handler\n  // (.seize() or .waitReady()) unlocks it, thus confirming it is fine\n  // to continue the draining. This is specifically important for .seize(),\n  // which should have a chance to switch semaphore state to non-ready prior\n  // to next Promise in the queue being unlocked.\n  private pDrainLock: Barrier<void> | null = null;\n\n  // The array of barriers set for each async code flow awaiting for\n  // the Semaphore to become ready.\n  private pQueue: Array<Barrier<void>> = [];\n\n  private pReady: boolean;\n}\n"],"mappings":";;;;;;;AAAA,IAAAA,QAAA,GAAAC,sBAAA,CAAAC,OAAA;AAEA;AACA;AACA;AACe,MAAMC,SAAS,CAAC;EAC7BC,WAAWA,CAACC,KAAK,GAAG,KAAK,EAAE;IACzB;IACA;IACA;IACA,IAAI,CAACC,MAAM,GAAG,CAAC,CAACD,KAAK;EACvB;EAEA,IAAIA,KAAKA,CAAA,EAAY;IACnB,OAAO,IAAI,CAACC,MAAM;EACpB;EAEAC,QAAQA,CAACF,KAAc,EAAQ;IAC7B;IACA;IACA;IACA,MAAMG,IAAI,GAAG,CAAC,CAACH,KAAK;IACpB,IAAI,IAAI,CAACC,MAAM,KAAKE,IAAI,EAAE;MACxB,IAAI,CAACF,MAAM,GAAGE,IAAI;MAClB,IAAIA,IAAI,IAAI,CAAC,IAAI,CAACC,SAAS,IAAI,IAAI,CAACC,MAAM,CAACC,MAAM,EAAE;QACjD,KAAK,IAAI,CAACC,WAAW,CAAC,CAAC;MACzB;IACF;EACF;;EAEA;AACF;AACA;EACE,MAAMC,KAAKA,CAAA,EAAkB;IAC3B,OAAO,IAAI,CAACC,SAAS,CAAC,IAAI,CAAC;EAC7B;EAEA,MAAMA,SAASA,CAACD,KAAK,GAAG,KAAK,EAAiB;IAC5C,IAAI,CAAC,IAAI,CAACP,MAAM,IAAI,IAAI,CAACI,MAAM,CAACC,MAAM,EAAE;MACtC,MAAMI,OAAO,GAAG,IAAIC,gBAAO,CAAO,CAAC;MACnC,IAAI,CAACN,MAAM,CAACO,IAAI,CAACF,OAAO,CAAC;MACzB,MAAMA,OAAO;MACb,IAAIF,KAAK,EAAE,IAAI,CAACP,MAAM,GAAG,KAAK;MAC9B,KAAK,IAAI,CAACY,UAAU,CAAEC,OAAO,CAAC,CAAC;IACjC,CAAC,MAAM,IAAIN,KAAK,EAAE,IAAI,CAACP,MAAM,GAAG,KAAK;EACvC;;EAEA;;EAEA;AACF;AACA;AACA;AACA;AACA;EACE,MAAMM,WAAWA,CAAA,EAAkB;IACjC,IAAI,CAACH,SAAS,GAAG,IAAI;IACrB,OAAO,IAAI,CAACH,MAAM,IAAI,IAAI,CAACI,MAAM,CAACC,MAAM,EAAE;MACxC,IAAI,CAACO,UAAU,GAAG,IAAIF,gBAAO,CAAC,CAAC;MAC/B,KAAK,IAAI,CAACN,MAAM,CAAC,CAAC,CAAC,CAAES,OAAO,CAAC,CAAC;MAC9B,MAAM,IAAI,CAACD,UAAU;MACrB,KAAK,IAAI,CAACR,MAAM,CAACU,KAAK,CAAC,CAAC;IAC1B;IACA,IAAI,CAACX,SAAS,GAAG,KAAK;IACtB,IAAI,CAACS,UAAU,GAAG,IAAI;EACxB;;EAEA;EACA;EACQT,SAAS,GAAG,KAAK;;EAEzB;EACA;EACA;EACA;EACA;EACA;EACQS,UAAU,GAAyB,IAAI;;EAE/C;EACA;EACQR,MAAM,GAAyB,EAAE;AAG3C;AAACW,OAAA,CAAAC,OAAA,GAAAnB,SAAA","ignoreList":[]}

package/build/common/index.js

@@ -28,6 +28,18 @@ Object.defineProperty(exports, "withRetries", {
   }
 });
 var _Barrier = _interopRequireDefault(require("./Barrier"));
+var _Cached = require("./Cached");
+Object.keys(_Cached).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Cached[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Cached[key];
+    }
+  });
+});
 var _Emitter = require("./Emitter");
 Object.keys(_Emitter).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/build/common/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["_Barrier","_interopRequireDefault","require","_Emitter","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_Semaphore","_time","_withRetries"],"sources":["../../src/index.ts"],"sourcesContent":["export { default as Barrier } from './Barrier';\nexport * from './Emitter';\nexport { default as Semaphore } from './Semaphore';\nexport * from './time';\nexport { default as withRetries } from './withRetries';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,QAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,QAAA,GAAAD,OAAA;AAAAE,MAAA,CAAAC,IAAA,CAAAF,QAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAJ,QAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAZ,QAAA,CAAAI,GAAA;IAAA;EAAA;AAAA;AACA,IAAAS,UAAA,GAAAf,sBAAA,CAAAC,OAAA;AACA,IAAAe,KAAA,GAAAf,OAAA;AAAAE,MAAA,CAAAC,IAAA,CAAAY,KAAA,EAAAX,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAU,KAAA,CAAAV,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAE,KAAA,CAAAV,GAAA;IAAA;EAAA;AAAA;AACA,IAAAW,YAAA,GAAAjB,sBAAA,CAAAC,OAAA","ignoreList":[]}
+{"version":3,"file":"index.js","names":["_Barrier","_interopRequireDefault","require","_Cached","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_Emitter","_Semaphore","_time","_withRetries"],"sources":["../../src/index.ts"],"sourcesContent":["export { default as Barrier } from './Barrier';\nexport * from './Cached';\nexport * from './Emitter';\nexport { default as Semaphore } from './Semaphore';\nexport * from './time';\nexport { default as withRetries } from './withRetries';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,QAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAAAE,MAAA,CAAAC,IAAA,CAAAF,OAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAJ,OAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAZ,OAAA,CAAAI,GAAA;IAAA;EAAA;AAAA;AACA,IAAAS,QAAA,GAAAd,OAAA;AAAAE,MAAA,CAAAC,IAAA,CAAAW,QAAA,EAAAV,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAS,QAAA,CAAAT,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,QAAA,CAAAT,GAAA;IAAA;EAAA;AAAA;AACA,IAAAU,UAAA,GAAAhB,sBAAA,CAAAC,OAAA;AACA,IAAAgB,KAAA,GAAAhB,OAAA;AAAAE,MAAA,CAAAC,IAAA,CAAAa,KAAA,EAAAZ,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAW,KAAA,CAAAX,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAG,KAAA,CAAAX,GAAA;IAAA;EAAA;AAAA;AACA,IAAAY,YAAA,GAAAlB,sBAAA,CAAAC,OAAA","ignoreList":[]}

package/build/common/time.js

@@ -22,10 +22,10 @@ const YEAR_MS = exports.YEAR_MS = 31536000000; // 365 * DAY_MS
 // from the library as well, and it should be documented later.
 class Timer extends _Barrier.default {
   get abort() {
-    return this.p_abort;
+    return this.pAbort;
   }
   get timeout() {
-    return this.p_timeout;
+    return this.pTimeout;
   }
 
   /**
@@ -43,24 +43,34 @@ class Timer extends _Barrier.default {
    */
   constructor(executor) {
     super(executor);
-    this.p_abort = () => {};
+    this.pAbort = () => undefined;
   }
   init(timeout) {
-    if (this.p_timeout !== undefined) {
+    if (this.pTimeout !== undefined) {
       throw Error('This Timer is initialized already');
     }
-    this.p_timeout = timeout;
+    this.pTimeout = timeout;
     if (timeout > 0) {
-      const id = setTimeout(super.resolve.bind(this), timeout);
-      this.p_abort = () => clearTimeout(id);
+      const id = setTimeout(() => {
+        void super.resolve();
+      }, timeout);
+      this.pAbort = () => {
+        clearTimeout(id);
+      };
     } else {
-      super.resolve();
+      void super.resolve();
     }
     return this;
   }
+
+  // TODO: For async functions TS requires the return type to be the global
+  // Promise, thus not allowing to return our Timer type extending that via
+  // Barrier. Thus, we don't mark this method async for now, disabling the rule,
+  // and we should think more about it in future.
+  // eslint-disable-next-line @typescript-eslint/promise-function-async
   then(onFulfilled, onRejected) {
     const res = super.then(onFulfilled, onRejected);
-    if (this.timeout !== undefined) res.init(this.timeout);
+    if (this.timeout !== undefined) void res.init(this.timeout);
     return res;
   }
 }
@@ -72,6 +82,11 @@ class Timer extends _Barrier.default {
  *  .abort() method attached, which cancels the pending timer resolution
  *  (without resolving or rejecting the barrier).
  */
+// TODO: For async functions TS requires the return type to be the global
+// Promise, thus not allowing to return our Timer type extending that via
+// Barrier. Thus, we don't mark this method async for now, disabling the rule,
+// and we should think more about it in future.
+// eslint-disable-next-line @typescript-eslint/promise-function-async
 exports.Timer = Timer;
 function timer(timeout) {
   const t = new Timer();

package/build/common/time.js.map

@@ -1 +1 @@
-{"version":3,"file":"time.js","names":["_Barrier","_interopRequireDefault","require","SEC_MS","exports","MIN_MS","HOUR_MS","DAY_MS","YEAR_MS","Timer","Barrier","abort","p_abort","timeout","p_timeout","constructor","executor","init","undefined","Error","id","setTimeout","resolve","bind","clearTimeout","then","onFulfilled","onRejected","res","timer","t"],"sources":["../../src/time.ts"],"sourcesContent":["import Barrier, { type Executor } from './Barrier';\n\n// This is not very elegant, but as of now TypeScript does not support type\n// arithmetic, thus we can't have constants assigned like `MIN_MS = 60 * SEC_MS`\n// and have the result type to be 60000 (number literal), it would be just\n// the generic number type.\nexport const SEC_MS = 1000;\nexport const MIN_MS = 60000; // 60 * SEC_MS\nexport const HOUR_MS = 3600000; // 60 * MIN_MS\nexport const DAY_MS = 86400000; // 24 * HOUR_MS\nexport const YEAR_MS = 31536000000; // 365 * DAY_MS\n\n// TODO: Ok, as we have ended up with a Timer class, mostly to achieve a good\n// TypeScript typing for timer() function, it makes sense to expose the class\n// from the library as well, and it should be documented later.\nexport class Timer<T> extends Barrier<void, T> {\n  private p_abort: () => void;\n\n  private p_timeout?: number;\n\n  get abort(): () => void { return this.p_abort; }\n\n  get timeout(): number | undefined { return this.p_timeout; }\n\n  /**\n   * Creates a new, non-initialized instance of Timer. Call .init() method\n   * to actually initialize and launch the timer.\n   *\n   * NOTE: Although it might be tempting to accept `timeout` value as\n   * a constructor's argument, it won't work well, because Timer is an\n   * extension of Promise (via Barrier), and the way Promises works (in\n   * particular their .then() method, which internally calls constructor()\n   * with special executor) does not play along with initalization depending\n   * on custom parameters done in constructor().\n   *\n   * @param executor\n   */\n  constructor(executor?: Executor<T>) {\n    super(executor);\n    this.p_abort = () => {};\n  }\n\n  init(timeout: number): Timer<T> {\n    if (this.p_timeout !== undefined) {\n      throw Error('This Timer is initialized already');\n    }\n    this.p_timeout = timeout;\n    if (timeout > 0) {\n      const id = setTimeout(super.resolve.bind(this), timeout);\n      this.p_abort = () => clearTimeout(id);\n    } else {\n      super.resolve();\n    }\n    return this;\n  }\n\n  then<TR1, TR2>(\n    onFulfilled?: ((value: T) => TR1 | PromiseLike<TR1>) | null,\n    onRejected?: ((reason: any) => TR2 | PromiseLike<TR2>) | null,\n  ): Timer<TR1 | TR2> {\n    const res = <Timer<TR1 | TR2>> super.then(onFulfilled, onRejected);\n    if (this.timeout !== undefined) res.init(this.timeout);\n    return res;\n  }\n}\n\n/**\n * Creates a Promise, which resolves after the given timeout.\n * @param {number} timeout Timeout [ms].\n * @return {Barrier} Resolves after the timeout. It has additional\n *  .abort() method attached, which cancels the pending timer resolution\n *  (without resolving or rejecting the barrier).\n */\nexport function timer(timeout: number): Timer<void> {\n  const t = new Timer<void>();\n  return t.init(timeout);\n}\n"],"mappings":";;;;;;;;AAAA,IAAAA,QAAA,GAAAC,sBAAA,CAAAC,OAAA;AAEA;AACA;AACA;AACA;AACO,MAAMC,MAAM,GAAAC,OAAA,CAAAD,MAAA,GAAG,IAAI;AACnB,MAAME,MAAM,GAAAD,OAAA,CAAAC,MAAA,GAAG,KAAK,CAAC,CAAC;AACtB,MAAMC,OAAO,GAAAF,OAAA,CAAAE,OAAA,GAAG,OAAO,CAAC,CAAC;AACzB,MAAMC,MAAM,GAAAH,OAAA,CAAAG,MAAA,GAAG,QAAQ,CAAC,CAAC;AACzB,MAAMC,OAAO,GAAAJ,OAAA,CAAAI,OAAA,GAAG,WAAW,CAAC,CAAC;;AAEpC;AACA;AACA;AACO,MAAMC,KAAK,SAAYC,gBAAO,CAAU;EAK7C,IAAIC,KAAKA,CAAA,EAAe;IAAE,OAAO,IAAI,CAACC,OAAO;EAAE;EAE/C,IAAIC,OAAOA,CAAA,EAAuB;IAAE,OAAO,IAAI,CAACC,SAAS;EAAE;;EAE3D;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEC,WAAWA,CAACC,QAAsB,EAAE;IAClC,KAAK,CAACA,QAAQ,CAAC;IACf,IAAI,CAACJ,OAAO,GAAG,MAAM,CAAC,CAAC;EACzB;EAEAK,IAAIA,CAACJ,OAAe,EAAY;IAC9B,IAAI,IAAI,CAACC,SAAS,KAAKI,SAAS,EAAE;MAChC,MAAMC,KAAK,CAAC,mCAAmC,CAAC;IAClD;IACA,IAAI,CAACL,SAAS,GAAGD,OAAO;IACxB,IAAIA,OAAO,GAAG,CAAC,EAAE;MACf,MAAMO,EAAE,GAAGC,UAAU,CAAC,KAAK,CAACC,OAAO,CAACC,IAAI,CAAC,IAAI,CAAC,EAAEV,OAAO,CAAC;MACxD,IAAI,CAACD,OAAO,GAAG,MAAMY,YAAY,CAACJ,EAAE,CAAC;IACvC,CAAC,MAAM;MACL,KAAK,CAACE,OAAO,CAAC,CAAC;IACjB;IACA,OAAO,IAAI;EACb;EAEAG,IAAIA,CACFC,WAA2D,EAC3DC,UAA6D,EAC3C;IAClB,MAAMC,GAAG,GAAsB,KAAK,CAACH,IAAI,CAACC,WAAW,EAAEC,UAAU,CAAC;IAClE,IAAI,IAAI,CAACd,OAAO,KAAKK,SAAS,EAAEU,GAAG,CAACX,IAAI,CAAC,IAAI,CAACJ,OAAO,CAAC;IACtD,OAAOe,GAAG;EACZ;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AANAxB,OAAA,CAAAK,KAAA,GAAAA,KAAA;AAOO,SAASoB,KAAKA,CAAChB,OAAe,EAAe;EAClD,MAAMiB,CAAC,GAAG,IAAIrB,KAAK,CAAO,CAAC;EAC3B,OAAOqB,CAAC,CAACb,IAAI,CAACJ,OAAO,CAAC;AACxB","ignoreList":[]}
+{"version":3,"file":"time.js","names":["_Barrier","_interopRequireDefault","require","SEC_MS","exports","MIN_MS","HOUR_MS","DAY_MS","YEAR_MS","Timer","Barrier","abort","pAbort","timeout","pTimeout","constructor","executor","undefined","init","Error","id","setTimeout","resolve","clearTimeout","then","onFulfilled","onRejected","res","timer","t"],"sources":["../../src/time.ts"],"sourcesContent":["import Barrier, { type Executor } from './Barrier';\n\n// This is not very elegant, but as of now TypeScript does not support type\n// arithmetic, thus we can't have constants assigned like `MIN_MS = 60 * SEC_MS`\n// and have the result type to be 60000 (number literal), it would be just\n// the generic number type.\nexport const SEC_MS = 1000;\nexport const MIN_MS = 60000; // 60 * SEC_MS\nexport const HOUR_MS = 3600000; // 60 * MIN_MS\nexport const DAY_MS = 86400000; // 24 * HOUR_MS\nexport const YEAR_MS = 31536000000; // 365 * DAY_MS\n\n// TODO: Ok, as we have ended up with a Timer class, mostly to achieve a good\n// TypeScript typing for timer() function, it makes sense to expose the class\n// from the library as well, and it should be documented later.\nexport class Timer<T> extends Barrier<void, T> {\n  private pAbort: () => void;\n\n  private pTimeout?: number;\n\n  get abort(): () => void {\n    return this.pAbort;\n  }\n\n  get timeout(): number | undefined {\n    return this.pTimeout;\n  }\n\n  /**\n   * Creates a new, non-initialized instance of Timer. Call .init() method\n   * to actually initialize and launch the timer.\n   *\n   * NOTE: Although it might be tempting to accept `timeout` value as\n   * a constructor's argument, it won't work well, because Timer is an\n   * extension of Promise (via Barrier), and the way Promises works (in\n   * particular their .then() method, which internally calls constructor()\n   * with special executor) does not play along with initalization depending\n   * on custom parameters done in constructor().\n   *\n   * @param executor\n   */\n  constructor(executor?: Executor<T>) {\n    super(executor);\n    this.pAbort = () => undefined;\n  }\n\n  init(timeout: number): this {\n    if (this.pTimeout !== undefined) {\n      throw Error('This Timer is initialized already');\n    }\n    this.pTimeout = timeout;\n    if (timeout > 0) {\n      const id = setTimeout(() => {\n        void super.resolve();\n      }, timeout);\n      this.pAbort = () => {\n        clearTimeout(id);\n      };\n    } else {\n      void super.resolve();\n    }\n    return this;\n  }\n\n  // TODO: For async functions TS requires the return type to be the global\n  // Promise, thus not allowing to return our Timer type extending that via\n  // Barrier. Thus, we don't mark this method async for now, disabling the rule,\n  // and we should think more about it in future.\n  // eslint-disable-next-line @typescript-eslint/promise-function-async\n  then<TR1, TR2>(\n    onFulfilled?: ((value: T) => TR1 | PromiseLike<TR1>) | null,\n    onRejected?: ((reason: unknown) => TR2 | PromiseLike<TR2>) | null,\n  ): Timer<TR1 | TR2> {\n    const res = super.then(onFulfilled, onRejected) as Timer<TR1 | TR2>;\n    if (this.timeout !== undefined) void res.init(this.timeout);\n    return res;\n  }\n}\n\n/**\n * Creates a Promise, which resolves after the given timeout.\n * @param {number} timeout Timeout [ms].\n * @return {Barrier} Resolves after the timeout. It has additional\n *  .abort() method attached, which cancels the pending timer resolution\n *  (without resolving or rejecting the barrier).\n */\n// TODO: For async functions TS requires the return type to be the global\n// Promise, thus not allowing to return our Timer type extending that via\n// Barrier. Thus, we don't mark this method async for now, disabling the rule,\n// and we should think more about it in future.\n// eslint-disable-next-line @typescript-eslint/promise-function-async\nexport function timer(timeout: number): Timer<void> {\n  const t = new Timer<void>();\n  return t.init(timeout);\n}\n"],"mappings":";;;;;;;;AAAA,IAAAA,QAAA,GAAAC,sBAAA,CAAAC,OAAA;AAEA;AACA;AACA;AACA;AACO,MAAMC,MAAM,GAAAC,OAAA,CAAAD,MAAA,GAAG,IAAI;AACnB,MAAME,MAAM,GAAAD,OAAA,CAAAC,MAAA,GAAG,KAAK,CAAC,CAAC;AACtB,MAAMC,OAAO,GAAAF,OAAA,CAAAE,OAAA,GAAG,OAAO,CAAC,CAAC;AACzB,MAAMC,MAAM,GAAAH,OAAA,CAAAG,MAAA,GAAG,QAAQ,CAAC,CAAC;AACzB,MAAMC,OAAO,GAAAJ,OAAA,CAAAI,OAAA,GAAG,WAAW,CAAC,CAAC;;AAEpC;AACA;AACA;AACO,MAAMC,KAAK,SAAYC,gBAAO,CAAU;EAK7C,IAAIC,KAAKA,CAAA,EAAe;IACtB,OAAO,IAAI,CAACC,MAAM;EACpB;EAEA,IAAIC,OAAOA,CAAA,EAAuB;IAChC,OAAO,IAAI,CAACC,QAAQ;EACtB;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEC,WAAWA,CAACC,QAAsB,EAAE;IAClC,KAAK,CAACA,QAAQ,CAAC;IACf,IAAI,CAACJ,MAAM,GAAG,MAAMK,SAAS;EAC/B;EAEAC,IAAIA,CAACL,OAAe,EAAQ;IAC1B,IAAI,IAAI,CAACC,QAAQ,KAAKG,SAAS,EAAE;MAC/B,MAAME,KAAK,CAAC,mCAAmC,CAAC;IAClD;IACA,IAAI,CAACL,QAAQ,GAAGD,OAAO;IACvB,IAAIA,OAAO,GAAG,CAAC,EAAE;MACf,MAAMO,EAAE,GAAGC,UAAU,CAAC,MAAM;QAC1B,KAAK,KAAK,CAACC,OAAO,CAAC,CAAC;MACtB,CAAC,EAAET,OAAO,CAAC;MACX,IAAI,CAACD,MAAM,GAAG,MAAM;QAClBW,YAAY,CAACH,EAAE,CAAC;MAClB,CAAC;IACH,CAAC,MAAM;MACL,KAAK,KAAK,CAACE,OAAO,CAAC,CAAC;IACtB;IACA,OAAO,IAAI;EACb;;EAEA;EACA;EACA;EACA;EACA;EACAE,IAAIA,CACFC,WAA2D,EAC3DC,UAAiE,EAC/C;IAClB,MAAMC,GAAG,GAAG,KAAK,CAACH,IAAI,CAACC,WAAW,EAAEC,UAAU,CAAqB;IACnE,IAAI,IAAI,CAACb,OAAO,KAAKI,SAAS,EAAE,KAAKU,GAAG,CAACT,IAAI,CAAC,IAAI,CAACL,OAAO,CAAC;IAC3D,OAAOc,GAAG;EACZ;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAAvB,OAAA,CAAAK,KAAA,GAAAA,KAAA;AACO,SAASmB,KAAKA,CAACf,OAAe,EAAe;EAClD,MAAMgB,CAAC,GAAG,IAAIpB,KAAK,CAAO,CAAC;EAC3B,OAAOoB,CAAC,CAACX,IAAI,CAACL,OAAO,CAAC;AACxB","ignoreList":[]}

package/build/common/withRetries.js

@@ -16,10 +16,7 @@ var _time = require("./time");
  * @returns Resolves to the result of the successful `action` execution;
  *  or rejects with the error from the last faileda attempt.
  */
-async function withRetries(action) {
-  let maxRetries = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3;
-  let interval = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 300;
-  /* eslint-disable no-await-in-loop */
+async function withRetries(action, maxRetries = 3, interval = 300) {
   for (let n = 1;; ++n) {
     try {
       const res = action();
@@ -28,6 +25,5 @@ async function withRetries(action) {
       if (n < maxRetries) await (0, _time.timer)(interval);else throw error;
     }
   }
-  /* eslint-enable no-await-in-loop */
 }
 //# sourceMappingURL=withRetries.js.map