@3dsource/angular-unreal-module 0.0.122 → 0.0.123-dev.0

package/fesm2022/3dsource-angular-unreal-module.mjs

@@ -6,7 +6,7 @@ import { createAction, props, createReducer, on, createFeature, createSelector,
 import { concatLatestFrom } from '@ngrx/operators';
 import { Actions, createEffect, ofType, provideEffects } from '@ngrx/effects';
 import { whereNot, Logger, calculateMedian, clampf, lerp, getCanvasCached, getSnapshot, fitIntoRectangle, Truthy, tapLog, Falsy, generateUuid, COLOR_CODES, where, KeyboardNumericCode, InvertedKeyMap, Semaphore, HEXtoRGB, RGBtoHSV, inverseLerp, HSVtoRGB, RGBtoHEX, fpIsASameAsB } from '@3dsource/utils';
-import { map as map$1, distinctUntilChanged, takeWhile, filter, tap, takeUntil, catchError, withLatestFrom, exhaustMap, switchMap as switchMap$1, timeout as timeout$1, debounceTime as debounceTime$1, take as take$1, startWith as startWith$1 } from 'rxjs/operators';
+import { map as map$1, distinctUntilChanged, takeWhile, filter, tap, takeUntil, catchError, withLatestFrom, exhaustMap, switchMap as switchMap$1, timeout as timeout$1, share as share$1, debounceTime as debounceTime$1, take as take$1, startWith as startWith$1 } from 'rxjs/operators';
 import { DialogRef, DIALOG_DATA, Dialog } from '@angular/cdk/dialog';
 import { HttpClient } from '@angular/common/http';
 import { ScrollStrategyOptions } from '@angular/cdk/overlay';
@@ -1276,12 +1276,6 @@ class UnrealEffects {
             onDataChannelClose: this.unrealInitialConfig?.reconnect?.onDataChannelClose ??
                 DEFAULT_RECONNECT_ON_DATACHANNEL_CLOSE,
         };
-        this.destroyConnectionsCleanup$ = createEffect(() => {
-            return this.actions$.pipe(ofType(destroyUnrealScene), tap(() => {
-                this.commandsSender.destroy();
-                this.videoService.setContainer(null);
-            }));
-        }, { dispatch: false });
         this.destroyConnections$ = createEffect(() => {
             return this.actions$.pipe(ofType(destroyUnrealScene), map(() => destroyRemoteConnections({ reason: DisconnectReason.Destroy })));
         });
@@ -1903,7 +1897,7 @@ const BITRATE_MONITOR = new DataFlowMonitor(FilterModel.yellowFlag, FilterModel.
 
 class VideoService extends SubService {
     constructor() {
-        super(...arguments);
+        super();
         this.isVideoPlaying = this.store.selectSignal(unrealFeature.selectIsVideoPlaying);
         this.video = null;
         this.audio = null;
@@ -1922,6 +1916,11 @@ class VideoService extends SubService {
             ? // IMPORTANT! DO NOT CHANGE THOSE NUMBERS, LBM Stats are based on those values
                 interval(250).pipe(map(() => track.pcClient), switchMap$1((pcClient) => from(this.getStats(pcClient))), filter(Truthy))
             : of(null)), filter(Truthy), share());
+        this.destroyAbort = new AbortController();
+        this.destroyRef.onDestroy(() => {
+            this.destroyAbort.abort();
+            this.destroy();
+        });
     }
     setContainer(container = null) {
         this.container = container;
@@ -1933,7 +1932,9 @@ class VideoService extends SubService {
         this.VideoEncoderQP = Number(new TextDecoder('utf-16').decode(data));
     }
     create() {
-        this.disconnect$.pipe(take(1)).subscribe(() => this.destroy());
+        this.disconnect$
+            .pipe(take(1), takeUntil$1(this.destroy$))
+            .subscribe(() => this.destroy());
         this.destroy();
         this.createWebRtcVideo();
         this.createWebRtcAudio();
@@ -2006,8 +2007,13 @@ class VideoService extends SubService {
             window.addEventListener('pointerdown', resume, {
                 once: true,
                 capture: true,
+                signal: this.destroyAbort.signal,
+            });
+            window.addEventListener('keydown', resume, {
+                once: true,
+                capture: true,
+                signal: this.destroyAbort.signal,
             });
-            window.addEventListener('keydown', resume, { once: true, capture: true });
         }
     }
     async getStats(pcClient) {
@@ -2173,7 +2179,7 @@ class VideoService extends SubService {
             .pipe(takeUntil$1(merge(this.disconnect$, this.destroy$)))
             .subscribe(() => this.changeStatusMainVideoOnScene(true));
         fromEvent(this.video, 'loadedmetadata')
-            .pipe(take(1), filter((data) => this.video === data.target), tapLog('VideoService loadedmetadata:'), filter(() => !!this.video))
+            .pipe(take(1), filter((data) => this.video === data.target), tapLog('VideoService loadedmetadata:'), filter(() => !!this.video), takeUntil$1(this.destroy$))
             .subscribe(() => this.store.dispatch(videoStreamInitialized()));
     }
     createWebRtcAudio() {
@@ -2189,12 +2195,12 @@ class VideoService extends SubService {
             error: () => ({}),
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: VideoService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: VideoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: VideoService }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: VideoService, decorators: [{
             type: Injectable
-        }] });
+        }], ctorParameters: () => [] });
 
 class CommandTelemetryService {
     constructor() {
@@ -2650,21 +2656,32 @@ class SignallingService extends SubService {
         this.onWebRtcAnswer$ = new Subject();
         // Fan-in produced by abortEstablishingConnection$ in unreal.effects.ts
         // whenever cirrus drops, dropConnection fires, or the scene is destroyed.
+        // `share()` deduplicates the tap side effect across all takeUntil(abort$)
+        // subscribers — close() runs once per action, not once per subscriber.
         this.abort$ = this.actions$.pipe(ofType(abortEstablishingConnection), tap(() => this.close({
             code: 1000,
             reason: DisconnectReason.AbortEstablishingConnection,
-        })));
+        })), share$1());
+        this.ws = null;
         this.wsMsgHandlers = {};
         this.init();
