@diffenderfer-games/hub 2.0.0-next.0 → 2.0.0-next.1

package/src/uistack/ui-stack.ts

@@ -1,144 +1,144 @@
-/**
- * The overlay stack implementation: two edges (`open` when depth goes
- * 0 → 1, `close` when it returns to 0) mirrored as window events, the
- * `autoPause` helper, and the `play` suspension.
- */
-import { LEGACY_GLOBAL_NAMES } from '../globals';
-import { isGroupSwitch, PlaySuspension } from './play-suspension';
-import type { AutoPauseOptions, OverlayEdge, OverlayEvent, OverlayListener, OverlayReason, UiStack, UiStackHandoff } from './types';
-
-/** Bump when the UiStack contract gains behaviour; idle older instances are replaced. */
-export const UI_STACK_VERSION = 1;
-
-/** One open entry (its identity is what `pop` removes). */
-interface StackEntry {
-  readonly reason: OverlayReason;
-}
-
-/** The page-wide overlay stack (see {@link UiStack}). */
-export class UiStackImpl implements UiStack {
-  readonly version = UI_STACK_VERSION;
-  private readonly entries: StackEntry[] = [];
-  private readonly listeners: Record<OverlayEdge, Set<OverlayListener>> = { open: new Set(), close: new Set() };
-  private isPausable = true;
-  private suspension: PlaySuspension | null = null;
-
-  constructor(handoff?: UiStackHandoff) {
-    if (handoff === undefined) {
-      return;
-    }
-    handoff.listeners.open.forEach((listener) => this.listeners.open.add(listener));
-    handoff.listeners.close.forEach((listener) => this.listeners.close.add(listener));
-    this.isPausable = handoff.canPause;
-  }
-
-  get isOpen(): boolean {
-    return this.entries.length > 0;
-  }
-
-  get depth(): number {
-    return this.entries.length;
-  }
-
-  get canPause(): boolean {
-    return this.isPausable;
-  }
-
-  push(reason: OverlayReason): () => void {
-    const entry: StackEntry = { reason };
-    this.entries.push(entry);
-    if (this.entries.length === 1) {
-      this.suspendPlay();
-      this.emit('open', { reason, canPause: this.isPausable });
-    }
-    let wasPopped = false;
-    return () => {
-      if (wasPopped) {
-        return;
-      }
-      wasPopped = true;
-      const index = this.entries.indexOf(entry);
-      if (index < 0) {
-        return;
-      }
-      this.entries.splice(index, 1);
-      if (this.entries.length === 0) {
-        // Listeners run before `play` is restored, so a game that pauses in its close handler is honoured.
-        this.emit('close', { reason, canPause: this.isPausable });
-        this.suspension?.release();
-        this.suspension = null;
-      }
-    };
-  }
-
-  on(edge: OverlayEdge, listener: OverlayListener): () => void {
-    this.listeners[edge].add(listener);
-    return () => {
-      this.listeners[edge].delete(listener);
-    };
-  }
-
-  autoPause(options: AutoPauseOptions): () => void {
-    let wasPausedByUs = false;
-    const pauseOnOpen = (event: OverlayEvent): void => {
-      if (!event.canPause) {
-        return;
-      }
-      wasPausedByUs = true;
-      options.pause();
-    };
-    const resumeOnClose = (): void => {
-      if (wasPausedByUs && options.resumeOnClose === true) {
-        options.resume?.();
-      }
-      wasPausedByUs = false;
-    };
-    const stopOpen = this.on('open', pauseOnOpen);
-    const stopClose = this.on('close', resumeOnClose);
-    // Registered while hub UI is already up: pause now, as if it just opened.
-    const firstEntry = this.entries[0];
-    if (firstEntry !== undefined) {
-      pauseOnOpen({ reason: firstEntry.reason, canPause: this.isPausable });
-    }
-    return () => {
-      stopOpen();
-      stopClose();
-    };
-  }
-
-  setCanPause(canPause: boolean): void {
-    this.isPausable = canPause;
-  }
-
-  handoff(): UiStackHandoff {
-    const handoff: UiStackHandoff = {
-      listeners: { open: [...this.listeners.open], close: [...this.listeners.close] },
-      canPause: this.isPausable,
-    };
-    this.listeners.open.clear();
-    this.listeners.close.clear();
-    return handoff;
-  }
-
-  private suspendPlay(): void {
-    // eslint-disable-next-line no-restricted-syntax -- trust boundary: the page input system may be another bundle's
-    const input: unknown = typeof window === 'undefined' ? undefined : window[LEGACY_GLOBAL_NAMES.input];
-    if (this.suspension === null && isGroupSwitch(input)) {
-      this.suspension = new PlaySuspension(input);
-    }
-  }
-
-  private emit(edge: OverlayEdge, event: OverlayEvent): void {
-    for (const listener of [...this.listeners[edge]]) {
-      try {
-        listener(event);
-      } catch (error) {
-        // eslint-disable-next-line no-console -- a game's listener failing must not break the hub UI; surface it
-        console.error('[hub] overlay listener failed', error);
-      }
-    }
-    if (typeof window !== 'undefined') {
-      window.dispatchEvent(new CustomEvent(`hub:overlay-${edge}`, { detail: event }));
-    }
-  }
-}
+/**
+ * The overlay stack implementation: two edges (`open` when depth goes
+ * 0 → 1, `close` when it returns to 0) mirrored as window events, the
+ * `autoPause` helper, and the `play` suspension.
+ */
+import { LEGACY_GLOBAL_NAMES } from '../globals';
+import { isGroupSwitch, PlaySuspension } from './play-suspension';
+import type { AutoPauseOptions, OverlayEdge, OverlayEvent, OverlayListener, OverlayReason, UiStack, UiStackHandoff } from './types';
+
+/** Bump when the UiStack contract gains behaviour; idle older instances are replaced. */
+export const UI_STACK_VERSION = 1;
+
+/** One open entry (its identity is what `pop` removes). */
+interface StackEntry {
+  readonly reason: OverlayReason;
+}
+
+/** The page-wide overlay stack (see {@link UiStack}). */
+export class UiStackImpl implements UiStack {
+  readonly version = UI_STACK_VERSION;
+  private readonly entries: StackEntry[] = [];
+  private readonly listeners: Record<OverlayEdge, Set<OverlayListener>> = { open: new Set(), close: new Set() };
+  private isPausable = true;
+  private suspension: PlaySuspension | null = null;
+
+  constructor(handoff?: UiStackHandoff) {
+    if (handoff === undefined) {
+      return;
+    }
+    handoff.listeners.open.forEach((listener) => this.listeners.open.add(listener));
+    handoff.listeners.close.forEach((listener) => this.listeners.close.add(listener));
+    this.isPausable = handoff.canPause;
+  }
+
+  get isOpen(): boolean {
+    return this.entries.length > 0;
+  }
+
+  get depth(): number {
+    return this.entries.length;
+  }
+
+  get canPause(): boolean {
+    return this.isPausable;
+  }
+
+  push(reason: OverlayReason): () => void {
+    const entry: StackEntry = { reason };
+    this.entries.push(entry);
+    if (this.entries.length === 1) {
+      this.suspendPlay();
+      this.emit('open', { reason, canPause: this.isPausable });
+    }
+    let wasPopped = false;
+    return () => {
+      if (wasPopped) {
+        return;
+      }
+      wasPopped = true;
+      const index = this.entries.indexOf(entry);
+      if (index < 0) {
+        return;
+      }
+      this.entries.splice(index, 1);
+      if (this.entries.length === 0) {
+        // Listeners run before `play` is restored, so a game that pauses in its close handler is honoured.
+        this.emit('close', { reason, canPause: this.isPausable });
+        this.suspension?.release();
+        this.suspension = null;
+      }
+    };
+  }
+
+  on(edge: OverlayEdge, listener: OverlayListener): () => void {
+    this.listeners[edge].add(listener);
+    return () => {
+      this.listeners[edge].delete(listener);
+    };
+  }
+
+  autoPause(options: AutoPauseOptions): () => void {
+    let wasPausedByUs = false;
+    const pauseOnOpen = (event: OverlayEvent): void => {
+      if (!event.canPause) {
+        return;
+      }
+      wasPausedByUs = true;
+      options.pause();
+    };
+    const resumeOnClose = (): void => {
+      if (wasPausedByUs && options.resumeOnClose === true) {
+        options.resume?.();
+      }
+      wasPausedByUs = false;
+    };
+    const stopOpen = this.on('open', pauseOnOpen);
+    const stopClose = this.on('close', resumeOnClose);
+    // Registered while hub UI is already up: pause now, as if it just opened.
+    const firstEntry = this.entries[0];
+    if (firstEntry !== undefined) {
+      pauseOnOpen({ reason: firstEntry.reason, canPause: this.isPausable });
+    }
+    return () => {
+      stopOpen();
+      stopClose();
+    };
+  }
+
+  setCanPause(canPause: boolean): void {
+    this.isPausable = canPause;
+  }
+
+  handoff(): UiStackHandoff {
+    const handoff: UiStackHandoff = {
+      listeners: { open: [...this.listeners.open], close: [...this.listeners.close] },
+      canPause: this.isPausable,
+    };
+    this.listeners.open.clear();
+    this.listeners.close.clear();
+    return handoff;
+  }
+
+  private suspendPlay(): void {
+    // eslint-disable-next-line no-restricted-syntax -- trust boundary: the page input system may be another bundle's
+    const input: unknown = typeof window === 'undefined' ? undefined : window[LEGACY_GLOBAL_NAMES.input];
+    if (this.suspension === null && isGroupSwitch(input)) {
+      this.suspension = new PlaySuspension(input);
+    }
+  }
+
+  private emit(edge: OverlayEdge, event: OverlayEvent): void {
+    for (const listener of [...this.listeners[edge]]) {
+      try {
+        listener(event);
+      } catch (error) {
+        // eslint-disable-next-line no-console -- a game's listener failing must not break the hub UI; surface it
+        console.error('[hub] overlay listener failed', error);
+      }
+    }
+    if (typeof window !== 'undefined') {
+      window.dispatchEvent(new CustomEvent(`hub:overlay-${edge}`, { detail: event }));
+    }
+  }
+}