rx-player 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/_esm5.processed/core/segment_buffers/implementations/text/html/html_text_segment_buffer.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,31 +14,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-import { events, onHeightWidthChange, } from "../../../../../compat";
-import config from "../../../../../config";
-import log from "../../../../../log";
-import TaskCanceller from "../../../../../utils/task_canceller";
-import { SegmentBuffer, } from "../../types";
-import ManualTimeRanges from "../../utils/manual_time_ranges";
-import parseTextTrackToElements from "./parsers";
-import TextTrackCuesStore from "./text_track_cues_store";
-import updateProportionalElements from "./update_proportional_elements";
-var onEnded = events.onEnded, onSeeked = events.onSeeked, onSeeking = events.onSeeking;
+Object.defineProperty(exports, "__esModule", { value: true });
+const compat_1 = require("../../../../../compat");
+const config_1 = require("../../../../../config");
+const log_1 = require("../../../../../log");
+const task_canceller_1 = require("../../../../../utils/task_canceller");
+const types_1 = require("../../types");
+const manual_time_ranges_1 = require("../../utils/manual_time_ranges");
+const parsers_1 = require("./parsers");
+const text_track_cues_store_1 = require("./text_track_cues_store");
+const update_proportional_elements_1 = require("./update_proportional_elements");
+const { onEnded, onSeeked, onSeeking } = compat_1.events;
 /**
  * @param {Element} element
  * @param {Element} child
@@ -47,7 +34,7 @@ function safelyRemoveChild(element, child) {
         element.removeChild(child);
     }
     catch (_error) {
-        log.warn("HTSB: Can't remove text track: not in the element.");
+        log_1.default.warn("HTSB: Can't remove text track: not in the element.");
     }
 }
 /**
@@ -55,62 +42,59 @@ function safelyRemoveChild(element, child) {
  * @returns {Object|null}
  */
 function getElementResolution(element) {
-    var strRows = element.getAttribute("data-resolution-rows");
-    var strColumns = element.getAttribute("data-resolution-columns");
+    const strRows = element.getAttribute("data-resolution-rows");
+    const strColumns = element.getAttribute("data-resolution-columns");
     if (strRows === null || strColumns === null) {
         return null;
     }
-    var rows = parseInt(strRows, 10);
-    var columns = parseInt(strColumns, 10);
+    const rows = parseInt(strRows, 10);
+    const columns = parseInt(strColumns, 10);
     if (rows === null || columns === null) {
         return null;
     }
-    return { rows: rows, columns: columns };
+    return { rows, columns };
 }
 /**
  * SegmentBuffer implementation which display buffered TextTracks in the given
  * HTML element.
  * @class HTMLTextSegmentBuffer
  */
