@benev/tact 0.4.0-0 → 0.4.0-10

package/s/_archive/core/intent/decode.ts

@@ -1,23 +0,0 @@
-
-import {dataViewFrom} from "@e280/stz"
-import {Intent} from "../types.js"
-import {littleEndian, size} from "./consts.js"
-
-/** decode intents from compact binary format */
-export function decodeIntents(bytes: Uint8Array) {
-	const n = bytes.byteLength / size
-	if (!Number.isInteger(n)) throw new Error("invalid bytes length")
-
-	const data = dataViewFrom(bytes)
-	const intents: Intent[] = new Array<Intent>(n)
-
-	for (let i = 0; i < n; i++) {
-		const offset = i * size
-		const index = data.getUint16(offset, littleEndian)
-		const value = data.getFloat32(offset + 2, littleEndian)
-		intents[i] = [index, value]
-	}
-
-	return intents
-}
-

package/s/_archive/core/intent/encode.ts

@@ -1,20 +0,0 @@
-
-import {Intent} from "../types.js"
-import {littleEndian, size} from "./consts.js"
-
-/** encode intents into compact binary format (good for networking) */
-export function encodeIntents(intents: Intent[]) {
-	const length = intents.length * size
-	const buffer = new ArrayBuffer(length)
-	const view = new DataView(buffer)
-
-	for (let i = 0; i < intents.length; i++) {
-		const [index, value] = intents[i]
-		const offset = i * size
-		view.setUint16(offset, index, littleEndian)
-		view.setFloat32(offset + 2, value, littleEndian)
-	}
-
-	return new Uint8Array(buffer)
-}
-

package/s/_archive/core/intent/merge.ts

@@ -1,15 +0,0 @@
-
-import {Intent} from "../types.js"
-
-/** merge multiple sources of intents together */
-export function mergeIntents(intents: Intent[]): Intent[] {
-	const map = new Map<number, number>()
-
-	for (const [id, value] of intents) {
-		const previous = map.get(id) ?? 0
-		map.set(id, Math.max(previous, value))
-	}
-
-	return [...map.entries()]
-}
-

package/s/_archive/core/parts/action.ts

