@vpmedia/phaser 1.109.0 → 1.110.0

package/src/phaser/core/input.ts

@@ -15,28 +15,28 @@ const MAX_POINTERS = 10;
 
 export class Input {
   game!: any;
-  hitCanvas!: any;
+  hitCanvas!: HTMLCanvasElement;
   hitContext!: any;
-  moveCallbacks!: any;
+  moveCallbacks!: { callback: Function; context: any }[];
   lockCallbacks!: any;
   customCandidateHandler!: any;
   customCandidateHandlerContext!: any;
-  pollRate!: any;
-  enabled!: any;
-  multiInputOverride!: any;
-  position!: any;
-  speed!: any;
-  circle!: any;
-  scale!: any;
-  maxPointers!: any;
-  tapRate!: any;
-  doubleTapRate!: any;
-  holdRate!: any;
-  justPressedRate!: any;
-  justReleasedRate!: any;
-  recordPointerHistory!: any;
-  recordRate!: any;
-  recordLimit!: any;
+  pollRate!: number;
+  enabled!: boolean;
+  multiInputOverride!: number;
+  position!: Point;
+  speed!: Point;
+  circle!: Circle;
+  scale!: Point;
+  maxPointers!: number;
+  tapRate!: number;
+  doubleTapRate!: number;
+  holdRate!: number;
+  justPressedRate!: number;
+  justReleasedRate!: number;
+  recordPointerHistory!: boolean;
+  recordRate!: number;
+  recordLimit!: number;
   pointer1!: any;
   pointer2!: any;
   pointer3!: any;
@@ -47,32 +47,32 @@ export class Input {
   pointer8!: any;
   pointer9!: any;
   pointer10!: any;
-  pointers!: any;
-  activePointer!: any;
-  mousePointer!: any;
-  mouse!: any;
-  touch!: any;
-  mspointer!: any;
-  resetLocked!: any;
-  onDown!: any;
-  onUp!: any;
-  onTap!: any;
-  onHold!: any;
-  minPriorityID!: any;
-  interactiveItems!: any;
-  _localPoint!: any;
-  _pollCounter!: any;
-  _oldPosition!: any;
+  pointers!: Pointer[];
+  activePointer!: Pointer;
+  mousePointer!: Pointer;
+  mouse!: Mouse;
+  touch!: Touch;
+  mspointer!: MSPointer;
+  resetLocked!: boolean;
+  onDown!: Signal;
+  onUp!: Signal;
+  onTap!: Signal;
+  onHold!: Signal;
+  minPriorityID!: number;
+  interactiveItems!: ArraySet;
+  _localPoint!: Point;
+  _pollCounter!: number;
+  _oldPosition!: Point;
   _onClickTrampoline!: any;
-  _x!: any;
-  _y!: any;
+  _x!: number;
+  _y!: number;
   /**
    * TBD.
    * @param {import('./game.js').Game} game - TBD.
    */
   constructor(game: import('./game.js').Game) {
     this.game = game;
-    this.hitCanvas = null;
+    this.hitCanvas = null!;
     this.hitContext = null;
     this.moveCallbacks = [];
     this.lockCallbacks = [];
@@ -81,10 +81,10 @@ export class Input {
     this.pollRate = 0;
     this.enabled = true;
     this.multiInputOverride = MOUSE_TOUCH_COMBINE;
-    this.position = null;
-    this.speed = null;
-    this.circle = null;
-    this.scale = null;
+    this.position = null!;
+    this.speed = null!;
+    this.circle = null!;
+    this.scale = null!;
     this.maxPointers = 1;
     this.tapRate = 200;
     this.doubleTapRate = 300;
@@ -105,21 +105,21 @@ export class Input {
     this.pointer9 = null;
     this.pointer10 = null;
     this.pointers = [];
-    this.activePointer = null;
-    this.mousePointer = null;
-    this.mouse = null;
-    this.touch = null;
-    this.mspointer = null;
+    this.activePointer = null!;
+    this.mousePointer = null!;
+    this.mouse = null!;
+    this.touch = null!;
+    this.mspointer = null!;
     this.resetLocked = false;
-    this.onDown = null;
-    this.onUp = null;
-    this.onTap = null;
-    this.onHold = null;
+    this.onDown = null!;
+    this.onUp = null!;
+    this.onTap = null!;
+    this.onHold = null!;
     this.minPriorityID = 0;
     this.interactiveItems = new ArraySet();
     this._localPoint = new Point();
     this._pollCounter = 0;
-    this._oldPosition = null;
+    this._oldPosition = null!;
     this._x = 0;
     this._y = 0;
   }

package/src/phaser/core/input_handler.ts

@@ -2,48 +2,66 @@ import { Point } from '../geom/point.js';
 import { distance } from '../util/math.js';
 import { GROUP } from './const.js';
 
+interface PointerData {
+  id: number;
+  x: number;
+  y: number;
+  camX: number;
+  camY: number;
+  isDown: boolean;
+  isUp: boolean;
+  isOver: boolean;
+  isOut: boolean;
+  timeOver: number;
+  timeOut: number;
+  timeDown: number;
+  timeUp: number;
+  downDuration: number;
+  isDragged: boolean;
+}
+
 export class InputHandler {
   sprite!: any;
   game!: any;
-  enabled!: any;
-  checked!: any;
-  priorityID!: any;
-  useHandCursor!: any;
-  _setHandCursor!: any;
-  isDragged!: any;
-  allowHorizontalDrag!: any;
-  allowVerticalDrag!: any;
-  bringToTop!: any;
+  enabled!: boolean;
+  checked!: boolean;
+  priorityID!: number;
+  useHandCursor!: boolean;
+  _setHandCursor!: boolean;
+  isDragged!: boolean;
+  allowHorizontalDrag!: boolean;
+  allowVerticalDrag!: boolean;
+  bringToTop!: boolean;
   snapOffset!: any;
-  snapOnDrag!: any;
-  snapOnRelease!: any;
-  snapX!: any;
-  snapY!: any;
-  snapOffsetX!: any;
-  snapOffsetY!: any;
-  pixelPerfectOver!: any;
-  pixelPerfectClick!: any;
-  pixelPerfectAlpha!: any;
-  draggable!: any;
+  snapOnDrag!: boolean;
+  snapOnRelease!: boolean;
+  snapX!: number;
+  snapY!: number;
+  snapOffsetX!: number;
+  snapOffsetY!: number;
+  pixelPerfectOver!: boolean;
+  pixelPerfectClick!: boolean;
+  pixelPerfectAlpha!: number;
+  draggable!: boolean;
   boundsRect!: any;
   boundsSprite!: any;
-  scaleLayer!: any;
-  dragOffset!: any;
-  dragFromCenter!: any;
-  dragStopBlocksInputUp!: any;
-  dragStartPoint!: any;
-  dragDistanceThreshold!: any;
-  dragTimeThreshold!: any;
-  downPoint!: any;
-  snapPoint!: any;
-  _dragPoint!: any;
-  _dragPhase!: any;
-  _pendingDrag!: any;
-  _dragTimePass!: any;
-  _dragDistancePass!: any;
-  _wasEnabled!: any;
+  scaleLayer!: boolean;
+  dragOffset!: Point;
+  dragFromCenter!: boolean;
+  dragStopBlocksInputUp!: boolean;
+  dragStartPoint!: Point;
+  dragDistanceThreshold!: number;
+  dragTimeThreshold!: number;
+  downPoint!: Point;
+  snapPoint!: Point;
+  _dragPoint!: Point;
+  _dragPhase!: boolean;
+  _pendingDrag!: boolean;
+  _dragTimePass!: boolean;
+  _dragDistancePass!: boolean;
+  _wasEnabled!: boolean;
   _tempPoint!: import('../geom/point.js').Point;
-  _pointerData!: any;
+  _pointerData!: PointerData[];
   _dx!: any;
   _dy!: any;
   _draggedPointerID!: any;
@@ -130,6 +148,8 @@ export class InputHandler {
           id: i,
           x: 0,
           y: 0,
+          camX: 0,
+          camY: 0,
           isDown: false,
           isUp: false,
           isOver: false,
@@ -188,6 +208,8 @@ export class InputHandler {
         id: i,
         x: 0,
         y: 0,
+        camX: 0,
+        camY: 0,
         isDown: false,
         isUp: false,
         isOver: false,

package/src/phaser/core/input_mouse.ts

@@ -1,20 +1,22 @@
+import type { Input } from './input.js';
+
 export class Mouse {
   game!: any;
-  input!: any;
+  input!: Input;
   callbackContext!: any;
-  mouseDownCallback!: any;
-  mouseUpCallback!: any;
-  mouseOutCallback!: any;
-  mouseOverCallback!: any;
-  mouseWheelCallback!: any;
-  mouseMoveCallback!: any;
-  capture!: any;
-  button!: any;
-  wheelDelta!: any;
-  enabled!: any;
-  locked!: any;
-  stopOnGameOut!: any;
-  event!: any;
+  mouseDownCallback!: ((event: MouseEvent) => void) | null;
+  mouseUpCallback!: ((event: MouseEvent) => void) | null;
+  mouseOutCallback!: ((event: MouseEvent) => void) | null;
+  mouseOverCallback!: ((event: MouseEvent) => void) | null;
+  mouseWheelCallback!: ((event: WheelEvent) => void) | null;
+  mouseMoveCallback!: ((event: MouseEvent) => void) | null;
+  capture!: boolean;
+  button!: number;
+  wheelDelta!: number;
+  enabled!: boolean;
+  locked!: boolean;
+  stopOnGameOut!: boolean;
+  event!: MouseEvent | WheelEvent | null;
   _onMouseDown!: ((event: MouseEvent) => void) | null;
   _onMouseMove!: ((event: MouseEvent) => void) | null;
   _onMouseUp!: ((event: MouseEvent) => void) | null;

package/src/phaser/core/input_pointer.ts

@@ -11,47 +11,47 @@ import {
 
 export class Pointer {
   game!: any;
-  id!: any;
-  type!: any;
-  exists!: any;
-  identifier!: any;
+  id!: number;
+  type!: number;
+  exists!: boolean;
+  identifier!: number | null;
   pointerId!: any;
-  pointerMode!: any;
+  pointerMode!: number;
   target!: any;
   button!: any;
-  _holdSent!: any;
+  _holdSent!: boolean;
   _history!: any;
-  _nextDrop!: any;
-  _stateReset!: any;
-  withinGame!: any;
-  clientX!: any;
-  clientY!: any;
-  pageX!: any;
-  pageY!: any;
-  screenX!: any;
-  screenY!: any;
-  rawMovementX!: any;
-  rawMovementY!: any;
-  movementX!: any;
-  movementY!: any;
-  x!: any;
-  y!: any;
-  isMouse!: any;
-  isDown!: any;
-  isUp!: any;
-  timeDown!: any;
-  timeUp!: any;
-  previousTapTime!: any;
-  totalTouches!: any;
-  msSinceLastClick!: any;
+  _nextDrop!: number;
+  _stateReset!: boolean;
+  withinGame!: boolean;
+  clientX!: number;
+  clientY!: number;
+  pageX!: number;
+  pageY!: number;
+  screenX!: number;
+  screenY!: number;
+  rawMovementX!: number;
+  rawMovementY!: number;
+  movementX!: number;
+  movementY!: number;
+  x!: number;
+  y!: number;
+  isMouse!: boolean;
+  isDown!: boolean;
+  isUp!: boolean;
+  timeDown!: number;
+  timeUp!: number;
+  previousTapTime!: number;
+  totalTouches!: number;
+  msSinceLastClick!: number;
   targetObject!: any;
   interactiveCandidates!: any;
-  active!: any;
-  dirty!: any;
-  position!: any;
-  positionDown!: any;
-  positionUp!: any;
-  circle!: any;
+  active!: boolean;
+  dirty!: boolean;
+  position!: Point;
+  positionDown!: Point;
+  positionUp!: Point;
+  circle!: Circle;
   _clickTrampolines!: any;
   _trampolineTargetObject!: any;
   /**
@@ -63,10 +63,8 @@ export class Pointer {
   constructor(game: import('./game.js').Game, id: number, pointerMode: number) {
     this.game = game;
     this.id = id;
-    /** @type {number} */
     this.type = POINTER;
     this.exists = true;
-    /** @type {number} */
     this.identifier = 0;
     this.pointerId = null;
     this.pointerMode = pointerMode || POINTER_CURSOR | POINTER_CONTACT;
@@ -74,43 +72,27 @@ export class Pointer {
     this.button = null;
     this._holdSent = false;
     this._history = [];
-    /** @type {number} */
     this._nextDrop = 0;
     this._stateReset = false;
     this.withinGame = false;
     this.clientX = -1;
-    /** @type {number} */
     this.clientY = -1;
-    /** @type {number} */
     this.pageX = -1;
-    /** @type {number} */
     this.pageY = -1;
-    /** @type {number} */
     this.screenX = -1;
-    /** @type {number} */
     this.screenY = -1;
-    /** @type {number} */
     this.rawMovementX = 0;
-    /** @type {number} */
     this.rawMovementY = 0;
-    /** @type {number} */
     this.movementX = 0;
-    /** @type {number} */
     this.movementY = 0;
-    /** @type {number} */
     this.x = -1;
-    /** @type {number} */
     this.y = -1;
     this.isMouse = id === 0;
     this.isDown = false;
     this.isUp = true;
-    /** @type {number} */
     this.timeDown = 0;
-    /** @type {number} */
     this.timeUp = 0;
-    /** @type {number} */
     this.previousTapTime = 0;
-    /** @type {number} */
     this.totalTouches = 0;
     this.msSinceLastClick = Number.MAX_VALUE;
     this.targetObject = null;

package/src/phaser/core/loader.ts

@@ -1,6 +1,8 @@
 import { Rectangle } from '../geom/rectangle.js';
 import { canPlayAudio } from './device_util.js';
 import { ENGINE_ERROR_INVALID_BITMAP_FONT_ATLAS } from './error_code.js';
+import type { Cache } from './cache.js';
+import type { Game } from './game.js';
 import { Signal } from './signal.js';
 
 const TEXTURE_ATLAS_JSON_HASH = 1;
@@ -17,39 +19,39 @@ export interface LoaderFile {
 }
 
 export class Loader {
-  game!: any;
-  cache!: any;
-  isLoading!: any;
-  isUseLog!: any;
-  isUseRetry!: any;
-  maxRetry!: any;
-  hasLoaded!: any;
+  game!: Game;
+  cache!: Cache;
+  isLoading!: boolean;
+  isUseLog!: boolean;
+  isUseRetry!: boolean;
+  maxRetry!: number;
+  hasLoaded!: boolean;
   preloadSprite!: any;
-  crossOrigin!: any;
-  baseURL!: any;
-  path!: any;
-  headers!: any;
-  onLoadStart!: any;
-  onLoadComplete!: any;
-  onPackComplete!: any;
-  onFileStart!: any;
-  onFileComplete!: any;
-  onFileError!: any;
-  maxParallelDownloads!: any;
-  _withSyncPointDepth!: any;
+  crossOrigin!: boolean | string;
+  baseURL!: string;
+  path!: string;
+  headers!: Record<string, string | false>;
+  onLoadStart!: Signal;
+  onLoadComplete!: Signal;
+  onPackComplete!: Signal;
+  onFileStart!: Signal;
+  onFileComplete!: Signal;
+  onFileError!: Signal;
+  maxParallelDownloads!: number;
+  _withSyncPointDepth!: number;
   _fileList!: any;
   _flightQueue!: any;
-  _processingHead!: any;
-  _fileLoadStarted!: any;
-  _totalPackCount!: any;
-  _totalFileCount!: any;
-  _loadedPackCount!: any;
-  _loadedFileCount!: any;
+  _processingHead!: number;
+  _fileLoadStarted!: boolean;
+  _totalPackCount!: number;
+  _totalFileCount!: number;
+  _loadedPackCount!: number;
+  _loadedFileCount!: number;
   /**
    * Creates a new Loader instance.
    * @param {import('./game.js').Game} game - Reference to the Phaser Game instance.
    */
-  constructor(game: import('./game.js').Game) {
+  constructor(game: Game) {
     this.game = game;
     this.cache = game.cache;
     this.isLoading = false;
@@ -896,8 +898,9 @@ export class Loader {
     if (this.headers.requestedWith !== false) {
       xhr.setRequestHeader('X-Requested-With', this.headers.requestedWith);
     }
-    if (this.headers[file.type]) {
-      xhr.setRequestHeader('Accept', this.headers[file.type]);
+    const acceptHeader = this.headers[file.type];
+    if (acceptHeader) {
+      xhr.setRequestHeader('Accept', acceptHeader);
     }
     onerror = onerror || this.fileError;
     xhr.onload = () => {
@@ -1045,7 +1048,7 @@ export class Loader {
         break;
       case 'textureatlas':
         if (file.atlasURL == null) {
-          this.cache.addTextureAtlas(file.key, file.url, file.data, file.atlasData, file.format);
+          this.cache.addTextureAtlas(file.key, file.url, file.data, file.atlasData);
         } else {
           loadNext = false;
           if (file.format === TEXTURE_ATLAS_JSON_HASH) {
@@ -1124,7 +1127,7 @@ export class Loader {
     } else if (file.type === 'json') {
       this.cache.addJSON(file.key, file.url, data);
     } else {
-      this.cache.addTextureAtlas(file.key, file.url, file.data, data, file.format);
+      this.cache.addTextureAtlas(file.key, file.url, file.data, data);
     }
     this.asyncComplete(file);
   }
@@ -1155,7 +1158,7 @@ export class Loader {
     if (file.type === 'bitmapfont') {
       this.cache.addBitmapFont(file.key, file.url, file.data, xml, file.atlasType, file.xSpacing, file.ySpacing);
     } else if (file.type === 'textureatlas') {
-      this.cache.addTextureAtlas(file.key, file.url, file.data, xml, file.format);
+      this.cache.addTextureAtlas(file.key, file.url, file.data, xml);
     } else if (file.type === 'xml') {
       this.cache.addXML(file.key, file.url, xml);
     }