excalibur 0.25.1 → 0.25.2

package/build/esm/Input/PointerAbstraction.d.ts

@@ -0,0 +1,33 @@
+import { Class } from '../Class';
+import { Vector } from '../Math/vector';
+import { WheelEvent } from './WheelEvent';
+import { PointerEvent } from './PointerEvent';
+export declare class PointerAbstraction extends Class {
+    /**
+     * The last position on the document this pointer was at. Can be `null` if pointer was never active.
+     */
+    lastPagePos: Vector;
+    /**
+     * The last position on the screen this pointer was at. Can be `null` if pointer was never active.
+     */
+    lastScreenPos: Vector;
+    /**
+     * The last position in the game world coordinates this pointer was at. Can be `null` if pointer was never active.
+     */
+    lastWorldPos: Vector;
+    constructor();
+    on(event: 'move', handler: (event: PointerEvent) => void): void;
+    on(event: 'down', handler: (event: PointerEvent) => void): void;
+    on(event: 'up', handler: (event: PointerEvent) => void): void;
+    on(event: 'wheel', handler: (event: WheelEvent) => void): void;
+    once(event: 'move', handler: (event: PointerEvent) => void): void;
+    once(event: 'down', handler: (event: PointerEvent) => void): void;
+    once(event: 'up', handler: (event: PointerEvent) => void): void;
+    once(event: 'wheel', handler: (event: WheelEvent) => void): void;
+    off(event: 'move', handler?: (event: PointerEvent) => void): void;
+    off(event: 'down', handler?: (event: PointerEvent) => void): void;
+    off(event: 'up', handler?: (event: PointerEvent) => void): void;
+    off(event: 'wheel', handler?: (event: WheelEvent) => void): void;
+    private _onPointerMove;
+    private _onPointerDown;
+}

package/build/esm/Input/PointerButton.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The mouse button being pressed.
+ */
+export declare enum PointerButton {
+    Left = "Left",
+    Middle = "Middle",
+    Right = "Right",
+    Unknown = "Unknown",
+    NoButton = "NoButton"
+}

package/build/esm/Input/PointerComponent.d.ts

@@ -0,0 +1,24 @@
+import { Component } from '../EntityComponentSystem/Component';
+/**
+ * Add this component to optionally configure how the pointer
+ * system detects pointer events.
+ *
+ * By default the collider shape is used and graphics bounds is not.
+ *
+ * If both collider shape and graphics bounds are enabled it will fire events if either or
+ * are intersecting the pointer.
+ */
+export declare class PointerComponent extends Component<'ex.pointer'> {
+    readonly type = "ex.pointer";
+    /**
+     * Use any existing Collider component geometry for pointer events. This is useful if you want
+     * user pointer events only to trigger on the same collision geometry used in the collider component
+     * for collision resolution. Default is `true`.
+     */
+    useColliderShape: boolean;
+    /**
+     * Use any existing Graphics component bounds for pointers. This is useful if you want the axis aligned
+     * bounds around the graphic to trigger pointer events. Default is `false`.
+     */
+    useGraphicsBounds: boolean;
+}

package/build/esm/Input/PointerEvent.d.ts

@@ -0,0 +1,18 @@
+import { GlobalCoordinates } from '../Math/global-coordinates';
+import { Vector } from '../Math/vector';
+import { PointerButton } from './PointerButton';
+import { PointerType } from './PointerType';
+export declare class PointerEvent {
+    type: 'down' | 'up' | 'move' | 'cancel';
+    pointerId: number;
+    button: PointerButton;
+    pointerType: PointerType;
+    coordinates: GlobalCoordinates;
+    nativeEvent: Event;
+    active: boolean;
+    cancel(): void;
+    get pagePos(): Vector;
+    get screenPos(): Vector;
+    get worldPos(): Vector;
+    constructor(type: 'down' | 'up' | 'move' | 'cancel', pointerId: number, button: PointerButton, pointerType: PointerType, coordinates: GlobalCoordinates, nativeEvent: Event);
+}

package/build/esm/Input/PointerEventReceiver.d.ts

