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

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

@@ -13,6 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { IContentProtections, IManifestStreamEvent } from "../parsers/manifest";
+import { IHDRInformation, ITrackType } from "../public_types";
 /** Enumerate the different ways a Manifest update can be done. */
 export declare enum MANIFEST_UPDATE_TYPE {
     /**
@@ -27,3 +29,383 @@ export declare enum MANIFEST_UPDATE_TYPE {
      */
     Partial = 1
 }
+/**
+ * Various formats an `IManifestMetadata` object can take.
+ */
+export declare const enum ManifestMetadataFormat {
+    /**
+     * This is actually a `Manifest` class, with its event listeners, methods and
+     * all properties.
+     */
+    Class = 0,
+    /**
+     * This is only an object anouncing the properties required by the
+     * `IManifestMetadata` interface.
+     *
+     * The main advantages of this smaller structure is that:
+     *   - it takes less place in memory
+     *   - it can be serialized and thus communicated between threads
+     *     without loss of information.
+     *
+     * However it does not contain the full information like `Class` would.
+     */
+    MetadataObject = 1
+}
+/**
+ * Object describing the metadata of a given content.
+ *
+ * An `IManifestMetadata` object has several advantages over the full `Manifest`
+ * class:
+ *   - it contains fewer properties and is thus much cheaper to deeply copy
+ *   - it doesn't contain any method
+ *   - it is fully serializable while still containing its more important
+ *     metadata
+ *   - A `Manifest` is compatible and thus can be automatically upcasted into an
+ *     `IManifestMetadata`.
+ *
+ * This makes it a good candidate when a `Manifest`'s information has to be
+ * shared through several threads or environments.
+ *
+ * As such, modules which may be running in a different environment than the
+ * one creating Manifest classes should prefer to depend on an
+ * `IManifestMetadata` object, rather than the full `Manifest` class.
+ */
+export interface IManifestMetadata {
+    /**
+     * Format of the current object respecting the `IManifestMetadata` interface.
+     * Allowing for several type of formats allows to accomodate several
+     * environments such as multi-thread scenarios without badly impacting much
+     * advanced features of a mono-thread scenario.
+     */
+    manifestFormat: ManifestMetadataFormat;
+    /**
+     * ID uniquely identifying this Manifest.
+     * No two Manifests should have this ID.
+     * This ID is automatically calculated each time a `Manifest` instance is
+     * created.
+     */
+    id: string;
+    /**
+     * List every Period in that Manifest chronologically (from start to end).
+     * A Period contains information about the content available for a specific
+     * period of time.
+     */
+    periods: IPeriodMetadata[];
+    /**
+     * If true, the Manifest can evolve over time:
+     * New segments can become available in the future, properties of the manifest
+     * can change...
+     */
+    isDynamic: boolean;
+    /**
+     * If true, this Manifest describes a live content.
+     * A live content is a specific kind of content where you want to play very
+     * close to the maximum position (here called the "live edge").
+     * E.g., a TV channel is a live content.
+     */
+    isLive: boolean;
+    /**
+     * If `true`, no more periods will be added after the current last manifest's
+     * Period.
+     * `false` if we know that more Period is coming or if we don't know.
+     */
+    isLastPeriodKnown: boolean;
+    uris: string[];
+    /**
+     * Minimum time, in seconds, at which a segment defined in the Manifest
+     * can begin.
+     * This is also used as an offset for live content to apply to a segment's
+     * time.
+     */
+    availabilityStartTime: number | undefined;
+    /**
+     * Suggested delay from the "live edge" (i.e. the position corresponding to
+     * the current broadcast for a live content) the content is suggested to start
+     * from.
+     * This only applies to live contents.
+     */
+    suggestedPresentationDelay?: number | undefined;
+    clockOffset?: number | undefined;
+    /**
+     * Data allowing to calculate the minimum and maximum seekable positions at
+     * any given time.
+     */
+    timeBounds: {
+        /**
+         * This is the theoretical minimum playable position on the content
+         * regardless of the current Adaptation chosen, as estimated at parsing
+         * time.
+         * `undefined` if unknown.
+         *
+         * More technically, the `minimumSafePosition` is the maximum between all
+         * the minimum positions reachable in any of the audio and video Adaptation.
+         *
+         * Together with `timeshiftDepth` and the `maximumTimeData` object, this
+         * value allows to compute at any time the minimum seekable time:
+         *
+         *   - if `timeshiftDepth` is not set, the minimum seekable time is a
+         *     constant that corresponds to this value.
+         *
+         *    - if `timeshiftDepth` is set, `minimumSafePosition` will act as the
+         *      absolute minimum seekable time we can never seek below, even when
+         *      `timeshiftDepth` indicates a possible lower position.
+         *      This becomes useful for example when playing live contents which -
+         *      despite having a large window depth - just begun and as such only
+         *      have a few segment available for now.
+         *      Here, `minimumSafePosition` would be the start time of the initial
+         *      segment, and `timeshiftDepth` would be the whole depth that will
+         *      become available once enough segments have been generated.
+         */
+        minimumSafePosition?: 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
+         * segments, in function of the maximum reachable position.
+         *
+         * This is justified by the fact that a server might want to remove older
+         * segments when new ones become available, to free storage size.
+         *
+         * If this value is set to a number, it is the amount of time in seconds
+         * that needs to be substracted from the current maximum seekable position,
+         * to obtain the minimum seekable position.
+         * As such, this value evolves at the same rate than the maximum position
+         * does (if it does at all).
+         *
+         * If set to `null`, this content has no concept of a "window depth".
+         */
+        timeshiftDepth: number | null;
+        /** Data allowing to calculate the maximum playable position at any given time. */
+        maximumTimeData: {
+            /**
+             * Current position representing live content.
+             * Only makes sense for un-ended live contents.
+             *
+             * `undefined` if unknown or if it doesn't make sense in the current context.
+             */
+            livePosition: number | undefined;
+            /**
+             * Whether the maximum positions should evolve linearly over time.
+             *
+             * If set to `true`, the maximum seekable position continuously increase at
+             * the same rate than the time since `time` does.
+             */
+            isLinear: boolean;
+            /**
+             * This is the theoretical maximum playable position on the content,
+             * regardless of the current Adaptation chosen, as estimated at parsing
+             * time.
+             *
+             * More technically, the `maximumSafePosition` is the minimum between all
+             * attributes indicating the duration of the content in the Manifest.
+             *
+             * That is the minimum between:
+             *   - The Manifest original attributes relative to its duration
+             *   - The minimum between all known maximum audio positions
+             *   - The minimum between all known maximum video positions
+             *
+             * This can for example be understood as the safe maximum playable
+             * position through all possible tacks.
+             */
+            maximumSafePosition: number;
+            /**
+             * Monotonically-raising timestamp (the one commonly used by the RxPlayer)
+             * at the time both `maximumSafePosition` and `livePosition` were
+             * calculated.
+             * This can be used to retrieve a new maximum position from them when they
+             * linearly evolves over time (see `isLinear` property).
+             */
+            time: number;
+        };
+    };
+}
+/**
+ * Object describing a "Period" in the Manifest, that is, a time-delimited
+ * subset with its own tracks and qualities.
+ *
+ * Streaming technologies without the concept of a "Period" will just be
+ * considered to have a single Period spanning the whole content.
+ *
+ * An `IPeriodMetadata` object has several advantages over the full `Period`
+ * class:
+ *   - it contains fewer properties and is thus much cheaper to deeply copy
+ *   - it doesn't contain any method
+ *   - it is fully serializable while still containing its more important
+ *     metadata
+ *   - A `Period` is compatible and thus can be automatically upcasted into an
+ *     `IPeriodMetadata`.
+ *
+ * This makes it a good candidate when a `Period`'s information has to be
+ * shared through several threads or environments.
+ *
+ * As such, modules which may be running in a different environment than the
+ * one creating Period classes should prefer to depend on an
+ * `IPeriodMetadata` object, rather than the full `Period` class.
+ */
+export interface IPeriodMetadata {
+    /** ID uniquely identifying the IPeriodMetadata in the IManifestMetadata. */
+    id: string;
+    /** Absolute start time of the Period, in seconds. */
+    start: number;
+    /**
+     * Absolute end time of the Period, in seconds.
+     * `undefined` for still-running Periods.
+     */
+    end?: number | undefined;
+    /**
+     * Duration of this Period, in seconds.
+     * `undefined` for still-running Periods.
+     */
+    duration?: number | undefined;
+    /** Every 'Adaptation' in that Period, per type of Adaptation. */
+    adaptations: Partial<Record<ITrackType, IAdaptationMetadata[]>>;
+    /** Array containing every stream event happening on the period */
+    streamEvents: IManifestStreamEvent[];
+}
+export interface IAdaptationMetadata {
+    /** ID uniquely identifying the Adaptation in the Period. */
+    id: string;
+    /** Type of this Adaptation. */
+    type: ITrackType;
+    /** Language this Adaptation is in, as announced in the original Manifest. */
+    language?: string | undefined;
+    /** Whether this Adaptation contains closed captions for the hard-of-hearing. */
+    isClosedCaption?: boolean | undefined;
+    /** Whether this track contains an audio description for the visually impaired. */
+    isAudioDescription?: boolean | undefined;
+    /** If true this Adaptation contains sign interpretation. */
+    isSignInterpreted?: boolean | undefined;
+    /**
+     * If `true` this Adaptation are subtitles Meant for display when no other text
+     * Adaptation is selected. It is used to clarify dialogue, alternate
+     * languages, texted graphics or location/person IDs that are not otherwise
+     * covered in the dubbed/localized audio Adaptation.
+     */
+    isForcedSubtitles?: boolean | undefined;
+    /**
+     * `true` if at least one Representation is in a supported codec. `false` otherwise.
+     *
+     * `undefined` for when this is not yet known (we're still in the process of
+     * probing for support).
+     */
+    isSupported?: boolean | undefined;
+    /** Language this Adaptation is in, when translated into an ISO639-3 code. */
+    normalizedLanguage?: string | undefined;
+    /**
+     * Different `Representations` (e.g. qualities) this Adaptation is available
+     * in.
+     */
+    representations: IRepresentationMetadata[];
+    /** Label of the adaptionSet */
+    label?: string | undefined;
+    /**
+     * If `true`, this Adaptation is a "dub", meaning it was recorded in another
+     * language than the original one.
+     */
+    isDub?: boolean | undefined;
+    /** Tells if the track is a trick mode track. */
+    trickModeTracks?: IAdaptationMetadata[] | undefined;
+    /** Tells if the track is a trick mode track. */
+    isTrickModeTrack?: boolean | undefined;
+}
+export interface IRepresentationMetadata {
+    /**
+     * ID uniquely identifying the `Representation` in its parent `Adaptation`.
+     *
+     * This identifier might be linked to an identifier present in the original
+     * Manifest file, it is thus the identifier to use to determine if a
+     * `Representation` from a refreshed `Manifest` is actually the same one than
+     * one in the previously loaded Manifest (as long as the `Adaptation` and
+     * `Period` are also the same).
+     *
+     * For a globally unique identifier regardless of the `Adaptation`, `Period`
+     * or even `Manifest`, you can rely on `uniqueId` instead.
+     */
+    id: string;
+    /**
+     * Globally unique identifier for this `Representation` object.
+     *
+     * This identifier is guaranteed to be unique for any `Representation`s of all
+     * `Manifest` objects created in the current JS Realm.
+     * As such, it can be used as an identifier for the JS object itself, whereas
+     * `id` is the identifier for the original Manifest's Representation in the
+     * scope of its parent `Adaptation`.
+     */
+    uniqueId: string;
+    /** Bitrate this Representation is in, in bits per seconds. */
+    bitrate: number;
+    /**
+     * `true` if the Representation is in a supported codec, false otherwise.
+     * `undefined` for when this is not yet known (we're still in the process of
+     * probing for support).
+     */
+    isSupported?: boolean | undefined;
+    /**
+     * An array of strings describing codecs that Representation relies on.
+     *
+     * If multiple elements are in this array, each element is a codec (or groups
+     * of codecs, e.g. for both audio and video) enhancing and backward compatible
+     * to the next element of that array.
+     *
+     * For example, a Dolby Vision video Representation could be retro-compatible
+     * with HDR10 decoders not handling Dolby Vision-specific metadata.
+     * In that scenario, we could have an array with two elements:
+     *   1. The Dolby Vision codec
+     *   2. The base HDR10 codec, hopefully with higher device compatibility.
+     *
+     * To note that we should aim to have the shorter array possible to always
+     * expose the actually relied-on codec through the API. The idea could be
+     * to only have several elements in this Array _BEFORE_ testing for codec
+     * support on the current device, only to then remove all non-used codecs to
+     * keep the one actually relied on.
+     */
+    codecs?: string[];
+    /**
+     * A string describing the mime-type for this Representation.
+     * Examples: audio/mp4, video/webm, application/mp4, text/plain
+     * undefined if we do not know.
+     */
+    mimeType?: string | undefined;
+    /**
+     * If this Representation is linked to video content, this value is the width
+     * in pixel of the corresponding video data.
+     */
+    width?: number | undefined;
+    /**
+     * If this Representation is linked to video content, this value is the height
+     * in pixel of the corresponding video data.
+     */
+    height?: number | undefined;
+    /**
+     * Frame-rate, when it can be applied, of this Representation, in any textual
+     * indication possible (often under a ratio form).
+     */
+    frameRate?: number | undefined;
+    /**
+     * `true` if this `Representation` is linked to a spatial audio technology.
+     * For example, it may be set to `true` if the Representation relies on the
+     * "Dolby Atmos". technology.
+     *
+     * `false` if it is known that this `Representation` does not contain any
+     * spatial audio.
+     *
+     * `undefined` if we do not know whether this `Representation` contains
+     * spatial audio or not.
+     */
+    isSpatialAudio?: boolean | undefined;
+    /**
+     * If the track is HDR, give the characteristics of the content
+     */
+    hdrInfo?: IHDRInformation | undefined;
+    /**
+     * Whether we are able to decrypt this Representation / unable to decrypt it or
+     * if we don't know yet:
+     *   - if `true`, it means that we know we were able to decrypt this
+     *     Representation in the current content.
+     *   - if `false`, it means that we know we were unable to decrypt this
+     *     Representation
+     *   - if `undefined` there is no certainty on this matter
+     */
+    decipherable?: boolean | undefined;
+    /** Encryption information for this Representation. */
+    contentProtections?: IContentProtections | undefined;
+}

