@code-essentials/utils 1.0.2 → 1.0.4

package/LICENSE.md

@@ -0,0 +1,21 @@
+# 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.

package/dist/async-variable.d.ts

@@ -0,0 +1,19 @@
+export declare class AsyncVariable<T> implements PromiseLike<T> {
+    #private;
+    get value(): T;
+    set value(value: T);
+    get error(): any;
+    set error(error: any);
+    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>;
+    static performCallback<R = void>(fn: (cb: (err?: unknown, res?: R) => void) => void): AsyncVariable<R>;
+    perform(fn: () => Promise<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

@@ -0,0 +1,103 @@
+export class AsyncVariable {
+    #result;
+    #result_res;
+    #result_p;
+    #initialization;
+    get value() {
+        if (!this.#result)
+            throw new Error('incomplete');
+        if (this.#result.type === "rejected")
+            throw this.#result.error;
+        return this.#result.value;
+    }
+    set value(value) {
+        this.set(value);
+    }
+    get error() {
+        if (!this.#result)
+            throw new Error('incomplete');
+        if (this.#result.type === "resolved")
+            throw new Error(this.#result.type);
+        return this.#result.error;
+    }
+    set error(error) {
+        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;
+    }
+    async read() {
+        await this.#initialization;
+        await this.#result_p;
+        return this.value;
+    }
+    then(onfulfilled, onrejected) {
+        return this.read().then(onfulfilled, onrejected);
+    }
+    async #complete(throw_if_set = true) {
+        await this.#initialization;
+        if (this.complete) {
+            if (throw_if_set)
+                throw new Error('already set');
+            else
+                return false;
+        }
+        return true;
+    }
+    async set(value, throw_if_set = true) {
+        if (await 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)) {
+            this.#result_res(this.#result = {
+                type: "rejected",
+                error
+            });
+        }
+    }
+    static performCallback(fn) {
+        const av = new AsyncVariable();
+        fn(async (err, res) => {
+            if (err)
+                await av.error(err);
+            else
+                await av.set(res);
+        });
+        return av;
+    }
+    perform(fn) {
+        fn().then(value => this.set(value)).catch(error => this.reject(error));
+        return this;
+    }
+    timeout(milliseconds) {
+        AsyncVariable.wait(milliseconds).then(() => {
+            if (!this.complete)
+                this.reject("timeout");
+        });
+        return this;
+    }
+    static perform(fn) {
+        return new AsyncVariable().perform(fn);
+    }
+    static wait(milliseconds) {
+        const res = new AsyncVariable();
+        setTimeout(() => res.set(), milliseconds);
+        return res;
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/lock.d.ts

@@ -0,0 +1,16 @@
+export declare class Lock<Of = void> {
+    #private;
+    get isAcquired(): boolean;
+    acquire(of: Of): LockContext<Of>;
+    protected release(_context: LockContext<Of>): void;
+    static readonly ERR_ACQUIRED = "lock currently acquired";
+}
+export declare class LockContext<Of> implements Disposable {
+    #private;
+    readonly lock: Lock<Of>;
+    readonly of: Of;
+    constructor(lock: Lock<Of>, of: Of, release: (conext: LockContext<Of>) => void);
+    release(): void;
+    [Symbol.dispose](): void;
+    static readonly ERR_LOCK_RELEASED = "lock context already released";
+}

package/dist/lock.js

@@ -0,0 +1,39 @@
+export class Lock {
+    #isAcquired = false;
+    get isAcquired() {
+        return this.#isAcquired;
+    }
+    acquire(of) {
+        if (this.#isAcquired)
+            throw new Error(Lock.ERR_ACQUIRED);
+        this.#isAcquired = true;
+        return new LockContext(this, of, this.release.bind(this));
+    }
+    release(_context) {
+        if (!this.isAcquired)
+            throw new Error();
+        this.#isAcquired = false;
+    }
+    static ERR_ACQUIRED = 'lock currently acquired';
+}
+export class LockContext {
+    lock;
+    of;
+    #release;
+    #isAcquired = true;
+    constructor(lock, of, release) {
+        this.lock = lock;
+        this.of = of;
+        this.#release = release;
+    }
+    release() {
+        if (!this.#isAcquired)
+            throw new Error(LockContext.ERR_LOCK_RELEASED);
+        this.#isAcquired = false;
+        this.#release(this);
+    }
+    [Symbol.dispose]() {
+        this.release();
+    }
+    static ERR_LOCK_RELEASED = "lock context already released";
+}

package/dist/object.d.ts

@@ -0,0 +1,10 @@
+export type Values<T extends object> = T[keyof T];
+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]>;
+}> : T;
+export declare function replaceProperty<T, Property extends PropertyPath<T> = PropertyPath<T>>(obj: T, property: Property, value: any): T;
+export {};

package/dist/object.js

@@ -0,0 +1,34 @@
+// export type PropertyType<T, Property extends PropertyPath<T> & PropertyKey[]> = PropertyType_<T, Property>
+// type PropertyType_<T, Property extends PropertyKey[], Constructed extends PropertyKey[] = []> =
+//     (Property & Constructed) extends never ?
+//     Values<{
+//         [K in keyof T as Property extends [...Constructed, K, ...PropertyKey[]] ? K : never]:
+//         PropertyType_<T[K], Property, [...Constructed, K]>
+//     }> :
+//     T
+// type A = {
+//     a: {
+//         a: 10,
+//         b: 1
+//         c: 2
+//     }
+//     b: {
+//         a: {
+//             c: 1
+//         }
+//     }
+// }
+// type a_path = PropertyPath<A>
+// const ac = ["a", "c"] satisfies a_path
+// // type a1 = (typeof ac) extends ["a", "c", ...PropertyKey[]] ? true : false
+// type ac_type = PropertyType_<A, typeof ac>
+export function replaceProperty(obj, property, value) {
+    if (property.length === 0)
+        return (value ?? obj);
+    if (typeof obj !== 'object')
+        throw new Error();
+    const prototype = Object.create(obj);
+    const property0 = property[0];
+    prototype[property0] = replaceProperty(obj[property0], property.slice(1), value);
+    return prototype;
+}

package/dist/observable-list.d.ts

@@ -0,0 +1,24 @@
+export interface ObservableListProtocols<T> {
+    insert(item: T, index: number): void;
+    delete(item: T, index: number): void;
+    reorder(item: T, index1: number): void;
+}
+export declare class ObservableList<T> extends Array<T> {
+    #private;
+    constructor(length: number);
+    constructor(...items: T[]);
+    push(...items: T[]): number;
+    pop(): T | undefined;
+    reverse(): T[];
+    sort(compareFn?: ((a: T, b: T) => number) | undefined): this;
+    shift(): T | undefined;
+    splice(start: number, deleteCount?: number, ...items: T[]): T[];
+    unshift(...items: T[]): number;
+    on<Protocol extends keyof ObservableListProtocols<T>>(protocol: Protocol, responder: ObservableListProtocols<T>[Protocol]): void;
+    off<Protocol extends keyof ObservableListProtocols<T>>(protocol: Protocol, responder: ObservableListProtocols<T>[Protocol]): void;
+    responders<Protocol extends keyof ObservableListProtocols<T>>(protocol: Protocol): {
+        insert: Set<(item: T, index: number) => void>;
+        delete: Set<(item: T, index: number) => void>;
+        reorder: Set<(item: T, index1: number) => void>;
+    }[Protocol];
+}

package/dist/observable-list.js

@@ -0,0 +1,75 @@
+export class ObservableList extends Array {
+    constructor(...itemsOrArrayLength) {
+        super(...itemsOrArrayLength);
+    }
+    push(...items) {
+        const length0 = this.length;
+        const result = super.push(...items);
+        items.forEach((item, i) => this.#emit("insert", item, length0 + i));
+        return result;
+    }
+    pop() {
+        const index = this.length - 1;
+        const result = super.pop();
+        if (index >= 0)
+            this.#emit("delete", result, index);
+        return result;
+    }
+    reverse() {
+        const final_index = this.length - 1;
+        const result = super.reverse();
+        this.forEach((item, i) => {
+            const index0 = final_index - i;
+            const index1 = i;
+            if (index0 !== index1)
+                this.#emit("reorder", item, index1);
+        });
+        return result;
+    }
+    sort(compareFn) {
+        const result = super.sort(compareFn);
+        this.forEach((item, i) => this.#emit("reorder", item, i));
+        return result;
+    }
+    shift() {
+        const length0 = this.length;
+        const result = super.shift();
+        if (length0 > 0)
+            this.#emit("delete", result, 0);
+        this.forEach((item, i) => this.#emit("reorder", item, i));
+        return result;
+    }
+    splice(start, deleteCount = 0, ...items) {
+        const deleted = super.splice(start, deleteCount, ...items);
+        deleted.forEach((item, i) => this.#emit("delete", item, start + i));
+        if ((deleteCount ?? 0) !== (items?.length ?? 0))
+            for (let i = start + (items?.length ?? 0); i < this.length; i++)
+                this.#emit("reorder", this[i], i);
+        items.forEach((item, i) => this.#emit("insert", item, start + i));
+        return deleted;
+    }
+    unshift(...items) {
+        const result = super.unshift(...items);
+        for (let i = items.length; i < this.length; i++)
+            this.#emit("reorder", this[i], i);
+        items.forEach((item, i) => this.#emit("insert", item, i));
+        return result;
+    }
+    #responders = {
+        insert: new Set(),
+        delete: new Set(),
+        reorder: new Set(),
+    };
+    #emit(protocol, ...parameters) {
+        return [...this.#responders[protocol]].map(responder => responder(...parameters));
+    }
+    on(protocol, responder) {
+        this.#responders[protocol].add(responder);
+    }
+    off(protocol, responder) {
+        this.#responders[protocol].delete(responder);
+    }
+    responders(protocol) {
+        return this.#responders[protocol];
+    }
+}

package/dist/strings.d.ts

@@ -0,0 +1,3 @@
+export type StartsWith<Prefix extends string = string, Body extends string = string> = `${Prefix}${Body}`;
+export type EndsWith<Suffix extends string = string, Body extends string = string> = `${Body}${Suffix}`;
+export type Concat<StrArr extends readonly string[] = readonly string[], Separator extends string = ""> = StrArr extends readonly [infer S0 extends string, ...infer Rest extends string[]] ? Rest extends [] ? S0 : `${S0}${Separator}${Concat<Rest, Separator>}` : "";

package/dist/strings.js

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

package/dist/types.d.ts

@@ -0,0 +1,12 @@
+export type Deleteable<T, K extends keyof T = keyof T> = {
+    -readonly [K1 in K]?: T[K1];
+};
+export type PartlyDeleteable<T, K extends keyof T> = {
+    [K1 in keyof T as (K1 extends K ? never : K1)]: T[K1];
+} & Deleteable<T, K>;
+export type UndefinedIf<T, Condition extends boolean = boolean> = Condition extends true ? undefined : T;
+export declare function undefinedIf<T, Condition extends boolean = boolean>(condition: Condition, item: () => T): UndefinedIf<T, Condition>;
+export type Prefixed<Prefix extends string, T extends object> = {
+    [K in string & keyof T as `${Prefix}${K}`]: T[K];
+};
+export declare function prefixed<Prefix extends string, T extends object>(prefix: Prefix, o: T): Prefixed<Prefix, T>;

package/dist/types.js

@@ -0,0 +1,6 @@
+export function undefinedIf(condition, item) {
+    return (condition ? undefined : item());
+}
+export function prefixed(prefix, o) {
+    return Object.fromEntries(Object.entries(o).map(([k, v]) => [`${prefix}${k}`, v]));
+}

package/package.json

@@ -1,23 +1,16 @@
 {
   "name": "@code-essentials/utils",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "scripts": {
-    "clean": "rm -rf dist",
-    "prebuild": "npm run clean",
-    "prebuild:debug": "npm run clean",
-    "build": "tsc",
-    "build:debug": "tsc -p tsconfig.debug.json",
-    "pretest": "npm run build:debug",
-    "test": "ava",
-    "prepublishOnly": "npm test && npm run build"
-  },
+  "files": [
+    "dist/**/*"
+  ],
   "devDependencies": {
     "@ava/typescript": "^6.0.0",
-    "@code-essentials/tsconfig": "^1.0",
+    "@code-essentials/tsconfig": "^1.0.3",
     "@types/node": "^24.5.2",
     "ava": "^6.4.1",
     "typescript": "^5.9.2"
@@ -41,5 +34,14 @@
     "email": "isaac_valdez@msn.com",
     "url": "https://i12345.github.io"
   },
-  "license": "MIT"
-}
+  "license": "MIT",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "prebuild": "npm run clean",
+    "prebuild:debug": "npm run clean",
+    "build": "tsc",
+    "build:debug": "tsc -p tsconfig.debug.json",
+    "pretest": "npm run build:debug",
+    "test": "ava"
+  }
+}

package/.vscode/launch.json

@@ -1,21 +0,0 @@
-{
-    "configurations": [
-        {
-            "name": "test",
-            "request": "launch",
-            "runtimeArgs": [
-                "run-script",
-                "test"
-            ],
-            "runtimeExecutable": "pnpm",
-            "sourceMaps": true,
-            "pauseForSourceMap": true,
-            "preLaunchTask": "npm: build:debug",
-            "internalConsoleOptions": "neverOpen",
-            "skipFiles": [
-                "<node_internals>/**"
-            ],
-            "type": "node"
-        }
-    ]
-}

package/.vscode/tasks.json

@@ -1,22 +0,0 @@
-{
-    "version": "2.0.0",
-    "tasks": [
-        {
-            "label": "npm: build:debug",
-            "type": "shell",
-            "command": "npm",
-            "args": [
-                "run-script",
-                "build:debug",
-            ],
-            "problemMatcher": [
-                "$tsc"
-            ],
-            "presentation": {
-                "reveal": "silent",
-                "close": true,
-            },
-            "group": "build"
-        }
-    ]
-}

package/src/async-variable.ts

@@ -1,146 +0,0 @@
-interface AsyncVariableResultBase<Type> {
-    readonly type: Type
-}
-
-interface AsyncVariableResultResolved<T> extends AsyncVariableResultBase<"resolved"> {
-    readonly value: T
-}
-
-interface AsyncVariableResultRejected extends AsyncVariableResultBase<"rejected"> {
-    readonly error: any
-}
-
-type AsyncVariableResult<T> =
-    | AsyncVariableResultResolved<T>
-    | AsyncVariableResultRejected
-
-export class AsyncVariable<T> implements PromiseLike<T> {
-    #result: AsyncVariableResult<T> | undefined
-    #result_res!: (res: AsyncVariableResult<T>) => void
-    #result_p!: Promise<AsyncVariableResult<T>>
-    readonly #initialization: Promise<void>
-
-    get value(): T {
-        if (!this.#result)
-            throw new Error('incomplete')
-
-        if (this.#result.type === "rejected")
-            throw this.#result.error
-
-        return this.#result.value
-    }
-
-    set value(value) {
-        this.set(value)
-    }
-
-    get error() {
-        if (!this.#result)
-            throw new Error('incomplete')
-
-        if (this.#result.type === "resolved")
-            throw new Error(this.#result.type)
-
-        return this.#result.error
-    }
-
-    set error(error) {
-        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
-    }
-
-    async read() {
-        await this.#initialization
-        await this.#result_p
-        return this.value
-    }
-
-    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2> {
-        return this.read().then(onfulfilled, onrejected)
-    }
-
-    async #complete(throw_if_set = true) {
-        await this.#initialization
-        if (this.complete) {
-            if (throw_if_set)
-                throw new Error('already set')
-            else
-                return false
-        }
-
-        return true
-    }
-
-    async set(value: T, throw_if_set = true) {
-        if (await this.#complete(throw_if_set)) {
-            this.#result_res(this.#result = {
-                type: "resolved",
-                value
-            })
-        }
-    }
-
-    async reject(error: unknown, throw_if_set = true) {
-        if (await this.#complete(throw_if_set)) {
-            this.#result_res(this.#result = {
-                type: "rejected",
-                error
-            })
-        }
-    }
-
-    static performCallback<R = void>(fn: (cb: (err?: unknown, res?: R) => void) => void): AsyncVariable<R> {
-        const av = new AsyncVariable<R>()
-
-        fn(async (err, res) => {
-            if (err)
-                await av.error(err)
-            else
-                await av.set(<R>res)
-        })
-
-        return av
-    }
-
-    perform(fn: () => Promise<T>): this {
-        fn().then(value => this.set(value)).catch(error => this.reject(error))
-
-        return this
-    }
-
-    timeout(milliseconds: number): this {
-        AsyncVariable.wait(milliseconds).then(() => {
-            if (!this.complete)
-                this.reject("timeout")
-        })
-
-        return this
-    }
-
-    static perform<T>(fn: () => Promise<T>): AsyncVariable<T> {
-        return new AsyncVariable<T>().perform(fn)
-    }
-
-    static wait(milliseconds: number) {
-        const res = new AsyncVariable<void>()
-        setTimeout(() => res.set(), milliseconds)
-        return res
-    }
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from './types.js'
-export * from './async-variable.js'
-export * from './observable-list.js'
-export * from './object.js'
-export * from './lock.js'

package/src/lock.spec.ts

@@ -1,38 +0,0 @@
-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: boolean) {
-        if (pass)
-            t.notThrows(() => lock.acquire())
-        else
-            t.throws(() => lock.acquire(), { message: Lock.ERR_ACQUIRED })
-    }
-
-    function acquire_0() {
-        using _context1 = lock.acquire()
-        acquire(false)
-    }
-
-    function acquire_1() {
-        acquire(true)
-    }
-
-    acquire_0()
-    acquire_1()
-})

package/src/lock.ts

@@ -1,50 +0,0 @@
-export class Lock<Of = void> {
-    #isAcquired = false
-
-    get isAcquired() {
-        return this.#isAcquired
-    }
-
-    acquire(of: Of): LockContext<Of> {
-        if (this.#isAcquired)
-            throw new Error(Lock.ERR_ACQUIRED)
-        this.#isAcquired = true
-        return new LockContext(this, of, this.release.bind(this))
-    }
-
-    protected release(_context: LockContext<Of>) {
-        if (!this.isAcquired)
-            throw new Error()
-
-        this.#isAcquired = false
-    }
-
-    static readonly ERR_ACQUIRED = 'lock currently acquired'
-}
-
-export class LockContext<Of> implements Disposable {
-    readonly #release: (conext: LockContext<Of>) => void
-    #isAcquired = true
-
-    constructor(
-            readonly lock: Lock<Of>,
-            readonly of: Of,
-            release: (conext: LockContext<Of>) => void
-        ) {
-        this.#release = release
-    }
-
-    release() {
-        if (!this.#isAcquired)
-            throw new Error(LockContext.ERR_LOCK_RELEASED)
-
-        this.#isAcquired = false
-        this.#release(this)
-    }
-
-    [Symbol.dispose]() {
-        this.release()
-    }
-
-    static readonly ERR_LOCK_RELEASED = "lock context already released"
-}

package/src/object.spec.ts

@@ -1,39 +0,0 @@
-import test from "ava"
-import { replaceProperty } from "./object.js"
-
-test("replace", t => {
-    interface A {
-        i: number
-        b: B
-    }
-    
-    interface B {
-        j: number
-        c: C
-    }
-
-    interface C {
-        k: number
-    }
-
-    const a0: A = {
-        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/src/object.ts

@@ -1,60 +0,0 @@
-export type Values<T extends object> = T[keyof T]
-
-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]>
-    }> :
-    T
-
-// export type PropertyType<T, Property extends PropertyPath<T> & PropertyKey[]> = PropertyType_<T, Property>
-// type PropertyType_<T, Property extends PropertyKey[], Constructed extends PropertyKey[] = []> =
-//     (Property & Constructed) extends never ?
-//     Values<{
-//         [K in keyof T as Property extends [...Constructed, K, ...PropertyKey[]] ? K : never]:
-//         PropertyType_<T[K], Property, [...Constructed, K]>
-//     }> :
-//     T
-
-// type A = {
-//     a: {
-//         a: 10,
-//         b: 1
-//         c: 2
-//     }
-//     b: {
-//         a: {
-//             c: 1
-//         }
-//     }
-// }
-
-// type a_path = PropertyPath<A>
-// const ac = ["a", "c"] satisfies a_path
-// // type a1 = (typeof ac) extends ["a", "c", ...PropertyKey[]] ? true : false
-// type ac_type = PropertyType_<A, typeof ac>
-
-export function replaceProperty<T, Property extends PropertyPath<T> = PropertyPath<T>>(
-        obj: T,
-        property: Property,
-        value: any
-    ): T {
-    if (property.length === 0)
-        return <T>((<any>value) ?? obj)
-
-    if (typeof obj !== 'object')
-        throw new Error()
-
-    const prototype = Object.create(obj)
-    const property0 = property[0]!
-    prototype[property0] = replaceProperty<any>((<any>obj)[property0]!, <any>property.slice(1), value)
-    return <T>prototype
-}

package/src/observable-list.spec.ts

@@ -1,25 +0,0 @@
-import { ObservableList, ObservableListProtocols } from "./observable-list.js"
-import test from "ava"
-
-test("insert", t => {
-    const list = new ObservableList<string>()
-    
-    const words = ["keyboard", "mouse", "display"]
-    t.plan(words.length)
-
-    let itemInserted = ""
-    const responder: ObservableListProtocols<string>["insert"] = (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/src/observable-list.ts

@@ -1,114 +0,0 @@
-export interface ObservableListProtocols<T> {
-    insert(item: T, index: number): void
-    delete(item: T, index: number): void
-    reorder(item: T, index1: number): void
-}
-
-export class ObservableList<T> extends Array<T> {
-    constructor(length: number)
-    constructor(...items: T[])
-    constructor(...itemsOrArrayLength: any[]) {
-        super(...itemsOrArrayLength)
-    }
-
-    override push(...items: T[]): number {
-        const length0 = this.length
-        const result = super.push(...items)
-
-        items.forEach((item, i) => this.#emit("insert", item, length0 + i))
-
-        return result
-    }
-
-    override pop(): T | undefined {
-        const index = this.length - 1
-        const result = super.pop()
-
-        if (index >= 0)
-            this.#emit("delete", result!, index)
-
-        return result
-    }
-
-    override reverse(): T[] {
-        const final_index = this.length - 1
-        const result = super.reverse()
-
-        this.forEach((item, i) => {
-            const index0 = final_index - i
-            const index1 = i
-
-            if (index0 !== index1)
-                this.#emit("reorder", item, index1)
-        })
-
-        return result
-    }
-
-    override sort(compareFn?: ((a: T, b: T) => number) | undefined): this {
-        const result = super.sort(compareFn)
-
-        this.forEach((item, i) => this.#emit("reorder", item, i))
-
-        return result
-    }
-
-    override shift(): T | undefined {
-        const length0 = this.length
-        const result = super.shift()
-
-        if (length0 > 0)
-            this.#emit("delete", result!, 0)
-
-        this.forEach((item, i) => this.#emit("reorder", item, i))
-
-        return result
-    }
-
-    override splice(start: number, deleteCount = 0, ...items: T[]): T[] {
-        const deleted = super.splice(start, deleteCount, ...items)
-
-        deleted.forEach((item, i) => this.#emit("delete", item, start + i))
-
-        if ((deleteCount ?? 0) !== (items?.length ?? 0))
-            for (let i = start + (items?.length ?? 0); i < this.length; i++)
-                this.#emit("reorder", this[i]!, i)
-        
-        items.forEach((item, i) => this.#emit("insert", item, start + i))
-
-        return deleted
-    }
-
-    override unshift(...items: T[]): number {
-        const result = super.unshift(...items)
-
-        for (let i = items.length; i < this.length; i++)
-            this.#emit("reorder", this[i]!, i)
-
-        items.forEach((item, i) => this.#emit("insert", item, i))
-
-        return result
-    }
-
-    #responders: { [Protocol in keyof ObservableListProtocols<T>]: Set<ObservableListProtocols<T>[Protocol]> } = {
-        insert: new Set(),
-        delete: new Set(),
-        reorder: new Set(),
-    }
-
-    #emit<Protocol extends keyof ObservableListProtocols<T>>(protocol: Protocol, ...parameters: Parameters<ObservableListProtocols<T>[Protocol]>): ReturnType<ObservableListProtocols<T>[Protocol]>[] {
-        return [...this.#responders[protocol]].map(responder => (<any>responder)(...parameters))
-    }
-
-    on<Protocol extends keyof ObservableListProtocols<T>>(protocol: Protocol, responder: ObservableListProtocols<T>[Protocol]) {
-        this.#responders[protocol].add(responder)
-    }
-
-    off<Protocol extends keyof ObservableListProtocols<T>>(protocol: Protocol, responder: ObservableListProtocols<T>[Protocol]) {
-        this.#responders[protocol].delete(responder)
-    }
-
-    responders<Protocol extends keyof ObservableListProtocols<T>>(protocol: Protocol) {
-        return this.#responders[protocol]
-    }
-}

package/src/types.ts

@@ -1,21 +0,0 @@
-export type Deleteable<T, K extends keyof T = keyof T> = {
-    -readonly [K1 in K]?: T[K1]
-}
-
-export type PartlyDeleteable<T, K extends keyof T> = {
-    [K1 in keyof T as (K1 extends K ? never : K1)]: T[K1]
-} & Deleteable<T, K>
-
-export type UndefinedIf<T, Condition extends boolean = boolean> = Condition extends true ? undefined : T
-
-export function undefinedIf<T, Condition extends boolean = boolean>(condition: Condition, item: () => T): UndefinedIf<T, Condition> {
-    return <UndefinedIf<T, Condition>>(condition ? undefined : item())
-}
-
-export type Prefixed<Prefix extends string, T extends object> = {
-    [K in string & keyof T as `${Prefix}${K}`]: T[K]
-}
-
-export function prefixed<Prefix extends string, T extends object>(prefix: Prefix, o: T): Prefixed<Prefix, T> {
-    return <Prefixed<Prefix, T>>Object.fromEntries(Object.entries(o).map(([k, v]) => [`${prefix}${k}`, v] as const))
-}

package/tsconfig.debug.json

@@ -1,9 +0,0 @@
-{
-    "extends": "@code-essentials/tsconfig/tsconfig.debug.json",
-    "compilerOptions": {
-        "outDir": "dist",
-        "rootDir": "src",
-    },
-    "include": ["src", "src/**/*.spec.ts"],
-    "exclude": ["node_modules"],
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-    "extends": "@code-essentials/tsconfig/tsconfig.json",
-    "compilerOptions": {
-        "outDir": "dist",
-        "rootDir": "src",
-    },
-    "include": ["src"],
-    "exclude": ["node_modules", "src/**/*.spec.ts"],
-}