@e280/stz 0.0.0-2 → 0.0.0-20

package/s/deadline.ts

@@ -1,17 +1,20 @@
 
 export class DeadlineError extends Error {
 	name = this.constructor.name
-	constructor(milliseconds: number) {
-		super(`deadline exceeded (${milliseconds.toLocaleString()} ms)`)
+	constructor(public milliseconds: number, message: string) {
+		super(`${message}, timed out in ${(milliseconds / 1000).toFixed(1)} seconds`)
 	}
 }
 
 /** set a deadline for a fn to do something, will reject with a `DeadlineError` if it takes too long */
-export function deadline<R>(milliseconds: number, fn: () => Promise<R>) {
+export function deadline<R>(milliseconds: number, message: string, fn: () => Promise<R>) {
+	if (milliseconds <= 0 || milliseconds === Infinity)
+		return fn()
+
 	return new Promise<R>((resolve, reject) => {
 
 		const id = setTimeout(
-			() => reject(new DeadlineError(milliseconds)),
+			() => reject(new DeadlineError(milliseconds, message)),
 			milliseconds,
 		)
 

package/s/debounce/debounce.test.ts

@@ -1,73 +1,73 @@
-//
-// import {nap} from "../nap.js"
-// import {Suite, expect} from "cynic"
-// import {debounce as debounce} from "./debounce.js"
-//
-// export default <Suite>{
-// 	async "reduces many calls into one"() {
-// 		let count = 0
-// 		const increment = debounce(100, () => {
-// 			count += 1
-// 		})
-// 		increment()
-// 		increment()
-// 		increment()
-// 		await nap(200)
-// 		expect(count).equals(1)
-// 	},
-// 	async "timer gets reset on each call"() {
-// 		let count = 0
-// 		const increment = debounce(100, () => {
-// 			count += 1
-// 		})
-// 		increment()
-// 		await nap(50)
-// 		increment()
-// 		await nap(50)
-// 		increment()
-// 		await nap(50)
-// 		increment()
-// 		await nap(50)
-// 		increment()
-// 		expect(count).equals(0)
-// 		await nap(101)
-// 		expect(count).equals(1)
-// 	},
-// 	async "provides a promise that resolves when done"() {
-// 		let count = 0
-// 		const increment = debounce(100, () => {
-// 			count += 1
-// 		})
-// 		let done = false
-// 		increment()
-// 			.then(() => done = true)
-// 		await nap(50)
-// 		increment()
-// 		await nap(50)
-// 		increment()
-// 		await nap(50)
-// 		increment()
-// 		await nap(50)
-// 		increment()
-// 		expect(done).equals(false)
-// 		await nap(201)
-// 		expect(done).equals(true)
-// 	},
-// 	async "can wait multiple rounds"() {
-// 		let count = 0
-// 		const increment = debounce(100, () => {
-// 			count += 1
-// 		})
-// 		await increment()
-// 		expect(count).equals(1)
-// 		await increment()
-// 		expect(count).equals(2)
-// 	},
-// 	async "errors are passed into promise chain"() {
-// 		const err = debounce(1, () => {
-// 			throw new Error()
-// 		})
-// 		await expect(async() => err()).throws()
-// 	},
-// }
-//
+
+import {nap} from "../nap.js"
+import {Science, expect} from "@e280/science"
+import {debounce as debounce} from "./debounce.js"
+
+export default Science.suite({
+	async "reduces many calls into one"() {
+		let count = 0
+		const increment = debounce(100, () => {
+			count += 1
+		})
+		increment()
+		increment()
+		increment()
+		await nap(200)
+		expect(count).is(1)
+	},
+	async "timer gets reset on each call"() {
+		let count = 0
+		const increment = debounce(100, () => {
+			count += 1
+		})
+		increment()
+		await nap(50)
+		increment()
+		await nap(50)
+		increment()
+		await nap(50)
+		increment()
+		await nap(50)
+		increment()
+		expect(count).is(0)
+		await nap(101)
+		expect(count).is(1)
+	},
+	async "provides a promise that resolves when done"() {
+		let count = 0
+		const increment = debounce(100, () => {
+			count += 1
+		})
+		let done = false
+		increment()
+			.then(() => done = true)
+		await nap(50)
+		increment()
+		await nap(50)
+		increment()
+		await nap(50)
+		increment()
+		await nap(50)
+		increment()
+		expect(done).is(false)
+		await nap(201)
+		expect(done).is(true)
+	},
+	async "can wait multiple rounds"() {
+		let count = 0
+		const increment = debounce(100, () => {
+			count += 1
+		})
+		await increment()
+		expect(count).is(1)
+		await increment()
+		expect(count).is(2)
+	},
+	async "errors are passed into promise chain"() {
+		const err = debounce(1, () => {
+			throw new Error()
+		})
+		await expect(async() => err()).throwsAsync()
+	},
+})
+

package/s/deep/deep.test.ts

@@ -1,8 +1,8 @@
-//
-// import {Suite} from "cynic"
-// import deepEqual from "./parts/equal.test.js"
-//
-// export default <Suite>{
-// 	deepEqual,
-// }
-//
+
+import {Science} from "@e280/science"
+import deepEqual from "./parts/equal.test.js"
+
+export default Science.suite({
+	deepEqual,
+})
+

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

@@ -1,124 +1,123 @@
-//
-// 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)
-// 		},
-// 	},
-// }
-//
+
+import {deepEqual} from "./equal.js"
+import {Science, expect} from "@e280/science"
+
+export default Science.suite({
+	async "compare primitive types"() {
+		expect(deepEqual(123, 123)).is(true)
+		expect(deepEqual("abc", "abc")).is(true)
+		expect(deepEqual(true, true)).is(true)
+		expect(deepEqual(123, "123")).is(false)
+		expect(deepEqual(true, 1)).is(false)
+	},
+
+	async "compare arrays"() {
+		const array1 = [1, 2, 3]
+		const array2 = [1, 2, 3]
+		const array3 = [1, 2, 4]
+		expect(deepEqual(array1, array2)).is(true)
+		expect(deepEqual(array1, array3)).is(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)).is(true)
+		expect(deepEqual(obj1, obj3)).is(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)).is(true)
+		expect(deepEqual(obj1, obj3)).is(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)).is(true)
+		expect(deepEqual(arr1, arr3)).is(false)
+	},
+
+	async "compare null and undefined"() {
+		expect(deepEqual(null, null)).is(true)
+		expect(deepEqual(undefined, undefined)).is(true)
+		expect(deepEqual(null, undefined)).is(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)).is(true)
+		expect(deepEqual(obj1, obj3)).is(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)).is(true)
+		expect(deepEqual(obj1, obj3)).is(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)).is(true)
+			expect(deepEqual(map1, map3)).is(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)).is(true)
+			expect(deepEqual(set1, set3)).is(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)).is(true)
+			expect(deepEqual(obj1, obj3)).is(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)).is(true)
+			expect(deepEqual(map1, map3)).is(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)).is(true)
+			expect(deepEqual(emptySet1, emptySet2)).is(true)
+			expect(deepEqual(mixedMap1, mixedMap2)).is(true)
+		},
+	},
+})
+

