@e280/stz 0.0.0-0

package/s/deep/parts/equal.test.ts

@@ -0,0 +1,124 @@
+//
+// import {Suite, expect} from "cynic"
+// import {deepEqual} from "./equal.js"
+//
+// export default <Suite>{
+//
+// 	async "compare primitive types"() {
+// 		expect(deepEqual(123, 123)).equals(true)
+// 		expect(deepEqual("abc", "abc")).equals(true)
+// 		expect(deepEqual(true, true)).equals(true)
+// 		expect(deepEqual(123, "123")).equals(false)
+// 		expect(deepEqual(true, 1)).equals(false)
+// 	},
+//
+// 	async "compare arrays"() {
+// 		const array1 = [1, 2, 3]
+// 		const array2 = [1, 2, 3]
+// 		const array3 = [1, 2, 4]
+// 		expect(deepEqual(array1, array2)).equals(true)
+// 		expect(deepEqual(array1, array3)).equals(false)
+// 	},
+//
+// 	async "compare plain objects"() {
+// 		const obj1 = { foo: "bar", baz: 123 }
+// 		const obj2 = { foo: "bar", baz: 123 }
+// 		const obj3 = { foo: "bar", baz: 124 }
+// 		expect(deepEqual(obj1, obj2)).equals(true)
+// 		expect(deepEqual(obj1, obj3)).equals(false)
+// 	},
+//
+// 	async "compare nested objects"() {
+// 		const obj1 = { foo: "bar", inner: { baz: 123, deeper: { qux: true }}}
+// 		const obj2 = { foo: "bar", inner: { baz: 123, deeper: { qux: true }}}
+// 		const obj3 = { foo: "bar", inner: { baz: 124, deeper: { qux: true }}}
+// 		expect(deepEqual(obj1, obj2)).equals(true)
+// 		expect(deepEqual(obj1, obj3)).equals(false)
+// 	},
+//
+// 	async "compare array of objects"() {
+// 		const arr1 = [{ foo: "bar" }, { baz: 123 }, { qux: true }]
+// 		const arr2 = [{ foo: "bar" }, { baz: 123 }, { qux: true }]
+// 		const arr3 = [{ foo: "bar" }, { baz: 123 }, { qux: false }]
+// 		expect(deepEqual(arr1, arr2)).equals(true)
+// 		expect(deepEqual(arr1, arr3)).equals(false)
+// 	},
+//
+// 	async "compare null and undefined"() {
+// 		expect(deepEqual(null, null)).equals(true)
+// 		expect(deepEqual(undefined, undefined)).equals(true)
+// 		expect(deepEqual(null, undefined)).equals(false)
+// 	},
+//
+// 	async "compare with nested arrays"() {
+// 		const obj1 = { foo: "bar", array: [1, 2, [3, 4]] }
+// 		const obj2 = { foo: "bar", array: [1, 2, [3, 4]] }
+// 		const obj3 = { foo: "bar", array: [1, 2, [3, 5]] }
+// 		expect(deepEqual(obj1, obj2)).equals(true)
+// 		expect(deepEqual(obj1, obj3)).equals(false)
+// 	},
+//
+// 	async "circularity is forbidden"() {
+// 		const obj1 = {alpha: 1} as any
+// 		const obj2 = {alpha: 1} as any
+// 		obj1.bravo = obj1
+// 		obj2.bravo = obj2
+// 		expect(() => deepEqual(obj1, obj2)).throws()
+// 	},
+//
+// 	async "duplicate references are allowed"() {
+// 		const dupe = {a: 123}
+// 		const obj1 = {alpha: 1, dupe}
+// 		const obj2 = {alpha: 1, dupe}
+// 		const obj3 = {alpha: 1, dupe: {a: 0}}
+// 		expect(deepEqual(obj1, obj2)).equals(true)
+// 		expect(deepEqual(obj1, obj3)).equals(false)
+// 	},
+//
+// 	"maps and sets": {
+// 		async "compare maps"() {
+// 			const map1 = new Map([['key1', 'value1'], ['key2', 'value2']])
+// 			const map2 = new Map([['key1', 'value1'], ['key2', 'value2']])
+// 			const map3 = new Map([['key1', 'value1'], ['key2', 'value3']])
+// 			expect(deepEqual(map1, map2)).equals(true)
+// 			expect(deepEqual(map1, map3)).equals(false)
+// 		},
+//
+// 		async "compare sets"() {
+// 			const set1 = new Set([1, 2, 3])
+// 			const set2 = new Set([1, 2, 3])
+// 			const set3 = new Set([1, 2, 4])
+// 			expect(deepEqual(set1, set2)).equals(true)
+// 			expect(deepEqual(set1, set3)).equals(false)
+// 		},
+//
+// 		async "compare nested maps and sets"() {
+// 			const obj1 = { map: new Map([['key', new Set([1, 2, 3])]]) }
+// 			const obj2 = { map: new Map([['key', new Set([1, 2, 3])]]) }
+// 			const obj3 = { map: new Map([['key', new Set([1, 2, 4])]]) }
+// 			expect(deepEqual(obj1, obj2)).equals(true)
+// 			expect(deepEqual(obj1, obj3)).equals(false)
+// 		},
+//
+// 		async "compare complex structures"() {
+// 			const map1 = new Map([['set', new Set([{ a: 1 }, { b: 2 }])]])
+// 			const map2 = new Map([['set', new Set([{ a: 1 }, { b: 2 }])]])
+// 			const map3 = new Map([['set', new Set([{ a: 1 }, { b: 3 }])]])
+// 			expect(deepEqual(map1, map2)).equals(true)
+// 			expect(deepEqual(map1, map3)).equals(false)
+// 		},
+//
+// 		async "compare edge cases"() {
+// 			const emptyMap1 = new Map()
+// 			const emptyMap2 = new Map()
+// 			const emptySet1 = new Set()
+// 			const emptySet2 = new Set()
+// 			const mixedMap1 = new Map([['b', 2], ['a', 1]])
+// 			const mixedMap2 = new Map([['a', 1], ['b', 2]])
+// 			expect(deepEqual(emptyMap1, emptyMap2)).equals(true)
+// 			expect(deepEqual(emptySet1, emptySet2)).equals(true)
+// 			expect(deepEqual(mixedMap1, mixedMap2)).equals(true)
+// 		},
+// 	},
+// }
+//

