@e280/stz 0.0.0-5 → 0.0.0-7

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/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"

package/s/tests.test.ts

@@ -0,0 +1,17 @@
+
+import {Science} from "@e280/science"
+
+import cloneTest from "./clone/clone.test.js"
+import badgeTest from "./data/bytename/badge.test.js"
+import debounceTest from "./debounce/debounce.test.js"
+import bytenameTest from "./data/bytename/bytename.test.js"
+import deepTest from "./deep/deep.test.js"
+
+await Science.run({
+	clone: cloneTest,
+	bytename: bytenameTest,
+	badge: badgeTest,
+	debounce: debounceTest,
+	deep: deepTest,
+})
+

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

@@ -1 +1,15 @@
-export {};
+declare const _default: {
+    "clone primitive types"(): Promise<void>;
+    "clone arrays"(): Promise<void>;
+    "clone plain objects"(): Promise<void>;
+    "clone Map"(): Promise<void>;
+    "clone Set"(): Promise<void>;
+    "clone Date"(): Promise<void>;
+    "clone objects with circular reference"(): Promise<void>;
+    "clone nested objects"(): Promise<void>;
+    "clone array of objects"(): Promise<void>;
+    "clone object with array"(): Promise<void>;
+    "clone object with Map"(): Promise<void>;
+    "clone object with duplicate sibling references"(): Promise<void>;
+};
+export default _default;