@dr.pogodin/js-utils 0.0.14 → 0.0.16

package/babel.config.js

@@ -1,8 +1,10 @@
 // Babel is used for Jest testing.
 
-module.exports = {
+export default {
   presets: [
-    ['@babel/preset-env', { targets: { node: 'current' } }],
-    '@babel/preset-typescript',
+    ['./config/babel/preset', {
+      modules: 'cjs',
+      targets: 'defaults',
+    }],
   ],
 };

package/babel.module.config.js

@@ -0,0 +1,10 @@
+// Babel is used for Jest testing.
+
+export default {
+  presets: [
+    ['./config/babel/preset', {
+      modules: false,
+      targets: 'defaults',
+    }],
+  ],
+};

package/{src/Barrier.ts → build/common/Barrier.js}

@@ -1,14 +1,15 @@
-export type Executor<T> = ConstructorParameters<typeof Promise<T>>[0];
-
-type Resolver<T> = Parameters<Executor<T>>[0];
-type Rejecter = Parameters<Executor<unknown>>[1];
-
-enum STATE {
-  PENDING = 'PENDING',
-  REJECTED = 'REJECTED',
-  RESOLVED = 'RESOLVED',
-}
-
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var STATE = /*#__PURE__*/function (STATE) {
+  STATE["PENDING"] = "PENDING";
+  STATE["REJECTED"] = "REJECTED";
+  STATE["RESOLVED"] = "RESOLVED";
+  return STATE;
+}(STATE || {});
 /**
  * Barrier is just a Promise which has resolve and reject exposed as instance
  * methods.
@@ -32,20 +33,14 @@ enum STATE {
  *
  * Docs: https://dr.pogodin.studio/docs/react-utils/docs/api/classes/Barrier
  */
-export default class Barrier<T = unknown, TR = T> extends Promise<TR> {
-  private p_resolve: Resolver<T>;
-
-  private p_reject: Rejecter;
-
-  private p_state = STATE.PENDING;
-
-  constructor(executor?: Executor<TR>) {
-    let resolveRef: Resolver<TR>;
-    let rejectRef: Rejecter;
-
+class Barrier extends Promise {
+  p_state = (() => STATE.PENDING)();
+  constructor(executor) {
+    let resolveRef;
+    let rejectRef;
     super((resolve, reject) => {
       // Note: Enforcing `void` return type because of the BEWARE note below.
-      resolveRef = (value: TR | PromiseLike<TR>): void => {
+      resolveRef = value => {
         resolve(value);
         this.p_state = STATE.RESOLVED;
 
@@ -57,11 +52,10 @@ export default class Barrier<T = unknown, TR = T> extends Promise<TR> {
       };
 
       // Note: Enforcing `void` return type because of the BEWARE note below.
-      rejectRef = (reason?: any): void => {
+      rejectRef = reason => {
         reject(reason);
         this.p_state = STATE.REJECTED;
       };
-
       if (executor) executor(resolveRef, rejectRef);
     });
 
@@ -69,48 +63,42 @@ export default class Barrier<T = unknown, TR = T> extends Promise<TR> {
     // 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! as Resolver<T>;
-
-    this.p_reject = rejectRef!;
+    this.p_resolve = resolveRef;
+    this.p_reject = rejectRef;
   }
-
   get resolve() {
-    return (arg: Parameters<Resolver<T>>[0]) => {
+    return arg => {
       this.p_resolve(arg);
       return this;
     };
   }
-
   get reject() {
-    return (arg: Parameters<Rejecter>[0]) => {
+    return arg => {
       this.p_reject(arg);
       return this;
     };
   }
-
-  get resolved() { return this.p_state === STATE.RESOLVED; }
-
-  get rejected() { return this.p_state === STATE.REJECTED; }
-
-  get settled() { return this.p_state !== STATE.PENDING; }
-
-  catch<TR1>(
-    onRejected?: ((reason: any) => TR1 | PromiseLike<TR1>) | null,
-  ): Barrier<T, TR1> {
-    return <Barrier<T, TR1>> super.catch(onRejected);
+  get resolved() {
+    return this.p_state === STATE.RESOLVED;
   }
-
-  finally(onFinally?: (() => void) | null): Barrier<TR> {
-    return <Barrier<TR>> super.finally(onFinally);
+  get rejected() {
+    return this.p_state === STATE.REJECTED;
   }
-
-  then<TR1, TR2>(
-    onFulfilled?: ((value: TR) => TR1 | PromiseLike<TR1>) | null,
-    onRejected?: ((reason: any) => TR2 | PromiseLike<TR2>) | null,
-  ): Barrier<T, TR1 | TR2> {
-    const res = <Barrier<T, TR1 | TR2>> super.then(onFulfilled, onRejected);
+  get settled() {
+    return this.p_state !== STATE.PENDING;
+  }
+  catch(onRejected) {
+    return super.catch(onRejected);
+  }
+  finally(onFinally) {
+    return super.finally(onFinally);
+  }
+  then(onFulfilled, onRejected) {
+    const res = super.then(onFulfilled, onRejected);
     res.p_resolve = this.resolve;
     res.p_reject = this.reject;
     return res;
   }
 }
+exports.default = Barrier;
+//# sourceMappingURL=Barrier.js.map

package/build/common/Barrier.js.map

@@ -0,0 +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":[]}

package/{src/Emitter.ts → build/common/Emitter.js}

@@ -1,27 +1,32 @@
-export type Listener<T extends unknown[] = unknown[]> = (...args: T) => void;
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Emitter = void 0;
 /**
  * Simple listeneable data Emitter.
  */
-export class Emitter<T extends unknown[] = unknown[]> {
-  private p_listeners: Listener<T>[] = [];
+class Emitter {
+  p_listeners = [];
 
   /**
    * Returns "true" if any listener is connected; "false" otherwise.
    * @return {boolean}
    */
-  get hasListeners(): boolean {
+  get hasListeners() {
     return !!this.p_listeners.length;
   }
-
-  get listeners(): ReadonlyArray<Listener<T>> { return this.p_listeners; }
+  get listeners() {
+    return this.p_listeners;
+  }
 
   /**
    * Adds `listener` if it is not already connected.
    * @param {function} listener
    * @return {function} Unsubscribe function.
    */
-  addListener(listener: Listener<T>): () => void {
+  addListener(listener) {
     if (!this.p_listeners.includes(listener)) {
       this.p_listeners.push(listener);
     }
@@ -32,11 +37,9 @@ export class Emitter<T extends unknown[] = unknown[]> {
    * Calls every connected listener with the given arguments.
    * @param args
    */
-  emit(...args: T) {
+  emit() {
     const listeners = this.p_listeners.slice();
-    for (let i = 0; i < listeners.length; ++i) {
-      listeners[i](...args);
-    }
+    for (const listener of listeners) listener(...arguments);
   }
 
   /**
@@ -50,8 +53,10 @@ export class Emitter<T extends unknown[] = unknown[]> {
    * Removes specified `listener`, if connected.
    * @param listener
    */
-  removeListener(listener: Listener<T>) {
+  removeListener(listener) {
     const idx = this.p_listeners.indexOf(listener);
     if (idx >= 0) this.p_listeners.splice(idx, 1);
   }
 }
+exports.Emitter = Emitter;
+//# sourceMappingURL=Emitter.js.map

package/build/common/Emitter.js.map

@@ -0,0 +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":[]}

package/build/common/Semaphore.js

@@ -0,0 +1,85 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+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;
+  }
+  get ready() {
+    return this.p_ready;
+  }
+  setReady(ready) {
+    const bool = !!ready;
+    if (this.p_ready !== bool) {
+      this.p_ready = bool;
+      if (bool && !this.p_draining && this.p_queue.length) {
+        this.p_drainQueue();
+      }
+    }
+  }
+
+  /**
+   * 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) {
+      const barrier = new _Barrier.default();
+      this.p_queue.push(barrier);
+      await barrier;
+      if (seize) this.p_ready = false;
+      this.p_drainLock.resolve();
+    } else if (seize) this.p_ready = false;
+  }
+
+  // Private members below this point.
+
+  /**
+   * If semaphore is ready, it releases the next barrier in the queue, if any,
+   * and reschedules itself for a call in the next event loop iteration.
+   * 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();
+    }
+    this.p_draining = false;
+    this.p_drainLock = null;
+  }
+
+  // "true" when the drain queue process is running (and thus no need to start
+  // a new one).
+  p_draining = false;
+
+  // Each time a Promise from drain queue is resolved this drainLock is set
+  // to block further queue draining until the promise resolution handler
+  // (.seize() or .waitReady()) unlocks it, thus confirming it is fine
+  // 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;
+
+  // The array of barriers set for each async code flow awaiting for
+  // the Semaphore to become ready.
+  p_queue = [];
+}
+exports.default = Semaphore;
+//# sourceMappingURL=Semaphore.js.map

package/build/common/Semaphore.js.map

@@ -0,0 +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":[]}

package/build/common/index.js

@@ -0,0 +1,57 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  Barrier: true,
+  Semaphore: true,
+  withRetries: true
+};
+Object.defineProperty(exports, "Barrier", {
+  enumerable: true,
+  get: function () {
+    return _Barrier.default;
+  }
+});
+Object.defineProperty(exports, "Semaphore", {
+  enumerable: true,
+  get: function () {
+    return _Semaphore.default;
+  }
+});
+Object.defineProperty(exports, "withRetries", {
+  enumerable: true,
+  get: function () {
+    return _withRetries.default;
+  }
+});
+var _Barrier = _interopRequireDefault(require("./Barrier"));
+var _Emitter = require("./Emitter");
+Object.keys(_Emitter).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Emitter[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Emitter[key];
+    }
+  });
+});
+var _Semaphore = _interopRequireDefault(require("./Semaphore"));
+var _time = require("./time");
+Object.keys(_time).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _time[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _time[key];
+    }
+  });
+});
+var _withRetries = _interopRequireDefault(require("./withRetries"));
+//# sourceMappingURL=index.js.map

package/build/common/index.js.map

@@ -0,0 +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":[]}

package/build/common/time.js

@@ -0,0 +1,80 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.YEAR_MS = exports.Timer = exports.SEC_MS = exports.MIN_MS = exports.HOUR_MS = exports.DAY_MS = void 0;
+exports.timer = timer;
+var _Barrier = _interopRequireDefault(require("./Barrier"));
+// This is not very elegant, but as of now TypeScript does not support type
+// arithmetic, thus we can't have constants assigned like `MIN_MS = 60 * SEC_MS`
+// and have the result type to be 60000 (number literal), it would be just
+// the generic number type.
+const SEC_MS = exports.SEC_MS = 1000;
+const MIN_MS = exports.MIN_MS = 60000; // 60 * SEC_MS
+const HOUR_MS = exports.HOUR_MS = 3600000; // 60 * MIN_MS
+const DAY_MS = exports.DAY_MS = 86400000; // 24 * HOUR_MS
+const YEAR_MS = exports.YEAR_MS = 31536000000; // 365 * DAY_MS
+
+// TODO: Ok, as we have ended up with a Timer class, mostly to achieve a good
+// TypeScript typing for timer() function, it makes sense to expose the class
+// from the library as well, and it should be documented later.
+class Timer extends _Barrier.default {
+  get abort() {
+    return this.p_abort;
+  }
+  get timeout() {
+    return this.p_timeout;
+  }
+
+  /**
+   * Creates a new, non-initialized instance of Timer. Call .init() method
+   * to actually initialize and launch the timer.
+   *
+   * NOTE: Although it might be tempting to accept `timeout` value as
+   * a constructor's argument, it won't work well, because Timer is an
+   * extension of Promise (via Barrier), and the way Promises works (in
+   * particular their .then() method, which internally calls constructor()
+   * with special executor) does not play along with initalization depending
+   * on custom parameters done in constructor().
+   *
+   * @param executor
+   */
+  constructor(executor) {
+    super(executor);
+    this.p_abort = () => {};
+  }
+  init(timeout) {
+    if (this.p_timeout !== undefined) {
+      throw Error('This Timer is initialized already');
+    }
+    this.p_timeout = timeout;
+    if (timeout > 0) {
+      const id = setTimeout(super.resolve.bind(this), timeout);
+      this.p_abort = () => clearTimeout(id);
+    } else {
+      super.resolve();
+    }
+    return this;
+  }
+  then(onFulfilled, onRejected) {
+    const res = super.then(onFulfilled, onRejected);
+    if (this.timeout !== undefined) res.init(this.timeout);
+    return res;
+  }
+}
+
+/**
+ * Creates a Promise, which resolves after the given timeout.
+ * @param {number} timeout Timeout [ms].
+ * @return {Barrier} Resolves after the timeout. It has additional
+ *  .abort() method attached, which cancels the pending timer resolution
+ *  (without resolving or rejecting the barrier).
+ */
+exports.Timer = Timer;
+function timer(timeout) {
+  const t = new Timer();
+  return t.init(timeout);
+}
+//# sourceMappingURL=time.js.map

package/build/common/time.js.map

@@ -0,0 +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":[]}

package/build/common/withRetries.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = withRetries;
+var _time = require("./time");
+/**
+ * Attempts to perform the given async `action` up to `maxRetries` times with
+ * the specified `interval`, stopping at the first successful (non-throwing)
+ * execution.
+ * @param action
+ * @param maxRetries Optional. The maximum number of re-tries. Defaults 3.
+ * @param interval Optional. The interval between re-tries (in milliseconds).
+ *  Defaults to 300ms.
+ * @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 */
+  for (let n = 1;; ++n) {
+    try {
+      const res = action();
+      return res instanceof Promise ? await res : res;
+    } catch (error) {
+      if (n < maxRetries) await (0, _time.timer)(interval);else throw error;
+    }
+  }
+  /* eslint-enable no-await-in-loop */
+}
+//# sourceMappingURL=withRetries.js.map

package/build/common/withRetries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withRetries.js","names":["_time","require","withRetries","action","maxRetries","arguments","length","undefined","interval","n","res","Promise","error","timer"],"sources":["../../src/withRetries.ts"],"sourcesContent":["import { timer } from './time';\n\n/**\n * Attempts to perform the given async `action` up to `maxRetries` times with\n * the specified `interval`, stopping at the first successful (non-throwing)\n * execution.\n * @param action\n * @param maxRetries Optional. The maximum number of re-tries. Defaults 3.\n * @param interval Optional. The interval between re-tries (in milliseconds).\n *  Defaults to 300ms.\n * @returns Resolves to the result of the successful `action` execution;\n *  or rejects with the error from the last faileda attempt.\n */\nexport default async function withRetries<T>(\n  action: () => T,\n  maxRetries = 3,\n  interval = 300,\n): Promise<Awaited<T>> {\n  /* eslint-disable no-await-in-loop */\n  for (let n = 1; ; ++n) {\n    try {\n      const res = action();\n      return res instanceof Promise ? await res : (res as Awaited<T>);\n    } catch (error) {\n      if (n < maxRetries) await timer(interval);\n      else throw error;\n    }\n  }\n  /* eslint-enable no-await-in-loop */\n}\n"],"mappings":";;;;;;AAAA,IAAAA,KAAA,GAAAC,OAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,eAAeC,WAAWA,CACvCC,MAAe,EAGM;EAAA,IAFrBC,UAAU,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC;EAAA,IACdG,QAAQ,GAAAH,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,GAAG;EAEd;EACA,KAAK,IAAII,CAAC,GAAG,CAAC,GAAI,EAAEA,CAAC,EAAE;IACrB,IAAI;MACF,MAAMC,GAAG,GAAGP,MAAM,CAAC,CAAC;MACpB,OAAOO,GAAG,YAAYC,OAAO,GAAG,MAAMD,GAAG,GAAIA,GAAkB;IACjE,CAAC,CAAC,OAAOE,KAAK,EAAE;MACd,IAAIH,CAAC,GAAGL,UAAU,EAAE,MAAM,IAAAS,WAAK,EAACL,QAAQ,CAAC,CAAC,KACrC,MAAMI,KAAK;IAClB;EACF;EACA;AACF","ignoreList":[]}

package/build/module/Barrier.js

@@ -0,0 +1,97 @@
+var STATE = /*#__PURE__*/function (STATE) {
+  STATE["PENDING"] = "PENDING";
+  STATE["REJECTED"] = "REJECTED";
+  STATE["RESOLVED"] = "RESOLVED";
+  return STATE;
+}(STATE || {});
+/**
+ * Barrier is just a Promise which has resolve and reject exposed as instance
+ * methods.
+ *
+ * It has two generic arguments T and TR which correspond to the argument of
+ * the .resolve() method, and to the value resolved by the promise (barrier).
+ * For a simple barrier TR equals to T, however for barriers created via .then()
+ * chain, T corresponds to the argument of the original barrier, and TR to
+ * the value resolved by the latest promise in the chain. Consider this:
+ *
+ * const b = new Barrier<string>();
+ * b.resolve('result');
+ * const s = await b; // `s` has `string` type, and equals "result".
+ *
+ * const b = (new Barrier<string>()).then((s) => s.length);
+ * b.resolve('result'); // Chained barrier exposes .resolve() method of
+ *                      // the first barrier in the chain, which expects
+ *                      // `string` arugment (T), but the chained barrier
+ *                      // resolves to `number` (TR).
+ * const n = await b; // `n` has `number` type, and equals 6.
+ *
+ * Docs: https://dr.pogodin.studio/docs/react-utils/docs/api/classes/Barrier
+ */
+export default class Barrier extends Promise {
+  p_state = (() => STATE.PENDING)();
+  constructor(executor) {
+    let resolveRef;
+    let rejectRef;
+    super((resolve, reject) => {
+      // Note: Enforcing `void` return type because of the BEWARE note below.
+      resolveRef = value => {
+        resolve(value);
+        this.p_state = STATE.RESOLVED;
+
+        // BEWARE: Don't try to return `this` here, it will easily cause
+        // infinite loops in React Native, which are extremely difficult
+        // to troubleshoot (I wasn't able to figure out, are they due to
+        // internal Promise implementation in RN, or because of some bad
+        // patterns in the host code).
+      };
+
+      // Note: Enforcing `void` return type because of the BEWARE note below.
+      rejectRef = reason => {
+        reject(reason);
+        this.p_state = STATE.REJECTED;
+      };
+      if (executor) executor(resolveRef, rejectRef);
+    });
+
+    // NOTE: We assume, the only scenario where TR is not equal T is when
+    // 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;
+  }
+  get resolve() {
+    return arg => {
+      this.p_resolve(arg);
+      return this;
+    };
+  }
+  get reject() {
+    return arg => {
+      this.p_reject(arg);
+      return this;
+    };
+  }
+  get resolved() {
+    return this.p_state === STATE.RESOLVED;
+  }
+  get rejected() {
+    return this.p_state === STATE.REJECTED;
+  }
+  get settled() {
+    return this.p_state !== STATE.PENDING;
+  }
+  catch(onRejected) {
+    return super.catch(onRejected);
+  }
+  finally(onFinally) {
+    return super.finally(onFinally);
+  }
+  then(onFulfilled, onRejected) {
+    const res = super.then(onFulfilled, onRejected);
+    res.p_resolve = this.resolve;
+    res.p_reject = this.reject;
+    return res;
+  }
+}
+//# sourceMappingURL=Barrier.js.map