+        this.destroyRef.onDestroy(() => this.close({
+            code: 1000,
+            reason: DisconnectReason.AbortEstablishingConnection,
+        }));
     }
     init() {
         if (this.unrealConfig?.playwright) {
             return;
         }
         this.setHandlersFromStream();
-        const stop$ = merge(this.abort$, this.destroy$);
+        // Subscriptions persist across sessions (use destroy$ only, not abort$).
+        // dataChannelReady is a per-session event; abort$ fires on every
+        // destroyUnrealScene, so binding to it kills the subs after the first
+        // session within a persistent injector. send() is already a no-op when
+        // the WS is closed, so there's no risk of leaking messages during teardown.
         this.actions$
-            .pipe(ofType(dataChannelReady), takeUntil(stop$))
+            .pipe(ofType(dataChannelReady), takeUntil(this.destroy$))
             .subscribe(() => {
             this.send({
                 type: 'p2pEstablished',
@@ -2675,7 +2692,7 @@ class SignallingService extends SubService {
         this.actions$
             .pipe(ofType(dataChannelReady), switchMap(() => this.store
             .select(unrealFeature.selectViewportReady)
-            .pipe(filter(Truthy), take(1))), takeUntil(stop$))
+            .pipe(filter(Truthy), take(1))), takeUntil(this.destroy$))
             .subscribe(() => {
             this.send({
                 type: 'streamPreparedForUserInteraction',
@@ -2698,7 +2715,7 @@ class SignallingService extends SubService {
             this.correlationId = generateUuid();
             this.commandTelemetryService.reset();
             this.startEstablishingConnection();
-            return this.getRegion().pipe(tap((region) => this.region.set(region ?? '')), map$1((region) => this.adaptUrlsToRegion(urlList, region)), switchMap((urls) => this.getAwsInstance(urls).pipe(take(1))), tap((awsInstance) => this.store.dispatch(setAwsInstance(awsInstance))), switchMap(({ wsUrl }) => this.connectToCirrus(wsUrl ?? '').pipe(filter(Truthy), take(1))), takeUntil(this.abort$));
+            return this.getRegion().pipe(tap((region) => this.region.set(region ?? '')), map$1((region) => this.adaptUrlsToRegion(urlList, region)), switchMap((urls) => this.getAwsInstance(urls).pipe(take(1))), tap((awsInstance) => this.store.dispatch(setAwsInstance(awsInstance))), switchMap(({ wsUrl }) => this.connectToCirrus(wsUrl ?? '').pipe(filter(Truthy), take(1))), takeUntil(merge(this.abort$, this.destroy$)));
         }).pipe(
         // Retry the whole attempt on error, advancing to the next URL each time.
         // Note: this currently re-runs `getRegion()` on every retry — see
@@ -2718,10 +2735,10 @@ class SignallingService extends SubService {
             // count: 10, // Optional: cap the number of attempts.
         }), 
         // abort$ sits OUTSIDE retry, so it kills the entire retry loop,
-        // not just the current attempt. Each inner createWebSocket also
-        // receives abort$ independently, so mid-connection attempts are
-        // canceled too.
-        takeUntil(this.abort$));
+        // not just the current attempt. destroy$ is the defense-in-depth
+        // signal for injector teardown — if the abort action chain doesn't
+        // run for any reason, destroy$ still stops the loop.
+        takeUntil(merge(this.abort$, this.destroy$)));
     }
     startEstablishingConnection() {
         this.showStatusMessage(UnrealStatusMessage.STARTING_YOUR_SESSION);
@@ -2903,10 +2920,10 @@ class SignallingService extends SubService {
     }
     connectToCirrus(wsUrl) {
         this.close({ code: 1000, reason: DisconnectReason.NewConnectionAttempt });
-        return createWebSocket(wsUrl).pipe(takeUntil(this.abort$), tapLog('WS CREATED'), tap((ws) => {
+        return createWebSocket(wsUrl).pipe(tapLog('WS CREATED'), tap((ws) => {
             this.commandTelemetryService.trackStartCommand('EXT-iceCandidate');
             this.addWsHandlers(ws);
-        }));
+        }), takeUntil(merge(this.abort$, this.destroy$)));
     }
     addWsHandlers(ws) {
         ws.onmessage = OnMessageHandler.bind(this);
@@ -2925,6 +2942,9 @@ class SignallingService extends SubService {
      */
     close(data) {
         const { code, reason } = data;
+        // Signal "no answer in flight anymore" to any subscriber that observes
+        // raw emissions (today's subscribers filter Truthy, but the Subject's
+        // `| null` type is the contract — keep it honored).
         this.onWebRtcAnswer$.next(null);
         this.orchestrationRetrySub?.unsubscribe();
         if (this.ws) {
@@ -3004,7 +3024,7 @@ class SignallingService extends SubService {
      * Check if the WebSocket connection is open and ready.
      */
     isConnected() {
-        return this.ws && this.ws.readyState === WS_OPEN_STATE;
+        return !!(this.ws && this.ws.readyState === WS_OPEN_STATE);
     }
     getRegion() {
         Logger.log('Start Getting Region');
@@ -3042,6 +3062,7 @@ class WebRtcPlayerService extends SubService {
         this.actions$
             .pipe(ofType(dropPC), takeUntil(this.destroy$))
             .subscribe(() => this.pcClient?.close());
+        this.destroyRef.onDestroy(() => this.closePC());
     }
     init() {
         this.signallingSrv.onConfig$
@@ -3176,7 +3197,7 @@ class WebRtcPlayerService extends SubService {
         this.commandTelemetryService.trackStartCommand('EXT-Browser ICE connection');
         this.commandTelemetryService.trackStartCommand('EXT-Signaling state change');
         this.handlePeerConnectionEvents(this.pcClient);
-        this.disconnect$.pipe(take(1)).subscribe(() => {
+        this.disconnect$.pipe(take(1), takeUntil(this.destroy$)).subscribe(() => {
             this.closePC();
         });
     }
@@ -3383,39 +3404,39 @@ class WebRtcPlayerService extends SubService {
     }
     handlePeerConnectionEvents(pcClient) {
         fromEvent(pcClient, 'signalingstatechange')
-            .pipe(map$1(() => this.pcClient?.signalingState), takeUntil(this.disconnect$))
+            .pipe(map$1(() => this.pcClient?.signalingState), takeUntil(merge(this.disconnect$, this.destroy$)))
             .subscribe((state) => {
             Logger.info('[Signaling state change] |', state, '|');
             this.commandTelemetryService.trackStopCommand('EXT-Signaling state change', true, { state, multi: true });
         });
         fromEvent(pcClient, 'iceconnectionstatechange')
-            .pipe(map$1(() => this.pcClient?.iceConnectionState), takeUntil(this.disconnect$))
+            .pipe(map$1(() => this.pcClient?.iceConnectionState), takeUntil(merge(this.disconnect$, this.destroy$)))
             .subscribe((state) => {
             Logger.info('[Browser ICE connection] |', state, '|');
             this.commandTelemetryService.trackStopCommand('EXT-Browser ICE connection', true, { state, multi: true });
         });
         fromEvent(pcClient, 'icegatheringstatechange')
-            .pipe(map$1(() => this.pcClient?.iceGatheringState), takeUntil(this.disconnect$))
+            .pipe(map$1(() => this.pcClient?.iceGatheringState), takeUntil(merge(this.disconnect$, this.destroy$)))
             .subscribe((state) => {
             Logger.info('[Browser ICE gathering] |', state, '|');
             this.commandTelemetryService.trackStopCommand('EXT-Browser ICE gathering', true, { state, multi: true });
         });
         fromEvent(pcClient, 'connectionstatechange')
-            .pipe(map$1(() => this.pcClient?.connectionState), takeUntil(this.disconnect$))
+            .pipe(map$1(() => this.pcClient?.connectionState), takeUntil(merge(this.disconnect$, this.destroy$)))
             .subscribe((state) => {
             Logger.info('[RTCPeerConnection state] |', state, '|');
         });
         fromEvent(pcClient, 'icecandidate')
-            .pipe(map$1((e) => e.candidate), filter(Truthy), tap$1((candidate) => Logger.info('[Browser ICE candidate]', '| Type=', candidate.type, '| Protocol=', candidate.protocol, '| Address=', candidate.address, '| Port=', candidate.port, '|')), takeUntil(this.disconnect$))
+            .pipe(map$1((e) => e.candidate), filter(Truthy), tap$1((candidate) => Logger.info('[Browser ICE candidate]', '| Type=', candidate.type, '| Protocol=', candidate.protocol, '| Address=', candidate.address, '| Port=', candidate.port, '|')), takeUntil(merge(this.disconnect$, this.destroy$)))
             .subscribe((candidate) => this.signallingSrv.send({ type: 'iceCandidate', candidate }));
         // When the server creates the DataChannel (server-offer flow),
         // we receive it here via the 'datachannel' event
         fromEvent(pcClient, 'datachannel')
-            .pipe(tap$1((e) => Logger.info(`[DATACHANNEL] Received remote DC: label="${e.channel.label}" id=${e.channel.id} protocol="${e.channel.protocol}" ordered=${e.channel.ordered}`)), map$1((e) => e.channel), takeUntil(this.disconnect$))
+            .pipe(tap$1((e) => Logger.info(`[DATACHANNEL] Received remote DC: label="${e.channel.label}" id=${e.channel.id} protocol="${e.channel.protocol}" ordered=${e.channel.ordered}`)), map$1((e) => e.channel), takeUntil(merge(this.disconnect$, this.destroy$)))
             .subscribe((datachannel) => {
             this.dcClient = this.setupDataChannelCallbacks(datachannel);
         });
-        const onTrack$ = fromEvent(pcClient, 'track').pipe(takeUntil(this.disconnect$), filter((e) => !!e.track), tap$1((e) => Logger.info('Got track - ' +
+        const onTrack$ = fromEvent(pcClient, 'track').pipe(takeUntil(merge(this.disconnect$, this.destroy$)), filter((e) => !!e.track), tap$1((e) => Logger.info('Got track - ' +
             e.track.kind +
             ' id=' +
             e.track.id +
@@ -3496,7 +3517,7 @@ class WebRtcPlayerService extends SubService {
             fromEvent(datachannel, 'close')
                 .pipe(
             // Only dispatch disconnect if not already reconnecting to avoid infinite loops
-            filter(() => !this.isReconnecting()), take(1))
+            filter(() => !this.isReconnecting()), take(1), takeUntil(this.destroy$))
                 .subscribe((e) => {
                 Logger.warn(`[DATACHANNEL] Data channel disconnected: ${datachannel.label}(${datachannel.id})`, e);
                 this.store.dispatch(disconnectStream({
@@ -3505,7 +3526,7 @@ class WebRtcPlayerService extends SubService {
                 }));
             });
             fromEvent(datachannel, 'error')
-                .pipe(takeUntil(this.disconnect$))
+                .pipe(takeUntil(merge(this.disconnect$, this.destroy$)))
                 .subscribe((e) => {
                 const message = `[DATACHANNEL] Data channel "${datachannel.label}" error. id:${datachannel.id}`;
                 Logger.error(message, e);
@@ -3513,7 +3534,7 @@ class WebRtcPlayerService extends SubService {
             fromEvent(datachannel, 'open')
                 .pipe(tap$1(() => {
                 Logger.info(`[DATACHANNEL] Data channel "${datachannel.label}" connected. id:${datachannel.id}`);
-            }), takeUntil(this.disconnect$))
+            }), takeUntil(merge(this.disconnect$, this.destroy$)))
                 .subscribe(() => {
                 this.commandTelemetryService.trackStopCommand('EXT-DataChannel Connection');
                 this.onDataChannelConnected();
@@ -3526,7 +3547,7 @@ class WebRtcPlayerService extends SubService {
                 `[DATACHANNEL] Message received on "${datachannel.label}" id=${datachannel.id}, byteCode=${view[0]}, size=${view.byteLength}`,
               );
             }),*/
-            map$1((e) => e.data), takeUntil(this.disconnect$))
+            map$1((e) => e.data), takeUntil(merge(this.disconnect$, this.destroy$)))
                 .subscribe((data) => this.onDataChannelMessage$.next(data));
             return datachannel;
         }
@@ -4065,12 +4086,6 @@ class UnrealCommunicatorService {
             this.requestQualityControl();
         });
     }
-    destroy() {
-        this.destroy$.next();
-        // Recreate the Subject so it remains usable for the next session.
-        // A completed Subject silently ignores all future next/complete calls.
-        this.destroy$ = new Subject();
-    }
     sendCommandToUnreal(data) {
         if (this.isPlaywrightMode()) {
             return;
@@ -4656,12 +4671,17 @@ class RegionsPingService {
         this.httpClient = inject(HttpClient);
         this.store = inject(Store);
         this.unrealInitialConfig = inject(UNREAL_CONFIG, { optional: true });
+        this.destroyRef = inject(DestroyRef);
+        // Aborted on injector destruction. Cascades through every in-flight
+        // fetch so background pings stop the moment the service dies.
+        this.destroyAbort = new AbortController();
         this.config = {
             ping_count: 2,
             ping_timeout: 2000,
             max_parallel_requests: 10,
             bust_cache: true,
         };
+        this.destroyRef.onDestroy(() => this.destroyAbort.abort());
     }
     getFastest(regionListUrl = this.unrealInitialConfig?.regionsPingUrl || '') {
         // Self-announce every lifecycle waypoint of the region-discovery
@@ -4684,13 +4704,27 @@ class RegionsPingService {
         return this.httpClient.get(regionListUrl);
     }
     async startPinging(endpoints, defaultTimeout) {
+        // Two-tier cancellation:
+        //   - destroyAbort: service teardown (injector destroy)
+        //   - winnerAbort: first successful region resolves Promise.any
+        // Both aborts cascade into every in-flight fetch so losing pings stop
+        // immediately instead of running their full ping_count × timeout budget.
+        const winnerAbort = new AbortController();
+        const stopSignal = AbortSignal.any([
+            winnerAbort.signal,
+            this.destroyAbort.signal,
+        ]);
         const semaphore = new Semaphore(this.config.max_parallel_requests);
         const tasks = endpoints.map(async ({ region_code, url, timeout }) => {
             await semaphore.acquire();
             try {
-                const result = await this.checkLatency(url, timeout ?? defaultTimeout);
-                if (result.length < 2)
+                if (stopSignal.aborted) {
+                    throw new Error('aborted');
+                }
+                const result = await this.checkLatency(url, timeout ?? defaultTimeout, stopSignal);
+                if (result.length < 2) {
                     throw new Error('insufficient pings');
+                }
                 return { region_code, result };
             }
             finally {
@@ -4698,13 +4732,15 @@ class RegionsPingService {
             }
         });
         try {
-            return await Promise.any(tasks);
+            const winner = await Promise.any(tasks);
+            winnerAbort.abort();
+            return winner;
         }
         catch {
             return null;
         }
     }
-    async checkLatency(endpoint, timeout) {
+    async checkLatency(endpoint, timeout, externalSignal) {
         const pingResults = [];
         const sep = endpoint.includes('?') ? '&' : '?';
         for (let i = 0; i < this.config.ping_count; i++) {
@@ -4721,7 +4757,7 @@ class RegionsPingService {
                         Expires: '0',
                     },
                     credentials: 'omit',
-                }, timeout);
+                }, timeout, externalSignal);
             }
             catch {
                 // intentional: finally pushes the elapsed time as the latency sample
@@ -4733,9 +4769,11 @@ class RegionsPingService {
         }
         return pingResults;
     }
-    async fetchWithTimeout(url, options = {}, timeout) {
+    async fetchWithTimeout(url, options = {}, timeout, externalSignal) {
         const controller = new AbortController();
-        options.signal = controller.signal;
+        options.signal = externalSignal
+            ? AbortSignal.any([controller.signal, externalSignal])
+            : controller.signal;
         const timeoutId = setTimeout(() => controller.abort(new DOMException('Request timed out', 'TimeoutError')), timeout);
         try {
             const response = await fetch(url, options);
@@ -4752,7 +4790,7 @@ class RegionsPingService {
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: RegionsPingService, decorators: [{
             type: Injectable
-        }] });
+        }], ctorParameters: () => [] });
 
 class StreamStatusTelemetryService extends SubService {
     constructor() {
@@ -5711,7 +5749,7 @@ class AnalyticsService extends SubService {
         });
     }
     monitorMouse() {
-        const stop$ = this.#stopMouse$.asObservable();
+        const stop$ = merge(this.#stopMouse$, this.destroy$);
         const element = document.getElementById('streamingVideo');
         if (!element) {
             return;