package/dist/commonjs/manifest/types.js

@@ -1,19 +1,4 @@
 "use strict";
-/**
- * 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.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MANIFEST_UPDATE_TYPE = void 0;
 /** Enumerate the different ways a Manifest update can be done. */

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

@@ -13,10 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import Adaptation from "./adaptation";
+import { ITrackType } from "../public_types";
 import Period from "./period";
-import Representation from "./representation";
-import { MANIFEST_UPDATE_TYPE } from "./types";
+import { MANIFEST_UPDATE_TYPE, IAdaptationMetadata, IRepresentationMetadata } from "./types";
 /**
  * Update oldPeriod attributes with the one from newPeriod (e.g. when updating
  * the Manifest).
@@ -33,17 +32,21 @@ export default function updatePeriodInPlace(oldPeriod: Period, newPeriod: Period
 export interface IUpdatedPeriodResult {
     /** Information on Adaptations that have been updated. */
     updatedAdaptations: Array<{
+        trackType: ITrackType;
         /** The concerned Adaptation. */
-        adaptation: Adaptation;
+        adaptation: string;
         /** Representations that have been updated. */
-        updatedRepresentations: Representation[];
+        updatedRepresentations: IRepresentationMetadata[];
         /** Representations that have been removed from the Adaptation. */
-        removedRepresentations: Representation[];
+        removedRepresentations: string[];
         /** Representations that have been added to the Adaptation. */
-        addedRepresentations: Representation[];
+        addedRepresentations: IRepresentationMetadata[];
     }>;
     /** Adaptation that have been removed from the Period. */
