@dr.pogodin/js-utils 0.0.1

package/LICENSE.md

@@ -0,0 +1,22 @@
+# MIT License
+
+_Copyright © 2023, Dr. Sergey Pogodin_
+  &mdash; <doc@pogodin.studio> (https://dr.pogodin.studio) \
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,27 @@
+[React Utils]: https://github.com/birdofpreyru/react-utils
+
+# JS Utils
+
+[_TODO: Latest NPM version / Link to NPM package page_]
+[_TODO: NPM monthly downloads count / Link to NPM package page_]
+[_TODO: CircleCI status of primary branch build / Link to CircleCI project page_]
+[![GitHub repo stars](https://img.shields.io/github/stars/birdofpreyru/js-utils?style=social)](https://github.com/birdofpreyru/js-utils)
+
+The aim for this repo/package is to move in from the [React Utils] the pieces
+which are not React-specific, thus are also useful cross non-React projects,
+and thus having them in a dedicated package will faciliate their re-use
+in generic JavaScript (and TypeScript) projects.
+
+At least for the first time, all stuff moved in here will still be exposed from
+[React Utils] the same  way as before, and the documentation for these pieces
+will be still kept at https://dr.pogodin.studio/docs/react-utils/index.html.
+Maybe later, time permitting, this will be documented as a stand-alone library,
+but prior to that it will be maintained and used as a stand-alone lib, but not
+very well documented as such.
+
+Yeah, the source code will be written in TypeScript, and for the library
+version released to NPM it will be also compiled into plain JavaScript.
+Consumers of that NPM package thus will have access to both TS (`/ts` folder)
+and JS (`/js` folder) version of the library.
+
+[![Sponsor](.README/sponsor.png)](https://github.com/sponsors/birdofpreyru)

package/babel.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  presets: [
+    ['@babel/preset-env', { targets: { node: 'current' } }],
+    '@babel/preset-typescript',
+  ],
+};

package/bin/release.sh

@@ -0,0 +1,6 @@
+#/bin/sh
+
+set -e # Interrupt the deployment if any command fails.
+
+echo "//registry.npmjs.org/:_authToken=$NPM_TOKEN" >> ~/.npmrc
+npm publish --access public

package/jest.config.js

@@ -0,0 +1,4 @@
+module.exports = {
+  collectCoverage: true,
+  coverageDirectory: '__coverage__',
+};

package/js/Barrier.d.ts

@@ -0,0 +1,24 @@
+type Resolver<T> = (value: T | PromiseLike<T>) => void;
+type Rejecter = (reason?: any) => void;
+export type Executor<T> = (resolve: Resolver<T>, reject: Rejecter) => void;
+/**
+ * Barrier is just a Promise which has resolve and reject exposed as instance
+ * methods.
+ *
+ * Docs: https://dr.pogodin.studio/docs/react-utils/docs/api/classes/Barrier
+ */
+export default class Barrier<T, TR = T> extends Promise<TR> {
+    private p_resolve;
+    private p_reject;
+    private p_state;
+    constructor(executor?: Executor<TR>);
+    get resolve(): Resolver<T>;
+    get reject(): Rejecter;
+    get resolved(): boolean;
+    get rejected(): boolean;
+    get settled(): boolean;
+    catch<TR1>(onRejected?: ((reason: any) => TR1 | PromiseLike<TR1>) | null): Barrier<T, TR1>;
+    finally(onFinally?: (() => void) | null): Barrier<TR>;
+    then<TR1, TR2>(onFulfilled?: ((value: TR) => TR1 | PromiseLike<TR1>) | null, onRejected?: ((reason: any) => TR2 | PromiseLike<TR2>) | null): Barrier<T, TR1 | TR2>;
+}
+export {};

package/js/Barrier.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var STATE;
+(function (STATE) {
+    STATE["PENDING"] = "PENDING";
+    STATE["REJECTED"] = "REJECTED";
+    STATE["RESOLVED"] = "RESOLVED";
+})(STATE || (STATE = {}));
+/**
+ * Barrier is just a Promise which has resolve and reject exposed as instance
+ * methods.
+ *
+ * Docs: https://dr.pogodin.studio/docs/react-utils/docs/api/classes/Barrier
+ */
+class Barrier extends Promise {
+    constructor(executor) {
+        let resolveRef;
+        let rejectRef;
+        super((resolve, reject) => {
+            resolveRef = (value) => {
+                resolve(value);
+                this.p_state = STATE.RESOLVED;
+            };
+            rejectRef = (reason) => {
+                reject(reason);
+                this.p_state = STATE.REJECTED;
+            };
+            if (executor)
+                executor(resolveRef, rejectRef);
+        });
+        this.p_state = STATE.PENDING;
+        this.p_resolve = resolveRef;
+        this.p_reject = rejectRef;
+    }
+    get resolve() { return this.p_resolve; }
+    get reject() { return this.p_reject; }
+    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;
+    }
+}
+exports.default = Barrier;

package/js/Emitter.d.ts

@@ -0,0 +1,30 @@
+type Listener = (...args: any[]) => void;
+/**
+ * Simple listeneable data Emitter.
+ */
+export default class Emitter {
+    private p_listeners;
+    /**
+     * Returns "true" if any listener is connected; "false" otherwise.
+     * @return {boolean}
+     */
+    get hasListeners(): boolean;
+    get listeners(): ReadonlyArray<Listener>;
+    /**
+     * Adds `listener` if it is not already connected.
+     * @param {function} listener
+     * @return {function} Unsubscribe function.
+     */
+    addListener(listener: Listener): () => void;
+    /**
+     * Calls every connected listener with the given arguments.
+     * @param  {...any} args
+     */
+    emit(...args: any[]): void;
+    /**
+     * Removes specified `listener`, if connected.
+     * @param {function} listener
+     */
+    removeListener(listener: Listener): void;
+}
+export {};

package/js/Emitter.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Simple listeneable data Emitter.
+ */
+class Emitter {
+    constructor() {
+        this.p_listeners = [];
+    }
+    /**
+     * Returns "true" if any listener is connected; "false" otherwise.
+     * @return {boolean}
+     */
+    get hasListeners() {
+        return !!this.p_listeners.length;
+    }
+    get listeners() { return this.p_listeners; }
+    /**
+     * Adds `listener` if it is not already connected.
+     * @param {function} listener
+     * @return {function} Unsubscribe function.
+     */
+    addListener(listener) {
+        if (!this.p_listeners.includes(listener)) {
+            this.p_listeners.push(listener);
+        }
+        return () => this.removeListener(listener);
+    }
+    /**
+     * Calls every connected listener with the given arguments.
+     * @param  {...any} args
+     */
+    emit(...args) {
+        const { p_listeners: listeners } = this;
+        for (let i = 0; i < listeners.length; ++i) {
+            listeners[i](...args);
+        }
+    }
+    /**
+     * Removes specified `listener`, if connected.
+     * @param {function} listener
+     */
+    removeListener(listener) {
+        const idx = this.p_listeners.indexOf(listener);
+        if (idx >= 0)
+            this.p_listeners.splice(idx, 1);
+    }
+}
+exports.default = Emitter;

package/js/Semaphore.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Implements a simple semaphore for async code logic.
+ */
+export default class Semaphore {
+    constructor(ready?: boolean);
+    get ready(): boolean;
+    setReady(ready: boolean): void;
+    /**
+     * Waits until the semaphore is ready, and marks it as non-ready (seizes it).
+     * @return {Promise}
+     */
+    seize(): Promise<void>;
+    waitReady(seize?: boolean): Promise<void>;
+    /**
+     * 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.
+     */
+    p_drainQueue(): Promise<void>;
+    private p_draining;
+    private p_drainLock;
+    private p_queue;
+    private p_ready;
+}

package/js/Semaphore.js

@@ -0,0 +1,90 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Barrier_1 = __importDefault(require("./Barrier"));
+/**
+ * Implements a simple semaphore for async code logic.
+ */
+class Semaphore {
+    constructor(ready = false) {
+        // "true" when the drain queue process is running (and thus no need to start
+        // a new one).
+        this.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.
+        this.p_drainLock = null;
+        // The array of barriers set for each async code flow awaiting for
+        // the Semaphore to become ready.
+        this.p_queue = [];
+        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}
+     */
+    seize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.waitReady(true);
+        });
+    }
+    waitReady(seize = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.p_ready || this.p_queue.length) {
+                const barrier = new Barrier_1.default();
+                this.p_queue.push(barrier);
+                yield 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.
+     */
+    p_drainQueue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.p_draining = true;
+            while (this.p_ready && this.p_queue.length) {
+                this.p_drainLock = new Barrier_1.default();
+                this.p_queue[0].resolve();
+                yield this.p_drainLock; // eslint-disable-line no-await-in-loop
+                this.p_queue.shift();
+            }
+            this.p_draining = false;
+            this.p_drainLock = null;
+        });
+    }
+}
+exports.default = Semaphore;

