like2d 1.0.0 → 2.0.0

package/dist/core/audio.js

@@ -0,0 +1,226 @@
+/** The audio module performs a few things:
+ *
+ * ## Make audio resources behave as if synchronous
+ * Functions like playback and seeking are deferred until the sound is loaded.
+ *
+ * ## Track and give global control to all audio objects
+ * Start, stop, or set global volume for every currently playing sound.
+ *
+ */
+/**
+ * Handle to a loaded audio resource.
+ * Use `play()`, `stop()`, `pause()`, `resume()` for playback control.
+ * Access the underlying HTMLAudioElement via `source.audio` for looping,
+ * pitch, etc. Note: Use `source.setVolume()` instead of setting
+ * `source.audio.volume` directly to ensure global volume scaling works correctly.
+ */
+export class Source {
+    constructor(path, audioRef, options = {}) {
+        Object.defineProperty(this, "path", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Underlying HTMLAudioElement. Modify directly for looping, pitch, etc. Use methods for playback control. Avoid setting volume directly. */
+        Object.defineProperty(this, "audio", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Resolves when the audio is loaded and ready to play. */
+        Object.defineProperty(this, "ready", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "loadState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: { loaded: false, pendingPlay: false, pendingSeek: 0 }
+        });
+        Object.defineProperty(this, "audioRef", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.path = path;
+        this.audioRef = audioRef;
+        this.audio = document.createElement('audio');
+        this.audio.src = path;
+        this.options = {
+            volume: Math.max(0, Math.min(1, options.volume ?? 1))
+        };
+        this.audio.volume = this.options.volume * audioRef.getVolume();
+        this.ready = new Promise((resolve, reject) => {
+            this.audio.oncanplaythrough = () => {
+                if (this.loadState.loaded)
+                    return;
+                const { pendingPlay, pendingSeek } = this.loadState;
+                this.loadState = { loaded: true };
+                this.audio.currentTime = pendingSeek;
+                if (pendingPlay) {
+                    this.audio.play()?.catch(() => {
+                        // Play failed (autoplay policy) - reset so user can retry
+                    });
+                }
+                resolve();
+            };
+            this.audio.onerror = () => reject(new Error(`Failed to load audio: ${path}`));
+            // Handle audio that is already loaded (cached) when we attach the listener
+            if (this.audio.readyState >= 3) {
+                this.loadState = { loaded: true };
+                resolve();
+            }
+        });
+    }
+    isReady() {
+        return this.loadState.loaded;
+    }
+    play() {
+        if (this.loadState.loaded) {
+            this.audio.play()?.catch(() => {
+                // Play failed (autoplay policy) - ignore
+            });
+        }
+        else {
+            this.loadState.pendingPlay = true;
+        }
+    }
+    stop() {
+        if (this.loadState.loaded) {
+            this.audio.pause();
+            this.audio.currentTime = 0;
+        }
+        else {
+            this.loadState.pendingPlay = false;
+            this.loadState.pendingSeek = 0;
+        }
+    }
+    pause() {
+        if (this.loadState.loaded) {
+            this.audio.pause();
+        }
+        else {
+            this.loadState.pendingPlay = false;
+        }
+    }
+    resume() {
+        if (this.loadState.loaded) {
+            if (this.audio.paused) {
+                this.audio.play()?.catch(() => {
+                    // Play failed (autoplay policy, etc.) - ignore
+                });
+            }
+        }
+        else {
+            this.loadState.pendingPlay = true;
+        }
+    }
+    seek(position) {
+        if (this.loadState.loaded) {
+            this.audio.currentTime = position;
+        }
+        else {
+            this.loadState.pendingSeek = position;
+        }
+    }
+    tell() {
+        if (this.loadState.loaded)
+            return this.audio.currentTime;
+        return this.loadState.pendingSeek;
+    }
+    isPlaying() {
+        if (this.loadState.loaded)
+            return !this.audio.paused && !this.audio.ended;
+        return this.loadState.pendingPlay;
+    }
+    isPaused() {
+        if (this.loadState.loaded)
+            return this.audio.paused;
+        return !this.loadState.pendingPlay;
+    }
+    isStopped() {
+        if (this.loadState.loaded)
+            return this.audio.paused && this.audio.currentTime === 0;
+        return !this.loadState.pendingPlay && this.loadState.pendingSeek === 0;
+    }
+    /** Set volume (0-1). Applies global volume scaling. Prefer this over `source.audio.volume`. */
+    setVolume(volume) {
+        this.options.volume = Math.max(0, Math.min(1, volume));
+        this.audio.volume = this.options.volume * this.audioRef.getVolume();
+    }
+    getVolume() {
+        return this.options.volume;
+    }
+    getDuration() {
+        if (this.loadState.loaded)
+            return this.audio.duration;
+        return 0;
+    }
+}
+export class Audio {
+    constructor() {
+        Object.defineProperty(this, "sources", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "globalVolume", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+    }
+    newSource(path, options) {
+        const source = new Source(path, this, options);
+        this.sources.push(new WeakRef(source));
+        return source;
+    }
+    /** Get all audio sources -- note that sources are tracked
+      * using weak references, and storing this list can cause
+      * a memory leak.
+      */
+    getAllSources() {
+        const active = [];
+        for (const sourceRef of this.sources) {
+            const source = sourceRef.deref();
+            if (source)
+                active.push(source);
+        }
+        return active;
+    }
+    stopAll() {
+        this.getAllSources().forEach(s => s.stop());
+    }
+    pauseAll() {
+        this.getAllSources().forEach(s => s.pause());
+    }
+    resumeAll() {
+        this.getAllSources().forEach(s => s.resume());
+    }
+    setVolume(volume) {
+        this.globalVolume = Math.max(0, Math.min(1, volume));
+        this.getAllSources().forEach(s => {
+            s.audio.volume = s.options.volume * this.globalVolume;
+        });
+    }
+    getVolume() {
+        return this.globalVolume;
+    }
+    clone(source) {
+        return this.newSource(source.path, { ...source.options });
+    }
+}

package/dist/core/canvas-config.d.ts

@@ -0,0 +1,22 @@
+import type { Vector2 } from './vector2';
+export type CanvasMode = 'fixed' | 'native';
+export type CanvasConfig = {
+    mode: 'fixed';
+    size: Vector2;
+    pixelArt?: boolean;
+} | {
+    mode: 'native';
+};
+/**
+ * Calculate the scale and offset for rendering fixed-size content to a target canvas.
+ * This is useful when you want to render in "native" mode but maintain a fixed game resolution.
+ *
+ * @param canvasSize - The actual canvas size in pixels
+ * @param gameSize - The desired game resolution (fixed size)
+ * @returns Object containing the scale factor and offset for centering
+ */
+export declare function calcFixedScale(canvasSize: Vector2, gameSize: Vector2): {
+    scale: number;
+    offset: Vector2;
+};
+//# sourceMappingURL=canvas-config.d.ts.map

package/dist/core/canvas-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-config.d.ts","sourceRoot":"","sources":["../../src/core/canvas-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE5C,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GACpD;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAEvB;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAKzG"}

package/dist/core/canvas-config.js

@@ -0,0 +1,14 @@
+/**
+ * Calculate the scale and offset for rendering fixed-size content to a target canvas.
+ * This is useful when you want to render in "native" mode but maintain a fixed game resolution.
+ *
+ * @param canvasSize - The actual canvas size in pixels
+ * @param gameSize - The desired game resolution (fixed size)
+ * @returns Object containing the scale factor and offset for centering
+ */
+export function calcFixedScale(canvasSize, gameSize) {
+    const scale = Math.min(canvasSize[0] / gameSize[0], canvasSize[1] / gameSize[1]);
+    const scaledGame = [gameSize[0] * scale, gameSize[1] * scale];
+    const offset = [(canvasSize[0] - scaledGame[0]) * 0.5, (canvasSize[1] - scaledGame[1]) * 0.5];
+    return { scale, offset };
+}

package/dist/core/canvas-manager.d.ts

@@ -0,0 +1,26 @@
+import type { CanvasConfig } from './canvas-config';
+import { type Vector2 } from './vector2';
+export declare class CanvasManager {
+    private canvas;
+    private container;
+    private ctx;
+    private config;
+    private resizeObserver;
+    private pixelArtCanvas;
+    private pixelArtCtx;
+    private onWindowResize;
+    private onFullscreenChange;
+    onResize: ((size: Vector2, pixelSize: Vector2, fullscreen: boolean) => void) | null;
+    constructor(canvas: HTMLCanvasElement, container: HTMLElement, ctx: CanvasRenderingContext2D, config?: CanvasConfig);
+    private listenForPixelRatioChanges;
+    setConfig(config: CanvasConfig): void;
+    getConfig(): CanvasConfig;
+    private applyConfig;
+    private applyFixedMode;
+    private applyNativeMode;
+    dispose(): void;
+    present(): void;
+    getDisplayCanvas(): HTMLCanvasElement;
+    transformMousePosition(cssX: number, cssY: number): Vector2;
+}
+//# sourceMappingURL=canvas-manager.d.ts.map

package/dist/core/canvas-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-manager.d.ts","sourceRoot":"","sources":["../../src/core/canvas-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAQ,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAmB/C,qBAAa,aAAa;IAWtB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,MAAM;IAbhB,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,cAAc,CAAkC;IACxD,OAAO,CAAC,WAAW,CAAyC;IAE5D,OAAO,CAAC,cAAc,CAA4B;IAClD,OAAO,CAAC,kBAAkB,CAA4B;IAE/C,QAAQ,EAAE,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,KAAK,IAAI,CAAC,GAAG,IAAI,CAAQ;gBAGxF,MAAM,EAAE,iBAAiB,EACzB,SAAS,EAAE,WAAW,EACtB,GAAG,EAAE,wBAAwB,EAC7B,MAAM,GAAE,YAAiC;IAYnD,OAAO,CAAC,0BAA0B;IAQlC,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAKrC,SAAS,IAAI,YAAY;IAIzB,OAAO,CAAC,WAAW;IA+BnB,OAAO,CAAC,cAAc;IAiCtB,OAAO,CAAC,eAAe;IAkBvB,OAAO,IAAI,IAAI;IASf,OAAO,IAAI,IAAI;IAaf,gBAAgB,IAAI,iBAAiB;IAIrC,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO;CAiB5D"}

package/dist/core/canvas-manager.js

@@ -0,0 +1,197 @@
+import { Vec2 } from './vector2';
+function setCanvasSize(canvas, size) {
+    canvas.width = size[0];
+    canvas.height = size[1];
+}
+function setCanvasDisplaySize(canvas, size) {
+    canvas.style.width = `${size[0]}px`;
+    canvas.style.height = `${size[1]}px`;
+}
+function centerElement(el) {
+    el.style.position = 'absolute';
+    el.style.left = '50%';
+    el.style.top = '50%';
+    el.style.transform = 'translate(-50%, -50%)';
+}
+export class CanvasManager {
+    constructor(canvas, container, ctx, config = { mode: 'native' }) {
+        Object.defineProperty(this, "canvas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: canvas
+        });
+        Object.defineProperty(this, "container", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: container
+        });
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ctx
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+        Object.defineProperty(this, "resizeObserver", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "pixelArtCanvas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "pixelArtCtx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "onWindowResize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => this.applyConfig()
+        });
+        Object.defineProperty(this, "onFullscreenChange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => this.applyConfig()
+        });
+        Object.defineProperty(this, "onResize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.resizeObserver = new ResizeObserver(() => this.applyConfig());
+        this.resizeObserver.observe(this.container);
+        window.addEventListener('resize', this.onWindowResize);
+        document.addEventListener('fullscreenchange', this.onFullscreenChange);
+        this.listenForPixelRatioChanges();
+        this.applyConfig();
+    }
+    listenForPixelRatioChanges() {
+        const media = window.matchMedia(`(resolution: ${window.devicePixelRatio}dppx)`);
+        media.addEventListener('change', () => {
+            this.applyConfig();
+            this.listenForPixelRatioChanges();
+        }, { once: true });
+    }
+    setConfig(config) {
+        this.config = config;
+        this.applyConfig();
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    applyConfig() {
+        const containerSize = document.fullscreenElement
+            ? [document.fullscreenElement.clientWidth, document.fullscreenElement.clientHeight]
+            : [this.container.clientWidth, this.container.clientHeight];
+        // Always clean up pixel art canvas first
+        if (this.pixelArtCanvas) {
+            this.pixelArtCanvas.remove();
+            this.pixelArtCanvas = null;
+            this.pixelArtCtx = null;
+        }
+        switch (this.config.mode) {
+            case 'fixed':
+                this.applyFixedMode(containerSize);
+                break;
+            case 'native':
+                this.applyNativeMode(containerSize);
+                break;
+        }
+        const displayCanvas = this.pixelArtCanvas ?? this.canvas;
+        const isFullscreen = !!document.fullscreenElement;
+        this.onResize?.(containerSize, [displayCanvas.width, displayCanvas.height], isFullscreen);
+    }
+    applyFixedMode(csize) {
+        const { size: gameSize, pixelArt } = this.config;
+        const pixelRatio = window.devicePixelRatio || 1;
+        const scale = Math.min(csize[0] / gameSize[0], csize[1] / gameSize[1]);
+        if (pixelArt) {
+            const physicalScale = scale * pixelRatio;
+            const intScale = Math.max(1, Math.floor(physicalScale));
+            this.pixelArtCanvas = document.createElement('canvas');
+            this.pixelArtCtx = this.pixelArtCanvas.getContext('2d');
+            setCanvasSize(this.pixelArtCanvas, Vec2.mul(gameSize, intScale));
+            setCanvasSize(this.canvas, gameSize);
+            this.canvas.style.display = 'none';
+            const pac = this.pixelArtCanvas;
+            setCanvasDisplaySize(pac, Vec2.mul(gameSize, scale));
+            pac.style.maxWidth = '100%';
+            pac.style.maxHeight = '100%';
+            pac.style.imageRendering = 'auto';
+            centerElement(pac);
+            this.container.appendChild(pac);
+        }
+        else {
+            setCanvasSize(this.canvas, gameSize);
+            this.canvas.style.display = 'block';
+            setCanvasDisplaySize(this.canvas, Vec2.mul(gameSize, scale));
+            this.canvas.style.imageRendering = pixelArt ? 'pixelated' : 'auto';
+            this.ctx.imageSmoothingEnabled = !pixelArt;
+            centerElement(this.canvas);
+        }
+    }
+    applyNativeMode(csize) {
+        const pixelRatio = window.devicePixelRatio || 1;
+        const canvasSize = Vec2.mul(csize, pixelRatio);
+        setCanvasSize(this.canvas, Vec2.floor(canvasSize));
+        setCanvasDisplaySize(this.canvas, csize);
+        this.canvas.style.position = 'absolute';
+        this.canvas.style.left = '0';
+        this.canvas.style.top = '0';
+        this.canvas.style.transform = 'none';
+        this.canvas.style.margin = '0';
+        this.canvas.style.display = 'block';
+        this.canvas.style.imageRendering = 'auto';
+        this.ctx.setTransform(1, 0, 0, 1, 0, 0);
+    }
+    dispose() {
+        this.resizeObserver?.disconnect();
+        window.removeEventListener('resize', this.onWindowResize);
+        document.removeEventListener('fullscreenchange', this.onFullscreenChange);
+        this.pixelArtCanvas?.remove();
+        this.pixelArtCanvas = null;
+        this.pixelArtCtx = null;
+    }
+    present() {
+        if (!this.pixelArtCtx || !this.pixelArtCanvas) {
+            return;
+        }
+        this.pixelArtCtx.imageSmoothingEnabled = false;
+        this.pixelArtCtx.drawImage(this.canvas, 0, 0, this.canvas.width, this.canvas.height, 0, 0, this.pixelArtCanvas.width, this.pixelArtCanvas.height);
+    }
+    getDisplayCanvas() {
+        return this.pixelArtCanvas ?? this.canvas;
+    }
+    transformMousePosition(cssX, cssY) {
+        const displayCanvas = this.getDisplayCanvas();
+        const rect = displayCanvas.getBoundingClientRect();
+        const relative = [cssX - rect.left, cssY - rect.top];
+        switch (this.config.mode) {
+            case 'fixed': {
+                const scale = [displayCanvas.width / rect.width, displayCanvas.height / rect.height];
+                return Vec2.mul(relative, scale);
+            }
+            case 'native':
+            default: {
+                return Vec2.mul(relative, window.devicePixelRatio || 1);
+            }
+        }
+    }
+}

package/dist/core/events.d.ts

@@ -0,0 +1,52 @@
+import type { Vector2 } from './vector2';
+export type Like2DEvent = {
+    type: 'load';
+    args: [];
+    timestamp: number;
+} | {
+    type: 'update';
+    args: [dt: number];
+    timestamp: number;
+} | {
+    type: 'draw';
+    args: [canvas: HTMLCanvasElement];
+    timestamp: number;
+} | {
+    type: 'resize';
+    args: [size: Vector2, pixelSize: Vector2, fullscreen: boolean];
+    timestamp: number;
+} | {
+    type: 'keypressed';
+    args: [scancode: string, keycode: string];
+    timestamp: number;
+} | {
+    type: 'keyreleased';
+    args: [scancode: string, keycode: string];
+    timestamp: number;
+} | {
+    type: 'mousepressed';
+    args: [x: number, y: number, button: number];
+    timestamp: number;
+} | {
+    type: 'mousereleased';
+    args: [x: number, y: number, button: number];
+    timestamp: number;
+} | {
+    type: 'gamepadpressed';
+    args: [gamepadIndex: number, buttonIndex: number, buttonName: string];
+    timestamp: number;
+} | {
+    type: 'gamepadreleased';
+    args: [gamepadIndex: number, buttonIndex: number, buttonName: string];
+    timestamp: number;
+} | {
+    type: 'actionpressed';
+    args: [action: string];
+    timestamp: number;
+} | {
+    type: 'actionreleased';
+    args: [action: string];
+    timestamp: number;
+};
+export type EventType = Like2DEvent['type'];
+//# sourceMappingURL=events.d.ts.map

package/dist/core/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/core/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACzD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACtE;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACrG;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACpF;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACrF;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACzF;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC1F;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACpH;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACrH;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACpE;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1E,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC"}

package/dist/core/gamepad-button-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gamepad-button-map.d.ts","sourceRoot":"","sources":["../../src/core/gamepad-button-map.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAiCrD,CAAC;AAGF,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAiBvD,CAAC;AAEF,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAErE"}

package/dist/core/gamepad-buttons.d.ts

@@ -0,0 +1,23 @@
+export declare namespace GP {
+    const Bottom = 0;
+    const Right = 1;
+    const Left = 2;
+    const Top = 3;
+    const LB = 4;
+    const RB = 5;
+    const LT = 6;
+    const RT = 7;
+    const Back = 8;
+    const Start = 9;
+    const Guide = 10;
+    const LS = 11;
+    const RS = 12;
+    const DUp = 13;
+    const DDown = 14;
+    const DLeft = 15;
+    const DRight = 16;
+}
+export declare const GP_NAMES: Record<number, string>;
+export declare const GP_NAME_MAP: Record<string, number>;
+export declare function getGPName(buttonIndex: number): string;
+//# sourceMappingURL=gamepad-buttons.d.ts.map

package/dist/core/gamepad-buttons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gamepad-buttons.d.ts","sourceRoot":"","sources":["../../src/core/gamepad-buttons.ts"],"names":[],"mappings":"AAGA,yBAAiB,EAAE,CAAC;IAEX,MAAM,MAAM,IAAI,CAAC;IACjB,MAAM,KAAK,IAAI,CAAC;IAChB,MAAM,IAAI,IAAI,CAAC;IACf,MAAM,GAAG,IAAI,CAAC;IAGd,MAAM,EAAE,IAAI,CAAC;IACb,MAAM,EAAE,IAAI,CAAC;IACb,MAAM,EAAE,IAAI,CAAC;IACb,MAAM,EAAE,IAAI,CAAC;IAGb,MAAM,IAAI,IAAI,CAAC;IACf,MAAM,KAAK,IAAI,CAAC;IAChB,MAAM,KAAK,KAAK,CAAC;IAGjB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IAGd,MAAM,GAAG,KAAK,CAAC;IACf,MAAM,KAAK,KAAK,CAAC;IACjB,MAAM,KAAK,KAAK,CAAC;IACjB,MAAM,MAAM,KAAK,CAAC;CAC1B;AAMD,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAE3C,CAAC;AAGF,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAkC,CAAC;AAElF,wBAAgB,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAErD"}

package/dist/core/gamepad-buttons.js

@@ -0,0 +1,36 @@
+// Gamepad button constants
+// Use these constants instead of magic numbers
+export var GP;
+(function (GP) {
+    // Face buttons (physical positions)
+    GP.Bottom = 0; // A on Xbox, X on PlayStation, B on Nintendo
+    GP.Right = 1; // B on Xbox, O on PlayStation, A on Nintendo
+    GP.Left = 2; // X on Xbox, □ on PlayStation, Y on Nintendo
+    GP.Top = 3; // Y on Xbox, △ on PlayStation, X on Nintendo
+    // Bumpers and triggers
+    GP.LB = 4; // Left bumper (L1)
+    GP.RB = 5; // Right bumper (R1)
+    GP.LT = 6; // Left trigger (L2)
+    GP.RT = 7; // Right trigger (R2)
+    // Menu buttons
+    GP.Back = 8; // Select/Back/Minus
+    GP.Start = 9; // Start/Plus
+    GP.Guide = 10; // Home/Guide button
+    // Stick presses
+    GP.LS = 11; // Left stick press (L3)
+    GP.RS = 12; // Right stick press (R3)
+    // D-Pad
+    GP.DUp = 13;
+    GP.DDown = 14;
+    GP.DLeft = 15;
+    GP.DRight = 16;
+})(GP || (GP = {}));
+// Build reverse mappings programmatically
+const GP_ENTRIES = Object.entries(GP);
+// Map button index to name (for debugging/display)
+export const GP_NAMES = Object.fromEntries(GP_ENTRIES.map(([name, index]) => [index, name]));
+// Map name to button index (for action system parsing)
+export const GP_NAME_MAP = Object.fromEntries(GP_ENTRIES);
+export function getGPName(buttonIndex) {
+    return GP_NAMES[buttonIndex] ?? `Button${buttonIndex}`;
+}

package/dist/core/gamepad-db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gamepad-db.d.ts","sourceRoot":"","sources":["../../src/core/gamepad-db.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IAEjB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE7B,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE1B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACpD;AAGD,eAAO,MAAM,WAAW,qQASd,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAGrD,eAAO,MAAM,QAAQ,iDAGX,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAwC;IACxD,OAAO,CAAC,kBAAkB,CAAwC;IAClE,OAAO,CAAC,MAAM,CAAS;IAEvB,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IA0B7B,OAAO,CAAC,uBAAuB;IAU/B;;OAEG;IACH,QAAQ,IAAI,OAAO;IAInB;;OAEG;IACH,eAAe,IAAI,MAAM;IAIzB;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAIvD,yBAAyB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAKzF;;OAEG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIpC;;OAEG;IACH,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,EAAE;IAa5D;;OAEG;IACH,OAAO,CAAC,SAAS;CAiFlB;AAGD,eAAO,MAAM,eAAe,iBAAwB,CAAC"}

package/dist/{gamepad-mapping.d.ts → core/gamepad-mapping.d.ts}

@@ -1,30 +1,18 @@
 export interface ButtonMapping {
     toStandard: Map<number, number>;
-    fromStandard: Map<number, number>;
     controllerName: string;
     hasMapping: boolean;
+    vendor: number | null;
+    product: number | null;
 }
 export declare class GamepadMapping {
-    private mappings;
     private dbLoaded;
     loadDatabase(): Promise<void>;
-    /**
-     * Load database from raw text content
-     */
     loadDatabaseFromText(content: string): void;
     /**
-     * Get or create a button mapping for a specific gamepad
+     * Get button mapping for a specific gamepad
      */
     getMapping(gamepad: Gamepad): ButtonMapping;
-    /**
-     * Clear all cached mappings
-     */
-    clear(): void;
-    /**
-     * Create a new button mapping for a gamepad
-     */
-    private createMapping;
-    private findDatabaseMapping;
     private extractVendorProduct;
 }
 export declare const gamepadMapping: GamepadMapping;

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

@@ -0,0 +1 @@
+{"version":3,"file":"gamepad-mapping.d.ts","sourceRoot":"","sources":["../../src/core/gamepad-mapping.ts"],"names":[],"mappings":"AA+HA,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAS;IAEnB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IA+BnC,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAK3C;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,aAAa;IAsC3C,OAAO,CAAC,oBAAoB;CAuB7B;AAUD,eAAO,MAAM,cAAc,gBAAuB,CAAC"}