like2d 2.9.0 → 2.10.1

package/dist/input/gamepad-mapping.d.ts

@@ -0,0 +1,119 @@
+/**
+ * @module GamepadMapping
+ *
+ * A database, generated on module load,
+ * which uses SDL's database to coerce
+ * browser APIs into physical gamepad button
+ * mappings.
+ *
+ *
+ * Browser API shortcomings:
+ *  - [No standard way of exposing vendor/product, Safari doesn't even do it.](https://github.com/w3c/gamepad/issues/199)
+ *  - Vendor and product alone doesn't suffice for GUID -- Different controllers have the same, it's good-enough.
+ *  - D-pads either get mapped to an axis (last pair of axes in Chromium) or buttons (Firefox).
+ *  - Analog axes get mapped differently in Firefox and Chromium.
+ *
+ * How we overcome them:
+ *  - We parse out vendor and product based on currently known formats.
+ *  - We go with best-match and always fall back on manual mapping.
+ */
+import type { Vector2 } from "../math";
+/**
+ * ref: https://www.w3.org/TR/gamepad/#dfn-standard-gamepad
+ * note: `num` is only the corresponding number on standard mapping above.
+ *
+ * The point of the mapping system is to apply that _or_ non-standard mappings,
+ * Which are exceedingly common.
+ */
+declare const buttonMap: readonly [{
+    readonly like: "BBottom";
+    readonly num: number;
+    readonly name: "Bottom Face Button";
+}, {
+    readonly like: "BRight";
+    readonly num: 1;
+    readonly name: "Right Face Button";
+}, {
+    readonly like: "BLeft";
+    readonly num: 2;
+    readonly name: "Left Face Button";
+}, {
+    readonly like: "BTop";
+    readonly num: 3;
+    readonly name: "Top Face Button";
+}, {
+    readonly like: "L1";
+    readonly num: 4;
+    readonly name: "Left shoulder (front)";
+}, {
+    readonly like: "R1";
+    readonly num: 5;
+    readonly name: "Right shoulder (front)";
+}, {
+    readonly like: "L2";
+    readonly num: 6;
+    readonly name: "Left shoulder (rear)";
+}, {
+    readonly like: "R2";
+    readonly num: 7;
+    readonly name: "Right shoulder (rear)";
+}, {
+    readonly like: "MenuLeft";
+    readonly num: 8;
+    readonly name: "Left Menu Button";
+}, {
+    readonly like: "MenuRight";
+    readonly num: 9;
+    readonly name: "Right Menu Button";
+}, {
+    readonly like: "LeftStick";
+    readonly num: 10;
+    readonly name: "Left Stick Button";
+}, {
+    readonly like: "RightStick";
+    readonly num: 11;
+    readonly name: "Right Stick Button";
+}, {
+    readonly like: "Up";
+    readonly num: 12;
+    readonly name: "D-Pad Up";
+}, {
+    readonly like: "Down";
+    readonly num: 13;
+    readonly name: "D-Pad Down";
+}, {
+    readonly like: "Left";
+    readonly num: 14;
+    readonly name: "D-Pad Left";
+}, {
+    readonly like: "Right";
+    readonly num: 15;
+    readonly name: "D-Pad right";
+}];
+export type LikeButton = (typeof buttonMap)[number]["like"] | `Button${number}` | `Axis${number}+` | `Axis${number}-`;
+export type GamepadMapping = {
+    buttons: ButtonMapping;
+    sticks: StickMapping[];
+};
+export type ButtonMapping = Record<number, LikeButton>;
+export type StickMapping = [StickAxisMapping, StickAxisMapping];
+export type StickAxisMapping = {
+    index: number;
+    invert: boolean;
+};
+export declare const defaultMapping: (stickCount: number) => GamepadMapping;
+export declare const standardButtonMapping: () => ButtonMapping;
+export declare const allButtons: Set<string>;
+export declare const fullButtonName: Map<"BBottom" | "BRight" | "BLeft" | "BTop" | "L1" | "R1" | "L2" | "R2" | "MenuLeft" | "MenuRight" | "LeftStick" | "RightStick" | "Up" | "Down" | "Left" | "Right", "Bottom Face Button" | "Right Face Button" | "Left Face Button" | "Top Face Button" | "Left shoulder (front)" | "Right shoulder (front)" | "Left shoulder (rear)" | "Right shoulder (rear)" | "Left Menu Button" | "Right Menu Button" | "Left Stick Button" | "Right Stick Button" | "D-Pad Up" | "D-Pad Down" | "D-Pad Left" | "D-Pad right">;
+export declare const mapStick: (gp: Gamepad, mapping: StickMapping) => Vector2;
+type SdlMapping = {
+    vendor: number;
+    product: number;
+    name: string;
+    mapping: Record<number, LikeButton>;
+    browserName?: string;
+    id?: string;
+};
+export declare function getSdlMapping(gamepad: Gamepad): SdlMapping | undefined;
+export {};
+//# sourceMappingURL=gamepad-mapping.d.ts.map

