rx-player 4.0.0-dev.2023121900 → 4.0.0-dev.2024022000

package/dist/commonjs/default_config.js

@@ -10,14 +10,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * @type {Object}
  */
 var DEFAULT_CONFIG = {
-    /**
-     * Volume set on unMute if the volume is set to 0 and either:
-     *   - mute has never been called before
-     *   - mute has last been called while the volume was already set to 0 (either
-     *     via setVolume, or a previous mute call)
-     * @type {Number}
-     */
-    DEFAULT_UNMUTED_VOLUME: 0.1,
     /**
      * Default time interval after which a request will timeout, in ms.
      * @type {Number}
@@ -85,9 +77,7 @@ var DEFAULT_CONFIG = {
          * "Other" mainly concern text track, where seeking back could even be
          * annoying, so that behavior has been disabled in that case.
          */
-        trackSwitch: { audio: -0.7,
-            video: -0.1,
-            other: 0 },
+        trackSwitch: { audio: 0, video: 0, other: 0 },
     },
     /**
      * Behavior of the RxPlayer when encountering a whole other codec on a already
@@ -239,32 +229,6 @@ var DEFAULT_CONFIG = {
      * @type {Number}
      */
     BITRATE_REBUFFERING_RATIO: 1.5,
-    /**
-     * Those are used when a "QuotaExceededError" error is received after
-     * appending a new segment in the SourceBuffer.
-     *
-     * This error can arise when the browser's buffer is considered full.
-     * In this case, the player goes into manual garbage collection (GC) mode.
-     * @type {Object}
-     */
-    BUFFER_GC_GAPS: {
-        /**
-         * _Low_ gap (from current position) from which the buffer will be _garbage
-         * collected_ (read removed from the buffer) when a QuotaExceededError is
-         * received.
-         * In seconds.
-         * @type {Number}
-         */
-        CALM: 240,
-        /**
-         * _High_ gap (from current position) from which the buffer will be _garbage
-         * collected_ (read removed from the buffer) when a QuotaExceededError is
-         * received, if the low one does not clean up any buffer.
-         * In seconds.
-         * @type {Number}
-         */
-        BEEFY: 30,
-    },
     /**
      * The default number of times a manifest request will be re-performed
      * when loaded/refreshed if the request finishes on an error which
@@ -341,7 +305,7 @@ var DEFAULT_CONFIG = {
      * Same than SAMPLING_INTERVAL_MEDIASOURCE but for lowLatency mode.
      * @type {Number}
      */
-    SAMPLING_INTERVAL_LOW_LATENCY: 250,
+    SAMPLING_INTERVAL_LOW_LATENCY: 500,
     /**
      * Same than SAMPLING_INTERVAL_MEDIASOURCE but for the directfile API.
      * @type {Number}
@@ -548,6 +512,37 @@ var DEFAULT_CONFIG = {
      * buffers.
      */
     UNFREEZING_DELTA_POSITION: 0.001,