-    removedAdaptations: Adaptation[];
+    removedAdaptations: Array<{
+        id: string;
+        trackType: ITrackType;
+    }>;
     /** Adaptation that have been added to the Period. */
-    addedAdaptations: Adaptation[];
+    addedAdaptations: IAdaptationMetadata[];
 }

package/dist/commonjs/manifest/update_period_in_place.js

@@ -85,14 +85,18 @@ function updatePeriodInPlace(oldPeriod, newPeriod, updateType) {
                 "\" not found when merging.");
             var _c = __read(oldAdaptations.splice(j, 1), 1), removed = _c[0];
             j--;
-            res.removedAdaptations.push(removed);
+            res.removedAdaptations.push({
+                id: removed.id,
+                trackType: removed.type,
+            });
         }
         else {
             var _d = __read(newAdaptations.splice(newAdaptationIdx, 1), 1), newAdaptation = _d[0];
             var updatedRepresentations = [];
             var addedRepresentations = [];
             var removedRepresentations = [];
-            res.updatedAdaptations.push({ adaptation: oldAdaptation, updatedRepresentations: updatedRepresentations, addedRepresentations: addedRepresentations, removedRepresentations: removedRepresentations });
+            res.updatedAdaptations.push({ adaptation: oldAdaptation.id,
+                trackType: oldAdaptation.type, updatedRepresentations: updatedRepresentations, addedRepresentations: addedRepresentations, removedRepresentations: removedRepresentations });
             var oldRepresentations = oldAdaptation.representations;
             var newRepresentations = newAdaptation.representations.slice();
             var _loop_2 = function (k) {
@@ -105,11 +109,11 @@ function updatePeriodInPlace(oldPeriod, newPeriod, updateType) {
                         "not found when merging.");
                     var _e = __read(oldRepresentations.splice(k, 1), 1), removed = _e[0];
                     k--;
-                    removedRepresentations.push(removed);
+                    removedRepresentations.push(removed.id);
                 }
                 else {
                     var _f = __read(newRepresentations.splice(newRepresentationIdx, 1), 1), newRepresentation = _f[0];
-                    updatedRepresentations.push(oldRepresentation);
+                    updatedRepresentations.push(oldRepresentation.getMetadataSnapshot());
                     oldRepresentation.cdnMetadata = newRepresentation.cdnMetadata;
                     if (updateType === types_1.MANIFEST_UPDATE_TYPE.Full) {
                         oldRepresentation.index._replace(newRepresentation.index);
@@ -129,7 +133,7 @@ function updatePeriodInPlace(oldPeriod, newPeriod, updateType) {
                 log_1.default.warn("Manifest: ".concat(newRepresentations.length, " new Representations ") +
                     "found when merging.");
                 (_b = oldAdaptation.representations).push.apply(_b, __spreadArray([], __read(newRepresentations), false));
-                addedRepresentations.push.apply(addedRepresentations, __spreadArray([], __read(newRepresentations), false));
+                addedRepresentations.push.apply(addedRepresentations, __spreadArray([], __read(newRepresentations.map(function (r) { return r.getMetadataSnapshot(); })), false));
             }
         }
         out_j_1 = j;
@@ -152,7 +156,7 @@ function updatePeriodInPlace(oldPeriod, newPeriod, updateType) {
                 else {
                     prevAdaps.push(adap);
                 }
-                res.addedAdaptations.push(adap);
+                res.addedAdaptations.push(adap.getMetadataSnapshot());
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }

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

@@ -13,7 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { IPeriod } from "../public_types";
 import Period from "./period";
+import { IPeriodMetadata } from "./types";
 import { IUpdatedPeriodResult } from "./update_period_in_place";
 /**
  * Update old periods by adding new periods and removing
@@ -31,17 +33,18 @@ export declare function replacePeriods(oldPeriods: Period[], newPeriods: Period[
  * @returns {Object}
  */
 export declare function updatePeriods(oldPeriods: Period[], newPeriods: Period[]): IPeriodsUpdateResult;
+export type IUpdatePeriodInformation = Pick<IPeriodMetadata, "id" | "start" | "end" | "duration" | "streamEvents">;
 /** Object describing a Manifest update at the Periods level. */
 export interface IPeriodsUpdateResult {
     /** Information on Periods that have been updated. */
     updatedPeriods: Array<{
-        /** The concerned Period. */
-        period: Period;
+        /** The concerned Period's information. */
+        period: IUpdatePeriodInformation;
         /** The updates performed. */
         result: IUpdatedPeriodResult;
     }>;
     /** Periods that have been added. */
-    addedPeriods: Period[];
+    addedPeriods: IPeriodMetadata[];
     /** Periods that have been removed. */
-    removedPeriods: Period[];
+    removedPeriods: IPeriod[];
 }

package/dist/commonjs/manifest/update_periods.js

@@ -44,6 +44,7 @@ exports.updatePeriods = exports.replacePeriods = void 0;
 var errors_1 = require("../errors");
 var log_1 = require("../log");
 var array_find_index_1 = require("../utils/array_find_index");
+var object_assign_1 = require("../utils/object_assign");
 var types_1 = require("./types");
 var update_period_in_place_1 = require("./update_period_in_place");
 /**
@@ -71,13 +72,26 @@ function replacePeriods(oldPeriods, newPeriods) {
         }
         if (oldPeriod != null) {
             var result = (0, update_period_in_place_1.default)(oldPeriod, newPeriod, types_1.MANIFEST_UPDATE_TYPE.Full);
-            res.updatedPeriods.push({ period: oldPeriod, result: result });
+            res.updatedPeriods.push({
+                period: {
+                    id: oldPeriod.id,
+                    start: oldPeriod.start,
+                    end: oldPeriod.end,
+                    duration: oldPeriod.duration,
+                    streamEvents: oldPeriod.streamEvents,
+                },
+                result: result,
+            });
             var periodsToInclude = newPeriods.slice(firstUnhandledPeriodIdx, i);
             var nbrOfPeriodsToRemove = j - firstUnhandledPeriodIdx;
             var removed = oldPeriods.splice.apply(oldPeriods, __spreadArray([firstUnhandledPeriodIdx,
                 nbrOfPeriodsToRemove], __read(periodsToInclude), false));
-            (_a = res.removedPeriods).push.apply(_a, __spreadArray([], __read(removed), false));
-            (_b = res.addedPeriods).push.apply(_b, __spreadArray([], __read(periodsToInclude), false));
+            (_a = res.removedPeriods).push.apply(_a, __spreadArray([], __read(removed.map(function (p) { return ({
+                id: p.id,
+                start: p.start,
+                end: p.end,
+            }); })), false));
+            (_b = res.addedPeriods).push.apply(_b, __spreadArray([], __read(periodsToInclude.map(function (p) { return p.getMetadataSnapshot(); })), false));
             firstUnhandledPeriodIdx = i + 1;
         }
     }
@@ -87,12 +101,16 @@ function replacePeriods(oldPeriods, newPeriods) {
     }
     if (firstUnhandledPeriodIdx < oldPeriods.length) {
         var removed = oldPeriods.splice(firstUnhandledPeriodIdx, oldPeriods.length - firstUnhandledPeriodIdx);
-        (_c = res.removedPeriods).push.apply(_c, __spreadArray([], __read(removed), false));
+        (_c = res.removedPeriods).push.apply(_c, __spreadArray([], __read(removed.map(function (p) { return ({
+            id: p.id,
+            start: p.start,
+            end: p.end,
+        }); })), false));
     }
     var remainingNewPeriods = newPeriods.slice(firstUnhandledPeriodIdx, newPeriods.length);
     if (remainingNewPeriods.length > 0) {
         oldPeriods.push.apply(oldPeriods, __spreadArray([], __read(remainingNewPeriods), false));
-        (_d = res.addedPeriods).push.apply(_d, __spreadArray([], __read(remainingNewPeriods), false));
+        (_d = res.addedPeriods).push.apply(_d, __spreadArray([], __read(remainingNewPeriods.map(function (p) { return p.getMetadataSnapshot(); })), false));
     }
     return res;
 }
@@ -113,7 +131,7 @@ function updatePeriods(oldPeriods, newPeriods) {
     };
     if (oldPeriods.length === 0) {
         oldPeriods.splice.apply(oldPeriods, __spreadArray([0, 0], __read(newPeriods), false));
-        (_a = res.addedPeriods).push.apply(_a, __spreadArray([], __read(newPeriods), false));
+        (_a = res.addedPeriods).push.apply(_a, __spreadArray([], __read(newPeriods.map(function (p) { return p.getMetadataSnapshot(); })), false));
         return res;
     }
     if (newPeriods.length === 0) {
@@ -125,7 +143,7 @@ function updatePeriods(oldPeriods, newPeriods) {
             throw new errors_1.MediaError("MANIFEST_UPDATE_ERROR", "Cannot perform partial update: not enough data");
         }
         oldPeriods.push.apply(oldPeriods, __spreadArray([], __read(newPeriods), false));
-        (_b = res.addedPeriods).push.apply(_b, __spreadArray([], __read(newPeriods), false));
+        (_b = res.addedPeriods).push.apply(_b, __spreadArray([], __read(newPeriods.map(function (p) { return p.getMetadataSnapshot(); })), false));
         return res;
     }
     /** Index, in `oldPeriods` of the first element of `newPeriods` */
@@ -138,8 +156,12 @@ function updatePeriods(oldPeriods, newPeriods) {
     }
     // The first updated Period can only be a partial part
     var updateRes = (0, update_period_in_place_1.default)(oldPeriods[indexOfNewFirstPeriod], newPeriods[0], types_1.MANIFEST_UPDATE_TYPE.Partial);
-    res.updatedPeriods.push({ period: oldPeriods[indexOfNewFirstPeriod],
-        result: updateRes });
+    res.updatedPeriods.push({
+        period: (0, object_assign_1.default)(oldPeriods[indexOfNewFirstPeriod].getMetadataSnapshot(), {
+            adaptations: undefined,
+        }),
+        result: updateRes,
+    });
     // Search each consecutive elements of `newPeriods` - after the initial one already
     // processed - in `oldPeriods`, removing and adding unfound Periods in the process
     var prevIndexOfNewPeriod = indexOfNewFirstPeriod + 1;
@@ -162,27 +184,44 @@ function updatePeriods(oldPeriods, newPeriods) {
             }
             var nbElementsToRemove = toRemoveUntil - prevIndexOfNewPeriod;
             var removed = oldPeriods.splice(prevIndexOfNewPeriod, nbElementsToRemove, newPeriod);
-            res.addedPeriods.push(newPeriod);
-            (_c = res.removedPeriods).push.apply(_c, __spreadArray([], __read(removed), false));
+            res.addedPeriods.push(newPeriod.getMetadataSnapshot());
+            (_c = res.removedPeriods).push.apply(_c, __spreadArray([], __read(removed.map(function (p) { return ({
+                id: p.id,
+                start: p.start,
+                end: p.end,
+            }); })), false));
         }
         else {
             if (indexOfNewPeriod > prevIndexOfNewPeriod) {
                 // Some old periods were not found: remove
                 log_1.default.warn("Manifest: old Periods not found in new when updating, removing");
                 var removed = oldPeriods.splice(prevIndexOfNewPeriod, indexOfNewPeriod - prevIndexOfNewPeriod);
-                (_d = res.removedPeriods).push.apply(_d, __spreadArray([], __read(removed), false));
+                (_d = res.removedPeriods).push.apply(_d, __spreadArray([], __read(removed.map(function (p) { return ({
+                    id: p.id,
+                    start: p.start,
+                    end: p.end,
+                }); })), false));
                 indexOfNewPeriod = prevIndexOfNewPeriod;
             }
             // Later Periods can be fully replaced
             var result = (0, update_period_in_place_1.default)(oldPeriods[indexOfNewPeriod], newPeriod, types_1.MANIFEST_UPDATE_TYPE.Full);
-            res.updatedPeriods.push({ period: oldPeriods[indexOfNewPeriod], result: result });
+            res.updatedPeriods.push({
+                period: (0, object_assign_1.default)(oldPeriods[indexOfNewPeriod].getMetadataSnapshot(), {
+                    adaptations: undefined,
+                }),
+                result: result,
+            });
         }
         prevIndexOfNewPeriod++;
     }
     if (prevIndexOfNewPeriod < oldPeriods.length) {
         log_1.default.warn("Manifest: Ending Periods not found in new when updating, removing");
         var removed = oldPeriods.splice(prevIndexOfNewPeriod, oldPeriods.length - prevIndexOfNewPeriod);
-        (_e = res.removedPeriods).push.apply(_e, __spreadArray([], __read(removed), false));
+        (_e = res.removedPeriods).push.apply(_e, __spreadArray([], __read(removed.map(function (p) { return ({
+            id: p.id,
+            start: p.start,
+            end: p.end,
+        }); })), false));
     }
     return res;
 }