package/dist/input/gamepad-mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gamepad-mapping.d.ts","sourceRoot":"","sources":["../../src/input/gamepad-mapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAEvC;;;;;;GAMG;AACH,QAAA,MAAM,SAAS;;kBACgB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoB3B,CAAC;AAUX,MAAM,MAAM,UAAU,GAClB,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,GAClC,SAAS,MAAM,EAAE,GACjB,OAAO,MAAM,GAAG,GAChB,OAAO,MAAM,GAAG,CAAC;AAIrB,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,YAAY,EAAE,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AACvD,MAAM,MAAM,YAAY,GAAG,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC;AAChE,MAAM,MAAM,gBAAgB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAAC;AAElE,eAAO,MAAM,cAAc,GAAI,YAAY,MAAM,KAAG,cAQlD,CAAC;AAEH,eAAO,MAAM,qBAAqB,QAAO,aAC0B,CAAC;AACpE,eAAO,MAAM,UAAU,aAAqD,CAAC;AAC7E,eAAO,MAAM,cAAc,qfAE1B,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,IAAI,OAAO,EAAE,SAAS,YAAY,KAAG,OAK7D,CAAC;AAkBF,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAwBtE"}

package/dist/input/gamepad-mapping.js

@@ -0,0 +1,114 @@
+/**
+ * @module GamepadMapping
+ *
+ * A database, generated on module load,
+ * which uses SDL's database to coerce
+ * browser APIs into physical gamepad button
+ * mappings.
+ *
+ *
+ * Browser API shortcomings:
+ *  - [No standard way of exposing vendor/product, Safari doesn't even do it.](https://github.com/w3c/gamepad/issues/199)
+ *  - Vendor and product alone doesn't suffice for GUID -- Different controllers have the same, it's good-enough.
+ *  - D-pads either get mapped to an axis (last pair of axes in Chromium) or buttons (Firefox).
+ *  - Analog axes get mapped differently in Firefox and Chromium.
+ *
+ * How we overcome them:
+ *  - We parse out vendor and product based on currently known formats.
+ *  - We go with best-match and always fall back on manual mapping.
+ */
+/**
+ * ref: https://www.w3.org/TR/gamepad/#dfn-standard-gamepad
+ * note: `num` is only the corresponding number on standard mapping above.
+ *
+ * The point of the mapping system is to apply that _or_ non-standard mappings,
+ * Which are exceedingly common.
+ */
+const buttonMap = [
+    { like: "BBottom", num: 0, name: "Bottom Face Button" },
+    { like: "BRight", num: 1, name: "Right Face Button" },
+    { like: "BLeft", num: 2, name: "Left Face Button" },
+    { like: "BTop", num: 3, name: "Top Face Button" },
+    { like: "L1", num: 4, name: "Left shoulder (front)" },
+    { like: "R1", num: 5, name: "Right shoulder (front)" },
+    { like: "L2", num: 6, name: "Left shoulder (rear)" },
+    { like: "R2", num: 7, name: "Right shoulder (rear)" },
+    { like: "MenuLeft", num: 8, name: "Left Menu Button" },
+    { like: "MenuRight", num: 9, name: "Right Menu Button" },
+    { like: "LeftStick", num: 10, name: "Left Stick Button" },
+    { like: "RightStick", num: 11, name: "Right Stick Button" },
+    { like: "Up", num: 12, name: "D-Pad Up" },
+    { like: "Down", num: 13, name: "D-Pad Down" },
+    { like: "Left", num: 14, name: "D-Pad Left" },
+    { like: "Right", num: 15, name: "D-Pad right" },
+];
+const detectedOs = ((s) => [
+    ["Android", "Android"],
+    ["iPhone", "iOS"],
+    ["iPad", "iOS"],
+    ["Win", "Windows"],
+    ["Mac", "Mac OS X"],
+].find(([ss]) => s.includes(ss))?.[1] ?? "Linux")(navigator.userAgent);
+export const defaultMapping = (stickCount) => ({
+    buttons: {},
+    sticks: Array(stickCount)
+        .fill(0)
+        .map((_, i) => [
+        { index: i * 2, invert: false },
+        { index: i * 2 + 1, invert: false },
+    ]),
+});
+export const standardButtonMapping = () => Object.fromEntries(buttonMap.map(({ like, num }) => [num, like]));
+export const allButtons = new Set(buttonMap.map(({ like }) => like));
+export const fullButtonName = new Map(buttonMap.map(({ like, name }) => [like, name]));
+export const mapStick = (gp, mapping) => {
+    return mapping.map((axis) => (axis.invert ? -1 : 1) * (gp.axes[axis.index] ?? 0));
+};
+//// ************* SDL Gamepad auto-binding system ******************* ////
+import mappingDbRaw from "./controllerdb.json";
+const mappingDb = new Map(Object.entries(mappingDbRaw[detectedOs]).map(([k, v]) => [
+    Number(k),
+    {
+        ...v,
+        mapping: Object.fromEntries(Object.entries(v.mapping).map(([k, v]) => [Number(k), v])),
+    },
+]));
+export function getSdlMapping(gamepad) {
+    const parsed = trySplitId(gamepad.id);
+    if (parsed) {
+        const [vendorStr, productStr, nameStr] = parsed;
+        const vendor = parseInt(vendorStr, 16);
+        const product = parseInt(productStr, 16);
+        const name = nameStr.trim();
+        const mapping = mappingDb.get(vendor * 0x10000 + product);
+        if (mapping) {
+            console.log(`[Gamepad] Found SDL db mapping for '${name}'`);
+            return {
+                ...mapping,
+                browserName: name,
+                id: gamepad.id,
+            };
+        }
+        else {
+            console.log(`[Gamepad] No SDL db mapping found for '${gamepad.id}.`);
+        }
+    }
+    else {
+        console.log(`[Gamepad] Failed to parse id: ${gamepad.id}. Please report this bug with the name of your web browser.`);
+    }
+}
+function trySplitId(id) {
+    const infoC = id.match(/^([^(]+)\(Vendor: ([0-9a-f]+) Product: ([0-9a-f]+)/i);
+    if (infoC) {
+        // chrome pattern: Name(Vendor: VEND Product: PROD)
+        const [, name, vendor, product] = infoC;
+        return [vendor, product, name.trim()];
+    }
+    else {
+        // firefox pattern: VEND-PROD-Name
+        const infoF = id.split("-");
+        if (infoF.length == 3) {
+            return infoF;
+        }
+    }
+}

package/dist/input/gamepad.d.ts

@@ -0,0 +1,73 @@
+import { GamepadMapping, LikeButton } from './gamepad-mapping';
+import { type LikeGamepadEvent } from '../events';
+import { Vector2 } from '../math/vector2';
+import { EngineProps } from '../engine';
+/** A selector for a gamepad. */
+export type GamepadTarget = number | "any";
+/** LIKE Gamepad Wrapper
+ *
+ *  - Allows events/callbacks to be sent from joy buttons.
+ *  - Can track if any gamepad has a button pressed / just pressed.
+ *  - Remaps raw input numbers to readable strings -- by default using SDL database.
+ *
+ * If you're planning on supporting gamepads, please include a
+ * way to generate {@link GamepadMapping} and set it with {@link Gamepad.setMapping}.
+ *
+ * If you don't want to make your own, take a look at `prefab-scenes/mapGamepad`.
+ */
+export declare class Gamepad {
+    private dispatch;
+    private gamepads;
+    private autoLoadMapping;
+    constructor(props: EngineProps<LikeGamepadEvent>);
+    private onGamepadConnected;
+    /**
+     * Called by the engine every frame.
+     */
+    private update;
+    /**
+     *
+     * @param target Which controller?
+     * @returns all of the sticks. Convention is 0 = left, 1 = right.
+     */
+    getSticks(target: number): Vector2[];
+    fullButtonName(name: LikeButton): string;
+    private checkButton;
+    /** Check if a gamepad button is down. */
+    isDown(target: GamepadTarget, button: LikeButton | number): boolean | undefined;
+    /**
+     * Returns true for only one frame/update if a button is pressed.
+     * Considered an alternative to `like.gamepadpressed`.
+     */
+    justPressed(target: GamepadTarget, button: LikeButton | number): boolean | undefined;
+    /**
+     * Get a controller mapping.
+     * Note that modifying this mapping in place will modify the target controller.
+     * However, use `setMapping` to finalize the mapping.
+     */
+    getMapping(index: number): GamepadMapping | undefined;
+    /**
+     * Set the mapping for a particular controller.
+     *
+     * Set `save = false` if you don't want this written into localstorage.
+     */
+    setMapping(index: number, mapping: GamepadMapping, save?: boolean): void;
+    /**
+     * Get saved mapping from db, if it exists.
+     */
+    loadMapping(index: number): GamepadMapping | undefined;
+    /**
+     * Save a mapping to persistant storage
+     */
+    saveMapping(index: number, mapping: GamepadMapping): void;
+    /**
+     * Enable automatically loading mappings.
+     *
+     * When a gamepad with a known (to this system) ID is plugged in,
+     * this will load the previously saved mapping.
+     *
+     * @param enable
+     */
+    enableAutoLoadMapping(enable: boolean): void;
+}
+//# sourceMappingURL=gamepad.d.ts.map

package/dist/input/gamepad.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gamepad.d.ts","sourceRoot":"","sources":["../../src/input/gamepad.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,cAAc,EAAiB,UAAU,EAAmC,MAAM,mBAAmB,CAAC;AAC/I,OAAO,EAAmB,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AACnE,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,gCAAgC;AAChC,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,KAAK,CAAC;AAE3C;;;;;;;;;;GAUG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,QAAQ,CAAoC;IACpD,OAAO,CAAC,eAAe,CAAQ;gBAEnB,KAAK,EAAE,WAAW,CAAC,gBAAgB,CAAC;IAmChD,OAAO,CAAC,kBAAkB;IAgC1B;;OAEG;IACH,OAAO,CAAC,MAAM;IAId;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,EAAE;IAQpC,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM;IAIxC,OAAO,CAAC,WAAW;IAYnB,yCAAyC;IACzC,MAAM,CACJ,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,UAAU,GAAG,MAAM,GAC1B,OAAO,GAAG,SAAS;IAItB;;;OAGG;IACH,WAAW,CACT,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,UAAU,GAAG,MAAM,GAC1B,OAAO,GAAG,SAAS;IAItB;;;;OAIG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAIrD;;;;OAIG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,EAAE,IAAI,UAAO;IAU9D;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAYtD;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc;IASlD;;;;;;;OAOG;IACH,qBAAqB,CAAC,MAAM,EAAE,OAAO;CAGtC"}

package/dist/input/gamepad.js

@@ -0,0 +1,291 @@
+import { defaultMapping, fullButtonName, getSdlMapping, mapStick, standardButtonMapping } from './gamepad-mapping';
+/** LIKE Gamepad Wrapper
+ *
+ *  - Allows events/callbacks to be sent from joy buttons.
+ *  - Can track if any gamepad has a button pressed / just pressed.
+ *  - Remaps raw input numbers to readable strings -- by default using SDL database.
+ *
+ * If you're planning on supporting gamepads, please include a
+ * way to generate {@link GamepadMapping} and set it with {@link Gamepad.setMapping}.
+ *
+ * If you don't want to make your own, take a look at `prefab-scenes/mapGamepad`.
+ */
+export class Gamepad {
+    constructor(props) {
+        Object.defineProperty(this, "dispatch", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gamepads", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "autoLoadMapping", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        this.dispatch = props.dispatch;
+        const { abort } = props;
+        // Register event listeners
+        window.addEventListener("gamepadconnected", this.onGamepadConnected.bind(this), {
+            signal: abort,
+        });
+        window.addEventListener("gamepaddisconnected", (ev) => {
+            console.log(`[Gamepad] Disconnected ${ev.gamepad.id}`);
+            delete this.gamepads[ev.gamepad.index];
+            this.dispatch("gamepaddisconnected", [ev.gamepad.index]);
+        }, { signal: abort });
+        window.addEventListener("blur", () => {
+            for (const gps of Object.values(this.gamepads)) {
+                gps.clear();
+            }
+        }, { signal: abort });
+        props.canvas.addEventListener("like:update", this.update.bind(this), {
+            signal: abort,
+        });
+    }
+    onGamepadConnected(ev) {
+        const gps = new GamepadState(ev.gamepad.index);
+        this.gamepads[ev.gamepad.index] = gps;
+        console.log(`[Gamepad] Connected ${ev.gamepad.id}. buttons: ${ev.gamepad.buttons.length}, axes: ${ev.gamepad.axes.length}`);
+        const mapping = this.loadMapping(ev.gamepad.index);
+        if (this.autoLoadMapping && mapping) {
+            gps.mapping = mapping;
+            console.log(`[Gamepad] Applied presaved mapping.`);
+        }
+        else if (ev.gamepad.mapping == 'standard') {
+            gps.mapping = defaultMapping(ev.gamepad.axes.length / 2);
+            gps.mapping.buttons = standardButtonMapping();
+            console.log(`Loaded standard mapping.`);
+        }
+        else {
+            const sdlMapping = getSdlMapping(ev.gamepad);
+            if (sdlMapping) {
+                gps.mapping.buttons = sdlMapping.mapping;
+                console.log(`[Gamepad] Connected, applied SDL database mapping.`);
+            }
+            else {
+                console.log(`[Gamepad] Could not find mapping for gamepad. Consider remapping it.`);
+            }
+        }
+        this.dispatch("gamepadconnected", [ev.gamepad.index]);
+    }
+    /**
+     * Called by the engine every frame.
+     */
+    update() {
+        Object.values(this.gamepads).forEach((gp) => gp.update(this.dispatch));
+    }
+    /**
+     *
+     * @param target Which controller?
+     * @returns all of the sticks. Convention is 0 = left, 1 = right.
+     */
+    getSticks(target) {
+        const gp = this.gamepads[target];
+        if (gp) {
+            return gp.getSticks();
+        }
+        return [];
+    }
+    fullButtonName(name) {
+        return fullButtonName.get(name) ?? name;
+    }
+    checkButton(target, button, mode) {
+        if (target == "any") {
+            return Object.values(this.gamepads).some((gp) => gp[mode](button));
+        }
+        else {
+            return this.gamepads[target]?.[mode](button);
+        }
+    }
+    /** Check if a gamepad button is down. */
+    isDown(target, button) {
+        return this.checkButton(target, button, "isDown");
+    }
+    /**
+     * Returns true for only one frame/update if a button is pressed.
+     * Considered an alternative to `like.gamepadpressed`.
+     */
+    justPressed(target, button) {
+        return this.checkButton(target, button, "justPressed");
+    }
+    /**
+     * Get a controller mapping.
+     * Note that modifying this mapping in place will modify the target controller.
+     * However, use `setMapping` to finalize the mapping.
+     */
+    getMapping(index) {
+        return this.gamepads[index]?.mapping;
+    }
+    /**
+     * Set the mapping for a particular controller.
+     *
+     * Set `save = false` if you don't want this written into localstorage.
+     */
+    setMapping(index, mapping, save = true) {
+        const gp = this.gamepads[index];
+        if (gp) {
+            gp.mapping = mapping;
+            if (save) {
+                this.saveMapping(index, mapping);
+            }
+        }
+    }
+    /**
+     * Get saved mapping from db, if it exists.
+     */
+    loadMapping(index) {
+        const gp = navigator.getGamepads()?.[index];
+        if (gp) {
+            const path = getLocalstoragePath(gp);
+            console.log(`[Gamepad] Found saved mapping for ${gp.id}.`);
+            const item = localStorage.getItem(path);
+            if (item) {
+                return JSON.parse(item);
+            }
+        }
+    }
+    /**
+     * Save a mapping to persistant storage
+     */
+    saveMapping(index, mapping) {
+        const gp = navigator.getGamepads()?.[index];
+        if (gp) {
+            const path = getLocalstoragePath(gp);
+            console.log(`[Gamepad] Saved mapping ${path} to localStorage.`);
+            localStorage.setItem(path, JSON.stringify(mapping));
+        }
+    }
+    /**
+     * Enable automatically loading mappings.
+     *
+     * When a gamepad with a known (to this system) ID is plugged in,
+     * this will load the previously saved mapping.
+     *
+     * @param enable
+     */
+    enableAutoLoadMapping(enable) {
+        this.autoLoadMapping = enable;
+    }
+}
+function getLocalstoragePath(gamepad) {
+    return `${gamepad.axes.length}A${gamepad.buttons.length}B${gamepad.id}`;
+}
+const maxButtons = 64;
+/** Internal class: Using it externally could result
+ * in a gamepad being disconnected and still trying to maintain
+ * its state.
+ */
+class GamepadState {
+    constructor(index) {
+        Object.defineProperty(this, "index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: index
+        });
+        Object.defineProperty(this, "mapping", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "downNums", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "lastDownNums", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "down", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "lastDown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        const gp = navigator.getGamepads()[this.index];
+        this.mapping = defaultMapping(gp.axes.length);
+    }
+    isDown(button) {
+        return typeof (button) == "number" ? !!this.downNums[button] : !!this.down[button];
+    }
+    justPressed(button) {
+        return typeof (button) == "number" ?
+            (!!this.downNums[button] && !this.lastDownNums[button]) :
+            (!!this.down[button] && !this.lastDown[button]);
+    }
+    map(button) {
+        return (this.mapping.buttons[button] ??
+            (button < maxButtons
+                ? `Button${button}`
+                : `Axis${Math.floor((button - maxButtons) / 2)}${button % 2 ? "-" : "+"}`));
+    }
+    update(dispatch) {
+        const gp = navigator.getGamepads()[this.index];
+        if (!gp)
+            return;
+        [this.downNums, this.lastDownNums] = [this.lastDownNums, this.downNums];
+        for (const k in this.downNums) {
+            delete this.downNums[Number(k)];
+        }
+        gp.buttons.forEach((btn, i) => {
+            if (btn.pressed) {
+                this.downNums[i] = true;
+            }
+        });
+        gp.axes.forEach((axis, i) => {
+            const pos = Math.round(axis);
+            if (pos == 0)
+                return;
+            const index = 64 + i * 2 + (pos == -1 ? 1 : 0);
+            this.downNums[index] = true;
+        });
+        [this.down, this.lastDown] = [this.lastDown, this.down];
+        for (const k in this.down) {
+            delete this.down[k];
+        }
+        for (const i in this.downNums) {
+            const name = this.map(Number(i));
+            this.down[name] = true;
+            if (!this.lastDownNums[Number(i)]) {
+                dispatch("gamepadpressed", [this.index, name, Number(i)]);
+            }
+        }
+        for (const i in this.lastDownNums) {
+            if (!this.downNums[Number(i)]) {
+                const name = this.map(Number(i));
+                dispatch("gamepadreleased", [this.index, name, Number(i)]);
+            }
+        }
+    }
+    getSticks() {
+        const gp = navigator.getGamepads()[this.index];
+        return this.mapping.sticks.map((stick) => mapStick(gp, stick));
+    }
+    clear() {
+        for (const k in this.lastDown) {
+            delete this.lastDown[k];
+        }
+        for (const k in this.down) {
+            delete this.down[k];
+        }
+    }
+}

package/dist/input/index.d.ts

@@ -0,0 +1,6 @@
+export type { Input, InputType, InputBinding, } from "./input";
+export type { GamepadTarget, Gamepad, } from "./gamepad";
+export type { LikeButton, GamepadMapping, StickMapping, StickAxisMapping, } from "./gamepad-mapping";
+export { defaultMapping, allButtons } from "./gamepad-mapping";
+export type { MouseSetMode, Mouse, } from "./mouse";
+//# sourceMappingURL=index.d.ts.map

package/dist/input/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/input/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,KAAK,EACL,SAAS,EACT,YAAY,GACb,MAAM,SAAS,CAAC;AAEjB,YAAY,EACV,aAAa,EACb,OAAO,GACR,MAAM,WAAW,CAAA;AAElB,YAAY,EACV,UAAU,EACV,cAAc,EACd,YAAY,EACZ,gBAAgB,GACjB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/D,YAAY,EACV,YAAY,EACZ,KAAK,GACN,MAAM,SAAS,CAAC"}

package/dist/input/index.js

@@ -0,0 +1 @@
+export { defaultMapping, allButtons } from "./gamepad-mapping";