@the-w1zard/dx 1.0.11 → 1.0.13

package/src/map_rows.ts

@@ -0,0 +1,145 @@
+
+
+export class M2RI<K = N> {
+    #vals: Float64Array;
+    #pidToSlot: Int32Array;
+    #slotToPid: Int32Array;
+    #size = 0;
+    readonly stride: N;
+
+    constructor(capacity = 1024, stride = 3) {
+        this.stride = Math.max(1, stride | 0);
+        const cap = Math.max(1, capacity | 0);
+        this.#pidToSlot = new Int32Array(cap).fill(-1);
+        this.#slotToPid = new Int32Array(cap).fill(-1);
+        this.#vals = new Float64Array(cap * this.stride);
+    }
+
+    get size(): N {
+        return this.#size;
+    }
+    get capacity(): N {
+        return this.#pidToSlot.length;
+    }
+    get buffer(): Float64Array {
+        return this.#vals;
+    }
+
+    get(pid: N): Float64Array | UD {
+        const i = this.#pidToSlot[pid] as N;
+        if (i < 0) return undefined;
+        const o = i * this.stride;
+        return this.#vals.subarray(o, o + this.stride);
+    }
+    has(pid: N): boolean {
+        const i = this.#pidToSlot[pid];
+        return i !== undefined && i !== -1;
+    }
+    set(pid: N, v: Float64Array | ArrayLike<N>): this {
+        this.write(pid, v);
+        return this;
+    }
+    delete(pid: N): boolean {
+        const i = this.#pidToSlot[pid] as N;
+        if (i === undefined || i < 0) return false;
+        const st = this.stride;
+        const last = --this.#size;
+        const lastPid = this.#slotToPid[last];
+        if (i !== last) {
+            this.#vals.copyWithin(i * st, last * st, last * st + st);
+            this.#slotToPid[i] = lastPid;
+            this.#pidToSlot[lastPid] = i;
+        }
+        this.#pidToSlot[pid] = -1;
+        this.#slotToPid[last] = -1;
+        return true;
+    }
+    clear(): void {
+        this.#pidToSlot.fill(-1);
+        this.#slotToPid.fill(-1);
+        this.#size = 0;
+    }
+
+    /** copy a row in, no validation per component */
+    write(pid: N, v: Float64Array | ArrayLike<N>): V {
+        const o = this.#open(pid) * this.stride;
+        this.#vals.set(v as ArrayLike<N>, o);
+    }
+    /** single component: row[c] = v */
+    put(pid: N, c: N, v: N): V {
+        this.#vals[this.#open(pid) * this.stride + c] = v;
+    }
+    /** single component: row[c] */
+    at(pid: N, c: N): N {
+        return this.#vals[this.#pidToSlot[pid] * this.stride + c];
+    }
+    /** pid -> slot, or -1 */
+    slotOf(pid: N): N {
+        const i = this.#pidToSlot[pid];
+        return i === undefined ? -1 : i;
+    }
+    /** zero-copy row view you can write through */
+    row(pid: N): F64 | UD {
+        return this.get(pid);
+    }
+    /** view over the live prefix of the whole table — feed straight to a shader/worker */
+    live(): F64 {
+        return this.#vals.subarray(0, this.#size * this.stride);
+    }
+    *keys(): MapIterator<K> {
+        for (let i = 0; i < this.#size; i++) yield this.#slotToPid[i] as K;
+    }
+    *values(): MapIterator<F64> {
+        const st = this.stride;
+        for (let i = 0; i < this.#size; i++) yield this.#vals.subarray(i * st, i * st + st);
+    }
+    *entries(): MapIterator<[K, F64]> {
+        const st = this.stride;
+        for (let i = 0; i < this.#size; i++) yield [this.#slotToPid[i] as K, this.#vals.subarray(i * st, i * st + st)];
+    }
+    [Symbol.iterator](): MapIterator<[K, F64]> {
+        return this.entries();
+    }
+    forEach(fn: (v: F64, k: K, m: Map<K, F64>) => V, thisArg?: U): V {
+        for (const [k, v] of this.entries()) fn.call(thisArg, v, k, this);
+    }
+    forEachRaw(fn: (pid: N, slot: N) => V): V {
+        for (let i = 0; i < this.#size; i++) fn(this.#slotToPid[i], i);
+    }
+
+    #open(pid: N): N {
+        let p = this.#pidToSlot;
+        if (pid >= p.length) {
+            this.#grow(pid);
+            p = this.#pidToSlot;
+        }
+        let i = p[pid];
+        if (i < 0) {
+            if (this.#size === p.length) {
+                this.#grow(this.#size);
+                p = this.#pidToSlot;
+            }
+            i = this.#size++;
+            p[pid] = i;
+            this.#slotToPid[i] = pid;
+        }
+        return i;
+    }
+    #grow(need: N): V {
+        let cap = this.#pidToSlot.length;
+        while (cap <= need) cap *= 2;
+        const p2s = new Int32Array(cap).fill(-1);
+        p2s.set(this.#pidToSlot);
+        this.#pidToSlot = p2s;
+        const s2p = new Int32Array(cap).fill(-1);
+        s2p.set(this.#slotToPid);
+        this.#slotToPid = s2p;
+        const v = new Float64Array(cap * this.stride);
+        v.set(this.#vals);
+        this.#vals = v;
+    }
+}
+export interface M2R<K> extends M2RI {}
+Object.setPrototypeOf(M2RI.prototype, Map.prototype);
+
+globalThis.M2R = M2RI;

package/src/number.ts

@@ -0,0 +1,212 @@
+
+
+export class N2I extends Number implements N2 {
+	abs(): N2I {
+		return new N2I(Math.abs(this.valueOf()));
+	}
+
+	sign(): N2I {
+		return new N2I(Math.sign(this.valueOf()));
+	}
+
+	neg(): N2I {
+		return new N2I(-this.valueOf());
+	}
+
+	inv(): N2I {
+		return new N2I(1 / this.valueOf());
+	}
+
+	clamp(min: N, max: N): N2I {
+		return new N2I(Math.min(Math.max(this.valueOf(), min), max));
+	}
+
+	wrap(min: N, max: N): N2I {
+		const range = max - min;
+		if (range <= 0) throw new RangeError("max must be greater than min");
+		return new N2I((((this.valueOf() - min) % range) + range) % range + min);
+	}
+
+	lerp(to: N, t: N): N2I {
+		return new N2I(this.valueOf() + (to - this.valueOf()) * t);
+	}
+
+	map(inMin: N, inMax: N, outMin: N, outMax: N): N2I {
+		if (inMax === inMin) throw new RangeError("Input range cannot be zero");
+		return new N2I(outMin + ((this.valueOf() - inMin) / (inMax - inMin)) * (outMax - outMin));
+	}
+
+	remap(inMin: N, inMax: N, outMin: N, outMax: N): N2I {
+		return this.map(inMin, inMax, outMin, outMax);
+	}
+
+	roundTo(precision: N = 0): N2I {
+		const factor = 10 ** precision;
+		return new N2I(Math.round((this.valueOf() + Number.EPSILON) * factor) / factor);
+	}
+
+	floorTo(precision: N = 0): N2I {
+		const factor = 10 ** precision;
+		return new N2I(Math.floor(this.valueOf() * factor) / factor);
+	}
+
+	ceilTo(precision: N = 0): N2I {
+		const factor = 10 ** precision;
+		return new N2I(Math.ceil(this.valueOf() * factor) / factor);
+	}
+
+	truncTo(precision: N = 0): N2I {
+		const factor = 10 ** precision;
+		return new N2I(Math.trunc(this.valueOf() * factor) / factor);
+	}
+
+	isFinite(): B {
+		return Number.isFinite(this.valueOf());
+	}
+
+	isInteger(): B {
+		return Number.isInteger(this.valueOf());
+	}
+
+	isSafeInteger(): B {
+		return Number.isSafeInteger(this.valueOf());
+	}
+
+	isNaN(): B {
+		return Number.isNaN(this.valueOf());
+	}
+
+	isBetween(min: N, max: N, inclusive: B = true): B {
+		const value = this.valueOf();
+		return inclusive ? value >= min && value <= max : value > min && value < max;
+	}
+
+	isPositive(): B {
+		return this.valueOf() > 0;
+	}
+
+	isNegative(): B {
+		return this.valueOf() < 0;
+	}
+
+	isZero(): B {
+		return this.valueOf() === 0;
+	}
+
+	isEven(): B {
+		const value = this.valueOf();
+		return Number.isInteger(value) && value % 2 === 0;
+	}
+
+	isOdd(): B {
+		const value = this.valueOf();
+		return Number.isInteger(value) && Math.abs(value % 2) === 1;
+	}
+
+	squared(): N2I {
+		return new N2I(this.valueOf() ** 2);
+	}
+
+	cubed(): N2I {
+		return new N2I(this.valueOf() ** 3);
+	}
+
+	sqrt(): N2I {
+		return new N2I(Math.sqrt(this.valueOf()));
+	}
+
+	cbrt(): N2I {
+		return new N2I(Math.cbrt(this.valueOf()));
+	}
+
+	pow(exponent: N): N2I {
+		return new N2I(this.valueOf() ** exponent);
+	}
+
+	root(degree: N): N2I {
+		if (degree === 0) throw new RangeError("Root degree cannot be zero");
+		const value = this.valueOf();
+		if (value < 0 && Number.isInteger(degree) && Math.abs(degree % 2) === 1) {
+			return new N2I(-((-value) ** (1 / degree)));
+		}
+		return new N2I(value ** (1 / degree));
+	}
+
+	mod(divisor: N): N2I {
+		if (divisor === 0) throw new RangeError("Divisor cannot be zero");
+		return new N2I(((this.valueOf() % divisor) + divisor) % divisor);
+	}
+
+	percentOf(total: N): N2I {
+		return new N2I((this.valueOf() / 100) * total);
+	}
+
+	percentChange(from: N): N2I {
+		if (from === 0) throw new RangeError("Cannot calculate percentage change from zero");
+		return new N2I(((this.valueOf() - from) / Math.abs(from)) * 100);
+	}
+
+	toRadians(): N2I {
+		return new N2I(this.valueOf() * (Math.PI / 180));
+	}
+
+	toDegrees(): N2I {
+		return new N2I(this.valueOf() * (180 / Math.PI));
+	}
+
+	toOrdinal(): S {
+		const value = this.valueOf();
+		const integer = Math.trunc(value);
+		const abs = Math.abs(integer);
+		const suffix = abs % 100 >= 11 && abs % 100 <= 13
+			? "th"
+			: ({ 1: "st", 2: "nd", 3: "rd" } as Record<N, S>)[abs % 10] ?? "th";
+		return `${value}${suffix}`;
+	}
+
+	toBytes(unit?: N, decimals: N = 2): S {
+		const value = this.valueOf();
+		const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB"];
+		const index = unit === undefined
+			? value === 0 ? 0 : Math.min(Math.floor(Math.log(Math.abs(value)) / Math.log(1024)), units.length - 1)
+			: Math.max(0, Math.min(Math.trunc(unit), units.length - 1));
+		return `${(value / 1024 ** index).toFixed(decimals)} ${units[index]}`;
+	}
+
+	toCompact(locales?: Intl.LocalesArgument): S {
+		return new Intl.NumberFormat(locales, { notation: "compact", maximumFractionDigits: 2 }).format(this.valueOf());
+	}
+
+	toCurrency(currency: S = "USD", locales?: Intl.LocalesArgument): S {
+		return new Intl.NumberFormat(locales, { style: "currency", currency }).format(this.valueOf());
+	}
+
+	toPercent(decimals: N = 0, locales?: Intl.LocalesArgument): S {
+		return new Intl.NumberFormat(locales, {
+			style: "percent",
+			maximumFractionDigits: decimals,
+		}).format(this.valueOf());
+	}
+
+	times(fn: (index: N) => void): this {
+		const count = this.valueOf();
+		for (let i = 0; i < count; i++) fn(i);
+		return this;
+	}
+
+	upTo(end: N, step: N = 1): AR<N> {
+		if (step <= 0) throw new RangeError("step must be positive");
+		const out: N[] = [];
+		for (let value = this.valueOf(); value <= end; value += step) out.push(value);
+		return out as AR<N>;
+	}
+
+	downTo(end: N, step: N = 1): AR<N> {
+		if (step <= 0) throw new RangeError("step must be positive");
+		const out: N[] = [];
+		for (let value = this.valueOf(); value >= end; value -= step) out.push(value);
+		return out as AR<N>;
+	}
+}
+
+globalThis.N2 = N2I;

package/src/object.ts

@@ -0,0 +1,291 @@
+
+
+export class O2I   {
+    static isEmpty(value: object): B {
+        return Reflect.ownKeys(value).length === 0;
+    }
+    static isNotEmpty(value: object): B {
+        return Reflect.ownKeys(value).length !== 0;
+    }
+    static size(value: object): N {
+        return Reflect.ownKeys(value).length as N;
+    }
+    static isPlainObject(value: unknown): B {
+        if (value === null || typeof value !== "object") return false;
+        const prototype = Object.getPrototypeOf(value);
+        return prototype === Object.prototype || prototype === null;
+    }
+    static isObject(value: unknown): B {
+        return value !== null && typeof value === "object";
+    }
+    static get<X = unknown>(
+        value: unknown,
+        path: string | readonly PropertyKey[],
+        fallback?: X
+    ): unknown | X {
+        const parts: readonly PropertyKey[] = typeof path === "string" ? path.split(".") : path;
+        let current = value;
+
+        for (const key of parts) {
+            if (current === null || (typeof current !== "object" && typeof current !== "function")) {
+                return fallback;
+            }
+            current = (current as Record<PropertyKey, unknown>)[key];
+        }
+
+        return current === undefined ? fallback : current;
+    }
+    static getOr<X>(value: unknown, path: string | readonly PropertyKey[], fallback: X): X {
+        return this.get(value, path, fallback) as X;
+    }
+    static set<T extends object>(value: T, path: string | readonly PropertyKey[], next: unknown): T {
+        const parts: readonly PropertyKey[] = typeof path === "string" ? path.split(".") : path;
+        if (!parts.length) return value;
+
+        let current = value as Record<PropertyKey, unknown>;
+
+        for (let i = 0; i < parts.length - 1; i++) {
+            const key = parts[i];
+            const child = current[key];
+
+            if (child === null || (typeof child !== "object" && typeof child !== "function")) {
+                current[key] = {};
+            }
+
+            current = current[key] as Record<PropertyKey, unknown>;
+        }
+
+        current[parts[parts.length - 1]] = next;
+        return value;
+    }
+    static unset(value: object, path: string | readonly PropertyKey[]): B {
+        const parts: readonly PropertyKey[] = typeof path === "string" ? path.split(".") : path;
+        if (!parts.length) return false;
+
+        let current = value as Record<PropertyKey, unknown>;
+
+        for (let i = 0; i < parts.length - 1; i++) {
+            const child = current[parts[i]];
+            if (child === null || typeof child !== "object") return false;
+            current = child as Record<PropertyKey, unknown>;
+        }
+
+        return Reflect.deleteProperty(current, parts[parts.length - 1]);
+    }
+    static hasPath(value: unknown, path: string | readonly PropertyKey[]): B {
+        const parts: readonly PropertyKey[] = typeof path === "string" ? path.split(".") : path;
+        let current = value;
+
+        for (const key of parts) {
+            if (current === null || (typeof current !== "object" && typeof current !== "function")) {
+                return false;
+            }
+            if (!Object.prototype.hasOwnProperty.call(current, key)) return false;
+            current = (current as Record<PropertyKey, unknown>)[key];
+        }
+
+        return true;
+    }
+    static clone<T>(value: T): T {
+        if (value === null || typeof value !== "object") return value;
+        if (Array.isArray(value)) return value.slice() as T;
+        return Object.assign(Object.create(Object.getPrototypeOf(value)), value);
+    }
+    static deepClone<T>(value: T): T {
+        return structuredClone(value);
+    }
+    static deepMerge<T extends object, U extends object>(target: T, source: U): T & U {
+        const result = { ...target } as Record<PropertyKey, unknown>;
+
+        for (const key of Reflect.ownKeys(source)) {
+            const incoming = source[key as keyof U];
+            const current = result[key];
+
+            result[key] =
+                this.isPlainObject(current) && this.isPlainObject(incoming)
+                    ? this.deepMerge(
+                        current as Record<PropertyKey, unknown>,
+                        incoming as Record<PropertyKey, unknown>
+                    )
+                    : incoming;
+        }
+
+        return result as T & U;
+    }
+    static defaults<T extends object, U extends object>(target: T, defaults: U): T & U {
+        return Object.assign({}, defaults, target) as T & U;
+    }
+    static getOrCreate<T extends object, K extends PropertyKey, X>(
+        value: T,
+        key: K,
+        create: () => X
+    ): T & Record<K, X> {
+        const object = value as T & Record<K, X>;
+
+        if (!Object.prototype.hasOwnProperty.call(object, key) || object[key] === undefined) {
+            object[key] = create() as (T & Record<K, X>)[K];
+        }
+
+        return object;
+    }
+    static pick<T extends object, K extends keyof T>(value: T, keys: readonly K[]): Pick<T, K> {
+        const result = {} as Pick<T, K>;
+
+        for (const key of keys) {
+            if (Object.prototype.hasOwnProperty.call(value, key)) result[key] = value[key];
+        }
+
+        return result;
+    }
+    static omit<T extends object, K extends keyof T>(value: T, keys: readonly K[]): Omit<T, K> {
+        const result = { ...value };
+
+        for (const key of keys) delete result[key];
+
+        return result;
+    }
+    static pickBy<T extends object>(
+        value: T,
+        predicate: (value: T[keyof T], key: keyof T) => B
+    ): Partial<T> {
+        const result: Partial<T> = {};
+
+        for (const key of Object.keys(value) as (keyof T)[]) {
+            if (predicate(value[key], key)) result[key] = value[key];
+        }
+
+        return result;
+    }
+    static omitBy<T extends object>(
+        value: T,
+        predicate: (value: T[keyof T], key: keyof T) => B
+    ): Partial<T> {
+        const result: Partial<T> = {};
+
+        for (const key of Object.keys(value) as (keyof T)[]) {
+            if (!predicate(value[key], key)) result[key] = value[key];
+        }
+
+        return result;
+    }
+    static mapKeys<T extends object, K extends PropertyKey>(
+        value: T,
+        mapper: (key: keyof T, value: T[keyof T]) => K
+    ): Partial<Record<K, T[keyof T]>> {
+        const result: Partial<Record<K, T[keyof T]>> = {};
+
+        for (const key of Object.keys(value) as (keyof T)[]) {
+            result[mapper(key, value[key])] = value[key];
+        }
+
+        return result;
+    }
+    static mapValues<T extends object, X>(
+        value: T,
+        mapper: (value: T[keyof T], key: keyof T) => X
+    ): { [K in keyof T]: X } {
+        const result = {} as { [K in keyof T]: X };
+
+        for (const key of Object.keys(value) as (keyof T)[]) {
+            result[key] = mapper(value[key], key);
+        }
+
+        return result;
+    }
+    static mapEntries<T extends object, K extends PropertyKey, X>(
+        value: T,
+        mapper: (entry: [keyof T, T[keyof T]]) => readonly [K, X]
+    ): Partial<Record<K, X>> {
+        const result: Partial<Record<K, X>> = {};
+
+        for (const key of Object.keys(value) as (keyof T)[]) {
+            const [nextKey, nextValue] = mapper([key, value[key]]);
+            result[nextKey] = nextValue;
+        }
+
+        return result;
+    }
+    static filter<T extends object>(
+        value: T,
+        predicate: (value: T[keyof T], key: keyof T) => B
+    ): Partial<T> {
+        return this.pickBy(value, predicate);
+    }
+    static isEqual(first: unknown, second: unknown): B {
+        if (Object.is(first, second)) return true;
+
+        if (
+            first === null || second === null ||
+            typeof first !== "object" || typeof second !== "object"
+        ) {
+            return false;
+        }
+
+        if (first instanceof Date && second instanceof Date) {
+            return first.getTime() === second.getTime();
+        }
+
+        if (Array.isArray(first) || Array.isArray(second)) {
+            return Array.isArray(first) && Array.isArray(second) &&
+                first.length === second.length &&
+                first.every((value, index) => this.isEqual(value, second[index]));
+        }
+
+        const firstKeys = Reflect.ownKeys(first);
+        const secondKeys = Reflect.ownKeys(second);
+
+        return firstKeys.length === secondKeys.length &&
+            firstKeys.every(key =>
+                secondKeys.includes(key) &&
+                this.isEqual(
+                    (first as Record<PropertyKey, unknown>)[key],
+                    (second as Record<PropertyKey, unknown>)[key]
+                )
+            );
+    }
+    static isShallowEqual(first: object, second: object): B {
+        if (Object.is(first, second)) return true;
+
+        const firstKeys = Reflect.ownKeys(first);
+        const secondKeys = Reflect.ownKeys(second);
+
+        return firstKeys.length === secondKeys.length &&
+            firstKeys.every(key =>
+                secondKeys.includes(key) &&
+                Object.is(
+                    (first as Record<PropertyKey, unknown>)[key],
+                    (second as Record<PropertyKey, unknown>)[key]
+                )
+            );
+    }
+    static hasAll<T extends object>(value: T, keys: readonly PropertyKey[]): B {
+        return keys.every(key => Object.prototype.hasOwnProperty.call(value, key));
+    }
+    static hasAny<T extends object>(value: T, keys: readonly PropertyKey[]): B {
+        return keys.some(key => Object.prototype.hasOwnProperty.call(value, key));
+    }
+    static assertKeys<T extends object>(value: T, keys: readonly PropertyKey[]): asserts value is T {
+        const missing = keys.filter(key => !Object.prototype.hasOwnProperty.call(value, key));
+
+        if (missing.length) {
+            throw new TypeError(`Missing required keys: ${missing.map(String).join(", ")}`);
+        }
+    }
+    static with<T extends object, K extends keyof T>(value: T, key: K, next: T[K]): T {
+        return { ...value, [key]: next };
+    }
+    static without<T extends object, K extends keyof T>(value: T, key: K): Omit<T, K> {
+        const result = { ...value };
+        delete result[key];
+        return result;
+    }
+    static update<T extends object, K extends keyof T>(
+        value: T,
+        key: K,
+        updater: (current: T[K]) => T[K]
+    ): T {
+        return { ...value, [key]: updater(value[key]) };
+    }
+}
+
+globalThis.O2 = O2I;