@benev/tact 0.3.0-5 → 0.4.0-1

package/x/lib/ui/views/theme.css.js

@@ -0,0 +1,113 @@
+import { css } from "lit";
+import { cssReset } from "@e280/sly";
+export default css `
+@layer theme, view;
+@layer theme {
+
+${cssReset}
+
+:host {
+	--prime: var(--tact-prime, #fb0);
+
+	--text: var(--tact-text, #fffc);
+	--bg: var(--tact-bg, oklch(from var(--prime) calc(l * 0.3) calc(c * 0.1) h));
+	--droppy: var(--tact-droppy, oklch(from var(--prime) l c calc(h + 100)));
+	--recording: var(--tact-recording, oklch(from var(--prime) l c calc(h + 100)));
+
+	--round: var(--tact-round, 0.5em);
+	--pad: var(--tact-pad, 0.5em);
+	--nib: var(--tact-nib, 0.2em);
+	--space: var(--tact-space, 1em);
+	--box-shadow: var(--tact-box-shadow, 0.1em 0.2em 1em #0006);
+	--text-shadow: var(--tact-text-shadow, 0.02em 0.04em 0.1em #000a);
+}
+
+[theme-card] {
+	--tint: var(--prime);
+	--slate: color-mix(in oklch,
+		transparent,
+		color-mix(in oklch, var(--bg), var(--tint) 25%) 25%
+	);
+	--shimmer: color-mix(in oklch, transparent, var(--tint));
+
+	border-radius: var(--round);
+	background: var(--slate);
+	border: 1px solid var(--shimmer);
+	box-shadow:
+		inset 0 0 3em color-mix(in oklch, transparent, var(--shimmer) 30%),
+		var(--box-shadow);
+
+	&[theme-card="dull"] {
+		--tint: #8888;
+	}
+}
+
+[theme-button] {
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	font: inherit;
+	color: inherit;
+
+	cursor: pointer;
+	user-select: none;
+
+	opacity: 0.8;
+	gap: 0.5em;
+	padding: 0.5em;
+
+	&:is(:hover, :focus-visible) { opacity: 1; }
+	&:active { opacity: 0.8; }
+
+	svg {
+		width: 1.2em;
+		height: 1.2em;
+	}
+
+	&[theme-button~="naked"] {
+		padding: 0;
+		border: none;
+		background: transparent;
+		color: currentColor;
+	}
+
+	&[theme-button~="angry"] {
+		&:is(:hover, :focus-visible) { color: red; }
+	}
+}
+
+[theme-select] {
+	--base: var(--tint, var(--prime));
+	font: inherit;
+	color: inherit;
+	background: transparent;
+	border: 1px solid var(--base);
+	border-radius: var(--round);
+	padding: var(--nib) var(--pad);
+	box-shadow: inset 0 0 1em oklch(from var(--base) l c h / 40%);
+
+	&:is(:hover, :focus-visible) {
+		filter: brightness(110%);
+		box-shadow: inset 0 0 1em oklch(from var(--base) l c h / 60%);
+	}
+
+	&:active {
+		filter: brightness(90%);
+		box-shadow: inset 0 0 1em oklch(from var(--base) l c h / 40%);
+	}
+}
+
+[theme-input] {
+	--base: var(--tint, var(--prime));
+	--chill: oklch(from var(--base) l c h / 50%);
+	font: inherit;
+	color: inherit;
+	background: transparent;
+	border: 1px solid var(--chill);
+	border-radius: var(--round);
+	padding: 0 var(--nib);
+	box-shadow: inset 0 0 1em oklch(from var(--chill) l c h / 20%);
+}
+
+}`;
+//# sourceMappingURL=theme.css.js.map

package/x/lib/ui/views/theme.css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.css.js","sourceRoot":"","sources":["../../../../s/lib/ui/views/theme.css.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,GAAG,EAAC,MAAM,KAAK,CAAA;AACvB,OAAO,EAAC,QAAQ,EAAC,MAAM,WAAW,CAAA;AAElC,eAAe,GAAG,CAAA;;;;EAIhB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyGR,CAAA"}

package/x/lib/ui/views/visualizer/style.css.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("lit").CSSResult;
+export default _default;

