@antha/input 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './bindings/antha-active-bindings-debug.element.js';
+export * from './bindings/antha-binding-assignments-debug.element.js';
+export * from './bindings/antha-input-bindings.mod.js';
+export * from './bindings/antha-menu-nav.mod.js';
+export * from './bindings/player-bindings.js';
+export * from './elements/antha-keyboard.element.js';
+export * from './raw-inputs/antha-raw-input-debug.element.js';
+export * from './raw-inputs/antha-read-raw-input.mod.js';
+export * from './raw-inputs/raw-input.js';
+export * from 'gamepad-type';
+export * from 'input-device-handler';

package/dist/index.js

@@ -0,0 +1,11 @@
+export * from './bindings/antha-active-bindings-debug.element.js';
+export * from './bindings/antha-binding-assignments-debug.element.js';
+export * from './bindings/antha-input-bindings.mod.js';
+export * from './bindings/antha-menu-nav.mod.js';
+export * from './bindings/player-bindings.js';
+export * from './elements/antha-keyboard.element.js';
+export * from './raw-inputs/antha-raw-input-debug.element.js';
+export * from './raw-inputs/antha-read-raw-input.mod.js';
+export * from './raw-inputs/raw-input.js';
+export * from 'gamepad-type';
+export * from 'input-device-handler';

package/dist/raw-inputs/antha-raw-input-debug.element.d.ts

@@ -0,0 +1,9 @@
+import { type AnthaReadRawInputModState } from './antha-read-raw-input.mod.js';
+/**
+ * An element for debugging raw inputs that displays all current inputs.
+ *
+ * @category Internal
+ */
+export declare const AnthaRawInputDebug: import("element-vir").DeclarativeElementDefinition<"antha-raw-input-debug", {
+    rawInputs: Readonly<AnthaReadRawInputModState["rawInputs"]>;
+}, {}, {}, "antha-raw-input-debug-", "antha-raw-input-debug-", readonly [], readonly []>;

package/dist/raw-inputs/antha-raw-input-debug.element.js

@@ -0,0 +1,43 @@
+import { css, defineElement, html } from 'element-vir';
+/**
+ * An element for debugging raw inputs that displays all current inputs.
+ *
+ * @category Internal
+ */
+export const AnthaRawInputDebug = defineElement()({
+    tagName: 'antha-raw-input-debug',
+    styles: css `
+        :host {
+            display: flex;
+            gap: 16px;
+            flex-wrap: wrap;
+        }
+
+        .device {
+            min-width: 500px;
+        }
+
+        .no-inputs {
+            opacity: 0.3;
+            font-weight: bold;
+        }
+    `,
+    render({ inputs }) {
+        return Object.entries(inputs.rawInputs).map(([deviceKey, values,]) => {
+            const hasNoValues = Object.keys(values).length === 0;
+            const valuesTemplate = hasNoValues
+                ? html `
+                          <p class="no-inputs">No inputs</p>
+                      `
+                : html `
+                          <pre>${JSON.stringify(values, null, 4)}</pre>
+                      `;
+            return html `
+                    <section class="device">
+                        <b>${deviceKey}</b>
+                        ${valuesTemplate}
+                    </section>
+                `;
+        });
+    },
+});

package/dist/raw-inputs/antha-read-raw-input.mod.d.ts