@@ -0,0 +1,114 @@
+import { Class } from '../Class';
+import { Engine } from '../Engine';
+import { GlobalCoordinates } from '../Math/global-coordinates';
+import { Vector } from '../Math/vector';
+import { PointerEvent } from './PointerEvent';
+import { WheelEvent } from './WheelEvent';
+import { PointerAbstraction } from './PointerAbstraction';
+export declare type NativePointerEvent = globalThis.PointerEvent;
+export declare type NativeMouseEvent = globalThis.MouseEvent;
+export declare type NativeTouchEvent = globalThis.TouchEvent;
+export declare type NativeWheelEvent = globalThis.WheelEvent;
+/**
+ * The PointerEventProcessor is responsible for collecting all the events from the canvas and transforming them into GlobalCoordinates
+ */
+export declare class PointerEventReceiver extends Class {
+    readonly target: GlobalEventHandlers & EventTarget;
+    engine: Engine;
+    primary: PointerAbstraction;
+    private _activeNativePointerIdsToNormalized;
+    lastFramePointerCoords: Map<number, GlobalCoordinates>;
+    currentFramePointerCoords: Map<number, GlobalCoordinates>;
+    currentFramePointerDown: Map<number, boolean>;
+    lastFramePointerDown: Map<number, boolean>;
+    currentFrameDown: PointerEvent[];
+    currentFrameUp: PointerEvent[];
+    currentFrameMove: PointerEvent[];
+    currentFrameCancel: PointerEvent[];
+    currentFrameWheel: WheelEvent[];
+    constructor(target: GlobalEventHandlers & EventTarget, engine: Engine);
+    private _pointers;
+    /**
+     * Locates a specific pointer by id, creates it if it doesn't exist
+     * @param index
+     */
+    at(index: number): PointerAbstraction;
+    /**
+     * The number of pointers currently being tracked by excalibur
+     */
+    count(): number;
+    /**
+     * Is the specified pointer id down this frame
+     * @param pointerId
+     */
+    isDown(pointerId: number): boolean;
+    /**
+     * Was the specified pointer id down last frame
+     * @param pointerId
+     */
+    wasDown(pointerId: number): boolean;
+    /**
+     * Whether the Pointer is currently dragging.
+     */
+    isDragging(pointerId: number): boolean;
+    /**
+     * Whether the Pointer just started dragging.
+     */
+    isDragStart(pointerId: number): boolean;
+    /**
+     * Whether the Pointer just ended dragging.
+     */
+    isDragEnd(pointerId: number): boolean;
+    on(event: 'move', handler: (event: PointerEvent) => void): void;
+    on(event: 'down', handler: (event: PointerEvent) => void): void;
+    on(event: 'up', handler: (event: PointerEvent) => void): void;
+    on(event: 'wheel', handler: (event: WheelEvent) => void): void;
+    once(event: 'move', handler: (event: PointerEvent) => void): void;
+    once(event: 'down', handler: (event: PointerEvent) => void): void;
+    once(event: 'up', handler: (event: PointerEvent) => void): void;
+    once(event: 'wheel', handler: (event: WheelEvent) => void): void;
+    off(event: 'move', handler?: (event: PointerEvent) => void): void;
+    off(event: 'down', handler?: (event: PointerEvent) => void): void;
+    off(event: 'up', handler?: (event: PointerEvent) => void): void;
+    off(event: 'wheel', handler?: (event: WheelEvent) => void): void;
+    /**
+     * Called internally by excalibur
+     *
+     * Updates the current frame pointer info and emits raw pointer events
+     *
+     * This does not emit events to entities, see PointerSystem
+     */
+    update(): void;
+    /**
+     * Clears the current frame event and pointer data
+     */
+    clear(): void;
+    private _boundHandle;
+    private _boundWheel;
+    /**
+     * Initializes the pointer event receiver so that it can start listening to native
+     * browser events.
+     */
+    init(): void;
+    detach(): void;
+    /**
+     * Take native pointer id and map it to index in active pointers
+     * @param nativePointerId
+     */
+    private _normalizePointerId;
+    /**
+     * Responsible for handling and parsing pointer events
+     */
+    private _handle;
+    private _handleWheel;
+    /**
+     * Triggers an excalibur pointer event in a world space pos
+     *
+     * Useful for testing pointers in excalibur
+     * @param type
+     * @param pos
+     */
+    triggerEvent(type: 'down' | 'up' | 'move' | 'cancel', pos: Vector): void;
+    private _nativeButtonToPointerButton;
+    private _stringToPointerType;
+}

