@guardvideo/player-sdk 3.4.0 → 3.6.0

package/dist/index.js

@@ -70,8 +70,19 @@ class WatchChunkAccumulator {
     }
 }
 
+const VALID_EVENT_TYPES = [
+    'watch_chunk',
+    'play',
+    'pause',
+    'seek',
+    'ended',
+    'quality_change',
+    'error',
+    'security_event',
+];
 const MAX_BATCH_SIZE = 25;
 const DEFAULT_FLUSH_INTERVAL = 5000;
+const MAX_FLUSH_BACKOFF = 60000;
 class EventTracker {
     constructor(config) {
         this.buffer = [];
@@ -79,6 +90,8 @@ class EventTracker {
         this.accumulator = new WatchChunkAccumulator();
         this.destroyed = false;
         this._onBeforeUnload = null;
+        this.flushBackoff = 0;
+        this.flushing = false;
         this.config = {
             endpoint: config.endpoint,
             tokenId: config.tokenId,
@@ -94,6 +107,12 @@ class EventTracker {
     track(type, positionSeconds, payload) {
         if (this.destroyed)
             return;
+        if (!VALID_EVENT_TYPES.includes(type)) {
+            if (this.config.debug) {
+                console.warn('[GuardVideo EventTracker] Skipping unknown event type:', type);
+            }
+            return;
+        }
         this.buffer.push({
             event_type: type,
             event_at: new Date().toISOString(),
@@ -117,7 +136,7 @@ class EventTracker {
         this.config.sessionId = sessionId;
     }
     async flush() {
-        if (this.destroyed)
+        if (this.destroyed || this.flushing)
             return;
         const chunks = this.accumulator.drain();
         for (const c of chunks) {
@@ -125,8 +144,14 @@ class EventTracker {
         }
         if (this.buffer.length === 0)
             return;
-        const batch = this.buffer.splice(0, MAX_BATCH_SIZE);
-        await this.sendBatch(batch);
+        this.flushing = true;
+        try {
+            const batch = this.buffer.splice(0, MAX_BATCH_SIZE);
+            await this.sendBatch(batch);
+        }
+        finally {
+            this.flushing = false;
+        }
     }
     destroy() {
         this.destroyed = true;
@@ -141,6 +166,11 @@ class EventTracker {
     startAutoFlush() {
         this.flushTimer = setInterval(() => this.flush(), this.config.flushIntervalMs);
     }
+    restartAutoFlush(intervalMs) {
+        if (this.flushTimer)
+            clearInterval(this.flushTimer);
+        this.flushTimer = setInterval(() => this.flush(), intervalMs);
+    }
     hookPageUnload() {
         if (typeof window === 'undefined')
             return;
@@ -186,8 +216,25 @@ class EventTracker {
                 body,
                 credentials: 'omit',
             });
-            if (!resp.ok && this.config.debug) {
-                console.warn('[GuardVideo EventTracker] Flush failed:', resp.status);
+            if (!resp.ok) {
+                if (resp.status === 429) {
+                    this.flushBackoff = Math.min((this.flushBackoff || this.config.flushIntervalMs) * 2, MAX_FLUSH_BACKOFF);
+                    if (this.config.debug) {
+                        console.warn('[GuardVideo EventTracker] 429 — backing off to', this.flushBackoff, 'ms');
+                    }
+                    this.buffer.unshift(...events);
+                    this.restartAutoFlush(this.flushBackoff);
+                    return;
+                }
+                if (this.config.debug) {
+                    console.warn('[GuardVideo EventTracker] Flush failed:', resp.status);
+                }
+            }
+            else {
+                if (this.flushBackoff > 0) {
+                    this.flushBackoff = 0;
+                    this.restartAutoFlush(this.config.flushIntervalMs);
+                }
             }
         }
         catch (err) {
@@ -403,6 +450,15 @@ class GuardVideoPlayer {
         this._onSecurityEvent = null;
         this.playlistNonce = null;
         this.nonceRefreshInProgress = false;
+        this.nonceRefreshTimer = null;
+        this.retryBackoff = 1000;
+        this.MAX_BACKOFF = 30000;
+        this.rateLimitCooldownUntil = 0;
+        this.nonceRefreshPromise = null;
+        this.destroyed = false;
+        this.networkRetryCount = 0;
+        this.MAX_NETWORK_RETRIES = 6;
+        this.pendingRetryTimer = null;
         this._onRateChange = this.enforceMaxRate.bind(this);
         this.videoElement = videoElement;
         this.config = {
@@ -613,9 +669,18 @@ class GuardVideoPlayer {
     async solveChallenge(tokenId) {
         if (!this.config.apiBaseUrl)
             return undefined;
+        if (Date.now() < this.rateLimitCooldownUntil) {
+            this.log('Challenge skipped — rate limit cooldown active');
+            return undefined;
+        }
         try {
             const url = this.config.apiBaseUrl + '/videos/challenge/' + encodeURIComponent(tokenId);
             const resp = await fetch(url, { credentials: 'omit' });
+            if (resp.status === 429) {
+                this.enterRateLimitCooldown();
+                this.log('Challenge hit 429 — entering cooldown');
+                return undefined;
+            }
             if (!resp.ok) {
                 this.log('Challenge fetch failed (challenge may be disabled)', resp.status);
                 return undefined;
@@ -641,6 +706,10 @@ class GuardVideoPlayer {
     async acquireNonce(tokenId) {
         if (!this.config.apiBaseUrl)
             return null;
+        if (Date.now() < this.rateLimitCooldownUntil) {
+            this.log('Nonce acquisition skipped — rate limit cooldown active');
+            return this.playlistNonce;
+        }
         try {
             const challengeResult = await this.solveChallenge(tokenId);
             const url = this.config.apiBaseUrl + '/videos/playlist-session';
@@ -654,12 +723,20 @@ class GuardVideoPlayer {
                 body: JSON.stringify(body),
                 credentials: 'omit',
             });
+            if (resp.status === 429) {
+                this.enterRateLimitCooldown();
+                this.log('Nonce acquisition hit 429 — entering cooldown');
+                return this.playlistNonce;
+            }
             if (!resp.ok) {
                 this.log('Playlist session nonce acquisition failed', resp.status);
                 return null;
             }
             const data = await resp.json();
             this.log('Playlist nonce acquired, expires in ' + data.expiresIn + 's');
+            this.retryBackoff = 1000;
+            this.networkRetryCount = 0;
+            this.scheduleNonceRefresh(data.expiresIn);
             return data.nonce;
         }
         catch (err) {
@@ -667,19 +744,58 @@ class GuardVideoPlayer {
             return null;
         }
     }
+    scheduleNonceRefresh(expiresInSeconds) {
+        if (this.nonceRefreshTimer)
+            clearTimeout(this.nonceRefreshTimer);
+        const refreshMs = Math.max(5000, expiresInSeconds * 750);
+        this.nonceRefreshTimer = setTimeout(() => {
+            if (this.destroyed)
+                return;
+            this.refreshNonce().catch(() => {
+                this.log('Proactive nonce refresh failed');
+            });
+        }, refreshMs);
+    }
     async refreshNonce() {
-        if (this.nonceRefreshInProgress)
-            return;
+        if (this.nonceRefreshInProgress && this.nonceRefreshPromise) {
+            return this.nonceRefreshPromise;
+        }
         if (!this.embedToken)
             return;
         this.nonceRefreshInProgress = true;
-        try {
-            const nonce = await this.acquireNonce(this.embedToken.tokenId);
-            this.playlistNonce = nonce;
-        }
-        finally {
-            this.nonceRefreshInProgress = false;
+        this.nonceRefreshPromise = (async () => {
+            try {
+                const nonce = await this.acquireNonce(this.embedToken.tokenId);
+                this.playlistNonce = nonce;
+            }
+            finally {
+                this.nonceRefreshInProgress = false;
+                this.nonceRefreshPromise = null;
+            }
+        })();
+        return this.nonceRefreshPromise;
+    }
+    enterRateLimitCooldown() {
+        this.rateLimitCooldownUntil = Date.now() + this.retryBackoff;
+        this.retryBackoff = Math.min(this.retryBackoff * 2, this.MAX_BACKOFF);
+    }
+    scheduleRetry(fn, delayMs) {
+        if (this.pendingRetryTimer)
+            clearTimeout(this.pendingRetryTimer);
+        this.pendingRetryTimer = setTimeout(() => {
+            this.pendingRetryTimer = null;
+            if (!this.destroyed && this.hls)
+                fn();
+        }, delayMs);
+    }
+    stopLoading() {
+        if (this.pendingRetryTimer) {
+            clearTimeout(this.pendingRetryTimer);
+            this.pendingRetryTimer = null;
         }
+        this.hls?.stopLoad();
+        this.networkRetryCount = 0;
+        this.retryBackoff = 1000;
     }
     async initializePlayer() {
         if (!this.embedToken) {
@@ -719,8 +835,12 @@ class GuardVideoPlayer {
             enableWorker: true,
             lowLatencyMode: false,
             liveSyncDurationCount: 3,
-            manifestLoadingMaxRetry: 6,
-            levelLoadingMaxRetry: 6,
+            manifestLoadingMaxRetry: 3,
+            manifestLoadingRetryDelay: 2000,
+            levelLoadingMaxRetry: 3,
+            levelLoadingRetryDelay: 2000,
+            fragLoadingMaxRetry: 4,
+            fragLoadingRetryDelay: 1000,
             xhrSetup(xhr, url) {
                 if (url.includes('/watermark-stream/') && url.includes('.m3u8')) {
                     if (self.playlistNonce) {
@@ -728,10 +848,6 @@ class GuardVideoPlayer {
                         const nonceUrl = url + separator + 'nonce=' + encodeURIComponent(self.playlistNonce);
                         xhr.open('GET', nonceUrl, true);
                         self.log('Injected nonce into playlist request');
-                        self.playlistNonce = null;
-                        self.refreshNonce().catch(() => {
-                            self.log('Background nonce refresh failed');
-                        });
                     }
                 }
             },
@@ -743,6 +859,8 @@ class GuardVideoPlayer {
             this.log('HLS manifest parsed', { levels: data.levels.map((l) => l.height + 'p') });
             this.setState(exports.PlayerState.READY);
             this.config.onReady();
+            this.retryBackoff = 1000;
+            this.networkRetryCount = 0;
             if (this.config.autoplay)
                 this.play();
         });
@@ -758,28 +876,77 @@ class GuardVideoPlayer {
             this.currentQuality = quality;
             this.log('Quality switched to ' + quality.name);
             this.config.onQualityChange(quality.name);
+            this.eventTracker?.track('quality_change', this.videoElement.currentTime, {
+                level: data.level,
+                height: level.height,
+                bitrate: level.bitrate,
+            });
         });
         this.hls.on(Hls.Events.ERROR, (_event, data) => {
             this.error('HLS Error', data);
+            this.eventTracker?.track('error', this.videoElement.currentTime, {
+                type: data.type,
+                details: data.details,
+                fatal: data.fatal,
+            });
+            if (this.destroyed)
+                return;
+            if (Date.now() < this.rateLimitCooldownUntil) {
+                this.log('Suppressing retry — rate limit cooldown active (' +
+                    Math.ceil((this.rateLimitCooldownUntil - Date.now()) / 1000) + 's remaining)');
+                if (data.fatal) {
+                    const delay = this.rateLimitCooldownUntil - Date.now() + 500;
+                    this.scheduleRetry(() => this.hls?.startLoad(), delay);
+                }
+                return;
+            }
+            const httpStatus = data.response?.code;
+            if (httpStatus === 429) {
+                this.enterRateLimitCooldown();
+                this.log('429 detected — entering cooldown for ' + this.retryBackoff + 'ms');
+                this.scheduleRetry(() => {
+                    if (this.embedToken?.forensicWatermark) {
+                        this.refreshNonce().then(() => this.hls?.startLoad()).catch(() => this.hls?.startLoad());
+                    }
+                    else {
+                        this.hls?.startLoad();
+                    }
+                }, this.retryBackoff);
+                return;
+            }
             if (data.type === Hls.ErrorTypes.NETWORK_ERROR &&
                 data.details === Hls.ErrorDetails.LEVEL_LOAD_ERROR &&
                 this.embedToken?.forensicWatermark) {
-                this.log('Playlist load failed — refreshing nonce before retry');
+                this.networkRetryCount++;
+                if (this.networkRetryCount > this.MAX_NETWORK_RETRIES) {
+                    this.error('Max network retries exceeded for playlist load');
+                    this.handleError({ code: 'NETWORK_ERROR', message: 'Playlist load failed after multiple retries', fatal: true, details: data });
+                    return;
+                }
+                this.log('Playlist load failed — refreshing nonce before retry (' + this.networkRetryCount + '/' + this.MAX_NETWORK_RETRIES + ')');
                 this.refreshNonce().then(() => {
-                    setTimeout(() => this.hls?.startLoad(), 500);
+                    this.scheduleRetry(() => this.hls?.startLoad(), this.retryBackoff);
                 }).catch(() => {
-                    setTimeout(() => this.hls?.startLoad(), 1000);
+                    this.scheduleRetry(() => this.hls?.startLoad(), this.retryBackoff);
                 });
+                this.retryBackoff = Math.min(this.retryBackoff * 1.5, this.MAX_BACKOFF);
                 return;
             }
             if (data.fatal) {
                 switch (data.type) {
                     case Hls.ErrorTypes.NETWORK_ERROR:
-                        this.error('Network error, attempting recovery...');
+                        this.networkRetryCount++;
+                        if (this.networkRetryCount > this.MAX_NETWORK_RETRIES) {
+                            this.error('Max network retries exceeded — giving up');
+                            this.handleError({ code: 'NETWORK_ERROR', message: 'Network error after multiple retries. Please check your connection.', fatal: true, details: data });
+                            return;
+                        }
+                        this.error('Network error, attempting recovery (' + this.networkRetryCount + '/' + this.MAX_NETWORK_RETRIES + ')...');
                         if (this.embedToken?.forensicWatermark) {
                             this.refreshNonce().catch(() => { });
                         }
-                        setTimeout(() => this.hls?.startLoad(), 1000);
+                        this.scheduleRetry(() => this.hls?.startLoad(), this.retryBackoff);
+                        this.retryBackoff = Math.min(this.retryBackoff * 1.5, this.MAX_BACKOFF);
                         break;
                     case Hls.ErrorTypes.MEDIA_ERROR:
                         this.error('Media error, attempting recovery...');
@@ -793,8 +960,21 @@ class GuardVideoPlayer {
         this.setupVideoEventListeners();
     }
     setupVideoEventListeners() {
-        this.videoElement.addEventListener('playing', () => this.setState(exports.PlayerState.PLAYING));
-        this.videoElement.addEventListener('pause', () => this.setState(exports.PlayerState.PAUSED));
+        this.videoElement.addEventListener('playing', () => {
+            this.setState(exports.PlayerState.PLAYING);
+            if (this.hls)
+                this.hls.startLoad(-1);
+        });
+        this.videoElement.addEventListener('pause', () => {
+            this.setState(exports.PlayerState.PAUSED);
+            if (this.hls && !this.videoElement.seeking) {
+                this.hls.stopLoad();
+                if (this.pendingRetryTimer) {
+                    clearTimeout(this.pendingRetryTimer);
+                    this.pendingRetryTimer = null;
+                }
+            }
+        });
         this.videoElement.addEventListener('waiting', () => this.setState(exports.PlayerState.BUFFERING));
         this.videoElement.addEventListener('error', () => {
             const error = this.videoElement.error;
@@ -821,6 +1001,8 @@ class GuardVideoPlayer {
     }
     async play() {
         try {
+            this.networkRetryCount = 0;
+            this.retryBackoff = 1000;
             await this.videoElement.play();
         }
         catch (err) {
@@ -857,6 +1039,15 @@ class GuardVideoPlayer {
     getState() { return this.state; }
     destroy() {
         this.log('Destroying player');
+        this.destroyed = true;
+        if (this.pendingRetryTimer) {
+            clearTimeout(this.pendingRetryTimer);
+            this.pendingRetryTimer = null;
+        }
+        if (this.nonceRefreshTimer) {
+            clearTimeout(this.nonceRefreshTimer);
+            this.nonceRefreshTimer = null;
+        }
         if (this.eventTracker) {
             this.eventTracker.destroy();
             this.eventTracker = null;
@@ -2567,6 +2758,7 @@ class PlayerUI {
     }
     play() { return this.corePlayer.play(); }
     pause() { return this.corePlayer.pause(); }
+    stopLoading() { return this.corePlayer.stopLoading(); }
     seek(t) { return this.corePlayer.seek(t); }
     getCurrentTime() { return this.corePlayer.getCurrentTime(); }
     getDuration() { return this.corePlayer.getDuration(); }
@@ -2626,6 +2818,7 @@ const GuardVideoPlayerComponent = React.forwardRef((props, ref) => {
     React.useImperativeHandle(ref, () => ({
         play: () => uiRef.current?.play() ?? Promise.resolve(),
         pause: () => uiRef.current?.pause(),
+        stopLoading: () => uiRef.current?.stopLoading(),
         seek: (t) => uiRef.current?.seek(t),
         getCurrentTime: () => uiRef.current?.getCurrentTime() ?? 0,
         getDuration: () => uiRef.current?.getDuration() ?? 0,