@oat-sa/tao-core-ui 1.60.2 → 1.62.0

package/dist/mediaplayer/utils/timeObserver.js

@@ -2,143 +2,140 @@ define(['core/eventifier'], function (eventifier) { 'use strict';
 
     eventifier = eventifier && Object.prototype.hasOwnProperty.call(eventifier, 'default') ? eventifier['default'] : eventifier;
 
-    /**
-     * This program is free software; you can redistribute it and/or
-     * modify it under the terms of the GNU General Public License
-     * as published by the Free Software Foundation; under version 2
-     * of the License (non-upgradable).
-     *
-     * This program is distributed in the hope that it will be useful,
-     * but WITHOUT ANY WARRANTY; without even the implied warranty of
-     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-     * GNU General Public License for more details.
-     *
-     * You should have received a copy of the GNU General Public License
-     * along with this program; if not, write to the Free Software
-     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-     *
-     * Copyright (c) 2021 (original work) Open Assessment Technologies SA ;
-     */
-    /**
-     * Creates a time observer.
-     *
-     * It observes the updates applied to a timeline, raising a flag when an irregularity occurs.
-     *
-     * It works as follow:
-     * - an initial state is defined (example: current: 0, duration: 100)
-     * - each time a position is forced (say the position is changed outside of the regular time update), the observer needs
-     *   to be notified.
-     * - each time the position is updated (say regular time update), the observer needs to be called.
-     * - if the difference between the last regular update and the last one is too high, an event is triggered
-     *
-     * @example
-     * // Create a time observer with an expected interval of 2 seconds
-     * const observer = timeObserverFactory(2);
-     *
-     * // Init the state
-     * observer.start(player.position, player.duration);
-     *
-     * // Update on a regular basis
-     * player.on('timeupdate', () => observer.update(player.position));
-     *
-     * // Notify any position change outside of the regular update
-     * player.on('seek', () => observer.seek(player.position));
-     *
-     * // Gets informed from any irregularity
-     * observer.on('irregularity', () => console.log('irregular jump in time');
-     *
-     * @param {number} interval - The typical interval expected between two updates. It is given in seconds.
-     * @returns {timeObserver}
+    /**
+     * This program is free software; you can redistribute it and/or
+     * modify it under the terms of the GNU General Public License
+     * as published by the Free Software Foundation; under version 2
+     * of the License (non-upgradable).
+     *
+     * This program is distributed in the hope that it will be useful,
+     * but WITHOUT ANY WARRANTY; without even the implied warranty of
+     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+     * GNU General Public License for more details.
+     *
+     * You should have received a copy of the GNU General Public License
+     * along with this program; if not, write to the Free Software
+     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+     *
+     * Copyright (c) 2021 (original work) Open Assessment Technologies SA ;
      */
 
+    /**
+     * Creates a time observer.
+     *
+     * It observes the updates applied to a timeline, raising a flag when an irregularity occurs.
+     *
+     * It works as follow:
+     * - an initial state is defined (example: current: 0, duration: 100)
+     * - each time a position is forced (say the position is changed outside of the regular time update), the observer needs
+     *   to be notified.
+     * - each time the position is updated (say regular time update), the observer needs to be called.
+     * - if the difference between the last regular update and the last one is too high, an event is triggered
+     *
+     * @example
+     * // Create a time observer with an expected interval of 2 seconds
+     * const observer = timeObserverFactory(2);
+     *
+     * // Init the state
+     * observer.start(player.position, player.duration);
+     *
+     * // Update on a regular basis
+     * player.on('timeupdate', () => observer.update(player.position));
+     *
+     * // Notify any position change outside of the regular update
+     * player.on('seek', () => observer.seek(player.position));
+     *
+     * // Gets informed from any irregularity
+     * observer.on('irregularity', () => console.log('irregular jump in time');
+     *
+     * @param {number} interval - The typical interval expected between two updates. It is given in seconds.
+     * @returns {timeObserver}
+     */
     function timeObserverFactory() {
-      var interval = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      let interval = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
       // Current time position
-      var position = 0; // Total duration expected
+      let position = 0;
 
-      var duration = 0; // Last position forced
+      // Total duration expected
+      let duration = 0;
 
-      var _seek = 0;
-      /**
-       * Defines the API of a time observer.
-       *
-       * It observes the updates applied to a timeline, raising a flag when an irregularity occurs.
-       *
-       * @namespace timeObserver
-       */
+      // Last position forced
+      let seek = 0;
 
+      /**
+       * Defines the API of a time observer.
+       *
+       * It observes the updates applied to a timeline, raising a flag when an irregularity occurs.
+       *
+       * @namespace timeObserver
+       */
       return eventifier({
-        /**
-         * Gets the current time position reported to the observer.
-         *
-         * @returns {number}
-         * @type {number}
-         * @member position
-         * @memberOf timeObserver
+        /**
+         * Gets the current time position reported to the observer.
+         *
+         * @returns {number}
+         * @type {number}
+         * @member position
+         * @memberOf timeObserver
          */
         get position() {
           return position;
         },
-
-        /**
-         * Gets the total duration reported to the observer.
-         *
-         * @returns {number}
-         * @type {number}
-         * @member duration
-         * @memberOf timeObserver
+        /**
+         * Gets the total duration reported to the observer.
+         *
+         * @returns {number}
+         * @type {number}
+         * @member duration
+         * @memberOf timeObserver
          */
         get duration() {
           return duration;
         },
-
-        /**
-         * Initialises the time state.
-         *
-         * @param {number} initPosition - The initial time position
-         * @param {number} initDuration - The total duration expected
-         * @returns {timeObserver}
-         * @function init
-         * @memberOf timeObserver
+        /**
+         * Initialises the time state.
+         *
+         * @param {number} initPosition - The initial time position
+         * @param {number} initDuration - The total duration expected
+         * @returns {timeObserver}
+         * @function init
+         * @memberOf timeObserver
          */
-        init: function init(initPosition, initDuration) {
-          position = _seek = initPosition;
+        init(initPosition, initDuration) {
+          position = seek = initPosition;
           duration = initDuration;
           return this;
         },
-
-        /**
-         * Updates the time position. If the difference with the previous update is too high, an `irregularity` event
-         * will be emitted.
-         *
-         * @param {number} newPosition - The new time position
-         * @returns {timeObserver}
-         *
-         * @fires irregularity
+        /**
+         * Updates the time position. If the difference with the previous update is too high, an `irregularity` event
+         * will be emitted.
+         *
+         * @param {number} newPosition - The new time position
+         * @returns {timeObserver}
+         *
+         * @fires irregularity
          */
-        update: function update(newPosition) {
-          if (newPosition > _seek && newPosition - position > interval) {
-            /**
-             * Notifies an irregularity in the time update
-             * @event irregularity
-             * @param {number} position - last regular position
-             * @param {number} newPosition - new irregular position
+        update(newPosition) {
+          if (newPosition > seek && newPosition - position > interval) {
+            /**
+             * Notifies an irregularity in the time update
+             * @event irregularity
+             * @param {number} position - last regular position
+             * @param {number} newPosition - new irregular position
              */
             this.trigger('irregularity', position, newPosition);
           }
-
           position = newPosition;
           return this;
         },
-
-        /**
-         * Notifies the observer about a change in the position outside of the regular update.
-         *
-         * @param {number} seekPosition
-         * @returns {timeObserver}
+        /**
+         * Notifies the observer about a change in the position outside of the regular update.
+         *
+         * @param {number} seekPosition
+         * @returns {timeObserver}
          */
-        seek: function seek(seekPosition) {
-          position = _seek = seekPosition;
+        seek(seekPosition) {
+          position = seek = seekPosition;
           return this;
         }
       });

package/dist/mediaplayer/youtubeManager.js

@@ -1,190 +1,162 @@
 define(['jquery'], function ($) { 'use strict';
 
-  $ = $ && Object.prototype.hasOwnProperty.call($, 'default') ? $['default'] : $;
-
-  function _toConsumableArray(arr) {
-    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-  }
-
-  function _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-  }
-
-  function _iterableToArray(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-  }
-
-  function _unsupportedIterableToArray(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(o);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-  }
-
-  function _arrayLikeToArray(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-
-    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-
-    return arr2;
-  }
-
-  function _nonIterableSpread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-
-  /**
-   * CDN for the YouTube API
-   * @type {String}
-   */
-
-  var youtubeApi = 'https://www.youtube.com/iframe_api';
-  /**
-   * A Regex to extract ID from Youtube URLs
-   * @type {RegExp}
-   */
+    $ = $ && Object.prototype.hasOwnProperty.call($, 'default') ? $['default'] : $;
+
+    /**
+     * This program is free software; you can redistribute it and/or
+     * modify it under the terms of the GNU General Public License
+     * as published by the Free Software Foundation; under version 2
+     * of the License (non-upgradable).
+     *
+     * This program is distributed in the hope that it will be useful,
+     * but WITHOUT ANY WARRANTY; without even the implied warranty of
+     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+     * GNU General Public License for more details.
+     *
+     * You should have received a copy of the GNU General Public License
+     * along with this program; if not, write to the Free Software
+     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+     *
+     * Copyright (c) 2015-2021 (original work) Open Assessment Technologies SA ;
+     */
 
-  var reYoutube = /([?&\/]v[=\/])([\w-]+)([&\/]?)/;
-  /**
-   * Installs a Youtube player. The Youtube API must be ready
-   * @param {String|jQuery|HTMLElement} elem
-   * @param {Object} player
-   * @param {Object} [options]
-   * @param {Boolean} [options.controls]
-   */
+    /**
+     * CDN for the YouTube API
+     * @type {String}
+     */
+    const youtubeApi = 'https://www.youtube.com/iframe_api';
 
-  function addYoutubePlayer(elem, player) {
-    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    var $elem = $(elem);
-    new window.YT.Player($elem.get(0), {
-      height: '360',
-      width: '640',
-      videoId: $elem.data('videoId'),
-      playerVars: {
-        //hd: true,
-        autoplay: 0,
-        controls: options && options.controls ? 1 : 0,
-        rel: 0,
-        showinfo: 0,
-        wmode: 'transparent',
-        modestbranding: 1,
-        disablekb: 1,
-        playsinline: 1,
-        enablejsapi: 1,
-        origin: location.hostname
-      },
-      events: {
-        onReady: function onReady(ev) {
-          return player.onReady(ev);
+    /**
+     * A Regex to extract ID from Youtube URLs
+     * @type {RegExp}
+     */
+    const reYoutube = /([?&\/]v[=\/])([\w-]+)([&\/]?)/;
+
+    /**
+     * Installs a Youtube player. The Youtube API must be ready
+     * @param {String|jQuery|HTMLElement} elem
+     * @param {Object} player
+     * @param {Object} [options]
+     * @param {Boolean} [options.controls]
+     */
+    function addYoutubePlayer(elem, player) {
+      let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      const $elem = $(elem);
+      new window.YT.Player($elem.get(0), {
+        height: '360',
+        width: '640',
+        videoId: $elem.data('videoId'),
+        playerVars: {
+          //hd: true,
+          autoplay: 0,
+          controls: options && options.controls ? 1 : 0,
+          rel: 0,
+          showinfo: 0,
+          wmode: 'transparent',
+          modestbranding: 1,
+          disablekb: 1,
+          playsinline: 1,
+          enablejsapi: 1,
+          origin: location.hostname
         },
-        onStateChange: function onStateChange(ev) {
-          return player.onStateChange(ev);
+        events: {
+          onReady: ev => player.onReady(ev),
+          onStateChange: ev => player.onStateChange(ev)
         }
-      }
-    });
-  }
-  /**
-   * A local manager for Youtube players.
-   * Relies on https://developers.google.com/youtube/iframe_api_reference
-   * @type {Object}
-   */
-
-
-  function youtubeManagerFactory() {
-    // The Youtube API injection state
-    var injected = false; // The Youtube API ready state
-
-    var ready = false; // A list of pending players
+      });
+    }
 
-    var pending = [];
-    /**
-     * Checks if the Youtube API is ready to use
-     * @returns {Boolean}
+    /**
+     * A local manager for Youtube players.
+     * Relies on https://developers.google.com/youtube/iframe_api_reference
+     * @type {Object}
      */
+    function youtubeManagerFactory() {
+      // The Youtube API injection state
+      let injected = false;
 
-    function isApiReady() {
-      var apiReady = typeof window.YT !== 'undefined' && typeof window.YT.Player !== 'undefined';
-
-      if (apiReady && !ready) {
-        ready = true;
-        pending.forEach(function (args) {
-          if (args) {
-            addYoutubePlayer.apply(void 0, _toConsumableArray(args));
-          }
-        });
-        pending = [];
-      }
-
-      return apiReady;
-    }
-    /**
-     * Injects the Youtube API into the page
-     */
+      // The Youtube API ready state
+      let ready = false;
 
+      // A list of pending players
+      let pending = [];
 
-    function injectApi() {
-      if (!isApiReady()) {
-        window.require([youtubeApi], function () {
-          var check = function check() {
-            if (!isApiReady()) {
-              setTimeout(check, 100);
+      /**
+       * Checks if the Youtube API is ready to use
+       * @returns {Boolean}
+       */
+      function isApiReady() {
+        const apiReady = typeof window.YT !== 'undefined' && typeof window.YT.Player !== 'undefined';
+        if (apiReady && !ready) {
+          ready = true;
+          pending.forEach(args => {
+            if (args) {
+              addYoutubePlayer(...args);
             }
-          };
-
-          check();
-        });
+          });
+          pending = [];
+        }
+        return apiReady;
       }
 
-      injected = true;
-    }
-
-    return {
-      /**
-       * Adds a Youtube player
-       * @param {String|jQuery|HTMLElement} elem
-       * @param {Object} player
-       * @param {Object} [options]
-       * @param {Boolean} [options.controls]
+      /**
+       * Injects the Youtube API into the page
        */
-      add: function add(elem, player, options) {
-        if (ready) {
-          addYoutubePlayer(elem, player, options);
-        } else {
-          pending.push([elem, player, options]);
-
-          if (!injected) {
-            injectApi();
-          }
+      function injectApi() {
+        if (!isApiReady()) {
+          window.require([youtubeApi], () => {
+            const check = () => {
+              if (!isApiReady()) {
+                setTimeout(check, 100);
+              }
+            };
+            check();
+          });
         }
-      },
-
-      /**
-       * Removes a pending Youtube player
-       * @param {String|jQuery|HTMLElement} elem
-       * @param {Object} player
-       */
-      remove: function remove(elem, player) {
-        pending.forEach(function (args, idx) {
-          if (args && elem === args[0] && player === args[1]) {
-            pending[idx] = null;
-          }
-        });
-      },
-
-      /**
-       * Extracts the ID of a Youtube video from an URL
-       * @param {String} url
-       * @returns {String}
-       */
-      extractYoutubeId: function extractYoutubeId(url) {
-        var res = reYoutube.exec(url);
-        return res && res[2] || url;
+        injected = true;
       }
-    };
-  }
+      return {
+        /**
+         * Adds a Youtube player
+         * @param {String|jQuery|HTMLElement} elem
+         * @param {Object} player
+         * @param {Object} [options]
+         * @param {Boolean} [options.controls]
+         */
+        add(elem, player, options) {
+          if (ready) {
+            addYoutubePlayer(elem, player, options);
+          } else {
+            pending.push([elem, player, options]);
+            if (!injected) {
+              injectApi();
+            }
+          }
+        },
+        /**
+         * Removes a pending Youtube player
+         * @param {String|jQuery|HTMLElement} elem
+         * @param {Object} player
+         */
+        remove(elem, player) {
+          pending.forEach((args, idx) => {
+            if (args && elem === args[0] && player === args[1]) {
+              pending[idx] = null;
+            }
+          });
+        },
+        /**
+         * Extracts the ID of a Youtube video from an URL
+         * @param {String} url
+         * @returns {String}
+         */
+        extractYoutubeId(url) {
+          const res = reYoutube.exec(url);
+          return res && res[2] || url;
+        }
+      };
+    }
 
-  return youtubeManagerFactory;
+    return youtubeManagerFactory;
 
 });