@the-w1zard/dx 1.0.11 → 1.0.13

package/src/error.ts

@@ -0,0 +1,81 @@
+
+
+export class ER2I extends Error implements ER2 {
+	constructor(message = "", options?: ErrorOptions) {
+		super(message, options);
+		this.name = new.target.name;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+
+	clone(): ER2I {
+		const error = new ER2I(this.message, { cause: this.cause });
+		error.name = this.name;
+		error.stack = this.stack;
+		return error;
+	}
+
+	toJSON(): {
+		name: string;
+		message: string;
+		stack?: string;
+		cause?: unknown;
+	} {
+		return {
+			name: this.name,
+			message: this.message,
+			stack: this.stack,
+			cause: this.cause,
+		};
+	}
+
+	override toString(): string {
+		return `${this.name}: ${this.message}`;
+	}
+
+	static is(value: unknown): value is Error {
+		return value instanceof Error;
+	}
+
+	static isER2(value: unknown): value is ER2I {
+		return value instanceof ER2I;
+	}
+
+	static from(value: unknown, fallback = "An unknown error occurred"): ER2I {
+		if (value instanceof ER2I) return value;
+
+		if (value instanceof Error) {
+			const error = new ER2I(value.message, { cause: value });
+			error.name = value.name;
+			error.stack = value.stack;
+			return error;
+		}
+
+		if (typeof value === "string") {
+			return new ER2I(value);
+		}
+
+		if (value === null || value === undefined) {
+			return new ER2I(fallback);
+		}
+
+		try {
+			return new ER2I(String(value));
+		} catch {
+			return new ER2I(fallback);
+		}
+	}
+
+	static wrap(value: unknown, message?: string): ER2I {
+		const cause = ER2I.from(value);
+		return new ER2I(message ?? cause.message, { cause });
+	}
+
+	static aggregate(errors: Iterable<unknown>, message = "Multiple errors occurred"): AggregateError {
+		return new AggregateError(
+			Array.from(errors, error => ER2I.from(error)),
+			message,
+		);
+	}
+}
+
+globalThis.ER2 = ER2I 

package/src/index.ts

@@ -0,0 +1,45 @@
+import { A2I } from './array'
+import { B2BI } from './boolean_byte'
+import { D2I,  R2I, R2II } from './date'
+import { ER2I } from './error'
+import { I2I } from './iterator'
+import { M2BI } from './map_byte'
+import { M2I } from './map'
+import { N2I } from './number'
+import { O2I } from './object'
+import { P2I } from './promise'
+import { REC2, RECC2 } from './reg_ex'
+import { SET2I } from './set'
+import { SET2BI } from './set_byte'
+import { SOA_CODEC } from './soa_codec'
+import { S2I } from './string'
+import { U82I } from './unit8array'
+import { USP2I } from './url_search_params'
+import { WM2I } from './weak_map'
+import { WS2I } from './weak_set'
+
+
+export {
+    A2I as A2,
+    B2BI as B2B,
+    D2I as D2,
+    ER2I as ER2,
+    I2I as I2,
+    M2BI as M2B,
+    M2I as M2,
+    N2I as N2,
+    O2I as O2,
+    P2I as P2,
+    REC2 as REC,
+    SET2I as SET2,
+    SET2BI as SET2B,
+    SOA_CODEC ,
+    S2I as S2,
+    U82I as U82,
+    USP2I as USP2,
+    WM2I as WM2,
+    WS2I as WS2,
+    RECC2 as RECC,
+    R2I as R2,
+    R2II as R2I 
+}

package/src/iterator.ts

@@ -0,0 +1,407 @@
+
+
+export class I2I<T = A> implements I2<T> {
+	private source: Iterator<T>;
+	private index = 0;
+	private buffer: T[] = [];
+	private done = false;
+
+	constructor(source: Iterable<T> | Iterator<T>) {
+		this.source = Symbol.iterator in Object(source)
+			? (source as Iterable<T>)[Symbol.iterator]()
+			: source as Iterator<T>;
+	}
+
+	n = this.next;
+	r = this.return;
+	f = this.throw;
+
+	next(): IteratorResult<T> {
+		if (this.buffer.length) {
+			this.index++;
+			return { done: false, value: this.buffer.shift() as T };
+		}
+
+		if (this.done) return { done: true, value: undefined };
+
+		const result = this.source.next();
+		if (result.done) this.done = true;
+		else this.index++;
+		return result;
+	}
+
+	return(value?: A): IteratorResult<T> {
+		this.done = true;
+		this.buffer.length = 0;
+		return this.source.return
+			? this.source.return(value)
+			: { done: true, value: value as T };
+	}
+
+	throw(error?: A): IteratorResult<T> {
+		this.done = true;
+		this.buffer.length = 0;
+		if (this.source.throw) return this.source.throw(error);
+		throw error;
+	}
+
+	[Symbol.iterator](): this {
+		return this;
+	}
+
+	toArray(): AR<T> {
+		return Array.from(this);
+	}
+
+	first(): T | UD {
+		return this.next().value;
+	}
+
+	last(): T | UD {
+		let result: T | UD;
+		for (const value of this) result = value;
+		return result!;
+	}
+
+	at(index: N): T | UD {
+		if (index < 0) {
+			const values = this.toArray();
+			return values[values.length + index];
+		}
+
+		let i = 0;
+		for (const value of this) {
+			if (i++ === index) return value;
+		}
+		return undefined;
+	}
+
+	peek(): T | UD {
+		if (!this.buffer.length && !this.done) {
+			const result = this.source.next();
+			if (result.done) this.done = true;
+			else this.buffer.push(result.value);
+		}
+		return this.buffer[0];
+	}
+
+	nextValue(): T | UD {
+		return this.next().value;
+	}
+
+	nextOr(value: T): T {
+		const result = this.next();
+		return result.done ? value : result.value;
+	}
+
+	nextOrM(make: () => T): T {
+		const result = this.next();
+		return result.done ? make() : result.value;
+	}
+
+	nextOrThrow(error: Error = new Error("Iterator exhausted")): T {
+		const result = this.next();
+		if (result.done) throw error;
+		return result.value;
+	}
+
+	map<G>(fn: (value: T, index: N) => G): I2I<G> {
+		const source = this;
+		let index = 0;
+		return new I2I<G>({
+			next() {
+				const result = source.next();
+				return result.done ? result : { done: false, value: fn(result.value, index++) };
+			},
+			return: (value?: A): IteratorResult<G> => {
+				source.return?.();
+				return { done: true, value: value as G };
+			},
+		});
+	}
+
+	filter<S extends T>(pred: (value: T, index: N) => value is S): I2I<S>;
+	filter(pred: (value: T, index: N) => B): I2I<T>;
+	filter(pred: (value: T, index: N) => B): I2I<T> {
+		const source = this;
+		let index = 0;
+		return new I2I<T>({
+			next() {
+				let result: IteratorResult<T>;
+				while (!(result = source.next()).done) {
+					if (pred(result.value, index++)) return result;
+				}
+				return result;
+			},
+			return: (value?: A) => source.return(value),
+		});
+	}
+
+	flatMap<G>(fn: (value: T, index: N) => Iterable<G> | Iterator<G>): I2I<G> {
+		const source = this;
+		let index = 0;
+		let inner: Iterator<G> | undefined;
+
+		return new I2I<G>({
+			next() {
+				while (true) {
+					if (inner) {
+						const result = inner.next();
+						if (!result.done) return result;
+						inner = undefined;
+					}
+
+					const outer = source.next();
+					if (outer.done) return { done: true, value: undefined };
+
+					const mapped = fn(outer.value, index++);
+					inner = Symbol.iterator in Object(mapped)
+						? (mapped as Iterable<G>)[Symbol.iterator]()
+						: mapped as Iterator<G>;
+				}
+			},
+			return: (value?: A): IteratorResult<G> => {
+				source.return?.();
+				return { done: true, value: value as G };
+			},
+		});
+	}
+
+	flat<G>(this: I2I<Iterable<G> | Iterator<G>>): I2I<G> {
+		return this.flatMap(value => value);
+	}
+
+	take(limit: N): I2I<T> {
+		const source = this;
+		let count = 0;
+		return new I2I<T>({
+			next() {
+				if (count >= limit) return { done: true, value: undefined };
+				const result = source.next();
+				if (!result.done) count++;
+				return result;
+			},
+			return: (value?: A) => source.return(value),
+		});
+	}
+
+	drop(limit: N): I2I<T> {
+		const source = this;
+		let dropped = false;
+		return new I2I<T>({
+			next() {
+				if (!dropped) {
+					for (let i = 0; i < limit; i++) {
+						if (source.next().done) return { done: true, value: undefined };
+					}
+					dropped = true;
+				}
+				return source.next();
+			},
+			return: (value?: A) => source.return(value),
+		});
+	}
+
+	unique<G = T>(fn?: (value: T, index: N) => G): I2I<T> {
+		const source = this;
+		const seen = new Set<G>();
+		let index = 0;
+		return new I2I<T>({
+			next() {
+				let result: IteratorResult<T>;
+				while (!(result = source.next()).done) {
+					const key = fn ? fn(result.value, index++) : result.value as unknown as G;
+					if (!seen.has(key)) {
+						seen.add(key);
+						return result;
+					}
+				}
+				return result;
+			},
+			return: (value?: A) => source.return(value),
+		});
+	}
+
+	chunk<G>(size: N): I2I<AR<T>> {
+		if (!Number.isInteger(size) || size < 1) throw new RangeError("Chunk size must be a positive integer");
+		const source = this;
+		return new I2I<AR<T>>({
+			next() {
+				const chunk: T[] = [];
+				while (chunk.length < size) {
+					const result = source.next();
+					if (result.done) break;
+					chunk.push(result.value);
+				}
+				return chunk.length ? { done: false, value: chunk as AR<T> } : { done: true, value: undefined };
+			},
+			return: (value?: A): IteratorResult<AR<T>> => {
+				source.return?.();
+				return { done: true, value: value as AR<T> };
+			},
+		});
+	}
+
+	zip<G>(other: Iterable<G> | Iterator<G>): I2I<[T, G]> {
+		const left = this;
+		const right = new I2I(other);
+		return new I2I<[T, G]>({
+			next() {
+				const a = left.next();
+				const b = right.next();
+				if (a.done || b.done) {
+					left.return();
+					right.return();
+					return { done: true, value: undefined };
+				}
+				return { done: false, value: [a.value, b.value] };
+			},
+			return: (value?: A) => {
+				left.return();
+				right.return();
+				return { done: true, value: value as [T, G] };
+			},
+		});
+	}
+
+	concat(...others: (Iterable<T> | Iterator<T>)[]): I2I<T> {
+		const source = this;
+		let current: Iterator<T> = source;
+		let index = 0;
+		return new I2I<T>({
+			next() {
+				while (true) {
+					const result = current.next();
+					if (!result.done) return result;
+					if (index >= others.length) return { done: true, value: undefined };
+					const other = others[index++];
+					current = Symbol.iterator in Object(other)
+						? (other as Iterable<T>)[Symbol.iterator]()
+						: other as Iterator<T>;
+				}
+			},
+			return: (value?: A) => {
+				current.return?.(value);
+				return { done: true, value: value as T };
+			},
+		});
+	}
+
+	enumerate<G>(): I2I<[N, T]> {
+		const source = this;
+		let index = 0;
+		return new I2I<[N, T]>({
+			next() {
+				const result = source.next();
+				return result.done ? result : { done: false, value: [index++, result.value] };
+			},
+			return: (value?: A): IteratorResult<[N, T]> => {
+				source.return?.();
+				return { done: true, value: value as [N, T] };
+			},
+		});
+	}
+
+	find(pred: (value: T, index: N) => B): T | UD {
+		let index = 0;
+		for (const value of this) if (pred(value, index++)) return value;
+		return undefined;
+	}
+
+	findIndex(pred: (value: T, index: N) => B): N {
+		let index = 0;
+		for (const value of this) {
+			if (pred(value, index)) return index;
+			index++;
+		}
+		return -1 as N;
+	}
+
+	some(pred: (value: T, index: N) => B): B {
+		let index = 0;
+		for (const value of this) if (pred(value, index++)) return true;
+		return false;
+	}
+
+	every(pred: (value: T, index: N) => B): B {
+		let index = 0;
+		for (const value of this) if (!pred(value, index++)) return false;
+		return true;
+	}
+
+	reduce<G>(fn: (acc: G, value: T, index: N) => G, initial: G): G {
+		let acc = initial;
+		let index = 0;
+		for (const value of this) acc = fn(acc, value, index++);
+		return acc;
+	}
+
+	forEach(fn: (value: T, index: N) => void): void {
+		let index = 0;
+		for (const value of this) fn(value, index++);
+	}
+
+	count(): N {
+		let count = 0;
+		for (const _ of this) count++;
+		return count as N;
+	}
+
+	sum(fn?: (value: T) => N): N {
+		let sum = 0;
+		for (const value of this) sum += fn ? fn(value) : value as N;
+		return sum as N;
+	}
+
+	join(separator: S = ","): S {
+		return this.toArray().join(separator) as S;
+	}
+
+	partition(pred: (value: T, index: N) => B): [AR<T>, AR<T>] {
+		const yes: T[] = [];
+		const no: T[] = [];
+		let index = 0;
+		for (const value of this) (pred(value, index++) ? yes : no).push(value);
+		return [yes as AR<T>, no as AR<T>];
+	}
+
+	group<G>(fn: (value: T, index: N) => G): Map<G, AR<T>> {
+		const out = new Map<G, T[]>();
+		let index = 0;
+		for (const value of this) {
+			const key = fn(value, index++);
+			let group = out.get(key);
+			if (!group) out.set(key, group = []);
+			group.push(value);
+		}
+		return out as Map<G, AR<T>>;
+	}
+
+	toSet(): Set<T> {
+		return new Set(this);
+	}
+
+	toMap<K, V = T>(keyFn: (value: T, index: N) => K, valueFn?: (value: T, index: N) => V): Map<K, V> {
+		const out = new Map<K, V>();
+		let index = 0;
+		for (const value of this) {
+			out.set(keyFn(value, index), valueFn ? valueFn(value, index) : value as unknown as V);
+			index++;
+		}
+		return out;
+	}
+
+	isEmpty(): B {
+		return this.peek() === undefined;
+	}
+
+	exhaust(): void {
+		for (const _ of this) {}
+	}
+
+	clone(): I2I<T> {
+		return new I2I(this.toArray());
+	}
+}
+
+globalThis.I2 = I2I;