like2d 2.8.0 → 2.10.0

package/dist/graphics/drawing.js

@@ -0,0 +1,388 @@
+/**
+ * @module graphics
+ * @description a reduced-state, Love2D-like wrapper around browser canvas
+ *
+ * # Graphics Module
+ *
+ * A wrapper around browser Canvas.
+ * In standard usage `like.gfx` gives a {@link BoundGraphics} object with a canvas already on it.
+ * So, you can for example call `like.gfx.rectangle('fill', 'green', [10, 10, 30, 30])`
+ *
+ * ## State Isolation
+ * Each drawing operation resets relevant canvas state before executing:
+ * - Stroke properties (`lineWidth`, `lineCap`, `lineJoin`, `miterLimit`) are always set to defaults first
+ * - No state leakage between drawing calls
+ *
+ * ## Predicable Parameter Ordering
+ * - No clunky argument overrides that could affect positionality.
+ * - **Required arguments** come first as positional parameters
+ * - **Optional arguments** are grouped in a trailing `props` object
+ * - **Mode** `'fill' | 'line'` is the first arg if relevent.
+ * - **Color** then {@link Color}, if relevant -- there is no `setColor`.
+ *
+ * ## Note: Coordinate System is unchanged from native Canvas.
+ * - Origin (0, 0) at top-left
+ * - X increases right
+ * - Y increases down
+ * - Angles in radians, 0 is right, positive is clockwise
+ */
+import { Vec2 } from "../math/vector2";
+export class ImageHandle {
+    constructor(path) {
+        Object.defineProperty(this, "path", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "element", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "loadPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isLoaded", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.path = path;
+        this.loadPromise = new Promise((resolve, reject) => {
+            const img = new Image();
+            img.onload = () => {
+                this.element = img;
+                this.isLoaded = true;
+                resolve();
+            };
+            img.onerror = () => {
+                reject(new Error(`Failed to load image: ${path}`));
+            };
+            img.src = path;
+        });
+    }
+    isReady() {
+        return this.isLoaded;
+    }
+    ready() {
+        return this.loadPromise;
+    }
+    get size() {
+        return [this.element?.width ?? 0, this.element?.height ?? 0];
+    }
+    getElement() {
+        return this.element;
+    }
+}
+function parseColor(color) {
+    if (typeof color === "string")
+        return color;
+    const [r, g, b, a = 1] = color;
+    return `rgba(${r * 255}, ${g * 255}, ${b * 255}, ${a})`;
+}
+function applyColor(color) {
+    return parseColor(color ?? [1, 1, 1, 1]);
+}
+function setStrokeProps(ctx, props) {
+    ctx.lineWidth = props?.lineWidth ?? 1;
+    ctx.lineCap = props?.lineCap ?? "butt";
+    ctx.lineJoin = props?.lineJoin ?? "miter";
+    ctx.miterLimit = props?.miterLimit ?? 10;
+}
+function wrapText(ctx, text, maxWidth) {
+    const words = text.split(" ");
+    const [first, ...rest] = words;
+    const lines = [];
+    let current = first ?? "";
+    rest.forEach((word) => {
+        if (ctx.measureText(current + " " + word).width < maxWidth) {
+            current += " " + word;
+        }
+        else {
+            lines.push(current);
+            current = word;
+        }
+    });
+    lines.push(current);
+    return lines;
+}
+function getFontHeight(ctx) {
+    const match = ctx.font.match(/(\d+)px/);
+    return match ? parseInt(match[1]) : 16;
+}
+/**
+ * All of these methods exist on `like.gfx`, but with `ctx`
+ * bound to the first arg.
+ *
+ * Acts as the core of the graphics system, but can be used separately.
+ *
+ * ```ts
+ * import { draw } from "like/graphics"
+ * draw.clear(my2dContext, "red");
+ * ```
+ *
+ */
+export const draw = {
+    /**
+     * Clears the canvas with a solid color.
+     * @param ctx Canvas context.
+     * @param color Fill color.
+     */
+    clear(ctx, color = [0, 0, 0, 1]) {
+        ctx.fillStyle = parseColor(color);
+        ctx.fillRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+    },
+    /**
+     * Draws a rectangle.
+     * @param ctx Canvas context.
+     * @param mode Fill or line.
+     * @param color Fill or stroke color.
+     * @param rect Rectangle [x, y, w, h].
+     * @param props Optional stroke properties.
+     */
+    rectangle(ctx, mode, color, rect, props) {
+        const c = applyColor(color);
+        if (mode === "fill") {
+            ctx.fillStyle = c;
+            ctx.fillRect(...rect);
+        }
+        else {
+            setStrokeProps(ctx, props);
+            ctx.strokeStyle = c;
+            ctx.strokeRect(...rect);
+        }
+    },
+    /**
+     * Draws a circle or ellipse.
+     * @param ctx Canvas context.
+     * @param mode Fill or line.
+     * @param color Fill or stroke color.
+     * @param position Center position.
+     * @param radii Radius (number) or [rx, ry] for ellipse.
+     * @param props Optional arc, center, and stroke properties. Center is true by default.
+     */
+    circle(ctx, mode, color, position, radii, props) {
+        const center = (props && 'center' in props) ? props.center : true;
+        const c = applyColor(color);
+        const size = typeof radii === "number" ? [radii, radii] : radii;
+        const [startAngle, endAngle] = props?.arc ?? [0, Math.PI * 2];
+        if (!center) {
+            position = Vec2.add(position, size);
+        }
+        ctx.save();
+        ctx.translate(...position);
+        ctx.scale(...size);
+        ctx.beginPath();
+        ctx.arc(0, 0, 1, startAngle, endAngle);
+        if (mode == 'fill')
+            ctx.lineTo(0, 0);
+        ctx.closePath();
+        ctx.restore();
+        if (mode === "fill") {
+            ctx.fillStyle = c;
+            ctx.fill();
+        }
+        else {
+            setStrokeProps(ctx, props);
+            ctx.strokeStyle = c;
+            ctx.stroke();
+        }
+    },
+    /**
+     * Draws connected line segments.
+     * @param ctx Canvas context.
+     * @param color Stroke color.
+     * @param points Array of [x, y] positions.
+     * @param props Optional stroke properties.
+     */
+    line(ctx, color, points, props) {
+        if (points.length < 2)
+            return;
+        setStrokeProps(ctx, props);
+        ctx.beginPath();
+        const [[x0, y0], ...rest] = points;
+        ctx.moveTo(x0, y0);
+        rest.forEach(([x, y]) => ctx.lineTo(x, y));
+        ctx.strokeStyle = applyColor(color);
+        ctx.stroke();
+    },
+    /**
+     * Draws text at a position.
+     *
+     * Keep in mind: if you set `align` without `width` in your props,
+     * nothing will happen -- you'll get left-aligned text.
+     *
+     * Align works browser-style: if you align center, your text draws
+     * to the left and right of its position. If you align right, your position
+     * becomes the upper-right corner of the text.
+     *
+     * @param ctx Canvas context.
+     * @param color Fill color.
+     * @param text Text string.
+     * @param position Top-left position.
+     * @param props {@link PrintProps} Optional font, text limit, or alignment.
+     */
+    print(ctx, color, text, position, props) {
+        const [x, y] = position;
+        const { font = "16px sans-serif" } = props ?? {};
+        ctx.fillStyle = parseColor(color);
+        ctx.font = font;
+        ctx.textAlign = props?.align ?? "left";
+        if (props && 'width' in props) {
+            const { width } = props;
+            const lines = wrapText(ctx, text, width);
+            const lineHeight = getFontHeight(ctx);
+            ctx.textBaseline = "top";
+            lines.forEach((line, i) => {
+                ctx.fillText(line, x, y + i * lineHeight, width);
+            });
+            ctx.textBaseline = "alphabetic";
+        }
+        else {
+            ctx.fillText(text, x, y);
+        }
+    },
+    /**
+     * Draws an image.
+     *
+     * @remarks named "draw" because it draws anything _drawable_
+     * in the long run.
+     *
+     * @param ctx Canvas context.
+     * @param handle Image handle from newImage.
+     * @param position Draw position.
+     * @param props Optional rotation, scale, origin, or quad.
+     */
+    draw(ctx, handle, position, props) {
+        if (!handle.isReady())
+            return;
+        const element = handle.getElement();
+        if (!element)
+            return;
+        const [x, y] = position;
+        const { r = 0, scale = 1, origin = 0, quad } = props ?? {};
+        const [sx, sy] = typeof scale === "number" ? [scale, scale] : scale;
+        const [ox, oy] = typeof origin === "number" ? [origin, origin] : origin;
+        ctx.save();
+        ctx.translate(x, y);
+        ctx.rotate(r);
+        ctx.scale(sx, sy);
+        if (quad) {
+            const [qx, qy, qw, qh] = quad;
+            ctx.drawImage(element, qx, qy, qw, qh, -ox, -oy, qw, qh);
+        }
+        else {
+            ctx.drawImage(element, -ox, -oy);
+        }
+        ctx.restore();
+    },
+    /**
+     * Loads an image from a path.
+     * Unlike built-in loading, this pretends to be synchronous.
+     * @param ctx Canvas context.
+     * @param path Image file path.
+     * @returns ImageHandle for use with draw.
+     */
+    newImage(_ctx, path) {
+        return new ImageHandle(path);
+    },
+    /**
+     * Sets the clipping region.
+     * @param ctx Canvas context.
+     * @param rect Clipping rectangle, or full canvas if omitted.
+     */
+    clip(ctx, rect) {
+        ctx.beginPath();
+        if (rect) {
+            const [x, y, w, h] = rect;
+            ctx.rect(x, y, w, h);
+        }
+        else {
+            ctx.rect(0, 0, ctx.canvas.width, ctx.canvas.height);
+        }
+        ctx.clip();
+    },
+    /**
+     * Draws a polygon.
+     * @param ctx Canvas context.
+     * @param mode Fill or line.
+     * @param color Fill or stroke color.
+     * @param points Array of [x, y] vertices.
+     * @param props Optional stroke properties.
+     */
+    polygon(ctx, mode, color, points, props) {
+        if (points.length < 3)
+            return;
+        const c = applyColor(color);
+        ctx.beginPath();
+        const [[x0, y0], ...rest] = points;
+        ctx.moveTo(x0, y0);
+        rest.forEach(([x, y]) => ctx.lineTo(x, y));
+        ctx.closePath();
+        if (mode === "fill") {
+            ctx.fillStyle = c;
+            ctx.fill();
+        }
+        else {
+            setStrokeProps(ctx, props);
+            ctx.strokeStyle = c;
+            ctx.stroke();
+        }
+    },
+    /**
+     * Draws individual pixels.
+     * @param ctx Canvas context.
+     * @param color Fill color.
+     * @param pts Array of [x, y] positions.
+     */
+    points(ctx, color, pts) {
+        ctx.fillStyle = applyColor(color);
+        pts.forEach(([x, y]) => ctx.fillRect(x, y, 1, 1));
+    },
+    /**
+     * Saves canvas state.
+     * @param ctx Canvas context.
+     */
+    push(ctx) {
+        ctx.save();
+    },
+    /**
+     * Restores canvas state.
+     * @param ctx Canvas context.
+     */
+    pop(ctx) {
+        ctx.restore();
+    },
+    /**
+     * Applies a translation.
+     * @param ctx Canvas context.
+     * @param offset [x, y] offset.
+     */
+    translate(ctx, offset) {
+        const [x, y] = offset;
+        ctx.translate(x, y);
+    },
+    /**
+     * Applies a rotation.
+     * @param ctx Canvas context.
+     * @param angle Rotation in radians.
+     */
+    rotate(ctx, angle) {
+        ctx.rotate(angle);
+    },
+    /**
+     * Applies a scale.
+     * @param ctx Canvas context.
+     * @param factor Scale factor (number or [x, y]).
+     */
+    scale(ctx, factor) {
+        const [sx, sy] = typeof factor === "number" ? [factor, factor] : factor;
+        ctx.scale(sx, sy);
+    },
+};

package/dist/graphics/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @module graphics
+ * @description a reduced-state, Love2D-like wrapper around browser canvas
+ */
+import { draw } from "./drawing";
+export type { Color, DrawMode, ShapeProps, DrawProps, PrintProps, ImageHandle, } from "./drawing";
+export { draw } from "./drawing";
+export type { CanvasModeOptions, CanvasSize, Canvas, } from "./canvas";
+type Bind<F> = F extends (ctx: CanvasRenderingContext2D, ...args: infer A) => infer R ? (...args: A) => R : never;
+/**
+ * A graphics object with a canvas already attatched to it.
+ * Calling its methods will draw to the render canvas.
+ * See {@link graphics} for more info.
+ */
+export type BoundGraphics = {
+    [K in keyof typeof draw]: Bind<(typeof draw)[K]>;
+};
+export declare function bindGraphics(ctx: CanvasRenderingContext2D): BoundGraphics;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/graphics/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,YAAY,EACV,KAAK,EACL,QAAQ,EACR,UAAU,EACV,SAAS,EACT,UAAU,EACV,WAAW,GACZ,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,YAAY,EACV,iBAAiB,EACjB,UAAU,EACV,MAAM,GACP,MAAM,UAAU,CAAC;AAElB,KAAK,IAAI,CAAC,CAAC,IAAI,CAAC,SAAS,CACvB,GAAG,EAAE,wBAAwB,EAC7B,GAAG,IAAI,EAAE,MAAM,CAAC,KACb,MAAM,CAAC,GACR,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,GACjB,KAAK,CAAC;AAEV;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;KACzB,CAAC,IAAI,MAAM,OAAO,IAAI,GAAG,IAAI,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;CACjD,CAAC;AAEF,wBAAgB,YAAY,CAAC,GAAG,EAAE,wBAAwB,GAAG,aAAa,CAMzE"}

package/dist/graphics/index.js

@@ -0,0 +1,13 @@
+/**
+ * @module graphics
+ * @description a reduced-state, Love2D-like wrapper around browser canvas
+ */
+import { draw } from "./drawing";
+export { draw } from "./drawing";
+export function bindGraphics(ctx) {
+    const bound = {};
+    for (const [name, fn] of Object.entries(draw)) {
+        bound[name] = (...args) => fn(ctx, ...args);
+    }
+    return bound;
+}

package/dist/index.d.ts

@@ -1,25 +1,19 @@
-import type { EventMap, EventType } from './core/events';
-import type { Like } from './core/like';
-export type { Like } from './core/like';
-export type { Vector2 } from './core/vector2';
-export { Vec2 } from './core/vector2';
-export { Rect } from './core/rect';
-export type { Like2DEvent, EventType, EventMap } from './core/events';
-export type { CanvasMode, PartialCanvasMode } from './core/canvas-config';
-export type { Color, Quad, ShapeProps, DrawProps, PrintProps } from './core/graphics';
-export { ImageHandle } from './core/graphics';
-export type { Source, SourceOptions } from './core/audio';
-export type { Scene } from './scene';
-export { StartupScene } from './scenes/startup';
-export { getGPName, GP } from './core/gamepad';
-export type { StickPosition } from './core/gamepad';
-type Callback<K extends EventType> = (...args: EventMap[K]) => void;
-type Callbacks = {
-    [K in EventType]?: Callback<K>;
-};
-export type LikeWithCallbacks = Like & Callbacks & {
-    start(): Promise<void>;
-    dispose(): void;
-};
-export declare function createLike(container: HTMLElement): LikeWithCallbacks;
+/**
+ * @module like2d
+ * @description A cozy web-native 2D game framework.
+ */
+import type { Like } from './like';
+export type { Like, TopLevelEventHandler } from './like';
+export type { LikeEvent, EventType, EventMap } from './events';
+/**
+ * Create a new Like2D game instance attached to a DOM container.
+ *
+ * This is the entry point for all Like2D games. It creates a canvas element,
+ * initializes all subsystems (graphics, audio, input), and returns an object
+ * where you can assign game callbacks.
+ *
+ * @param container - The HTML element to attach the game canvas to.
+ * @returns A {@link Like} instance ready for callback assignment
+ */
+export declare function createLike(container: HTMLElement): Like;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAe,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACtE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,YAAY,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACnC,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACtE,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC1E,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACtF,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC1D,YAAY,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AAC/C,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,KAAK,QAAQ,CAAC,CAAC,SAAS,SAAS,IAAI,CAAC,GAAG,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AAEpE,KAAK,SAAS,GAAG;KACd,CAAC,IAAI,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,IAAI,GAAG,SAAS,GAAG;IACjD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,OAAO,IAAI,IAAI,CAAC;CACjB,CAAC;AAEF,wBAAgB,UAAU,CAAC,SAAS,EAAE,WAAW,GAAG,iBAAiB,CAapE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,YAAY,EAAE,IAAI,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AACzD,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAE/D;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,WAAW,GAAG,IAAI,CAGvD"}

package/dist/index.js

@@ -1,19 +1,19 @@
+/**
+ * @module like2d
+ * @description A cozy web-native 2D game framework.
+ */
 import { Engine } from './engine';
-export { Vec2 } from './core/vector2';
-export { Rect } from './core/rect';
-export { ImageHandle } from './core/graphics';
-export { StartupScene } from './scenes/startup';
-export { getGPName, GP } from './core/gamepad';
+/**
+ * Create a new Like2D game instance attached to a DOM container.
+ *
+ * This is the entry point for all Like2D games. It creates a canvas element,
+ * initializes all subsystems (graphics, audio, input), and returns an object
+ * where you can assign game callbacks.
+ *
+ * @param container - The HTML element to attach the game canvas to.
+ * @returns A {@link Like} instance ready for callback assignment
+ */
 export function createLike(container) {
     const engine = new Engine(container);
-    const callbacks = {};
-    const handleEvent = (event) => {
-        const cb = callbacks[event.type];
-        if (cb)
-            cb(...event.args);
-    };
-    return Object.assign(engine.like, callbacks, {
-        start: () => engine.start(handleEvent),
-        dispose: () => engine.dispose(),
-    });
+    return engine.like;
 }

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

@@ -0,0 +1,134 @@
+/**
+ * @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 and product
+ *  - Almost nothing is standard
+ *  - Vendor and product alone doesn't suffice for GUID -- Different controllers have the same.
+ *  - 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 sdl: "a";
+    readonly like: "BBottom";
+    readonly num: number;
+    readonly name: "Bottom Face Button";
+}, {
+    readonly sdl: "b";
+    readonly like: "BRight";
+    readonly num: 1;
+    readonly name: "Right Face Button";
+}, {
+    readonly sdl: "x";
+    readonly like: "BLeft";
+    readonly num: 2;
+    readonly name: "Left Face Button";
+}, {
+    readonly sdl: "y";
+    readonly like: "BTop";
+    readonly num: 3;
+    readonly name: "Top Face Button";
+}, {
+    readonly sdl: "leftshoulder";
+    readonly like: "L1";
+    readonly num: 4;
+    readonly name: "Left shoulder (front)";
+}, {
+    readonly sdl: "rightshoulder";
+    readonly like: "R1";
+    readonly num: 5;
+    readonly name: "Right shoulder (front)";
+}, {
+    readonly sdl: "lefttrigger";
+    readonly like: "L2";
+    readonly num: 6;
+    readonly name: "Left shoulder (rear)";
+}, {
+    readonly sdl: "righttrigger";
+    readonly like: "R2";
+    readonly num: 7;
+    readonly name: "Right shoulder (rear)";
+}, {
+    readonly sdl: "back";
+    readonly like: "MenuLeft";
+    readonly num: 8;
+    readonly name: "Left Menu Button";
+}, {
+    readonly sdl: "start";
+    readonly like: "MenuRight";
+    readonly num: 9;
+    readonly name: "Right Menu Button";
+}, {
+    readonly sdl: "leftstick";
+    readonly like: "LeftStick";
+    readonly num: 10;
+    readonly name: "Left Stick Button";
+}, {
+    readonly sdl: "rightstick";
+    readonly like: "RightStick";
+    readonly num: 11;
+    readonly name: "Right Stick Button";
+}, {
+    readonly sdl: "dpup";
+    readonly like: "Up";
+    readonly num: 12;
+    readonly name: "D-Pad Up";
+}, {
+    readonly sdl: "dpdown";
+    readonly like: "Down";
+    readonly num: 13;
+    readonly name: "D-Pad Down";
+}, {
+    readonly sdl: "dpleft";
+    readonly like: "Left";
+    readonly num: 14;
+    readonly name: "D-Pad Left";
+}, {
+    readonly sdl: "dpright";
+    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;
+    sdlName: string;
+    mapping: Record<number, LikeButton>;
+};
+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;;;kBAC0B,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBrC,CAAC;AAEX,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;AAsEF,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACrC,CAAC;AAEF,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CA0BtE"}