@the-w1zard/dx 1.0.11 → 1.0.13

package/src/unit8array.ts

@@ -0,0 +1,374 @@
+
+export class U82I<T = A> extends Array<T> implements U82<T> {
+	constructor(...items: T[]) {
+		super(...items);
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+
+	static get [Symbol.species](): ArrayConstructor {
+		return Array;
+	}
+
+	static override from<T>(arrayLike: ArrayLike<T>): U82I<T>;
+	static override from<T, U>(
+		arrayLike: ArrayLike<T>,
+		mapFn: (value: T, index: number) => U,
+		thisArg?: A,
+	): U82I<U>;
+	static override from<T>(iterable: Iterable<T> | ArrayLike<T>): U82I<T>;
+	static override from<T, U>(
+		iterable: Iterable<T> | ArrayLike<T>,
+		mapFn?: (value: T, index: number) => U,
+		thisArg?: A,
+	): U82I<T | U> {
+		const values: T[] =
+			Symbol.iterator in Object(iterable)
+				? Array.from(iterable as Iterable<T>)
+				: Array.from(iterable as ArrayLike<T>);
+
+		const result: (T | U)[] = mapFn
+			? values.map((value, index) => mapFn.call(thisArg, value, index))
+			: values;
+
+		return new U82I<T | U>(...result);
+	}
+
+	static override of<T>(...items: T[]): U82I<T> {
+		return new U82I(...items);
+	}
+
+	first(): T | undefined {
+		return this[0];
+	}
+
+	last(): T | undefined {
+		return this[this.length - 1];
+	}
+
+	second(): T | undefined {
+		return this[1];
+	}
+
+	third(): T | undefined {
+		return this[2];
+	}
+
+	random(): T | undefined {
+		return this.length ? this[Math.floor(Math.random() * this.length)] : undefined;
+	}
+
+	isEmpty(): boolean {
+		return this.length === 0;
+	}
+
+	isNotEmpty(): boolean {
+		return this.length > 0;
+	}
+
+	isNotEmptyAndDefined(): boolean {
+		return this.some(value => value !== undefined && value !== null);
+	}
+
+	clear(): this {
+		this.length = 0;
+		return this;
+	}
+
+	clone(): U82I<T> {
+		return new U82I(...this);
+	}
+
+	unique(): U82I<T> {
+		return new U82I(...new Set(this));
+	}
+
+	compact(): U82I<NonNullable<T>> {
+		return new U82I(...this.filter((value): value is NonNullable<T> => value != null));
+	}
+
+	chunk(size: N): U82I<U82I<T>> {
+		if (size <= 0) throw new RangeError("Chunk size must be greater than zero");
+
+		const result = new U82I<U82I<T>>();
+
+		for (let i = 0; i < this.length; i += size) {
+			result.push(new U82I(...this.slice(i, i + size)));
+		}
+
+		return result;
+	}
+
+	flatten<D extends N = 1>(depth?: D): U82I<A> {
+		return new U82I(...(this.flat(depth) as A[]));
+	}
+
+	shuffle(): this {
+		return this.shuffleInPlace();
+	}
+
+	sample(count = 1 as N): U82I<T> {
+		return this.pick(count);
+	}
+
+	count(predicate?: (value: T, index: N, array: T[]) => unknown): N {
+		return (predicate ? this.filter(predicate).length : this.length) as N;
+	}
+
+	sum(this: U82I<number>): number {
+		return this.reduce((total, value) => total + value, 0);
+	}
+
+	average(this: U82I<number>): number {
+		return this.length ? this.sum() / this.length : 0;
+	}
+
+	min(this: U82I<number>): number | undefined {
+		return this.length ? Math.min(...this) : undefined;
+	}
+
+	max(this: U82I<number>): number | undefined {
+		return this.length ? Math.max(...this) : undefined;
+	}
+
+	groupBy<K extends PropertyKey>(keyFn: (value: T, index: N) => K): Map<K, U82I<T>> {
+		const result = new Map<K, U82I<T>>();
+
+		this.forEach((value, index) => {
+			const key = keyFn(value, index as N);
+
+			if (!result.has(key)) result.set(key, new U82I<T>());
+			result.get(key)!.push(value);
+		});
+
+		return result;
+	}
+
+	keyBy<K extends PropertyKey>(keyFn: (value: T, index: N) => K): Map<K, T> {
+		const result = new Map<K, T>();
+
+		this.forEach((value, index) => result.set(keyFn(value, index as N), value));
+
+		return result;
+	}
+
+	partition(predicate: (value: T, index: N, array: T[]) => unknown): [U82I<T>, U82I<T>] {
+		const yes = new U82I<T>();
+		const no = new U82I<T>();
+
+		this.forEach((value, index, array) => {
+			(predicate(value, index as N, array) ? yes : no).push(value);
+		});
+
+		return [yes, no];
+	}
+
+	difference(other: Iterable<T>): U82I<T> {
+		const values = new Set(other);
+		return new U82I(...this.filter(value => !values.has(value)));
+	}
+
+	intersection(other: Iterable<T>): U82I<T> {
+		const values = new Set(other);
+		return new U82I(...this.filter(value => values.has(value)));
+	}
+
+	union(other: Iterable<T>): U82I<T> {
+		return new U82I(...new Set([...this, ...other]));
+	}
+
+	symmetricDifference(other: Iterable<T>): U82I<T> {
+		const values = new Set(other);
+		const own = new Set(this);
+
+		return new U82I(
+			...[...this.filter(value => !values.has(value)), ...Array.from(values).filter(value => !own.has(value))],
+		);
+	}
+
+	take(count: N): U82I<T> {
+		return new U82I(...this.slice(0, Math.max(0, count)));
+	}
+
+	takeLast(count: N): U82I<T> {
+		return new U82I(...this.slice(-Math.max(0, count)));
+	}
+
+	drop(count: N): U82I<T> {
+		return new U82I(...this.slice(Math.max(0, count)));
+	}
+
+	dropLast(count: N): U82I<T> {
+		return new U82I(...this.slice(0, Math.max(0, this.length - count)));
+	}
+
+	pluck<K extends keyof T>(key: K): U82I<T[K]> {
+		return new U82I(...this.map(value => value[key]));
+	}
+
+	flattenDeep(): U82I<A> {
+		return new U82I(...(this.flat(Infinity) as A[]));
+	}
+
+	insert(index: N, ...items: T[]): this {
+		this.splice(index, 0, ...items);
+		return this;
+	}
+
+	removeAt(index: N): T | undefined {
+		if (index < 0 || index >= this.length) return undefined;
+		return this.splice(index, 1)[0];
+	}
+
+	remove(value: T): boolean {
+		const index = this.indexOf(value);
+
+		if (index === -1) return false;
+
+		this.splice(index, 1);
+		return true;
+	}
+
+	removeWhere(predicate: (value: T, index: N, array: T[]) => unknown): this {
+		for (let i = this.length - 1; i >= 0; i--) {
+			if (predicate(this[i], i as N, this)) this.splice(i, 1);
+		}
+
+		return this;
+	}
+
+	replace(oldValue: T, newValue: T): boolean {
+		const index = this.indexOf(oldValue);
+
+		if (index === -1) return false;
+
+		this[index] = newValue;
+		return true;
+	}
+
+	move(from: N, to: N): this {
+		if (from < 0 || from >= this.length || to < 0 || to >= this.length) return this;
+
+		const [value] = this.splice(from, 1);
+		this.splice(to, 0, value);
+
+		return this;
+	}
+
+	swap(i: N, j: N): this {
+		if (i < 0 || j < 0 || i >= this.length || j >= this.length) return this;
+
+		[this[i], this[j]] = [this[j], this[i]];
+
+		return this;
+	}
+
+	shuffleInPlace(): this {
+		for (let i = this.length - 1; i > 0; i--) {
+			const j = Math.floor(Math.random() * (i + 1));
+			[this[i], this[j]] = [this[j], this[i]];
+		}
+
+		return this;
+	}
+
+	pick(count = 1 as N): U82I<T> {
+		const values = [...this];
+		const result = new U82I<T>();
+
+		for (let i = 0; i < Math.min(Math.max(0, count), values.length); i++) {
+			const j = Math.floor(Math.random() * values.length);
+			result.push(values.splice(j, 1)[0]);
+		}
+
+		return result;
+	}
+
+	toSet(): Set<T> {
+		return new Set(this);
+	}
+
+	toMap<K extends PropertyKey>(keyFn: (value: T, index: N) => K): Map<K, T> {
+		return this.keyBy(keyFn);
+	}
+
+	equals(other: readonly T[]): boolean {
+		return this.length === other.length && this.every((value, index) => Object.is(value, other[index]));
+	}
+
+	startsWith(other: readonly T[]): boolean {
+		return other.length <= this.length && other.every((value, index) => Object.is(this[index], value));
+	}
+
+	endsWith(other: readonly T[]): boolean {
+		return (
+			other.length <= this.length &&
+			other.every((value, index) => Object.is(this[this.length - other.length + index], value))
+		);
+	}
+
+	isSorted(compareFn: (a: T, b: T) => N = ((a, b) => (a < b ? -1 : a > b ? 1 : 0) as N)): boolean {
+		for (let i = 1; i < this.length; i++) {
+			if (compareFn(this[i - 1], this[i]) > 0) return false;
+		}
+
+		return true;
+	}
+
+	frequencies(): Map<T, N> {
+		const result = new Map<T, N>();
+
+		for (const value of this) {
+			result.set(value, ((result.get(value) ?? 0) + 1) as N);
+		}
+
+		return result;
+	}
+	findLast<S extends T>(
+		predicate: (value: T, index: N, obj: T[]) => value is S,
+		thisArg?: A,
+	): S | undefined;
+	findLast(
+		predicate: (value: T, index: N, obj: T[]) => unknown,
+		thisArg?: A,
+	): T | undefined {
+		for (let i = this.length - 1; i >= 0; i--) {
+			if (predicate.call(thisArg, this[i], i as N, this)) return this[i];
+		}
+		return undefined;
+	}
+	
+	findLastIndex(predicate: (value: T, index: N, obj: T[]) => unknown, thisArg?: A): N {
+		for (let i = this.length - 1; i >= 0; i--) {
+			if (predicate.call(thisArg, this[i], i as N, this)) return i as N;
+		}
+		return -1 as N;
+	}
+	
+	toReversed(): T[] {
+		return [...this].reverse();
+	}
+	
+	toSorted(compareFn?: (a: T, b: T) => N): T[] {
+		return [...this].sort(compareFn);
+	}
+	
+	toSpliced(start: N, deleteCount: N, ...items: T[]): T[] {
+		const result = [...this];
+		result.splice(start, deleteCount, ...items);
+		return result;
+	}
+	
+	with(index: N, value: T): T[] {
+		const result = [...this];
+		const actualIndex = index < 0 ? result.length + index : index;
+	
+		if (actualIndex < 0 || actualIndex >= result.length) {
+			throw new RangeError("Invalid index");
+		}
+	
+		result[actualIndex] = value;
+		return result;
+	}
+}
+
+globalThis.U82 = U82I;

package/src/url_search_params.ts

@@ -0,0 +1,187 @@
+
+
+export class USP2I extends URLSearchParams implements USP2 {
+	constructor(init?: S | URLSearchParams | R<S, S> | S[][]) {
+		super(init as S | URLSearchParams | R<S, S> | S[][] | UD);
+	}
+
+	get size(): N {
+		return Array.from(this).length as N;
+	}
+
+	getOr(name: S, fallback: S): S {
+		return this.get(name) ?? fallback;
+	}
+
+	getOrNull(name: S): S | NU {
+		return this.get(name);
+	}
+
+	getOrThrow(name: S, error: A = new Error(`Missing URL parameter: ${name}`)): string {
+		const value = this.get(name);
+		if (value === null) throw error;
+		return value;
+	}
+
+	getNumber(name: S, fallback?: N): N | UD {
+		const value = this.get(name);
+		if (value === null || value.trim() === "") return fallback;
+		const number = Number(value);
+		return Number.isFinite(number) ? number : fallback;
+	}
+
+	getInt(name: S, radix: N = 10 as N): N | UD {
+		const value = this.get(name);
+		if (value === null || value.trim() === "") return undefined;
+		const number = Number.parseInt(value, radix);
+		return Number.isNaN(number) ? undefined : number;
+	}
+
+	getFloat(name: S): N | UD {
+		const value = this.get(name);
+		if (value === null || value.trim() === "") return undefined;
+		const number = Number.parseFloat(value);
+		return Number.isNaN(number) ? undefined : number;
+	}
+
+	getBoolean(name: S, fallback = false): B {
+		const value = this.get(name);
+		if (value === null) return fallback;
+		switch (value.trim().toLowerCase()) {
+			case "true":
+			case "1":
+			case "yes":
+			case "on":
+				return true;
+			case "false":
+			case "0":
+			case "no":
+			case "off":
+				return false;
+			default:
+				return fallback;
+		}
+	}
+
+	getJSON<T = A>(name: S): T | UD {
+		const value = this.get(name);
+		if (value === null) return undefined;
+		try {
+			return JSON.parse(value) as T;
+		} catch {
+			return undefined;
+		}
+	}
+
+	getArray(name: S, separator = ","): S[] {
+		const value = this.get(name);
+		return value === null || value === "" ? [] : value.split(separator);
+	}
+
+	getObject<T extends R<S, A> = R<S, A>>(): T {
+		const result: R<S, A> = {};
+		for (const key of new Set(this.keys())) {
+			const values = this.getAll(key);
+			result[key] = values.length > 1 ? values : values[0];
+		}
+		return result as T;
+	}
+
+	setNumber(name: S, value: N): this {
+		this.set(name, String(value));
+		return this;
+	}
+
+	setBoolean(name: S, value: B): this {
+		this.set(name, String(value));
+		return this;
+	}
+
+	setJSON(name: S, value: A): this {
+		this.set(name, JSON.stringify(value));
+		return this;
+	}
+
+	setArray(name: S, values: Iterable<A>, separator = ","): this {
+		this.set(name, Array.from(values, String).join(separator));
+		return this;
+	}
+
+	setIfAbsent(name: S, value: S): this {
+		if (!this.has(name)) this.set(name, value);
+		return this;
+	}
+
+	setIfPresent(name: S, value: S): this {
+		if (this.has(name)) this.set(name, value);
+		return this;
+	}
+
+	appendAll(params: URLSearchParams | R<S, A>): this {
+		if (params instanceof URLSearchParams) {
+			params.forEach((value, key) => this.append(key, value));
+		} else {
+			for (const [key, value] of Object.entries(params)) {
+				if (value != null) {
+					if (Array.isArray(value)) {
+						for (const item of value) this.append(key, String(item));
+					} else {
+						this.append(key, String(value));
+					}
+				}
+			}
+		}
+		return this;
+	}
+
+	merge(params: URLSearchParams | R<S, A>, overwrite = true): this {
+		if (params instanceof URLSearchParams) {
+			params.forEach((value, key) => {
+				if (overwrite || !this.has(key)) this.set(key, value);
+			});
+		} else {
+			for (const [key, value] of Object.entries(params)) {
+				if (value != null && (overwrite || !this.has(key))) {
+					this.set(key, String(value));
+				}
+			}
+		}
+		return this;
+	}
+
+	clone(): USP2I {
+		return new USP2I(this);
+	}
+
+	clear(): V {
+		for (const key of new Set(this.keys())) this.delete(key);
+	}
+
+	isEmpty(): B {
+		return this.size === 0;
+	}
+
+	isNotEmpty(): B {
+		return this.size > 0;
+	}
+
+	toObject(): R<S, S | S[]> {
+		return this.getObject();
+	}
+
+	toJSON(): R<S, S | S[]> {
+		return this.toObject();
+	}
+
+	toURLSearchParams(): URLSearchParams {
+		return new URLSearchParams(this);
+	}
+
+	toURL(url: S | URL): URL {
+		const result = new URL(url);
+		this.forEach((value, key) => result.searchParams.append(key, value));
+		return result;
+	}
+}
+
+globalThis.USP2 = USP2I 

package/src/weak_map.ts

@@ -0,0 +1,155 @@
+
+export class WM2I<H extends WeakKey = A, T = A> extends WeakMap<H, T> implements WM2<H, T> {
+	g = this.get;
+	h = this.has;
+	d = this.delete;
+
+	private _tracked?: Set<H>;
+
+	s(k: H, v: T | (() => T)): this {
+		const n = typeof v === "function" ? (v as () => T)() : v;
+		super.set(k, n);
+		return this;
+	}
+
+	swap(key: H, value: T): T | UD {
+		const previous = this.h(key) ? this.g(key) : undefined;
+		this.s(key, value);
+		return previous as T | UD;
+	}
+
+	take(key: H): T | UD {
+		const value = this.g(key);
+		this.d(key);
+		return value;
+	}
+
+	getAndDelete(key: H): T | UD {
+		return this.take(key);
+	}
+
+	peek(key: H): T | false {
+		return this.h(key) ? (this.g(key) as T) : false;
+	}
+
+	getOrI(key: H, value: T): T {
+		if (this.h(key)) return this.g(key) as T;
+		this.s(key, value);
+		return value;
+	}
+
+	getOrM(key: H, make: () => T): T {
+		if (this.h(key)) return this.g(key) as T;
+		const value = make();
+		this.s(key, value);
+		return value;
+	}
+
+	getOr<G>(key: H, fallback: G): T | G {
+		return this.h(key) ? (this.g(key) as T) : fallback;
+	}
+
+	getOrThrow(key: H, error: Error = new Error("WeakMap key not found")): T {
+		if (!this.h(key)) throw error;
+		return this.g(key) as T;
+	}
+
+	getOrCreate(key: H, make: () => T): T {
+		return this.getOrM(key, make);
+	}
+
+	ensure(key: H, make: () => T): T {
+		return this.getOrM(key, make);
+	}
+
+	update(key: H, fn: (old: T, has: B) => T, initial: T): T {
+		const has = this.h(key);
+		const value = fn(has ? (this.g(key) as T) : initial, has);
+		this.s(key, value);
+		return value;
+	}
+
+	setIfAbsent(key: H, value: T): B {
+		if (this.h(key)) return false;
+		this.s(key, value);
+		return true;
+	}
+
+	setIfPresent(key: H, value: T): B {
+		if (!this.h(key)) return false;
+		this.s(key, value);
+		return true;
+	}
+
+	hasOrSet(key: H, value: T): B {
+		if (this.h(key)) return true;
+		this.s(key, value);
+		return false;
+	}
+
+	replace(key: H, value: T): B {
+		return this.setIfPresent(key, value);
+	}
+
+	touch(key: H): B {
+		return this.setIfAbsent(key, undefined as unknown as T);
+	}
+
+	get tracked(): B {
+		return this._tracked !== undefined;
+	}
+
+	get trackedSize(): N {
+		return this._tracked?.size ?? 0;
+	}
+
+	track(key: H): this {
+		(this._tracked ??= new Set()).add(key);
+		return this;
+	}
+
+	untrack(key: H): B {
+		return this._tracked?.delete(key) ?? false;
+	}
+
+	trackedKeys(): AR<H> {
+		return this._tracked ? Array.from(this._tracked) : [];
+	}
+
+	trackedValues(): AR<T> {
+		const out: T[] = [];
+		if (this._tracked) {
+			for (const key of this._tracked) {
+				if (this.h(key)) out.push(this.g(key) as T);
+			}
+		}
+		return out as AR<T>;
+	}
+
+	trackedEntries(): AR<[H, T]> {
+		const out: [H, T][] = [];
+		if (this._tracked) {
+			for (const key of this._tracked) {
+				if (this.h(key)) out.push([key, this.g(key) as T]);
+			}
+		}
+		return out as AR<[H, T]>;
+	}
+
+	forEachTracked(fn: (value: T, key: H, map: this) => void): void {
+		if (this._tracked) {
+			for (const key of this._tracked) {
+				if (this.h(key)) fn(this.g(key) as T, key, this);
+			}
+		}
+	}
+
+	clearTracked(): void {
+		if (this._tracked) {
+			for (const key of this._tracked) this.d(key);
+			this._tracked.clear();
+		}
+	}
+}
+
+globalThis.WM2 = WM2I;