@e280/stz 0.0.0-3 → 0.0.0-31

package/s/data/data.test.ts

@@ -0,0 +1,98 @@
+
+import {Science, test, expect} from "@e280/science"
+import {ob} from "../ob.js"
+import {Txt} from "./txt.js"
+import {Hex} from "./hex.js"
+import {Bytes} from "./bytes.js"
+import {BaseX} from "./base-x.js"
+import {Base58} from "./base58.js"
+import {Base64} from "./base64.js"
+import {Base64url} from "./base64url.js"
+
+const sampleBytes = Hex.toBytes("9960cd633a46acfe8307d8a400e842da0d930a75fb8188e0f5da264e4b6b4e5b")
+
+type ByteUtil = {
+	toBytes: (string: string) => Uint8Array
+	fromBytes: (bytes: Uint8Array) => string
+}
+
+type NumberUtil = {
+	toInteger: (s: string) => number
+	fromInteger: (n: number) => string
+}
+
+function testBytes(util: ByteUtil) {
+	return async() => {
+		const string = util.fromBytes(sampleBytes)
+		const recreated = util.toBytes(string)
+		expect(Bytes.eq(sampleBytes, recreated)).ok()
+	}
+}
+
+function testNumbers(util: NumberUtil) {
+	return {
+		positive: async() => {
+			const original = 123456789
+			const string = util.fromInteger(original)
+			const recreated = util.toInteger(string)
+			expect(original).is(recreated)
+			expect(util.toInteger("")).is(0)
+		},
+		negative: async() => {
+			const original = -123456789
+			const string = util.fromInteger(original)
+			const recreated = util.toInteger(string)
+			expect(original).is(recreated)
+			expect(util.toInteger("")).is(0)
+		},
+	}
+}
+
+function testBoth(util: ByteUtil & NumberUtil) {
+	return {
+		bytes: testBytes(util),
+		numbers: testNumbers(util),
+	}
+}
+
+function testCompat(alpha: ByteUtil, bravo: ByteUtil) {
+	return async() => {
+		expect(alpha.fromBytes(sampleBytes))
+			.is(bravo.fromBytes(sampleBytes))
+	}
+}
+
+export default Science.suite({
+	"Base58": testBytes(Base58),
+	"Base64": testBytes(Base64),
+	"Base64url": testBytes(Base64url),
+	"Hex": testBytes(Hex),
+
+	"Txt": test(async() => {
+		const original = `build or die. 💻>☠️ 命火工`
+		const bytes = Txt.toBytes(original)
+		const recreated = Txt.fromBytes(bytes)
+		expect(original).is(recreated)
+	}),
+
+	"BaseX": Science.suite({
+		lexicons: Science.suite(
+			ob(BaseX.lexicons).map(lex => testBoth(new BaseX(lex)))
+		),
+		compat: Science.suite({
+			"Hex": testCompat(Hex, new BaseX(BaseX.lexicons.hex)),
+			"Base64": testCompat(Base64, new BaseX(BaseX.lexicons.base64)),
+			"Base64url": testCompat(Base64url, new BaseX(BaseX.lexicons.base64url)),
+		}),
+		"base64 has padding": test(async() => {
+			const s = new BaseX(BaseX.lexicons.base64).fromBytes(sampleBytes)
+			expect(s.endsWith("=")).ok()
+		}),
+		"antagonistic base64 positive integer": test(async() => {
+			const base64url = new BaseX(BaseX.lexicons.base64url)
+			expect(base64url.toInteger(base64url.fromInteger(62))).is(62)
+			expect(base64url.toInteger(base64url.fromInteger(4030))).is(4030)
+		}),
+	}),
+})
+

package/s/data/hex.ts

@@ -11,14 +11,14 @@
 
 import {Bytes} from "./bytes.js"
 
-export const Hex = {
-	string(bytes: Uint8Array) {
+export const Hex = Object.freeze({
+	fromBytes(bytes: Uint8Array) {
 		return [...bytes]
 			.map(byte => byte.toString(16).padStart(2, "0"))
 			.join("")
 	},
 
-	bytes(string: string) {
+	toBytes(string: string) {
 		if (string.length % 2 !== 0)
 			throw new Error("must have even number of hex characters")
 		const bytes = new Uint8Array(string.length / 2)
@@ -29,7 +29,17 @@ export const Hex = {
 
 	/** generate a random hex string. byteCount defaults to 32. */
 	random(byteCount = 32) {
-		return this.string(Bytes.random(byteCount))
+		return this.fromBytes(Bytes.random(byteCount))
+	},
+
+	/** @deprecated renamed to `fromBytes` */
+	string(bytes: Uint8Array) {
+		return Hex.fromBytes(bytes)
+	},
+
+	/** @deprecated renamed to `toBytes` */
+	bytes(string: string) {
+		return Hex.toBytes(string)
 	},
-}
+})
 

package/s/data/txt.ts

@@ -1,11 +1,21 @@
 
-export const Txt = {
-	string(bytes: Uint8Array) {
+export const Txt = Object.freeze({
+	fromBytes(bytes: Uint8Array) {
 		return new TextDecoder().decode(bytes)
 	},
 
-	bytes(string: string) {
+	toBytes(string: string) {
 		return new TextEncoder().encode(string)
 	},
-}
+
+	/** @deprecated renamed to `fromBytes` */
+	string(bytes: Uint8Array) {
+		return Txt.fromBytes(bytes)
+	},
+
+	/** @deprecated renamed to `toBytes` */
+	bytes(string: string) {
+		return Txt.toBytes(string)
+	},
+})
 

package/s/deadline.ts

@@ -1,26 +1,25 @@
 
 export class DeadlineError extends Error {
 	name = this.constructor.name
-	constructor(public milliseconds: number, message: string) {
-		super(`${message}, timed out in ${(milliseconds / 1000).toFixed(1)} seconds`)
+	constructor(public milliseconds: number) {
+		super(`deadline exceeded (${(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, message: string, fn: () => Promise<R>) {
+export function deadline<R>(milliseconds: number, fn: () => Promise<R>) {
 	if (milliseconds <= 0 || milliseconds === Infinity)
 		return fn()
 
 	return new Promise<R>((resolve, reject) => {
-
 		const id = setTimeout(
-			() => reject(new DeadlineError(milliseconds, message)),
+			() => reject(new DeadlineError(milliseconds)),
 			milliseconds,
 		)
-
 		fn()
 			.then(resolve)
 			.catch(reject)
 			.finally(() => clearTimeout(id))
 	})
 }
+

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
 	}