@vpmedia/phaser 1.125.0 → 1.127.0

package/src/phaser/core/page_lifecycle.ts

@@ -0,0 +1,142 @@
+/**
+ * A minimal page lifecycle observer.
+ * @see https://developer.chrome.com/docs/web-platform/page-lifecycle-api
+ */
+
+/** The page is visible and has focus. */
+export const PAGE_STATE_ACTIVE = 'active';
+/** The page is visible but does not have focus. */
+export const PAGE_STATE_PASSIVE = 'passive';
+/** The page is not visible. */
+export const PAGE_STATE_HIDDEN = 'hidden';
+/** The browser has frozen the page to reclaim its resources. */
+export const PAGE_STATE_FROZEN = 'frozen';
+/** The page is being unloaded. */
+export const PAGE_STATE_TERMINATED = 'terminated';
+
+/** One of the states a page can be in. */
+export type PageState =
+  | typeof PAGE_STATE_ACTIVE
+  | typeof PAGE_STATE_PASSIVE
+  | typeof PAGE_STATE_HIDDEN
+  | typeof PAGE_STATE_FROZEN
+  | typeof PAGE_STATE_TERMINATED;
+
+/** Called with the state the page has just entered and the one it left. */
+export type PageStateListener = (state: PageState, previous: PageState) => void;
+
+const listeners = new Set<PageStateListener>();
+let currentState: PageState | null = null;
+let started = false;
+
+/**
+ * Reads the state the page is in right now.
+ * @returns {PageState} The current page state.
+ */
+export const readPageState = (): PageState => {
+  if (document.visibilityState === 'hidden') {
+    return PAGE_STATE_HIDDEN;
+  }
+  return document.hasFocus() ? PAGE_STATE_ACTIVE : PAGE_STATE_PASSIVE;
+};
+
+/**
+ * Records a new state and tells the listeners, ignoring transitions to the state already held.
+ * @param {PageState} next - The state the page has entered.
+ */
+const enterState = (next: PageState): void => {
+  const previous = currentState ?? readPageState();
+  if (next === previous) {
+    return;
+  }
+  currentState = next;
+  const current = [...listeners];
+  for (const listener of current) {
+    listener(next, previous);
+  }
+};
+
+/**
+ * Starts observing the page, if it is not observed already.
+ */
+export const startPageLifecycle = (): void => {
+  if (started) {
+    return;
+  }
+  started = true;
+  currentState = readPageState();
+  for (const type of ['pageshow', 'focus', 'blur', 'visibilitychange', 'resume']) {
+    globalThis.addEventListener(
+      type,
+      (event: Event): void => {
+        // blur and focus also fire for elements inside the page, which say nothing about the page
+        const fromElement = event.target !== globalThis && event.target !== document;
+        if ((event.type === 'blur' || event.type === 'focus') && fromElement) {
+          return;
+        }
+        enterState(readPageState());
+      },
+      true
+    );
+  }
+  globalThis.addEventListener(
+    'freeze',
+    (): void => {
+      enterState(PAGE_STATE_FROZEN);
+    },
+    true
+  );
+  globalThis.addEventListener(
+    'pagehide',
+    (event: Event): void => {
+      enterState((event as PageTransitionEvent).persisted ? PAGE_STATE_FROZEN : PAGE_STATE_TERMINATED);
+    },
+    true
+  );
+};
+
+/**
+ * Returns the state the page is in, starting the observer on first use.
+ * @returns {PageState} The current page state.
+ */
+export const getPageState = (): PageState => {
+  startPageLifecycle();
+  return currentState ?? readPageState();
+};
+
+/**
+ * Registers a listener for every state change.
+ * @param {PageStateListener} listener - The listener to call on each change.
+ * @returns {() => void} A function that removes the listener again.
+ */
+export const onPageStateChange = (listener: PageStateListener): (() => void) => {
+  startPageLifecycle();
+  listeners.add(listener);
+  return (): void => {
+    listeners.delete(listener);
+  };
+};
+
+/**
+ * Runs a callback the next time the page becomes active, once.
+ * @param {() => void} callback - The callback to run.
+ * @returns {() => void} A function that cancels the pending callback.
+ */
+export const oncePageActive = (callback: () => void): (() => void) => {
+  const stop = onPageStateChange((state: PageState): void => {
+    if (state === PAGE_STATE_ACTIVE) {
+      stop();
+      callback();
+    }
+  });
+  return stop;
+};
+
+/**
+ * Drops every listener and stops tracking. Only the tests need this.
+ */
+export const resetPageLifecycle = (): void => {
+  listeners.clear();
+  currentState = null;
+  started = false;
+};

package/src/phaser/core/scale_manager.ts

@@ -453,7 +453,7 @@ export class ScaleManager {
     }
     this.bounds.setTo(this.offset.x, this.offset.y, this.width, this.height);
     // Can be invoked in boot pre-input
-    if (this.game.input as Input | undefined) {
+    if ((this.game.input as Input | undefined)?.scale) {
       this.game.input.scale.setTo(this.scaleFactor.x, this.scaleFactor.y);
     }
   }

package/src/phaser/core/sound_manager.ts

@@ -1,10 +1,4 @@
 import type { Game } from './game.js';
-import {
-  addPageLifecycleCallback,
-  getPageLifecycleEventEmitter,
-  PAGE_LIFECYCLE_STATE_ACTIVE,
-  PAGE_LIFECYCLE_STATE_CHANGE_EVENT,
-} from '@vpmedia/simplify';
 import { ArraySet } from './array_set.js';
 import { AUDIO_DISABLED, AUDIO_STANDARD, AUDIO_WEBKIT } from './const.js';
 import { ENGINE_ERROR_CREATING_AUDIO_CONTEXT } from './error_code.js';
@@ -12,6 +6,7 @@ import { Signal } from './signal.js';
 import { Sound } from './sound.js';
 import { SoundSprite } from './sound_sprite.js';
 import type { Callback } from './callback.js';
+import { onPageStateChange, oncePageActive } from './page_lifecycle.js';
 
 export class SoundManager {
   public game!: Game;
@@ -115,7 +110,7 @@ export class SoundManager {
       this.addUnlockHandlers();
     }
     this.context.addEventListener('statechange', this.onContextStateChange, false);
-    getPageLifecycleEventEmitter().on(PAGE_LIFECYCLE_STATE_CHANGE_EVENT, this.onPageLifecycleChange);
+    onPageStateChange(this.onPageLifecycleChange);
   }
 
   /**
@@ -293,7 +288,7 @@ export class SoundManager {
       const typedError = error instanceof Error ? error : new Error(String(error));
       this.game.logger.fatal('SoundManager', { error: typedError, tags: { 'asset.key': key } });
       if (typedError.name === 'InvalidStateError') {
-        addPageLifecycleCallback(PAGE_LIFECYCLE_STATE_ACTIVE, (): void => {
+        oncePageActive((): void => {
           void this.decode(key);
         });
       } else if (typedError.name === 'EncodingError') {

package/src/phaser/display/webgl/graphics.ts

@@ -470,8 +470,8 @@ export const buildPoly = (graphicsData: DisplayGraphicsData, webGLData: Graphics
   const r = color[0] * alpha;
   const g = color[1] * alpha;
   const b = color[2] * alpha;
-  const triangles = triangulate(points, null, 2);
-  if (triangles.length === 0) {
+  const triangles: number[] | null = triangulate(points, null, 2);
+  if (!triangles?.length) {
     return false;
   }
   const vertPos = verts.length / 6;