@the-w1zard/dx 1.0.7 → 1.0.9

package/src/number.ts

@@ -1,212 +0,0 @@
-
-
-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.js

@@ -1,217 +0,0 @@
-export class O2I {
-    static isEmpty(value) {
-        return Reflect.ownKeys(value).length === 0;
-    }
-    static isNotEmpty(value) {
-        return Reflect.ownKeys(value).length !== 0;
-    }
-    static size(value) {
-        return Reflect.ownKeys(value).length;
-    }
-    static isPlainObject(value) {
-        if (value === null || typeof value !== "object")
-            return false;
-        const prototype = Object.getPrototypeOf(value);
-        return prototype === Object.prototype || prototype === null;
-    }
-    static isObject(value) {
-        return value !== null && typeof value === "object";
-    }
-    static get(value, path, fallback) {
-        const parts = 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[key];
-        }
-        return current === undefined ? fallback : current;
-    }
-    static getOr(value, path, fallback) {
-        return this.get(value, path, fallback);
-    }
-    static set(value, path, next) {
-        const parts = typeof path === "string" ? path.split(".") : path;
-        if (!parts.length)
-            return value;
-        let current = value;
-        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];
-        }
-        current[parts[parts.length - 1]] = next;
-        return value;
-    }
-    static unset(value, path) {
-        const parts = typeof path === "string" ? path.split(".") : path;
-        if (!parts.length)
-            return false;
-        let current = value;
-        for (let i = 0; i < parts.length - 1; i++) {
-            const child = current[parts[i]];
-            if (child === null || typeof child !== "object")
-                return false;
-            current = child;
-        }
-        return Reflect.deleteProperty(current, parts[parts.length - 1]);
-    }
-    static hasPath(value, path) {
-        const parts = 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[key];
-        }
-        return true;
-    }
-    static clone(value) {
-        if (value === null || typeof value !== "object")
-            return value;
-        if (Array.isArray(value))
-            return value.slice();
-        return Object.assign(Object.create(Object.getPrototypeOf(value)), value);
-    }
-    static deepClone(value) {
-        return structuredClone(value);
-    }
-    static deepMerge(target, source) {
-        const result = { ...target };
-        for (const key of Reflect.ownKeys(source)) {
-            const incoming = source[key];
-            const current = result[key];
-            result[key] =
-                this.isPlainObject(current) && this.isPlainObject(incoming)
-                    ? this.deepMerge(current, incoming)
-                    : incoming;
-        }
-        return result;
-    }
-    static defaults(target, defaults) {
-        return Object.assign({}, defaults, target);
-    }
-    static getOrCreate(value, key, create) {
-        const object = value;
-        if (!Object.prototype.hasOwnProperty.call(object, key) || object[key] === undefined) {
-            object[key] = create();
-        }
-        return object;
-    }
-    static pick(value, keys) {
-        const result = {};
-        for (const key of keys) {
-            if (Object.prototype.hasOwnProperty.call(value, key))
-                result[key] = value[key];
-        }
-        return result;
-    }
-    static omit(value, keys) {
-        const result = { ...value };
-        for (const key of keys)
-            delete result[key];
-        return result;
-    }
-    static pickBy(value, predicate) {
-        const result = {};
-        for (const key of Object.keys(value)) {
-            if (predicate(value[key], key))
-                result[key] = value[key];
-        }
-        return result;
-    }
-    static omitBy(value, predicate) {
-        const result = {};
-        for (const key of Object.keys(value)) {
-            if (!predicate(value[key], key))
-                result[key] = value[key];
-        }
-        return result;
-    }
-    static mapKeys(value, mapper) {
-        const result = {};
-        for (const key of Object.keys(value)) {
-            result[mapper(key, value[key])] = value[key];
-        }
-        return result;
-    }
-    static mapValues(value, mapper) {
-        const result = {};
-        for (const key of Object.keys(value)) {
-            result[key] = mapper(value[key], key);
-        }
-        return result;
-    }
-    static mapEntries(value, mapper) {
-        const result = {};
-        for (const key of Object.keys(value)) {
-            const [nextKey, nextValue] = mapper([key, value[key]]);
-            result[nextKey] = nextValue;
-        }
-        return result;
-    }
-    static filter(value, predicate) {
-        return this.pickBy(value, predicate);
-    }
-    static isEqual(first, second) {
-        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[key], second[key]));
-    }
-    static isShallowEqual(first, second) {
-        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[key], second[key]));
-    }
-    static hasAll(value, keys) {
-        return keys.every(key => Object.prototype.hasOwnProperty.call(value, key));
-    }
-    static hasAny(value, keys) {
-        return keys.some(key => Object.prototype.hasOwnProperty.call(value, key));
-    }
-    static assertKeys(value, keys) {
-        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(value, key, next) {
-        return { ...value, [key]: next };
-    }
-    static without(value, key) {
-        const result = { ...value };
-        delete result[key];
-        return result;
-    }
-    static update(value, key, updater) {
-        return { ...value, [key]: updater(value[key]) };
-    }
-}
-globalThis.O2 = O2I;