@the-w1zard/dx 1.0.7 → 1.0.9

package/src/unit8array.ts

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

@@ -1,172 +0,0 @@
-export class USP2I extends URLSearchParams {
-    constructor(init) {
-        super(init);
-    }
-    get size() {
-        return Array.from(this).length;
-    }
-    getOr(name, fallback) {
-        return this.get(name) ?? fallback;
-    }
-    getOrNull(name) {
-        return this.get(name);
-    }
-    getOrThrow(name, error = new Error(`Missing URL parameter: ${name}`)) {
-        const value = this.get(name);
-        if (value === null)
-            throw error;
-        return value;
-    }
-    getNumber(name, fallback) {
-        const value = this.get(name);
-        if (value === null || value.trim() === "")
-            return fallback;
-        const number = Number(value);
-        return Number.isFinite(number) ? number : fallback;
-    }
-    getInt(name, radix = 10) {
-        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) {
-        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, fallback = false) {
-        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(name) {
-        const value = this.get(name);
-        if (value === null)
-            return undefined;
-        try {
-            return JSON.parse(value);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    getArray(name, separator = ",") {
-        const value = this.get(name);
-        return value === null || value === "" ? [] : value.split(separator);
-    }
-    getObject() {
-        const result = {};
-        for (const key of new Set(this.keys())) {
-            const values = this.getAll(key);
-            result[key] = values.length > 1 ? values : values[0];
-        }
-        return result;
-    }
-    setNumber(name, value) {
-        this.set(name, String(value));
-        return this;
-    }
-    setBoolean(name, value) {
-        this.set(name, String(value));
-        return this;
-    }
-    setJSON(name, value) {
-        this.set(name, JSON.stringify(value));
-        return this;
-    }
-    setArray(name, values, separator = ",") {
-        this.set(name, Array.from(values, String).join(separator));
-        return this;
-    }
-    setIfAbsent(name, value) {
-        if (!this.has(name))
-            this.set(name, value);
-        return this;
-    }
-    setIfPresent(name, value) {
-        if (this.has(name))
-            this.set(name, value);
-        return this;
-    }
-    appendAll(params) {
-        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, overwrite = true) {
-        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() {
-        return new USP2I(this);
-    }
-    clear() {
-        for (const key of new Set(this.keys()))
-            this.delete(key);
-    }
-    isEmpty() {
-        return this.size === 0;
-    }
-    isNotEmpty() {
-        return this.size > 0;
-    }
-    toObject() {
-        return this.getObject();
-    }
-    toJSON() {
-        return this.toObject();
-    }
-    toURLSearchParams() {
-        return new URLSearchParams(this);
-    }
-    toURL(url) {
-        const result = new URL(url);
-        this.forEach((value, key) => result.searchParams.append(key, value));
-        return result;
-    }
-}
-globalThis.USP2 = USP2I;