@oat-sa/tao-core-ui 1.58.1 → 1.58.2

package/dist/mediaplayer/support.js

@@ -23,14 +23,14 @@ define(function () { 'use strict';
      * @type {RegExp}
      * @private
      */
-    const reAppleMobiles = /ip(hone|od)/i;
+    var reAppleMobiles = /ip(hone|od)/i;
     /**
      * A list of MIME types with codec declaration
      * @type {Object}
      * @private
      */
 
-    const supportedMimeTypes = {
+    var supportedMimeTypes = {
       // video
       'video/webm': 'video/webm; codecs="vp8, vorbis"',
       'video/mp4': 'video/mp4; codecs="avc1.42E01E, mp4a.40.2"',
@@ -49,7 +49,9 @@ define(function () { 'use strict';
      * @private
      */
 
-    const findSupport = (media, mimeType) => media.canPlayType(mimeType).replace(/no/, '');
+    var findSupport = function findSupport(media, mimeType) {
+      return media.canPlayType(mimeType).replace(/no/, '');
+    };
     /**
      * Support detection
      * @type {Object}
@@ -64,8 +66,8 @@ define(function () { 'use strict';
        * @returns {Boolean}
        * @private
        */
-      checkSupport(media, mimeType) {
-        const support = media.canPlayType;
+      checkSupport: function checkSupport(media, mimeType) {
+        var support = media.canPlayType;
 
         if (support && mimeType) {
           return !!(supportedMimeTypes[mimeType] && findSupport(media, supportedMimeTypes[mimeType]) || findSupport(media, mimeType));
@@ -80,7 +82,7 @@ define(function () { 'use strict';
        * @param {String} [mime] A media MIME type to check
        * @returns {Boolean}
        */
-      canPlay(type, mime) {
+      canPlay: function canPlay(type, mime) {
         if (type) {
           switch (type.toLowerCase()) {
             case 'audio':
@@ -105,7 +107,7 @@ define(function () { 'use strict';
        * @param {String} [mime] A media MIME type to check
        * @returns {Boolean}
        */
-      canPlayAudio(mime) {
+      canPlayAudio: function canPlayAudio(mime) {
         return this.checkSupport(document.createElement('audio'), mime);
       },
 
@@ -114,7 +116,7 @@ define(function () { 'use strict';
        * @param {String} [mime] A media MIME type to check
        * @returns {Boolean}
        */
-      canPlayVideo(mime) {
+      canPlayVideo: function canPlayVideo(mime) {
         return this.checkSupport(document.createElement('video'), mime);
       },
 
@@ -122,10 +124,9 @@ define(function () { 'use strict';
        * Checks if the browser allows to control the media playback
        * @returns {Boolean}
        */
-      canControl() {
+      canControl: function canControl() {
         return !reAppleMobiles.test(window.navigator.userAgent);
       }
-
     };
 
     return support;

package/dist/mediaplayer/utils/reminder.js

@@ -49,18 +49,18 @@ define(function () { 'use strict';
      */
     function reminderManagerFactory() {
       // Keep track of the running state
-      let running = false; // Timestamp of the last start
+      var running = false; // Timestamp of the last start
 
-      let last = 0; // A list of reminders to callback
+      var last = 0; // A list of reminders to callback
 
-      const reminders = new Map();
+      var reminders = new Map();
       /**
        * Cancels a schedule for a particular reminder.
        * @param {object} state - A sate object containing the timeout handler for the reminder.
        * @private
        */
 
-      const stopReminder = state => {
+      var stopReminder = function stopReminder(state) {
         if (state && state.timeout) {
           clearTimeout(state.timeout);
           state.timeout = null;
@@ -72,15 +72,17 @@ define(function () { 'use strict';
        */
 
 
-      const stopAllReminders = () => reminders.forEach(stopReminder);
+      var stopAllReminders = function stopAllReminders() {
+        return reminders.forEach(stopReminder);
+      };
       /**
        * Schedule all reminders.
        * @private
        */
 
 
-      const startAllReminders = () => {
-        reminders.forEach((state, reminder) => {
+      var startAllReminders = function startAllReminders() {
+        reminders.forEach(function (state, reminder) {
           stopReminder(state);
           state.timeout = setTimeout(reminder, state.delay);
         });
@@ -128,7 +130,7 @@ define(function () { 'use strict';
          * @function start
          * @memberOf reminderManager
          */
-        start() {
+        start: function start() {
           running = true;
           last = performance.now();
           startAllReminders();
@@ -142,7 +144,7 @@ define(function () { 'use strict';
          * @function stop
          * @memberOf reminderManager
          */
-        stop() {
+        stop: function stop() {
           running = false;
           stopAllReminders();
           return this;
@@ -158,11 +160,11 @@ define(function () { 'use strict';
          * @function remind
          * @memberOf reminderManager
          */
-        remind(cb, delay) {
+        remind: function remind(cb, delay) {
           if ('function' === typeof cb && delay) {
             stopReminder(reminders.get(cb));
             reminders.set(cb, {
-              delay
+              delay: delay
             });
           }
 
@@ -177,7 +179,7 @@ define(function () { 'use strict';
          * @function forget
          * @memberOf reminderManager
          */
-        forget(cb) {
+        forget: function forget(cb) {
           if ('undefined' !== typeof cb) {
             stopReminder(reminders.get(cb));
             reminders.delete(cb);
@@ -188,7 +190,6 @@ define(function () { 'use strict';
 
           return this;
         }
-
       };
     }
 

package/dist/mediaplayer/utils/timeObserver.js

@@ -52,13 +52,13 @@ define(['core/eventifier'], function (eventifier) { 'use strict';
      */
 
     function timeObserverFactory() {
-      let interval = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      var interval = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
       // Current time position
-      let position = 0; // Total duration expected
+      var position = 0; // Total duration expected
 
-      let duration = 0; // Last position forced
+      var duration = 0; // Last position forced
 
-      let seek = 0;
+      var _seek = 0;
       /**
        * Defines the API of a time observer.
        *
@@ -101,8 +101,8 @@ define(['core/eventifier'], function (eventifier) { 'use strict';
          * @function init
          * @memberOf timeObserver
          */
-        init(initPosition, initDuration) {
-          position = seek = initPosition;
+        init: function init(initPosition, initDuration) {
+          position = _seek = initPosition;
           duration = initDuration;
           return this;
         },
@@ -116,8 +116,8 @@ define(['core/eventifier'], function (eventifier) { 'use strict';
          *
          * @fires irregularity
          */
-        update(newPosition) {
-          if (newPosition > seek && newPosition - position > interval) {
+        update: function update(newPosition) {
+          if (newPosition > _seek && newPosition - position > interval) {
             /**
              * Notifies an irregularity in the time update
              * @event irregularity
@@ -137,11 +137,10 @@ define(['core/eventifier'], function (eventifier) { 'use strict';
          * @param {number} seekPosition
          * @returns {timeObserver}
          */
-        seek(seekPosition) {
-          position = seek = seekPosition;
+        seek: function seek(seekPosition) {
+          position = _seek = seekPosition;
           return this;
         }
-
       });
     }
 

package/dist/mediaplayer/youtubeManager.js

@@ -1,171 +1,190 @@
 define(['jquery'], function ($) { 'use strict';
 
-    $ = $ && Object.prototype.hasOwnProperty.call($, 'default') ? $['default'] : $;
+  $ = $ && 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}
+   */
+
+  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]
+   */
+
+  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);
+        },
+        onStateChange: function onStateChange(ev) {
+          return player.onStateChange(ev);
+        }
+      }
+    });
+  }
+  /**
+   * A local manager for Youtube players.
+   * Relies on https://developers.google.com/youtube/iframe_api_reference
+   * @type {Object}
+   */
 
-    /**
-     * 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 ;
-     */
-    /**
-     * CDN for the YouTube API
-     * @type {String}
-     */
 
-    const youtubeApi = 'https://www.youtube.com/iframe_api';
-    /**
-     * A Regex to extract ID from Youtube URLs
-     * @type {RegExp}
-     */
+  function youtubeManagerFactory() {
+    // The Youtube API injection state
+    var injected = false; // The Youtube API ready state
 
-    const reYoutube = /([?&\/]v[=\/])([\w-]+)([&\/]?)/;
+    var ready = false; // A list of pending players
+
+    var pending = [];
     /**
-     * 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]
+     * Checks if the Youtube API is ready to use
+     * @returns {Boolean}
      */
 
-    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
-        },
-        events: {
-          onReady: ev => player.onReady(ev),
-          onStateChange: ev => player.onStateChange(ev)
-        }
-      });
+    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;
     }
     /**
-     * A local manager for Youtube players.
-     * Relies on https://developers.google.com/youtube/iframe_api_reference
-     * @type {Object}
+     * Injects the Youtube API into the page
      */
 
 
-    function youtubeManagerFactory() {
-      // The Youtube API injection state
-      let injected = false; // The Youtube API ready state
+    function injectApi() {
+      if (!isApiReady()) {
+        window.require([youtubeApi], function () {
+          var check = function check() {
+            if (!isApiReady()) {
+              setTimeout(check, 100);
+            }
+          };
 
-      let ready = false; // A list of pending players
+          check();
+        });
+      }
+
+      injected = true;
+    }
 
-      let pending = [];
+    return {
       /**
-       * Checks if the Youtube API is ready to use
-       * @returns {Boolean}
+       * Adds a Youtube player
+       * @param {String|jQuery|HTMLElement} elem
+       * @param {Object} player
+       * @param {Object} [options]
+       * @param {Boolean} [options.controls]
        */
-
-      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);
-            }
-          });
-          pending = [];
+      add: function add(elem, player, options) {
+        if (ready) {
+          addYoutubePlayer(elem, player, options);
+        } else {
+          pending.push([elem, player, options]);
+
+          if (!injected) {
+            injectApi();
+          }
         }
+      },
 
-        return apiReady;
-      }
       /**
-       * Injects the Youtube API into the page
+       * Removes a pending Youtube player
+       * @param {String|jQuery|HTMLElement} elem
+       * @param {Object} player
        */
-
-
-      function injectApi() {
-        if (!isApiReady()) {
-          window.require([youtubeApi], () => {
-            const check = () => {
-              if (!isApiReady()) {
-                setTimeout(check, 100);
-              }
-            };
-
-            check();
-          });
-        }
-
-        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();
-            }
+      remove: function remove(elem, player) {
+        pending.forEach(function (args, idx) {
+          if (args && elem === args[0] && player === args[1]) {
+            pending[idx] = null;
           }
-        },
-
-        /**
-         * 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;
-        }
+        });
+      },
 
-      };
-    }
+      /**
+       * 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;
+      }
+    };
+  }
 
-    return youtubeManagerFactory;
+  return youtubeManagerFactory;
 
 });