package/js/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Barrier } from './Barrier';
+export { default as Emitter } from './Emitter';
+export { default as Semaphore } from './Semaphore';
+export * from './time';

package/js/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Semaphore = exports.Emitter = exports.Barrier = void 0;
+var Barrier_1 = require("./Barrier");
+Object.defineProperty(exports, "Barrier", { enumerable: true, get: function () { return __importDefault(Barrier_1).default; } });
+var Emitter_1 = require("./Emitter");
+Object.defineProperty(exports, "Emitter", { enumerable: true, get: function () { return __importDefault(Emitter_1).default; } });
+var Semaphore_1 = require("./Semaphore");
+Object.defineProperty(exports, "Semaphore", { enumerable: true, get: function () { return __importDefault(Semaphore_1).default; } });
+__exportStar(require("./time"), exports);

package/js/time.d.ts

@@ -0,0 +1,13 @@
+export declare const SEC_MS = 1000;
+export declare const MIN_MS: number;
+export declare const HOUR_MS: number;
+export declare const DAY_MS: number;
+export declare const YEAR_MS: number;
+/**
+ * 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).
+ */
+export declare function timer(timeout: number): Promise<void>;

package/js/time.js

@@ -0,0 +1,53 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timer = exports.YEAR_MS = exports.DAY_MS = exports.HOUR_MS = exports.MIN_MS = exports.SEC_MS = void 0;
+const Barrier_1 = __importDefault(require("./Barrier"));
+exports.SEC_MS = 1000;
+exports.MIN_MS = 60 * exports.SEC_MS;
+exports.HOUR_MS = 60 * exports.MIN_MS;
+exports.DAY_MS = 24 * exports.HOUR_MS;
+exports.YEAR_MS = 365 * exports.DAY_MS;
+class Timer extends Barrier_1.default {
+    get abort() { return this.p_abort; }
+    constructor(executor, timeout = 0) {
+        super(executor);
+        if (timeout > 0) {
+            const id = setTimeout(super.resolve.bind(this), timeout);
+            this.p_abort = () => clearTimeout(id);
+        }
+        else {
+            this.p_abort = () => { };
+            super.resolve();
+        }
+    }
+    then(onFulfilled, onRejected) {
+        const res = super.then(onFulfilled, onRejected);
+        res.p_abort = this.p_abort;
+        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).
+ */
+function timer(timeout) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Timer(undefined, timeout);
+    });
+}
+exports.timer = timer;

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@dr.pogodin/js-utils",
+  "version": "0.0.1",
+  "description": "Collection of JavaScript (TypeScript) utilities.",
+  "main": "js/index",
+  "react-native": "ts/index",
+  "source": "ts/index",
+  "types": "js/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "jest": "jest --config jest.config.js",
+    "lint": "eslint . --ext .js,.ts",
+    "test": "npm run lint && npm run typecheck && npm run jest",
+    "typecheck": "tsc --noEmit && tsc --project __tests__/tsconfig.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/birdofpreyru/js-utils.git"
+  },
+  "keywords": [
+    "javascript",
+    "util",
+    "utility"
+  ],
+  "author": "Dr. Sergey Pogodin <doc@pogodin.studio> (https://dr.pogodin.studio)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/birdofpreyru/js-utils/issues"
+  },
+  "homepage": "https://github.com/birdofpreyru/js-utils#readme",
+  "devDependencies": {
+    "@babel/core": "^7.21.4",
+    "@babel/preset-env": "^7.21.4",
+    "@babel/preset-typescript": "^7.21.4",
+    "@tsconfig/recommended": "^1.0.2",
+    "@types/jest": "^29.5.1",
+    "@typescript-eslint/eslint-plugin": "^5.59.1",
+    "@typescript-eslint/parser": "^5.59.1",
+    "babel-jest": "^29.5.0",
+    "eslint": "^8.39.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-airbnb-typescript": "^17.0.0",
+    "eslint-import-resolver-typescript": "^3.5.5",
+    "eslint-plugin-import": "^2.27.5",
+    "jest": "^29.5.0",
+    "typescript": "^5.0.4"
+  }
+}

