rx-player 3.29.0-dev.2022091600 → 3.29.0-dev.2022103100

package/dist/_esm5.processed/transports/dash/construct_segment_url.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ISegment } from "../../manifest";
+import { ICdnMetadata } from "../../parsers/manifest";
+export default function constructSegmentUrl(wantedCdn: ICdnMetadata | null, segment: ISegment): string | null;

package/dist/_esm5.processed/transports/dash/construct_segment_url.js

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import resolveURL from "../../utils/resolve_url";
+export default function constructSegmentUrl(wantedCdn, segment) {
+    return wantedCdn === null ? null :
+        segment.url === null ? wantedCdn.baseUrl :
+            resolveURL(wantedCdn.baseUrl, segment.url);
+}

package/dist/_esm5.processed/transports/dash/image_pipelines.d.ts

@@ -13,18 +13,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { ICdnMetadata } from "../../parsers/manifest";
 import { CancellationSignal } from "../../utils/task_canceller";
 import { IImageTrackSegmentData, ILoadedImageSegmentFormat, ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderOptions, ISegmentLoaderResultSegmentCreated, ISegmentLoaderResultSegmentLoaded, ISegmentParserParsedInitChunk, ISegmentParserParsedMediaChunk } from "../types";
 /**
  * Loads an image segment.
- * @param {string|null} url
+ * @param {Object|null} wantedCdn
  * @param {Object} content
  * @param {Object} options
  * @param {Object} cancelSignal
  * @param {Object} callbacks
  * @returns {Promise}
  */
-export declare function imageLoader(url: string | null, content: ISegmentContext, options: ISegmentLoaderOptions, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<ILoadedImageSegmentFormat>): Promise<ISegmentLoaderResultSegmentLoaded<ILoadedImageSegmentFormat> | ISegmentLoaderResultSegmentCreated<ILoadedImageSegmentFormat>>;
+export declare function imageLoader(wantedCdn: ICdnMetadata | null, content: ISegmentContext, options: ISegmentLoaderOptions, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<ILoadedImageSegmentFormat>): Promise<ISegmentLoaderResultSegmentLoaded<ILoadedImageSegmentFormat> | ISegmentLoaderResultSegmentCreated<ILoadedImageSegmentFormat>>;
 /**
  * Parses an image segment.
  * @param {Object} loadedSegment

package/dist/_esm5.processed/transports/dash/image_pipelines.js

@@ -52,22 +52,24 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 import features from "../../features";
 import request from "../../utils/request";
 import takeFirstSet from "../../utils/take_first_set";
+import constructSegmentUrl from "./construct_segment_url";
 /**
  * Loads an image segment.
- * @param {string|null} url
+ * @param {Object|null} wantedCdn
  * @param {Object} content
  * @param {Object} options
  * @param {Object} cancelSignal
  * @param {Object} callbacks
  * @returns {Promise}
  */
