@vpmedia/phaser 1.123.0 → 1.124.0

package/src/phaser/core/tween.ts

@@ -6,6 +6,7 @@ import { TweenData } from './tween_data.js';
 import type { Game } from './game.js';
 import type { TweenManager } from './tween_manager.js';
 import type { AppliedCallback, Callback, EasingFunction, InterpolationFunction } from './callback.js';
+import type { TweenValues } from './tween_data.js';
 
 export class Tween {
   public game!: Game;
@@ -23,7 +24,7 @@ export class Tween {
   public onComplete!: Signal;
   public isRunning!: boolean;
   public current!: number;
-  public properties!: any;
+  public properties!: TweenValues;
   public chainedTween!: Tween | null;
   public isPaused!: boolean;
   public _onUpdateCallback!: Callback | null;
@@ -92,7 +93,7 @@ export class Tween {
    * @returns {Tween} This Tween object for chaining.
    */
   public to(
-    properties: any,
+    properties: TweenValues,
     duration = 1000,
     ease: string | EasingFunction = 'Linear',
     autoStart = false,
@@ -100,13 +101,11 @@ export class Tween {
     repeat = 0,
     yoyo = false
   ): this {
-    if (typeof ease === 'string' && this.manager.easeMap[ease]) {
-      ease = this.manager.easeMap[ease]!;
-    }
+    const easing = this.resolveEasing(ease);
     if (this.isRunning) {
       return this;
     }
-    this.timeline.push(new TweenData(this).to(properties, duration, ease, delay, repeat, yoyo));
+    this.timeline.push(new TweenData(this).to(properties, duration, easing, delay, repeat, yoyo));
     if (autoStart) {
       this.start();
     }
@@ -125,7 +124,7 @@ export class Tween {
    * @returns {Tween} This Tween object for chaining.
    */
   public from(
-    properties: any,
+    properties: TweenValues,
     duration = 1000,
     ease: string | EasingFunction = 'Linear',
     autoStart = false,
@@ -133,14 +132,11 @@ export class Tween {
     repeat = 0,
     yoyo = false
   ): this {
-    if (typeof ease === 'string' && this.manager.easeMap[ease]) {
-      ease = this.manager.easeMap[ease]!;
-    }
     if (this.isRunning) {
       this.game.logger.warn('Tween.from cannot be called after Tween.start');
       return this;
     }
-    this.timeline.push(new TweenData(this).from(properties, duration, ease, delay, repeat, yoyo));
+    this.timeline.push(new TweenData(this).from(properties, duration, this.resolveEasing(ease), delay, repeat, yoyo));
     if (autoStart) {
       this.start();
     }
@@ -161,12 +157,9 @@ export class Tween {
       //  Build our master property list with the starting values
       const keys = Object.keys(tweenData.vEnd);
       for (const property of keys) {
-        const targetProperties = this.target as unknown as Record<string, number>;
-        this.properties[property] = targetProperties[property] ?? 0;
-        if (!Array.isArray(this.properties[property])) {
-          //  Ensures we're using numbers, not strings
-          this.properties[property] *= 1;
-        }
+        const targetProperties = this.target as unknown as Record<string, number | string | undefined>;
+        //  Ensures we're using numbers, not strings
+        this.properties[property] = Number(targetProperties[property] ?? 0);
       }
     }
     for (const tweenData of this.timeline) {
@@ -209,7 +202,7 @@ export class Tween {
    * @param {number} index - The index in the timeline to update.
    * @returns {Tween} This Tween object for chaining.
    */
-  public updateTweenData(property: string, value: any, index = 0): this {
+  public updateTweenData(property: string, value: unknown, index = 0): this {
     if (this.timeline.length === 0) {
       return this;
     }
@@ -283,6 +276,19 @@ export class Tween {
    * @param {number} index - The index in the timeline to apply easing to.
    * @returns {Tween} This Tween object for chaining.
    */
+  public resolveEasing(ease: string | EasingFunction): EasingFunction {
+    if (typeof ease !== 'string') {
+      return ease;
+    }
+    return this.manager.easeMap[ease] ?? this.manager.easeMap['Linear']!;
+  }
+
+  /**
+   * Sets the easing function for a tween in the timeline.
+   * @param {string | Function} ease - The easing function or its name.
+   * @param {number} index - The index of the tween in the timeline.
+   * @returns {Tween} This Tween object for chaining.
+   */
   public easing(ease: string | EasingFunction, index: number): this {
     if (typeof ease === 'string' && this.manager.easeMap[ease]) {
       ease = this.manager.easeMap[ease]!;
@@ -484,7 +490,7 @@ export class Tween {
    * @param {object[]} data - The array to store the generated data in.
    * @returns {object[]} The populated data array.
    */
-  public generateData(frameRate = 60, data: any[] = []) {
+  public generateData(frameRate = 60, data: Record<string, number>[] = []): Record<string, number>[] | null {
     if (this.game === null || this.target === null) {
       return null;
     }
@@ -493,12 +499,9 @@ export class Tween {
       //  Build our master property list with the starting values
       const keys = Object.keys(tweenData.vEnd);
       for (const property of keys) {
-        const targetProperties = this.target as unknown as Record<string, number>;
-        this.properties[property] = targetProperties[property] ?? 0;
-        if (!Array.isArray(this.properties[property])) {
-          //  Ensures we're using numbers, not strings
-          this.properties[property] *= 1;
-        }
+        const targetProperties = this.target as unknown as Record<string, number | string | undefined>;
+        //  Ensures we're using numbers, not strings
+        this.properties[property] = Number(targetProperties[property] ?? 0);
       }
     }
     for (const tweenData of this.timeline) {

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

@@ -0,0 +1,119 @@
+import { describe, expect, it } from 'vitest';
+import { TWEEN_COMPLETE, TWEEN_RUNNING } from './const.js';
+import { Signal } from './signal.js';
+import { Tween } from './tween.js';
+import { TweenManager } from './tween_manager.js';
+import type { Game } from './game.js';
+
+const createGame = (): Game =>
+  ({
+    time: { time: 0, elapsedMS: 0 },
+    logger: { warn: (): void => undefined },
+    onPause: new Signal(),
+    onResume: new Signal(),
+  }) as unknown as Game;
+
+const createTween = (target: Record<string, number>): { game: Game; tween: Tween } => {
+  const game = createGame();
+  const manager = new TweenManager(game);
+  return { game, tween: new Tween(target, game, manager) };
+};
+
+const advance = (game: Game, tween: Tween, ms: number): void => {
+  game.time.time += ms;
+  game.time.elapsedMS = ms;
+  tween.update(game.time.time);
+};
+
+describe('TweenData', (): void => {
+  describe('resolveEasing', (): void => {
+    it('takes a function as-is', (): void => {
+      const { tween } = createTween({ x: 0 });
+      const ease = (k: number): number => k * k;
+      expect(tween.resolveEasing(ease)).toBe(ease);
+    });
+
+    it('looks a named curve up in the manager', (): void => {
+      const { tween } = createTween({ x: 0 });
+      expect(tween.resolveEasing('Quad.easeIn')).toBe(tween.manager.easeMap['Quad.easeIn']);
+    });
+
+    it('falls back to linear for a name the manager does not know', (): void => {
+      const { tween } = createTween({ x: 0 });
+      expect(tween.resolveEasing('No.Such.Curve')).toBe(tween.manager.easeMap['Linear']);
+    });
+  });
+
+  describe('to', (): void => {
+    it('drives a numeric property from its start value to the end value', (): void => {
+      const target = { x: 0 };
+      const { game, tween } = createTween(target);
+      tween.to({ x: 100 }, 100, 'Linear', true);
+      advance(game, tween, 50);
+      expect(target.x).toBeCloseTo(50);
+      advance(game, tween, 50);
+      expect(target.x).toBeCloseTo(100);
+    });
+
+    it('reads a relative end value against the start', (): void => {
+      const target = { x: 20 };
+      const { game, tween } = createTween(target);
+      tween.to({ x: '+10' }, 100, 'Linear', true);
+      advance(game, tween, 100);
+      expect(target.x).toBeCloseTo(30);
+    });
+
+    it('interpolates through a list of waypoints', (): void => {
+      const target = { x: 0 };
+      const { game, tween } = createTween(target);
+      tween.to({ x: [0, 50, 100] }, 100, 'Linear', true);
+      advance(game, tween, 100);
+      expect(target.x).toBeCloseTo(100);
+    });
+
+    // An empty waypoint list has nothing to interpolate between, so the property goes to NaN.
+    it('survives an empty waypoint list', (): void => {
+      const target = { x: 7 };
+      const { game, tween } = createTween(target);
+      tween.to({ x: [] }, 100, 'Linear', true);
+      expect((): void => {
+        advance(game, tween, 100);
+      }).not.toThrow();
+    });
+
+    it('reports the tween running until the duration has passed', (): void => {
+      const target = { x: 0 };
+      const { game, tween } = createTween(target);
+      tween.to({ x: 10 }, 100, 'Linear', true);
+      game.time.time += 50;
+      game.time.elapsedMS = 50;
+      expect(tween.timeline[0]?.update(game.time.time)).toBe(TWEEN_RUNNING);
+      game.time.time += 100;
+      game.time.elapsedMS = 100;
+      expect(tween.timeline[0]?.update(game.time.time)).toBe(TWEEN_COMPLETE);
+    });
+  });
+
+  describe('from', (): void => {
+    it('starts at the given value and lands on the target original', (): void => {
+      const target = { x: 100 };
+      const { game, tween } = createTween(target);
+      tween.from({ x: 0 }, 100, 'Linear', true);
+      advance(game, tween, 0);
+      expect(target.x).toBeCloseTo(0);
+      advance(game, tween, 100);
+      expect(target.x).toBeCloseTo(100);
+    });
+  });
+
+  describe('generateData', (): void => {
+    it('produces one frame of values per step', (): void => {
+      const { tween } = createTween({ x: 0 });
+      tween.to({ x: 100 }, 100, 'Linear');
+      tween.start();
+      const data = tween.generateData(10) ?? [];
+      expect(data.length).toBeGreaterThan(0);
+      expect(data.at(-1)?.['x']).toBeCloseTo(100);
+    });
+  });
+});

package/src/phaser/core/tween_data.ts

@@ -2,15 +2,18 @@ import type { Game } from './game.js';
 import * as MathUtils from '../util/math.js';
 import { TWEEN_COMPLETE, TWEEN_LOOPED, TWEEN_PENDING, TWEEN_RUNNING } from './const.js';
 import type { Tween } from './tween.js';
-import type { InterpolationFunction } from './callback.js';
+import type { EasingFunction, InterpolationFunction } from './callback.js';
+
+/** The properties a tween drives, each holding either a single target or a list of waypoints. */
+export type TweenValues = Record<string, number | number[] | string>;
 
 export class TweenData {
   public parent!: Tween;
   public game!: Game;
-  public vStart!: Record<string, any>;
-  public vStartCache!: Record<string, any>;
-  public vEnd!: Record<string, any>;
-  public vEndCache!: Record<string, any>;
+  public vStart!: TweenValues;
+  public vStartCache!: TweenValues;
+  public vEnd!: TweenValues;
+  public vEndCache!: TweenValues;
   public duration!: number;
   public percent!: number;
   public value!: number;
@@ -71,7 +74,14 @@ export class TweenData {
    * @param {boolean} yoyo - Whether to reverse the tween on each repeat.
    * @returns {TweenData} This TweenData object for chaining.
    */
-  public to(properties: any, duration: number, ease: any, delay: number, repeat: number, yoyo: boolean): this {
+  public to(
+    properties: TweenValues,
+    duration: number,
+    ease: EasingFunction,
+    delay: number,
+    repeat: number,
+    yoyo: boolean
+  ): this {
     this.vEnd = properties;
     this.duration = duration;
     this.easingFunction = ease;
@@ -92,7 +102,14 @@ export class TweenData {
    * @param {boolean} yoyo - Whether to reverse the tween on each repeat.
    * @returns {TweenData} This TweenData object for chaining.
    */
-  public from(properties: any, duration: number, ease: any, delay: number, repeat: number, yoyo: boolean): this {
+  public from(
+    properties: TweenValues,
+    duration: number,
+    ease: EasingFunction,
+    delay: number,
+    repeat: number,
+    yoyo: boolean
+  ): this {
     this.vEnd = properties;
     this.duration = duration;
     this.easingFunction = ease;
@@ -115,9 +132,9 @@ export class TweenData {
       //  Reverse them all and instant set them
       const keys = Object.keys(this.vStartCache);
       for (const property of keys) {
-        this.vStart[property] = this.vEndCache[property];
-        this.vEnd[property] = this.vStartCache[property];
-        (this.parent.target as unknown as Record<string, any>)[property] = this.vStart[property];
+        this.vStart[property] = this.vEndCache[property]!;
+        this.vEnd[property] = this.vStartCache[property]!;
+        (this.parent.target as unknown as Record<string, unknown>)[property] = this.vStart[property];
       }
     }
     this.value = 0;
@@ -134,29 +151,27 @@ export class TweenData {
     const keys = Object.keys(this.parent.properties);
     for (const property of keys) {
       //  Load the property from the parent object
-      this.vStart[property] = this.parent.properties[property];
+      const start = this.parent.properties[property]!;
+      this.vStart[property] = start;
       //  Check if an Array was provided as property value
-      if (Array.isArray(this.vEnd[property])) {
-        if (this.vEnd[property].length === 0) {
-          // an empty end array leaves the property untouched for this step
-        } else if (this.percent === 0) {
-          //  Put the start value at the beginning of the array
-          //  but we only want to do this once, if the Tween hasn't run before
-          this.vEnd[property] = [this.vStart[property], ...this.vEnd[property]];
-        }
+      const end = this.vEnd[property];
+      if (Array.isArray(end) && end.length > 0 && this.percent === 0) {
+        //  Put the start value at the beginning of the array
+        //  but we only want to do this once, if the Tween hasn't run before
+        this.vEnd[property] = [Number(start), ...end];
       }
-      if (this.vEnd[property] !== undefined) {
-        if (typeof this.vEnd[property] === 'string') {
+      if (end === undefined) {
+        //  Null tween
+        this.vEnd[property] = start;
+      } else {
+        if (typeof end === 'string') {
           //  Parses relative end values with start as base (e.g.: +10, -3)
-          this.vEnd[property] = this.vStart[property] + Number(this.vEnd[property]);
+          this.vEnd[property] = Number(start) + Number(end);
         }
-        this.parent.properties[property] = this.vEnd[property];
-      } else {
-        //  Null tween
-        this.vEnd[property] = this.vStart[property];
+        this.parent.properties[property] = this.vEnd[property]!;
       }
-      this.vStartCache[property] = this.vStart[property];
-      this.vEndCache[property] = this.vEnd[property];
+      this.vStartCache[property] = this.vStart[property]!;
+      this.vEndCache[property] = this.vEnd[property]!;
     }
     return this;
   }
@@ -189,11 +204,11 @@ export class TweenData {
     this.value = this.easingFunction(this.percent);
     const keys = Object.keys(this.vEnd);
     for (const property of keys) {
-      const start = this.vStart[property];
       const end = this.vEnd[property];
-      (this.parent.target as unknown as Record<string, any>)[property] = Array.isArray(end)
+      const start = Number(this.vStart[property]);
+      (this.parent.target as unknown as Record<string, unknown>)[property] = Array.isArray(end)
         ? this.interpolationFunction.call(this.interpolationContext, end, this.value)
-        : start + (end - start) * this.value;
+        : start + (Number(end) - start) * this.value;
     }
     if ((!this.parent.reverse && this.percent === 1) || (this.parent.reverse && this.percent === 0)) {
       return this.repeat();
@@ -224,11 +239,11 @@ export class TweenData {
       const blob: Record<string, number> = {};
       const keys = Object.keys(this.vEnd);
       for (const property of keys) {
-        const start = this.vStart[property];
         const end = this.vEnd[property];
+        const start = Number(this.vStart[property]);
         blob[property] = Array.isArray(end)
           ? this.interpolationFunction(end, this.value)
-          : start + (end - start) * this.value;
+          : start + (Number(end) - start) * this.value;
       }
       data.push(blob);
       if ((!this.parent.reverse && this.percent === 1) || (this.parent.reverse && this.percent === 0)) {
@@ -253,8 +268,8 @@ export class TweenData {
         //  Restore the properties
         const keys = Object.keys(this.vStartCache);
         for (const property of keys) {
-          this.vStart[property] = this.vStartCache[property];
-          this.vEnd[property] = this.vEndCache[property];
+          this.vStart[property] = this.vStartCache[property]!;
+          this.vEnd[property] = this.vEndCache[property]!;
         }
         this.inReverse = false;
         return TWEEN_COMPLETE;
@@ -267,15 +282,15 @@ export class TweenData {
       //  If inReverse we're going from vEnd to vStartCache
       const keys = Object.keys(this.vStartCache);
       for (const property of keys) {
-        this.vStart[property] = this.vEndCache[property];
-        this.vEnd[property] = this.vStartCache[property];
+        this.vStart[property] = this.vEndCache[property]!;
+        this.vEnd[property] = this.vStartCache[property]!;
       }
     } else {
       //  If not inReverse we're just repopulating the cache again
       const keys = Object.keys(this.vStartCache);
       for (const property of keys) {
-        this.vStart[property] = this.vStartCache[property];
-        this.vEnd[property] = this.vEndCache[property];
+        this.vStart[property] = this.vStartCache[property]!;
+        this.vEnd[property] = this.vEndCache[property]!;
       }
       //  -1 means repeat forever, otherwise decrement the repeatCounter
       //  We only decrement this counter if the tween isn't doing a yoyo, as that doesn't count towards the repeat total

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

@@ -82,22 +82,22 @@ const EXPECTED: Record<string, number[]> = {
   ],
 };
 
-describe('tween_easing', () => {
-  it.each(Object.keys(EXPECTED))('%s matches its reference curve', (name) => {
+describe('tween_easing', (): void => {
+  it.each(Object.keys(EXPECTED))('%s matches its reference curve', (name): void => {
     const fn = (Easing as unknown as Record<string, (k: number) => number>)[name]!;
-    const actual = SAMPLE_POINTS.map((k) => fn(k));
+    const actual = SAMPLE_POINTS.map((k): number => fn(k));
     for (const [index, value] of actual.entries()) {
       expect(value).toBeCloseTo(EXPECTED[name]![index]!, 12);
     }
   });
 
-  it.each(Object.keys(EXPECTED))('%s is anchored at both ends', (name) => {
+  it.each(Object.keys(EXPECTED))('%s is anchored at both ends', (name): void => {
     const fn = (Easing as unknown as Record<string, (k: number) => number>)[name]!;
     expect(fn(0)).toBeCloseTo(0, 12);
     expect(fn(1)).toBeCloseTo(1, 12);
   });
 
-  it.each(Object.keys(EXPECTED))('%s does not mutate beyond its return value', (name) => {
+  it.each(Object.keys(EXPECTED))('%s does not mutate beyond its return value', (name): void => {
     const fn = (Easing as unknown as Record<string, (k: number) => number>)[name]!;
     for (const k of SAMPLE_POINTS) {
       expect(fn(k)).toBe(fn(k));

package/src/phaser/core/tween_manager.ts

@@ -106,7 +106,7 @@ export class TweenManager {
    * Get all tweens managed by this manager.
    * @returns {Tween[]} An array of all active tweens.
    */
-  public getAll() {
+  public getAll(): Tween[] {
     return this._tweens;
   }
 
@@ -128,7 +128,7 @@ export class TweenManager {
    */
   public removeFrom(obj: TweenTarget, children: object[] | null = null): void {
     if (Array.isArray(obj)) {
-      for (const entry of obj) {
+      for (const entry of obj as object[]) {
         this.removeFrom(entry);
       }
       return;

package/src/phaser/display/bitmap_text.test.ts

@@ -58,35 +58,35 @@ const createGame = (font: BitmapFontData | null = FONT): Game =>
 
 const createText = (text: string, size = 10): BitmapText => new BitmapText(createGame(), 0, 0, 'test', text, size);
 
-describe('BitmapText', () => {
-  beforeEach(() => {
+describe('BitmapText', (): void => {
+  beforeEach((): void => {
     getRegistry().CACHE_MISSING_IMAGE = new Texture(atlas, new Rectangle(0, 0, 1, 1));
   });
 
-  describe('updateText', () => {
-    it('measures a single line from the glyph advances', () => {
+  describe('updateText', (): void => {
+    it('measures a single line from the glyph advances', (): void => {
       const bitmapText = createText('AB');
       expect(bitmapText.textWidth).toBe(20);
       expect(bitmapText.textHeight).toBe(12);
     });
 
-    it('scales the metrics with the font size', () => {
+    it('scales the metrics with the font size', (): void => {
       const bitmapText = createText('AB', 20);
       expect(bitmapText.textWidth).toBe(40);
       expect(bitmapText.textHeight).toBe(24);
     });
 
-    it('splits on a newline and takes the widest line as the width', () => {
+    it('splits on a newline and takes the widest line as the width', (): void => {
       const bitmapText = createText('AB\nA');
       expect(bitmapText.textWidth).toBe(20);
       expect(bitmapText.textHeight).toBe(24);
     });
 
-    it('creates one glyph sprite per character', () => {
+    it('creates one glyph sprite per character', (): void => {
       expect(createText('AB')._glyphs).toHaveLength(2);
     });
 
-    it('reuses the glyph pool when the text shrinks', () => {
+    it('reuses the glyph pool when the text shrinks', (): void => {
       const bitmapText = createText('AB');
       const pooled = bitmapText._glyphs;
       bitmapText.text = 'A';
@@ -95,115 +95,115 @@ describe('BitmapText', () => {
       expect(bitmapText.children).toHaveLength(1);
     });
 
-    it('drops the glyphs that left the display list when purged', () => {
+    it('drops the glyphs that left the display list when purged', (): void => {
       const bitmapText = createText('AB');
       bitmapText.text = 'A';
       expect(bitmapText.purgeGlyphs()).toBe(1);
       expect(bitmapText._glyphs).toHaveLength(1);
     });
 
-    it('lays out an empty string as a single empty line', () => {
+    it('lays out an empty string as a single empty line', (): void => {
       const bitmapText = createText('');
       expect(bitmapText.textWidth).toBe(0);
       expect(bitmapText.textHeight).toBe(12);
       expect(bitmapText._glyphs).toHaveLength(0);
     });
 
-    it('does nothing when the font is not in the cache', () => {
+    it('does nothing when the font is not in the cache', (): void => {
       const bitmapText = new BitmapText(createGame(null), 0, 0, 'missing', 'AB');
       expect(bitmapText.textWidth).toBe(0);
       expect(bitmapText._glyphs).toHaveLength(0);
     });
   });
 
-  describe('scanLine', () => {
-    it('reports the whole text when nothing forces a wrap', () => {
+  describe('scanLine', (): void => {
+    it('reports the whole text when nothing forces a wrap', (): void => {
       const line = createText('AB').scanLine(FONT, 1, 'AB');
       expect(line).toMatchObject({ width: 20, text: 'AB', end: true, chars: [0, 10] });
     });
 
-    it('stops at a newline and reports the line as unfinished', () => {
+    it('stops at a newline and reports the line as unfinished', (): void => {
       const line = createText('AB').scanLine(FONT, 1, 'AB\nA');
       expect(line.text).toBe('AB');
       expect(line.end).toBe(false);
     });
 
-    it('wraps at the last space once maxWidth is exceeded', () => {
+    it('wraps at the last space once maxWidth is exceeded', (): void => {
       const bitmapText = createText('A A');
       bitmapText.maxWidth = 20;
       expect(bitmapText.scanLine(FONT, 1, 'A A').text).toBe('A');
     });
 
-    it('substitutes a space for a character the font does not carry', () => {
+    it('substitutes a space for a character the font does not carry', (): void => {
       const line = createText('A').scanLine(FONT, 1, 'Z');
       expect(line.width).toBe(5);
     });
 
-    it('skips a character the font cannot even substitute for', () => {
+    it('skips a character the font cannot even substitute for', (): void => {
       const spaceless: BitmapFontData = { ...FONT, chars: Object.fromEntries([glyph(65, 10)]) };
       expect(createText('A').scanLine(spaceless, 1, 'AZ').width).toBe(10);
     });
   });
 
-  describe('cleanText', () => {
-    it('drops characters the font does not carry', () => {
+  describe('cleanText', (): void => {
+    it('drops characters the font does not carry', (): void => {
       expect(createText('A').cleanText('AZB')).toBe('AB');
     });
 
-    it('replaces them with the given stand-in', () => {
+    it('replaces them with the given stand-in', (): void => {
       expect(createText('A').cleanText('AZB', '?')).toBe('A?B');
     });
 
-    it('keeps line breaks', () => {
+    it('keeps line breaks', (): void => {
       expect(createText('A').cleanText('A\nB')).toBe('A\nB');
     });
   });
 
-  describe('properties', () => {
-    it('re-lays out when the alignment changes', () => {
+  describe('properties', (): void => {
+    it('re-lays out when the alignment changes', (): void => {
       const bitmapText = createText('A\nAB');
       bitmapText.align = 'right';
       expect(bitmapText.align).toBe('right');
       expect(bitmapText._glyphs[0]?.position.x).toBe(10);
     });
 
-    it('ignores an alignment it does not know', () => {
+    it('ignores an alignment it does not know', (): void => {
       const bitmapText = createText('A');
       bitmapText.align = 'sideways';
       expect(bitmapText.align).toBe('left');
     });
 
-    it('coerces a string font size', () => {
+    it('coerces a string font size', (): void => {
       const bitmapText = createText('A');
       bitmapText.fontSize = '20';
       expect(bitmapText.fontSize).toBe(20);
     });
 
-    it('ignores a font size of zero or less', () => {
+    it('ignores a font size of zero or less', (): void => {
       const bitmapText = createText('A');
       bitmapText.fontSize = -5;
       expect(bitmapText.fontSize).toBe(10);
     });
 
-    it('renders the tint as a padded hex string', () => {
+    it('renders the tint as a padded hex string', (): void => {
       const bitmapText = createText('A');
       bitmapText.tint = 0x00ff00;
       expect(bitmapText.fill).toBe('#00FF00');
     });
 
-    it('reads a hex string back into the tint', () => {
+    it('reads a hex string back into the tint', (): void => {
       const bitmapText = createText('A');
       bitmapText.fill = '#FF0000';
       expect(bitmapText.tint).toBe(0xff0000);
     });
 
-    it('trims the font key before looking it up', () => {
+    it('trims the font key before looking it up', (): void => {
       const bitmapText = createText('A');
       bitmapText.font = '  other  ';
       expect(bitmapText.font).toBe('other');
     });
 
-    it('stringifies whatever the text is set to', () => {
+    it('stringifies whatever the text is set to', (): void => {
       const bitmapText = createText('A');
       bitmapText.text = 65;
       expect(bitmapText.text).toBe('65');