package/x/lib/ui/views/visualizer/style.css.js

@@ -0,0 +1,22 @@
+import { css } from "lit";
+export default css `@layer view {
+
+:host {
+	display: block;
+}
+
+output {
+	opacity: 0.5;
+	color: var(--prime);
+	font-size: 1em;
+	font-family: monospace;
+	display: block;
+	overflow-wrap: anywhere;
+	text-overflow: ellipsis;
+	height: 8em;
+	padding: 0 4em;
+	overflow: hidden;
+}
+
+}`;
+//# sourceMappingURL=style.css.js.map

package/x/lib/ui/views/visualizer/style.css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.css.js","sourceRoot":"","sources":["../../../../../s/lib/ui/views/visualizer/style.css.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,GAAG,EAAC,MAAM,KAAK,CAAA;AACvB,eAAe,GAAG,CAAA;;;;;;;;;;;;;;;;;;;EAmBhB,CAAA"}

package/x/lib/ui/views/visualizer/view.d.ts

@@ -0,0 +1,2 @@
+import { Visualizer } from "./visualizer.js";
+export declare const VisualizerView: import("@e280/sly").ShadowView<[visualizer: Visualizer]>, makeVisualizerElement: (visualizer: Visualizer) => new () => HTMLElement;

package/x/lib/ui/views/visualizer/view.js

@@ -0,0 +1,11 @@
+import { html } from "lit";
+import { shadowDuplex, useCss } from "@e280/sly";
+import styleCss from "./style.css.js";
+import themeCss from "../theme.css.js";
+export const [VisualizerView, makeVisualizerElement] = shadowDuplex((visualizer) => {
+    useCss(themeCss, styleCss);
+    return html `
+		<output class=viz>${visualizer.$hex()}</output>
+	`;
+});
+//# sourceMappingURL=view.js.map

package/x/lib/ui/views/visualizer/view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"view.js","sourceRoot":"","sources":["../../../../../s/lib/ui/views/visualizer/view.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,IAAI,EAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAC,YAAY,EAAE,MAAM,EAAC,MAAM,WAAW,CAAA;AAE9C,OAAO,QAAQ,MAAM,gBAAgB,CAAA;AACrC,OAAO,QAAQ,MAAM,iBAAiB,CAAA;AAGtC,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,qBAAqB,CAAC,GAAG,YAAY,CAAC,CAAC,UAAsB,EAAE,EAAE;IAC9F,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;IAE1B,OAAO,IAAI,CAAA;sBACU,UAAU,CAAC,IAAI,EAAE;EACrC,CAAA;AACF,CAAC,CAAC,CAAA"}

package/x/lib/ui/views/visualizer/visualizer.d.ts

@@ -0,0 +1,5 @@
+export declare class Visualizer {
+    $hex: import("@e280/strata").Signal<string>;
+    clear: import("@e280/stz").DebounceReturn<() => void>;
+    update(data: ArrayBuffer): void;
+}

package/x/lib/ui/views/visualizer/visualizer.js

@@ -0,0 +1,13 @@
+import { signal } from "@e280/strata";
+import { debounce, hex } from "@e280/stz";
+export class Visualizer {
+    $hex = signal("");
+    clear = debounce(250, () => {
+        this.$hex.set("");
+    });
+    update(data) {
+        this.$hex(hex(new Uint8Array(data)));
+        this.clear();
+    }
+}
+//# sourceMappingURL=visualizer.js.map

package/x/lib/ui/views/visualizer/visualizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visualizer.js","sourceRoot":"","sources":["../../../../../s/lib/ui/views/visualizer/visualizer.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,MAAM,EAAC,MAAM,cAAc,CAAA;AACnC,OAAO,EAAC,QAAQ,EAAE,GAAG,EAAC,MAAM,WAAW,CAAA;AAEvC,MAAM,OAAO,UAAU;IACtB,IAAI,GAAG,MAAM,CAAC,EAAE,CAAC,CAAA;IAEjB,KAAK,GAAG,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE;QAC1B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IAClB,CAAC,CAAC,CAAA;IAEF,MAAM,CAAC,IAAiB;QACvB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;QACpC,IAAI,CAAC,KAAK,EAAE,CAAA;IACb,CAAC;CACD"}