package/ts/Barrier.ts

@@ -0,0 +1,73 @@
+type Resolver<T> = (value: T | PromiseLike<T>) => void;
+type Rejecter = (reason?: any) => void;
+export type Executor<T> = (resolve: Resolver<T>, reject: Rejecter) => void;
+
+enum STATE {
+  PENDING = 'PENDING',
+  REJECTED = 'REJECTED',
+  RESOLVED = 'RESOLVED',
+}
+
+/**
+ * Barrier is just a Promise which has resolve and reject exposed as instance
+ * methods.
+ *
+ * Docs: https://dr.pogodin.studio/docs/react-utils/docs/api/classes/Barrier
+ */
+export default class Barrier<T, TR = T> extends Promise<TR> {
+  private p_resolve: Resolver<T> | Resolver<TR>;
+
+  private p_reject: Rejecter;
+
+  private p_state = STATE.PENDING;
+
+  constructor(executor?: Executor<TR>) {
+    let resolveRef: Resolver<TR>;
+    let rejectRef: Rejecter;
+
+    super((resolve, reject) => {
+      resolveRef = (value: TR | PromiseLike<TR>) => {
+        resolve(value);
+        this.p_state = STATE.RESOLVED;
+      };
+      rejectRef = (reason?: any) => {
+        reject(reason);
+        this.p_state = STATE.REJECTED;
+      };
+      if (executor) executor(resolveRef, rejectRef);
+    });
+
+    this.p_resolve = resolveRef!;
+    this.p_reject = rejectRef!;
+  }
+
+  get resolve() { return <Resolver<T>> this.p_resolve; }
+
+  get reject() { return this.p_reject; }
+
+  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);
+  }
+
+  finally(onFinally?: (() => void) | null): Barrier<TR> {
+    return <Barrier<TR>> super.finally(onFinally);
+  }
+
+  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);
+    res.p_resolve = this.resolve;
+    res.p_reject = this.reject;
+    return res;
+  }
+}