-var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
-    __extends(HTMLTextSegmentBuffer, _super);
+class HTMLTextSegmentBuffer extends types_1.SegmentBuffer {
     /**
      * @param {HTMLMediaElement} videoElement
      * @param {HTMLElement} textTrackElement
      */
-    function HTMLTextSegmentBuffer(videoElement, textTrackElement) {
-        var _this = this;
-        log.debug("HTSB: Creating HTMLTextSegmentBuffer");
-        _this = _super.call(this) || this;
-        _this.bufferType = "text";
-        _this._buffered = new ManualTimeRanges();
-        _this._videoElement = videoElement;
-        _this._textTrackElement = textTrackElement;
-        _this._sizeUpdateCanceller = new TaskCanceller();
-        _this._canceller = new TaskCanceller();
-        _this._buffer = new TextTrackCuesStore();
-        _this._currentCues = [];
-        _this.autoRefreshSubtitles(_this._canceller.signal);
-        return _this;
+    constructor(videoElement, textTrackElement) {
+        log_1.default.debug("HTSB: Creating HTMLTextSegmentBuffer");
+        super();
+        this.bufferType = "text";
+        this._buffered = new manual_time_ranges_1.default();
+        this._videoElement = videoElement;
+        this._textTrackElement = textTrackElement;
+        this._sizeUpdateCanceller = new task_canceller_1.default();
+        this._canceller = new task_canceller_1.default();
+        this._buffer = new text_track_cues_store_1.default();
+        this._currentCues = [];
+        this.autoRefreshSubtitles(this._canceller.signal);
     }
     /**
      * @param {string} uniqueId
      */
-    HTMLTextSegmentBuffer.prototype.declareInitSegment = function (uniqueId) {
-        log.warn("ISB: Declaring initialization segment for image SegmentBuffer", uniqueId);
-    };
+    declareInitSegment(uniqueId) {
+        log_1.default.warn("ISB: Declaring initialization segment for image SegmentBuffer", uniqueId);
+    }
     /**
      * @param {string} uniqueId
      */
-    HTMLTextSegmentBuffer.prototype.freeInitSegment = function (uniqueId) {
-        log.warn("ISB: Freeing initialization segment for image SegmentBuffer", uniqueId);
-    };
+    freeInitSegment(uniqueId) {
+        log_1.default.warn("ISB: Freeing initialization segment for image SegmentBuffer", uniqueId);
+    }
     /**
      * Push text segment to the HTMLTextSegmentBuffer.
      * @param {Object} infos
      * @returns {Promise}
      */
-    HTMLTextSegmentBuffer.prototype.pushChunk = function (infos) {
+    pushChunk(infos) {
         try {
             this.pushChunkSync(infos);
         }
@@ -118,39 +102,39 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
             return Promise.reject(err);
         }
         return Promise.resolve();
-    };
+    }
     /**
      * Remove buffered data.
      * @param {number} start - start position, in seconds
      * @param {number} end - end position, in seconds
      * @returns {Promise}
      */
-    HTMLTextSegmentBuffer.prototype.removeBuffer = function (start, end) {
+    removeBuffer(start, end) {
         this.removeBufferSync(start, end);
         return Promise.resolve();
-    };
+    }
     /**
      * @param {Object} infos
      * @returns {Promise}
      */
-    HTMLTextSegmentBuffer.prototype.endOfSegment = function (infos) {
+    endOfSegment(infos) {
         this._segmentInventory.completeSegment(infos, this._buffered);
         return Promise.resolve();
-    };
+    }
     /**
      * Returns the currently buffered data, in a TimeRanges object.
      * @returns {TimeRanges}
      */
-    HTMLTextSegmentBuffer.prototype.getBufferedRanges = function () {
+    getBufferedRanges() {
         return this._buffered;
-    };
-    HTMLTextSegmentBuffer.prototype.dispose = function () {
-        log.debug("HTSB: Disposing HTMLTextSegmentBuffer");
+    }
+    dispose() {
+        log_1.default.debug("HTSB: Disposing HTMLTextSegmentBuffer");
         this._disableCurrentCues();
         this._buffer.remove(0, Infinity);
         this._buffered.remove(0, Infinity);
         this._canceller.cancel();
-    };
+    }
     /**
      * Push the text track contained in `data` to the HTMLTextSegmentBuffer
      * synchronously.
@@ -166,21 +150,21 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
      * @param {Object} infos
      * @returns {boolean}
      */
-    HTMLTextSegmentBuffer.prototype.pushChunkSync = function (infos) {
+    pushChunkSync(infos) {
         var _a, _b;
-        log.debug("HTSB: Appending new html text tracks");
-        var _c = infos.data, timestampOffset = _c.timestampOffset, appendWindow = _c.appendWindow, chunk = _c.chunk;
+        log_1.default.debug("HTSB: Appending new html text tracks");
+        const { timestampOffset, appendWindow, chunk } = infos.data;
         if (chunk === null) {
             return;
         }
         assertChunkIsTextTrackSegmentData(chunk);
-        var startTime = chunk.start, endTime = chunk.end, dataString = chunk.data, type = chunk.type, language = chunk.language;
-        var appendWindowStart = (_a = appendWindow[0]) !== null && _a !== void 0 ? _a : 0;
-        var appendWindowEnd = (_b = appendWindow[1]) !== null && _b !== void 0 ? _b : Infinity;
-        var cues = parseTextTrackToElements(type, dataString, timestampOffset, language);
+        const { start: startTime, end: endTime, data: dataString, type, language } = chunk;
+        const appendWindowStart = (_a = appendWindow[0]) !== null && _a !== void 0 ? _a : 0;
+        const appendWindowEnd = (_b = appendWindow[1]) !== null && _b !== void 0 ? _b : Infinity;
+        const cues = (0, parsers_1.default)(type, dataString, timestampOffset, language);
         if (appendWindowStart !== 0 && appendWindowEnd !== Infinity) {
             // Removing before window start
-            var i = 0;
+            let i = 0;
             while (i < cues.length && cues[i].end <= appendWindowStart) {
                 i++;
             }
@@ -202,32 +186,32 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
                 i--;
             }
         }
-        var start;
+        let start;
         if (startTime !== undefined) {
             start = Math.max(appendWindowStart, startTime);
         }
         else {
             if (cues.length <= 0) {
-                log.warn("HTSB: Current text tracks have no cues nor start time. Aborting");
+                log_1.default.warn("HTSB: Current text tracks have no cues nor start time. Aborting");
                 return;
             }
-            log.warn("HTSB: No start time given. Guessing from cues.");
+            log_1.default.warn("HTSB: No start time given. Guessing from cues.");
             start = cues[0].start;
         }
-        var end;
+        let end;
         if (endTime !== undefined) {
             end = Math.min(appendWindowEnd, endTime);
         }
         else {
             if (cues.length <= 0) {
-                log.warn("HTSB: Current text tracks have no cues nor end time. Aborting");
+                log_1.default.warn("HTSB: Current text tracks have no cues nor end time. Aborting");
                 return;
             }
-            log.warn("HTSB: No end time given. Guessing from cues.");
+            log_1.default.warn("HTSB: No end time given. Guessing from cues.");
             end = cues[cues.length - 1].end;
         }
         if (end <= start) {
-            log.warn("HTSB: Invalid text track appended: ", "the start time is inferior or equal to the end time.");
+            log_1.default.warn("HTSB: Invalid text track appended: ", "the start time is inferior or equal to the end time.");
             return;
         }
         if (infos.inventoryInfos !== null) {
@@ -235,92 +219,90 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
         }
         this._buffer.insert(cues, start, end);
         this._buffered.insert(start, end);
-    };
+    }
     /**
      * Remove buffer data between the given start and end, synchronously.
      * @param {number} start
      * @param {number} end
      */
