@benev/tact 0.4.0-0 → 0.4.0-10

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

@@ -1,10 +0,0 @@
-
-/** stable reference to a gamepad, has a getter to get the latest gamepad snapshot */
-export class Pad {
-	constructor(private get: () => Gamepad) {}
-
-	get gamepad() {
-		return this.get()
-	}
-}
-

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

@@ -1,28 +0,0 @@
-
-import {arraylimit} from "@e280/stz"
-import {Sample, Source} from "../types.js"
-
-const limit = 1024
-
-export class Sampler {
-	readonly dispose
-	#source
-	#samples: Sample[] = []
-
-	constructor(source: Source) {
-		this.#source = source
-		this.dispose = source.onSample(sample => {
-			this.#samples.push(sample)
-			if (this.#samples.length > limit) console.warn(`tact sampler exceeded limit ${limit}`)
-			this.#samples = arraylimit(this.#samples, limit)
-		})
-	}
-
-	take() {
-		this.#source.poll?.()
-		const samples = this.#samples
-		this.#samples = []
-		return samples
-	}
-}
-

package/s/_archive/lib4/input/utils/split-axis.ts

@@ -1,15 +0,0 @@
-
-import {Xy} from "@benev/math"
-
-export function splitAxis(n: number) {
-	return (n >= 0)
-		? [n, 0]
-		: [0, Math.abs(n)]
-}
-
-export function splitVector(vector: Xy) {
-	const [right, left] = splitAxis(vector.x)
-	const [down, up] = splitAxis(vector.y)
-	return {up, down, left, right}
-}
-

package/s/_archive/lib4/test.ts

@@ -1,12 +0,0 @@
-
-import {expect, run, suite, test} from "@e280/science"
-
-await run({
-	input: suite({
-		"roundtrip": test(async() => {
-			//...
-			expect(true).ok()
-		}),
-	}),
-})
-

package/s/_archive/test.ts

@@ -1,339 +0,0 @@
-
-import {need} from "@e280/stz"
-import {distance} from "@benev/math"
-import {science, suite, test, expect} from "@e280/science"
-
-import {asBindings, Intent} from "./core/types.js"
-import {encodeIntents} from "./core/intent/encode.js"
-import {decodeIntents} from "./core/intent/decode.js"
-import {bindingsShape} from "./core/bindings/shape.js"
-import {bindingsTable} from "./core/bindings/table.js"
-import {normalizeBindings} from "./core/bindings/normalize.js"
-import {makeIntentsResolver} from "./core/resolvers/intents.js"
-import {makeActionsResolver} from "./core/resolvers/actions.js"
-
-export const exampleBindings = asBindings({
-	running: {forward: "KeyW", jump: ["and", "ShiftLeft", "Space"]},
-	gunning: {shoot: ["or", "pointer.button.left", "gamepad.trigger.right"]},
-})
-
-await science.run({
-	bindings: suite({
-		"shape": test(async() => {
-			expect(bindingsShape(exampleBindings).running.forward).ok()
-		}),
-
-		"table actions": test(async() => {
-			expect(need(bindingsTable(exampleBindings), 0).action).is("shoot")
-			expect(need(bindingsTable(exampleBindings), 1).action).deep("forward")
-			expect(need(bindingsTable(exampleBindings), 2).action).deep("jump")
-		}),
-
-		"table consistent ordering, mode": test(async() => {
-			for (const b of [
-				bindingsTable({alpha: {x: "KeyX"}, bravo: {x: "KeyX"}}),
-				bindingsTable({bravo: {x: "KeyX"}, alpha: {x: "KeyX"}}),
-			]) expect(need(b, 0).mode).deep("alpha")
-		}),
-
-		"table consistent ordering, action": test(async() => {
-			for (const b of [
-				bindingsTable({x: {alpha: "KeyA", bravo: "KeyB"}}),
-				bindingsTable({x: {bravo: "KeyB", alpha: "KeyA"}}),
-			]) expect(need(b, 0).action).deep("alpha")
-		}),
-
-		normalize: {
-			"adopts atom": test(async() => {
-				const standard = {a: {b: "KeyQ"}}
-				expect(normalizeBindings(standard, {a: {b: "KeyW"}}).a.b).is("KeyW")
-			}),
-
-			"excludes excess action": test(async() => {
-				const standard = {a: {b: "KeyQ"}}
-				expect("c" in normalizeBindings(standard, {a: {b: "KeyQ", c: "KeyW"}}).a).is(false)
-			}),
-
-			"excludes excess bracket": test(async() => {
-				const standard = {a: {b: "KeyQ"}}
-				expect("c" in normalizeBindings(standard, {a: {b: "KeyQ"}, c: {d: "KeyW"}})).is(false)
-			}),
-
-			"falls back on standard atom": test(async() => {
-				const standard = {a: {b: "KeyQ"}}
-				expect(normalizeBindings(standard, {a: {}}).a.b).is("KeyQ")
-			}),
-
-			"falls back on standard bracket": test(async() => {
-				const standard = {a: {b: "KeyQ"}}
-				expect(normalizeBindings(standard, {}).a.b).is("KeyQ")
-			}),
-
-			"complex fallback": test(async() => {
-				const standard = {a: {b: "KeyQ"}, c: {d: "KeyW"}}
-				expect(normalizeBindings(standard, {c: {d: "KeyE"}}).a.b).is("KeyQ")
-				expect(normalizeBindings(standard, {c: {d: "KeyE"}}).c.d).is("KeyE")
-			}),
-		},
-	}),
-
-	intents: suite({
-		"encoded roundtrip": test(async() => {
-			const intentsA: Intent[] = [[0, 0], [1, 1]]
-			const bytes = encodeIntents(intentsA)
-			const intentsB = decodeIntents(bytes)
-			expect(intentsB).deep(intentsA)
-		}),
-
-		"encoded six bytes": test(async() => {
-			const bytesA = encodeIntents([[0, 0]])
-			const bytesB = encodeIntents([[25, 0.7853981633974483]])
-			expect(bytesA.length).is(6)
-			expect(bytesB.length).is(6)
-		}),
-
-		"encoded float precision is acceptable": test(async() => {
-			const target = Math.PI / 4
-			const bytes = encodeIntents([[25, target]])
-			const [[,suspect]] = decodeIntents(bytes)
-			expect(distance(suspect, target) < (1 / 1_000_000)).is(true)
-		}),
-
-		"encoded billion": test(async() => {
-			const target = 1_000_000_000
-			const bytes = encodeIntents([[25, target]])
-			const [[,suspect]] = decodeIntents(bytes)
-			expect(suspect).is(target)
-		}),
-
-		"encoded negative billion": test(async() => {
-			const target = -1_000_000_000
-			const bytes = encodeIntents([[25, target]])
-			const [[,suspect]] = decodeIntents(bytes)
-			expect(suspect).is(target)
-		}),
-	}),
-
-	intentsResolver: suite({
-		"resolve samples to intents": test(async() => {
-			const resolveIntents = makeIntentsResolver(exampleBindings)
-			const intents = resolveIntents(0, [["KeyW", 1]])
-			expect(intents).deep([[1, 1]])
-		}),
-	}),
-
-	actionsResolver: suite({
-		"resolve intents to actions": test(async() => {
-			const resolveActions = makeActionsResolver(exampleBindings)
-			const actions = resolveActions([[1, 1]])
-			expect(actions.running.forward.value).is(1)
-			expect(actions.running.forward.down).is(true)
-			expect(actions.running.forward.changed).is(true)
-		}),
-
-		"changing actions over time": test(async() => {
-			const resolveActions = makeActionsResolver(exampleBindings)
-			const actions = resolveActions([])
-
-			resolveActions([[1, 0]])
-			expect(actions.running.forward.value).is(0)
-			expect(actions.running.forward.down).is(false)
-			expect(actions.running.forward.changed).is(false)
-			expect(actions.running.forward.changedDown).is(false)
-			expect(actions.running.forward.changedUp).is(false)
-
-			resolveActions([[1, 1]])
-			expect(actions.running.forward.value).is(1)
-			expect(actions.running.forward.down).is(true)
-			expect(actions.running.forward.changed).is(true)
-			expect(actions.running.forward.changedDown).is(true)
-			expect(actions.running.forward.changedUp).is(false)
-
-			resolveActions([[1, 1]])
-			expect(actions.running.forward.value).is(1)
-			expect(actions.running.forward.down).is(true)
-			expect(actions.running.forward.changed).is(false)
-			expect(actions.running.forward.changedDown).is(false)
-			expect(actions.running.forward.changedUp).is(false)
-
-			resolveActions([[1, 0]])
-			expect(actions.running.forward.value).is(0)
-			expect(actions.running.forward.down).is(false)
-			expect(actions.running.forward.changed).is(true)
-			expect(actions.running.forward.changedDown).is(false)
-			expect(actions.running.forward.changedUp).is(true)
-		}),
-
-		"changed expires with empty intents": test(async() => {
-			const resolveActions = makeActionsResolver(exampleBindings)
-			const actions = resolveActions([])
-
-			resolveActions([[1, 0]])
-			expect(actions.running.forward.value).is(0)
-			expect(actions.running.forward.down).is(false)
-			expect(actions.running.forward.changed).is(false)
-			expect(actions.running.forward.changedDown).is(false)
-			expect(actions.running.forward.changedUp).is(false)
-
-			resolveActions([[1, 1]])
-			expect(actions.running.forward.value).is(1)
-			expect(actions.running.forward.down).is(true)
-			expect(actions.running.forward.changed).is(true)
-			expect(actions.running.forward.changedDown).is(true)
-			expect(actions.running.forward.changedUp).is(false)
-
-			resolveActions([])
-			expect(actions.running.forward.value).is(1)
-			expect(actions.running.forward.down).is(true)
-			expect(actions.running.forward.changed).is(false)
-			expect(actions.running.forward.changedDown).is(false)
-			expect(actions.running.forward.changedUp).is(false)
-		}),
-	}),
-
-	"dynamics": {
-		"just tapping": test(async() => {
-			const bindings = asBindings({
-				alpha: {
-					tapper: ["code", "KeyE", {timing: ["tap", 10]}],
-				},
-			})
-			const resolveIntents = makeIntentsResolver(bindings)
-			const resolveActions = makeActionsResolver(bindings)
-			{
-				const intents = resolveIntents(0, [["KeyE", 0]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(false)
-			}
-			{
-				const intents = resolveIntents(1, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(false)
-			}
-			{
-				const intents = resolveIntents(2, [["KeyE", 0]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(true)
-			}
-		}),
-
-		"just holding": test(async() => {
-			const bindings = asBindings({
-				alpha: {
-					holder: ["code", "KeyE", {timing: ["hold", 10]}],
-				},
-			})
-			const resolveIntents = makeIntentsResolver(bindings)
-			const resolveActions = makeActionsResolver(bindings)
-			{
-				const intents = resolveIntents(0, [["KeyE", 0]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.holder.down).is(false)
-			}
-			{
-				const intents = resolveIntents(1, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.holder.down).is(false)
-			}
-			{
-				const intents = resolveIntents(11, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.holder.down).is(true)
-			}
-		}),
-
-		"tapper works while holder exists": test.skip(async() => {
-			const bindings = asBindings({
-				alpha: {
-					tapper: ["code", "KeyE", {timing: ["tap", 10]}],
-					holder: ["code", "KeyE", {timing: ["hold", 10]}],
-				},
-			})
-			const resolveIntents = makeIntentsResolver(bindings)
-			const resolveActions = makeActionsResolver(bindings)
-			{
-				const intents = resolveIntents(0, [["KeyE", 0]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(false)
-			}
-			{
-				const intents = resolveIntents(1, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(false)
-			}
-			{
-				const intents = resolveIntents(2, [["KeyE", 0]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(true)
-			}
-		}),
-
-		"holder works while tapper exists": test(async() => {
-			const bindings = asBindings({
-				alpha: {
-					tapper: ["code", "KeyE", {timing: ["tap", 10]}],
-					holder: ["code", "KeyE", {timing: ["hold", 10]}],
-				},
-			})
-			const resolveIntents = makeIntentsResolver(bindings)
-			const resolveActions = makeActionsResolver(bindings)
-			{
-				const intents = resolveIntents(0, [["KeyE", 0]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.holder.down).is(false)
-			}
-			{
-				const intents = resolveIntents(1, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.holder.down).is(false)
-			}
-			{
-				const intents = resolveIntents(11, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.holder.down).is(true)
-			}
-		}),
-
-		"tapper and holder both work together": test.skip(async() => {
-			const bindings = asBindings({
-				alpha: {
-					tapper: ["code", "KeyE", {timing: ["tap", 10]}],
-					holder: ["code", "KeyE", {timing: ["hold", 10]}],
-				},
-			})
-			const resolveIntents = makeIntentsResolver(bindings)
-			const resolveActions = makeActionsResolver(bindings)
-			{
-				const intents = resolveIntents(0, [["KeyE", 0]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(false)
-				expect(actions.alpha.holder.down).is(false)
-			}
-			{
-				const intents = resolveIntents(1, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(false)
-				expect(actions.alpha.holder.down).is(false)
-			}
-			{
-				const intents = resolveIntents(2, [["KeyE", 0]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(true)
-				expect(actions.alpha.holder.down).is(false)
-			}
-			{
-				const intents = resolveIntents(3, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(false)
-				expect(actions.alpha.holder.down).is(false)
-			}
-			{
-				const intents = resolveIntents(13, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(false)
-				expect(actions.alpha.holder.down).is(true)
-			}
-		}),
-	},
-})
-

package/s/_archive/ui/views/desk/style.css.ts

@@ -1,70 +0,0 @@
-
-import {css} from "lit"
-export default css`
-
-.deck {
-	display: flex;
-	flex-direction: column;
-	gap: 0.5em;
-
-	> div {
-		display: flex;
-		flex-wrap: wrap;
-		gap: 0.5em;
-	}
-}
-
-.port {
-	background: grey;
-	width: 16em;
-	max-width: 100%;
-
-	header {
-		display: flex;
-		padding: 0.5em;
-
-		> span {
-			flex: 1 1 auto;
-			font-weight: bold;
-		}
-	}
-
-	strong {
-		display: block;
-		width: 100%;
-		padding: 0.2em;
-	}
-
-	.controllerlist {
-		display: flex;
-		flex-direction: column;
-		padding: 0.5em;
-		gap: 0.5em;
-	}
-}
-
-.controller {
-	display: flex;
-	flex-direction: column;
-	background: green;
-	padding: 0.5em;
-	gap: 0.5em;
-
-	.buttons {
-		display: flex;
-		flex-wrap: wrap;
-		justify-content: space-between;
-
-		> div {
-			display: flex;
-			flex-wrap: wrap;
-		}
-	}
-}
-
-button[disabled] {
-	opacity: 0.2;
-}
-
-`
-

package/s/_archive/ui/views/desk/view.ts

@@ -1,122 +0,0 @@
-
-import {html} from "lit"
-import {clamp} from "@benev/math"
-import {Content, shadow, useCss, useName} from "@e280/sly"
-
-import styleCss from "./style.css.js"
-import {Deck} from "../../../deck/deck.js"
-import {Port} from "../../../deck/port.js"
-import {Controller} from "../../../deck/controller.js"
-
-export type DeskOptions = {
-	getControllerLabel?: (controller: Controller) => Content | undefined
-}
-
-export const DeskView = shadow((deck: Deck, options: DeskOptions = {}) => {
-	useName("desk")
-	useCss(styleCss)
-
-	function shimmy(controller: Controller, offset: number) {
-		const ports = deck.ports
-		const info = deck.queryController(controller)
-		const portIndex = ports.indexOf(info.port!)
-		const newIndex = clamp(portIndex + offset, 0, ports.length - 1)
-		const newPort = ports.at(newIndex)
-		if (newPort)
-			newPort.plug(controller)
-	}
-
-	function PortView(port: Port, portIndex: number) {
-		return html`
-			<div class=port>
-				<header>
-					<span>P${portIndex + 1}</span>
-					<div class=buttons>
-						<button @click=${() => deck.deletePort(port)}>🚫</button>
-					</div>
-				</header>
-				<div class=controllerlist>
-					${port.controllers.map(ControllerView)}
-				</div>
-			</div>
-		`
-	}
-
-	function UnassignedView(controllers: Controller[]) {
-		return html`
-			<div class=port>
-				<header>
-					<span>unassigned</span>
-				</header>
-				<div class=controllerlist>
-					${controllers.map(ControllerView)}
-				</div>
-			</div>
-		`
-	}
-
-
-	function ControllerView(controller: Controller) {
-		const {port, profileKey} = deck.queryController(controller)
-
-		async function onChange(event: Event) {
-			const element = event.currentTarget as HTMLSelectElement
-			const profileKey = element.value
-			await deck.assignControllerProfile(controller, profileKey)
-		}
-
-		function plugIn(controller: Controller) {
-			const p1 = deck.ports.at(0) ?? deck.createPort()
-			p1.plug(controller)
-		}
-
-		return html`
-			<div class=controller>
-				<span>${options.getControllerLabel?.(controller) ?? controller.handle}</span>
-
-				<div class=buttons>
-					<div>
-						${port
-							? html`
-								<button @click=${() => shimmy(controller, -1)} ?disabled=${deck.ports.indexOf(port) === 0}>👈</button>
-								<button @click=${() => port.unplug(controller)}>⏏️</button>
-								<button @click=${() => shimmy(controller, 1)} ?disabled=${deck.ports.indexOf(port) === (deck.ports.length - 1)}>👉</button>
-							`
-							: html`
-								<button @click=${() => plugIn(controller)}>🔌</button>
-							`}
-					</div>
-					<select @change=${onChange}>
-						${deck.profiles.all.map(([pk, profile]) => html`
-							<option
-								.value=${pk}
-								.selected=${pk === profileKey}>
-								${profile.label}
-							</option>
-						`)}
-					</select>
-				</div>
-			</div>
-		`
-	}
-
-	const {unassignedControllers} = deck
-
-	return html`
-		<div class=deck>
-			<div>
-				${deck.ports.map(PortView)}
-				<div>
-					<button @click=${() => deck.createPort()}>✨add port</button>
-				</div>
-			</div>
-
-			<div>
-				${unassignedControllers.length > 0
-					? UnassignedView(unassignedControllers)
-					: null}
-			</div>
-		</div>
-	`
-})
-

package/s/_archive/utils/circular-clamp.ts

@@ -1,14 +0,0 @@
-
-import {remap, Vec2, Xy} from "@benev/math"
-
-export function circularClamp(vector: Xy, range: Vec2) {
-	const v = Vec2.from(vector)
-	const distance = v.distance_(0, 0)
-	const modifiedDistance = remap(
-		distance,
-		range.x, range.y,
-		0, 1,
-		true,
-	)
-	return v.normalize().mulBy(modifiedDistance)
-}

package/s/_archive/utils/do-async.ts

@@ -1,5 +0,0 @@
-
-export async function doAsync<Ret>(fn: () => Promise<Ret>) {
-	return fn()
-}
-

package/s/_archive/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/utils/freeze-clone.ts

@@ -1,7 +0,0 @@
-
-import {deep} from "@e280/stz"
-
-export function freezeClone<X>(x: X): X {
-	return deep.freeze(deep.clone(x))
-}
-

package/s/_archive/utils/identifier.ts

@@ -1,30 +0,0 @@
-
-import {guarantee, is, need} from "@e280/stz"
-
-export class Identifier<Item> {
-	#nextId = 0
-	#ids = new Map<Item, number>()
-	#items = new Map<number, Item>()
-
-	id(item: Item) {
-		const id = guarantee(this.#ids, item, () => {
-			const freshId = this.#nextId++
-			this.#items.set(freshId, item)
-			return freshId
-		})
-		return id
-	}
-
-	need(id: number) {
-		return need(this.#items, id)
-	}
-
-	delete(item: Item) {
-		const id = this.#ids.get(item)
-		if (is.happy(id)) {
-			this.#ids.delete(item)
-			this.#items.delete(id)
-		}
-	}
-}
-

package/s/_archive/utils/insert.ts

@@ -1,6 +0,0 @@
-
-export function insert<K, V>(map: Map<K, V>, entries: [K, V][]) {
-	for (const [key, value] of entries)
-		map.set(key, value)
-}
-

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

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

package/s/_archive/utils/remap.ts

@@ -1,7 +0,0 @@
-
-export function remap<K, V>(entries: [K, V][], fn?: (map: Map<K, V>) => void) {
-	const map = new Map(entries)
-	fn?.(map)
-	return [...map.entries()]
-}
-