@e280/stz 0.0.0-0

package/s/data/base58.ts

@@ -0,0 +1,65 @@
+
+/*
+
+256-bit base58 ids look like this:
+
+	9X1D9rdkDgRdykzmogNcxfopRc7TnbS869ow1E2ehCFS
+	AmRKyNfq6jhhsd9qda1Y6rAVS2NLUqyTUvfcB2wUiiAC
+	8skYcqBAXsejDcJzsZMo19PErt43DHP3bykaXBtMvdu
+
+*/
+
+import {Hex} from "./hex.js"
+import {Bytes} from "./bytes.js"
+
+const base = 58
+const characters = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+
+export const Base58 = Object.freeze({
+	string(bytes: Uint8Array) {
+		let intVal = BigInt("0x" + Hex.string(bytes))
+		let encoded = ""
+
+		while (intVal > 0) {
+			const remainder = intVal % BigInt(base)
+			intVal = intVal / BigInt(base)
+			encoded = characters[Number(remainder)] + encoded
+		}
+
+		for (const byte of bytes) {
+			if (byte === 0) encoded = characters[0] + encoded
+			else break
+		}
+
+		return encoded
+	},
+
+	bytes(string: string) {
+		let intVal = BigInt(0)
+
+		for (const char of string) {
+			const index = characters.indexOf(char)
+			if (index === -1) throw new Error(`Invalid character '${char}' in base58 string`)
+			intVal = intVal * BigInt(base) + BigInt(index)
+		}
+
+		let hex = intVal.toString(16)
+		if (hex.length % 2 !== 0) hex = "0" + hex
+		const bytes = Hex.bytes(hex)
+
+		let leadingZeroes = 0
+		for (const char of string) {
+			if (char === characters[0]) leadingZeroes++
+			else break
+		}
+
+		const decoded = new Uint8Array(leadingZeroes + bytes.length)
+		decoded.set(bytes, leadingZeroes)
+		return decoded
+	},
+
+	random(count = 32) {
+		return this.string(Bytes.random(count))
+	},
+})
+

package/s/data/base64.ts

@@ -0,0 +1,22 @@
+
+import {Bytes} from "./bytes.js"
+
+export const Base64 = {
+
+	string(bytes: Uint8Array) {
+		return (typeof btoa === "function")
+			? btoa(String.fromCharCode(...bytes))
+			: Buffer.from(bytes).toString("base64")
+	},
+
+	bytes(string: string) {
+		return (typeof atob === "function")
+			? Uint8Array.from(atob(string), char => char.charCodeAt(0))
+			: Uint8Array.from(Buffer.from(string, "base64"))
+	},
+
+	random(count = 32) {
+		return this.string(Bytes.random(count))
+	},
+}
+

package/s/data/base64url.ts