@@ -1,36 +0,0 @@
-
-import {sub} from "@e280/stz"
-import {isDown} from "../../utils/is-down.js"
-
-export class Action {
-	on = sub<[Action]>()
-	onUp = sub<[Action]>()
-	onDown = sub<[Action]>()
-
-	#value = 0
-	#previous = 0
-
-	changed = false
-
-	get value() {
-		return this.#value
-	}
-
-	set value(v: number) {
-		this.#previous = this.#value
-		this.#value = v
-
-		if (this.changed) {
-			this.on.publish(this)
-			if (this.up) this.onUp.publish(this)
-			else this.onDown.publish(this)
-		}
-	}
-
-	get previous() { return this.#previous }
-	get up() { return !isDown(this.#value) }
-	get down() { return isDown(this.#value) }
-	get changedUp() { return this.changed && this.up }
-	get changedDown() { return this.changed && this.down }
-}
-

package/s/_archive/core/parts/sample-map.ts

@@ -1,24 +0,0 @@
-
-import {Sample} from "../types.js"
-
-export class SampleMap extends Map<string, number> {
-	constructor(samples?: Iterable<Sample>) {
-		super()
-		if (samples) {
-			for (const [code, value] of samples)
-				this.set(code, value)
-		}
-	}
-
-	zero() {
-		for (const code of this.keys()) this.set(code, 0)
-		return this
-	}
-
-	merge([code, value]: Sample) {
-		const previous = this.get(code) ?? 0
-		if (value > previous) this.set(code, value)
-		return this
-	}
-}
-

package/s/_archive/core/resolvers/actions.ts

@@ -1,30 +0,0 @@
-
-import {need, obMap} from "@e280/stz"
-import {Action} from "../parts/action.js"
-import {bindingsShape} from "../bindings/shape.js"
-import {Actions, Bindings, Intent} from "../types.js"
-
-export function makeActionsResolver<B extends Bindings>(bindings: B) {
-	const shape = bindingsShape(bindings)
-	const map = new Map<number, Action>()
-
-	const actions = obMap(shape, bracket => obMap(bracket, id => {
-		const action = new Action()
-		map.set(id, action)
-		return action
-	})) as Actions<B>
-
-	return (intents: Intent[]) => {
-		for (const action of map.values())
-			action.changed = false
-
-		for (const [id, value] of intents) {
-			const action = need(map, id)
-			action.changed = action.value !== value
-			action.value = value
-		}
-
-		return actions
-	}
-}
-

package/s/_archive/core/resolvers/intents.ts

@@ -1,106 +0,0 @@
-
-import {guarantee} from "@e280/stz"
-import {tmax} from "../../utils/tmax.js"
-import {tmin} from "../../utils/tmin.js"
-import {lensAlgo} from "../atom/lens-algo.js"
-import {SampleMap} from "../parts/sample-map.js"
-import {bindingsTable} from "../bindings/table.js"
-import {defaultCodeState} from "../atom/defaults.js"
-import {Bindings, Sample, Intent} from "../types.js"
-import {Atom, CodeSettings, CodeState} from "../atom/types.js"
-
-export function makeIntentsResolver<B extends Bindings>(bindings: B) {
-	const table = bindingsTable(bindings)
-	const sampleMap = new SampleMap()
-	const codeStates = new Map<string, CodeState>()
-	const intentMap = new Map<number, number>()
-
-	for (const bind of table.values())
-		intentMap.set(bind.id, 0)
-
-	const resolveCode = (now: number, path: string[], code: string, settings?: Partial<CodeSettings>) => {
-		const state = guarantee(
-			codeStates,
-			path.join("/"),
-			() => defaultCodeState(["code", code, settings], now),
-		)
-		const value = sampleMap.get(code) ?? 0
-		return lensAlgo(now, state, value)
-	}
-
-	const resolveAtomForPath = (now: number, path: string[]) => (atom: Atom, zone: string | number): number => {
-		const nextPath = [
-			...path,
-			String(zone),
-			typeof atom === "string" ? atom : atom[0],
-		]
-
-		const resolveAtom = resolveAtomForPath(now, nextPath)
-
-		if (typeof atom === "string")
-			return resolveCode(now, nextPath, atom)
-
-		else switch (atom[0]) {
-			case "code": {
-				const [, code, settings] = atom
-				return resolveCode(now, nextPath, code, settings)
-			}
-			case "and": {
-				const [,...atoms] = atom
-				const values = atoms.map(resolveAtom)
-				return tmin(values)
-			}
-			case "or": {
-				const [,...atoms] = atom
-				const values = atoms.map(resolveAtom)
-				return tmax(values)
-			}
-			case "not": {
-				const [, subject] = atom
-				const value = resolveAtom(subject, "subject")
-				return (value > 0) ? 0 : 1
-			}
-			case "cond": {
-				const [, subject, guard] = atom
-				return (resolveAtom(guard, "guard") > 0)
-					? resolveAtom(subject, "subject")
-					: 0
-			}
-			case "mods": {
-				const [, subject, modifiers] = atom
-				const maybe = (x: boolean, ...codes: Atom[]): Atom => x
-					? ["or", ...codes]
-					: ["not", ["or", ...codes]]
-				const guard = resolveAtom(["cond", subject, ["and",
-					maybe(modifiers.ctrl ?? false, "ControlLeft", "ControlRight"),
-					maybe(modifiers.alt ?? false, "AltLeft", "AltRight"),
-					maybe(modifiers.meta ?? false, "MetaLeft", "MetaRight"),
-					maybe(modifiers.shift ?? false, "ShiftLeft", "ShiftRight"),
-				]], "guard")
-				return (guard > 0)
-					? resolveAtom(subject, "subject")
-					: 0
-			}
-		}
-	}
-
-	return (now: number, samples: Iterable<Sample>) => {
-		sampleMap.zero()
-		const intents: Intent[] = []
-
-		for (const sample of samples)
-			sampleMap.merge(sample)
-
-		for (const bind of table.values()) {
-			const value = resolveAtomForPath(now, [])(bind.atom, bind.mode as string)
-			const previous = intentMap.get(bind.id)
-			if (value !== previous) {
-				intentMap.set(bind.id, value)
-				intents.push([bind.id, value])
-			}
-		}
-
-		return intents
-	}
-}
-

package/s/_archive/core/types.ts

@@ -1,40 +0,0 @@
-
-import {Atom} from "./atom/types.js"
-import {Action} from "./parts/action.js"
-
-/** json-friendly description of how samples are interpreted */
-export type Bindings = {[mode: string]: {[action: string]: Atom}}
-
-/** describes the shape of how bindings relate to the binds index (useful on serverside) */
-export type BindingsShape<B extends Bindings> = {[MK in keyof B]: {[AK in keyof B[MK]]: number}}
-
-/** integer-indexed flat map of bindings info (for efficient networking) */
-export type BindingsTable<B extends Bindings> = Map<number, BindingsRow<B>>
-
-/** the binding for a single action */
-export type BindingsRow<B extends Bindings> = {
-	id: number
-	mode: keyof B
-	action: keyof B[keyof B]
-	atom: Atom
-}
-
-/** produces user input samples (eg, a keyboard produces samples) */
-export type Device = {samples(): Iterable<Sample>}
-
-/** raw user input, eg, `["KeyW", 1]` */
-export type Sample = [code: string, value: number]
-
-/** efficiently express resolved values */
-export type Intent = [id: number, value: number]
-
-/** ergonomic access to user inputs (your app logic should read from this) */
-export type Actions<B extends Bindings> = {
-	[M in keyof B]: {
-		[A in keyof B[M]]: Action
-	}
-}
-
-export type AsBindings<B extends Bindings> = {[MK in keyof B]: {[AK in keyof B[MK]]: Atom}}
-export const asBindings = <B extends Bindings>(b: B) => (b as AsBindings<B>)
-

package/s/_archive/deck/controller.ts

@@ -1,35 +0,0 @@
-
-import {deep} from "@e280/stz"
-import {Bindings, Device} from "../core/types.js"
-import {makeIntentsResolver} from "../core/resolvers/intents.js"
-
-/** associate a device with particular bindings */
-export class Controller<B extends Bindings = Bindings, D extends Device = Device> {
-	#bindings: B
-	#resolveIntents
-
-	constructor(
-			readonly handle: string,
-			bindings: B,
-			public device: D,
-		) {
-		this.#bindings = bindings
-		this.#resolveIntents = makeIntentsResolver(bindings)
-	}
-
-	get bindings() {
-		return this.#bindings
-	}
-
-	set bindings(bindings: B) {
-		if (!deep.equal(this.#bindings, bindings)) {
-			this.#bindings = bindings
-			this.#resolveIntents = makeIntentsResolver(bindings)
-		}
-	}
-
-	resolveIntents(now: number) {
-		return this.#resolveIntents(now, this.device.samples())
-	}
-}
-

package/s/_archive/deck/deck.ts

@@ -1,92 +0,0 @@
-
-import {Cubby, debounce, guarantee} from "@e280/stz"
-import {Port} from "./port.js"
-import {Device} from "../core/types.js"
-import {Runtime} from "./parts/runtime.js"
-import {Controller} from "./controller.js"
-import {Profiles} from "./parts/profiles.js"
-import {Settings} from "./parts/settings.js"
-import {DeckState, Profile, ProfileKey} from "./types.js"
-
-export class Deck<StockProfileKey extends ProfileKey = ProfileKey> {
-	profiles
-	settings
-	#runtime = new Runtime()
-
-	constructor(options: {
-			store: Cubby<DeckState>
-			stockProfiles: Record<StockProfileKey, Profile>
-		}) {
-		this.settings = new Settings(options.store)
-		this.profiles = new Profiles(options.stockProfiles, this.settings.customProfiles)
-	}
-
-	async load() {
-		await this.settings.load()
-		for (const controller of this.#runtime.controllers.keys())
-			this.#applyControllerProfile(controller)
-	}
-
-	#save = debounce(100, () => this.settings.save())
-
-	get ports() {
-		return [...this.#runtime.ports]
-	}
-
-	get controllers() {
-		return [...this.#runtime.controllers]
-	}
-
-	get unassignedControllers() {
-		return [...this.#runtime.controllers]
-			.filter(controller => !this.#runtime.portAssignments.get(controller))
-	}
-
-	createPort() {
-		const port = new Port(this.#runtime)
-		this.#runtime.ports.add(port)
-		return port
-	}
-
-	deletePort(port: Port) {
-		for (const controller of port.controllers)
-			port.unplug(controller)
-		this.#runtime.ports.delete(port)
-	}
-
-	createController<D extends Device = Device>(
-			handle: string,
-			stockProfileKey: StockProfileKey,
-			device: D,
-		) {
-		const profileKey = guarantee(this.settings.profileAssignments, handle, () => stockProfileKey)
-		const profile = this.profiles.get(profileKey)
-		const controller = new Controller(handle, profile.bindings, device)
-		this.#runtime.controllers.add(controller)
-		return controller
-	}
-
-	deleteController(controller: Controller) {
-		this.#runtime.controllers.delete(controller)
-		this.#runtime.portAssignments.delete(controller)
-	}
-
-	async assignControllerProfile(controller: Controller, profileKey: StockProfileKey | ProfileKey) {
-		this.settings.profileAssignments.set(controller.handle, profileKey)
-		this.#applyControllerProfile(controller)
-		await this.#save()
-	}
-
-	queryController(controller: Controller) {
-		const port = this.#runtime.portAssignments.get(controller)
-		const profileKey = this.settings.profileAssignments.get(controller.handle)
-		const profile = this.profiles.get(profileKey)
-		return {controller, port, profileKey, profile}
-	}
-
-	#applyControllerProfile(controller: Controller) {
-		const profileKey = this.settings.profileAssignments.get(controller.handle)
-		controller.bindings = this.profiles.get(profileKey).bindings
-	}
-}
-

package/s/_archive/deck/parts/profiles.ts

@@ -1,39 +0,0 @@
-
-import {RMap} from "@e280/strata"
-import {need, setEntries} from "@e280/stz"
-import {Profile, ProfileKey} from "../types.js"
-
-export class Profiles {
-	stock
-
-	constructor(stock: Record<ProfileKey, Profile>, public custom: RMap<ProfileKey, Profile>) {
-		this.stock = new RMap<ProfileKey, Profile>()
-		setEntries(this.stock, Object.entries(stock))
-
-		if (this.stock.size === 0)
-			throw new Error("must be at least one stock profile")
-	}
-
-	get all() {
-		return [...this.stock, ...this.custom]
-	}
-
-	normalizeKey(key?: ProfileKey) {
-		return key && (this.stock.has(key) || this.custom.has(key))
-			? key
-			: this.defaultId
-	}
-
-	get defaultId() {
-		return [...this.stock.keys()][0]
-	}
-
-	get(key?: ProfileKey) {
-		return this.need(this.normalizeKey(key))
-	}
-
-	need(key: ProfileKey) {
-		return this.stock.get(key) ?? need(this.custom, key)
-	}
-}
-

package/s/_archive/deck/parts/runtime.ts

@@ -1,11 +0,0 @@
-
-import {RMap, RSet} from "@e280/strata"
-import {Port} from "../port.js"
-import {Controller} from "../controller.js"
-
-export class Runtime {
-	ports = new RSet<Port>()
-	controllers = new RSet<Controller>()
-	portAssignments = new RMap<Controller, Port | undefined>()
-}
-

package/s/_archive/deck/parts/settings.ts

@@ -1,30 +0,0 @@
-
-import {RMap} from "@e280/strata"
-import {Cubby, setEntries} from "@e280/stz"
-import {shiftLimit} from "../../utils/shift-limit.js"
-import {ControllerHandle, DeckState, Profile, ProfileKey} from "../types.js"
-
-const limit = 256
-
-export class Settings {
-	profileAssignments = new RMap<ControllerHandle, ProfileKey>()
-	customProfiles = new RMap<ProfileKey, Profile>()
-
-	constructor(private store: Cubby<DeckState>) {}
-
-	async save() {
-		await this.store.set({
-			customProfiles: shiftLimit(limit, [...this.customProfiles]),
-			profileAssignments: shiftLimit(limit, [...this.profileAssignments]),
-		})
-	}
-
-	async load() {
-		const state = await this.store.get()
-		this.customProfiles.clear()
-		this.profileAssignments.clear()
-		setEntries(this.customProfiles, state?.customProfiles ?? [])
-		setEntries(this.profileAssignments, state?.profileAssignments ?? [])
-	}
-}
-

package/s/_archive/deck/port.ts

@@ -1,35 +0,0 @@
-
-import {derived} from "@e280/strata"
-import {Runtime} from "./parts/runtime.js"
-import {Controller} from "./controller.js"
-
-export class Port {
-	#runtime
-	#controllers
-
-	constructor(runtime: Runtime) {
-		this.#runtime = runtime
-		this.#controllers = derived(
-			() => [...this.#runtime.controllers]
-				.filter(controller => this.#runtime.portAssignments.get(controller) === this)
-		)
-	}
-
-	get controllers() {
-		return this.#controllers()
-	}
-
-	plug(controller: Controller) {
-		this.#runtime.portAssignments.set(controller, this)
-	}
-
-	unplug(controller: Controller) {
-		this.#runtime.portAssignments.delete(controller)
-	}
-
-	resolveIntents(now: number) {
-		return this.controllers
-			.flatMap(controller => controller.resolveIntents(now))
-	}
-}
-

package/s/_archive/deck/types.ts

@@ -1,16 +0,0 @@
-
-import {Bindings} from "../core/types.js"
-
-export type ProfileKey = string
-export type ControllerHandle = string
-
-export type Profile = {
-	label: string
-	bindings: Bindings
-}
-
-export type DeckState = {
-	customProfiles: [key: ProfileKey, profile: Profile][]
-	profileAssignments: [handle: ControllerHandle, key: ProfileKey][]
-}
-

package/s/_archive/demo/demo-app/element.ts

@@ -1,17 +0,0 @@
-
-import {html} from "lit"
-import {shadowElement, useCss} from "@e280/sly"
-import styleCss from "./style.css.js"
-import {Deck} from "../../deck/deck.js"
-import {DeskOptions, DeskView} from "../../ui/views/desk/view.js"
-
-export const setupDemoApp = (deck: Deck, options: DeskOptions = {}) => shadowElement(() => {
-	useCss(styleCss)
-
-	return html`
-		<div class=plate>
-			${DeskView(deck, options)}
-		</div>
-	`
-})
-

package/s/_archive/demo/demo-app/style.css.ts

@@ -1,10 +0,0 @@
-
-import {css} from "lit"
-export default css`
-
-.plate {
-	background: black;
-}
-
-`
-

package/s/_archive/demo/main.bundle.ts

@@ -1,71 +0,0 @@
-
-import {Content, dom} from "@e280/sly"
-import {LocalStore} from "@e280/strata"
-
-import {Deck} from "../deck/deck.js"
-import {DeckState} from "../deck/types.js"
-import {asBindings} from "../core/types.js"
-import {Devices} from "../device/devices.js"
-import {onPad} from "../device/pad/on-pad.js"
-import {Controller} from "../deck/controller.js"
-import {PointerDevice} from "../device/pointer.js"
-import {GamepadDevice} from "../device/gamepad.js"
-import {setupDemoApp} from "./demo-app/element.js"
-import {KeyboardDevice} from "../device/keyboard.js"
-
-const bindings = asBindings({
-	play: {
-		action: ["or", "Space", "pointer.button.left", "gamepad.button.1"],
-		up: ["or", "KeyW", "gamepad.axis.2.pos"],
-		down: ["or", "KeyS", "gamepad.axis.2.neg"],
-		left: ["or", "KeyA", "gamepad.axis.1.pos"],
-		right: ["or", "KeyD", "gamepad.axis.1.neg"],
-	},
-})
-
-const store = new LocalStore<DeckState>("tactDeck")
-
-const deck = new Deck({
-	store,
-	stockProfiles: {
-		standard: {label: "📜standard", bindings},
-		micro: {label: "🦠micro", bindings: asBindings<typeof bindings>({
-			play: {
-				action: ["or", "Space", "pointer.button.left", "gamepad.button.1"],
-				up: ["or", "KeyW", "gamepad.axis.2.pos"],
-				down: ["or", "KeyS", "gamepad.axis.2.neg"],
-				left: ["or", "KeyA", "gamepad.axis.1.pos"],
-				right: ["or", "KeyD", "gamepad.axis.1.neg"],
-			},
-		})},
-	},
-})
-
-await deck.load()
-store.onStorageEvent(() => deck.load())
-
-const port = deck.createPort()
-const controller = deck.createController("primary", "standard", new Devices(
-	new KeyboardDevice(),
-	new PointerDevice(),
-))
-
-port.plug(controller)
-
-const labels = new Map<Controller, Content>()
-	.set(controller, "⌨️🖱keyboard+mouse")
-
-onPad(pad => {
-	const handle = `(${pad.gamepad.index + 1}) ${pad.gamepad.id}`
-	const controller = deck.createController(handle, "standard", new GamepadDevice(pad))
-	labels.set(controller, `🎮${handle}`)
-	port.plug(controller)
-	return () => deck.deleteController(controller)
-})
-
-dom.register({
-	DemoApp: setupDemoApp(deck, {
-		getControllerLabel: labels.get.bind(labels),
-	}),
-})
-