@vpmedia/phaser 1.102.0 → 1.104.0

package/src/phaser/display/{button.js → button.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { BUTTON, POINTER_CONTACT } from '../core/const.js';
 import { InputHandler } from '../core/input_handler.js';
 import { Signal } from '../core/signal.js';
@@ -10,6 +11,34 @@ const STATE_UP = 'Up';
 const STATE_DISABLED = 'Disabled';
 
 export class Button extends Image {
+  /** @type {string | null} */
+  _onOverFrame;
+  /** @type {string | null} */
+  _onOutFrame;
+  /** @type {string | null} */
+  _onDownFrame;
+  /** @type {string | null} */
+  _onUpFrame;
+  /** @type {string | null} */
+  _onDisabledFrame;
+  /** @type {Signal} */
+  onInputOver;
+  /** @type {Signal} */
+  onInputOut;
+  /** @type {Signal} */
+  onInputDown;
+  /** @type {Signal} */
+  onInputUp;
+  /** @type {boolean} */
+  onOverMouseOnly;
+  /** @type {number} */
+  justReleasedPreventsOver;
+  /** @type {boolean} */
+  freezeFrames;
+  /** @type {boolean} */
+  forceOut;
+  /** @type {InputHandler} */
+  input;
   /**
    * Creates a new Button instance.
    * @param {import('../core/game.js').Game} game - The game instance this button belongs to.

package/src/phaser/display/canvas/{buffer.js → buffer.ts}

@@ -1,6 +1,11 @@
+// @ts-nocheck
 import { create, removeByCanvas } from './pool.js';
 
 export class CanvasBuffer {
+width;
+height;
+canvas;
+context;
   /**
    * Creates a new CanvasBuffer instance.
    * @param {number} width - The width of the canvas buffer.

package/src/phaser/display/canvas/{graphics.js → graphics.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { GEOM_CIRCLE, GEOM_ELLIPSE, GEOM_POLYGON, GEOM_RECTANGLE, GEOM_ROUNDED_RECTANGLE } from '../../core/const.js';
 
 /**

package/src/phaser/display/canvas/{masker.js → masker.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { renderGraphicsMask } from './graphics.js';
 
 /**

package/src/phaser/display/canvas/{pool.js → pool.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /**
  * Gets the canvas pool array.
  * @returns {{canvas: HTMLCanvasElement, parent: object}[]} The canvas pool array.

package/src/phaser/display/canvas/{renderer.js → renderer.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import {
   BLEND_ADD,
   BLEND_COLOR,
@@ -26,6 +27,19 @@ import { detectCapabilities } from './tinter.js';
 import { getSmoothingPrefix } from './util.js';
 
 export class CanvasRenderer {
+type;
+resolution;
+clearBeforeRender;
+transparent;
+autoResize;
+contextLost;
+width;
+height;
+view;
+context;
+refresh;
+count;
+renderSession;
   /**
    * Creates a new CanvasRenderer instance.
    * @param {import('../../core/game.js').Game} game - The game instance.

package/src/phaser/display/canvas/{tinter.js → tinter.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { ENGINE_ERROR_CREATING_CANVAS_2D_CONTEXT, ENGINE_ERROR_GETTING_DOCUMENT } from '../../core/error_code.js';
 import { hex2rgb } from '../../util/math.js';
 import { create, removeByCanvas } from './pool.js';

package/src/phaser/display/{display_object.js → display_object.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { Matrix } from '../geom/matrix.js';
 import { Point } from '../geom/point.js';
 import { Rectangle } from '../geom/rectangle.js';
@@ -6,6 +7,62 @@ import { PI_2 } from '../util/math.js';
 import { renderCanvas, renderWebGL } from './sprite_util.js';
 
 export class DisplayObject {
+  /** @type {boolean} */
+  exists = true;
+  /** @type {boolean} */
+  renderable = false;
+  /** @type {boolean} */
+  visible = true;
+  /** @type {Point} */
+  position;
+  /** @type {Point} */
+  scale;
+  /** @type {Point} */
+  pivot;
+  /** @type {Point} */
+  anchor;
+  /** @type {number} */
+  rotation = 0;
+  /** @type {number} */
+  alpha = 1;
+  /** @type {Rectangle} */
+  hitArea = null;
+  /** @type {DisplayObject} */
+  parent = null;
+  /** @type {number} */
+  worldAlpha = 1;
+  /** @type {Matrix} */
+  worldTransform;
+  /** @type {Point} */
+  worldScale;
+  /** @type {Rectangle} */
+  filterArea = null;
+  /** @type {number} */
+  _sr = 0;
+  /** @type {number} */
+  _cr = 1;
+  /** @type {Rectangle} */
+  cachedBounds;
+  /** @type {Rectangle} */
+  currentBounds = null;
+  /** @type {import('./graphics.js').Graphics} */
+  _mask = null;
+  /** @type {object[]} */
+  _filters = null;
+  /** @type {object} */
+  _filterBlock = null;
+  /** @type {DisplayObject[]} */
+  children;
+  /** @type {boolean} */
+  ignoreChildInput = false;
+  /** @type {string | null} */
+  name = null;
+  /** @type {object | null} */
+  data = null;
+  /** @type {import('../core/game.js').Game} */
+  game;
+  /** @type {number} */
+  type;
   /**
    * Creates a new DisplayObject instance.
    * @param {import('../core/game.js').Game} game - The game instance this display object belongs to.
@@ -37,10 +94,10 @@ export class DisplayObject {
     this.worldAlpha = 1;
     /** @type {Matrix} */
     this.worldTransform = new Matrix();
-    // this.worldPosition = new Point(0, 0);
+    // This.worldPosition = new Point(0, 0);
     /** @type {Point} */
     this.worldScale = new Point(1, 1);
-    // this.worldRotation = 0;
+    // This.worldRotation = 0;
     /** @type {Rectangle} */
     this.filterArea = null;
     /** @type {number} */
@@ -85,7 +142,7 @@ export class DisplayObject {
     this.visible = false;
     // TODO: investigate how to clean up properly object references without breaking delayed tween cleanups.
     /*
-    this.position = null;
+    This.position = null;
     this.scale = null;
     this.pivot = null;
     this.anchor = null;
@@ -93,7 +150,7 @@ export class DisplayObject {
     this.hitArea = null;
     this.parent = null;
     this.worldTransform = null;
-    // this.worldPosition = null;
+    // This.worldPosition = null;
     this.worldScale = null;
     this.filterArea = null;
     this.cachedBounds = null;
@@ -174,8 +231,8 @@ export class DisplayObject {
       throw new Error('The supplied index is out of bounds');
     }
     const currentIndex = this.getChildIndex(child);
-    this.children.splice(currentIndex, 1); // remove from old position
-    this.children.splice(index, 0, child); // add at new position
+    this.children.splice(currentIndex, 1); // Remove from old position
+    this.children.splice(index, 0, child); // Add at new position
   }
 
   /**
@@ -269,37 +326,37 @@ export class DisplayObject {
     } else if (!this.parent) {
       p = this.game.world;
     }
-    // create some matrix refs for easy access
+    // Create some matrix refs for easy access
     const pt = p.worldTransform;
     const wt = this.worldTransform;
-    // temporary matrix variables
+    // Temporary matrix variables
     let a;
     let b;
     let c;
     let d;
     let tx;
     let ty;
-    // so if rotation is between 0 then we can simplify the multiplication process..
+    // So if rotation is between 0 then we can simplify the multiplication process..
     if (this.rotation % PI_2) {
-      // check to see if the rotation is the same as the previous render. This means we only need to use sin and cos when rotation actually changes
+      // Check to see if the rotation is the same as the previous render. This means we only need to use sin and cos when rotation actually changes
       if (this.rotation !== this.rotationCache) {
         this.rotationCache = this.rotation;
         this._sr = Math.sin(this.rotation);
         this._cr = Math.cos(this.rotation);
       }
-      // get the matrix values of the displayobject based on its transform properties..
+      // Get the matrix values of the displayobject based on its transform properties..
       a = this._cr * this.scale.x;
       b = this._sr * this.scale.x;
       c = -this._sr * this.scale.y;
       d = this._cr * this.scale.y;
       tx = this.position.x;
       ty = this.position.y;
-      // check for pivot.. not often used so geared towards that fact!
+      // Check for pivot.. not often used so geared towards that fact!
       if (this.pivot.x || this.pivot.y) {
         tx -= this.pivot.x * a + this.pivot.y * c;
         ty -= this.pivot.x * b + this.pivot.y * d;
       }
-      // concat the parent matrix with the objects transform.
+      // Concat the parent matrix with the objects transform.
       wt.a = a * pt.a + b * pt.c;
       wt.b = a * pt.b + b * pt.d;
       wt.c = c * pt.a + d * pt.c;
@@ -307,7 +364,7 @@ export class DisplayObject {
       wt.tx = tx * pt.a + ty * pt.c + pt.tx;
       wt.ty = tx * pt.b + ty * pt.d + pt.ty;
     } else {
-      // lets do the fast version as we know there is no rotation..
+      // Lets do the fast version as we know there is no rotation..
       a = this.scale.x;
       d = this.scale.y;
       tx = this.position.x - this.pivot.x * a;
@@ -321,13 +378,13 @@ export class DisplayObject {
     }
     //  Set the World values
     this.worldAlpha = this.alpha * p.worldAlpha;
-    // this.worldPosition.setTo(wt.tx, wt.ty);
+    // This.worldPosition.setTo(wt.tx, wt.ty);
     this.worldScale.setTo(
       this.scale.x * Math.sqrt(wt.a * wt.a + wt.c * wt.c),
       this.scale.y * Math.sqrt(wt.b * wt.b + wt.d * wt.d)
     );
     this.worldRotation = Math.atan2(-wt.c, wt.d);
-    // reset the bounds each time this is called!
+    // Reset the bounds each time this is called!
     this.currentBounds = null;
     //  Custom callback?
     if (this.transformCallback) {
@@ -391,13 +448,13 @@ export class DisplayObject {
       const w1 = bounds.width + bounds.x;
       const h0 = bounds.y;
       const h1 = bounds.height + bounds.y;
-      const worldTransform = this.worldTransform;
-      const a = worldTransform.a;
-      const b = worldTransform.b;
-      const c = worldTransform.c;
-      const d = worldTransform.d;
-      const tx = worldTransform.tx;
-      const ty = worldTransform.ty;
+      const { worldTransform } = this;
+      const { a } = worldTransform;
+      const { b } = worldTransform;
+      const { c } = worldTransform;
+      const { d } = worldTransform;
+      const { tx } = worldTransform;
+      const { ty } = worldTransform;
       const x1 = a * w1 + c * h1 + tx;
       const y1 = d * h1 + b * w1 + ty;
       const x2 = a * w0 + c * h1 + tx;
@@ -474,7 +531,7 @@ export class DisplayObject {
     }
     let i;
     if (this._mask || this._filters) {
-      // push filter first as we need to ensure the stencil buffer is correct for any masking
+      // Push filter first as we need to ensure the stencil buffer is correct for any masking
       if (this._filters) {
         renderSession.spriteBatch.flush();
         renderSession.filterManager.pushFilter(this._filterBlock);
@@ -488,8 +545,12 @@ export class DisplayObject {
         this.children[i].renderWebGL(renderSession);
       }
       renderSession.spriteBatch.stop();
-      if (this._mask) renderSession.maskManager.popMask(this._mask, renderSession);
-      if (this._filters) renderSession.filterManager.popFilter();
+      if (this._mask) {
+        renderSession.maskManager.popMask(this._mask, renderSession);
+      }
+      if (this._filters) {
+        renderSession.filterManager.popFilter();
+      }
       renderSession.spriteBatch.start();
     } else {
       for (i = 0; i < this.children.length; i += 1) {
@@ -521,21 +582,21 @@ export class DisplayObject {
    * Called before the update cycle for this display object.
    */
   preUpdate() {
-    // override
+    // Override
   }
 
   /**
    * Called during the update cycle for this display object.
    */
   update() {
-    // override
+    // Override
   }
 
   /**
    * Called after the update cycle for this display object.
    */
   postUpdate() {
-    // override
+    // Override
   }
 
   /**
@@ -620,7 +681,7 @@ export class DisplayObject {
    * @param {number} value - The new width in pixels.
    */
   set width(value) {
-    const width = this.getLocalBounds().width;
+    const { width } = this.getLocalBounds();
     if (width !== 0) {
       this.scale.x = value / width;
     } else {
@@ -642,7 +703,7 @@ export class DisplayObject {
    * @param {number} value - The new height in pixels.
    */
   set height(value) {
-    const height = this.getLocalBounds().height;
+    const { height } = this.getLocalBounds();
     if (height !== 0) {
       this.scale.y = value / height;
     } else {

package/src/phaser/display/{graphics.js → graphics.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import {
   BLEND_NORMAL,
   GEOM_CIRCLE,
@@ -25,6 +26,24 @@ import { renderGraphics as renderWebGLGraphics } from './webgl/graphics.js';
 import { textureFromCanvas } from './webgl/texture_util.js';
 
 export class Graphics extends DisplayObject {
+type;
+renderable;
+fillAlpha;
+lineWidth;
+lineColor;
+graphicsData;
+tint;
+blendMode;
+currentPath;
+_webGL;
+isMask;
+boundsPadding;
+_localBounds;
+dirty;
+_boundsDirty;
+_cacheAsBitmap;
+webGLDirty;
+cachedSpriteDirty;
   /**
    * Creates a new Graphics object.
    * @param {import('../core/game.js').Game} game - The game instance.

package/src/phaser/display/{graphics_data.js → graphics_data.ts}

@@ -1,6 +1,17 @@
+// @ts-nocheck
 import { clone } from './graphics_data_util.js';
 
 export class GraphicsData {
+lineWidth;
+lineColor;
+lineAlpha;
+_lineTint;
+fillColor;
+fillAlpha;
+_fillTint;
+fill;
+shape;
+type;
   /**
    * Creates a new GraphicsData object.
    * @param {number} lineWidth - The line width.

package/src/phaser/display/{graphics_data_util.js → graphics_data_util.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { GraphicsData } from './graphics_data.js';
 
 /**

package/src/phaser/display/{group.js → group.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { GROUP } from '../core/const.js';
 import { Signal } from '../core/signal.js';
 import { DisplayObject } from './display_object.js';
@@ -7,6 +8,34 @@ export const SORT_ASCENDING = -1;
 export const SORT_DESCENDING = 1;
 
 export class Group extends DisplayObject {
+  /** @type {number} */
+  z;
+  /** @type {boolean} */
+  ignoreDestroy;
+  /** @type {boolean} */
+  pendingDestroy;
+  /** @type {Function} */
+  classType;
+  /** @type {DisplayObject | null} */
+  cursor;
+  /** @type {boolean} */
+  inputEnableChildren;
+  /** @type {Signal} */
+  onChildInputDown;
+  /** @type {Signal} */
+  onChildInputUp;
+  /** @type {Signal} */
+  onChildInputOver;
+  /** @type {Signal} */
+  onChildInputOut;
+  /** @type {Signal} */
+  onDestroy;
+  /** @type {number} */
+  cursorIndex;
+  /** @type {string} */
+  _sortProperty;
+  /** @type {object[] | null} */
+  filters;
   /**
    * Creates a new Group object.
    * @param {import('../core/game.js').Game} game - The game instance this group belongs to.

package/src/phaser/display/{image.js → image.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { AnimationManager } from '../core/animation_manager.js';
 import { BLEND_NORMAL, IMAGE, PENDING_ATLAS, SCALE_NEAREST } from '../core/const.js';
 import { EventManager } from '../core/event_manager.js';
@@ -8,6 +9,44 @@ import { getBounds, getLocalBounds, renderCanvas, renderWebGL, setTexture } from
 import { Texture } from './webgl/texture.js';
 
 export class Image extends DisplayObject {
+  /** @type {string | number | Texture} */
+  key;
+  /** @type {Texture} */
+  texture;
+  /** @type {number} */
+  _width;
+  /** @type {number} */
+  _height;
+  /** @type {number} */
+  tint;
+  /** @type {number} */
+  cachedTint;
+  /** @type {Texture | null} */
+  tilingTexture;
+  /** @type {Texture | null} */
+  tintedTexture;
+  /** @type {number} */
+  blendMode;
+  /** @type {object | null} */
+  shader;
+  /** @type {import('../core/frame.js').Frame | null} */
+  _frame;
+  /** @type {boolean} */
+  pendingDestroy;
+  /** @type {EventManager} */
+  events;
+  /** @type {AnimationManager} */
+  animations;
+  /** @type {boolean} */
+  customRender;
+  /** @type {Rectangle | null} */
+  cropRect;
+  /** @type {Rectangle | null} */
+  _crop;
+  /** @type {boolean} */
+  refreshTexture;
+  /** @type {number} */
+  renderOrderID;
   /**
    * Creates a new Image instance.
    * @param {import('../core/game.js').Game} game - The game instance this image belongs to.
@@ -32,7 +71,7 @@ export class Image extends DisplayObject {
     /** @type {number} */
     this._height = 0;
     /** @type {number} */
-    this.tint = 0xffffff;
+    this.tint = 0xff_ff_ff;
     /** @type {number} */
     this.cachedTint = -1;
     /** @type {Texture | null} */
@@ -45,7 +84,7 @@ export class Image extends DisplayObject {
     this._frame = null;
     /** @type {boolean} */
     this.pendingDestroy = false;
-    /* if (this.texture.baseTexture.hasLoaded) {
+    /* If (this.texture.baseTexture.hasLoaded) {
       this.onTextureUpdate();
     } */
     this.position.setTo(x, y);
@@ -64,7 +103,7 @@ export class Image extends DisplayObject {
     this.key = null;
     this.data = null;
     this.texture = null;
-    this.tint = 0xffffff;
+    this.tint = 0xff_ff_ff;
     this.cachedTint = -1;
     this.tintedTexture = null;
     this.shader = null;
@@ -112,7 +151,7 @@ export class Image extends DisplayObject {
    * @param {string | number | null | undefined} frame - The frame identifier (name or index) to use.
    * @param {boolean} stopAnimation - Whether to stop the animation when changing textures.
    */
-  loadTexture(key, frame = 0, stopAnimation = true) {
+  loadTexture(key, frame: string | number | null = 0, stopAnimation = true) {
     if (key === PENDING_ATLAS) {
       key = frame;
       frame = 0;
@@ -124,7 +163,7 @@ export class Image extends DisplayObject {
     }
     this.key = key;
     this.customRender = false;
-    const cache = this.game.cache;
+    const { cache } = this.game;
     const smoothed = !this.texture.baseTexture.scaleMode;
     let setFrame = true;
     if (key instanceof Texture) {
@@ -341,7 +380,7 @@ export class Image extends DisplayObject {
    * Called when the texture of this image is updated.
    */
   onTextureUpdate() {
-    // so if _width is 0 then width was not set..
+    // So if _width is 0 then width was not set..
     if (this._width) {
       this.scale.x = this._width / this.texture.frame.width;
     }

package/src/phaser/display/{sprite_batch.js → sprite_batch.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { DisplayObject } from './display_object.js';
 
 export class SpriteBatch extends DisplayObject {

package/src/phaser/display/{sprite_util.js → sprite_util.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { SCALE_LINEAR } from '../core/const.js';
 import { getIdentityMatrix } from '../geom/util/matrix.js';
 import { getTintedTexture } from './canvas/tinter.js';

package/src/phaser/display/{text.js → text.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { TEXT } from '../core/const.js';
 import { Point } from '../geom/point.js';
 import { Rectangle } from '../geom/rectangle.js';

package/src/phaser/display/webgl/{abstract_filter.js → abstract_filter.ts}

@@ -1,4 +1,11 @@
+// @ts-nocheck
 export class AbstractFilter {
+passes;
+shaders;
+dirty;
+padding;
+uniforms;
+fragmentSrc;
   /**
    * Creates a new AbstractFilter instance.
    * @param {string[]} fragmentSrc - The fragment shader source.

package/src/phaser/display/webgl/{base_texture.js → base_texture.ts}

@@ -1,6 +1,19 @@
+// @ts-nocheck
 import { removeByCanvas } from '../canvas/pool.js';
 
 export class BaseTexture {
+resolution;
+width;
+height;
+scaleMode;
+hasLoaded;
+source;
+premultipliedAlpha;
+_glTextures;
+mipmap;
+skipRender;
+_powerOf2;
+_dirty;
   /**
    * Updates the base texture with a new source.
    * @param {HTMLCanvasElement} source - The new canvas element to use as the texture source.

package/src/phaser/display/webgl/{blend_manager.js → blend_manager.ts}

@@ -1,4 +1,7 @@
+// @ts-nocheck
 export class WebGLBlendModeManager {
+gl;
+currentBlendMode;
   /**
    * Creates a new BlendModeManager instance.
    */

package/src/phaser/display/webgl/{earcut.js → earcut.ts}

@@ -415,7 +415,7 @@ export function linkedList(data, start, end, dim, clockwise) {
  * @param {object} end - The ending point in the data structure.
  * @returns {object} The calculated bounding box with min and max coordinates.
  */
-export function filterPoints(start, end) {
+export function filterPoints(start, end?) {
   if (!start) return start;
   if (!end) end = start;
   let p = start;
@@ -599,7 +599,7 @@ export function splitEarcut(start, triangles, dim, minX, minY, size) {
  * @param {number} size - The size of the bounding box.
  * @param {object} pass - The pass information for triangulation.
  */
-export function earcutLinked(ear, triangles, dim, minX, minY, size, pass) {
+export function earcutLinked(ear, triangles, dim, minX?, minY?, size?, pass?) {
   if (!ear) return;
   // interlink polygon nodes in z-order
   if (!pass && size) indexCurve(ear, minX, minY, size);

package/src/phaser/display/webgl/{earcut_node.js → earcut_node.ts}

@@ -1,4 +1,14 @@
 export class Node {
+  i: number;
+  x: number;
+  y: number;
+  prev: Node | null;
+  next: Node | null;
+  z: number | null;
+  prevZ: Node | null;
+  nextZ: Node | null;
+  steiner: boolean;
+
   /**
    * Creates a new Node instance.
    * @param {number} i - The vertice index in coordinates array.

package/src/phaser/display/webgl/{fast_sprite_batch.js → fast_sprite_batch.ts}

@@ -1,4 +1,20 @@
+// @ts-nocheck
 export class FastSpriteBatch {
+vertSize;
+maxSize;
+size;
+vertices;
+indices;
+vertexBuffer;
+indexBuffer;
+lastIndexCount;
+drawing;
+currentBatchSize;
+currentBaseTexture;
+currentBlendMode;
+renderSession;
+shader;
+matrix;
   /**
    * Creates a new FastSpriteBatch instance.
    * @param {WebGLRenderingContext & { id: number }} gl - The WebGL rendering context.