@ndn/util/lib/closers_node.js

NDNts: general utilities

import "./polyfill_node.js";
export var Closer;
(function (Closer) {
    /** Close or dispose an object. */
    function close(c) {
        for (const key of ["close", Symbol.dispose, Symbol.asyncDispose]) {
            if (typeof c?.[key] === "function") {
                return c[key]();
            }
        }
    }
    Closer.close = close;
    /** Convert a closable object to AsyncDisposable. */
    function asAsyncDisposable(c) {
        if (typeof c[Symbol.asyncDispose] === "function") {
            return c;
        }
        return {
            async [Symbol.asyncDispose]() {
                await close(c);
            },
        };
    }
    Closer.asAsyncDisposable = asAsyncDisposable;
})(Closer || (Closer = {}));
/** A list of objects that can be closed or disposed. */
export class Closers extends Array {
    /**
     * Close all objects and clear the list.
     *
     * @remarks
     * All objects added to this array are closed, in the reversed order as they appear in the array.
     * This is a synchronous function, so that any AsyncDisposable objects in the array would have its
     * asyncDispose method is called but not awaited.
     * This array is cleared and can be reused.
     */
    close = () => {
        for (let i = this.length - 1; i >= 0; --i) {
            void Closer.close(this[i]);
        }
        this.splice(0, Infinity);
    };
    [Symbol.dispose]() {
        this.close();
    }
    /** Schedule a timeout or interval to be canceled upon close. */
    addTimeout(t) {
        this.push({ close: () => clearTimeout(t) });
        return t;
    }
    /** Wait for close. */
    wait() {
        const { promise, resolve } = Promise.withResolvers();
        this.push({ close: resolve });
        return promise;
    }
}
/**
 * Acquire a semaphore for unlocking via Disposable.
 * @param semaphore - Semaphore or Mutex from `wait-your-turn` package.
 */
export async function lock(semaphore) {
    const release = await semaphore.acquire();
    return {
        [Symbol.dispose]() {
            release();
        },
    };
}