package/ts/Emitter.ts

@@ -0,0 +1,50 @@
+type Listener = (...args: any[]) => void;
+
+/**
+ * Simple listeneable data Emitter.
+ */
+export default class Emitter {
+  private p_listeners: Listener[] = [];
+
+  /**
+   * Returns "true" if any listener is connected; "false" otherwise.
+   * @return {boolean}
+   */
+  get hasListeners(): boolean {
+    return !!this.p_listeners.length;
+  }
+
+  get listeners(): ReadonlyArray<Listener> { return this.p_listeners; }
+
+  /**
+   * Adds `listener` if it is not already connected.
+   * @param {function} listener
+   * @return {function} Unsubscribe function.
+   */
+  addListener(listener: Listener): () => void {
+    if (!this.p_listeners.includes(listener)) {
+      this.p_listeners.push(listener);
+    }
+    return () => this.removeListener(listener);
+  }
+
+  /**
+   * Calls every connected listener with the given arguments.
+   * @param  {...any} args
+   */
+  emit(...args: any[]) {
+    const { p_listeners: listeners } = this;
+    for (let i = 0; i < listeners.length; ++i) {
+      listeners[i](...args);
+    }
+  }
+
+  /**
+   * Removes specified `listener`, if connected.
+   * @param {function} listener
+   */
+  removeListener(listener: Listener) {
+    const idx = this.p_listeners.indexOf(listener);
+    if (idx >= 0) this.p_listeners.splice(idx, 1);
+  }
+}

package/ts/Semaphore.ts

@@ -0,0 +1,78 @@
+import Barrier from './Barrier';
+
+/**
+ * Implements a simple semaphore for async code logic.
+ */
+export default class Semaphore {
+  constructor(ready = false) {
+    this.p_ready = !!ready;
+  }
+
+  get ready() { return this.p_ready; }
+
+  setReady(ready: boolean) {
+    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(seize = false) {
+    if (!this.p_ready || this.p_queue.length) {
+      const barrier = new Barrier<void>();
+      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();
+      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).
+  private 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.
+  private p_drainLock: Barrier<void> | null = null;
+
+  // The array of barriers set for each async code flow awaiting for
+  // the Semaphore to become ready.
+  private p_queue: Barrier<void>[] = [];
+
+  private p_ready: boolean;
+}

package/ts/index.ts

@@ -0,0 +1,4 @@
+export { default as Barrier } from './Barrier';
+export { default as Emitter } from './Emitter';
+export { default as Semaphore } from './Semaphore';
+export * from './time';

package/ts/time.ts

@@ -0,0 +1,44 @@
+import Barrier, { type Executor } from './Barrier';
+
+export const SEC_MS = 1000;
+export const MIN_MS = 60 * SEC_MS;
+export const HOUR_MS = 60 * MIN_MS;
+export const DAY_MS = 24 * HOUR_MS;
+export const YEAR_MS = 365 * DAY_MS;
+
+class Timer<T> extends Barrier<void, T> {
+  private p_abort: () => void;
+
+  get abort(): () => void { return this.p_abort; }
+
+  constructor(executor?: Executor<T>, timeout: number = 0) {
+    super(executor);
+    if (timeout > 0) {
+      const id = setTimeout(super.resolve.bind(this), timeout);
+      this.p_abort = () => clearTimeout(id);
+    } else {
+      this.p_abort = () => {};
+      super.resolve();
+    }
+  }
+
+  then<TR1, TR2>(
+    onFulfilled?: ((value: T) => TR1 | PromiseLike<TR1>) | null,
+    onRejected?: ((reason: any) => TR2 | PromiseLike<TR2>) | null,
+  ): Timer<TR1 | TR2> {
+    const res = <Timer<TR1 | TR2>> super.then(onFulfilled, onRejected);
+    res.p_abort = this.p_abort;
+    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).
+ */
+export async function timer(timeout: number) {
+  return new Timer<void>(undefined, timeout);
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "@tsconfig/recommended",
+  "include": ["ts/**/*"],
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "js"
+  }
+}