@code-essentials/utils 1.0.12 → 1.1.0

package/dist/async-variable.d.ts

@@ -12,7 +12,8 @@ export declare class AsyncVariable<T> implements PromiseLike<T> {
     set(value: T, throw_if_set?: boolean): Promise<void>;
     reject(error: unknown, throw_if_set?: boolean): Promise<void>;
     static performCallback<R = void>(fn: (cb: (err?: unknown, res?: R) => void) => void): AsyncVariable<R>;
-    perform(fn: () => Promise<T>): this;
+    writeResult(task: PromiseLike<T>): Promise<void>;
+    perform(fn: () => PromiseLike<T>): this;
     timeout(milliseconds: number): this;
     static perform<T>(fn: () => Promise<T>): AsyncVariable<T>;
     static wait(milliseconds: number): AsyncVariable<void>;

package/dist/async-variable.js

@@ -81,8 +81,16 @@ export class AsyncVariable {
         });
         return av;
     }
+    async writeResult(task) {
+        try {
+            await this.set(await task);
+        }
+        catch (error) {
+            await this.reject(error);
+        }
+    }
     perform(fn) {
-        fn().then(value => this.set(value)).catch(error => this.reject(error));
+        this.writeResult(fn());
         return this;
     }
     timeout(milliseconds) {

package/dist/barrier.d.ts

@@ -0,0 +1,15 @@
+import { AsyncVariable } from "./async-variable.js";
+interface EnqueuedTask<T> {
+    task: PromiseLike<T>;
+    completion: AsyncVariable<T>;
+}
+export declare class Barrier<T = any> implements PromiseLike<T[]> {
+    #private;
+    readonly queue: EnqueuedTask<T>[];
+    await(...asyncTasks: PromiseLike<T>[]): void;
+    run(...asyncTasks: PromiseLike<T>[]): void;
+    clear(): void;
+    complete(): Promise<this>;
+    then<TResult1 = T[], TResult2 = never>(onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
+}
+export {};

package/dist/barrier.js

@@ -0,0 +1,33 @@
+import { AsyncVariable } from "./async-variable.js";
+export class Barrier {
+    queue = [];
+    await(...asyncTasks) {
+        this.run(...asyncTasks);
+    }
+    async #run(task) {
+        const completion = new AsyncVariable();
+        this.queue.push({ task, completion });
+        completion.writeResult(task);
+    }
+    run(...asyncTasks) {
+        for (const task of asyncTasks)
+            this.#run(task);
+    }
+    clear() {
+        this.queue.splice(0, this.queue.length);
+    }
+    async complete() {
+        const result = await this;
+        this.clear();
+        return result;
+    }
+    async then(onfulfilled, onrejected) {
+        try {
+            const values = await Promise.all(this.queue.map(({ completion }) => completion));
+            return await onfulfilled?.(values);
+        }
+        catch (reason) {
+            return await onrejected?.(reason);
+        }
+    }
+}

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from './types.js';
 export * from './strings.js';
 export * from './async-variable.js';
+export * from './barrier.js';
 export * from './observable-list.js';
 export * from './object.js';
 export * from './lock.js';

package/dist/index.js

@@ -1,6 +1,7 @@
 export * from './types.js';
 export * from './strings.js';
 export * from './async-variable.js';
+export * from './barrier.js';
 export * from './observable-list.js';
 export * from './object.js';
 export * from './lock.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@code-essentials/utils",
-  "version": "1.0.12",
+  "version": "1.1.0",
   "description": "",
   "type": "module",
   "main": "./dist/index.js",
@@ -10,9 +10,9 @@
   ],
   "devDependencies": {
     "@ava/typescript": "^6.0.0",
-    "@code-essentials/tsconfig": "^1.0.3",
-    "@code-essentials/ava-typescript": "^1.0.0",
-    "@types/node": "^24.8.1",
+    "@code-essentials/ava-typescript": "^1.1.1",
+    "@code-essentials/tsconfig": "^1.2.1",
+    "@types/node": "^24.10.1",
     "ava": "^6.4.1",
     "typescript": "^5.9.3"
   },
@@ -30,9 +30,11 @@
     "clean": "rm -rf dist",
     "prebuild": "pnpm run clean",
     "prebuild:debug": "pnpm run clean",
