@benev/tact 0.4.0-0 → 0.4.0-10

package/s/_archive/lib3/input/data/decode.ts

@@ -1,25 +0,0 @@
-
-import {Intent} from "../types.js"
-import {endian, sizeHash, sizeId, sizeValue} from "./params.js"
-
-export function decodeData(buffer: ArrayBuffer) {
-	const intents: Intent[] = []
-	const dv = new DataView(buffer)
-	let cursor = 0
-
-	const hash = dv.getUint32(cursor, endian)
-	cursor += sizeHash
-
-	while (cursor < buffer.byteLength) {
-		const id = dv.getUint16(cursor, endian)
-		cursor += sizeId
-
-		const value = dv.getFloat32(cursor, endian)
-		cursor += sizeValue
-
-		intents.push({id, value})
-	}
-
-	return {hash, intents}
-}
-

package/s/_archive/lib3/input/data/encode.ts

@@ -1,24 +0,0 @@
-
-import {Intent} from "../types.js"
-import {endian, sizeHash, sizeId, sizeIntention, sizeValue} from "./params.js"
-
-export function encodeData(hash: number, intents: Intent[]) {
-	const byteCount = sizeHash + (intents.length * sizeIntention)
-	const buffer = new ArrayBuffer(byteCount)
-	const dv = new DataView(buffer)
-	let cursor = 0
-
-	dv.setUint32(cursor, hash, endian)
-	cursor += sizeHash
-
-	for (const intention of intents) {
-		dv.setUint16(cursor, intention.id, endian)
-		cursor += sizeId
-
-		dv.setFloat32(cursor, intention.value, endian)
-		cursor += sizeValue
-	}
-
-	return buffer
-}
-

package/s/_archive/lib3/input/decoder.ts