+    /**
+     * The RxPlayer has a recurring logic which will synchronize the browser's
+     * buffers' buffered time ranges with its internal representation in the
+     * RxPlayer to then rely on that internal representation to determine where
+     * segments are technically present in the browser's buffer.
+     *
+     * We found out that when inserting a new segment to the buffer, the browser
+     * may actually take time before actually considering the full segment in its
+     * advertised buffered time ranges.
+     *
+     * This value thus set an amount of milliseconds we might want to wait before
+     * being sure that the buffered time ranges should have considered a segment
+     * that has been pushed.
+     */
+    SEGMENT_SYNCHRONIZATION_DELAY: 1500,
+    /**
+     * The `SEGMENT_SYNCHRONIZATION_DELAY` defined in this same configuration
+     * object only needs to be used if it appears that the current buffered
+     * time ranges do not reflect the full data of a pushed segment yet.
+     *
+     * The `MISSING_DATA_TRIGGER_SYNC_DELAY` value thus allows to define a
+     * minimum time difference in seconds between what's buffered and what the
+     * segment's ranges should have been, from which we might consider that we may
+     * want to wait the `SEGMENT_SYNCHRONIZATION_DELAY` before trusting the buffered
+     * time ranges for that segment.
+     * If what's missing from that segment is however less than that value in
+     * seconds, we can begin to trust the reported buffered time ranges.
+     *
+     * Should generally be inferior to `MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT`.
+     */
+    MISSING_DATA_TRIGGER_SYNC_DELAY: 0.1,
     /**
      * Maximum authorized difference between what we calculated to be the
      * beginning or end of the segment in a media buffer and what we
@@ -682,8 +677,8 @@ var DEFAULT_CONFIG = {
      * @type {Object}
      */
     BUFFER_PADDING: {
-        audio: 1,
-        video: 3,
+        audio: 1, // only "audio" segments
+        video: 3, // only "video" segments
         other: 1, // tracks which are not audio/video (like text).
     },
     /**
@@ -749,12 +744,14 @@ var DEFAULT_CONFIG = {
      *
      * @type {Array.<Number>}
      */
-    SEGMENT_PRIORITIES_STEPS: [2,
-        4,
-        8,
-        12,
-        18,
-        25],
+    SEGMENT_PRIORITIES_STEPS: [
+        2, // 1st Step (priority number = 0):  < 2
+        4, // 2nd Step (priority number = 1):  2-4
+        8, // 3rd Step (priority number = 2):  4-8
+        12, // 4th Step (priority number = 3):  8-12
+        18, // 5th Step (priority number = 4):  12-18
+        25,
+    ], // 6th Step (priority number = 5):  18-25
     // 7th Step (priority number = 6):  >= 25
     /**
      * Some segment requests are said to be "high priority".
@@ -767,7 +764,7 @@ var DEFAULT_CONFIG = {
      * (beginning by the first step, which has the priority number `0`).
      * @type {number}
      */
-    MAX_HIGH_PRIORITY_LEVEL: 1,
+    MAX_HIGH_PRIORITY_LEVEL: 1, // priority number 1 and lower is high priority
     /**
      * Enter here the first priority step (see `SEGMENT_PRIORITIES_STEPS`) that
      * will be considered as low priority.
@@ -780,7 +777,7 @@ var DEFAULT_CONFIG = {
      * `MAX_HIGH_PRIORITY_LEVEL`.
      * @type {number}
      */
-    MIN_CANCELABLE_PRIORITY: 3,
+    MIN_CANCELABLE_PRIORITY: 3, // priority number 3 onward can be cancelled
     /**
      * Codecs used in the videoCapabilities of the MediaKeySystemConfiguration
      * (DRM).
@@ -788,9 +785,11 @@ var DEFAULT_CONFIG = {
      * Defined in order of importance (first will be tested first etc.)
      * @type {Array.<string>}
      */
-    EME_DEFAULT_VIDEO_CODECS: ["video/mp4;codecs=\"avc1.4d401e\"",
-        "video/mp4;codecs=\"avc1.42e01e\"",
-        "video/webm;codecs=\"vp8\""],
+    EME_DEFAULT_VIDEO_CODECS: [
+        'video/mp4;codecs="avc1.4d401e"',
+        'video/mp4;codecs="avc1.42e01e"',
+        'video/webm;codecs="vp8"',
+    ],
     /**
      * Codecs used in the audioCapabilities of the MediaKeySystemConfiguration
      * (DRM).
@@ -798,8 +797,7 @@ var DEFAULT_CONFIG = {
      * Defined in order of importance (first will be tested first etc.)
      * @type {Array.<string>}
      */
