rx-player 3.26.2 → 3.26.3-dev.2022021400

package/src/parsers/manifest/dash/node_parser_types.ts

@@ -131,7 +131,7 @@ export interface IPeriodChildren {
   /**
    * Provide a template with which we will be able to request segments.
    */
-  segmentTemplate? : ISegmentTemplateIntermediateRepresentation;
+  segmentTemplate? : ISegmentTemplateIntermediateRepresentation | undefined;
   /**
    * Allows to signal events linked to this Period.
    *
@@ -189,17 +189,17 @@ export interface IAdaptationSetChildren {
   representations : IRepresentationIntermediateRepresentation[];
 
   // optional
-  accessibilities? : IScheme[];
-  contentComponent? : IContentComponentAttributes;
-  contentProtections? : IContentProtectionIntermediateRepresentation[];
-  essentialProperties? : IScheme[];
-  inbandEventStreams? : IScheme[];
+  accessibilities? : IScheme[] | undefined;
+  contentComponent? : IContentComponentAttributes | undefined;
+  contentProtections? : IContentProtectionIntermediateRepresentation[] | undefined;
+  essentialProperties? : IScheme[] | undefined;
+  inbandEventStreams? : IScheme[] | undefined;
   roles? : IScheme[];
-  supplementalProperties? : IScheme[];
+  supplementalProperties? : IScheme[] | undefined;
 
-  segmentBase? : ISegmentBaseIntermediateRepresentation;
-  segmentList? : ISegmentListIntermediateRepresentation;
-  segmentTemplate? : ISegmentTemplateIntermediateRepresentation;
+  segmentBase? : ISegmentBaseIntermediateRepresentation | undefined;
+  segmentList? : ISegmentListIntermediateRepresentation | undefined;
+  segmentTemplate? : ISegmentTemplateIntermediateRepresentation | undefined;
 }
 
 /* Intermediate representation for An AdaptationSet node's attributes. */
@@ -336,20 +336,20 @@ export interface IContentProtectionAttributes {
 }
 
 export interface ISegmentTemplateIntermediateRepresentation {
-  availabilityTimeComplete? : boolean;
-  availabilityTimeOffset?: number;
-  bitstreamSwitching? : boolean;
-  duration? : number;
-  index? : string;
-  indexRange?: [number, number];
-  indexRangeExact? : boolean;
-  media? : string;
-  presentationTimeOffset? : number;
-  startNumber? : number;
-  timescale? : number;
-  initialization? : { media?: string };
-  timeline? : ISegmentTimelineElement[];
-  timelineParser? : ITimelineParser;
+  availabilityTimeComplete? : boolean | undefined;
+  availabilityTimeOffset? : number | undefined;
+  bitstreamSwitching? : boolean | undefined;
+  duration? : number | undefined;
+  index? : string | undefined;
+  indexRange?: [number, number] | undefined;
+  indexRangeExact? : boolean | undefined;
+  media? : string | undefined;
+  presentationTimeOffset? : number | undefined;
+  startNumber? : number | undefined;
+  timescale? : number | undefined;
+  initialization? : { media?: string } | undefined;
+  timeline? : ISegmentTimelineElement[] | undefined;
+  timelineParser? : ITimelineParser | undefined;
 }
 
 export interface ISegmentTimelineElement {
@@ -382,9 +382,9 @@ export interface IScheme {
    *
    * `undefined` if no `schemeIdUri` attribute has been found.
    */
-  schemeIdUri? : string;
+  schemeIdUri? : string | undefined;
   /** Inner content of that scheme. */
-  value? : string;
+  value? : string | undefined;
 }
 
 export interface IEventStreamIntermediateRepresentation {
@@ -395,9 +395,9 @@ export interface IEventStreamIntermediateRepresentation {
 }
 
 export interface IEventStreamAttributes {
-  schemeIdUri? : string;
-  timescale? : number;
-  value? : string;
+  schemeIdUri? : string | undefined;
+  timescale? : number | undefined;
+  value? : string | undefined;
 
   /**
    * XML namespaces linked to the `<EventStream>` element.
@@ -406,7 +406,7 @@ export interface IEventStreamAttributes {
    * not parsed through the browser's DOMParser API, and thus might depend on
    * parent namespaces to be parsed correctly.
    */
-  namespaces? : Array<{ key: string; value: string }>;
+  namespaces? : Array<{ key: string; value: string }> | undefined;
 }
 
 export interface IEventStreamChildren {

package/src/parsers/manifest/dash/parsers_types.ts

@@ -71,19 +71,19 @@ export interface ILoadedResource<T extends string | ArrayBuffer> {
    * The URL of the loaded resource (post-redirection if one).
    * `undefined` if unknown or inexistant.
    */
-  url? : string;
+  url? : string | undefined;
   /**
    * The time, in terms of `performance.now()`, at which the resource was
    * starting to be fetched.
    * `undefined` if unknown or not applicable.
    */
-  sendingTime? : number;
+  sendingTime? : number | undefined;
   /**
    * The time, in terms of `performance.now()`, at which the resource was
    * fully-fetched.
    * `undefined` if unknown or not applicable.
    */
-  receivedTime? : number;
+  receivedTime? : number | undefined;
   /** The loaded resource itself, under the right format.
    * Or an error, when fetching ressources.
    */

package/src/parsers/manifest/dash/wasm-parser/ts/dash-wasm-parser.ts

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-import PPromise from "pinkie";
 import log from "../../../../../log";
 import assertUnreachable from "../../../../../utils/assert_unreachable";
 import noop from "../../../../../utils/noop";
+import PPromise from "../../../../../utils/promise";
 import parseMpdIr, {
   IIrParserResponse,
   ILoadedXlinkData,

package/src/parsers/manifest/metaplaylist/metaplaylist_parser.ts

@@ -69,11 +69,11 @@ export interface IMetaPlaylist {
 export default function parseMetaPlaylist(
   data : unknown,
   parserOptions : {
-    url?: string;
+    url?: string | undefined;
     serverSyncInfos?: {
       serverTimestamp: number;
       clientTime: number;
-    };
+    } | undefined;
   }
 ): IParserResponse<IParsedManifest> {
   let parsedData;
@@ -147,9 +147,9 @@ export default function parseMetaPlaylist(
 function createManifest(
   mplData : IMetaPlaylist,
   manifests : Manifest[],
-  parserOptions:  { url?: string;
+  parserOptions:  { url?: string | undefined;
                     serverSyncInfos?: { serverTimestamp: number;
-                                        clientTime: number; }; }
+                                        clientTime: number; } | undefined; }
 ): IParsedManifest {
   const { url, serverSyncInfos } = parserOptions;
   const clockOffset = serverSyncInfos !== undefined ?

package/src/parsers/manifest/smooth/create_parser.ts

@@ -64,8 +64,8 @@ interface IAdaptationParserArguments { root : Element;
                                        timescale : number;
                                        protections : IContentProtectionSmooth[];
                                        isLive : boolean;
-                                       timeShiftBufferDepth? : number;
-                                       manifestReceivedTime? : number; }
+                                       timeShiftBufferDepth? : number | undefined;
+                                       manifestReceivedTime? : number | undefined; }
 
 type IAdaptationType = "audio" |
                        "video" |
@@ -86,15 +86,15 @@ const MIME_TYPES : Partial<Record<string, string>> = {
 };
 
 export interface IHSSParserConfiguration {
-  aggressiveMode? : boolean;
-  suggestedPresentationDelay? : number;
-  referenceDateTime? : number;
-  minRepresentationBitrate? : number;
-  keySystems? : (hex? : Uint8Array) => IKeySystem[];
+  aggressiveMode? : boolean | undefined;
+  suggestedPresentationDelay? : number | undefined;
+  referenceDateTime? : number | undefined;
+  minRepresentationBitrate? : number | undefined;
+  keySystems? : ((hex : Uint8Array | undefined) => IKeySystem[]) | undefined;
   serverSyncInfos? : {
     serverTimestamp: number;
     clientTime: number;
-  };
+  } | undefined;
 }
 
 interface ISmoothParsedQualityLevel {
@@ -104,16 +104,16 @@ interface ISmoothParsedQualityLevel {
   customAttributes : string[];
 
   // optional
-  audiotag? : number;
-  bitsPerSample? : number;
-  channels? : number;
-  codecs? : string;
-  height? : number;
-  id? : string;
-  mimeType? : string;
-  packetSize? : number;
-  samplingRate? : number;
-  width? : number;
+  audiotag? : number | undefined;
+  bitsPerSample? : number | undefined;
+  channels? : number | undefined;
+  codecs? : string | undefined;
+  height? : number | undefined;
+  id? : string | undefined;
+  mimeType? : string | undefined;
+  packetSize? : number | undefined;
+  samplingRate? : number | undefined;
+  width? : number | undefined;
 }
 
 /**
@@ -122,9 +122,11 @@ interface ISmoothParsedQualityLevel {
  */
 function createSmoothStreamingParser(
   parserOptions : IHSSParserConfiguration = {}
-) : (manifest : Document, url? : string, manifestReceivedTime? : number)
-  => IParsedManifest
-{
+) : (
+    manifest : Document,
+    url? : string | undefined,
+    manifestReceivedTime? : number | undefined
+  ) => IParsedManifest {
   const referenceDateTime = parserOptions.referenceDateTime === undefined ?
     Date.UTC(1970, 0, 1, 0, 0, 0, 0) / 1000 :
     parserOptions.referenceDateTime;

package/src/parsers/manifest/smooth/representation_index.ts

@@ -178,12 +178,12 @@ export interface ISmoothRepresentationIndexContextInformation {
 
 /** Information allowing to generate a Smooth initialization segment. */
 interface ISmoothInitSegmentPrivateInfos {
-  bitsPerSample? : number;
-  channels? : number;
-  codecPrivateData? : string;
-  packetSize? : number;
-  samplingRate? : number;
-  protection? : { keyId : Uint8Array };
+  bitsPerSample? : number | undefined;
+  channels? : number | undefined;
+  codecPrivateData? : string | undefined;
+  packetSize? : number | undefined;
+  samplingRate? : number | undefined;
+  protection? : { keyId : Uint8Array } | undefined;
 }
 
 /**
@@ -198,13 +198,13 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
    * Information needed to generate an initialization segment.
    * Taken from the Manifest.
    */
-  private _initSegmentInfos : { codecPrivateData? : string;
-                                bitsPerSample? : number;
-                                channels? : number;
-                                packetSize? : number;
-                                samplingRate? : number;
+  private _initSegmentInfos : { codecPrivateData? : string | undefined;
+                                bitsPerSample? : number | undefined;
+                                channels? : number | undefined;
+                                packetSize? : number | undefined;
+                                samplingRate? : number | undefined;
                                 timescale : number;
-                                protection? : { keyId : Uint8Array }; };
+                                protection? : { keyId : Uint8Array } | undefined; };
 
   /**
    * if `true`, this class will return segments even if we're not sure they had
@@ -225,13 +225,13 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
    * Useful to know if a segment present in the timeline has actually been
    * generated on the server-side
    */
-  private _scaledLiveGap? : number;
+  private _scaledLiveGap : number | undefined;
 
   /**
    * Defines the end of the latest available segment when this index was known to
    * be valid, in the index's timescale.
    */
-  private _initialScaledLastPosition? : number;
+  private _initialScaledLastPosition : number | undefined;
 
   /**
    * Defines the earliest time when this index was known to be valid (that is, when

package/src/parsers/manifest/types.ts

@@ -18,8 +18,8 @@ import { IRepresentationIndex } from "../../manifest";
 import { IHDRInformation } from "../../manifest/types";
 
 export interface IManifestStreamEvent { start: number;
-                                        end?: number;
-                                        id?: string;
+                                        end?: number | undefined;
+                                        id?: string | undefined;
                                         data: IParsedStreamEventData; }
 
 export interface IParsedStreamEventData {
@@ -33,7 +33,7 @@ export interface IParsedStreamEventData {
 
 /** Describes information about an encryption Key ID of a given media. */
 export interface IContentProtectionKID { keyId : Uint8Array;
-                                         systemId?: string; }
+                                         systemId?: string | undefined; }
 
 /**
  * Encryption initialization data.
@@ -92,37 +92,37 @@ export interface IParsedRepresentation {
   id: string;
 
   /** Codec(s) associated with this Representation. */
-  codecs?: string;
+  codecs?: string | undefined;
   /**
    * Information about the encryption associated with this Representation.
    * Not set if unknown or if the content is not encrypted.
    */
-  contentProtections? : IContentProtections;
+  contentProtections? : IContentProtections | undefined;
   /**
    * Frame rate (images per seconds) associated with this Representation.
    * Not set if unknown or if it makes no sense (e.g. for subtitles).
    */
-  frameRate?: string;
+  frameRate?: string | undefined;
   /**
    * Height (top to bottom) in pixels this Representation has.
    * Not set if unknown or if it makes no sense (e.g. for audio).
    */
-  height?: number;
+  height?: number | undefined;
   /**
    * Defines the mime-type of the content.
    * This allows to deduce the media container but most of the time, the
    * `codecs` will also be needed to know how to decode that media.
    */
-  mimeType?: string;
+  mimeType?: string | undefined;
   /**
    * Width (left to right) in pixels this Representation has.
    * Not set if unknown or if it makes no sense (e.g. for audio).
    */
-  width?: number;
+  width?: number | undefined;
   /**
    * Information about the HDR characteristic of a content.
    */
-  hdrInfo?: IHDRInformation;
+  hdrInfo?: IHDRInformation | undefined;
 }
 
 /** Every possible types an Adaptation can have. */
@@ -155,34 +155,34 @@ export interface IParsedAdaptation {
    * Not set if unknown or if it makes no sense for the current track (e.g. for
    * a video track).
    */
-  audioDescription? : boolean;
+  audioDescription? : boolean | undefined;
   /**
    * Whether this Adaptation are closed captions for the hard of hearing.
    * Not set if unknown or if it makes no sense for the current track (e.g. for
    * a video track).
    */
-  closedCaption? : boolean;
+  closedCaption? : boolean | undefined;
   /**
    * If true this Adaptation is in a dub: it was recorded in another language
    * than the original(s) one(s).
    */
-  isDub? : boolean;
+  isDub? : boolean | undefined;
   /**
    * If true this Adaptation is in a sign interpreted: which is a variant of the
    * video with sign language.
    */
-  isSignInterpreted? : boolean;
+  isSignInterpreted? : boolean | undefined;
   /** Tells if the track is a trick mode track. */
-  isTrickModeTrack? : boolean;
+  isTrickModeTrack? : boolean | undefined;
   /**
    * Language the `Adaptation` is in.
    * Not set if unknown or if it makes no sense for the current track.
    */
-  language?: string;
+  language?: string | undefined;
   /**
    * TrickMode tracks attached to the adaptation.
    */
-  trickModeTracks?: IParsedAdaptation[];
+  trickModeTracks?: IParsedAdaptation[] | undefined;
 }
 
 /** Information on a given period of time in the Manifest */
@@ -205,18 +205,18 @@ export interface IParsedPeriod {
    * Duration of the Period (from the start to the end), in seconds.
    * `undefined` if the Period is the last one and is still being updated.
    */
-  duration? : number;
+  duration? : number | undefined;
   /**
    * Time at which the Period ends, in seconds.
    * `undefined` if the Period is the last one and is still
    * being updated.
    */
-  end? : number;
+  end? : number | undefined;
   /**
    * Array containing every stream event from period in manifest.
    * `undefined` if no parsed stream event in manifest.
    */
-  streamEvents?: IManifestStreamEvent[];
+  streamEvents?: IManifestStreamEvent[] | undefined;
 }
 
 /** Information on the whole content */
@@ -240,23 +240,23 @@ export interface IParsedManifest {
    * The wall-clock time when the manifest was generated and published at the
    * origin server
    */
-  publishTime?: number;
+  publishTime? : number | undefined;
   /** Underlying transport protocol: "smooth", "dash", "metaplaylist" etc. */
   transportType: string;
   /** Base time from which the segments are generated. */
-  availabilityStartTime? : number;
+  availabilityStartTime? : number | undefined;
   /**
    * Offset, in milliseconds, the client's clock (in terms of `performance.now`)
    * has relatively to the server's
    */
-  clockOffset?: number;
+  clockOffset? : number | undefined;
   /** If set, the Manifest needs to be updated when that Promise resolves. */
-  expired? : Promise<void>;
+  expired? : Promise<void> | undefined;
   /**
    * Duration of the validity of this Manifest from its download time.
    * After that time has elapsed, the Manifest should be refreshed.
    */
-  lifetime?: number;
+  lifetime? : number | undefined;
   /**
    * Data allowing to calculate the minimum and maximum seekable positions at
    * any given time.
@@ -266,7 +266,7 @@ export interface IParsedManifest {
      * The minimum time, in seconds, available in this Manifest.
      * `undefined` if that value is unknown.
      */
-    absoluteMinimumTime? : number;
+    absoluteMinimumTime? : number | undefined;
     /**
      * Some dynamic contents have the concept of a "window depth" (or "buffer
      * depth") which allows to set a minimum position for all reachable
@@ -311,8 +311,8 @@ export interface IParsedManifest {
    * Suggested delay from the last position the player should start from by
    * default.
    */
-  suggestedPresentationDelay? : number;
+  suggestedPresentationDelay? : number | undefined;
   /** URIs where the manifest can be refreshed by order of importance. */
-  uris?: string[];
+  uris? : string[] | undefined;
 }