@@ -1,56 +0,0 @@
-
-import {isDown} from "./utils/is-down.js"
-import {decodeData} from "./data/decode.js"
-import {Inputs, Bindings, InputData} from "./types.js"
-import {investigate} from "./investigate/investigate.js"
-
-export class InputDecoder<B extends Bindings> {
-	#investigation
-
-	constructor(bindings: B) {
-		this.#investigation = investigate(bindings)
-	}
-
-	get inputs() {
-		return this.#investigation.inputs
-	}
-
-	resolve(...datas: InputData[]): Inputs<B> {
-		for (const input of this.#investigation.inputList) {
-			input.was = input.value
-			input.pulses = 0
-			input.change = 0
-			input.up = 0
-			input.down = 0
-			input.highest = null
-			input.lowest = null
-		}
-
-		for (const data of datas) {
-			const decoded = decodeData(data)
-
-			if (decoded.hash !== this.#investigation.hash)
-				throw new Error("intent bindings hash mismatch")
-
-
-			for (const {id, value} of decoded.intents) {
-				const input = this.#investigation.inputList[id]
-				if (!input) throw new Error(`unknown input id ${id}`)
-
-				const previous = input.value
-				input.value = value
-				input.pulses += value
-
-				if (value !== previous) input.change++
-				if (!isDown(previous) && isDown(value)) input.down++
-				if (isDown(previous) && !isDown(value)) input.up++
-
-				input.lowest = Math.min(input.lowest ?? value, value)
-				input.highest = Math.max(input.highest ?? value, value)
-			}
-		}
-
-		return this.inputs
-	}
-}
-

package/s/_archive/lib3/input/encoder.ts

@@ -1,99 +0,0 @@
-
-import {deepClone, deepFreeze, got} from "@e280/stz"
-import {Sampler} from "./utils/sampler.js"
-import {encodeData} from "./data/encode.js"
-import {evaluate} from "./evaluate/evaluate.js"
-import {EvaluationContext} from "./evaluate/context.js"
-import {investigate} from "./investigate/investigate.js"
-import {Bindings, Expression, InputData, Intent, Rebindings, Source} from "./types.js"
-
-export class InputEncoder<B extends Bindings = any> {
-	#sampler
-	#bindings
-	#investigation
-	#context
-	#expressionValues = new Map<Expression, number>()
-
-	constructor(source: Source, bindings: B) {
-		this.#bindings = deepFreeze(deepClone(bindings)) as any as Rebindings<B>
-		this.#investigation = investigate(this.#bindings)
-		this.#sampler = new Sampler(source)
-		this.#context = new EvaluationContext()
-		this.#init()
-	}
-
-	get bindings() {
-		return this.#bindings
-	}
-
-	set bindings(b: Rebindings<B>) {
-		const fresh = investigate(b)
-
-		if (fresh.hash !== this.#investigation.hash)
-			throw new Error("incompatible bindings")
-
-		this.#investigation.rootIds = fresh.rootIds
-		this.#investigation.rootList = fresh.rootList
-		this.#investigation.rootIndex = fresh.rootIndex
-		this.#context = new EvaluationContext()
-		this.#expressionValues.clear()
-		this.#init()
-	}
-
-	encode(time = performance.now()): InputData {
-		return encodeData(this.#investigation.hash, [...this.evaluate(time)])
-	}
-
-	*evaluate(time = performance.now()) {
-		const samples = this.#sampler.take()
-
-		this.#context.clock.update(time)
-		this.#context.phase = "samples"
-		this.#context.dt = 0
-
-		for (const sample of samples) {
-			this.#context.sampleValues.set(sample.code, sample.value)
-
-			for (const root of this.#investigation.rootIndex.get(sample.code) ?? []) {
-				const intent = this.#makeIntent(root, sample.mode === "pulse")
-				if (intent) yield intent
-			}
-
-			if (sample.mode === "pulse")
-				this.#context.sampleValues.set(sample.code, 0)
-		}
-
-		this.#context.phase = "holdy"
-		for (const root of this.#context.holdyRoots) {
-			const intent = this.#makeIntent(root)
-			if (intent) yield intent
-		}
-
-		this.#context.phase = "dt"
-		this.#context.dt = this.#context.clock.since / 1000
-		for (const root of this.#context.dtRoots) {
-			const intent = this.#makeIntent(root, true)
-			if (intent) yield intent
-		}
-	}
-
-	#init() {
-		for (const root of this.#investigation.rootList)
-			evaluate(this.#context, root, root)
-	}
-
-	#makeIntent(root: Expression, force = false) {
-		const value = evaluate(this.#context, root, root)
-		const was = this.#expressionValues.get(root)
-		if (force || value !== was) {
-			this.#expressionValues.set(root, value)
-			const id = got(this.#investigation.rootIds.get(root))
-			return <Intent>{id, value}
-		}
-	}
-
-	dispose() {
-		return this.#sampler.dispose()
-	}
-}
-

package/s/_archive/lib3/input/evaluate/context.ts

@@ -1,15 +0,0 @@
-
-import {Expression} from "../types.js"
-import {Clock} from "./utils/clock.js"
-
-export class EvaluationContext {
-	phase: "samples" | "holdy" | "dt" = "samples"
-	clock = new Clock()
-	dt = 0
-	sampleValues = new Map<string, number>()
-	holding = new WeakMap<object, {start: number}>()
-	tapping = new WeakMap<object, {previous: number, events: number[]}>()
-	holdyRoots = new Set<Expression>()
-	dtRoots = new Set<Expression>()
-}
-

package/s/_archive/lib3/input/evaluate/evaluate.ts

@@ -1,142 +0,0 @@
-
-import {remap} from "@benev/math"
-import {arraylimit, guarantee, isNumber, isString} from "@e280/stz"
-import {Expression} from "../types.js"
-import {isDown} from "../utils/is-down.js"
-import {EvaluationContext} from "./context.js"
-
-export function evaluate(
-		context: EvaluationContext,
-		root: Expression,
-		expression: Expression,
-	): number {
-
-	const e = (expression: Expression) => evaluate(context, root, expression)
-
-	if (isNumber(expression))
-		return expression
-
-	else if (isString(expression))
-		return context.sampleValues.get(expression) ?? 0
-
-	else switch (expression[0]) {
-		case "min":
-			return Math.min(...expression.slice(1).map(e))
-
-		case "max":
-			return Math.max(...expression.slice(1).map(e))
-
-		case "+":
-			return expression.slice(1)
-				.map(e)
-				.reduce((p, c) => p + c, 0)
-
-		case "*":
-			return expression.slice(1)
-				.map(e)
-				.reduce((p, c) => p * c, 1)
-
-		case "!":
-			return +(e(expression[1]) === 0)
-
-		case "!!":
-			return +(e(expression[1]) !== 0)
-
-		case "==":
-			return +(e(expression[1]) === e(expression[2]))
-
-		case "!=":
-			return +(e(expression[1]) !== e(expression[2]))
-
-		case ">":
-			return +(e(expression[1]) > e(expression[2]))
-
-		case "<":
-			return +(e(expression[1]) < e(expression[2]))
-
-		case ">=":
-			return +(e(expression[1]) >= e(expression[2]))
-
-		case "<=":
-			return +(e(expression[1]) <= e(expression[2]))
-
-		case "clamp": {
-			const [, min, max, expr] = expression
-			const value = e(expr)
-			return Math.min(
-				max === null ? Infinity : e(max),
-				Math.max(
-					min === null ? -Infinity : e(min),
-					value,
-				),
-			)
-		}
-
-		case "remap": {
-			const [, a, b, c, d, expr] = expression
-			return remap(e(expr), e(a), e(b), e(c), e(d))
-		}
-
-		case "dt": {
-			context.dtRoots.add(root)
-			return context.dt
-		}
-
-		case "held": {
-			context.holdyRoots.add(root)
-
-			const [, ms, subexpression] = expression
-			const down = isDown(e(subexpression))
-			let held = context.holding.get(expression)
-
-			if (down && !held) {
-				held = {start: context.clock.time}
-				context.holding.set(expression, held)
-			}
-
-			if (!down && held) {
-				held = undefined
-				context.holding.delete(expression)
-			}
-
-			if (held) {
-				const timeHeld = context.clock.time - held.start
-				if (timeHeld >= ms)
-					return 1
-			}
-
-			return 0
-		}
-
-		case "taps": {
-			const [, taps, ms, subexpression] = expression
-			const value = e(subexpression)
-			const tapped = guarantee(context.tapping, expression, () => ({
-				previous: 0,
-				events: [],
-			}))
-
-			const nowDown = isDown(value)
-			const wasDown = isDown(tapped.previous)
-			tapped.previous = value
-
-			if (nowDown && !wasDown) {
-				tapped.events.push(context.clock.time)
-				tapped.events = arraylimit(
-					tapped.events.filter(time => time >= (context.clock.time - ms)),
-					1024,
-				)
-				if (tapped.events.length >= taps) {
-					tapped.events = []
-					return 1
-				}
-			}
-
-			return 0
-		}
-
-		default:
-			throw new Error("unknown expression")
-	}
-}
-

package/s/_archive/lib3/input/evaluate/utils/clock.ts

@@ -1,14 +0,0 @@
-
-export class Clock {
-	since = 0
-	last: number | undefined
-
-	constructor(public time = performance.now()) {}
-
-	update(time = performance.now()) {
-		this.since = time - (this.time ?? time)
-		this.last = this.time
-		this.time = time
-	}
-}
-

package/s/_archive/lib3/input/investigate/hash-bindings.ts

@@ -1,22 +0,0 @@
-
-import {hash32} from "@e280/stz"
-import {Bindings} from "../types.js"
-import {isExpression} from "./is-expression.js"
-
-export function hashBindings(bindings: Bindings) {
-	const paths: string[] = []
-
-	function recurse(b: Bindings, path: string[]) {
-		if (isExpression(b)) {
-			paths.push(path.join("."))
-		}
-		else {
-			for (const [key, value] of Object.entries(b))
-				recurse(value, [...path, key])
-		}
-	}
-
-	recurse(bindings, ["b"])
-	return hash32(...paths)
-}
-

package/s/_archive/lib3/input/investigate/investigate.ts

@@ -1,42 +0,0 @@
-
-import {obMap} from "@e280/stz"
-import {makeInput} from "./make-input.js"
-import {hashBindings} from "./hash-bindings.js"
-import {isExpression} from "./is-expression.js"
-import {Bindings, Expression, Input, Inputs} from "../types.js"
-import {makeRootIndex as makeRootIndex} from "./root-index.js"
-
-export function investigate<B extends Bindings>(bindings: B) {
-	const hash = hashBindings(bindings)
-	const inputList: Input[] = []
-	const rootList: Expression[] = []
-	const rootIds = new Map<Expression, number>()
-
-	function makeInputs(b: Bindings): unknown {
-		if (isExpression(b)) {
-			const input = makeInput()
-			inputList.push(input)
-			rootList.push(b)
-			return input
-		}
-		else {
-			return obMap(b, makeInputs)
-		}
-	}
-
-	const inputs = makeInputs(bindings) as Inputs<B>
-	const rootIndex = makeRootIndex(rootList)
-
-	for (const [id, root] of rootList.entries())
-		rootIds.set(root, id)
-
-	return {
-		hash,
-		inputs,
-		inputList,
-		rootList,
-		rootIndex,
-		rootIds,
-	}
-}
-

package/s/_archive/lib3/input/investigate/is-expression.ts

@@ -1,11 +0,0 @@
-
-import {isArray, isNumber, isString} from "@e280/stz"
-import {Bindings, Expression} from "../types.js"
-
-export function isExpression(b: Bindings): b is Expression {
-	if (isString(b)) return true
-	if (isNumber(b)) return true
-	if (isArray(b)) return true
-	return false
-}
-

package/s/_archive/lib3/input/investigate/make-input.ts

@@ -1,18 +0,0 @@
-
-import {Input} from "../types.js"
-
-export function makeInput(): Input {
-	return {
-		value: 0,
-		was: 0,
-		pulses: 0,
-
-		change: 0,
-		down: 0,
-		up: 0,
-
-		lowest: 0,
-		highest: 0,
-	}
-}
-

package/s/_archive/lib3/input/investigate/root-index.ts

@@ -1,26 +0,0 @@
-
-import {guarantee, isArray, isString} from "@e280/stz"
-import {Expression} from "../types.js"
-
-export function makeRootIndex(rootList: Expression[]) {
-	type Code = string
-	const rootIndex = new Map<Code, Set<Expression>>()
-
-	function recurse(root: Expression, e: Expression) {
-		if (isString(e)) {
-			guarantee(rootIndex, e, () => new Set())
-				.add(root)
-		}
-		else if (isArray(e)) {
-			for (const sub of e.slice(1))
-				if (sub !== null)
-					recurse(root, sub)
-		}
-	}
-
-	for (const root of rootList)
-		recurse(root, root)
-
-	return rootIndex
-}
-

package/s/_archive/lib3/input/mixer.ts

@@ -1,20 +0,0 @@
-
-import {Intent} from "./types.js"
-import {InputEncoder} from "./encoder.js"
-import {encodeData} from "./data/encode.js"
-
-export class InputMixer {
-	encoders = new Set<InputEncoder<any>>()
-	constructor(private hash: number) {}
-
-	encode(time = performance.now()) {
-		const intents: Intent[] = []
-
-		for (const encoder of this.encoders)
-			for (const intent of encoder.evaluate(time))
-				intents.push(intent)
-
-		return encodeData(this.hash, intents)
-	}
-}
-

package/s/_archive/lib3/input/sources/gamepad.ts

@@ -1,58 +0,0 @@
-
-import {PlainSource} from "./plain.js"
-import {Pad} from "../utils/pad/pad.js"
-import {splitAxis} from "../utils/split-axis.js"
-
-export class GamepadSource extends PlainSource {
-	#values = new Map<string, number>()
-
-	constructor(public pad: Pad) {
-		super()
-	}
-
-	get gamepad() {
-		return this.pad.gamepad
-	}
-
-	poll() {
-		const gamepad = this.gamepad
-		this.#pollButtons(gamepad)
-		this.#pollAxes(gamepad)
-	}
-
-	#publish(code: string, value: number) {
-		const previous = this.#values.get(code) ?? 0
-
-		if (value !== previous) {
-			this.#values.set(code, value)
-			this.onSample.publish({code, value, mode: "sticky"})
-		}
-	}
-
-	#pollButtons(gamepad: Gamepad) {
-		let any = 0
-
-		for (const [index, button] of gamepad.buttons.entries()) {
-			const value = button.value
-			const i = index + 1
-
-			this.#publish(`gamepad.button.${i}`, value)
-
-			any = Math.max(any, value)
-		}
-
-		this.#publish("gamepad.button.any", any)
-	}
-
-	#pollAxes(gamepad: Gamepad) {
-		for (const [index, value] of gamepad.axes.entries()) {
-			const i = index + 1
-			const [neg, pos] = splitAxis(value)
-
-			this.#publish(`gamepad.axis.${i}`, value)
-			this.#publish(`gamepad.axis.${i}.neg`, neg)
-			this.#publish(`gamepad.axis.${i}.pos`, pos)
-		}
-	}
-}
-

package/s/_archive/lib3/input/sources/keyboard.ts

@@ -1,49 +0,0 @@
-
-import {ev} from "@e280/stz"
-import {PlainSource} from "./plain.js"
-
-export class KeyboardSource extends PlainSource {
-	#down = new Set<string>()
-
-	constructor(target: EventTarget = window) {
-		super()
-		this.dispose.schedule(ev(target, this.#targetListeners))
-		this.dispose.schedule(ev(window, this.#windowListeners))
-	}
-
-	#publish = (code: string, value: number) =>
-		this.onSample.publish({code, value, mode: "sticky"})
-
-	#targetListeners = {
-		keydown: (event: KeyboardEvent) => {
-			if (event.repeat) return
-
-			if (this.#down.size === 0)
-				this.#publish("keyboard.any", 1)
-
-			this.#publish(event.code, 1)
-			this.#down.add(event.code)
-		},
-
-		keyup: (event: KeyboardEvent) => {
-			this.#publish(event.code, 0)
-			this.#down.delete(event.code)
-
-			if (this.#down.size === 0)
-				this.#publish("keyboard.any", 0)
-		},
-	}
-
-	#windowListeners = {
-		blur: () => {
-			for (const code of this.#down)
-				this.#publish(code, 0)
-
-			if (this.#down.size)
-				this.#publish("keyboard.any", 0)
-
-			this.#down.clear()
-		},
-	}
-}
-

package/s/_archive/lib3/input/sources/plain.ts

@@ -1,9 +0,0 @@
-
-import {disposer, sub} from "@e280/stz"
-import {Sample, Source} from "../types.js"
-
-export class PlainSource implements Source {
-	onSample = sub<[sample: Sample]>()
-	dispose = disposer()
-}
-