package/x/lib/utils/ellipsis.d.ts

@@ -0,0 +1 @@
+export declare function ellipsis(s: string, max: number): string;

package/x/lib/utils/ellipsis.js

@@ -0,0 +1,6 @@
+export function ellipsis(s, max) {
+    return s.length > max
+        ? s.slice(0, max) + "..."
+        : s;
+}
+//# sourceMappingURL=ellipsis.js.map

package/x/lib/utils/ellipsis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ellipsis.js","sourceRoot":"","sources":["../../../s/lib/utils/ellipsis.ts"],"names":[],"mappings":"AACA,MAAM,UAAU,QAAQ,CAAC,CAAS,EAAE,GAAW;IAC9C,OAAO,CAAC,CAAC,MAAM,GAAG,GAAG;QACpB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,KAAK;QACzB,CAAC,CAAC,CAAC,CAAA;AACL,CAAC"}

package/x/lib/utils/hueify.d.ts

@@ -0,0 +1 @@
+export declare function hueify(n: number): number;

package/x/lib/utils/hueify.js

@@ -0,0 +1,4 @@
+export function hueify(n) {
+    return n * 137.508;
+}
+//# sourceMappingURL=hueify.js.map

package/x/lib/utils/hueify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hueify.js","sourceRoot":"","sources":["../../../s/lib/utils/hueify.ts"],"names":[],"mappings":"AACA,MAAM,UAAU,MAAM,CAAC,CAAS;IAC/B,OAAO,CAAC,GAAG,OAAO,CAAA;AACnB,CAAC"}

package/x/lib/utils/make-id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-id.js","sourceRoot":"","sources":["../../../s/lib/utils/make-id.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,GAAG,EAAC,MAAM,WAAW,CAAA;AAE7B,MAAM,UAAU,MAAM;IACrB,OAAO,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;AACtB,CAAC"}

package/s/_archive/README.md