@@ -0,0 +1,89 @@
+import { type PartialWithUndefined, type SelectFrom, type SetRequired } from '@augment-vir/common';
+import { type GamepadBrandMap, type GamepadLayout, type GamepadModelMap } from 'gamepad-type';
+import { InputDeviceHandler, type InputDeviceHandlerOptions, type InputDeviceKey } from 'input-device-handler';
+import { type RawInput, type RawInputs, type SimpleInputDevicesMap } from './raw-input.js';
+/**
+ * Options for {@link createAnthaReadRawInputMod}.
+ *
+ * @category Internal
+ */
+export type AnthaReadRawInputModOptions = PartialWithUndefined<{
+    /**
+     * A device handler to insert into the game state. If not provided, the mod will create a device
+     * handler on its own.
+     */
+    deviceHandler: AnthaReadRawInputModState['deviceHandler'];
+    /**
+     * Used only when constructing an internal deviceHandler, which only happens if `deviceHandler`
+     * is not provided in these options.
+     */
+    deviceHandlerOptions: Omit<InputDeviceHandlerOptions, 'startLoopImmediately'>;
+    debugRawInputs: AnthaReadRawInputModState['debugRawInputs'];
+}>;
+/**
+ * All state used by and set by `createAnthaReadRawInputMod`.
+ *
+ * @category Internal
+ */
+export type AnthaReadRawInputModState = {
+    deviceHandler: Pick<InputDeviceHandler, 'readAllDevices'>;
+    rawInputs: RawInputs;
+    currentInputDevices: SimpleInputDevicesMap;
+    /**
+     * If no model map is provided, the built-in defaults from
+     * [gamepad-type](https://www.npmjs.com/package/gamepad-type) are used. If a model map is
+     * provided, make sure to also include the default model map (`defaultGamepadModelMap` from
+     * gamepad-type) if you want it (as it will not be automatically appended to your provided
+     * map).
+     */
+    gamepadModelMap: GamepadModelMap;
+    /**
+     * If no gamepad layouts are provided, the built-in defaults from
+     * [gamepad-type](https://www.npmjs.com/package/gamepad-type) are used. If layouts are provided,
+     * make sure to also include the default layouts (`defaultGamepadLayouts` from gamepad-type) if
+     * you want them (as they will not be automatically appended to your provided layouts).
+     */
+    gamepadLayouts: GamepadLayout[];
+    /**
+     * If no brand map is provided, the built-in defaults from
+     * [gamepad-type](https://www.npmjs.com/package/gamepad-type) are used. If a brand map is
+     * provided, make sure to also include the default brand map (`defaultGamepadBrandMap` from
+     * gamepad-type) if you want it (as it will not be automatically appended to your provided
+     * map).
+     */
+    gamepadBrandMap: GamepadBrandMap;
+    /** If set to true, raw inputs are printed on the screen. */
+    debugRawInputs: boolean;
+};
+/**
+ * A pre-built mod that reads all current devices and device inputs and sets both on the state.
+ *
+ * @category Pre-Built Mods
+ */
+export declare function createAnthaReadRawInputMod(options?: Readonly<AnthaReadRawInputModOptions>): import("@antha/engine").AnthaMod<NoInfer<AnthaReadRawInputModState>>;
+/**
+ * The mod returned by {@link createAnthaReadRawInputMod}.
+ *
+ * @category Internal
+ */
+export type AnthaReadRawInputMod = ReturnType<typeof createAnthaReadRawInputMod>;
+/**
+ * Reads raw inputs from a `InputDeviceHandler`. This is the core internals of
+ * {@link createAnthaReadRawInputMod}.
+ *
+ * @category Internal
+ */
+export declare function readRawInputs(state: SetRequired<SelectFrom<Partial<AnthaReadRawInputModState>, {
+    rawInputs: true;
+    deviceHandler: true;
+    gamepadLayouts: true;
+    gamepadBrandMap: true;
+    gamepadModelMap: true;
+}>, 'deviceHandler'>, { msSinceLastExecute, }: Readonly<{
+    msSinceLastExecute: number;
+}>): {
+    rawInputs: Partial<Record<InputDeviceKey, {
+        [x: string]: RawInput;
+    }>>;
+    currentDevices: Partial<Record<InputDeviceKey, import("./raw-input.js").SimpleInputDevice>>;
+};

package/dist/raw-inputs/antha-read-raw-input.mod.js

