@vpmedia/phaser 1.113.0 → 1.115.0

package/src/phaser/core/input_mouse.ts

@@ -1,31 +1,32 @@
+import type { InputEvent } from './input_event.js';
 import type { Input } from './input.js';
 import type { Game } from './game.js';
 
 export class Mouse {
-  public game!: any;
+  public game!: Game;
   public input!: Input;
-  public callbackContext!: any;
-  public mouseDownCallback: ((event: MouseEvent) => void) | null;
-  public mouseUpCallback: ((event: MouseEvent) => void) | null;
-  public mouseOutCallback: ((event: MouseEvent) => void) | null;
-  public mouseOverCallback: ((event: MouseEvent) => void) | null;
-  public mouseWheelCallback: ((event: WheelEvent) => void) | null;
-  public mouseMoveCallback: ((event: MouseEvent) => void) | null;
+  public callbackContext!: unknown;
+  public mouseDownCallback: EventListener | null;
+  public mouseUpCallback: EventListener | null;
+  public mouseOutCallback: EventListener | null;
+  public mouseOverCallback: EventListener | null;
+  public mouseWheelCallback: EventListener | null;
+  public mouseMoveCallback: EventListener | null;
   public capture!: boolean;
   public button!: number;
   public wheelDelta!: number;
   public enabled!: boolean;
   public locked!: boolean;
   public stopOnGameOut!: boolean;
-  public event!: MouseEvent | WheelEvent | null;
-  public _onMouseDown: ((event: MouseEvent) => void) | null;
-  public _onMouseMove: ((event: MouseEvent) => void) | null;
-  public _onMouseUp: ((event: MouseEvent) => void) | null;
-  public _onMouseOut: ((event: MouseEvent) => void) | null;
-  public _onMouseOver: ((event: MouseEvent) => void) | null;
-  public _onMouseWheel: ((event: WheelEvent) => void) | null;
-  public _onMouseUpGlobal!: (event: MouseEvent) => void;
-  public _onMouseOutGlobal!: (event: MouseEvent) => void;
+  public event!: InputEvent | null;
+  public _onMouseDown: EventListener | null;
+  public _onMouseMove: EventListener | null;
+  public _onMouseUp: EventListener | null;
+  public _onMouseOut: EventListener | null;
+  public _onMouseOver: EventListener | null;
+  public _onMouseWheel: EventListener | null;
+  public _onMouseUpGlobal!: EventListener;
+  public _onMouseOutGlobal!: EventListener;
   public _wheelEvent!: any;
   /**
    * TBD.
@@ -61,7 +62,7 @@ export class Mouse {
    * TBD.
    */
   public start() {
-    if (this.game.device.android && this.game.device.chrome === false) {
+    if (this.game.device.android && !this.game.device.chrome) {
       //  Android stock browser fires mouse events even if you preventDefault on the touchStart, so ...
       return;
     }
@@ -113,24 +114,40 @@ export class Mouse {
    */
   public stop() {
     const { canvas } = this.game;
-    canvas.removeEventListener('mousedown', this._onMouseDown, true);
-    canvas.removeEventListener('mousemove', this._onMouseMove, true);
-    canvas.removeEventListener('mouseup', this._onMouseUp, true);
-    canvas.removeEventListener('mouseover', this._onMouseOver, true);
-    canvas.removeEventListener('mouseout', this._onMouseOut, true);
+    if (this._onMouseDown) {
+      canvas.removeEventListener('mousedown', this._onMouseDown, true);
+    }
+    if (this._onMouseMove) {
+      canvas.removeEventListener('mousemove', this._onMouseMove, true);
+    }
+    if (this._onMouseUp) {
+      canvas.removeEventListener('mouseup', this._onMouseUp, true);
+    }
+    if (this._onMouseOver) {
+      canvas.removeEventListener('mouseover', this._onMouseOver, true);
+    }
+    if (this._onMouseOut) {
+      canvas.removeEventListener('mouseout', this._onMouseOut, true);
+    }
     const { wheelEvent } = this.game.device;
     if (wheelEvent) {
-      canvas.removeEventListener(wheelEvent, this._onMouseWheel, true);
+      if (this._onMouseWheel) {
+        canvas.removeEventListener(wheelEvent, this._onMouseWheel, true);
+      }
+    }
+    if (this._onMouseUpGlobal) {
+      globalThis.removeEventListener('mouseup', this._onMouseUpGlobal, true);
+    }
+    if (this._onMouseOutGlobal) {
+      globalThis.removeEventListener('mouseout', this._onMouseOutGlobal, true);
     }
-    globalThis.removeEventListener('mouseup', this._onMouseUpGlobal, true);
-    globalThis.removeEventListener('mouseout', this._onMouseOutGlobal, true);
   }
 
   /**
    * TBD.
    * @param {MouseEvent} event - TBD.
    */
-  public onMouseDown(event: any) {
+  public onMouseDown(event: InputEvent) {
     this.event = event;
     this.eventPreventDefault(event);
     if (this.mouseDownCallback) {
@@ -147,7 +164,7 @@ export class Mouse {
    * TBD.
    * @param {MouseEvent} event - TBD.
    */
-  public onMouseMove(event: any) {
+  public onMouseMove(event: InputEvent) {
     this.event = event;
     this.eventPreventDefault(event);
     if (this.mouseMoveCallback) {
@@ -164,7 +181,7 @@ export class Mouse {
    * TBD.
    * @param {MouseEvent} event - TBD.
    */
-  public onMouseUp(event: any) {
+  public onMouseUp(event: InputEvent) {
     this.event = event;
     this.eventPreventDefault(event);
     if (this.mouseUpCallback) {
@@ -181,7 +198,7 @@ export class Mouse {
    * TBD.
    * @param {MouseEvent} event - TBD.
    */
-  public onMouseUpGlobal(event: any) {
+  public onMouseUpGlobal(event: InputEvent) {
     if (!this.input.mousePointer.withinGame) {
       if (this.mouseUpCallback) {
         this.mouseUpCallback.call(this.callbackContext, event);
@@ -195,7 +212,7 @@ export class Mouse {
    * TBD.
    * @param {MouseEvent} event - TBD.
    */
-  public onMouseOutGlobal(event: any) {
+  public onMouseOutGlobal(event: InputEvent) {
     this.event = event;
     this.eventPreventDefault(event);
     this.input.mousePointer.withinGame = false;
@@ -214,7 +231,7 @@ export class Mouse {
    * TBD.
    * @param {MouseEvent} event - TBD.
    */
-  public onMouseOut(event: any) {
+  public onMouseOut(event: InputEvent) {
     this.event = event;
     this.eventPreventDefault(event);
     this.input.mousePointer.withinGame = false;
@@ -234,7 +251,7 @@ export class Mouse {
    * TBD.
    * @param {MouseEvent} event - TBD.
    */
-  public onMouseOver(event: any) {
+  public onMouseOver(event: InputEvent) {
     this.event = event;
     this.eventPreventDefault(event);
     this.input.mousePointer.withinGame = true;
@@ -247,14 +264,14 @@ export class Mouse {
    * TBD.
    * @param {WheelEvent} event - TBD.
    */
-  public onMouseWheel(event: any) {
+  public onMouseWheel(event: InputEvent) {
     if (this._wheelEvent) {
       event = this._wheelEvent.bindEvent(event);
     }
     this.event = event;
     this.eventPreventDefault(event);
     // reverse detail for firefox
-    this.wheelDelta = Math.max(-1, Math.min(1, -event.deltaY));
+    this.wheelDelta = Math.max(-1, Math.min(1, -(event.deltaY ?? 0)));
     if (this.mouseWheelCallback) {
       this.mouseWheelCallback.call(this.callbackContext, event);
     }
@@ -264,7 +281,7 @@ export class Mouse {
    * TBD.
    * @param {MouseEvent} event - TBD.
    */
-  public eventPreventDefault(event: any) {
+  public eventPreventDefault(event: Event) {
     if (this.capture) {
       if (typeof event.cancelable !== 'boolean' || event.cancelable) {
         event.preventDefault();

package/src/phaser/core/input_mspointer.ts

@@ -1,21 +1,22 @@
 import type { Game } from './game.js';
+import type { InputEvent } from './input_event.js';
 export class MSPointer {
-  public game!: any;
+  public game!: Game;
   public input!: any;
-  public callbackContext!: any;
+  public callbackContext!: unknown;
   public pointerDownCallback!: any;
   public pointerMoveCallback!: any;
   public pointerUpCallback!: any;
   public capture!: any;
   public button!: any;
-  public event!: any;
+  public event!: InputEvent | null;
   public enabled!: any;
-  public _onMSPointerDown: ((event: PointerEvent) => void) | null;
-  public _onMSPointerMove: ((event: PointerEvent) => void) | null;
-  public _onMSPointerUp: ((event: PointerEvent) => void) | null;
-  public _onMSPointerUpGlobal: ((event: Event) => void) | null;
-  public _onMSPointerOut: ((event: PointerEvent) => void) | null;
-  public _onMSPointerOver: ((event: PointerEvent) => void) | null;
+  public _onMSPointerDown: EventListener | null;
+  public _onMSPointerMove: EventListener | null;
+  public _onMSPointerUp: EventListener | null;
+  public _onMSPointerUpGlobal: EventListener | null;
+  public _onMSPointerOut: EventListener | null;
+  public _onMSPointerOver: EventListener | null;
   /**
    * TBD.
    * @param {Game} game - TBD.
@@ -73,8 +74,8 @@ export class MSPointer {
     canvas.addEventListener('pointerdown', this._onMSPointerDown, false);
     canvas.addEventListener('pointermove', this._onMSPointerMove, false);
     canvas.addEventListener('pointerup', this._onMSPointerUp, false);
-    canvas.style['-ms-content-zooming'] = 'none';
-    canvas.style['-ms-touch-action'] = 'none';
+    canvas.style.setProperty('-ms-content-zooming', 'none');
+    canvas.style.setProperty('-ms-touch-action', 'none');
     globalThis.addEventListener('MSPointerUp', this._onMSPointerUpGlobal, true);
     canvas.addEventListener('MSPointerOver', this._onMSPointerOver, true);
     canvas.addEventListener('MSPointerOut', this._onMSPointerOut, true);
@@ -92,31 +93,55 @@ export class MSPointer {
       return;
     }
     const { canvas } = this.game;
-    canvas.removeEventListener('MSPointerDown', this._onMSPointerDown, false);
-    canvas.removeEventListener('MSPointerMove', this._onMSPointerMove, false);
-    canvas.removeEventListener('MSPointerUp', this._onMSPointerUp, false);
+    if (this._onMSPointerDown) {
+      canvas.removeEventListener('MSPointerDown', this._onMSPointerDown, false);
+    }
+    if (this._onMSPointerMove) {
+      canvas.removeEventListener('MSPointerMove', this._onMSPointerMove, false);
+    }
+    if (this._onMSPointerUp) {
+      canvas.removeEventListener('MSPointerUp', this._onMSPointerUp, false);
+    }
     //  IE11+ uses non-prefix events
-    canvas.removeEventListener('pointerdown', this._onMSPointerDown, false);
-    canvas.removeEventListener('pointermove', this._onMSPointerMove, false);
-    canvas.removeEventListener('pointerup', this._onMSPointerUp, false);
+    if (this._onMSPointerDown) {
+      canvas.removeEventListener('pointerdown', this._onMSPointerDown, false);
+    }
+    if (this._onMSPointerMove) {
+      canvas.removeEventListener('pointermove', this._onMSPointerMove, false);
+    }
+    if (this._onMSPointerUp) {
+      canvas.removeEventListener('pointerup', this._onMSPointerUp, false);
+    }
     if (this._onMSPointerUpGlobal) {
-      globalThis.removeEventListener('MSPointerUp', this._onMSPointerUpGlobal, true);
+      if (this._onMSPointerUpGlobal) {
+        globalThis.removeEventListener('MSPointerUp', this._onMSPointerUpGlobal, true);
+      }
+    }
+    if (this._onMSPointerOver) {
+      canvas.removeEventListener('MSPointerOver', this._onMSPointerOver, true);
+    }
+    if (this._onMSPointerOut) {
+      canvas.removeEventListener('MSPointerOut', this._onMSPointerOut, true);
     }
-    canvas.removeEventListener('MSPointerOver', this._onMSPointerOver, true);
-    canvas.removeEventListener('MSPointerOut', this._onMSPointerOut, true);
     //  IE11+ uses non-prefix events
     if (this._onMSPointerUpGlobal) {
-      globalThis.removeEventListener('pointerup', this._onMSPointerUpGlobal, true);
+      if (this._onMSPointerUpGlobal) {
+        globalThis.removeEventListener('pointerup', this._onMSPointerUpGlobal, true);
+      }
+    }
+    if (this._onMSPointerOver) {
+      canvas.removeEventListener('pointerover', this._onMSPointerOver, true);
+    }
+    if (this._onMSPointerOut) {
+      canvas.removeEventListener('pointerout', this._onMSPointerOut, true);
     }
-    canvas.removeEventListener('pointerover', this._onMSPointerOver, true);
-    canvas.removeEventListener('pointerout', this._onMSPointerOut, true);
   }
 
   /**
    * TBD.
    * @param {PointerEvent} event - TBD.
    */
-  public onPointerDown(event: any) {
+  public onPointerDown(event: InputEvent) {
     this.event = event;
     this.eventPreventDefault(event);
     if (this.pointerDownCallback) {
@@ -137,7 +162,7 @@ export class MSPointer {
    * TBD.
    * @param {PointerEvent} event - TBD.
    */
-  public onPointerMove(event: any) {
+  public onPointerMove(event: InputEvent) {
     this.event = event;
     this.eventPreventDefault(event);
     if (this.pointerMoveCallback) {
@@ -158,7 +183,7 @@ export class MSPointer {
    * TBD.
    * @param {PointerEvent} event - TBD.
    */
-  public onPointerUp(event: any) {
+  public onPointerUp(event: InputEvent) {
     this.event = event;
     this.eventPreventDefault(event);
     if (this.pointerUpCallback) {
@@ -179,7 +204,7 @@ export class MSPointer {
    * TBD.
    * @param {PointerEvent} event - TBD.
    */
-  public onPointerUpGlobal(event: any) {
+  public onPointerUpGlobal(event: InputEvent) {
     if ((event.pointerType === 'mouse' || event.pointerType === 0x00000004) && !this.input.mousePointer.withinGame) {
       this.onPointerUp(event);
     } else {
@@ -194,7 +219,7 @@ export class MSPointer {
    * TBD.
    * @param {PointerEvent} event - TBD.
    */
-  public onPointerOut(event: any) {
+  public onPointerOut(event: InputEvent) {
     this.event = event;
     this.eventPreventDefault(event);
     let pointer;
@@ -226,7 +251,7 @@ export class MSPointer {
    * TBD.
    * @param {PointerEvent} event - TBD.
    */
-  public onPointerOver(event: any) {
+  public onPointerOver(event: InputEvent) {
     this.event = event;
     this.eventPreventDefault(event);
     if (event.pointerType === 'mouse' || event.pointerType === 0x00000004) {

package/src/phaser/core/input_pointer.test.ts

@@ -0,0 +1,149 @@
+import { describe, expect, it } from 'vitest';
+import { Circle } from '../geom/circle.js';
+import { Point } from '../geom/point.js';
+import { POINTER_CURSOR } from './const.js';
+import type { Game } from './game.js';
+import type { InputEvent } from './input_event.js';
+import { Pointer } from './input_pointer.js';
+
+const createGame = (): Game =>
+  ({
+    time: { time: 0 },
+    scale: { bounds: { contains: () => true }, offset: { x: 0, y: 0 } },
+    input: {
+      enabled: true,
+      multiInputOverride: 0,
+      moveCallbacks: [],
+      interactiveItems: { total: 0, callAll: () => undefined },
+      mouse: { locked: false },
+      scale: new Point(1, 1),
+      position: new Point(),
+      circle: new Circle(),
+      speed: new Point(),
+      activePointer: null,
+      onDown: { dispatch: () => undefined },
+      onUp: { dispatch: () => undefined },
+      onHold: { dispatch: () => undefined },
+      onTap: { dispatch: () => undefined },
+      x: 0,
+      y: 0,
+      resetSpeed: () => undefined,
+    },
+  }) as unknown as Game;
+
+const createPointer = (id = 1): Pointer => new Pointer(createGame(), id, POINTER_CURSOR);
+
+const event = (fields: Partial<InputEvent> = {}): InputEvent =>
+  ({ type: 'pointerdown', target: null, preventDefault: () => undefined, ...fields }) as InputEvent;
+
+describe('Pointer', () => {
+  describe('updateButtons', () => {
+    it('reads a down event as pressed', () => {
+      const pointer = createPointer();
+      pointer.updateButtons(event({ type: 'pointerdown' }));
+      expect(pointer.isDown).toBe(true);
+      expect(pointer.isUp).toBe(false);
+    });
+
+    it('reads an up event as released', () => {
+      const pointer = createPointer();
+      pointer.updateButtons(event({ type: 'pointerup' }));
+      expect(pointer.isDown).toBe(false);
+      expect(pointer.isUp).toBe(true);
+    });
+
+    it('matches the suffix case insensitively, as the legacy events are capitalised', () => {
+      const pointer = createPointer();
+      pointer.updateButtons(event({ type: 'MSPointerDown' }));
+      expect(pointer.isDown).toBe(true);
+    });
+
+    it('treats a move event as not pressed', () => {
+      const pointer = createPointer();
+      pointer.updateButtons(event({ type: 'pointermove' }));
+      expect(pointer.isUp).toBe(true);
+    });
+  });
+
+  describe('start', () => {
+    it('records the identifier the event carries', () => {
+      const pointer = createPointer();
+      pointer.start(event({ identifier: 7 }));
+      expect(pointer.identifier).toBe(7);
+    });
+
+    it('records a null identifier when the event has none', () => {
+      const pointer = createPointer();
+      pointer.start(event({}));
+      expect(pointer.identifier).toBeNull();
+    });
+
+    it('records the pointerId when the event carries one', () => {
+      const pointer = createPointer();
+      pointer.start(event({ pointerId: 3 }));
+      expect(pointer.pointerId).toBe(3);
+    });
+
+    it('marks the pointer active and down', () => {
+      const pointer = createPointer();
+      pointer.start(event({ identifier: 1 }));
+      expect(pointer.active).toBe(true);
+      expect(pointer.isDown).toBe(true);
+    });
+  });
+
+  describe('move', () => {
+    it('copies the coordinate set off the event', () => {
+      const pointer = createPointer();
+      pointer.start(event({ identifier: 1 }));
+      pointer.move(
+        event({
+          type: 'pointermove',
+          clientX: 11,
+          clientY: 22,
+          pageX: 33,
+          pageY: 44,
+          screenX: 55,
+          screenY: 66,
+        })
+      );
+      expect(pointer.clientX).toBe(11);
+      expect(pointer.clientY).toBe(22);
+      expect(pointer.pageX).toBe(33);
+      expect(pointer.pageY).toBe(44);
+      expect(pointer.screenX).toBe(55);
+      expect(pointer.screenY).toBe(66);
+    });
+
+    it('falls back to zero for coordinates the event omits', () => {
+      const pointer = createPointer();
+      pointer.start(event({ identifier: 1 }));
+      pointer.move(event({ type: 'pointermove' }));
+      expect(pointer.clientX).toBe(0);
+      expect(pointer.pageY).toBe(0);
+    });
+  });
+
+  describe('stop', () => {
+    it('clears the identifiers it recorded', () => {
+      const pointer = createPointer();
+      pointer.start(event({ identifier: 5, pointerId: 5 }));
+      pointer.stop(event({ type: 'pointerup' }));
+      expect(pointer.identifier).toBeNull();
+      expect(pointer.pointerId).toBeNull();
+      expect(pointer.isDown).toBe(false);
+    });
+  });
+
+  describe('reset', () => {
+    it('returns the pointer to its resting state', () => {
+      const pointer = createPointer();
+      pointer.start(event({ identifier: 5 }));
+      pointer.reset();
+      expect(pointer.identifier).toBeNull();
+      expect(pointer.pointerId).toBeNull();
+      expect(pointer.isDown).toBe(false);
+      expect(pointer.isUp).toBe(true);
+    });
+  });
+});

package/src/phaser/core/input_pointer.ts

@@ -1,3 +1,4 @@
+import type { InputEvent } from './input_event.js';
 import type { Game } from './game.js';
 import type { InputHandler } from './input_handler.js';
 import { Circle } from '../geom/circle.js';
@@ -12,14 +13,14 @@ import {
 } from './const.js';
 
 export class Pointer {
-  public game!: any;
+  public game!: Game;
   public id!: number;
   public type!: number;
   public exists!: boolean;
   public identifier!: number | null;
   public pointerId!: any;
   public pointerMode!: number;
-  public target!: any;
+  public target!: EventTarget | null;
   public button!: any;
   public _holdSent!: boolean;
   public _history!: any;
@@ -121,8 +122,8 @@ export class Pointer {
    * TBD.
    * @param {MouseEvent|PointerEvent} event - TBD.
    */
-  public updateButtons(event: any | PointerEvent) {
-    if (event.type.toLowerCase().slice(-4) === 'down') {
+  public updateButtons(event: InputEvent) {
+    if (event.type.toLowerCase().endsWith('down')) {
       this.isUp = false;
       this.isDown = true;
     } else {
@@ -136,12 +137,12 @@ export class Pointer {
    * @param {PointerEvent} event - TBD.
    * @returns {Pointer} TBD.
    */
-  public start(event: any) {
+  public start(event: InputEvent) {
     const { input } = this.game;
     if (event.pointerId) {
       this.pointerId = event.pointerId;
     }
-    this.identifier = event.identifier;
+    this.identifier = event.identifier ?? null;
     this.target = event.target;
     if (this.isMouse) {
       this.updateButtons(event);
@@ -225,7 +226,7 @@ export class Pointer {
    * @param {boolean} fromClick - TBD.
    * @returns {Pointer} TBD.
    */
-  public move(event: any | PointerEvent, fromClick = false) {
+  public move(event: InputEvent, fromClick = false) {
     const { input } = this.game;
     if (input.pollLocked) {
       return null;
@@ -233,12 +234,12 @@ export class Pointer {
     if (fromClick && this.isMouse) {
       this.updateButtons(event);
     }
-    this.clientX = event.clientX;
-    this.clientY = event.clientY;
-    this.pageX = event.pageX;
-    this.pageY = event.pageY;
-    this.screenX = event.screenX;
-    this.screenY = event.screenY;
+    this.clientX = event.clientX ?? 0;
+    this.clientY = event.clientY ?? 0;
+    this.pageX = event.pageX ?? 0;
+    this.pageY = event.pageY ?? 0;
+    this.screenX = event.screenX ?? 0;
+    this.screenY = event.screenY ?? 0;
     if (this.isMouse && input.mouse.locked && !fromClick) {
       this.rawMovementX = event.movementX ?? event.mozMovementX ?? event.webkitMovementX ?? 0;
       this.rawMovementY = event.movementY ?? event.mozMovementY ?? event.webkitMovementY ?? 0;
@@ -270,7 +271,8 @@ export class Pointer {
     let i = input.moveCallbacks.length;
     while (i) {
       i -= 1;
-      input.moveCallbacks[i].callback.call(input.moveCallbacks[i].context, this, this.x, this.y, fromClick);
+      const moveCallback = input.moveCallbacks[i]!;
+      moveCallback.callback.call(moveCallback.context, this, this.x, this.y, fromClick);
     }
     //  Easy out if we're dragging something and it still exists
     if (this.targetObject !== null && this.targetObject.isDragged === true) {
@@ -381,7 +383,7 @@ export class Pointer {
    * TBD.
    * @param {MouseEvent|PointerEvent} event - TBD.
    */
-  public leave(event: any | PointerEvent) {
+  public leave(event: InputEvent) {
     this.withinGame = false;
     this.move(event, false);
   }
@@ -391,7 +393,7 @@ export class Pointer {
    * @param {MouseEvent|PointerEvent} event - TBD.
    * @returns {Pointer} TBD.
    */
-  public stop(event: any | PointerEvent) {
+  public stop(event: InputEvent) {
     const { input } = this.game;
     if (this._stateReset && this.withinGame) {
       event.preventDefault();
@@ -427,13 +429,10 @@ export class Pointer {
     if (this.id > 0) {
       this.active = false;
     }
-    this.withinGame = this.game.scale.bounds.contains(event.pageX, event.pageY);
+    this.withinGame = this.game.scale.bounds.contains(event.pageX ?? 0, event.pageY ?? 0);
     this.pointerId = null;
     this.identifier = null;
     this.positionUp.setTo(this.x, this.y);
-    if (!this.isMouse) {
-      input.currentPointers -= 1;
-    }
     input.interactiveItems.callAll('_releasedHandler', this);
     if (this._clickTrampolines) {
       this._trampolineTargetObject = this.targetObject;
@@ -469,7 +468,7 @@ export class Pointer {
    * @param {object} callbackContext - TBD.
    * @param {...any} callbackArgs - TBD.
    */
-  public addClickTrampoline(name: string, callback: Function, callbackContext: any, callbackArgs: any) {
+  public addClickTrampoline(name: string, callback: Function, callbackContext: unknown, callbackArgs: any) {
     if (!this.isDown) {
       return;
     }