-    "build": "tsc",
+    "build": "tsc  -p tsconfig.prod.json",
     "build:debug": "tsc -p tsconfig.debug.json",
     "pretest": "pnpm run build:debug",
-    "test": "ava"
+    "test": "pnpm run test:run",
+    "pretest:run": "",
+    "test:run": "ava"
   }
 }

package/dist/lock.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lock.spec.js

@@ -1,93 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import test from "ava";
-import { Lock } from "./lock.js";
-test('acquire when free', t => {
-    const lock = new Lock();
-    const context = lock.acquire();
-    context.release();
-    t.pass();
-});
-test('fail to acquire when already acquired', t => {
-    const lock = new Lock();
-    lock.acquire();
-    t.throws(() => lock.acquire(), { message: Lock.ERR_ACQUIRED });
-});
-test('disposable release', t => {
-    const lock = new Lock();
-    function acquire(pass) {
-        if (pass)
-            t.notThrows(() => lock.acquire());
-        else
-            t.throws(() => lock.acquire(), { message: Lock.ERR_ACQUIRED });
-    }
-    function acquire_0() {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const _context1 = __addDisposableResource(env_1, lock.acquire(), false);
-            acquire(false);
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            __disposeResources(env_1);
-        }
-    }
-    function acquire_1() {
-        acquire(true);
-    }
-    acquire_0();
-    acquire_1();
-});

package/dist/object.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/object.spec.js

@@ -1,20 +0,0 @@
-import test from "ava";
-import { replaceProperty } from "./object.js";
-test("replace", t => {
-    const a0 = {
-        i: 0,
-        b: {
-            j: 0,
-            c: {
-                k: 0
-            },
-        }
-    };
-    t.is(a0.i, 0);
-    const a1 = replaceProperty(a0, ["i"], 1);
-    t.is(a0.i, 0);
-    t.is(a1.i, 1);
-    a0.b.j++;
-    t.is(a0.b.j, 1);
-    t.is(a1.b.j, 1);
-});

package/dist/observable-list.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/observable-list.spec.js

@@ -1,16 +0,0 @@
-import { ObservableList } from "./observable-list.js";
-import test from "ava";
-test("insert", t => {
-    const list = new ObservableList();
-    const words = ["keyboard", "mouse", "display"];
-    t.plan(words.length);
-    let itemInserted = "";
-    const responder = (item) => t.is(item, itemInserted);
-    list.on("insert", responder);
-    list.push(itemInserted = words[0]);
-    list.push(itemInserted = words[1]);
-    list.off("insert", responder);
-    list.push("unrelated");
-    list.on("insert", responder);
-    list.push(itemInserted = words[2]);
-});

package/dist/strings.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/strings.spec.js

@@ -1,20 +0,0 @@
-import test from "ava";
-function typeCheck(t, _) {
-    t.pass();
-}
-test("startsWith", t => {
-    const prefix = "abc";
-    typeCheck(t, `abc123`);
-});
-test("endsWith", t => {
-    const suffix = "123";
-    typeCheck(t, `abc123`);
-});
-test("concat 0", t => {
-    const arr = ["abc", "def", "gh", "ijk"];
-    typeCheck(t, "abcdefghijk");
-});
-test("concat 1", t => {
-    const arr = ["abc", "def", "gh", "ijk"];
-    typeCheck(t, "abc def gh ijk");
-});

package/dist/types.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types.spec.js

@@ -1,28 +0,0 @@
-import test from 'ava';
-import { assert, valuesPrefixed } from './types.js';
-test("valuesPrefixed", t => {
-    const abc = {
-        a: '.a',
-        b: '.b',
-        c: '.c',
-    };
-    const prefix = "prefix1";
-    const abc_k1 = valuesPrefixed(prefix, abc);
-    t.deepEqual(abc_k1, {
-        a: `${prefix}${abc.a}`,
-        b: `${prefix}${abc.b}`,
-        c: `${prefix}${abc.c}`,
-    });
-});
-test("deeply readonly 1", t => {
-    assert();
-    t.pass();
-});
-test("deeply readonly 2", t => {
-    assert();
-    t.pass();
-});
-test("deeply readonly 3", t => {
-    assert();
-    t.pass();
-});