package/s/deep/parts/equal.ts

@@ -0,0 +1,49 @@
+
+import {is} from "../../is.js"
+
+export const deepEqual = (alpha: any, bravo: any): boolean => {
+
+	function recurse(alpha: any, bravo: any, parents: object[]) {
+		if (!is.object(alpha) || !is.object(bravo))
+			return alpha === bravo
+
+		if (parents.includes(alpha))
+			throw new Error(`forbidden circularity detected in deep equal comparison`)
+
+		const newParents = [...parents, alpha]
+
+		if (alpha instanceof Map && bravo instanceof Map) {
+			if (alpha.size !== bravo.size)
+				return false
+			for (const [key, val] of alpha)
+				if (!bravo.has(key) || !recurse(val, bravo.get(key), newParents))
+					return false
+		}
+		else if (alpha instanceof Set && bravo instanceof Set) {
+			if (alpha.size !== bravo.size)
+				return false
+			for (const item of alpha)
+				if (!Array.from(bravo).some(bItem => recurse(item, bItem, newParents)))
+					return false
+		}
+		else {
+			const keys1 = Object.keys(alpha)
+			const keys2 = Object.keys(bravo)
+
+			if (keys1.length !== keys2.length)
+				return false
+
+			for (const key of keys1) {
+				if (!keys2.includes(key))
+					return false
+				if (!recurse(alpha[key], bravo[key], newParents))
+					return false
+			}
+		}
+
+		return true
+	}
+
+	return recurse(alpha, bravo, [])
+}
+

package/s/deep/parts/freeze.ts

@@ -0,0 +1,34 @@
+
+import {is} from "../../is.js"
+
+export function deepFreeze<X>(item: X): X {
+
+	function recurse(x: X, parents: object[]) {
+		if (!is.object(x) || parents.includes(x))
+			return x
+
+		const newParents = [...parents, x]
+
+		if (x instanceof Map)
+			for (const arr of x.entries())
+				for (const y of arr)
+					recurse(y, newParents)
+
+		else if (x instanceof Set)
+			for (const y of x)
+				recurse(y, newParents)
+
+		else if (Array.isArray(x))
+			for (const y of x)
+				recurse(y, newParents)
+
+		else
+			for (const y of Object.values(x))
+				recurse(y, newParents)
+
+		return Object.freeze(x)
+	}
+
+	return recurse(item, [])
+}
+