@@ -0,0 +1,113 @@
+import { defineAnthaMod } from '@antha/engine';
+import { mapObject, } from '@augment-vir/common';
+import { html } from 'element-vir';
+import { defaultGamepadLayouts, defaultGamepadModelMap, findMatchingGamepadLayout, findMatchingGamepadModel, } from 'gamepad-type';
+import { InputDeviceHandler, isGamepadDeviceKey, } from 'input-device-handler';
+import { AnthaRawInputDebug } from './antha-raw-input-debug.element.js';
+import { calculateInputDirection, mapToSimpleDevicesMap, } from './raw-input.js';
+/**
+ * A pre-built mod that reads all current devices and device inputs and sets both on the state.
+ *
+ * @category Pre-Built Mods
+ */
+export function createAnthaReadRawInputMod(options = {}) {
+    return defineAnthaMod({
+        modName: 'antha-read-raw-input',
+        initState: {
+            debugRawInputs: !!options.debugRawInputs,
+        },
+        execute({ state, msSinceLastExecute }) {
+            if (!state.deviceHandler) {
+                state.deviceHandler =
+                    options.deviceHandler ||
+                        new InputDeviceHandler({
+                            ...options.deviceHandlerOptions,
+                            startLoopImmediately: false,
+                        });
+            }
+            const { currentDevices, rawInputs } = readRawInputs(state, {
+                msSinceLastExecute,
+            });
+            state.rawInputs = rawInputs;
+            state.currentInputDevices = currentDevices;
+            if (state.debugRawInputs) {
+                return html `
+                    <${AnthaRawInputDebug.assign({
+                    rawInputs: state.rawInputs,
+                })}></${AnthaRawInputDebug}>
+                `;
+            }
+            else {
+                return undefined;
+            }
+        },
+    });
+}
+/**
+ * Reads raw inputs from a `InputDeviceHandler`. This is the core internals of
+ * {@link createAnthaReadRawInputMod}.
+ *
+ * @category Internal
+ */
+export function readRawInputs(state, { msSinceLastExecute, }) {
+    const currentDevices = state.deviceHandler.readAllDevices();
+    const rawInputs = mapObject(currentDevices, (deviceKey, device) => {
+        const deviceInputs = {};
+        Object.values(device.currentInputs).forEach((currentInput) => {
+            const direction = calculateInputDirection(currentInput.inputValue);
+            const previousRawInput = state.rawInputs?.[deviceKey]?.[currentInput.inputName];
+            const duration = previousRawInput?.direction === direction
+                ? {
+                    milliseconds: Math.round(previousRawInput.duration.milliseconds + msSinceLastExecute),
+                }
+                : {
+                    milliseconds: 0,
+                };
+            const layout = isGamepadDeviceKey(deviceKey)
+                ? findMatchingGamepadLayout({
+                    layouts: state.gamepadLayouts || defaultGamepadLayouts,
+                    gamepad: {
+                        deviceName: device.deviceName,
+                    },
+                    gamepadModelMap: state.gamepadModelMap || defaultGamepadModelMap,
+                })
+                : undefined;
+            const model = isGamepadDeviceKey(deviceKey)
+                ? findMatchingGamepadModel({
+                    gamepad: {
+                        deviceName: device.deviceName,
+                    },
+                    gamepadBrandMap: state.gamepadBrandMap,
+                    gamepadModelMap: state.gamepadModelMap,
+                })
+                : undefined;
+            const mappedInputName = layout?.inputMappings[currentInput.inputName];
+            const rawInput = {
+                mapped: {
+                    deviceName: model?.gamepadModel || device.deviceName,
+                    gamepadBrand: model?.gamepadBrand,
+                    inputName: mappedInputName || currentInput.inputName,
+                },
+                deviceKey,
+                deviceName: device.deviceName,
+                deviceType: device.deviceType,
+                direction,
+                duration,
+                inputName: currentInput.inputName,
+                inputValue: currentInput.inputValue,
+            };
+            if (mappedInputName) {
+                deviceInputs[mappedInputName] = rawInput;
+            }
+            deviceInputs[currentInput.inputName] = rawInput;
+        });
+        return {
+            key: deviceKey,
+            value: deviceInputs,
+        };
+    });
+    return {
+        rawInputs,
+        currentDevices: mapToSimpleDevicesMap(currentDevices),
+    };
+}

package/dist/raw-inputs/raw-input.d.ts

@@ -0,0 +1,81 @@
+import { type SelectFrom } from '@augment-vir/common';
+import { type Duration, type DurationUnit } from 'date-vir';
+import { type AllDevices, type InputDevice, type InputDeviceKey, type InputValueWrapper } from 'input-device-handler';
+/**
+ * All possible directions of an input value.
+ *
+ * @category Internal
+ */
+export declare enum InputDirection {
+    /** Right at 0. */
+    Flat = "flat",
+    Negative = "negative",
+    Positive = "positive"
+}
+/**
+ * Calculate the {@link InputDirection} value of an input value.
+ *
+ * @category Internal
+ */
+export declare function calculateInputDirection(inputValue: number): InputDirection;
+/**
+ * An individual raw input. Used in `createAnthaReadRawInputMod` and {@link RawInputs}.
+ *
+ * @category Internal
+ */
+export type RawInput = Omit<InputValueWrapper<InputDeviceKey, any>, 'details'> & {
+    mapped: SelectFrom<InputValueWrapper<InputDeviceKey, any>, {
+        /**
+         * `deviceName` is mapped by `gamepadModelMap`. If no mapping exists, this will always
+         * be set to the original `deviceName`.
+         */
+        deviceName: true;
+        /**
+         * `deviceKey` is mapped by `gamepadLayouts`. If no mapping exists, this will always be
+         * set to the original `inputName`.
+         */
+        inputName: true;
+    }> & {
+        /** This will only be populated for gamepad devices. */
+        gamepadBrand: undefined | string;
+    };
+    /** The raw input's direction. */
+    direction: InputDirection;
+    /** How long this input has been held down in the current direction. */
+    duration: Duration<DurationUnit.Milliseconds>;
+};
+/**
+ * All raw inputs for all devices. Used in `createAnthaReadRawInputMod` and
+ * `AnthaReadRawInputModState`.
+ *
+ * @category Internal
+ */
+export type RawInputs = Partial<Record<InputDeviceKey, {
+    [InputName in string]: RawInput;
+}>>;
+/**
+ * An input device object. A simpler version of `InputDevice` from the [`input-device-handler`
+ * package](https://www.npmjs.com/package/input-device-handler). Used in
+ * `createAnthaReadRawInputMod` and {@link SimpleInputDevicesMap}.
+ *
+ * @category Internal
+ */
+export type SimpleInputDevice = Pick<InputDevice, 'deviceKey' | 'deviceName' | 'deviceType'>;
+/**
+ * A collection of all current simple input devices. Used in `createAnthaReadRawInputMod` and
+ * `AnthaReadRawInputModState`.
+ *
+ * @category Internal
+ */
+export type SimpleInputDevicesMap = Partial<Record<InputDeviceKey, SimpleInputDevice>>;
+/**
+ * Maps `AllDevices` to {@link SimpleInputDevicesMap}.
+ *
+ * @category Internal
+ */
+export declare function mapToSimpleDevicesMap(currentDevices: SelectFrom<AllDevices, {
+    [Key in InputDeviceKey]?: {
+        deviceName: true;
+        deviceType: true;
+    };
+}>): SimpleInputDevicesMap;

