@gcorevideo/player 2.28.25 → 2.28.27

package/src/plugins/vast-ads/sctemanager.ts

@@ -1,16 +1,16 @@
-import { Events, Playback } from '@clappr/core';
-import { Events as HlsEvents, FragChangedData } from 'hls.js';
+import { Events, Playback } from '@clappr/core'
+import { Events as HlsEvents, FragChangedData } from 'hls.js'
 
 const OUT = 'out',
   IN = 'in',
-  OUT_CONT = 'out_cont';
+  OUT_CONT = 'out_cont'
 
-type CueResult = { kind?: "in" | "out" | "out_cont"; duration?: number };
+type CueResult = { kind?: 'in' | 'out' | 'out_cont'; duration?: number }
 
 export default class SCTEManager extends Events {
-  private _playback: Playback | null = null;
-  
-  private _scteIsStarted = false;
+  private _playback: Playback | null = null
+
+  private _scteIsStarted = false
 
   set playback(value: Playback) {
     if (this._playback) {
@@ -18,65 +18,82 @@ export default class SCTEManager extends Events {
       // @ts-ignore
       if (this._playback._hls) {
         // @ts-ignore
-        this._playback._hls.off(HlsEvents.FRAG_CHANGED, this._onHlsFragChanged.bind(this));
+        this._playback._hls.off(
+          HlsEvents.FRAG_CHANGED,
+          this._onHlsFragChanged.bind(this),
+        )
       }
-      
-      this._playback.off(Events.PLAYBACK_PLAY_INTENT, this._subscribedHlsEvents, this);
+
+      this._playback.off(
+        Events.PLAYBACK_PLAY_INTENT,
+        this._subscribedHlsEvents,
+        this,
+      )
     }
-    this._playback = value;
+    this._playback = value
     // @ts-ignore
     if (!this._playback._hls) {
-      this._playback.once(Events.PLAYBACK_PLAY_INTENT, this._subscribedHlsEvents, this);
+      this._playback.once(
+        Events.PLAYBACK_PLAY_INTENT,
+        this._subscribedHlsEvents,
+        this,
+      )
     } else {
-      this._subscribedHlsEvents();
+      this._subscribedHlsEvents()
     }
   }
 
   get playback(): Playback | null {
-    return this._playback;
+    return this._playback
   }
 
   _subscribedHlsEvents() {
     // @ts-ignore
     if (this._playback._hls) {
       // @ts-ignore
-      this._playback._hls.off(HlsEvents.FRAG_CHANGED, this._onHlsFragChanged.bind(this));
+      this._playback._hls.off(
+        HlsEvents.FRAG_CHANGED,
+        this._onHlsFragChanged.bind(this),
+      )
       // @ts-ignore
-      this._playback._hls.on(HlsEvents.FRAG_CHANGED, this._onHlsFragChanged.bind(this));
+      this._playback._hls.on(
+        HlsEvents.FRAG_CHANGED,
+        this._onHlsFragChanged.bind(this),
+      )
     }
   }
 
   _onHlsFragChanged(_: HlsEvents.FRAG_CHANGED, data: FragChangedData) {
-    const { tagList } = data.frag;
+    const { tagList } = data.frag
 
     if (tagList) {
-      const cue = this._getCue(tagList);
+      const cue = this._getCue(tagList)
 
       if (Object.keys(cue).length > 0) {
         if (!this._scteIsStarted) {
           if (cue.kind === OUT || cue.kind === OUT_CONT) {
-            this._scteIsStarted = true;
-            console.warn('scteroll will be started');
+            this._scteIsStarted = true
+            console.warn('scteroll will be started')
             this.trigger('startSCTERoll', {
-              duration: cue.duration
-            });
+              duration: cue.duration,
+            })
           }
         } else {
           if (cue.kind === IN) {
-            console.warn('scteroll will be stopped');
-            this._stopScte();
+            console.warn('scteroll will be stopped')
+            this._stopScte()
           }
         }
       } else {
-        this._stopScte();
+        this._stopScte()
       }
     }
   }
 
   _stopScte() {
     if (this._scteIsStarted) {
-      this.trigger('stopSCTERoll');
-      this._scteIsStarted = false;
+      this.trigger('stopSCTERoll')
+      this._scteIsStarted = false
     }
   }
 