@@ -1,435 +0,0 @@
-
-# 🎮 @benev/tact
-> *web game input library, from keypress to couch co-op*
-
-```ts
-npm install @benev/tact
-```
-
-tact is a toolkit for handling user inputs on the web.  
-it's good at user-customizable keybindings, multiple gamepad support, and mobile ui.  
-
-- 🛹 **[#deck](#deck)** full setup with localstorage persistence
-- 🎮 **[#devices](#devices)** produce user input samples
-- 🧩 **[#bindings](#bindings)** describe how actions interpret samples
-- 🔌 **[#port](#port)** updates actions by interpreting samples
-- 🛞 **[#hub](#hub)** plugs devices into ports (multi-gamepad couch co-op!)
-- 📱 **[#nubs](#nubs)** is mobile ui virtual gamepad stuff
-
-
-<br/><br/>
-<a id="deck"></a>
-
-## 🍋 tact deck
-> *full setup with ui, batteries included*
-
-the deck ties together all the important pieces of tact into a single user experience, complete with ui views.
-
-tact's ui is built with [`@e280/sly` shadow views](https://github.com/e280/sly).
-
-### 🛹 deck setup
-- **import stuff from tact**
-    ```ts
-    import * as tact from "@benev/tact"
-    ```
-- **setup your deck, and your game's bindings**
-    ```ts
-    const deck = await tact.Deck.load({
-
-      // how many player ports are possible? 1 is fine..
-      portCount: 4,
-
-      // where to store the user-customized bindings
-      kv: tact.localStorageKv(),
-
-      // default archetypal bindings for your game
-      bindings: {
-        walking: {forward: "KeyW", jump: "Space"},
-        gunning: {
-          shoot: ["or", "pointer.button.left", "gamepad.trigger.right"],
-        },
-      },
-    })
-    ```
-
-### 🛹 plug devices into the hub
-- **plug a keyboard/mouse player into the hub**
-    ```ts
-    deck.hub.plug(new tact.PrimaryDevice())
-    ```
-- **automatically detect and plug gamepads**
-    ```ts
-    tact.autoGamepads(deck.hub.plug)
-    ```
-
-### 🛹 do your gameplay
-- **poll the deck, interrogate actions**
-    ```ts
-    myGameLoop(() => {
-
-      // do your polling
-      const [p1, p2, p3, p4] = deck.hub.poll()
-
-      // check if the first player is pressing "forward" action
-      p1.actions.walking.forward.pressed // true
-
-      // check how hard the second player is pulling that trigger
-      p2.actions.gunning.shoot.value // 0.123
-    })
-    ```
-
-### 🛹 deck ui: the overlay
-- **render the deck overlay with sly**
-    ```ts
-    import {dom} from "@e280/sly"
-
-    dom.render(
-      dom("#game-ui"),
-      tact.DeckOverlay(deck),
-    )
-    ```
-- **place the ui on top of your game canvas**
-    ```html
-    <div id="game-ui"></div>
-    ```
-
-
-
-<br/><br/>
-<a id="devices"></a>
-
-## 🍋 tact devices
-> *sources of user input "samples"*
-
-### 🎮 polling is good, actually
-- tact operates on the basis of *polling*
-- *"but polling is bad"* says you — but no — you're wrong — polling is unironically *based,* and you *should* do it
-- the gift of polling is total control over *when* inputs are processed, this is good for games
-- i will elaborate no further 🗿
-
-### 🎮 basically how a device works
-- make a device
-    ```ts
-    const keyboard = new tact.KeyboardDevice()
-    ```
-- reading samples looks like this
-    ```ts
-    for (const sample of keyboard.samples())
-      console.log(sample) // ["KeyA", 1]
-    ```
-- some devices have disposers to call when you're done with them
-    ```ts
-    keyboard.dispose()
-    ```
-
-### 🎮 samples explained
-- a sample is a raw input tuple of type `[code: string, value: number]`
-- a sample has a `code` string
-  - it's either a [standard keycode](https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_code_values), like `KeyA`
-  - or it's something we made up, like `pointer.button.left` or `gamepad.trigger.right`
-- a sample has a `value` number
-  - `0` means *"nothing is going on"*
-  - `1` means *"pressed"*
-  - we don't like negative numbers
-  - values between `0` and `1`, like `0.123`, are how triggers and thumbsticks express themselves
-  - sometimes we use numbers greater then `1`, like for dots of pointer movement like in `pointer.move.up`
-  - don't worry about sensitivity, deadzones, values like `0.00001` — actions will account for all that using bindings later on
-
-### 🎮 sample code reference
-- **KeyboardDevice**
-    - any [standard keycode](https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_code_values)
-        - `KeyA`
-        - `Space`
-        - `Digit2`
-        - etc
-- **PointerDevice**
-    - mouse buttons
-        - `pointer.button.left`
-        - `pointer.button.right`
-        - `pointer.button.middle`
-        - `pointer.button.4`
-        - `pointer.button.5`
-    - mouse wheel
-        - `pointer.wheel.up`
-        - `pointer.wheel.down`
-        - `pointer.wheel.left`
-        - `pointer.wheel.right`
-    - mouse movements
-        - `pointer.move.up`
-        - `pointer.move.down`
-        - `pointer.move.left`
-        - `pointer.move.right`
-- **GamepadDevice**
-    - gamepad buttons
-        - `gamepad.a`
-        - `gamepad.b`
-        - `gamepad.x`
-        - `gamepad.y`
-        - `gamepad.bumper.left`
-        - `gamepad.bumper.right`
-        - `gamepad.trigger.left`
-        - `gamepad.trigger.right`
-        - `gamepad.alpha`
-        - `gamepad.beta`
-        - `gamepad.stick.left.click`
-        - `gamepad.stick.right.click`
-        - `gamepad.up`
-        - `gamepad.down`
-        - `gamepad.left`
-        - `gamepad.right`
-        - `gamepad.gamma`
-    - gamepad sticks
-        - `gamepad.stick.left.up`
-        - `gamepad.stick.left.down`
-        - `gamepad.stick.left.left`
-        - `gamepad.stick.left.right`
-        - `gamepad.stick.right.up`
-        - `gamepad.stick.right.down`
-        - `gamepad.stick.right.left`
-        - `gamepad.stick.right.right`
-
-
-
-<br/><br/>
-<a id="bindings"></a>
-
-## 🍋 tact bindings
-> *keybindings! they describe how actions interpret samples*
-
-### 🧩 bindings example
-- **let's start with a small example:**
-    ```ts
-    const bindings = tact.asBindings({
-      walking: {forward: "KeyW", jump: "Space"},
-      gunning: {
-        shoot: ["or", "pointer.button.left", "gamepad.trigger.right"],
-      },
-    })
-    ```
-    - `walking` and `gunning` are **modes**
-    - `forward`, `jump`, and `shoot` are **actions**
-    - note that whole modes can be enabled or disabled during gameplay
-
-### 🧩 bindings are a lispy domain-specific-language
-- **you can do complex stuff**
-    ```ts
-    ["or",
-      "KeyQ",
-      ["and",
-        "KeyA",
-        "KeyD",
-        ["not", "KeyS"],
-      ],
-    ]
-    ```
-    - press Q, or
-    - press A + D, while not pressing S
-- **you can get really weird**
-    ```ts
-    ["cond",
-      ["code", "gamepad.trigger.right", {range: [0, 0.5], timing: ["tap"]}],
-      ["and", "gamepad.bumper.left", ["not", "gamepad.trigger.left"]],
-    ]
-    ```
-    - hold LB and tap RT halfway while not holding LT
-
-### 🧩 bindings atom reference
-- **string** — strings are interpreted as "code" atoms with default settings
-- **"code"** — allows you to customize the settings
-    ```ts
-    ["code", "KeyA", {
-		  scale: 1,
-		  invert: false,
-		  timing: ["direct"],
-    }]
-    ```
-    - defaults shown
-    - `scale` is sensitivity, the value gets multiplied by this
-    - `invert` will invert a value by subtracting it from 1
-    - `clamp` clamps the value with a lower and upper bound
-    - `range` restricts value to the given range, and remaps that range 0 to 1
-    - `bottom` zeroes the value if it's less than the given bottom value
-    - `top` clamps the value to an upper bound
-    - `timing` lets you specify special timing considerations
-      - `["direct"]` ignores timing considerations
-      - `["tap", 250]` only fires for taps under 250ms
-      - `["hold", 250]` only fires for holds over 250ms
-- **"or"** — resolves to the maximum value
-    ```ts
-    ["or", "KeyA", "KeyB", "KeyC"]
-    ```
-- **"and"** — resolves to the minimum value
-    ```ts
-    ["and", "KeyA", "KeyB", "KeyC"]
-    ```
-- **"not"** — resolves to the opposite effect
-    ```ts
-    ["not", "KeyA"]
-    ```
-- **"cond"** — conditional situation (example for modifiers shown)
-    ```ts
-    ["cond", "KeyA", ["and",
-      ["or", "ControlLeft", "ControlRight"],
-      ["not", ["or", "AltLeft", "AltRight"]],
-      ["not", ["or", "MetaLeft", "MetaRight"]],
-      ["not", ["or", "ShiftLeft", "ShiftRight"]],
-    ]]
-    ```
-    - KeyA is the value that gets used
-    - but only if the following condition passes
-- **"mods"** — macro for modifiers
-    ```ts
-    ["mods", "KeyA", {ctrl: true}]
-    ```
-    - equivalent to the "cond" example above
-    - `ctrl`, `alt`, `meta`, `shift` are available
-
-
-
-<br/><br/>
-<a id="port"></a>
-
-## 🍋 tact port
-> *polling gives you "actions"*
-
-a port represents a single playable port, and you poll it each frame to resolve actions for you to read.
-
-### 🔌 port setup
-- **make a port**
-    ```ts
-    const port = new tact.Port(bindings)
-    ```
-- **attach some devices to the port**
-    ```ts
-    port.devices
-      .add(new tact.KeyboardDevice())
-      .add(new tact.PointerDevice())
-      .add(new tact.VpadDevice())
-    ```
-    - you can add/delete devices from the set any time
-- **manipulate modes**
-    ```ts
-    port.modes.clear()
-    port.modes.add("walking")
-    ```
-    - actions only happen for enabled modes
-    - you can toggle modes on and off by adding/deleting them from the modes set
-- **you can update the bindings any time**
-    ```ts
-    port.bindings = freshBindings
-    ```
-- **wire up gamepad auto connect/disconnect**
-    ```ts
-    tact.autoGamepads(device => {
-      port.devices.add(device)
-      return () => port.devices.delete(device)
-    })
-    ```
-
-### 🔌 interrogating actions
-- **poll the port every frame**
-    ```ts
-    port.resolve()
-    ```
-- **now you can inspect the `actions`**
-    ```ts
-    port.actions.walking.forward.value // 1
-    ```
-    - `walking` is a `mode`
-    - `forward` is an `action`
-    - `action.value` — current value
-    - `action.previous` — last frame's value
-    - `action.changed` — true if value and previous are different
-    - `action.pressed` — true if the value > 0
-    - `action.down` — true for one frame when the key goes from up to down
-    - `action.up` — true for one frame when the key goes from down to up
-
-
-
-<br/><br/>
-<a id="hub"></a>
-
-## 🍋 tact hub
-> *multiple gamepads! couch co-op is so back*
-
-you know the way old-timey game consoles had four controller ports on the front?
-
-the hub embraces that analogy, helping you coordinate the plugging and unplugging of virtual controller devices into its virtual ports.
-
-### 🛞 create a hub with ports
-- **make hub with multiple ports at the ready**
-    ```ts
-    const hub = new tact.Hub([
-      new tact.Port(bindings),
-      new tact.Port(bindings),
-      new tact.Port(bindings),
-      new tact.Port(bindings),
-    ])
-    ```
-    - yes that's right — each player port gets its own bindings 🤯
-
-### 🛞 plug in some devices
-- **let's plug in the keyboard/mouse player**
-    ```ts
-    hub.plug(new tact.PrimaryDevice())
-    ```
-    - the hub requires a single device to represent a player, so you can use a `GroupDevice` to combine multple devices into one
-- **wire up gamepad auto connect/disconnect**
-    ```ts
-    tact.autoGamepads(hub.plug)
-    ```
-
-### 🛞 now we're gaming
-- **do your polling, interrogate those actions**
-    ```ts
-    const [p1, p2, p3, p4] = hub.poll()
-
-    p1.actions.walking.jump.value // 1
-    p2.actions.walking.jump.value // 0
-    ```
-
-
-
-<br/><br/>
-<a id="nubs"></a>
-
-## 🍋 tact nubs
-> *mobile ui like virtual thumbsticks and buttons*
-
-### 📱 nubs setup
-- **render nub views with sly**
-    ```ts
-    import {dom} from "@e280/sly"
-
-    const stick = new tact.StickDevice()
-
-    dom.render(
-      dom("#controls"),
-      tact.NubStick(stick),
-    )
-    ```
-
-### 📱 nub stick
-- **place a mount point onto your page**
-    ```html
-    <div id="controls"></div>
-    ```
-- **make the stick device yourself, then plug it into your hub or whatever**
-    ```ts
-    const stick = new tact.StickDevice()
-
-    dom.render(
-      dom("#controls"),
-      tact.NubStick(stick),
-    )
-
-    deck.hub.plug(stick)
-    ```
-
-
-
-<br/><br/>
-<a id="benev"></a>
-
-## 🍋 tact is by https://benevolent.games/
-> *building the future of web games*

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

@@ -1,30 +0,0 @@
-
-import {sub} from "@e280/stz"
-import {isPressed} from "./parts/is-pressed.js"
-
-export class Action {
-	on = sub<[Action]>()
-	onDown = sub<[Action]>()
-
-	#value = 0
-	#previous = 0
-
-	get value() {
-		return this.#value
-	}
-
-	set value(v: number) {
-		this.#previous = this.#value
-		this.#value = v
-
-		this.on.publish(this)
-		if (this.down) this.onDown.publish(this)
-	}
-
-	get previous() { return this.#previous }
-	get changed() { return this.#value !== this.#previous }
-	get pressed() { return isPressed(this.#value) }
-	get down() { return !isPressed(this.#previous) && isPressed(this.#value) }
-	get up() { return isPressed(this.#previous) && !isPressed(this.#value) }
-}
-