package/build/esm/Input/PointerScope.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Determines the scope of handling mouse/touch events.
+ */
+export declare enum PointerScope {
+    /**
+     * Handle events on the `canvas` element only. Events originating outside the
+     * `canvas` will not be handled.
+     */
+    Canvas = "Canvas",
+    /**
+     * Handles events on the entire document. All events will be handled by Excalibur.
+     */
+    Document = "Document"
+}

package/build/esm/Input/PointerSystem.d.ts

@@ -0,0 +1,43 @@
+import { System, TransformComponent, SystemType, Entity } from '../EntityComponentSystem';
+import { Scene } from '../Scene';
+import { PointerComponent } from './PointerComponent';
+/**
+ * The PointerSystem is responsible for dispatching pointer events to entities
+ * that need them.
+ *
+ * The PointerSystem can be optionally configured by the [[PointerComponent]], by default Entities use
+ * the [[Collider]]'s shape for pointer events.
+ */
+export declare class PointerSystem extends System<TransformComponent | PointerComponent> {
+    readonly types: readonly ["ex.transform", "ex.pointer"];
+    readonly systemType = SystemType.Update;
+    priority: number;
+    private _engine;
+    private _receiver;
+    /**
+     * Optionally override component configuration for all entities
+     */
+    overrideUseColliderShape: boolean;
+    /**
+     * Optionally override component configuration for all entities
+     */
+    overrideUseGraphicsBounds: boolean;
+    lastFrameEntityToPointers: Map<number, number[]>;
+    currentFrameEntityToPointers: Map<number, number[]>;
+    initialize(scene: Scene): void;
+    sort(a: Entity, b: Entity): number;
+    entityCurrentlyUnderPointer(entity: Entity, pointerId: number): boolean;
+    entityWasUnderPointer(entity: Entity, pointerId: number): boolean;
+    entered(entity: Entity, pointerId: number): boolean;
+    left(entity: Entity, pointerId: number): boolean;
+    addPointerToEntity(entity: Entity, pointerId: number): void;
+    update(entities: Entity[]): void;
+    private _processPointerToEntity;
+    private _processDownAndEmit;
+    private _processUpAndEmit;
+    private _processMoveAndEmit;
+    private _processEnterLeaveAndEmit;
+    private _processCancelAndEmit;
+    private _processWheelAndEmit;
+    private _dispatchEvents;
+}

package/build/esm/Input/PointerType.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The type of pointer for a [[PointerEvent]].
+ */
+export declare enum PointerType {
+    Touch = "Touch",
+    Mouse = "Mouse",
+    Pen = "Pen",
+    Unknown = "Unknown"
+}

package/build/esm/Input/WheelDeltaMode.d.ts

@@ -0,0 +1,5 @@
+export declare enum WheelDeltaMode {
+    Pixel = "Pixel",
+    Line = "Line",
+    Page = "Page"
+}

package/build/esm/Input/WheelEvent.d.ts

@@ -0,0 +1,18 @@
+import { WheelDeltaMode } from './WheelDeltaMode';
+export declare class WheelEvent {
+    x: number;
+    y: number;
+    pageX: number;
+    pageY: number;
+    screenX: number;
+    screenY: number;
+    index: number;
+    deltaX: number;
+    deltaY: number;
+    deltaZ: number;
+    deltaMode: WheelDeltaMode;
+    ev: Event;
+    active: boolean;
+    cancel(): void;
+    constructor(x: number, y: number, pageX: number, pageY: number, screenX: number, screenY: number, index: number, deltaX: number, deltaY: number, deltaZ: number, deltaMode: WheelDeltaMode, ev: Event);
+}

package/build/esm/Interfaces/PointerEventHandlers.d.ts

@@ -1,5 +1,6 @@
 import * as Events from '../Events';
