@benev/tact 0.4.0-0 → 0.4.0-10

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

@@ -1,157 +0,0 @@
-
-import {remap} from "@benev/math"
-import {arraylimit, guarantee, isNumber, isString} from "@e280/stz"
-
-import {isDown} from "../utils/is-down.js"
-import {EvaluationContext} from "./context.js"
-import {Expression, RootExpression} from "../types.js"
-
-export function evaluate(
-		context: EvaluationContext,
-		id: number,
-		root: RootExpression,
-		expression: RootExpression,
-	): number {
-
-	const e = (expression: Expression) => evaluate(context, id, root, expression)
-
-	if (isNumber(expression))
-		return expression
-
-	else if (isString(expression))
-		return context.sampleValues.get(expression) ?? 0
-
-	else switch (expression[0]) {
-		case "delta":
-			return e(expression[1])
-
-		case "pulse": {
-			const [, code] = expression
-			const sample = context.currentSample
-			return (sample?.code === code)
-				? sample.value
-				: 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(id)
-			return context.currentSample === null
-				? context.dt
-				: 0
-		}
-
-		case "held": {
-			context.holdyRoots.add(id)
-
-			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/lib4/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/lib4/input/investigate/hash-bindings.ts

@@ -1,22 +0,0 @@
-
-import {hash32} from "@e280/stz"
-import {Bindings} from "../types.js"
-import {isRootExpression} from "./is.js"
-
-export function hashBindings(bindings: Bindings) {
-	const paths: string[] = []
-
-	function recurse(b: Bindings, path: string[]) {
-		if (isRootExpression(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/lib4/input/investigate/investigate.ts

@@ -1,37 +0,0 @@
-
-import {obMap} from "@e280/stz"
-import {isRootExpression} from "./is.js"
-import {makeInput} from "./make-input.js"
-import {hashBindings} from "./hash-bindings.js"
-import {makeRootIndex as makeRootIndex} from "./root-index.js"
-import {Bindings, Input, Inputs, RootExpression} from "../types.js"
-
-export function investigate<B extends Bindings>(bindings: B) {
-	const hash = hashBindings(bindings)
-	const inputList: Input[] = []
-	const rootList: RootExpression[] = []
-
-	function makeInputs(b: Bindings): unknown {
-		if (isRootExpression(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)
-
-	return {
-		hash,
-		inputs,
-		inputList,
-		rootList,
-		rootIndex,
-	}
-}
-

package/s/_archive/lib4/input/investigate/is.ts

@@ -1,19 +0,0 @@
-
-import {isArray, isNumber, isString} from "@e280/stz"
-import {Bindings, Expression, RootExpression} from "../types.js"
-
-export function isRootExpression(b: Bindings): b is RootExpression {
-	if (isString(b)) return true
-	if (isNumber(b)) return true
-	if (isArray(b)) return true
-	return false
-}
-
-export function isDeltaRoot(root: RootExpression) {
-	return isArray(root) && root[0] === "delta"
-}
-
-export function isExpression(b: Bindings): b is Expression {
-	return isRootExpression(b) && !isDeltaRoot(b)
-}
-

package/s/_archive/lib4/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/lib4/input/investigate/root-index.ts

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

package/s/_archive/lib4/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})
-		}
-	}
-
-	#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/lib4/input/sources/keyboard.ts

@@ -1,46 +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))
-	}
-
-	#targetListeners = {
-		keydown: (event: KeyboardEvent) => {
-			if (event.repeat) return
-
-			if (this.#down.size === 0)
-				this.onSample.publish({code: "keyboard.any", value: 1})
-
-			this.onSample.publish({code: event.code, value: 1})
-			this.#down.add(event.code)
-		},
-
-		keyup: (event: KeyboardEvent) => {
-			this.onSample.publish({code: event.code, value: 0})
-			this.#down.delete(event.code)
-
-			if (this.#down.size === 0)
-				this.onSample.publish({code: "keyboard.any", value: 0})
-		},
-	}
-
-	#windowListeners = {
-		blur: () => {
-			for (const code of this.#down)
-				this.onSample.publish({code: code, value: 0})
-
-			if (this.#down.size)
-				this.onSample.publish({code: "keyboard.any", value: 0})
-
-			this.#down.clear()
-		},
-	}
-}
-

package/s/_archive/lib4/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()
-}
-

package/s/_archive/lib4/input/sources/pointer.ts

@@ -1,50 +0,0 @@
-
-import {ev} from "@e280/stz"
-import {Vec2} from "@benev/math"
-import {PlainSource} from "./plain.js"
-import {splitAxis} from "../utils/split-axis.js"
-import {mouseButton} from "../utils/mouse-button.js"
-
-export class PointerSource extends PlainSource {
-	client = new Vec2()
-
-	constructor(target: EventTarget = window) {
-		super()
-		this.dispose.schedule(
-			ev(target, this.#listeners)
-		)
-	}
-
-	#listeners = {
-		pointerdown: (event: PointerEvent) => {
-			this.onSample.publish({code: mouseButton(event.button), value: 1})
-		},
-
-		pointerup: (event: PointerEvent) => {
-			this.onSample.publish({code: mouseButton(event.button), value: 0})
-		},
-
-		pointermove: (event: PointerEvent) => {
-			this.client.set_(event.clientX, event.clientY)
-
-			const [right, left] = splitAxis(event.movementX)
-			const [down, up] = splitAxis(event.movementY)
-
-			if (left) this.onSample.publish({code: "pointer.move.left", value: left})
-			if (right) this.onSample.publish({code: "pointer.move.right", value: right})
-			if (up) this.onSample.publish({code: "pointer.move.up", value: up})
-			if (down) this.onSample.publish({code: "pointer.move.down", value: down})
-		},
-
-		wheel: (event: WheelEvent) => {
-			const [right, left] = splitAxis(event.deltaX)
-			const [down, up] = splitAxis(event.deltaY)
-
-			if (left) this.onSample.publish({code: "pointer.wheel.left", value: left})
-			if (right) this.onSample.publish({code: "pointer.wheel.right", value: right})
-			if (up) this.onSample.publish({code: "pointer.wheel.up", value: up})
-			if (down) this.onSample.publish({code: "pointer.wheel.down", value: down})
-		},
-	}
-}
-

package/s/_archive/lib4/input/sources/sources.ts

@@ -1,24 +0,0 @@
-
-import {Source} from "../types.js"
-import {PlainSource} from "./plain.js"
-
-export class Sources extends PlainSource {
-	#array
-
-	constructor(...sources: Source[]) {
-		super()
-
-		this.#array = sources
-
-		for (const source of sources)
-			this.dispose.schedule(
-				source.onSample(sample => this.onSample.publish(sample))
-			)
-	}
-
-	poll() {
-		for (const source of this.#array)
-			source.poll?.()
-	}
-}
-

package/s/_archive/lib4/input/sources/stick.ts

@@ -1,25 +0,0 @@
-
-import {Vec2, Xy} from "@benev/math"
-import {Sample} from "../types.js"
-import {PlainSource} from "./plain.js"
-import {splitVector} from "../utils/split-axis.js"
-
-export class StickSource extends PlainSource {
-	samples: Sample[] = []
-	vector = Vec2.zero()
-
-	constructor(public channel = "stick") {
-		super()
-	}
-
-	set(vector: Xy) {
-		this.vector.set_(vector.x, vector.y)
-		const {up, down, left, right} = splitVector(this.vector)
-		this.onSample.publish({code: `${this.channel}.up`, value: up})
-		this.onSample.publish({code: `${this.channel}.down`, value: down})
-		this.onSample.publish({code: `${this.channel}.left`, value: left})
-		this.onSample.publish({code: `${this.channel}.right`, value: right})
-		return this
-	}
-}
-

package/s/_archive/lib4/input/types.ts

@@ -1,102 +0,0 @@
-
-export type Sample = {
-	code: string
-	value: number
-}
-
-export type Source = {
-	readonly onSample: (fn: (sample: Sample) => void) => () => void
-	readonly dispose: () => void
-	readonly poll?: () => void
-}
-
-export type Intent = {id: number, value: number}
-
-export type InputData = ArrayBuffer
-
-export type Input = {
-
-	/** latest-known value. */
-	value: number
-
-	/** previously-known value. */
-	was: number
-
-	/** sum of values in batch. */
-	pulses: number
-
-	/** number of times this value has changed in this batch. */
-	change: number
-
-	/** number of changes to up in this batch. */
-	up: number
-
-	/** number of changes to down in this batch. */
-	down: number
-
-	/** lowest value in batch. */
-	lowest: number | null
-
-	/** highest value in batch. */
-	highest: number | null
-}
-
-export type Inputs<B extends Bindings = any> = (
-	B extends Expression
-		? Input
-		: B extends {[key: string]: Bindings}
-			? {[K in keyof B]: Inputs<B[K]>}
-			: never
-)
-
-export type Bindings = RootExpression | {
-	[key: string]: Bindings
-}
-
-export const asBindings = <B extends Bindings>(bindings: B) => (bindings as any as Rebindings<B>)
-
-export type Rebindings<B extends Bindings> = (
-	B extends Expression
-		? Expression
-		: B extends {[key: string]: Bindings}
-			? {[K in keyof B]: Rebindings<B[K]>}
-			: never
-)
-
-export type RootExpression =
-	| ["delta", Expression] // values represent an amount of change, every event is respected.
-	| Expression // values represent final state, non-changes are discarded.
-
-export type Expression = (
-	| number // constants for doing math.
-	| string // use last-known sample value for a code like "KeyW", "pointer.move.up".
-
-	// special
-	| ["pulse", string] // use current sample's value, or zero.
-
-	// combiners
-	| ["min", ...Expression[]]
-	| ["max", ...Expression[]]
-	| ["+", ...(Expression | number)[]]
-	| ["*", ...(Expression | number)[]]
-
-	// comparisons
-	| ["==", Expression, Expression]
-	| ["!=", Expression, Expression]
-	| [">", Expression, Expression]
-	| ["<", Expression, Expression]
-	| [">=", Expression, Expression]
-	| ["<=", Expression, Expression]
-
-	// transforms
-	| ["!", Expression]
-	| ["!!", Expression]
-	| ["clamp", low: Expression | null, high: Expression | null, Expression]
-	| ["remap", inLow: Expression, inHigh: Expression, outLow: Expression, outHigh: Expression, Expression]
-
-	// temporal
-	| ["dt"] // delta time in seconds since last resolve, used for stick sensitivity
-	| ["taps", taps: number, ms: number, Expression]
-	| ["held", ms: number, Expression]
-)
-

package/s/_archive/lib4/input/utils/evergreen.ts

@@ -1,10 +0,0 @@
-
-export function evergreen<V>(value: V, fn: () => V | null | undefined) {
-	let cached = value
-	return () => {
-		const next = fn()
-		if (next !== undefined && next !== null) cached = next
-		return cached
-	}
-}
-

package/s/_archive/lib4/input/utils/is-down.ts

@@ -1,5 +0,0 @@
-
-export function isDown(value: number) {
-	return value !== 0
-}
-

package/s/_archive/lib4/input/utils/mouse-button.ts

@@ -1,10 +0,0 @@
-
-export function mouseButton(button: number) {
-	switch (button) {
-		case 0: return "pointer.button.left"
-		case 1: return "pointer.button.middle"
-		case 2: return "pointer.button.right"
-		default: return `pointer.button.${button + 1}`
-	}
-}
-

package/s/_archive/lib4/input/utils/pad/on-pad.ts

@@ -1,50 +0,0 @@
-
-import {ev} from "@e280/stz"
-import {Pad} from "./pad.js"
-import {evergreen} from "../../utils/evergreen.js"
-
-/** listen for gamepads coming and going */
-export function onPad(fn: (pad: Pad) => () => void) {
-	const known = new Map<number, {pad: Pad, dispose: () => void}>()
-
-	function refresh() {
-		addNew()
-		deleteOld()
-	}
-
-	function addNew() {
-		for (const gamepad of navigator.getGamepads()) {
-			if (gamepad?.connected && !known.has(gamepad.index)) {
-				const get = () => navigator.getGamepads()[gamepad.index]
-				const pad = new Pad(evergreen(gamepad, get))
-				const dispose = fn(pad)
-				known.set(gamepad.index, {pad, dispose})
-			}
-		}
-	}
-
-	function deleteOld() {
-		for (const [index, {pad, dispose}] of known) {
-			const gamepad = navigator.getGamepads()[pad.gamepad.index]
-			if (!gamepad?.connected) {
-				dispose()
-				known.delete(index)
-			}
-		}
-	}
-
-	refresh()
-
-	const unlisten = ev(window, {
-		gamepadconnected: refresh,
-		gamepaddisconnected: refresh,
-	})
-
-	return () => {
-		unlisten()
-		for (const {dispose} of known.values())
-			dispose()
-		known.clear()
-	}
-}
-