@code-essentials/utils 1.1.1 → 1.2.1

package/dist/async-variable.d.ts

@@ -1,16 +1,16 @@
 export declare class AsyncVariable<T> implements PromiseLike<T> {
     #private;
+    static readonly ERR_NOT_RESOLVED = "async variable not resolved or rejected";
     get value(): T;
     set value(value: T);
-    get error(): any;
-    set error(error: any);
+    get error(): unknown;
+    set error(error: unknown);
     get complete(): boolean;
     constructor();
-    init(): Promise<void>;
     read(): Promise<T>;
-    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2>;
-    set(value: T, throw_if_set?: boolean): Promise<void>;
-    reject(error: unknown, throw_if_set?: boolean): Promise<void>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): AsyncVariable<TResult1 | TResult2>;
+    set(value: T, throw_if_set?: boolean): void;
+    reject(error: unknown, throw_if_set?: boolean): void;
     static performCallback<R = void>(fn: (cb: (err?: unknown, res?: R) => void) => void): AsyncVariable<R>;
     writeResult(task: PromiseLike<T>): Promise<void>;
     perform(fn: () => PromiseLike<T>): this;

package/dist/async-variable.js

@@ -2,16 +2,16 @@ export class AsyncVariable {
     #result;
     #result_res;
     #result_p;
-    #initialization;
+    static ERR_NOT_RESOLVED = "async variable not resolved or rejected";
     get value() {
         if (!this.#result)
-            throw new Error('incomplete');
+            throw new Error(AsyncVariable.ERR_NOT_RESOLVED);
         if (this.#result.type === "rejected")
             throw this.#result.error;
         return this.#result.value;
     }
     set value(value) {
-        this.set(value);
+        void this.set(value);
     }
     get error() {
         if (!this.#result)
@@ -21,32 +21,24 @@ export class AsyncVariable {
         return this.#result.error;
     }
     set error(error) {
-        this.reject(error);
+        void this.reject(error);
     }
     get complete() {
         return this.#result !== undefined;
     }
     constructor() {
-        this.#initialization = new Promise(initialized => 
-        // prevents unhandled rejection
-        this.#result_p = new Promise(res => {
-            this.#result_res = res;
-            initialized();
-        }));
-    }
-    async init() {
-        await this.#initialization;
+        const { resolve, promise } = Promise.withResolvers();
+        this.#result_p = promise;
+        this.#result_res = (res => resolve(this.#result = res));
     }
     async read() {
-        await this.#initialization;
         await this.#result_p;
         return this.value;
     }
     then(onfulfilled, onrejected) {
-        return this.read().then(onfulfilled, onrejected);
+        return AsyncVariable.perform(() => this.read().then(onfulfilled, onrejected));
     }
-    async #complete(throw_if_set = true) {
-        await this.#initialization;
+    #complete(throw_if_set = true) {
         if (this.complete) {
             if (throw_if_set)
                 throw new Error('already set');
@@ -55,16 +47,16 @@ export class AsyncVariable {
         }
         return true;
     }
-    async set(value, throw_if_set = true) {
-        if (await this.#complete(throw_if_set)) {
+    set(value, throw_if_set = true) {
+        if (this.#complete(throw_if_set)) {
             this.#result_res(this.#result = {
                 type: "resolved",
                 value
             });
         }
     }
-    async reject(error, throw_if_set = true) {
-        if (await this.#complete(throw_if_set)) {
+    reject(error, throw_if_set = true) {
+        if (this.#complete(throw_if_set)) {
             this.#result_res(this.#result = {
                 type: "rejected",
                 error
@@ -73,30 +65,30 @@ export class AsyncVariable {
     }
     static performCallback(fn) {
         const av = new AsyncVariable();
-        fn(async (err, res) => {
-            if (err)
-                await av.error(err);
+        fn((err, res) => {
+            if (err !== undefined)
+                void av.reject(err);
             else
-                await av.set(res);
+                void av.set(res);
         });
         return av;
     }
     async writeResult(task) {
         try {
-            await this.set(await task);
+            this.set(await task);
         }
         catch (error) {
-            await this.reject(error);
+            this.reject(error);
         }
     }
     perform(fn) {
-        this.writeResult(fn());
+        void this.writeResult(fn());
         return this;
     }
     timeout(milliseconds) {
         AsyncVariable.wait(milliseconds).then(() => {
             if (!this.complete)
-                this.reject("timeout");
+                void this.reject("timeout");
         });
         return this;
     }
@@ -105,7 +97,7 @@ export class AsyncVariable {
     }
     static wait(milliseconds) {
         const res = new AsyncVariable();
-        setTimeout(() => res.set(), milliseconds);
+        setTimeout(() => void res.set(), milliseconds);
         return res;
     }
 }

package/dist/barrier.d.ts

@@ -3,14 +3,14 @@ interface EnqueuedTask<T> {
     task: PromiseLike<T>;
     completion: AsyncVariable<T>;
 }
-export declare class Barrier<T = any> implements PromiseLike<T[]>, AsyncDisposable {
+export declare class Barrier<T = unknown> implements PromiseLike<T[]>, AsyncDisposable {
     #private;
     readonly queue: EnqueuedTask<T>[];
     await(...asyncTasks: PromiseLike<T>[]): void;
-    run(...asyncTasks: PromiseLike<T>[]): void;
+    run(...asyncFunctions: (() => PromiseLike<T>)[]): void;
     clear(): void;
     complete(): Promise<this>;
     [Symbol.asyncDispose](): Promise<void>;
-    then<TResult1 = T[], TResult2 = never>(onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
+    then<TResult1 = T[], TResult2 = never>(onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
 }
 export {};

package/dist/barrier.js

@@ -2,16 +2,17 @@ import { AsyncVariable } from "./async-variable.js";
 export class Barrier {
     queue = [];
     await(...asyncTasks) {
-        this.run(...asyncTasks);
+        for (const asyncTask of asyncTasks)
+            this.#run(asyncTask);
     }
-    async #run(task) {
+    #run(task) {
         const completion = new AsyncVariable();
         this.queue.push({ task, completion });
-        completion.writeResult(task);
+        void completion.writeResult(task);
     }
-    run(...asyncTasks) {
-        for (const task of asyncTasks)
-            this.#run(task);
+    run(...asyncFunctions) {
+        for (const func of asyncFunctions)
+            this.#run(func());
     }
     clear() {
         this.queue.splice(0, this.queue.length);

package/dist/index.d.ts

@@ -5,3 +5,4 @@ export * from './barrier.js';
 export * from './observable-list.js';
 export * from './object.js';
 export * from './lock.js';
+export * from './log.js';

package/dist/index.js

@@ -5,3 +5,4 @@ export * from './barrier.js';
 export * from './observable-list.js';
 export * from './object.js';
 export * from './lock.js';
+export * from './log.js';

package/dist/lock.js

@@ -9,6 +9,7 @@ export class Lock {
         this.#isAcquired = true;
         return new LockContext(this, of, this.release.bind(this));
     }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     release(_context) {
         if (!this.isAcquired)
             throw new Error();

package/dist/log.d.ts

@@ -0,0 +1,6 @@
+export declare class Log implements Disposable {
+    readonly msg: string;
+    constructor(msg: string);
+    [Symbol.dispose](): void;
+}
+export declare function log(msg: string): Log;

package/dist/log.js

@@ -0,0 +1,13 @@
+export class Log {
+    msg;
+    constructor(msg) {
+        this.msg = msg;
+        console.log(msg);
+    }
+    [Symbol.dispose]() {
+        console.log(`${this.msg} complete`);
+    }
+}
+export function log(msg) {
+    return new Log(msg);
+}

package/dist/object.d.ts

@@ -8,8 +8,8 @@ export type PropertyPath<T> = [] | T extends object ? Values<{
     [K in keyof T]: [K] | [K, Values<PropertyPath<T[K]>>];
 }> : [];
 export type PropertyType<T, Property extends PropertyPath<T>> = PropertyType_<T, Property>;
-type PropertyType_<T, Property extends any[], Constructed extends any[] = []> = (Property & Constructed) extends never ? Values<{
-    [K in keyof T as Property extends [...Constructed, K, ...any[]] ? K : never]: PropertyType_<T[K], Property, [...Constructed, K]>;
+type PropertyType_<T, Property extends unknown[], Constructed extends unknown[] = []> = (Property & Constructed) extends never ? Values<{
+    [K in keyof T as Property extends [...Constructed, K, ...unknown[]] ? K : never]: PropertyType_<T[K], Property, [...Constructed, K]>;
 }> : T;
-export declare function replaceProperty<T, Property extends PropertyPath<T> = PropertyPath<T>>(obj: T, property: Property, value: any): T;
+export declare function replaceProperty<T, Property extends PropertyPath<T> = PropertyPath<T>>(obj: T, property: Property, value: unknown): T;
 export {};

package/dist/object.js

@@ -27,11 +27,12 @@ export function entries(o) {
 // type ac_type = PropertyType_<A, typeof ac>
 export function replaceProperty(obj, property, value) {
     if (property.length === 0)
-        return (value ?? obj);
-    if (typeof obj !== 'object')
+        return ((value) ?? obj);
+    if (!(obj instanceof Object))
         throw new Error();
     const prototype = Object.create(obj);
     const property0 = property[0];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
     prototype[property0] = replaceProperty(obj[property0], property.slice(1), value);
     return prototype;
 }

package/dist/observable-list.d.ts

@@ -10,7 +10,7 @@ export declare class ObservableList<T> extends Array<T> {
     push(...items: T[]): number;
     pop(): T | undefined;
     reverse(): T[];
-    sort(compareFn?: ((a: T, b: T) => number) | undefined): this;
+    sort(compareFn?: ((a: T, b: T) => number)): this;
     shift(): T | undefined;
     splice(start: number, deleteCount?: number, ...items: T[]): T[];
     unshift(...items: T[]): number;

package/dist/types.d.ts

@@ -29,3 +29,7 @@ export type Mutable<T> = {
 export type DeeplyReadonly<T> = T extends object ? T extends null ? T : {
     readonly [K in keyof T]: DeeplyReadonly<T[K]>;
 } : T;
+export type NonConstructorKeys<T> = {
+    [P in keyof T]: T[P] extends new (...args: any[]) => any ? never : P;
+}[keyof T];
+export type NonConstructor<T> = Pick<T, NonConstructorKeys<T>>;

package/dist/types.js

@@ -12,6 +12,7 @@ export function removePrefix(prefix, o) {
 export function valuesPrefixed(prefix, values) {
     return Object.fromEntries(Object.entries(values).map(([k, value]) => [k, prefix + value]));
 }
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 export function assert() { }
 export function never() {
     throw new Error("never");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@code-essentials/utils",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "description": "",
   "type": "module",
   "main": "./dist/index.js",
@@ -8,10 +8,24 @@
   "files": [
     "dist"
   ],
+  "scripts": {
+    "clean": "rm -rf dist",
+    "prebuild": "npm run clean && npm run lint",
+    "prebuild:debug": "npm run clean",
+    "build": "tsc  -p tsconfig.prod.json",
+    "build:debug": "tsc -p tsconfig.debug.json",
+    "pretest": "npm run build:debug",
+    "test": "npm run test:run",
+    "pretest:run": "",
+    "test:run": "ava",
+    "prepublishOnly": "pnpm test && npm run build",
+    "lint": "eslint ."
+  },
   "devDependencies": {
     "@ava/typescript": "^6.0.0",
     "@code-essentials/ava-typescript": "^1.1.1",
     "@code-essentials/tsconfig": "^1.2.1",
+    "@code-essentials/eslint-config": "^1.0.2",
     "@types/node": "^24.10.1",
     "ava": "^6.4.1",
     "typescript": "^5.9.3"
@@ -25,16 +39,5 @@
     "type": "git",
     "url": "https://github.com/code-essentials/utils.git"
   },
-  "license": "MIT",
-  "scripts": {
-    "clean": "rm -rf dist",
-    "prebuild": "npm run clean",
-    "prebuild:debug": "npm run clean",
-    "build": "tsc  -p tsconfig.prod.json",
-    "build:debug": "tsc -p tsconfig.debug.json",
-    "pretest": "npm run build:debug",
-    "test": "npm run test:run",
-    "pretest:run": "",
-    "test:run": "ava"
-  }
-}
+  "license": "MIT"
+}

package/LICENSE.md

@@ -1,21 +0,0 @@
-# Graph Mind License Agreement
-
-Copyright © 2025 Isaac Valdez. All Rights Reserved.
-
-1. Ownership
-The source code and all associated intellectual property for the 'graph-math' project (hereinafter referred to as "the Software") are the exclusive private property of Isaac Valdez.
-
-2. Permitted Use
-The Software may only be examined in source code form with explicit permission from Isaac Valdez. Individuals or entities wishing to review or utilize the source code must obtain this permission in writing.
-
-3. End-User Licensing
-End users are permitted to run the Software on their local computer systems, provided such usage complies with a separate End-User License Agreement (EULA) that will be supplied to the end user.
-
-4. License Modifications
-Isaac Valdez reserves the right to update or modify this license at any time. Changes will be effective upon modification of the license text and will apply to all users from that date onward.
-
-5. No Warranty
-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, or non-infringement.
-
-6. Acceptance
-By using the Software, you indicate your acceptance of this license agreement. If you do not agree to abide by the terms of this agreement, you must refrain from using the Software.