rx-player 4.0.0-dev.2023121900 → 4.0.0-rc.2

package/dist/commonjs/manifest/manifest.js

@@ -29,6 +29,17 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -54,28 +65,17 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 var errors_1 = require("../errors");
 var log_1 = require("../log");
 var array_find_1 = require("../utils/array_find");
 var event_emitter_1 = require("../utils/event_emitter");
 var id_generator_1 = require("../utils/id_generator");
-var monotonic_timestamp_1 = require("../utils/monotonic_timestamp");
 var warn_once_1 = require("../utils/warn_once");
 var period_1 = require("./period");
 var types_1 = require("./types");
 var update_periods_1 = require("./update_periods");
+var utils_1 = require("./utils");
 var generateNewManifestId = (0, id_generator_1.default)();
 /**
  * Normalized Manifest structure.
@@ -102,7 +102,7 @@ var Manifest = /** @class */ (function (_super) {
      * Construct a Manifest instance from a parsed Manifest object (as returned by
      * Manifest parsers) and options.
      *
-     * Some minor errors can arise during that construction. `this.contentWarnings`
+     * Some minor errors can arise during that construction. `warnings`
      * will contain all such errors, in the order they have been encountered.
      * @param {Object} parsedManifest
      * @param {Object} options
@@ -113,6 +113,7 @@ var Manifest = /** @class */ (function (_super) {
         var _a;
         var _this = _super.call(this) || this;
         var representationFilter = options.representationFilter, manifestUpdateUrl = options.manifestUpdateUrl;
+        _this.manifestFormat = 0 /* ManifestMetadataFormat.Class */;
         _this.id = generateNewManifestId();
         _this.expired = (_a = parsedManifest.expired) !== null && _a !== void 0 ? _a : null;
         _this.transport = parsedManifest.transportType;
@@ -123,7 +124,7 @@ var Manifest = /** @class */ (function (_super) {
             return period;
         }).sort(function (a, b) { return a.start - b.start; });
         if (unsupportedAdaptations.length > 0) {
-            var error = new errors_1.MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "An Adaptation contains only incompatible codecs.", { adaptations: unsupportedAdaptations });
+            var error = new errors_1.MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "An Adaptation contains only incompatible codecs.", { tracks: unsupportedAdaptations.map(utils_1.toTaggedTrack) });
             warnings.push(error);
         }
         /**
@@ -134,7 +135,7 @@ var Manifest = /** @class */ (function (_super) {
         _this.adaptations = _this.periods[0] === undefined ? {} :
             _this.periods[0].adaptations;
         /* eslint-enable import/no-deprecated */
-        _this._timeBounds = parsedManifest.timeBounds;
+        _this.timeBounds = parsedManifest.timeBounds;
         _this.isDynamic = parsedManifest.isDynamic;
         _this.isLive = parsedManifest.isLive;
         _this.isLastPeriodKnown = parsedManifest.isLastPeriodKnown;
@@ -142,11 +143,47 @@ var Manifest = /** @class */ (function (_super) {
             parsedManifest.uris;
         _this.updateUrl = manifestUpdateUrl;
         _this.lifetime = parsedManifest.lifetime;
+        _this.clockOffset = parsedManifest.clockOffset;
         _this.suggestedPresentationDelay = parsedManifest.suggestedPresentationDelay;
         _this.availabilityStartTime = parsedManifest.availabilityStartTime;
         _this.publishTime = parsedManifest.publishTime;
         return _this;
     }
+    /**
+     * Some environments (e.g. in a WebWorker) may not have the capability to know
+     * if a mimetype+codec combination is supported on the current platform.
+     *
+     * Calling `refreshCodecSupport` manually with a clear list of codecs supported
+     * once it has been requested on a compatible environment (e.g. in the main
+     * thread) allows to work-around this issue.
+     *
+     * @param {Array.<Object>} supportList
+     * @returns {Error|null} - Refreshing codec support might reveal that some
+     * `Adaptation` don't have any of their `Representation`s supported.
+     * In that case, an error object will be created and returned, so you can
+     * e.g. later emit it as a warning through the RxPlayer API.
+     */
+    Manifest.prototype.refreshCodecSupport = function (supportList) {
+        var e_1, _a;
+        var unsupportedAdaptations = [];
+        try {
+            for (var _b = __values(this.periods), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var period = _c.value;
+                period.refreshCodecSupport(supportList, unsupportedAdaptations);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (unsupportedAdaptations.length > 0) {
+            return new errors_1.MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "An Adaptation contains only incompatible codecs.", { tracks: unsupportedAdaptations.map(utils_1.toTaggedTrack) });
+        }
+        return null;
+    };
     /**
      * Returns the Period corresponding to the given `id`.
      * Returns `undefined` if there is none.
@@ -165,10 +202,7 @@ var Manifest = /** @class */ (function (_super) {
      * @returns {Object|undefined}
      */
     Manifest.prototype.getPeriodForTime = function (time) {
-        return (0, array_find_1.default)(this.periods, function (period) {
-            return time >= period.start &&
-                (period.end === undefined || period.end > time);
-        });
+        return (0, utils_1.getPeriodForTime)(this, time);
     };
     /**
      * Returns the first Period starting strictly after the given time.
@@ -188,15 +222,7 @@ var Manifest = /** @class */ (function (_super) {
      * @returns {Object|null}
      */
     Manifest.prototype.getPeriodAfter = function (period) {
-        var endOfPeriod = period.end;
-        if (endOfPeriod === undefined) {
-            return null;
-        }
-        var nextPeriod = (0, array_find_1.default)(this.periods, function (_period) {
-            return _period.end === undefined || endOfPeriod < _period.end;
-        });
-        return nextPeriod === undefined ? null :
-            nextPeriod;
+        return (0, utils_1.getPeriodAfter)(this, period);
     };
     /**
      * Returns the most important URL from which the Manifest can be refreshed.
@@ -234,22 +260,7 @@ var Manifest = /** @class */ (function (_super) {
      * @returns {number}
      */
     Manifest.prototype.getMinimumSafePosition = function () {
-        var _a, _b;
-        var windowData = this._timeBounds;
-        if (windowData.timeshiftDepth === null) {
-            return (_a = windowData.minimumSafePosition) !== null && _a !== void 0 ? _a : 0;
-        }
-        var maximumTimeData = windowData.maximumTimeData;
-        var maximumTime;
-        if (!windowData.maximumTimeData.isLinear) {
-            maximumTime = maximumTimeData.maximumSafePosition;
-        }
-        else {
-            var timeDiff = (0, monotonic_timestamp_1.default)() - maximumTimeData.time;
-            maximumTime = maximumTimeData.maximumSafePosition + timeDiff / 1000;
-        }
-        var theoricalMinimum = maximumTime - windowData.timeshiftDepth;
-        return Math.max((_b = windowData.minimumSafePosition) !== null && _b !== void 0 ? _b : 0, theoricalMinimum);
+        return (0, utils_1.getMinimumSafePosition)(this);
     };
     /**
      * Get the position of the live edge - that is, the position of what is
@@ -257,15 +268,7 @@ var Manifest = /** @class */ (function (_super) {
      * @returns {number|undefined}
      */
     Manifest.prototype.getLivePosition = function () {
-        var maximumTimeData = this._timeBounds.maximumTimeData;
-        if (!this.isLive || maximumTimeData.livePosition === undefined) {
-            return undefined;
-        }
-        if (!maximumTimeData.isLinear) {
-            return maximumTimeData.livePosition;
-        }
-        var timeDiff = (0, monotonic_timestamp_1.default)() - maximumTimeData.time;
-        return maximumTimeData.livePosition + timeDiff / 1000;
+        return (0, utils_1.getLivePosition)(this);
     };
     /**
      * Returns the theoretical maximum playable position on the content
@@ -273,12 +276,7 @@ var Manifest = /** @class */ (function (_super) {
      * time.
      */
     Manifest.prototype.getMaximumSafePosition = function () {
-        var maximumTimeData = this._timeBounds.maximumTimeData;
-        if (!maximumTimeData.isLinear) {
-            return maximumTimeData.maximumSafePosition;
-        }
-        var timeDiff = (0, monotonic_timestamp_1.default)() - maximumTimeData.time;
-        return maximumTimeData.maximumSafePosition + timeDiff / 1000;
+        return (0, utils_1.getMaximumSafePosition)(this);
     };
     /**
      * Look in the Manifest for Representations linked to the given key ID,
@@ -343,6 +341,50 @@ var Manifest = /** @class */ (function (_super) {
         });
         /* eslint-enable import/no-deprecated */
     };
+    /**
+     * Format the current `Manifest`'s properties into a
+     * `IManifestMetadata` format which can better be communicated through
+     * another thread.
+     *
+     * Please bear in mind however that the returned object will not be updated
+     * when the current `Manifest` instance is updated, it is only a
+     * snapshot at the current time.
+     *
+     * If you want to keep that data up-to-date with the current `Manifest`
+     * instance, you will have to do it yourself.
+     *
+     * @returns {Object}
+     */
+    Manifest.prototype.getMetadataSnapshot = function () {
+        var e_2, _a;
+        var periods = [];
+        try {
+            for (var _b = __values(this.periods), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var period = _c.value;
+                periods.push(period.getMetadataSnapshot());
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return {
+            manifestFormat: 1 /* ManifestMetadataFormat.MetadataObject */,
+            id: this.id,
+            periods: periods,
+            isDynamic: this.isDynamic,
+            isLive: this.isLive,
+            isLastPeriodKnown: this.isLastPeriodKnown,
+            suggestedPresentationDelay: this.suggestedPresentationDelay,
+            clockOffset: this.clockOffset,
+            uris: this.uris,
+            availabilityStartTime: this.availabilityStartTime,
+            timeBounds: this.timeBounds,
+        };
+    };
     /**
      * @param {Object} newManifest
      * @param {number} updateType
@@ -359,12 +401,12 @@ var Manifest = /** @class */ (function (_super) {
         this.publishTime = newManifest.publishTime;
         var updatedPeriodsResult;
         if (updateType === types_1.MANIFEST_UPDATE_TYPE.Full) {
-            this._timeBounds = newManifest._timeBounds;
+            this.timeBounds = newManifest.timeBounds;
             this.uris = newManifest.uris;
             updatedPeriodsResult = (0, update_periods_1.replacePeriods)(this.periods, newManifest.periods);
         }
         else {
-            this._timeBounds.maximumTimeData = newManifest._timeBounds.maximumTimeData;
+            this.timeBounds.maximumTimeData = newManifest.timeBounds.maximumTimeData;
             this.updateUrl = newManifest.uris[0];
             updatedPeriodsResult = (0, update_periods_1.updatePeriods)(this.periods, newManifest.periods);
             // Partial updates do not remove old Periods.
@@ -405,49 +447,50 @@ exports.default = Manifest;
  * @returns {Array.<Object>}
  */
 function updateDeciperability(manifest, isDecipherable) {
-    var e_1, _a, e_2, _b, e_3, _c;
+    var e_3, _a, e_4, _b, e_5, _c;
     var updates = [];
     try {
         for (var _d = __values(manifest.periods), _e = _d.next(); !_e.done; _e = _d.next()) {
             var period = _e.value;
             try {
-                for (var _f = (e_2 = void 0, __values(period.getAdaptations())), _g = _f.next(); !_g.done; _g = _f.next()) {
+                for (var _f = (e_4 = void 0, __values(period.getAdaptations())), _g = _f.next(); !_g.done; _g = _f.next()) {
                     var adaptation = _g.value;
                     try {
-                        for (var _h = (e_3 = void 0, __values(adaptation.representations)), _j = _h.next(); !_j.done; _j = _h.next()) {
+                        for (var _h = (e_5 = void 0, __values(adaptation.representations)), _j = _h.next(); !_j.done; _j = _h.next()) {
                             var representation = _j.value;
-                            var result = isDecipherable(representation);
+                            var content = { manifest: manifest, period: period, adaptation: adaptation, representation: representation };
+                            var result = isDecipherable(content);
                             if (result !== representation.decipherable) {
-                                updates.push({ manifest: manifest, period: period, adaptation: adaptation, representation: representation });
+                                updates.push(content);
                                 representation.decipherable = result;
                                 log_1.default.debug("Decipherability changed for \"".concat(representation.id, "\""), "(".concat(representation.bitrate, ")"), String(representation.decipherable));
                             }
                         }
                     }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
                     finally {
                         try {
                             if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
                         }
-                        finally { if (e_3) throw e_3.error; }
+                        finally { if (e_5) throw e_5.error; }
                     }
                 }
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
             finally {
                 try {
                     if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
                 }
-                finally { if (e_2) throw e_2.error; }
+                finally { if (e_4) throw e_4.error; }
             }
         }
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
     finally {
         try {
             if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
         }
-        finally { if (e_1) throw e_1.error; }
+        finally { if (e_3) throw e_3.error; }
     }
     return updates;
 }

package/dist/commonjs/manifest/period.d.ts

@@ -1,6 +1,8 @@
 import { IManifestStreamEvent, IParsedPeriod } from "../parsers/manifest";
 import { ITrackType, IRepresentationFilter } from "../public_types";
 import Adaptation from "./adaptation";
+import { ICodecSupportList } from "./representation";
+import { IPeriodMetadata } from "./types";
 /** Structure listing every `Adaptation` in a Period. */
 export type IManifestAdaptations = Partial<Record<ITrackType, Adaptation[]>>;
 /**
@@ -8,7 +10,7 @@ export type IManifestAdaptations = Partial<Record<ITrackType, Adaptation[]>>;
  * period in the the Manifest.
  * @class Period
  */
-export default class Period {
+export default class Period implements IPeriodMetadata {
     /** ID uniquely identifying the Period in the Manifest. */
     readonly id: string;
     /** Every 'Adaptation' in that Period, per type of Adaptation. */
@@ -30,9 +32,28 @@ export default class Period {
     /**
      * @constructor
      * @param {Object} args
+     * @param {Array.<Object>} unsupportedAdaptations - Array on which
+     * `Adaptation`s objects which have no supported `Representation` will be
+     * pushed.
+     * This array might be useful for minor error reporting.
      * @param {function|undefined} [representationFilter]
      */
     constructor(args: IParsedPeriod, unsupportedAdaptations: Adaptation[], representationFilter?: IRepresentationFilter | undefined);
+    /**
+     * Some environments (e.g. in a WebWorker) may not have the capability to know
+     * if a mimetype+codec combination is supported on the current platform.
+     *
+     * Calling `refreshCodecSupport` manually with a clear list of codecs supported
+     * once it has been requested on a compatible environment (e.g. in the main
+     * thread) allows to work-around this issue.
+     *
+     * @param {Array.<Object>} supportList
+     * @param {Array.<Object>} unsupportedAdaptations - Array on which
+     * `Adaptation`s objects which are now known to have no supported
+     * `Representation` will be pushed.
+     * This array might be useful for minor error reporting.
+     */
+    refreshCodecSupport(supportList: ICodecSupportList, unsupportedAdaptations: Adaptation[]): void;
     /**
      * Returns every `Adaptations` (or `tracks`) linked to that Period, in an
      * Array.
@@ -58,11 +79,28 @@ export default class Period {
      * type. Will return for all types if `undefined`.
      * @returns {Array.<Adaptation>}
      */
-    getSupportedAdaptations(type?: ITrackType): Adaptation[];
+    getSupportedAdaptations(type?: ITrackType | undefined): Adaptation[];
     /**
      * Returns true if the give time is in the time boundaries of this `Period`.
      * @param {number} time
+     * @param {object|null} nextPeriod - Period coming chronologically just
+     * after in the same Manifest. `null` if this instance is the last `Period`.
      * @returns {boolean}
      */
-    containsTime(time: number): boolean;
+    containsTime(time: number, nextPeriod: Period | null): boolean;
+    /**
+     * Format the current `Period`'s properties into a
+     * `IPeriodMetadata` format which can better be communicated through
+     * another thread.
+     *
+     * Please bear in mind however that the returned object will not be updated
+     * when the current `Period` instance is updated, it is only a
+     * snapshot at the current time.
+     *
+     * If you want to keep that data up-to-date with the current `Period`
+     * instance, you will have to do it yourself.
+     *
+     * @returns {Object}
+     */
+    getMetadataSnapshot(): IPeriodMetadata;
 }

package/dist/commonjs/manifest/period.js

@@ -1,4 +1,15 @@
 "use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Copyright 2015 CANAL+ Group
@@ -17,8 +28,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 var errors_1 = require("../errors");
 var array_find_1 = require("../utils/array_find");
-var object_values_1 = require("../utils/object_values");
 var adaptation_1 = require("./adaptation");
+var utils_1 = require("./utils");
 /**
  * Class representing the tracks and qualities available from a given time
  * period in the the Manifest.
@@ -28,6 +39,10 @@ var Period = /** @class */ (function () {
     /**
      * @constructor
      * @param {Object} args
+     * @param {Array.<Object>} unsupportedAdaptations - Array on which
+     * `Adaptation`s objects which have no supported `Representation` will be
+     * pushed.
+     * This array might be useful for minor error reporting.
      * @param {function|undefined} [representationFilter]
      */
     function Period(args, unsupportedAdaptations, representationFilter) {
@@ -41,7 +56,8 @@ var Period = /** @class */ (function () {
             var filteredAdaptations = adaptationsForType
                 .map(function (adaptation) {
                 var newAdaptation = new adaptation_1.default(adaptation, { representationFilter: representationFilter });
-                if (newAdaptation.representations.length > 0 && !newAdaptation.isSupported) {
+                if (newAdaptation.representations.length > 0
+                    && newAdaptation.isSupported === false) {
                     unsupportedAdaptations.push(newAdaptation);
                 }
                 return newAdaptation;
@@ -49,10 +65,10 @@ var Period = /** @class */ (function () {
                 .filter(function (adaptation) {
                 return adaptation.representations.length > 0;
             });
-            if (filteredAdaptations.every(function (adaptation) { return !adaptation.isSupported; }) &&
+            if (filteredAdaptations.every(function (adaptation) { return adaptation.isSupported === false; }) &&
                 adaptationsForType.length > 0 &&
                 (type === "video" || type === "audio")) {
-                throw new errors_1.MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "No supported " + type + " adaptations", { adaptations: undefined });
+                throw new errors_1.MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "No supported " + type + " adaptations", { tracks: undefined });
             }
             if (filteredAdaptations.length > 0) {
                 acc[type] = filteredAdaptations;
@@ -72,17 +88,66 @@ var Period = /** @class */ (function () {
             [] :
             args.streamEvents;
     }
+    /**
+     * Some environments (e.g. in a WebWorker) may not have the capability to know
+     * if a mimetype+codec combination is supported on the current platform.
+     *
+     * Calling `refreshCodecSupport` manually with a clear list of codecs supported
+     * once it has been requested on a compatible environment (e.g. in the main
+     * thread) allows to work-around this issue.
+     *
+     * @param {Array.<Object>} supportList
+     * @param {Array.<Object>} unsupportedAdaptations - Array on which
+     * `Adaptation`s objects which are now known to have no supported
+     * `Representation` will be pushed.
+     * This array might be useful for minor error reporting.
+     */
+    Period.prototype.refreshCodecSupport = function (supportList, unsupportedAdaptations) {
+        var _this = this;
+        Object.keys(this.adaptations).forEach(function (ttype) {
+            var e_1, _a;
+            var adaptationsForType = _this.adaptations[ttype];
+            if (adaptationsForType === undefined) {
+                return;
+            }
+            var hasSupportedAdaptations = false;
+            try {
+                for (var adaptationsForType_1 = __values(adaptationsForType), adaptationsForType_1_1 = adaptationsForType_1.next(); !adaptationsForType_1_1.done; adaptationsForType_1_1 = adaptationsForType_1.next()) {
+                    var adaptation = adaptationsForType_1_1.value;
+                    var wasSupported = adaptation.isSupported;
+                    adaptation.refreshCodecSupport(supportList);
+                    if (wasSupported !== false && adaptation.isSupported === false) {
+                        unsupportedAdaptations.push(adaptation);
+                    }
+                    if (hasSupportedAdaptations === false) {
+                        hasSupportedAdaptations = adaptation.isSupported;
+                    }
+                    else if (hasSupportedAdaptations === undefined &&
+                        adaptation.isSupported === true) {
+                        hasSupportedAdaptations = true;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (adaptationsForType_1_1 && !adaptationsForType_1_1.done && (_a = adaptationsForType_1.return)) _a.call(adaptationsForType_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            if ((ttype === "video" || ttype === "audio") &&
+                hasSupportedAdaptations === false) {
+                throw new errors_1.MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "No supported " + ttype + " adaptations", { tracks: undefined });
+            }
+        }, {});
+    };
     /**
      * Returns every `Adaptations` (or `tracks`) linked to that Period, in an
      * Array.
      * @returns {Array.<Object>}
      */
     Period.prototype.getAdaptations = function () {
-        var adaptationsByType = this.adaptations;
-        return (0, object_values_1.default)(adaptationsByType).reduce(
-        // Note: the second case cannot happen. TS is just being dumb here
-        function (acc, adaptations) { return adaptations != null ? acc.concat(adaptations) :
-            acc; }, []);
+        return (0, utils_1.getAdaptations)(this);
     };
     /**
      * Returns every `Adaptations` (or `tracks`) linked to that Period for a
@@ -113,27 +178,58 @@ var Period = /** @class */ (function () {
      * @returns {Array.<Adaptation>}
      */
     Period.prototype.getSupportedAdaptations = function (type) {
-        if (type === undefined) {
-            return this.getAdaptations().filter(function (ada) {
-                return ada.isSupported;
-            });
-        }
-        var adaptationsForType = this.adaptations[type];
-        if (adaptationsForType === undefined) {
-            return [];
-        }
-        return adaptationsForType.filter(function (ada) {
-            return ada.isSupported;
-        });
+        return (0, utils_1.getSupportedAdaptations)(this, type);
     };
     /**
      * Returns true if the give time is in the time boundaries of this `Period`.
      * @param {number} time
+     * @param {object|null} nextPeriod - Period coming chronologically just
+     * after in the same Manifest. `null` if this instance is the last `Period`.
      * @returns {boolean}
      */
-    Period.prototype.containsTime = function (time) {
-        return time >= this.start && (this.end === undefined ||
-            time < this.end);
+    Period.prototype.containsTime = function (time, nextPeriod) {
+        return (0, utils_1.periodContainsTime)(this, time, nextPeriod);
+    };
+    /**
+     * Format the current `Period`'s properties into a
+     * `IPeriodMetadata` format which can better be communicated through
+     * another thread.
+     *
+     * Please bear in mind however that the returned object will not be updated
+     * when the current `Period` instance is updated, it is only a
+     * snapshot at the current time.
+     *
+     * If you want to keep that data up-to-date with the current `Period`
+     * instance, you will have to do it yourself.
+     *
+     * @returns {Object}
+     */
+    Period.prototype.getMetadataSnapshot = function () {
+        var e_2, _a;
+        var adaptations = {};
+        var baseAdaptations = this.getAdaptations();
+        try {
+            for (var baseAdaptations_1 = __values(baseAdaptations), baseAdaptations_1_1 = baseAdaptations_1.next(); !baseAdaptations_1_1.done; baseAdaptations_1_1 = baseAdaptations_1.next()) {
+                var adaptation = baseAdaptations_1_1.value;
+                var currentAdaps = adaptations[adaptation.type];
+                if (currentAdaps === undefined) {
+                    currentAdaps = [];
+                    adaptations[adaptation.type] = currentAdaps;
+                }
+                currentAdaps.push(adaptation.getMetadataSnapshot());
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (baseAdaptations_1_1 && !baseAdaptations_1_1.done && (_a = baseAdaptations_1.return)) _a.call(baseAdaptations_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return { start: this.start,
+            end: this.end,
+            id: this.id,
+            streamEvents: this.streamEvents, adaptations: adaptations };
     };
     return Period;
 }());