@@ -84,51 +101,52 @@ export default class SCTEManager extends Events {
     let cueResult: CueResult = {
       kind: undefined,
       duration: undefined,
-    };
+    }
 
     for (let i = 0; i < tagList.length; i++) {
-      const infoSegment = tagList[i];
-      let kind: "in" | "out" | "out_cont" | undefined;
-      let duration: number | undefined;
+      const infoSegment = tagList[i]
+      let kind: 'in' | 'out' | 'out_cont' | undefined
+      let duration: number | undefined
 
       infoSegment.forEach((info) => {
         if (kind) {
           if (kind === OUT) {
-            const dur = parseInt(info);
+            const dur = parseInt(info)
 
-            !isNaN(dur) && (duration = dur);
+            !isNaN(dur) && (duration = dur)
           }
           if (kind === OUT_CONT) {
-            const durString = info.match(/Duration=\d+/g);
+            const durString = info.match(/Duration=\d+/g)
 
             if (durString) {
-              const durNumb = durString[0].match(/\d+/g);
+              const durNumb = durString[0].match(/\d+/g)
 
               if (durNumb) {
-                duration = parseInt(durNumb[0]);
+                duration = parseInt(durNumb[0])
               }
             }
           }
         } else {
           switch (info) {
             case 'EXT-X-CUE-OUT':
-              kind = OUT;
-              break;
+              kind = OUT
+              break
             case 'EXT-X-CUE-OUT-CONT':
-              kind = OUT_CONT;
-              break;
+              kind = OUT_CONT
+              break
             case 'EXT-X-CUE-IN':
-              kind = IN;
-              break;
+              kind = IN
+              break
           }
         }
-      });
-      kind && (cueResult = {
-        kind,
-        duration
-      });
+      })
+      kind &&
+        (cueResult = {
+          kind,
+          duration,
+        })
     }
 
-    return cueResult;
+    return cueResult
   }
 }

package/src/plugins/vast-ads/types.ts

@@ -1,14 +1,20 @@
-export type AdRollType = 'preroll' | 'middleroll' | 'repeatableroll' | 'pauseroll' | 'postroll' | 'scteroll';
+export type AdRollType =
+  | 'preroll'
+  | 'middleroll'
+  | 'repeatableroll'
+  | 'pauseroll'
+  | 'postroll'
+  | 'scteroll'
 
 export type AdRollItem = {
-  startTime: number;
-  startTimePercent: number;
-  tag: string;
-};
+  startTime: number
+  startTimePercent: number
+  tag: string
+}
 
 export type AdRollDesc = {
-  data: AdRollItem[];
-  oneByOne?: boolean;
-};
+  data: AdRollItem[]
+  oneByOne?: boolean
+}
 
-export type VastAdsOptions = Partial<Record<AdRollType, AdRollDesc>>;
+export type VastAdsOptions = Partial<Record<AdRollType, AdRollDesc>>

package/src/plugins/vast-ads/urlhandler.ts

@@ -1,37 +1,42 @@
-import assert from 'assert';
-import XHRURLHandler from './xmlhttprequest.js';
+import assert from 'assert'
+import XHRURLHandler from './xmlhttprequest.js'
 
 // eslint-disable-next-line max-len