-    EME_DEFAULT_AUDIO_CODECS: ["audio/mp4;codecs=\"mp4a.40.2\"",
-        "audio/webm;codecs=opus"],
+    EME_DEFAULT_AUDIO_CODECS: ['audio/mp4;codecs="mp4a.40.2"', "audio/webm;codecs=opus"],
     /**
      * Robustnesses used in the {audio,video}Capabilities of the
      * MediaKeySystemConfiguration (DRM).
@@ -809,11 +807,13 @@ var DEFAULT_CONFIG = {
      * Defined in order of importance (first will be tested first etc.)
      * @type {Array.<string>}
      */
-    EME_DEFAULT_WIDEVINE_ROBUSTNESSES: ["HW_SECURE_ALL",
+    EME_DEFAULT_WIDEVINE_ROBUSTNESSES: [
+        "HW_SECURE_ALL",
         "HW_SECURE_DECODE",
         "HW_SECURE_CRYPTO",
         "SW_SECURE_DECODE",
-        "SW_SECURE_CRYPTO"],
+        "SW_SECURE_CRYPTO",
+    ],
     /**
      * Robustnesses used in the {audio,video}Capabilities of the
      * MediaKeySystemConfiguration (DRM).
@@ -823,8 +823,7 @@ var DEFAULT_CONFIG = {
      * Defined in order of importance (first will be tested first etc.)
      * @type {Array.<string>}
      */
-    EME_DEFAULT_PLAYREADY_RECOMMENDATION_ROBUSTNESSES: ["3000",
-        "2000"],
+    EME_DEFAULT_PLAYREADY_RECOMMENDATION_ROBUSTNESSES: ["3000", "2000"],
     /**
      * Link canonical key systems names to their respective reverse domain name,
      * used in the EME APIs.
@@ -834,13 +833,14 @@ var DEFAULT_CONFIG = {
      */
     /* eslint-disable @typescript-eslint/consistent-type-assertions */
     EME_KEY_SYSTEMS: {
-        clearkey: ["webkit-org.w3.clearkey",
-            "org.w3.clearkey"],
+        clearkey: ["webkit-org.w3.clearkey", "org.w3.clearkey"],
         widevine: ["com.widevine.alpha"],
-        playready: ["com.microsoft.playready.recommendation",
+        playready: [
+            "com.microsoft.playready.recommendation",
             "com.microsoft.playready",
             "com.chromecast.playready",
-            "com.youtube.playready"],
+            "com.youtube.playready",
+        ],
         fairplay: ["com.apple.fps.1_0"],
     },
     /* eslint-enable @typescript-eslint/consistent-type-assertions */

package/dist/commonjs/errors/encrypted_media_error.d.ts

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IEncryptedMediaErrorKeyStatusObject } from "../public_types";
-import { IEncryptedMediaErrorCode } from "./error_codes";
+import type { IEncryptedMediaErrorKeyStatusObject } from "../public_types";
+import type { IEncryptedMediaErrorCode } from "./error_codes";
 /**
  * Error linked to the encryption of the media.
  *
@@ -28,6 +28,7 @@ export default class EncryptedMediaError extends Error {
     readonly keyStatuses?: IEncryptedMediaErrorKeyStatusObject[];
     message: string;
     fatal: boolean;
+    private _originalMessage;
     /**
      * @param {string} code
      * @param {string} reason
@@ -36,4 +37,20 @@ export default class EncryptedMediaError extends Error {
         keyStatuses: IEncryptedMediaErrorKeyStatusObject[];
     });
     constructor(code: Omit<IEncryptedMediaErrorCode, "KEY_STATUS_CHANGE_ERROR">, reason: string);
+    /**
+     * If that error has to be communicated through another thread, this method
+     * allows to obtain its main defining properties in an Object so the Error can
+     * be reconstructed in the other thread.
+     * @returns {Object}
+     */
+    serialize(): ISerializedEncryptedMediaError;
+}
+export interface ISerializedEncryptedMediaError {
+    name: "EncryptedMediaError";
+    code: IEncryptedMediaErrorCode;
+    reason: string;
+    keyStatuses: Array<{
+        keyStatus: MediaKeyStatus;
+        keyId: ArrayBuffer;
+    }> | undefined;
 }

