@the-w1zard/dx 1.0.12 → 1.0.14

package/src/dx.d.ts

@@ -4,21 +4,25 @@ import { M2BINI } from "./map_bin";
 import { B2BI } from "./boolean_byte";
 import { M2I } from "./map";
 import { M2BI } from "./map_byte";
-import { SET2I } from "./set";
-import { SET2BI } from "./set_byte";
-import { D2I, R2I, R2II } from "./date";
+
 import { A2I } from "./array";
-import { O2I } from "./object";
-import { WM2I } from "./weak_map";
+import { D2I, R2I, R2II } from "./date";
+import { ER2I } from './error'
 import { I2I } from "./iterator";
 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, soa_codeci } from './soa_codec'
 import { S2I } from "./string";
 import { U82I } from "./unit8array";
-import { WS2I } from "./weak_set";
 import { USP2I } from "./url_search_params";
-import { ER2I } from "./error";
-import {MaybePromise} from '../bag_of_tricks/maybe_promise'
+
+import { WM2I } from "./weak_map";
+import { WS2I } from "./weak_set";
+import { MaybePromisei, type MaybePromise } from './index'
 export {};
 
 
@@ -31,7 +35,7 @@ declare global {
      it.
 	================================================================================== ⇦✦──⇦✦──✦──✦──← 'pew pew' 🧙 [UX/DX] */
 	type MaybePromise<R = any> = R;
-	var MaybePromise: MaybePromise;
+	var MaybePromise: MaybePromisei;
 	var B2B: typeof B2BI; // BOOLEAN BINARY
 
 	var M2: typeof M2I; // map
@@ -43,6 +47,9 @@ declare global {
 	var SET2: typeof SET2I; // set
 	var SET2B: typeof SET2BI; // set
 
+	var RES2: typeof RECC2; // reg ex static
+	var RE2: typeof REC2; // reg ex
+	var ER2: typeof ER2I; // error
 	var D2: typeof D2I; // Date
 	var A2: typeof A2I; // Array
 	var O2: typeof O2I; // Object
@@ -52,17 +59,30 @@ declare global {
 	var S2: typeof S2I; // String
 	var N2: typeof N2I; // Number
 	var USP2: typeof USP2I; // URLSearchParams
-	var ER2: typeof ER2I; // Error
 	var U82: typeof U82I; // Uint8Array
 	var I2: typeof I2I; // Iterator
 	var R2: typeof R2I;
     var R2FN: typeof R2II;
+    var soa_codec: typeof soa_codeci;
+	interface soa_codec {
+		readonly maxPids: number;
+		readonly channelMap: Int32Array;
+		readonly subChannelMap: Int32Array;
+		readonly tripChannelMap: Int32Array;
+		readonly keyMap: Int32Array;
+		readonly listeners: Array<((pid: number, val?: number) => void) | undefined>;
+		nextPid: number;
+	  
+		allocatePid(rId: number, mId: number, sId: number, kId: number): number;
+	  }
+	interface soa_codeci extends soa_codec {}
+
 	//                                                                                                 [MAP]
 	// #region ══════════════════════════════════════════════════════════════════════════════════════════════════════ 
 	type M2Op = "set" | "del" | "upd" | "dirty";
 	interface M2Event<H = A, T = A> {
 		op: M2Op;
-		pid: H;
+		pid?: H;
 		k: H;
 		v?: T;
 		prev?: T;

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,57 @@
+import { M2RI } from "./map_rows";
+import { M2DI } from "./map_dense";
+import { M2BINI } from "./map_bin";
+import { B2BI } from "./boolean_byte";
+import { M2I } from "./map";
+import { M2BI } from "./map_byte";
+import { A2I } from './array'
+import { D2I,  R2I, R2II } from './date'
+import { ER2I } from './error'
+import { I2I } from './iterator'
+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, soa_codeci  } 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 type MaybePromise<R = any> = R;
+export function MaybePromisei<R = any>(v: R): MaybePromise {
+    return v !== undefined ? v as R : Promise.resolve(v) as Promise<R> 
+}
+
+globalThis.MaybePromise = MaybePromisei;
+
+export {
+    M2RI as M2R,
+    M2DI as M2D, 
+    M2BINI as M2BIN, 
+    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 RE2,
+    RECC2 as RES2,
+    SET2I as SET2,
+    SET2BI as SET2B,
+    SOA_CODEC ,
+    soa_codeci as soa_codec,
+    S2I as S2,
+    U82I as U82,
+    USP2I as USP2,
+    WM2I as WM2,
+    WS2I as WS2,
+    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;