-const ERROR_MESSAGE = 'Current context is not supported by any of the default URLHandlers. Please provide a custom URLHandler';
+const ERROR_MESSAGE =
+  'Current context is not supported by any of the default URLHandlers. Please provide a custom URLHandler'
 
 export default class URLHandler {
-  static get(url: string, options: any, cb?: (err: any | null, response?: any) => void) {
+  static get(
+    url: string,
+    options: any,
+    cb?: (err: any | null, response?: any) => void,
+  ) {
     // Allow skip of the options param
     if (!cb) {
       if (typeof options === 'function') {
-        cb = options;
+        cb = options
       }
-      options = {};
+      options = {}
     }
 
-    assert(cb, 'URLHandler.get: callback is required');
+    assert(cb, 'URLHandler.get: callback is required')
     if (options.response) {
       // Trick: the VAST response XML document is passed as an option
-      const { response } = options;
+      const { response } = options
 
-      delete options.response;
+      delete options.response
 
-      return cb(null, response);
+      return cb(null, response)
     }
 
     if (options.urlhandler?.supported()) {
       // explicitly supply your own URLHandler object
-      return options.urlhandler.get(url, options, cb);
+      return options.urlhandler.get(url, options, cb)
     }
     if (XHRURLHandler.supported()) {
-      return XHRURLHandler.get(url, options, cb);
+      return XHRURLHandler.get(url, options, cb)
     }
 
-    return cb(new Error(ERROR_MESSAGE));
+    return cb(new Error(ERROR_MESSAGE))
   }
 }

package/src/plugins/vast-ads/xmlhttprequest.ts

@@ -1,44 +1,49 @@
-import { reportError } from '@gcorevideo/utils';
-import assert from "assert";
+import { reportError } from '@gcorevideo/utils'
+import assert from 'assert'
 
 export default class XHRURLHandler {
   static xhrCreate(): XMLHttpRequest | false {
-    const xhr = new window.XMLHttpRequest();
+    const xhr = new window.XMLHttpRequest()
 
-    if ('withCredentials' in xhr) { // check CORS support
-      return xhr;
+    if ('withCredentials' in xhr) {
+      // check CORS support
+      return xhr
     }
 
-    return false;
+    return false
   }
 
   static supported() {
-    return !!this.xhrCreate();
+    return !!this.xhrCreate()
   }
 
-  static get(url: string, options: any, cb: (err: Error | null, response?: any) => void) {
+  static get(
+    url: string,
+    options: any,
+    cb: (err: Error | null, response?: any) => void,
+  ) {
     try {
-      const xhr = this.xhrCreate();
-      assert(xhr, 'XHRURLHandler: XMLHttpRequest is not supported');
+      const xhr = this.xhrCreate()
+      assert(xhr, 'XHRURLHandler: XMLHttpRequest is not supported')
 
-      xhr.open('GET', url);
-      xhr.timeout = options.timeout || 0;
-      xhr.withCredentials = options.withCredentials || false;
-      xhr.onreadystatechange = function() {
+      xhr.open('GET', url)
+      xhr.timeout = options.timeout || 0
+      xhr.withCredentials = options.withCredentials || false
+      xhr.onreadystatechange = function () {
         if (xhr.readyState === 4) {
           if (xhr.status === 200) {
-            return cb(null, xhr.response);
+            return cb(null, xhr.response)
           } else {
-            return cb(new Error(`XHRURLHandler: ${xhr.statusText}`));
+            return cb(new Error(`XHRURLHandler: ${xhr.statusText}`))
           }
         }
-      };
+      }
 
-      return xhr.send();
+      return xhr.send()
     } catch (error) {
       // LogManager.exception(error);
-      reportError(error);
-      return cb(new Error('XHRURLHandler: Unexpected error'));
+      reportError(error)
+      return cb(new Error('XHRURLHandler: Unexpected error'))
     }
   }
 }

package/src/plugins/vast-ads/xmlmerge.ts

@@ -1,41 +1,45 @@
-import { reportError } from '@gcorevideo/utils';
-import assert from "assert";
+import { reportError } from '@gcorevideo/utils'
+import assert from 'assert'
 
 export default class MergeVast {
-  private firstXML: Document;
-  private secondXML: Document;
+  private firstXML: Document
+  private secondXML: Document
 
-  private firstVAST: HTMLCollectionOf<Element>;
-  private secondVAST: HTMLCollectionOf<Element>;
+  private firstVAST: HTMLCollectionOf<Element>
+  private secondVAST: HTMLCollectionOf<Element>
 
   constructor(xml1: string, xml2: string) {
-    this.firstXML = this._stringToXML(xml1);
-    this.secondXML = this._stringToXML(xml2);
-    this.firstVAST = this.firstXML.getElementsByTagName('VAST');
-    this.secondVAST = this.secondXML.getElementsByTagName('VAST');
+    this.firstXML = this._stringToXML(xml1)
+    this.secondXML = this._stringToXML(xml2)
+    this.firstVAST = this.firstXML.getElementsByTagName('VAST')
+    this.secondVAST = this.secondXML.getElementsByTagName('VAST')
   }
 
   merge() {
-    const res = this._mergeXML(this.firstVAST, this.secondVAST);
+    const res = this._mergeXML(this.firstVAST, this.secondVAST)
 
     try {
-      return res[0].outerHTML;
+      return res[0].outerHTML
     } catch (error) {
       // LogManager.exception(error);
-      reportError(error);
+      reportError(error)
     }
 
-    return '';
+    return ''
   }
 
-  _mergeXML(first: HTMLCollectionOf<Element>, second: HTMLCollectionOf<Element>, parent?: Element): HTMLCollectionOf<Element> {
+  _mergeXML(
+    first: HTMLCollectionOf<Element>,
+    second: HTMLCollectionOf<Element>,
+    parent?: Element,
+  ): HTMLCollectionOf<Element> {
     // const sources = [].slice.call( arguments, 0 );
     // const first = sources[0];
     // const second = sources[1];
     // const parent = sources[2];
 
     for (let i = 0; i < first.length; i++) {
-      let secondItems = this._getPieceTree(first[i].nodeName,second);
+      let secondItems = this._getPieceTree(first[i].nodeName, second)
 
       if (
         first[i].nodeName === 'Tracking' ||
@@ -45,52 +49,58 @@ export default class MergeVast {
         first[i].nodeName === 'ClickTracking' ||
         first[i].nodeName === 'ClickThrough'
       ) {
-        secondItems = null;
+        secondItems = null
       }
 
       if (!secondItems) {
         try {
-          assert(parent, 'parent is null');
-          parent.appendChild(first[i].cloneNode(true));
+          assert(parent, 'parent is null')
+          parent.appendChild(first[i].cloneNode(true))
         } catch (error) {
           // LogManager.exception(error);
-          reportError(error);
+          reportError(error)
         }
       } else {
         if (first[i].children.length > 0 && secondItems) {
-          this._mergeXML(first[i].children, secondItems.children, secondItems );
+          this._mergeXML(first[i].children, secondItems.children, secondItems)
         }
       }
     }
 
-    return second;
+    return second
   }
 
-  _getPieceTree(nodeName: string, xml: HTMLCollectionOf<Element>): Element | null {
+  _getPieceTree(
+    nodeName: string,
+    xml: HTMLCollectionOf<Element>,
+  ): Element | null {
     if (xml) {
       if (xml instanceof HTMLCollection) {
         for (const item of xml) {
           if (item.nodeName === nodeName) {
-            return item;
+            return item
           }
         }
       }
     }
 
-    return null;
+    return null
   }
 
   _stringToXML(val: string): Document {
-    let xmlDoc = null;
+    let xmlDoc = null
 
-    if (document.implementation && (document.implementation as any).createDocument) {
-      return (new DOMParser()).parseFromString(val, 'application/xml');
+    if (
+      document.implementation &&
+      (document.implementation as any).createDocument
+    ) {
+      return new DOMParser().parseFromString(val, 'application/xml')
     } else if ('ActiveXObject' in window) {
-      xmlDoc = new (window.ActiveXObject as any)('Microsoft.XMLDOM');
-      xmlDoc.loadXML(val);
-      return xmlDoc;
+      xmlDoc = new (window.ActiveXObject as any)('Microsoft.XMLDOM')
+      xmlDoc.loadXML(val)
+      return xmlDoc
     }
 
-    throw new Error('XML Parser not found');
+    throw new Error('XML Parser not found')
   }
 }

package/src/plugins/video360/VRControls.js

@@ -1,104 +1,112 @@
-import { Matrix4 } from 'three';
-import LogManager from '../../utils/LogManager';
-import { SentryLogLevel } from '../../constants';
+import { Matrix4 } from 'three'
+import LogManager from '../../utils/LogManager'
+import { SentryLogLevel } from '../../constants'
 
 export class VRControls {
   constructor(object, onError) {
-    const scope = this;
-    let vrDisplay, vrDisplays;
-    const standingMatrix = new Matrix4();
-    let frameData = null;
+    const scope = this
+    let vrDisplay, vrDisplays
+    const standingMatrix = new Matrix4()
+    let frameData = null
 
     if ('VRFrameData' in window) {
-      frameData = new VRFrameData();
+      frameData = new VRFrameData()
     }
 
     function gotVRDisplays(displays) {
-      vrDisplays = displays;
+      vrDisplays = displays
       if (displays.length > 0) {
-        vrDisplay = displays[0];
+        vrDisplay = displays[0]
       } else {
         if (onError) {
-          onError('VR input not available.');
+          onError('VR input not available.')
         }
       }
     }
 
     if (navigator.getVRDisplays) {
-      navigator.getVRDisplays().then(gotVRDisplays).catch(function () {
-        LogManager.message('THREE.VRControls: Unable to get VR Displays', SentryLogLevel.WARNING);
-        console.warn('THREE.VRControls: Unable to get VR Displays');
-      });
+      navigator
+        .getVRDisplays()
+        .then(gotVRDisplays)
+        .catch(function () {
+          LogManager.message(
+            'THREE.VRControls: Unable to get VR Displays',
+            SentryLogLevel.WARNING,
+          )
+          console.warn('THREE.VRControls: Unable to get VR Displays')
+        })
     }
 
     // the Rift SDK returns the position in meters
     // this scale factor allows the user to define how meters
     // are converted to scene units.
 
-    this.scale = 1;
+    this.scale = 1
 
     // If true will use "standing space" coordinate system where y=0 is the
     // floor and x=0, z=0 is the center of the room.
-    this.standing = false;
+    this.standing = false
 
     // Distance from the users eyes to the floor in meters. Used when
     // standing=true but the VRDisplay doesn't provide stageParameters.
-    this.userHeight = 1.6;
+    this.userHeight = 1.6
 
     this.getVRDisplay = function () {
-      return vrDisplay;
-    };
+      return vrDisplay
+    }
 
     this.setVRDisplay = function (value) {
-      vrDisplay = value;
-    };
+      vrDisplay = value
+    }
 
     this.getVRDisplays = function () {
-      console.warn('THREE.VRControls: getVRDisplays() is being deprecated.');
+      console.warn('THREE.VRControls: getVRDisplays() is being deprecated.')
 
-      return vrDisplays;
-    };
+      return vrDisplays
+    }
 
     this.getStandingMatrix = function () {
-      return standingMatrix;
-    };
+      return standingMatrix
+    }
 
     this.update = function () {
       if (vrDisplay) {
-        let pose;
+        let pose
 
         if (vrDisplay.getFrameData) {
-          vrDisplay.getFrameData(frameData);
-          pose = frameData.pose;
+          vrDisplay.getFrameData(frameData)
+          pose = frameData.pose
         } else if (vrDisplay.getPose) {
-          pose = vrDisplay.getPose();
+          pose = vrDisplay.getPose()
         }
 
         if (pose.orientation) {
-          object.quaternion.fromArray(pose.orientation);
+          object.quaternion.fromArray(pose.orientation)
         }
 
         if (pose.position) {
-          object.position.fromArray(pose.position);
+          object.position.fromArray(pose.position)
         } else {
-          object.position.set(0, 0, 0);
+          object.position.set(0, 0, 0)
         }
 
         if (this.standing) {
           if (vrDisplay.stageParameters) {
-            object.updateMatrix();
-            standingMatrix.fromArray(vrDisplay.stageParameters.sittingToStandingTransform);
-            object.applyMatrix(standingMatrix);
+            object.updateMatrix()
+            standingMatrix.fromArray(
+              vrDisplay.stageParameters.sittingToStandingTransform,
+            )
+            object.applyMatrix(standingMatrix)
           } else {
-            object.position.setY(object.position.y + this.userHeight);
+            object.position.setY(object.position.y + this.userHeight)
           }
         }
-        object.position.multiplyScalar(scope.scale);
+        object.position.multiplyScalar(scope.scale)
       }
-    };
+    }
 
     this.dispose = function () {
-      vrDisplay = null;
-    };
+      vrDisplay = null
+    }
   }
 }