package/dist/raw-inputs/raw-input.js

@@ -0,0 +1,43 @@
+import { mapObjectValues } from '@augment-vir/common';
+/**
+ * All possible directions of an input value.
+ *
+ * @category Internal
+ */
+export var InputDirection;
+(function (InputDirection) {
+    /** Right at 0. */
+    InputDirection["Flat"] = "flat";
+    InputDirection["Negative"] = "negative";
+    InputDirection["Positive"] = "positive";
+})(InputDirection || (InputDirection = {}));
+/**
+ * Calculate the {@link InputDirection} value of an input value.
+ *
+ * @category Internal
+ */
+export function calculateInputDirection(inputValue) {
+    if (inputValue === 0) {
+        return InputDirection.Flat;
+    }
+    else if (inputValue < 0) {
+        return InputDirection.Negative;
+    }
+    else {
+        return InputDirection.Positive;
+    }
+}
+/**
+ * Maps `AllDevices` to {@link SimpleInputDevicesMap}.
+ *
+ * @category Internal
+ */
+export function mapToSimpleDevicesMap(currentDevices) {
+    return mapObjectValues(currentDevices, (deviceKey, device) => {
+        return {
+            deviceKey,
+            deviceName: device.deviceName,
+            deviceType: device.deviceType,
+        };
+    });
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+    "name": "@antha/input",
+    "version": "0.0.1",
+    "description": "An Antha mod for handling inputs.",
+    "keywords": [
+        "vir",
+        "antha",
+        "input"
+    ],
+    "homepage": "https://github.com/electrovir/antha",
+    "bugs": {
+        "url": "https://github.com/electrovir/antha/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/electrovir/antha.git"
+    },
+    "license": "(MIT OR CC0-1.0)",
+    "author": {
+        "name": "electrovir",
+        "url": "https://github.com/electrovir"
+    },
+    "sideEffects": false,
+    "type": "module",
+    "main": "dist/index.js",
+    "module": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "compile": "virmator compile",
+        "docs": "virmator docs",
+        "test": "virmator test web",
+        "test:coverage": "npm test coverage",
+        "test:docs": "virmator docs check"
+    },
+    "dependencies": {
+        "@augment-vir/assert": "^31.73.1",
+        "@augment-vir/common": "^31.73.1",
+        "date-vir": "^8.5.0",
+        "device-navigation": "^4.7.2",
+        "gamepad-type": "^2.0.2",
+        "input-device-handler": "^9.0.3",
+        "object-shape-tester": "^6.14.0",
+        "type-fest": "^5.7.0",
+        "vira": "^31.24.1"
+    },
+    "devDependencies": {
+        "@augment-vir/test": "^31.73.1",
+        "@web/dev-server-esbuild": "^1.0.5",
+        "@web/test-runner": "^0.20.2",
+        "@web/test-runner-playwright": "^0.11.1",
+        "element-vir": "^26.17.0",
+        "istanbul-smart-text-reporter": "^1.1.5"
+    },
+    "peerDependencies": {
+        "@antha/engine": "*",
+        "element-vir": ">=26"
+    },
+    "engines": {
+        "node": ">=22"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}