@e280/stz 0.0.0-3 → 0.0.0-30

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 = void> = {
 	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 = void>(): Deferred<R> {
 	let resolve!: (result: R) => void
 	let reject!: (reason: any) => void
 

package/s/drill.ts

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

package/s/ev.ts

@@ -0,0 +1,20 @@
+
+export type EvFn = (...a: any[]) => void
+
+export type EvTarget<N extends string> = {
+	addEventListener(name: N, fn: EvFn): void
+	removeEventListener(name: N, fn: EvFn): void
+}
+
+export function ev<N extends string>(target: EvTarget<N>, fns: Record<N, EvFn>) {
+	const entries = Object.entries(fns) as [N, EvFn][]
+
+	for (const [name, fn] of entries)
+		target.addEventListener(name, fn)
+
+	return () => {
+		for (const [name, fn] of entries)
+			target.removeEventListener(name, fn)
+	}
+}
+

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,6 @@
 
-export * from "./data/barname/index.js"
+export * from "./data/bytename/index.js"
+export * from "./data/base-x.js"
 export * from "./data/base58.js"
 export * from "./data/base64.js"
 export * from "./data/base64url.js"
@@ -7,19 +8,32 @@ 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 "./queue/queue.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 "./ev.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"
+export * from "./once.js"
 export * from "./pipe.js"
+export * from "./repeat.js"
 export * from "./pubsub.js"
+export * from "./time.js"
 export * from "./trash.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/once.ts

@@ -0,0 +1,14 @@
+
+export function once<Fn extends (...a: any[]) => any>(fn: Fn) {
+	let done = false
+	let ret: any
+
+	return ((...a) => {
+		if (!done) {
+			done = true
+			ret = fn(...a)
+		}
+		return ret
+	}) as Fn
+}
+