package/s/{defer-promise.ts → defer.ts}

@@ -1,6 +1,6 @@
 
 /** a promise which can be resolved from the outside */
-export type DeferredPromise<R> = {
+export type Deferred<R> = {
 	promise: Promise<R>
 	resolve: (result: R) => void
 	reject: (reason: any) => void
@@ -10,7 +10,7 @@ export type DeferredPromise<R> = {
 }
 
 /** returns a deferred promise with exposed resolve and reject fns */
-export function deferPromise<R>(): DeferredPromise<R> {
+export function defer<R>(): Deferred<R> {
 	let resolve!: (result: R) => void
 	let reject!: (reason: any) => void
 

package/s/drill.ts

@@ -0,0 +1,20 @@
+
+import {is} from "./is.js"
+
+/** return a value within an object tree, found at the given path. */
+export function drill<xResult>(
+		object: {[key: string]: any},
+		path: string[],
+	): xResult {
+
+	let current: any = object
+
+	for (const key of path) {
+		current = current[key]
+		if (is.unset(current))
+			break
+	}
+
+	return current
+}
+

package/s/id-counter.ts

@@ -0,0 +1,9 @@
+
+export class IdCounter {
+	constructor(public count = 0) {}
+
+	next() {
+		return this.count++
+	}
+}
+

package/s/index.ts

@@ -1,5 +1,5 @@
 
-export * from "./data/barname/index.js"
+export * from "./data/bytename/index.js"
 export * from "./data/base58.js"
 export * from "./data/base64.js"
 export * from "./data/base64url.js"
@@ -7,13 +7,22 @@ export * from "./data/bytes.js"
 export * from "./data/hex.js"
 export * from "./data/txt.js"
 
+export * from "./debounce/debounce.js"
+export * from "./debounce/types.js"
+
+export * from "./deep/deep.js"
+
+export * from "./coalesce.js"
 export * from "./concurrent.js"
 export * from "./deadline.js"
 export * from "./dedupe.js"
-export * from "./defer-promise.js"
+export * from "./defer.js"
+export * from "./drill.js"
 export * from "./escape-regex.js"
 export * from "./hat.js"
+export * from "./id-counter.js"
 export * from "./is.js"
+export * from "./loopy.js"
 export * from "./map-g.js"
 export * from "./nap.js"
 export * from "./ob.js"

package/s/is.ts

@@ -1,9 +1,9 @@
 
-export const is = {
-	available: <X>(x: X): x is NonNullable<X> =>
+export const is = Object.freeze({
+	set: <X>(x: X): x is NonNullable<X> =>
 		x !== undefined && x !== null,
 
-	unavailable: (x: any): x is (undefined | null) =>
+	unset: (x: any): x is (undefined | null) =>
 		x === undefined || x === null,
 
 	boolean: (x: any): x is boolean =>
@@ -23,5 +23,11 @@ export const is = {
 
 	array: (x: any | any[]): x is any[] =>
 		Array.isArray(x),
-}
+
+	fn: (x: any): x is (...a: any[]) => any =>
+		typeof x === "function",
+
+	symbol: (x: any): x is symbol =>
+		typeof x === "symbol",
+})
 

package/s/loopy.ts

@@ -0,0 +1,12 @@
+
+export function* loop(n: number) {
+	for (let i = 0; i < n; i++)
+		yield i
+}
+
+export function* loop2d([columns, rows]: [number, number]) {
+	for (let y = 0; y < rows; y++)
+		for (let x = 0; x < columns; x++)
+			yield [x, y] as [number, number]
+}
+

package/s/map-g.ts

@@ -1,11 +1,11 @@
 
-/** js map, but with handy methods like `require` and `guarantee` */
+/** extended js map 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
+		return value as V
 	}
 
 	static guarantee<K, V>(map: Map<K, V>, key: K, make: () => V) {

package/s/nap.ts

@@ -1,4 +1,5 @@
 
+/** create a promise that waits for a number of milliseconds. */
 export const nap = (milliseconds: number = 0) => (
 	new Promise<void>(resolve => setTimeout(resolve, milliseconds))
 )

package/s/pubsub.ts

@@ -1,19 +1,35 @@
 
-import {deferPromise} from "./defer-promise.js"
+import {defer} from "./defer.js"
 
 export type Listener<A extends any[]> = (...a: A) => (void | Promise<void>)
 
 export interface Xub<A extends any[] = []> {
+
+	/** publish to all subscribed listeners. */
 	pub(...a: A): Promise<void>
+
+	/** subscribe a listener function. */
 	sub(fn: Listener<A>): () => void
+
+	/**
+	 * subscribe a listener function.
+	 * @alias sub
+	 */
+	on(fn: Listener<A>): () => void
+
+	/** subscribe a listener function that unsubscribes itself after being invoked. */
 	once(): Promise<A>
+
+	/** wipe all listeners attached to this. */
 	clear(): void
 }
 
+/** subscriber fn that can be published to. */
 export interface Sub<A extends any[] = []> extends Xub<A> {
 	(fn: Listener<A>): () => void
 }
 
+/** publisher fn that can be published to. */
 export interface Pub<A extends any[] = []> extends Xub<A> {
 	(...a: A): Promise<void>
 }
@@ -31,7 +47,7 @@ export function xub<A extends any[] = []>() {
 	}
 
 	async function once() {
-		const {promise, resolve} = deferPromise<A>()
+		const {promise, resolve} = defer<A>()
 		const unsubscribe = sub((...a) => {
 			resolve(a)
 			unsubscribe()
@@ -45,11 +61,13 @@ export function xub<A extends any[] = []>() {
 
 	sub.pub = pub
 	sub.sub = sub
+	sub.on = sub
 	sub.once = once
 	sub.clear = clear
 
 	pub.pub = pub
 	pub.sub = sub
+	pub.on = sub
 	pub.once = once
 	pub.clear = clear