@@ -0,0 +1,27 @@
+
+import {Bytes} from "./bytes.js"
+import {Base64} from "./base64.js"
+
+export const Base64url = {
+
+	string(bytes: Uint8Array) {
+		return Base64.string(bytes)
+			.replace(/\+/g, "-")
+			.replace(/\//g, "_")
+			.replace(/=+$/g, "")
+	},
+
+	bytes(string: string) {
+		let b64 = string
+			.replace(/-/g, "+")
+			.replace(/_/g, "/")
+		if (b64.length % 4 !== 0)
+			b64 = b64.padEnd(b64.length + (4 - b64.length % 4) % 4, "=")
+		return Base64.bytes(b64)
+	},
+
+	random(count = 32) {
+		return this.string(Bytes.random(count))
+	},
+}
+

package/s/data/bytes.ts

@@ -0,0 +1,7 @@
+
+export const Bytes = {
+	random(count: number) {
+		return crypto.getRandomValues(new Uint8Array(count))
+	},
+}
+

package/s/data/hex.ts

@@ -0,0 +1,35 @@
+
+/*
+
+256-bit hex ids look like this:
+
+	8ff8dfbc7c994c5439d2dd327b9898aa6796f97fb396e262985f03f868707e32
+	6b99284a2c4a1c5f101502bd009f9fb592ca4427e4375155e411ddd07ed9da6b
+	2eb73fb00a2b9e38c855b5aa353b530d820a3a2dcea5013b7e4e277ddfe9d0ad
+
+*/
+
+import {Bytes} from "./bytes.js"
+
+export const Hex = {
+	string(bytes: Uint8Array) {
+		return [...bytes]
+			.map(byte => byte.toString(16).padStart(2, "0"))
+			.join("")
+	},
+
+	bytes(string: string) {
+		if (string.length % 2 !== 0)
+			throw new Error("must have even number of hex characters")
+		const bytes = new Uint8Array(string.length / 2)
+		for (let i = 0; i < string.length; i += 2)
+			bytes[i / 2] = parseInt(string.slice(i, i + 2), 16)
+		return bytes
+	},
+
+	/** generate a random hex string. byteCount defaults to 32. */
+	random(byteCount = 32) {
+		return this.string(Bytes.random(byteCount))
+	},
+}
+

package/s/data/nomen/demo.ts

@@ -0,0 +1,8 @@
+
+import {falryskNameGrammar} from "./presets/falrysk.js"
+
+const grammar = falryskNameGrammar()
+
+for (const _ of Array(20))
+	console.log(grammar.random())
+

package/s/data/nomen/grammar.ts

@@ -0,0 +1,41 @@
+
+import {ob} from "../../ob.js"
+import {Bytes} from "../bytes.js"
+import {GrammarTemplate, PhraseFns} from "./types.js"
+
+export class Grammar<P extends PhraseFns> {
+	constructor(
+		public phraseFns: P,
+		public templates: GrammarTemplate<P>[],
+	) {}
+
+	static phrases = <P extends PhraseFns>(phrases: P) => ({
+		templates: (templates: GrammarTemplate<P>[]) => (
+			new this<P>(phrases, templates)
+		),
+	})
+
+	generate([firstByte, ...bytes]: Uint8Array) {
+		const template = this.templates[firstByte % this.templates.length]
+		const phraseCount = Object.keys(this.phraseFns).length
+		const bytesPerPhrase = Math.floor(bytes.length / phraseCount)
+
+		let indexCounter = 0
+
+		const phrases = ob(this.phraseFns).map(fn => {
+			const index = indexCounter++
+			const start = index * bytesPerPhrase
+			const end = Math.min(start + bytesPerPhrase, bytes.length - 1)
+			const buffer = new Uint8Array(bytes.slice(start, end))
+			return fn(buffer)
+		})
+
+		return template(phrases)
+	}
+
+	random() {
+		const buffer = Bytes.random(32)
+		return this.generate(buffer)
+	}
+}
+

package/s/data/nomen/index.ts

@@ -0,0 +1,5 @@
+
+export * from "./nomen.js"
+export * from "./grammar.js"
+export * from "./presets/falrysk.js"
+

package/s/data/nomen/nomen.ts

@@ -0,0 +1,34 @@
+
+import {Bytes} from "../bytes.js"
+import {Dictionary, Pattern} from "./types.js"
+
+export class Nomen<D extends Dictionary> {
+	constructor(public dictionary: D, public patterns: Pattern<D>[]) {}
+
+	static dictionary = <D extends Dictionary>(dictionary: D) => ({
+		patterns: (patterns: Pattern<D>[]) => (
+			new this<D>(dictionary, patterns)
+		),
+	})
+
+	generate([firstByte, ...bytes]: Uint8Array) {
+		const pattern = this.patterns[firstByte % this.patterns.length]
+		let index = 0
+
+		const obtainWordChunk = (key: keyof D) => {
+			const dictionary = this.dictionary[key]
+			const byte = bytes[(index++) % bytes.length]
+			return dictionary[byte % dictionary.length]
+		}
+
+		return pattern
+			.map(wordpattern => wordpattern.map(obtainWordChunk).join(""))
+			.join(" ")
+	}
+
+	random() {
+		const buffer = Bytes.random(32)
+		return this.generate(buffer)
+	}
+}
+

package/s/data/nomen/presets/falrysk.ts

@@ -0,0 +1,112 @@
+
+import {Nomen} from "../nomen.js"
+import {Grammar} from "../grammar.js"
+
+export function falryskNameGrammar() {
+	const person = Nomen
+		.dictionary({
+			prefix: [
+				"Aed", "Ael", "Aer", "Aeg",
+				"Aes", "Aet", "Aeon", "Aek",
+				"Årg", "Ard", "Arn", "Ayn",
+				"Ar", "Ad", "Atl", "An",
+				"And", "Anr", "Ain", "Ayn",
+				"End", "Esk", "Eld", "Ŏln",
+				"Elg", "Erd", "Eyn", "Esn",
+				"Olf", "Of", "Oy", "Oc",
+				"War", "Wer", "Wot", "Wal",
+				"Gäl", "Gar", "Gaer", "Gir",
+				"Gor", "Gil", "Ger", "Gan",
+				"Thós", "Thès", "Tír", "Tal",
+				"Fâl", "Fen", "Fel", "Fol",
+				"Fír", "For", "Feyt", "Fern",
+				"Feyn", "Fayn", "Feln", "Faln",
+				"Ven", "Van", "Vèl", "Val",
+				"Veyn", "Vayn", "Veyl", "Vayl",
+				"Nýz", "Nor", "Nal", "Nyn",
+				"Mór", "Mar", "Myor", "Mor",
+				"Lom", "Lem", "Lorn", "Leyn",
+				"Kal", "Kel", "Kyel", "Kol",
+				"Shel", "Shen", "Shal", "Shey",
+				"Pip", "Par", "Pyot", "Poy",
+				"Thar", "Ther", "Thor", "Thel",
+				"Uyn", "Uer", "Usn", "Uin",
+				"Yön", "Yès", "Yol", "Yel",
+				"Xen", "Zael", "Zaer", "Zod",
+				"Aʼ", "Oʼ",
+			],
+
+			suffix: [
+				"th", "st", "yt", "ft",
+				"sk", "rk", "rd", "nd",
+				"by", "cy", "ry", "ny",
+				"yn", "vn", "vy", "ly",
+				"rik", "rek", "nok", "rôk",
+				"bie", "rie", "lie",
+				"nar", "råg", "lg", "rn",
+			],
+
+			o: [..."aaeeiou"],
+			x: [..."bcdfghklmnprstvwxyz"],
+
+			oo: [
+				"au", "ea", "ía", "oa",
+				"áe", "ës", "ie", "oé",
+				"aí", "ei", "iû", "uî",
+				"al", "eo", "io", "us",
+			],
+
+			ox: [
+				"ës", "us", "is", "os",
+				"as", "ar", "er", "or",
+				"ad", "ed", "id", "od",
+				"aw", "ew", "iw", "ow",
+			],
+
+			xox: [
+				"nak", "nëk", "nud", "nok",
+				"rár", "råth", "ýeg", "rin",
+				"wég", "wug", "wøg",
+			],
+
+			oxo: [
+				"ana", "ëna", "anu", "irá",
+				"arna", "erna", "arnû", "irna",
+				"ánla", "ënla", "arlu", "irla",
+				"ára", "atho", "oýo", "ina",
+				"éwe", "uwa", "øga",
+			],
+		})
+		.patterns([
+			[["prefix", "o"]],
+			[["prefix", "oo"]],
+			[["prefix", "ox"]],
+			[["prefix", "oxo"]],
+
+			[["prefix", "o", "suffix"]],
+			[["prefix", "o", "suffix"]],
+			[["prefix", "o", "suffix"]],
+			[["prefix", "o", "suffix"]],
+
+			[["prefix", "oo", "suffix"]],
+			[["prefix", "oxo", "suffix"]],
+
+			// // long names
+			// [["prefix", "oo", "x", "oo", "suffix"]],
+			// [["prefix", "o", "x", "oo", "suffix"]],
+		])
+
+	return Grammar
+		.phrases({
+			first: b => person.generate(b),
+			last: b => person.generate(b),
+		})
+		.templates([
+			o => `${o.first} ${o.last}`,
+
+			// // long names
+			// o => `${o.first} of ${o.last}`,
+			// o => `${o.first} from ${o.last}`,
+		])
+}
+

package/s/data/nomen/types.ts

@@ -0,0 +1,9 @@
+
+export type Dictionary = Record<string, string[]>
+export type Pattern<D extends Dictionary> = (keyof D)[][]
+
+export type PhraseFn = (bytes: Uint8Array) => string
+export type PhraseFns = Record<string, PhraseFn>
+export type Phrases<P extends PhraseFns> = Record<keyof P, string>
+export type GrammarTemplate<P extends PhraseFns> = (phrases: Phrases<P>) => string
+

package/s/data/txt.ts

@@ -0,0 +1,11 @@
+
+export const Txt = {
+	string(bytes: Uint8Array) {
+		return new TextDecoder().decode(bytes)
+	},
+
+	bytes(string: string) {
+		return new TextEncoder().encode(string)
+	},
+}
+

package/s/deadline.ts

@@ -0,0 +1,24 @@
+
+export class DeadlineError extends Error {
+	name = this.constructor.name
+	constructor(milliseconds: number) {
+		super(`deadline exceeded (${milliseconds.toLocaleString()} ms)`)
+	}
+}
+
+/** 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>) {
+	return new Promise<R>((resolve, reject) => {
+
+		const id = setTimeout(
+			() => reject(new DeadlineError(milliseconds)),
+			milliseconds,
+		)
+
+		fn()
+			.then(resolve)
+			.catch(reject)
+			.finally(() => clearTimeout(id))
+	})
+}
+

package/s/debounce/debounce.test.ts

@@ -0,0 +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()
+// 	},
+// }
+//

package/s/debounce/debounce.ts

@@ -0,0 +1,54 @@
+
+import {AnyFunction, DebounceReturn} from "./types.js"
+
+export function debounce<xAction extends AnyFunction>(
+		delay: number,
+		action: xAction,
+	): DebounceReturn<xAction> {
+
+	let latestArgs: any[]
+	let timeout: any
+
+	let waitingQueue: {
+		resolve: (r: ReturnType<xAction>) => void
+		reject: (reason: any) => void
+	}[] = []
+
+	function reset() {
+		latestArgs = []
+		if (timeout)
+			clearTimeout(timeout)
+		timeout = undefined
+		waitingQueue = []
+	}
+
+	reset()
+
+	return <DebounceReturn<xAction>>((...args) => {
+		latestArgs = args
+
+		if (timeout)
+			clearTimeout(timeout)
+
+		const promise = new Promise((resolve, reject) => {
+			waitingQueue.push({resolve, reject})
+		})
+
+		timeout = setTimeout(() => {
+			Promise.resolve()
+				.then(() => action(...latestArgs))
+				.then(r => {
+					for (const {resolve} of waitingQueue)
+						resolve(r)
+					reset()
+				})
+				.catch(err => {
+					for (const {reject} of waitingQueue)
+						reject(err)
+					reset()
+				})
+		}, delay)
+
+		return promise
+	})
+}

package/s/debounce/types.ts

@@ -0,0 +1,8 @@
+
+export type AnyFunction = (...args: any[]) => any
+
+export type DebounceReturn<xAction extends AnyFunction> =
+	(...args: Parameters<xAction>) =>
+		ReturnType<xAction> extends Promise<any>
+			? ReturnType<xAction>
+			: Promise<ReturnType<xAction>>

package/s/dedupe.ts

@@ -0,0 +1,5 @@
+
+export function dedupe<T>(array: T[]) {
+	return [...new Set(array)]
+}
+

package/s/deep/deep.test.ts

@@ -0,0 +1,8 @@
+//
+// import {Suite} from "cynic"
+// import deepEqual from "./parts/equal.test.js"
+//
+// export default <Suite>{
+// 	deepEqual,
+// }
+//

package/s/deep/deep.ts

@@ -0,0 +1,11 @@
+
+import {clone} from "../clone/clone.js"
+import {deepEqual} from "./parts/equal.js"
+import {deepFreeze} from "./parts/freeze.js"
+
+export const deep = {
+	clone,
+	equal: deepEqual,
+	freeze: deepFreeze,
+}
+