-export function imageLoader(url, content, options, cancelSignal, callbacks) {
+export function imageLoader(wantedCdn, content, options, cancelSignal, callbacks) {
     return __awaiter(this, void 0, void 0, function () {
-        var segment, data;
+        var segment, url, data;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     segment = content.segment;
+                    url = constructSegmentUrl(wantedCdn, segment);
                     if (segment.isInit || url === null) {
                         return [2 /*return*/, { resultType: "segment-created",
                                 resultData: null }];

package/dist/_esm5.processed/transports/dash/segment_loader.js

@@ -19,6 +19,7 @@ import warnOnce from "../../utils/warn_once";
 import byteRange from "../utils/byte_range";
 import inferSegmentContainer from "../utils/infer_segment_container";
 import addSegmentIntegrityChecks from "./add_segment_integrity_checks_to_loader";
+import constructSegmentUrl from "./construct_segment_url";
 import initSegmentLoader from "./init_segment_loader";
 import lowLatencySegmentLoader from "./low_latency_segment_loader";
 /**
@@ -63,10 +64,11 @@ export default function generateSegmentLoader(_a) {
     return checkMediaSegmentIntegrity !== true ? segmentLoader :
         addSegmentIntegrityChecks(segmentLoader);
     /**
-     * @param {Object} content
+     * @param {Object|null} wantedCdn
      * @returns {Observable}
      */
-    function segmentLoader(url, content, options, cancelSignal, callbacks) {
+    function segmentLoader(wantedCdn, content, options, cancelSignal, callbacks) {
+        var url = constructSegmentUrl(wantedCdn, content.segment);
         if (url == null) {
             return Promise.resolve({ resultType: "segment-created",
                 resultData: null });

package/dist/_esm5.processed/transports/dash/text_loader.js

@@ -18,6 +18,7 @@ import warnOnce from "../../utils/warn_once";
 import byteRange from "../utils/byte_range";
 import inferSegmentContainer from "../utils/infer_segment_container";
 import addSegmentIntegrityChecks from "./add_segment_integrity_checks_to_loader";
+import constructSegmentUrl from "./construct_segment_url";
 import initSegmentLoader from "./init_segment_loader";
 import lowLatencySegmentLoader from "./low_latency_segment_loader";
 /**
@@ -30,16 +31,17 @@ export default function generateTextTrackLoader(_a) {
     return checkMediaSegmentIntegrity !== true ? textTrackLoader :
         addSegmentIntegrityChecks(textTrackLoader);
     /**
-     * @param {string|null} url
+     * @param {Object|null} wantedCdn
      * @param {Object} content
      * @param {Object} options
      * @param {Object} cancelSignal
      * @param {Object} callbacks
      * @returns {Promise}
      */
-    function textTrackLoader(url, content, options, cancelSignal, callbacks) {
+    function textTrackLoader(wantedCdn, content, options, cancelSignal, callbacks) {
         var adaptation = content.adaptation, representation = content.representation, segment = content.segment;
         var range = segment.range;
+        var url = constructSegmentUrl(wantedCdn, segment);
         if (url === null) {
             return Promise.resolve({ resultType: "segment-created",
                 resultData: null });

package/dist/_esm5.processed/transports/dash/text_parser.js

@@ -129,7 +129,9 @@ export default function generateTextTrackParser(_a) {
     var __priv_patchLastSegmentInSidx = _a.__priv_patchLastSegmentInSidx;
     /**
      * Parse TextTrack data.
-     * @param {Object} infos
+     * @param {Object} loadedSegment
+     * @param {Object} content
+     * @param {number|undefined} initTimescale
      * @returns {Observable.<Object>}
      */
     return function textTrackParser(loadedSegment, content, initTimescale) {

package/dist/_esm5.processed/transports/local/segment_loader.d.ts

@@ -13,15 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { ICdnMetadata } from "../../parsers/manifest";
 import { CancellationSignal } from "../../utils/task_canceller";
 import { ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderOptions, ISegmentLoaderResultSegmentLoaded } from "../types";
 /**
  * Generic segment loader for the local Manifest.
- * @param {string | null} _url
+ * @param {string | null} _wantedCdn
  * @param {Object} content
  * @param {Object} cancelSignal
  * @param {Object} _callbacks
  * @returns {Promise}
  */
-export default function segmentLoader(_url: string | null, content: ISegmentContext, _loaderOptions: ISegmentLoaderOptions, // TODO use timeout?
+export default function segmentLoader(_wantedCdn: ICdnMetadata | null, content: ISegmentContext, _loaderOptions: ISegmentLoaderOptions, // TODO use timeout?
 cancelSignal: CancellationSignal, _callbacks: ISegmentLoaderCallbacks<ArrayBuffer | null>): Promise<ISegmentLoaderResultSegmentLoaded<ArrayBuffer | null>>;

package/dist/_esm5.processed/transports/local/segment_loader.js

@@ -132,13 +132,13 @@ function loadSegment(segment, customSegmentLoader, cancelSignal) {
 }
 /**
  * Generic segment loader for the local Manifest.
- * @param {string | null} _url
+ * @param {string | null} _wantedCdn
  * @param {Object} content
  * @param {Object} cancelSignal
  * @param {Object} _callbacks
  * @returns {Promise}
  */
-export default function segmentLoader(_url, content, _loaderOptions, // TODO use timeout?
+export default function segmentLoader(_wantedCdn, content, _loaderOptions, // TODO use timeout?
 cancelSignal, _callbacks) {
     var segment = content.segment;
     var privateInfos = segment.privateInfos;

package/dist/_esm5.processed/transports/metaplaylist/pipelines.js

@@ -167,11 +167,11 @@ export default function (options) {
             appendWindow: [offsetedWindowStart, offsetedWindowEnd] };
     }
     var audioPipeline = {
-        loadSegment: function (url, content, loaderOptions, cancelToken, callbacks) {
+        loadSegment: function (wantedCdn, content, loaderOptions, cancelToken, callbacks) {
             var segment = content.segment;
             var audio = getTransportPipelinesFromSegment(segment).audio;
             var ogContent = getOriginalContent(segment);
-            return audio.loadSegment(url, ogContent, loaderOptions, cancelToken, callbacks);
+            return audio.loadSegment(wantedCdn, ogContent, loaderOptions, cancelToken, callbacks);
         },
         parseSegment: function (loadedSegment, content, initTimescale) {
             var segment = content.segment;
@@ -187,11 +187,11 @@ export default function (options) {
         },
     };
     var videoPipeline = {
-        loadSegment: function (url, content, loaderOptions, cancelToken, callbacks) {
+        loadSegment: function (wantedCdn, content, loaderOptions, cancelToken, callbacks) {
             var segment = content.segment;
             var video = getTransportPipelinesFromSegment(segment).video;
             var ogContent = getOriginalContent(segment);
-            return video.loadSegment(url, ogContent, loaderOptions, cancelToken, callbacks);
+            return video.loadSegment(wantedCdn, ogContent, loaderOptions, cancelToken, callbacks);
         },
         parseSegment: function (loadedSegment, content, initTimescale) {
             var segment = content.segment;
@@ -207,11 +207,11 @@ export default function (options) {
         },
     };
     var textTrackPipeline = {
-        loadSegment: function (url, content, loaderOptions, cancelToken, callbacks) {
+        loadSegment: function (wantedCdn, content, loaderOptions, cancelToken, callbacks) {
             var segment = content.segment;
             var text = getTransportPipelinesFromSegment(segment).text;
             var ogContent = getOriginalContent(segment);
-            return text.loadSegment(url, ogContent, loaderOptions, cancelToken, callbacks);
+            return text.loadSegment(wantedCdn, ogContent, loaderOptions, cancelToken, callbacks);
         },
         parseSegment: function (loadedSegment, content, initTimescale) {
             var segment = content.segment;
@@ -227,11 +227,11 @@ export default function (options) {
         },
     };
     var imageTrackPipeline = {
-        loadSegment: function (url, content, loaderOptions, cancelToken, callbacks) {
+        loadSegment: function (wantedCdn, content, loaderOptions, cancelToken, callbacks) {
             var segment = content.segment;
             var image = getTransportPipelinesFromSegment(segment).image;
             var ogContent = getOriginalContent(segment);
-            return image.loadSegment(url, ogContent, loaderOptions, cancelToken, callbacks);
+            return image.loadSegment(wantedCdn, ogContent, loaderOptions, cancelToken, callbacks);
         },
         parseSegment: function (loadedSegment, content, initTimescale) {
             var segment = content.segment;

package/dist/_esm5.processed/transports/smooth/pipelines.js

@@ -73,7 +73,7 @@ import generateManifestLoader from "../utils/generate_manifest_loader";
 import extractTimingsInfos from "./extract_timings_infos";
 import { patchSegment } from "./isobmff";
 import generateSegmentLoader from "./segment_loader";
-import { extractISML, extractToken, isMP4EmbeddedTrack, replaceToken, resolveManifest, } from "./utils";
+import { constructSegmentUrl, extractISML, extractToken, isMP4EmbeddedTrack, replaceToken, resolveManifest, } from "./utils";
 var WSX_REG = /\.wsx?(\?token=\S+)?/;
 /**
  * @param {Object} adaptation
@@ -152,14 +152,15 @@ export default function (transportOptions) {
     var audioVideoPipeline = {
         /**
          * Load a Smooth audio/video segment.
-         * @param {string|null} url
+         * @param {Object|null} wantedCdn
          * @param {Object} content
          * @param {Object} loaderOptions
          * @param {Object} cancelSignal
          * @param {Object} callbacks
          * @returns {Promise}
          */
-        loadSegment: function (url, content, loaderOptions, cancelSignal, callbacks) {
+        loadSegment: function (wantedCdn, content, loaderOptions, cancelSignal, callbacks) {
+            var url = constructSegmentUrl(wantedCdn, content.segment);
             return segmentLoader(url, content, loaderOptions, cancelSignal, callbacks);
         },
         parseSegment: function (loadedSegment, content, initTimescale) {
@@ -214,8 +215,9 @@ export default function (transportOptions) {
         },
     };
     var textTrackPipeline = {
-        loadSegment: function (url, content, loaderOptions, cancelSignal, callbacks) {
+        loadSegment: function (wantedCdn, content, loaderOptions, cancelSignal, callbacks) {
             var segment = content.segment, representation = content.representation;
+            var url = constructSegmentUrl(wantedCdn, segment);
             if (segment.isInit || url === null) {
                 return Promise.resolve({ resultType: "segment-created",
                     resultData: null });
@@ -368,13 +370,15 @@ export default function (transportOptions) {
         },
     };
     var imageTrackPipeline = {
-        loadSegment: function (url, content, loaderOptions, cancelSignal, callbacks) {
+        loadSegment: function (wantedCdn, content, loaderOptions, cancelSignal, callbacks) {
             return __awaiter(this, void 0, void 0, function () {
-                var data;
+                var segment, url, data;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
-                            if (content.segment.isInit || url === null) {
+                            segment = content.segment;
+                            url = constructSegmentUrl(wantedCdn, segment);
+                            if (segment.isInit || url === null) {
                                 // image do not need an init segment. Passthrough directly to the parser
                                 return [2 /*return*/, { resultType: "segment-created",
                                         resultData: null }];

package/dist/_esm5.processed/transports/smooth/utils.d.ts

@@ -13,7 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Representation } from "../../manifest";
+import { ISegment, Representation } from "../../manifest";
+import { ICdnMetadata } from "../../parsers/manifest";
 /**
  * TODO Remove this logic completely from the player
  * @param {Document} doc
@@ -46,4 +47,5 @@ declare function resolveManifest(url: string): string;
  * @returns {Boolean}
  */
 declare function isMP4EmbeddedTrack(representation: Representation): boolean;
-export { extractISML, extractToken, isMP4EmbeddedTrack, replaceToken, resolveManifest, };
+declare function constructSegmentUrl(wantedCdn: ICdnMetadata | null, segment: ISegment): string | null;
+export { constructSegmentUrl, extractISML, extractToken, isMP4EmbeddedTrack, replaceToken, resolveManifest, };

package/dist/_esm5.processed/transports/smooth/utils.js

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import isNonEmptyString from "../../utils/is_non_empty_string";
+import resolveURL from "../../utils/resolve_url";
 import warnOnce from "../../utils/warn_once";
 var ISM_REG = /(\.isml?)(\?token=\S+)?$/;
 var TOKEN_REG = /\?token=(\S+)/;
@@ -77,4 +78,9 @@ function isMP4EmbeddedTrack(representation) {
     return typeof representation.mimeType === "string" &&
         representation.mimeType.indexOf("mp4") >= 0;
 }
-export { extractISML, extractToken, isMP4EmbeddedTrack, replaceToken, resolveManifest, };
+function constructSegmentUrl(wantedCdn, segment) {
+    return wantedCdn === null ? null :
+        segment.url === null ? wantedCdn.baseUrl :
+            resolveURL(wantedCdn.baseUrl, segment.url);
+}
+export { constructSegmentUrl, extractISML, extractToken, isMP4EmbeddedTrack, replaceToken, resolveManifest, };

package/dist/_esm5.processed/transports/types.d.ts

@@ -15,6 +15,7 @@
  */
 import { IInbandEvent } from "../core/stream";
 import Manifest, { Adaptation, ISegment, ISupplementaryImageTrack, ISupplementaryTextTrack, Period, Representation } from "../manifest";
+import { ICdnMetadata } from "../parsers/manifest";
 import { IBifThumbnail, ILoadedManifestFormat, IManifestLoader, IRepresentationFilter, ISegmentLoader as ICustomSegmentLoader, IServerSyncInfos } from "../public_types";
 import TaskCanceller, { CancellationSignal } from "../utils/task_canceller";
 /**
@@ -174,8 +175,9 @@ export interface ISegmentPipeline<TLoadedFormat, TParsedSegmentDataFormat> {
 }
 /**
  * Segment loader function, allowing to load a segment of any type.
- * @param {string|null} url - URL at which the segment should be downloaded.
- * `null` if we do not have an URL (in which case the segment should be loaded
+ * @param {string|null} wantedCdn - CDN metadata for the CDN on which the
+ * segment should be downloaded.
+ * `null` if we do not have such CDN (in which case the segment should be loaded
  * through other means, such as information taken from the segment's content).
  * @param {Object} content - Content linked to the wanted segment.
  * @param {CancellationSignal} cancelSignal - Cancellation signal which will
@@ -188,7 +190,7 @@ export interface ISegmentPipeline<TLoadedFormat, TParsedSegmentDataFormat> {
  * @returns {Promise.<Object>} - Promise resolving when it has finished loading
  * the segment.
  */
-export declare type ISegmentLoader<TLoadedFormat> = (url: string | null, content: ISegmentContext, options: ISegmentLoaderOptions, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<TLoadedFormat>) => Promise<ISegmentLoaderResultSegmentCreated<TLoadedFormat> | ISegmentLoaderResultSegmentLoaded<TLoadedFormat> | ISegmentLoaderResultChunkedComplete>;
+export declare type ISegmentLoader<TLoadedFormat> = (wantedCdn: ICdnMetadata | null, content: ISegmentContext, options: ISegmentLoaderOptions, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<TLoadedFormat>) => Promise<ISegmentLoaderResultSegmentCreated<TLoadedFormat> | ISegmentLoaderResultSegmentLoaded<TLoadedFormat> | ISegmentLoaderResultChunkedComplete>;
 /** Options given to an `ISegmentLoader` to configure its behavior. */
 export interface ISegmentLoaderOptions {
     /**

package/dist/_esm5.processed/utils/event_emitter.d.ts

@@ -18,7 +18,6 @@ import { CancellationSignal } from "./task_canceller";
 export interface IEventEmitter<T> {
     addEventListener<TEventName extends keyof T>(evt: TEventName, fn: IListener<T, TEventName>): void;
     removeEventListener<TEventName extends keyof T>(evt: TEventName, fn: IListener<T, TEventName>): void;
-    trigger?<TEventName extends keyof T>(evt: TEventName, arg: IArgs<T, TEventName>): void;
 }
 declare type IArgs<TEventRecord, TEventName extends keyof TEventRecord> = TEventRecord[TEventName];
 export declare type IListener<TEventRecord, TEventName extends keyof TEventRecord> = (args: IArgs<TEventRecord, TEventName>) => void;
@@ -60,7 +59,7 @@ export default class EventEmitter<T> implements IEventEmitter<T> {
      * @param {*} arg - The eventual payload for that event. All triggered
      * callbacks will recieve this payload as argument.
      */
-    trigger<TEventName extends keyof T>(evt: TEventName, arg: IArgs<T, TEventName>): void;
+    protected trigger<TEventName extends keyof T>(evt: TEventName, arg: IArgs<T, TEventName>): void;
 }
 /**
  * Simple redefinition of the fromEvent from rxjs to also work on our

package/dist/_esm5.processed/utils/resolve_url.d.ts

@@ -24,9 +24,12 @@
  */
 export default function resolveURL(...args: Array<string | undefined>): string;
 /**
- * Remove string after the last '/'.
+ * In a given URL, find the index at which the filename begins.
+ * That is, this function finds the index of the last `/` character and returns
+ * the index after it, returning the length of the whole URL if no `/` was found
+ * after the scheme (i.e. in `http://`, the slashes are not considered).
  * @param {string} url
- * @returns {string}
+ * @returns {number}
  */
-declare function normalizeBaseURL(url: string): string;
-export { normalizeBaseURL };
+declare function getFilenameIndexInUrl(url: string): number;
+export { getFilenameIndexInUrl };

package/dist/_esm5.processed/utils/resolve_url.js

@@ -86,29 +86,32 @@ export default function resolveURL() {
     return _normalizeUrl(base);
 }
 /**
- * Remove string after the last '/'.
+ * In a given URL, find the index at which the filename begins.
+ * That is, this function finds the index of the last `/` character and returns
+ * the index after it, returning the length of the whole URL if no `/` was found
+ * after the scheme (i.e. in `http://`, the slashes are not considered).
  * @param {string} url
- * @returns {string}
+ * @returns {number}
  */
-function normalizeBaseURL(url) {
+function getFilenameIndexInUrl(url) {
     var indexOfLastSlash = url.lastIndexOf("/");
     if (indexOfLastSlash < 0) {
-        return url;
+        return url.length;
     }
     if (schemeRe.test(url)) {
         var firstSlashIndex = url.indexOf("/");
         if (firstSlashIndex >= 0 && indexOfLastSlash === firstSlashIndex + 1) {
             // The "/" detected is actually the one from the protocol part of the URL
             // ("https://")
-            return url;
+            return url.length;
         }
     }
     var indexOfQuestionMark = url.indexOf("?");
     if (indexOfQuestionMark >= 0 && indexOfQuestionMark < indexOfLastSlash) {
         // There are query parameters. Let's ignore them and re-run the logic
         // without
-        return normalizeBaseURL(url.substring(0, indexOfQuestionMark));
+        return getFilenameIndexInUrl(url.substring(0, indexOfQuestionMark));
     }
-    return url.substring(0, indexOfLastSlash + 1);
+    return indexOfLastSlash + 1;
 }
-export { normalizeBaseURL };
+export { getFilenameIndexInUrl };