package/dist/commonjs/errors/encrypted_media_error.js

@@ -47,6 +47,7 @@ var EncryptedMediaError = /** @class */ (function (_super) {
         _this.name = "EncryptedMediaError";
         _this.type = error_codes_1.ErrorTypes.ENCRYPTED_MEDIA_ERROR;
         _this.code = code;
+        _this._originalMessage = reason;
         _this.message = (0, error_message_1.default)(_this.code, reason);
         _this.fatal = false;
         if (typeof (supplementaryInfos === null || supplementaryInfos === void 0 ? void 0 : supplementaryInfos.keyStatuses) === "string") {
@@ -54,6 +55,20 @@ var EncryptedMediaError = /** @class */ (function (_super) {
         }
         return _this;
     }
+    /**
+     * If that error has to be communicated through another thread, this method
+     * allows to obtain its main defining properties in an Object so the Error can
+     * be reconstructed in the other thread.
+     * @returns {Object}
+     */
+    EncryptedMediaError.prototype.serialize = function () {
+        return {
+            name: this.name,
+            code: this.code,
+            reason: this._originalMessage,
+            keyStatuses: this.keyStatuses,
+        };
+    };
     return EncryptedMediaError;
 }(Error));
 exports.default = EncryptedMediaError;

package/dist/commonjs/errors/error_codes.d.ts

@@ -13,19 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { IRequestErrorType } from "../utils/request";
 export type IErrorType = "NETWORK_ERROR" | "MEDIA_ERROR" | "ENCRYPTED_MEDIA_ERROR" | "OTHER_ERROR";
 export type IEncryptedMediaErrorCode = "INCOMPATIBLE_KEYSYSTEMS" | "INVALID_ENCRYPTED_EVENT" | "INVALID_KEY_SYSTEM" | "KEY_ERROR" | "KEY_GENERATE_REQUEST_ERROR" | "KEY_LOAD_ERROR" | "KEY_LOAD_TIMEOUT" | "KEY_STATUS_CHANGE_ERROR" | "KEY_UPDATE_ERROR" | "CREATE_MEDIA_KEYS_ERROR" | "LICENSE_SERVER_CERTIFICATE_ERROR" | "MEDIA_IS_ENCRYPTED_ERROR" | "MULTIPLE_SESSIONS_SAME_INIT_DATA";
 export type IMediaErrorCode = "BUFFER_APPEND_ERROR" | "BUFFER_FULL_ERROR" | "BUFFER_TYPE_UNKNOWN" | "MANIFEST_INCOMPATIBLE_CODECS_ERROR" | "MANIFEST_PARSE_ERROR" | "MANIFEST_UPDATE_ERROR" | "MANIFEST_UNSUPPORTED_ADAPTATION_TYPE" | "MEDIA_ERR_ABORTED" | "MEDIA_ERR_BLOCKED_AUTOPLAY" | "MEDIA_ERR_PLAY_NOT_ALLOWED" | "MEDIA_ERR_NOT_LOADED_METADATA" | "MEDIA_ERR_DECODE" | "MEDIA_ERR_NETWORK" | "MEDIA_ERR_SRC_NOT_SUPPORTED" | "MEDIA_ERR_UNKNOWN" | "MEDIA_KEYS_NOT_SUPPORTED" | "MEDIA_SOURCE_NOT_SUPPORTED" | "MEDIA_STARTING_TIME_NOT_FOUND" | "MEDIA_TIME_BEFORE_MANIFEST" | "MEDIA_TIME_AFTER_MANIFEST" | "MEDIA_TIME_NOT_FOUND" | "NO_PLAYABLE_REPRESENTATION" | "DISCONTINUITY_ENCOUNTERED";
 export type INetworkErrorCode = "PIPELINE_LOAD_ERROR";
+export type INetworkErrorType = IRequestErrorType;
+export declare const NetworkErrorTypes: Record<IRequestErrorType, IRequestErrorType>;
 export type IOtherErrorCode = "PIPELINE_LOAD_ERROR" | "PIPELINE_PARSE_ERROR" | "INTEGRITY_ERROR" | "NONE";
 export type IErrorCode = INetworkErrorCode | IMediaErrorCode | IEncryptedMediaErrorCode | IOtherErrorCode;
-export type INetworkErrorType = "TIMEOUT" | "ERROR_EVENT" | "PARSE_ERROR" | "ERROR_HTTP_CODE";
 declare const ErrorTypes: {
     readonly NETWORK_ERROR: "NETWORK_ERROR";
     readonly MEDIA_ERROR: "MEDIA_ERROR";
     readonly ENCRYPTED_MEDIA_ERROR: "ENCRYPTED_MEDIA_ERROR";
     readonly OTHER_ERROR: "OTHER_ERROR";
 };
-declare const NetworkErrorTypes: Record<INetworkErrorType, INetworkErrorType>;
 declare const ErrorCodes: Record<IErrorCode, IErrorCode>;
-export { ErrorTypes, NetworkErrorTypes, ErrorCodes, };
+export { ErrorTypes, ErrorCodes };

package/dist/commonjs/errors/error_codes.js

@@ -15,7 +15,9 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorCodes = exports.NetworkErrorTypes = exports.ErrorTypes = void 0;
+exports.ErrorCodes = exports.ErrorTypes = exports.NetworkErrorTypes = void 0;
+var request_1 = require("../utils/request");
+exports.NetworkErrorTypes = request_1.RequestErrorTypes;
 var ErrorTypes = {
     NETWORK_ERROR: "NETWORK_ERROR",
     MEDIA_ERROR: "MEDIA_ERROR",
@@ -23,13 +25,6 @@ var ErrorTypes = {
     OTHER_ERROR: "OTHER_ERROR",
 };
 exports.ErrorTypes = ErrorTypes;
-var NetworkErrorTypes = {
-    TIMEOUT: "TIMEOUT",
-    ERROR_EVENT: "ERROR_EVENT",
-    ERROR_HTTP_CODE: "ERROR_HTTP_CODE",
-    PARSE_ERROR: "PARSE_ERROR",
-};
-exports.NetworkErrorTypes = NetworkErrorTypes;
 var ErrorCodes = {
     PIPELINE_LOAD_ERROR: "PIPELINE_LOAD_ERROR",
     PIPELINE_PARSE_ERROR: "PIPELINE_PARSE_ERROR",

package/dist/commonjs/errors/format_error.d.ts

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IPlayerError } from "../public_types";
-export default function formatError(error: unknown, { defaultCode, defaultReason }: {
+import type { IPlayerError } from "../public_types";
+export default function formatError(error: unknown, { defaultCode, defaultReason, }: {
     defaultCode: "PIPELINE_LOAD_ERROR" | "PIPELINE_PARSE_ERROR" | "NONE";
     defaultReason: string;
 }): IPlayerError;

package/dist/commonjs/errors/format_error.js

@@ -27,8 +27,7 @@ function formatError(error, _a) {
     if ((0, is_known_error_1.default)(error)) {
         return error;
     }
-    var reason = error instanceof Error ? error.toString() :
-        defaultReason;
+    var reason = error instanceof Error ? error.toString() : defaultReason;
     return new other_error_1.default(defaultCode, reason);
 }
 exports.default = formatError;

package/dist/commonjs/errors/index.d.ts

@@ -13,14 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import AssertionError from "./assertion_error";
 import CustomLoaderError from "./custom_loader_error";
-import EncryptedMediaError from "./encrypted_media_error";
-import { ErrorCodes, ErrorTypes, IErrorCode, IErrorType, NetworkErrorTypes } from "./error_codes";
+import EncryptedMediaError, { ISerializedEncryptedMediaError } from "./encrypted_media_error";
+import { ErrorCodes, ErrorTypes, IErrorCode, IErrorType, INetworkErrorType, NetworkErrorTypes } from "./error_codes";
 import formatError from "./format_error";
 import isKnownError from "./is_known_error";
-import MediaError, { IMediaErrorTrackContext } from "./media_error";
-import NetworkError from "./network_error";
-import OtherError from "./other_error";
-import RequestError from "./request_error";
-export { AssertionError, CustomLoaderError, EncryptedMediaError, ErrorCodes, ErrorTypes, IErrorCode, IErrorType, IMediaErrorTrackContext, formatError, MediaError as MediaError, NetworkError, OtherError, RequestError, NetworkErrorTypes, isKnownError, };
+import MediaError, { ISerializedMediaError } from "./media_error";
+import NetworkError, { ISerializedNetworkError } from "./network_error";
+import OtherError, { ISerializedOtherError } from "./other_error";
+import SourceBufferError from "./source_buffer_error";
+export { CustomLoaderError, EncryptedMediaError, SourceBufferError, ErrorCodes, ErrorTypes, IErrorCode, IErrorType, formatError, MediaError as MediaError, NetworkError, OtherError, INetworkErrorType, NetworkErrorTypes, isKnownError, ISerializedMediaError, ISerializedNetworkError, ISerializedEncryptedMediaError, ISerializedOtherError, };

package/dist/commonjs/errors/index.js

@@ -15,9 +15,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isKnownError = exports.NetworkErrorTypes = exports.RequestError = exports.OtherError = exports.NetworkError = exports.MediaError = exports.formatError = exports.ErrorTypes = exports.ErrorCodes = exports.EncryptedMediaError = exports.CustomLoaderError = exports.AssertionError = void 0;
-var assertion_error_1 = require("./assertion_error");
-exports.AssertionError = assertion_error_1.default;
+exports.isKnownError = exports.NetworkErrorTypes = exports.OtherError = exports.NetworkError = exports.MediaError = exports.formatError = exports.ErrorTypes = exports.ErrorCodes = exports.SourceBufferError = exports.EncryptedMediaError = exports.CustomLoaderError = void 0;
 var custom_loader_error_1 = require("./custom_loader_error");
 exports.CustomLoaderError = custom_loader_error_1.default;
 var encrypted_media_error_1 = require("./encrypted_media_error");
@@ -36,5 +34,5 @@ var network_error_1 = require("./network_error");
 exports.NetworkError = network_error_1.default;
 var other_error_1 = require("./other_error");
 exports.OtherError = other_error_1.default;
-var request_error_1 = require("./request_error");
-exports.RequestError = request_error_1.default;
+var source_buffer_error_1 = require("./source_buffer_error");
+exports.SourceBufferError = source_buffer_error_1.default;

package/dist/commonjs/errors/is_known_error.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IPlayerError } from "../public_types";
+import type { IPlayerError } from "../public_types";
 /**
  * Whether the error given is a ICustomError.
  * @param {Error} error

package/dist/commonjs/errors/is_known_error.js

@@ -26,10 +26,10 @@ var other_error_1 = require("./other_error");
  * @returns {Boolean}
  */
 function isKnownError(error) {
-    return (error instanceof encrypted_media_error_1.default ||
+    return ((error instanceof encrypted_media_error_1.default ||
         error instanceof media_error_1.default ||
         error instanceof other_error_1.default ||
         error instanceof network_error_1.default) &&
-        Object.keys(error_codes_1.ErrorTypes).indexOf(error.type) >= 0;
+        Object.keys(error_codes_1.ErrorTypes).indexOf(error.type) >= 0);
 }
 exports.default = isKnownError;

package/dist/commonjs/errors/media_error.d.ts

@@ -13,22 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Adaptation } from "../manifest";
-import { IAudioTrack, ITextTrack, IVideoTrack } from "../public_types";
-import { IMediaErrorCode } from "./error_codes";
-interface IAudioTrackMediaErrorContext {
-    type: "audio";
-    track: IAudioTrack;
-}
-interface IVideoTrackMediaErrorContext {
-    type: "video";
-    track: IVideoTrack;
-}
-interface ITextTrackMediaErrorContext {
-    type: "text";
-    track: ITextTrack;
-}
-export type IMediaErrorTrackContext = IAudioTrackMediaErrorContext | IVideoTrackMediaErrorContext | ITextTrackMediaErrorContext;
+import type { ITaggedTrack } from "../manifest";
+import type { IMediaErrorCode } from "./error_codes";
 type ICodeWithAdaptationType = "BUFFER_APPEND_ERROR" | "BUFFER_FULL_ERROR" | "NO_PLAYABLE_REPRESENTATION" | "MANIFEST_INCOMPATIBLE_CODECS_ERROR";
 /**
  * Error linked to the media Playback.
@@ -41,16 +27,33 @@ export default class MediaError extends Error {
     readonly type: "MEDIA_ERROR";
     readonly message: string;
     readonly code: IMediaErrorCode;
-    readonly tracksInfo: IMediaErrorTrackContext[] | undefined;
+    readonly tracksInfo: ITaggedTrack[] | undefined;
     fatal: boolean;
+    private _originalMessage;
     /**
      * @param {string} code
      * @param {string} reason
      * @param {Object|undefined} [context]
      */
     constructor(code: ICodeWithAdaptationType, reason: string, context: {
-        adaptations: Adaptation[] | undefined;
+        tracks: ITaggedTrack[] | undefined;
     });
-    constructor(code: Exclude<IMediaErrorCode, ICodeWithAdaptationType>, reason: string);
+    constructor(code: Exclude<IMediaErrorCode, ICodeWithAdaptationType>, reason: string, context?: {
+        tracks?: undefined;
+    } | undefined);
+    /**
+     * If that error has to be communicated through another thread, this method
+     * allows to obtain its main defining properties in an Object so the Error can
+     * be reconstructed in the other thread.
+     * @returns {Object}
+     */
+    serialize(): ISerializedMediaError;
+}
+/** Serializable object which allows to create a `MediaError` later. */
+export interface ISerializedMediaError {
+    name: "MediaError";
+    code: IMediaErrorCode;
+    reason: string;
+    tracks: ITaggedTrack[] | undefined;
 }
 export {};

package/dist/commonjs/errors/media_error.js

@@ -46,31 +46,29 @@ var MediaError = /** @class */ (function (_super) {
         Object.setPrototypeOf(_this, MediaError.prototype);
         _this.name = "MediaError";
         _this.type = error_codes_1.ErrorTypes.MEDIA_ERROR;
+        _this._originalMessage = reason;
         _this.code = code;
         _this.message = (0, error_message_1.default)(_this.code, reason);
         _this.fatal = false;
-        var adaptations = context === null || context === void 0 ? void 0 : context.adaptations;
-        if (adaptations !== undefined && adaptations.length > 0) {
-            _this.tracksInfo = adaptations.reduce(function (acc, adaptation) {
-                switch (adaptation.type) {
-                    case "audio":
-                        acc.push({ type: "audio",
-                            track: adaptation.toAudioTrack(false) });
-                        break;
-                    case "video":
-                        acc.push({ type: "video",
-                            track: adaptation.toVideoTrack(false) });
-                        break;
-                    case "text":
-                        acc.push({ type: "text",
-                            track: adaptation.toTextTrack() });
-                        break;
-                }
-                return acc;
-            }, []);
+        if ((context === null || context === void 0 ? void 0 : context.tracks) !== undefined && (context === null || context === void 0 ? void 0 : context.tracks.length) > 0) {
+            _this.tracksInfo = context.tracks;
         }
         return _this;
     }
+    /**
+     * If that error has to be communicated through another thread, this method
+     * allows to obtain its main defining properties in an Object so the Error can
+     * be reconstructed in the other thread.
+     * @returns {Object}
+     */
+    MediaError.prototype.serialize = function () {
+        return {
+            name: this.name,
+            code: this.code,
+            reason: this._originalMessage,
+            tracks: this.tracksInfo,
+        };
+    };
     return MediaError;
 }(Error));
 exports.default = MediaError;

package/dist/commonjs/errors/network_error.d.ts

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { INetworkErrorCode, INetworkErrorType } from "./error_codes";
-import RequestError from "./request_error";
+import type { RequestError, ISerializedRequestError } from "../utils/request";
+import type { INetworkErrorCode, INetworkErrorType } from "./error_codes";
 /**
  * Error linked to network interactions (requests).
  *
@@ -30,6 +30,7 @@ export default class NetworkError extends Error {
     readonly status: number;
     readonly errorType: INetworkErrorType;
     fatal: boolean;
+    private _baseError;
     /**
      * @param {string} code
      * @param {Error} baseError
@@ -41,4 +42,17 @@ export default class NetworkError extends Error {
      * @returns {Boolean}
      */
     isHttpError(httpErrorCode: number): boolean;
+    /**
+     * If that error has to be communicated through another thread, this method
+     * allows to obtain its main defining properties in an Object so the Error can
+     * be reconstructed in the other thread.
+     * @returns {Object}
+     */
+    serialize(): ISerializedNetworkError;
+}
+/** Serializable object which allows to create a `NetworkError` later. */
+export interface ISerializedNetworkError {
+    name: "NetworkError";
+    code: INetworkErrorCode;
+    baseError: ISerializedRequestError;
 }

package/dist/commonjs/errors/network_error.js

@@ -53,6 +53,7 @@ var NetworkError = /** @class */ (function (_super) {
         _this.url = baseError.url;
         _this.status = baseError.status;
         _this.errorType = baseError.type;
+        _this._baseError = baseError;
         _this.code = code;
         _this.message = (0, error_message_1.default)(_this.code, baseError.message);
         _this.fatal = false;
@@ -64,8 +65,21 @@ var NetworkError = /** @class */ (function (_super) {
      * @returns {Boolean}
      */
     NetworkError.prototype.isHttpError = function (httpErrorCode) {
-        return this.errorType === error_codes_1.NetworkErrorTypes.ERROR_HTTP_CODE &&
-            this.status === httpErrorCode;
+        return (this.errorType === error_codes_1.NetworkErrorTypes.ERROR_HTTP_CODE &&
+            this.status === httpErrorCode);
+    };
+    /**
+     * If that error has to be communicated through another thread, this method
+     * allows to obtain its main defining properties in an Object so the Error can
+     * be reconstructed in the other thread.
+     * @returns {Object}
+     */
+    NetworkError.prototype.serialize = function () {
+        return {
+            name: this.name,
+            code: this.code,
+            baseError: this._baseError.serialize(),
+        };
     };
     return NetworkError;
 }(Error));

package/dist/commonjs/errors/other_error.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IOtherErrorCode } from "./error_codes";
+import type { IOtherErrorCode } from "./error_codes";
 /**
  * @class OtherError
  * @extends Error
@@ -24,9 +24,23 @@ export default class OtherError extends Error {
     readonly message: string;
     readonly code: IOtherErrorCode;
     fatal: boolean;
+    private _originalMessage;
     /**
      * @param {string} code
      * @param {string} reason
      */
     constructor(code: IOtherErrorCode, reason: string);
+    /**
+     * If that error has to be communicated through another thread, this method
+     * allows to obtain its main defining properties in an Object so the Error can
+     * be reconstructed in the other thread.
+     * @returns {Object}
+     */
+    serialize(): ISerializedOtherError;
+}
+/** Serializable object which allows to create an `OtherError` later. */
+export interface ISerializedOtherError {
+    name: "OtherError";
+    code: IOtherErrorCode;
+    reason: string;
 }