package/s/defer-promise.ts

@@ -0,0 +1,29 @@
+
+/** a promise which can be resolved from the outside */
+export type DeferredPromise<R> = {
+	promise: Promise<R>
+	resolve: (result: R) => void
+	reject: (reason: any) => void
+
+	/** ties the fate of this deferred promise to the outcome of the provided outsidePromise */
+	entangle: (outsidePromise: Promise<R>) => Promise<R>
+}
+
+/** returns a deferred promise with exposed resolve and reject fns */
+export function deferPromise<R>(): DeferredPromise<R> {
+	let resolve!: (result: R) => void
+	let reject!: (reason: any) => void
+
+	const promise = new Promise<R>((res, rej) => {
+		resolve = res
+		reject = rej
+	})
+
+	function entangle(outside: Promise<R>) {
+		outside.then(resolve).catch(reject)
+		return promise
+	}
+
+	return {promise, resolve, reject, entangle}
+}
+

package/s/escape-regex.ts

@@ -0,0 +1,5 @@
+
+export function escapeRegex(subject: string) {
+	return subject.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+

package/s/hat.ts

@@ -0,0 +1,17 @@
+
+export class Hat<T> {
+	#content: T[] = []
+
+	constructor(public items: T[]) {
+		this.#content = [...items]
+	}
+
+	pull() {
+		if (this.#content.length === 0)
+			this.#content = [...this.items]
+		const index = Math.floor(Math.random() * this.#content.length)
+		const [item] = this.#content.splice(index, 1)
+		return item
+	}
+}
+

package/s/index.ts

@@ -0,0 +1,23 @@
+
+export * from "./data/barname/index.js"
+export * from "./data/base58.js"
+export * from "./data/base64.js"
+export * from "./data/base64url.js"
+export * from "./data/bytes.js"
+export * from "./data/hex.js"
+export * from "./data/txt.js"
+
+export * from "./concurrent.js"
+export * from "./deadline.js"
+export * from "./dedupe.js"
+export * from "./defer-promise.js"
+export * from "./escape-regex.js"
+export * from "./hat.js"
+export * from "./is.js"
+export * from "./map-g.js"
+export * from "./nap.js"
+export * from "./ob.js"
+export * from "./pipe.js"
+export * from "./pubsub.js"
+export * from "./trash.js"
+

package/s/is.ts

@@ -0,0 +1,27 @@
+
+export const is = {
+	available: <X>(x: X): x is NonNullable<X> =>
+		x !== undefined && x !== null,
+
+	unavailable: (x: any): x is (undefined | null) =>
+		x === undefined || x === null,
+
+	boolean: (x: any): x is boolean =>
+		typeof x === "boolean",
+
+	number: (x: any): x is number =>
+		typeof x === "number",
+
+	string: (x: any): x is string =>
+		typeof x === "string",
+
+	bigint: (x: any): x is bigint =>
+		typeof x === "bigint",
+
+	object: <X>(x: X): x is object & NonNullable<X> =>
+		typeof x === "object" && x !== null,
+
+	array: (x: any | any[]): x is any[] =>
+		Array.isArray(x),
+}
+

package/s/map-g.ts

@@ -0,0 +1,52 @@
+
+/** js map, but with handy methods like `require` and `guarantee` */
+export class MapG<K, V> extends Map<K, V> {
+	static require<K, V>(map: Map<K, V>, key: K) {
+		const value = map.get(key)
+		if (value === undefined)
+			throw new Error(`required key not found: "${key}"`)
+		return value
+	}
+
+	static guarantee<K, V>(map: Map<K, V>, key: K, make: () => V) {
+		let value = map.get(key)
+
+		if (value === undefined) {
+			value = make()
+			map.set(key, value)
+		}
+
+		return value
+	}
+
+	array() {
+		return [...this]
+	}
+
+	require(key: K) {
+		return MapG.require(this, key)
+	}
+
+	guarantee(key: K, make: () => V) {
+		return MapG.guarantee(this, key, make)
+	}
+}
+
+export type Identifiable<Id = any> = {id: Id}
+
+/** js map but for things that have an `id` field */
+export class PoolG<V extends Identifiable> extends MapG<V["id"], V> {
+	got(value: V) {
+		return this.has(value.id)
+	}
+
+	add(value: V) {
+		this.set(value.id, value)
+		return value
+	}
+
+	remove(value: V) {
+		return this.delete(value.id)
+	}
+}
+

package/s/nap.ts

@@ -0,0 +1,5 @@
+
+export const nap = (milliseconds: number = 0) => (
+	new Promise<void>(resolve => setTimeout(resolve, milliseconds))
+)
+

package/s/ob.ts

@@ -0,0 +1,66 @@
+
+export function ob<Ob extends object>(o: Ob) {
+	return {
+		map: <Value>(transform: ObTransform<Ob, Value>) => (
+			obMap(o, transform)
+		),
+		filter: (predicate: ObPredicate<Ob>) => (
+			obFilter(o, predicate)
+		),
+	}
+}
+
+////////////
+////////////
+
+ob.pipe = Object.freeze({
+	map: <O extends {}, Value>(
+			transform: (value: O[keyof O], key: keyof O) => Value,
+		) => (
+		(o: O) => obMap(o, transform)
+	),
+	filter: <O extends {}>(
+			transform: (value: O[keyof O], key: keyof O) => boolean,
+		) => (
+		(o: O) => obFilter(o, transform) as {[key: string]: O[keyof O]}
+	),
+})
+
+////////////
+////////////
+
+export type ObTransform<Ob extends object, Value> = (
+	(value: Ob[keyof Ob], key: keyof Ob) => Value
+)
+
+export type ObPredicate<Ob extends object> = (
+	(value: Ob[keyof Ob], key: keyof Ob) => boolean
+)
+
+////////////
+////////////
+
+const obMap = <Ob extends object, Value>(
+		o: Ob,
+		transform: ObTransform<Ob, Value>,
+	) => {
+
+	return Object.fromEntries(
+		Object.entries(o).map(
+			([key, value]: any) => [key, transform(value, key)]
+		)
+	) as {[P in keyof Ob]: Value}
+}
+
+const obFilter = <Ob extends object>(
+		o: Ob,
+		predicate: ObPredicate<Ob>,
+	) => {
+
+	return Object.fromEntries(
+		Object.entries(o).filter(
+			([key, value]: any) => predicate(value, key)
+		)
+	) as {[P in keyof Ob]?: Ob[keyof Ob]}
+}
+

package/s/pipe.ts

@@ -0,0 +1,24 @@
+
+export type PipeFun<I, O> = (input: I) => O
+
+export class Pipe<I> {
+
+	static with<I>(input: I) {
+		return new this(input)
+	}
+
+	#input: I
+
+	constructor(input: I) {
+		this.#input = input
+	}
+
+	to<O>(fun: PipeFun<I, O>) {
+		return new Pipe(fun(this.#input))
+	}
+
+	done() {
+		return this.#input
+	}
+}
+

package/s/pubsub.ts

@@ -0,0 +1,68 @@
+
+import {deferPromise} from "./defer-promise.js"
+
+export type Listener<A extends any[]> = (...a: A) => (void | Promise<void>)
+
+export interface Xub<A extends any[] = []> {
+	pub(...a: A): Promise<void>
+	sub(fn: Listener<A>): () => void
+	once(): Promise<A>
+	clear(): void
+}
+
+export interface Sub<A extends any[] = []> extends Xub<A> {
+	(fn: Listener<A>): () => void
+}
+
+export interface Pub<A extends any[] = []> {
+	(...a: A): Promise<void>
+}
+
+export function xub<A extends any[] = []>() {
+	const set = new Set<Listener<A>>()
+
+	function sub(fn: Listener<A>) {
+		set.add(fn)
+		return () => { set.delete(fn) }
+	}
+
+	async function pub(...a: A) {
+		await Promise.all([...set].map(fn => fn(...a)))
+	}
+
+	async function once() {
+		const {promise, resolve} = deferPromise<A>()
+		const unsubscribe = sub((...a) => {
+			resolve(a)
+			unsubscribe()
+		})
+		return promise
+	}
+
+	function clear() {
+		set.clear()
+	}
+
+	sub.pub = pub
+	sub.sub = sub
+	sub.once = once
+	sub.clear = clear
+
+	pub.pub = pub
+	pub.sub = sub
+	pub.once = once
+	pub.clear = clear
+
+	return [pub, sub] as [Pub<A>, Sub<A>]
+}
+
+/** create a subscriber fn that can be published to */
+export function sub<A extends any[] = []>(): Sub<A> {
+	return xub<A>()[1]
+}
+
+/** create a publisher fn that can be subscribed to */
+export function pub<A extends any[] = []>(): Pub<A> {
+	return xub<A>()[0]
+}
+

package/s/trash.ts

@@ -0,0 +1,30 @@
+
+/** a trashcan where you can collect disposer fns, and dispose them all at once */
+export class Trash {
+	#fns: (() => void)[] = []
+
+	/** add a disposer fn to the trashcan */
+	add(...fns: (() => void)[]) {
+		this.#fns.push(...fns)
+		return this
+	}
+
+	/** add a disposable object to the trashcan, and return the object */
+	disposable<X extends {dispose: () => void}>(x: X) {
+		return this.bag(x, () => x.dispose())
+	}
+
+	/** add an item's disposer fn, and return the item */
+	bag<X>(x: X, fn: (x: X) => void) {
+		this.add(() => fn(x))
+		return x
+	}
+
+	/** dispose of everything in the trashcan */
+	dispose() {
+		for (const fn of this.#fns.reverse())
+			fn()
+		this.#fns = []
+	}
+}
+

package/x/clone/clone.d.ts

@@ -0,0 +1 @@
+export declare function clone<T>(data: T, refs?: Set<any>): T;

package/x/clone/clone.js

@@ -0,0 +1,26 @@
+export function clone(data, refs = new Set()) {
+    if (refs.has(data))
+        throw new Error("cannot clone circular reference");
+    let copy = undefined;
+    if (typeof data === "function" || (data !== null && typeof data === "object")) {
+        refs.add(data);
+        if (Array.isArray(data))
+            copy = data.map(d => clone(d, new Set(refs)));
+        else if (data.constructor === Object)
+            copy = Object.fromEntries(Object.entries(data)
+                .map(([key, d]) => [key, clone(d, new Set(refs))]));
+        else if (data instanceof Map)
+            copy = new Map(Array.from(data, ([key, val]) => [key, clone(val, new Set(refs))]));
+        else if (data instanceof Set)
+            copy = new Set(Array.from(data, val => clone(val, new Set(refs))));
+        else if (data instanceof Date)
+            copy = new Date(data.getTime());
+        else
+            copy = data;
+        refs.delete(data); // Remove current data from refs once we're done with this branch of the object tree
+    }
+    else
+        copy = data;
+    return copy;
+}
+//# sourceMappingURL=clone.js.map

package/x/clone/clone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone.js","sourceRoot":"","sources":["../../s/clone/clone.ts"],"names":[],"mappings":"AACA,MAAM,UAAU,KAAK,CAAI,IAAO,EAAE,OAAO,IAAI,GAAG,EAAO;IAEtD,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;QACjB,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAA;IAEnD,IAAI,IAAI,GAAG,SAAc,CAAA;IAEzB,IAAI,OAAO,IAAI,KAAK,UAAU,IAAI,CAAC,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,CAAC,EAAE,CAAC;QAC/E,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAEd,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;YACtB,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,CAAM,CAAA;aAE9C,IAAI,IAAI,CAAC,WAAW,KAAK,MAAM;YACnC,IAAI,GAAG,MAAM,CAAC,WAAW,CACxB,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC;iBAClB,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAC9C,CAAA;aAEF,IAAI,IAAI,YAAY,GAAG;YAC3B,IAAI,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAM,CAAA;aAEnF,IAAI,IAAI,YAAY,GAAG;YAC3B,IAAI,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAM,CAAA;aAEnE,IAAI,IAAI,YAAY,IAAI;YAC5B,IAAI,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAM,CAAA;;YAGpC,IAAI,GAAG,IAAI,CAAA;QAEZ,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA,CAAC,oFAAoF;IACvG,CAAC;;QAGA,IAAI,GAAG,IAAI,CAAA;IAEZ,OAAO,IAAI,CAAA;AACZ,CAAC"}

package/x/clone/clone.test.d.ts

@@ -0,0 +1 @@
+export {};