minimojs 1.0.0-alpha.25 → 1.0.0-alpha.26

package/dist/internal/InputSystem.js

@@ -29,6 +29,16 @@ export class InputSystem {
         this._touchPointers = new Map();
         /** @internal */
         this._primaryTouchId = null;
+        /**
+         * The primary touch after it lifted, kept until the mouse or a new touch
+         * takes over, so the pointer stays where the finger left the screen instead
+         * of jumping to the mouse's last position.
+         *
+         * @internal
+         */
+        this._releasedTouch = null;
+        /** @internal True on the frame the primary touch ended in a `touchcancel`. */
+        this._pointerCancelled = false;
     }
     get pointerX() {
         return this._pointerX;
@@ -52,16 +62,19 @@ export class InputSystem {
             this._mouseY = p.y;
             this._mouseDown = true;
             this._mousePressed = true;
+            this._releasedTouch = null;
             this.syncPrimaryPointer();
         });
         this.canvas.addEventListener("mouseup", () => {
             this._mouseDown = false;
+            this._releasedTouch = null;
             this.syncPrimaryPointer();
         });
         this.canvas.addEventListener("mousemove", (e) => {
             const p = this.getCanvasPoint(e.clientX, e.clientY);
             this._mouseX = p.x;
             this._mouseY = p.y;
+            this._releasedTouch = null;
             this.syncPrimaryPointer();
         });
         this.canvas.addEventListener("touchstart", (e) => {
@@ -76,27 +89,17 @@ export class InputSystem {
                     this._primaryTouchId = touch.identifier;
                 }
             }
+            this._releasedTouch = null;
+            this._pointerCancelled = false;
             this.syncPrimaryPointer();
             e.preventDefault();
         }, { passive: false });
         this.canvas.addEventListener("touchend", (e) => {
-            for (const touch of Array.from(e.changedTouches)) {
-                this._touchPointers.delete(touch.identifier);
-                if (this._primaryTouchId === touch.identifier) {
-                    this._primaryTouchId = null;
-                }
-            }
-            this.syncPrimaryPointer();
+            this.endTouches(e, false);
             e.preventDefault();
         }, { passive: false });
         this.canvas.addEventListener("touchcancel", (e) => {
-            for (const touch of Array.from(e.changedTouches)) {
-                this._touchPointers.delete(touch.identifier);
-                if (this._primaryTouchId === touch.identifier) {
-                    this._primaryTouchId = null;
-                }
-            }
-            this.syncPrimaryPointer();
+            this.endTouches(e, true);
             e.preventDefault();
         }, { passive: false });
         this.canvas.addEventListener("touchmove", (e) => {
@@ -131,6 +134,9 @@ export class InputSystem {
     isPointerPressed() {
         return this._pointerPressed;
     }
+    isPointerCancelled() {
+        return this._pointerCancelled;
+    }
     isPointerDownOverSprite(sprite) {
         if (!sprite)
             return false;
@@ -185,11 +191,38 @@ export class InputSystem {
         for (const pointer of this._touchPointers.values()) {
             pointer.pressed = false;
         }
+        if (this._releasedTouch)
+            this._releasedTouch.pressed = false;
+        this._pointerCancelled = false;
         this.syncPrimaryPointer();
     }
     resetPressedState() {
         this.clearFramePressedState();
     }
+    /**
+     * Removes the touches an event ended. When the primary one lifts, it is kept
+     * as the released touch at the point it lifted, carrying its frame-press flag
+     * so a tap that starts and ends between two frames still reads as pressed.
+     *
+     * @internal
+     */
+    endTouches(e, cancelled) {
+        for (const touch of Array.from(e.changedTouches)) {
+            const pointer = this._touchPointers.get(touch.identifier);
+            this._touchPointers.delete(touch.identifier);
+            if (this._primaryTouchId !== touch.identifier || !pointer)
+                continue;
+            this._primaryTouchId = null;
+            if (!cancelled) {
+                const p = this.getCanvasPoint(touch.clientX, touch.clientY);
+                pointer.x = p.x;
+                pointer.y = p.y;
+            }
+            this._releasedTouch = pointer;
+            this._pointerCancelled = cancelled;
+        }
+        this.syncPrimaryPointer();
+    }
     /** @internal */
     getCanvasPoint(clientX, clientY) {
         const rect = this.canvas.getBoundingClientRect();
@@ -257,9 +290,10 @@ export class InputSystem {
             }
         }
         this._primaryTouchId = null;
-        this._pointerX = this._mouseX;
-        this._pointerY = this._mouseY;
+        const released = this._releasedTouch;
+        this._pointerX = released ? released.x : this._mouseX;
+        this._pointerY = released ? released.y : this._mouseY;
         this._pointerDown = this._mouseDown;
-        this._pointerPressed = this._mousePressed;
+        this._pointerPressed = this._mousePressed || (released?.pressed ?? false);
     }
 }

package/dist/minimo-cards.js

@@ -658,7 +658,10 @@ export class CardTable {
             return;
         }
         this._press = null;
-        if (this._drag)
+        // A cancelled touch was interrupted, not released: return the cards, tap nothing.
+        if (game.isPointerCancelled())
+            this.cancelDrag();
+        else if (this._drag)
             this.finishDrag();
         else if (Math.hypot(x - press.x, y - press.y) < this.dragThreshold)
             this.onTap?.(press.card, press.pile);

package/dist/minimo.js

@@ -1816,6 +1816,15 @@ export class Game {
     isPointerPressed() {
         return this._inputSystem.isPointerPressed();
     }
+    /**
+     * True on the frame the primary touch ended in a `touchcancel` rather than
+     * lifting, so a module can drop the gesture instead of reading it as a tap.
+     *
+     * @internal
+     */
+    isPointerCancelled() {
+        return this._inputSystem.isPointerCancelled();
+    }
     /**
      * Returns `true` while any active pointer is held down over the target sprite.
      * Works with both mouse input and multiple simultaneous touches.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minimojs",
-  "version": "1.0.0-alpha.25",
+  "version": "1.0.0-alpha.26",
   "description": "MinimoJS v1 — ultra-minimal, flat, deterministic 2D web game engine. Image-first sprites with emoji as a zero-asset alternative, rAF loop, TypeScript-first, LLM-friendly.",
   "type": "module",
   "main": "dist/minimo.js",