-import { PointerEvent, WheelEvent, PointerDragEvent } from '../Input/PointerEvents';
+import { PointerEvent } from '../Input/PointerEvent';
+import { WheelEvent } from '../Input/WheelEvent';
 export interface PointerEvents {
     on(eventName: Events.pointerup, handler: (event: PointerEvent) => void): void;
     on(eventName: Events.pointerdown, handler: (event: PointerEvent) => void): void;
@@ -8,11 +9,11 @@ export interface PointerEvents {
     on(eventName: Events.pointermove, handler: (event: PointerEvent) => void): void;
     on(eventName: Events.pointercancel, handler: (event: PointerEvent) => void): void;
     on(eventName: Events.pointerwheel, handler: (event: WheelEvent) => void): void;
-    on(eventName: Events.pointerdragstart, handler: (event: PointerDragEvent) => void): void;
-    on(eventName: Events.pointerdragend, handler: (event: PointerDragEvent) => void): void;
-    on(eventName: Events.pointerdragenter, handler: (event: PointerDragEvent) => void): void;
-    on(eventName: Events.pointerdragleave, handler: (event: PointerDragEvent) => void): void;
-    on(eventName: Events.pointerdragmove, handler: (event: PointerDragEvent) => void): void;
+    on(eventName: Events.pointerdragstart, handler: (event: PointerEvent) => void): void;
+    on(eventName: Events.pointerdragend, handler: (event: PointerEvent) => void): void;
+    on(eventName: Events.pointerdragenter, handler: (event: PointerEvent) => void): void;
+    on(eventName: Events.pointerdragleave, handler: (event: PointerEvent) => void): void;
+    on(eventName: Events.pointerdragmove, handler: (event: PointerEvent) => void): void;
     once(eventName: Events.pointerup, handler: (event: PointerEvent) => void): void;
     once(eventName: Events.pointerdown, handler: (event: PointerEvent) => void): void;
     once(eventName: Events.pointerenter, handler: (event: PointerEvent) => void): void;
@@ -20,11 +21,11 @@ export interface PointerEvents {
     once(eventName: Events.pointermove, handler: (event: PointerEvent) => void): void;
     once(eventName: Events.pointercancel, handler: (event: PointerEvent) => void): void;
     once(eventName: Events.pointerwheel, handler: (event: WheelEvent) => void): void;
-    once(eventName: Events.pointerdragstart, handler: (event: PointerDragEvent) => void): void;
-    once(eventName: Events.pointerdragend, handler: (event: PointerDragEvent) => void): void;
-    once(eventName: Events.pointerdragenter, handler: (event: PointerDragEvent) => void): void;
-    once(eventName: Events.pointerdragleave, handler: (event: PointerDragEvent) => void): void;
-    once(eventName: Events.pointerdragmove, handler: (event: PointerDragEvent) => void): void;
+    once(eventName: Events.pointerdragstart, handler: (event: PointerEvent) => void): void;
+    once(eventName: Events.pointerdragend, handler: (event: PointerEvent) => void): void;
+    once(eventName: Events.pointerdragenter, handler: (event: PointerEvent) => void): void;
+    once(eventName: Events.pointerdragleave, handler: (event: PointerEvent) => void): void;
+    once(eventName: Events.pointerdragmove, handler: (event: PointerEvent) => void): void;
     off(eventName: Events.pointerup, handler?: (event: PointerEvent) => void): void;
     off(eventName: Events.pointerdown, handler?: (event: PointerEvent) => void): void;
     off(eventName: Events.pointerenter, handler?: (event: PointerEvent) => void): void;
@@ -32,9 +33,9 @@ export interface PointerEvents {
     off(eventName: Events.pointermove, handler?: (event: PointerEvent) => void): void;
     off(eventName: Events.pointercancel, handler?: (event: PointerEvent) => void): void;
     off(eventName: Events.pointerwheel, handler?: (event: WheelEvent) => void): void;
-    off(eventName: Events.pointerdragstart, handler?: (event: PointerDragEvent) => void): void;
-    off(eventName: Events.pointerdragend, handler?: (event: PointerDragEvent) => void): void;
-    off(eventName: Events.pointerdragenter, handler?: (event: PointerDragEvent) => void): void;
-    off(eventName: Events.pointerdragleave, handler?: (event: PointerDragEvent) => void): void;
-    off(eventName: Events.pointerdragmove, handler?: (event: PointerDragEvent) => void): void;
+    off(eventName: Events.pointerdragstart, handler?: (event: PointerEvent) => void): void;
+    off(eventName: Events.pointerdragend, handler?: (event: PointerEvent) => void): void;
+    off(eventName: Events.pointerdragenter, handler?: (event: PointerEvent) => void): void;
+    off(eventName: Events.pointerdragleave, handler?: (event: PointerEvent) => void): void;
+    off(eventName: Events.pointerdragmove, handler?: (event: PointerEvent) => void): void;
 }

package/build/esm/Label.d.ts

@@ -36,8 +36,10 @@ export interface LabelOptions {
  * actors and inherit all of the benefits and capabilities.
  */
 export declare class Label extends Actor {
-    font: Font;
+    private _font;
     private _text;
+    get font(): Font;
+    set font(newFont: Font);
     /**
      * The text to draw.
      */
@@ -110,7 +112,7 @@ export declare class Label extends Actor {
     letterSpacing: number;
     /**
      * Whether or not the [[SpriteFont]] will be case-sensitive when matching characters.
-     * @deprecated Use Graphics.SpriteFont.caseInsensitve
+     * @deprecated Use Graphics.SpriteFont.caseInsensitive
      */
     caseInsensitive: boolean;
     private _graphicsContext;
@@ -142,5 +144,10 @@ export declare class Label extends Actor {
      * @deprecated Use [[Font.shadow|Label.font.shadow]]
      */
     clearTextShadow(): void;
+    /**
+     * @deprecated signature will change in v0.26.0
+     * @param _ctx
+     * @param _delta
+     */
     draw(_ctx: CanvasRenderingContext2D, _delta: number): void;
 }

package/build/esm/Loader.d.ts

@@ -154,14 +154,17 @@ export declare class Loader extends Class implements Loadable<Loadable<any>[]> {
     dispose(): void;
     update(_engine: Engine, _delta: number): void;
     data: Loadable<any>[];
+    private _isLoadedResolve;
+    private _isLoadedPromise;
+    areResourcesLoaded(): Promise<void>;
     /**
      * Begin loading all of the supplied resources, returning a promise
-     * that resolves when loading of all is complete
+     * that resolves when loading of all is complete AND the user has clicked the "Play button"
      */
     load(): Promise<Loadable<any>[]>;
     markResourceComplete(): void;
     /**
-     * Returns the progess of the loader as a number between [0, 1] inclusive.
+     * Returns the progress of the loader as a number between [0, 1] inclusive.
      */
     get progress(): number;
     private _positionPlayButton;

package/build/esm/Math/Index.d.ts

@@ -6,3 +6,4 @@ export * from './global-coordinates';
 export * from './line';
 export * from './projection';
 export * from './ray';
+export * from './util';

package/build/esm/Math/matrix.d.ts

@@ -36,10 +36,22 @@ export declare class Matrix {
      * Creates a new Matrix with the same data as the current 4x4
      */
     clone(): Matrix;
+    /**
+     * Converts the current matrix into a DOMMatrix
+     *
+     * This is useful when working with the browser Canvas context
+     * @returns {DOMMatrix} DOMMatrix
+     */
+    toDOMMatrix(): DOMMatrix;
     /**
      * Creates a new identity matrix (a matrix that when applied does nothing)
      */
     static identity(): Matrix;
+    /**
+     * Resets the current matrix to the identity matrix, mutating it
+     * @returns {Matrix} Current matrix as identity
+     */
+    reset(): Matrix;
     /**
      * Creates a brand new translation matrix at the specified 3d point
      * @param x
@@ -104,7 +116,13 @@ export declare class Matrix {
      * Determinant of the upper left 2x2 matrix
      */
     getBasisDeterminant(): number;
-    getAffineInverse(): Matrix;
+    /**
+     * Return the affine inverse, optionally store it in a target matrix.
+     *
+     * It's recommended you call .reset() the target unless you know what you're doing
+     * @param target
+     */
+    getAffineInverse(target?: Matrix): Matrix;
     isIdentity(): boolean;
     toString(): string;
 }

package/build/esm/Math/util.d.ts

@@ -0,0 +1,45 @@
+import { Random } from './Random';
+/**
+ * Two PI constant
+ */
+export declare const TwoPI: number;
+/**
+ * Returns the fractional part of a number
+ * @param x
+ */
+export declare function frac(x: number): number;
+/**
+ * Returns the sign of a number, if 0 returns 0
+ */
+export declare function sign(val: number): number;
+/**
+ * Clamps a value between a min and max inclusive
+ */
+export declare function clamp(val: number, min: number, max: number): number;
+/**
+ * Convert an angle to be the equivalent in the range [0, 2PI]
+ */
+export declare function canonicalizeAngle(angle: number): number;
+/**
+ * Convert radians to degrees
+ */
+export declare function toDegrees(radians: number): number;
+/**
+ * Convert degrees to radians
+ */
+export declare function toRadians(degrees: number): number;
+/**
+ * Generate a range of numbers
+ * For example: range(0, 5) -> [0, 1, 2, 3, 4, 5]
+ * @param from inclusive
+ * @param to inclusive
+ */
+export declare const range: (from: number, to: number) => number[];
+/**
+ * Find a random floating point number in range
+ */
+export declare function randomInRange(min: number, max: number, random?: Random): number;
+/**
+ * Find a random integer in a range
+ */
+export declare function randomIntInRange(min: number, max: number, random?: Random): number;

package/build/esm/Particles.d.ts

@@ -55,6 +55,10 @@ export declare class ParticleImpl extends Entity {
     constructor(emitterOrConfig: ParticleEmitter | ParticleArgs, life?: number, opacity?: number, beginColor?: Color, endColor?: Color, position?: Vector, velocity?: Vector, acceleration?: Vector, startSize?: number, endSize?: number);
     kill(): void;
     update(_engine: Engine, delta: number): void;
+    /**
+     * @deprecated signature will change in v0.26.0
+     * @param ctx
+     */
     draw(ctx: CanvasRenderingContext2D): void;
 }
 export interface ParticleArgs extends Partial<ParticleImpl> {
@@ -238,7 +242,15 @@ export declare class ParticleEmitter extends Actor {
     clearParticles(): void;
     private _createParticle;
     update(engine: Engine, delta: number): void;
+    /**
+     * @deprecated signature will change in v0.26.0
+     * @param ctx
+     */
     draw(ctx: CanvasRenderingContext2D): void;
+    /**
+     * @deprecated signature will change in v0.26.0
+     * @param ctx
+     */
     debugDraw(ctx: CanvasRenderingContext2D): void;
 }
 export {};

package/build/esm/Resources/Gif.d.ts

@@ -49,12 +49,12 @@ export declare class Gif implements Loadable<ImageSource[]> {
     /**
      * Return the gif as a legacy spritesheet
      * @deprecated
-     * @returns
      */
     toLegacySpriteSheet(): LegacyDrawing.SpriteSheet;
     /**
      * Return the gif as a legacy animation
      * @deprecated
+     * @param engine
      * @param speed
      */
     toLegacyAnimation(engine: Engine, speed: number): LegacyDrawing.Animation;

package/build/esm/Scene.d.ts

@@ -55,6 +55,7 @@ export declare class Scene extends Class implements CanInitialize, CanActivate,
     get screenElements(): ScreenElement[];
     private _isInitialized;
     private _timers;
+    get timers(): readonly Timer[];
     private _cancelQueue;
     constructor();
     on(eventName: Events.initialize, handler: (event: InitializeEvent<Scene>) => void): void;
@@ -118,12 +119,16 @@ export declare class Scene extends Class implements CanInitialize, CanActivate,
      * Safe to override onPreDraw lifecycle event handler. Synonymous with `.on('preupdate', (evt) =>{...})`
      *
      * `onPreDraw` is called directly before a scene is drawn.
+     *
+     * @deprecated Signature will change in v0.26.0
      */
     onPreDraw(_ctx: CanvasRenderingContext2D, _delta: number): void;
     /**
      * Safe to override onPostDraw lifecycle event handler. Synonymous with `.on('preupdate', (evt) =>{...})`
      *
      * `onPostDraw` is called directly after a scene is drawn.
+     *
+     * @deprecated Signature will change in v0.26.0
      */
     onPostDraw(_ctx: CanvasRenderingContext2D, _delta: number): void;
     /**
@@ -175,6 +180,7 @@ export declare class Scene extends Class implements CanInitialize, CanActivate,
      *
      * Internal _predraw handler for [[onPreDraw]] lifecycle event
      *
+     * @deprecated Signature will change in v0.26.0
      * @internal
      */
     _predraw(_ctx: CanvasRenderingContext2D, _delta: number): void;
@@ -183,6 +189,7 @@ export declare class Scene extends Class implements CanInitialize, CanActivate,
      *
      * Internal _postdraw handler for [[onPostDraw]] lifecycle event
      *
+     * @deprecated Signature will change in v0.26.0
      * @internal
      */
     _postdraw(_ctx: CanvasRenderingContext2D, _delta: number): void;
@@ -194,6 +201,8 @@ export declare class Scene extends Class implements CanInitialize, CanActivate,
     update(engine: Engine, delta: number): void;
     /**
      * Draws all the actors in the Scene. Called by the [[Engine]].
+     *
+     * @deprecated Signature will change in v0.26.0
      * @param ctx    The current rendering context
      * @param delta  The number of milliseconds since the last draw
      */
@@ -201,7 +210,7 @@ export declare class Scene extends Class implements CanInitialize, CanActivate,
     /**
      * Draws all the actors' debug information in the Scene. Called by the [[Engine]].
      * @param ctx  The current rendering context
-     * @deprecated
+     * @deprecated Signature will change in v0.26.0
      */
     debugDraw(ctx: CanvasRenderingContext2D): void;
     /**

package/build/esm/Screen.d.ts

@@ -136,8 +136,8 @@ export interface ScreenOptions {
  * The Screen handles all aspects of interacting with the screen for Excalibur.
  */
 export declare class Screen {
+    graphicsContext: ExcaliburGraphicsContext;
     private _canvas;
-    private _ctx;
     private _antialiasing;
     private _browser;
     private _camera;
@@ -154,6 +154,7 @@ export declare class Screen {
     private _logger;
     private _resizeObserver;
     constructor(options: ScreenOptions);
+    private _listenForPixelRatio;
     dispose(): void;
     private _fullscreenChangeHandler;
     private _pixelRatioChangeHandler;
@@ -182,7 +183,7 @@ export declare class Screen {
     get antialiasing(): boolean;
     set antialiasing(isSmooth: boolean);
     /**
-     * Returns true if excalibur is fullscreened using the browser fullscreen api
+     * Returns true if excalibur is fullscreen using the browser fullscreen api
      */
     get isFullScreen(): boolean;
     /**
@@ -278,7 +279,7 @@ export declare class Screen {
     private _computeFitContainer;
     private _applyDisplayMode;
     /**
-     * Sets the resoultion and viewport based on the selected display mode.
+     * Sets the resolution and viewport based on the selected display mode.
      */
     private _setResolutionAndViewportByDisplayMode;
     private _initializeDisplayModePosition;

package/build/esm/TileMap.d.ts

@@ -100,6 +100,7 @@ export declare class TileMapImpl extends Entity {
      * @param delta  The number of milliseconds since the last draw
      */
     draw(ctx: CanvasRenderingContext2D | ExcaliburGraphicsContext, delta: number): void;
+    debug(gfx: ExcaliburGraphicsContext): void;
 }
 export interface TileMapArgs extends Partial<TileMapImpl> {
     x: number;
@@ -161,7 +162,7 @@ export declare class CellImpl extends Entity {
      */
     readonly graphics: Graphics.Graphic[];
     /**
-     * Abitrary data storage per cell, useful for any game specific data
+     * Arbitrary data storage per cell, useful for any game specific data
      */
     data: Map<string, any>;
     /**
@@ -191,7 +192,7 @@ export declare class CellImpl extends Entity {
      */
     removeGraphic(graphic: Graphics.Graphic | LegacySprite): void;
     /**
-     * Clear all graphis from this cell
+     * Clear all graphics from this cell
      */
     clearGraphics(): void;
 }