-    HTMLTextSegmentBuffer.prototype.removeBufferSync = function (start, end) {
-        log.debug("HTSB: Removing html text track data", start, end);
+    removeBufferSync(start, end) {
+        log_1.default.debug("HTSB: Removing html text track data", start, end);
         this._buffer.remove(start, end);
         this._buffered.remove(start, end);
-    };
+    }
     /**
      * Remove the current cue from being displayed.
      */
-    HTMLTextSegmentBuffer.prototype._disableCurrentCues = function () {
+    _disableCurrentCues() {
         this._sizeUpdateCanceller.cancel();
         if (this._currentCues.length > 0) {
-            for (var i = 0; i < this._currentCues.length; i++) {
+            for (let i = 0; i < this._currentCues.length; i++) {
                 safelyRemoveChild(this._textTrackElement, this._currentCues[i].element);
             }
             this._currentCues = [];
         }
-    };
+    }
     /**
      * Display a new Cue. If one was already present, it will be replaced.
      * @param {HTMLElement} elements
      */
-    HTMLTextSegmentBuffer.prototype._displayCues = function (elements) {
-        var nothingChanged = this._currentCues.length === elements.length &&
-            this._currentCues.every(function (current, index) { return current.element === elements[index]; });
+    _displayCues(elements) {
+        const nothingChanged = this._currentCues.length === elements.length &&
+            this._currentCues.every((current, index) => current.element === elements[index]);
         if (nothingChanged) {
             return;
         }
         // Remove and re-display everything
         // TODO More intelligent handling
         this._sizeUpdateCanceller.cancel();
-        for (var i = 0; i < this._currentCues.length; i++) {
+        for (let i = 0; i < this._currentCues.length; i++) {
             safelyRemoveChild(this._textTrackElement, this._currentCues[i].element);
         }
         this._currentCues = [];
-        for (var i = 0; i < elements.length; i++) {
-            var element = elements[i];
-            var resolution = getElementResolution(element);
-            this._currentCues.push({ element: element, resolution: resolution });
+        for (let i = 0; i < elements.length; i++) {
+            const element = elements[i];
+            const resolution = getElementResolution(element);
+            this._currentCues.push({ element, resolution });
             this._textTrackElement.appendChild(element);
         }
-        var proportionalCues = this._currentCues
-            .filter(function (cue) { return cue.resolution !== null; });
+        const proportionalCues = this._currentCues
+            .filter((cue) => cue.resolution !== null);
         if (proportionalCues.length > 0) {
-            this._sizeUpdateCanceller = new TaskCanceller();
+            this._sizeUpdateCanceller = new task_canceller_1.default();
             this._sizeUpdateCanceller.linkToSignal(this._canceller.signal);
-            var TEXT_TRACK_SIZE_CHECKS_INTERVAL = config.getCurrent().TEXT_TRACK_SIZE_CHECKS_INTERVAL;
+            const { TEXT_TRACK_SIZE_CHECKS_INTERVAL } = config_1.default.getCurrent();
             // update propertionally-sized elements periodically
-            var heightWidthRef = onHeightWidthChange(this._textTrackElement, TEXT_TRACK_SIZE_CHECKS_INTERVAL, this._sizeUpdateCanceller.signal);
-            heightWidthRef.onUpdate(function (_a) {
-                var height = _a.height, width = _a.width;
-                for (var i = 0; i < proportionalCues.length; i++) {
-                    var _b = proportionalCues[i], resolution = _b.resolution, element = _b.element;
-                    updateProportionalElements(height, width, resolution, element);
+            const heightWidthRef = (0, compat_1.onHeightWidthChange)(this._textTrackElement, TEXT_TRACK_SIZE_CHECKS_INTERVAL, this._sizeUpdateCanceller.signal);
+            heightWidthRef.onUpdate(({ height, width }) => {
+                for (let i = 0; i < proportionalCues.length; i++) {
+                    const { resolution, element } = proportionalCues[i];
+                    (0, update_proportional_elements_1.default)(height, width, resolution, element);
                 }
             }, { clearSignal: this._sizeUpdateCanceller.signal,
                 emitCurrentValue: true });
         }
-    };
+    }
     /**
      * Auto-refresh the display of subtitles according to the media element's
      * position and events.
      * @param {Object} cancellationSignal
      */
-    HTMLTextSegmentBuffer.prototype.autoRefreshSubtitles = function (cancellationSignal) {
-        var _this = this;
-        var autoRefreshCanceller = null;
-        var MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL = config.getCurrent().MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL;
-        var startAutoRefresh = function () {
+    autoRefreshSubtitles(cancellationSignal) {
+        let autoRefreshCanceller = null;
+        const { MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL } = config_1.default.getCurrent();
+        const startAutoRefresh = () => {
             stopAutoRefresh();
-            autoRefreshCanceller = new TaskCanceller();
+            autoRefreshCanceller = new task_canceller_1.default();
             autoRefreshCanceller.linkToSignal(cancellationSignal);
-            var intervalId = setInterval(function () { return _this.refreshSubtitles(); }, MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL);
-            autoRefreshCanceller.signal.register(function () {
+            const intervalId = setInterval(() => this.refreshSubtitles(), MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL);
+            autoRefreshCanceller.signal.register(() => {
                 clearInterval(intervalId);
             });
-            _this.refreshSubtitles();
+            this.refreshSubtitles();
         };
-        onSeeking(this._videoElement, function () {
+        onSeeking(this._videoElement, () => {
             stopAutoRefresh();
-            _this._disableCurrentCues();
+            this._disableCurrentCues();
         }, cancellationSignal);
         onSeeked(this._videoElement, startAutoRefresh, cancellationSignal);
         onEnded(this._videoElement, startAutoRefresh, cancellationSignal);
@@ -331,14 +313,14 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
                 autoRefreshCanceller = null;
             }
         }
-    };
+    }
     /**
      * Refresh current subtitles according to the current media element's
      * position.
      */
-    HTMLTextSegmentBuffer.prototype.refreshSubtitles = function () {
-        var MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL = config.getCurrent().MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL;
-        var time;
+    refreshSubtitles() {
+        const { MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL } = config_1.default.getCurrent();
+        let time;
         if (this._videoElement.paused || this._videoElement.playbackRate <= 0) {
             time = this._videoElement.currentTime;
         }
@@ -347,17 +329,16 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
             time = Math.max(this._videoElement.currentTime +
                 (MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL / 1000) / 2, 0);
         }
-        var cues = this._buffer.get(time);
+        const cues = this._buffer.get(time);
         if (cues.length === 0) {
             this._disableCurrentCues();
         }
         else {
             this._displayCues(cues);
         }
-    };
-    return HTMLTextSegmentBuffer;
-}(SegmentBuffer));
-export default HTMLTextSegmentBuffer;
+    }
+}
+exports.default = HTMLTextSegmentBuffer;
 /**
  * Throw if the given input is not in the expected format.
  * Allows to enforce runtime type-checking as compile-time type-checking here is
@@ -378,13 +359,13 @@ function assertChunkIsTextTrackSegmentData(chunk) {
             typeof chunk.start !== "number") ||
         (chunk.end !== undefined &&
             typeof chunk.end !== "number")) {
-        throw new Error("Invalid format given to a NativeTextSegmentBuffer");
+        throw new Error("Invalid format given to a HTMLTextSegmentBuffer");
     }
 }
 /*
  * The following ugly code is here to provide a compile-time check that an
- * `INativeTextTracksBufferSegmentData` (type of data pushed to a
- * `NativeTextSegmentBuffer`) can be derived from a `ITextTrackSegmentData`
+ * `IHTMLTextTracksBufferSegmentData` (type of data pushed to a
+ * `HTMLTextSegmentBuffer`) can be derived from a `ITextTrackSegmentData`
  * (text track data parsed from a segment).
  *
  * It doesn't correspond at all to real code that will be called. This is just

package/dist/_esm5.processed/core/segment_buffers/implementations/text/html/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,9 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * /!\ This file is feature-switchable.
  * It always should be imported through the `features` object.
  */
-import HTMLTextSegmentBuffer from "./html_text_segment_buffer";
-export default HTMLTextSegmentBuffer;
+const html_text_segment_buffer_1 = require("./html_text_segment_buffer");
+exports.default = html_text_segment_buffer_1.default;

package/dist/_esm5.processed/core/segment_buffers/implementations/text/html/parsers.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,8 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import features from "../../../../../features";
-import log from "../../../../../log";
+Object.defineProperty(exports, "__esModule", { value: true });
+const features_1 = require("../../../../../features");
+const log_1 = require("../../../../../log");
 /**
  * Convert text track data into timed HTML Cues.
  * @param {string} type - Text track format wanted
@@ -24,14 +26,15 @@ import log from "../../../../../log";
  * @returns {Array.<Object>}
  * @throws Error - Throw if no parser is found for the given type
  */
-export default function parseTextTrackToElements(type, data, timestampOffset, language) {
-    log.debug("HTSB: Finding parser for html text tracks:", type);
-    var parser = features.htmlTextTracksParsers[type];
+function parseTextTrackToElements(type, data, timestampOffset, language) {
+    log_1.default.debug("HTSB: Finding parser for html text tracks:", type);
+    const parser = features_1.default.htmlTextTracksParsers[type];
     if (typeof parser !== "function") {
         throw new Error("no parser found for the given text track");
     }
-    log.debug("HTSB: Parser found, parsing...");
-    var parsed = parser(data, timestampOffset, language);
-    log.debug("HTTB: Parsed successfully!", parsed.length);
+    log_1.default.debug("HTSB: Parser found, parsing...");
+    const parsed = parser(data, timestampOffset, language);
+    log_1.default.debug("HTTB: Parsed successfully!", parsed.length);
     return parsed;
 }
+exports.default = parseTextTrackToElements;