@oat-sa/tao-core-ui 1.5.4 → 1.6.3

package/dist/mediaplayer/utils/reminder.js

@@ -0,0 +1,198 @@
+define(function () { 'use strict';
+
+    /**
+     * 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 reminder manager.
+     *
+     * A reminder manager allows to register callback functions that will be called after a particular amount of time.
+     * The schedule can be created and cancelled at any time.
+     *
+     * @example
+     * // Create a reminder manager
+     * const manager = reminderManagerFactory();
+     *
+     * // Add a reminder that will be called after 2s (delay is given in milliseconds)
+     * manager.remind(() => console.log('Hello!'), 2000);
+     *
+     * // Start the schedule
+     * manager.start();
+     *
+     * // We can know how many time elapsed since the last schedule
+     * const elapsed = manager.elapsed;
+     *
+     * // The schedule can be cancelled
+     * if (needToCancel) {
+     *     manager.stop();
+     * }
+     *
+     * // The schedule should be cancelled
+     * console.log('schedule running:', manager.running)
+     *
+     * @returns {reminderManager}
+     */
+    function reminderManagerFactory() {
+      // Keep track of the running state
+      var running = false; // Timestamp of the last start
+
+      var last = 0; // A list of reminders to callback
+
+      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
+       */
+
+      var stopReminder = function stopReminder(state) {
+        if (state && state.timeout) {
+          clearTimeout(state.timeout);
+          state.timeout = null;
+        }
+      };
+      /**
+       * Cancel the schedule for all reminders.
+       * @private
+       */
+
+
+      var stopAllReminders = function stopAllReminders() {
+        return reminders.forEach(stopReminder);
+      };
+      /**
+       * Schedule all reminders.
+       * @private
+       */
+
+
+      var startAllReminders = function startAllReminders() {
+        reminders.forEach(function (state, reminder) {
+          stopReminder(state);
+          state.timeout = setTimeout(reminder, state.delay);
+        });
+      };
+      /**
+       * Defines the API of a reminder manager.
+       *
+       * A reminder manager allows to register callback functions that will be called after a particular amount of time.
+       * The schedule can be created and cancelled at any time.
+       *
+       * @namespace reminderManager
+       */
+
+
+      return {
+        /**
+         * Tells whether or not the schedule is running.
+         * @type {boolean}
+         * @member running
+         * @memberOf reminderManager
+         */
+        get running() {
+          return running;
+        },
+
+        /**
+         * Gives the amount of time elapsed since the start of the schedule. It is given in milliseconds.
+         * If the schedule is not running, it will always be 0.
+         * @type {number}
+         * @member running
+         * @memberOf reminderManager
+         */
+        get elapsed() {
+          if (!running) {
+            return 0;
+          }
+
+          return performance.now() - last;
+        },
+
+        /**
+         * Schedules all reminders from now on.
+         *
+         * @returns {reminderManager}
+         * @function start
+         * @memberOf reminderManager
+         */
+        start: function start() {
+          running = true;
+          last = performance.now();
+          startAllReminders();
+          return this;
+        },
+
+        /**
+         * Cancels all scheduled reminders.
+         *
+         * @returns {reminderManager}
+         * @function stop
+         * @memberOf reminderManager
+         */
+        stop: function stop() {
+          running = false;
+          stopAllReminders();
+          return this;
+        },
+
+        /**
+         * Adds a callback to be scheduled.
+         * It won't be scheduled until the schedule is restarted.
+         *
+         * @param {Function} cb - A function to call after the delay elapsed.
+         * @param {number} delay - The delay after what call back the reminder. It is given in milliseconds.
+         * @returns {reminderManager}
+         * @function remind
+         * @memberOf reminderManager
+         */
+        remind: function remind(cb, delay) {
+          if ('function' === typeof cb && delay) {
+            stopReminder(reminders.get(cb));
+            reminders.set(cb, {
+              delay: delay
+            });
+          }
+
+          return this;
+        },
+
+        /**
+         * Removes a scheduled callback. If a schedule was running, it will be cancelled first.
+         *
+         * @param {Function} [cb] - The callback function to remove. If omitted, all reminders will be removed.
+         * @returns {reminderManager}
+         * @function forget
+         * @memberOf reminderManager
+         */
+        forget: function forget(cb) {
+          if ('undefined' !== typeof cb) {
+            stopReminder(reminders.get(cb));
+            reminders.delete(cb);
+          } else {
+            stopAllReminders();
+            reminders.clear();
+          }
+
+          return this;
+        }
+      };
+    }
+
+    return reminderManagerFactory;
+
+});

package/dist/mediaplayer/utils/timeObserver.js

@@ -0,0 +1,149 @@
+define(['core/eventifier'], function (eventifier) { 'use strict';
+
+    eventifier = eventifier && eventifier.hasOwnProperty('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}
+     */
+
+    function timeObserverFactory() {
+      var interval = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      // Current time position
+      var position = 0; // Total duration expected
+
+      var duration = 0; // Last position forced
+
+      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
+       */
+
+      return eventifier({
+        /**
+         * 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
+         */
+        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
+         */
+        init: function 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
+         */
+        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
+             */
+            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}
+         */
+        seek: function seek(seekPosition) {
+          position = _seek = seekPosition;
+          return this;
+        }
+      });
+    }
+
+    return timeObserverFactory;
+
+});

package/dist/mediaplayer/youtubeManager.js

@@ -0,0 +1,177 @@
+define(['jquery'], function ($) { 'use strict';
+
+  $ = $ && $.hasOwnProperty('default') ? $['default'] : $;
+
+  function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
+  }
+
+  function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) {
+      for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+
+      return arr2;
+    }
+  }
+
+  function _iterableToArray(iter) {
+    if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+  }
+
+  function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance");
+  }
+
+  /**
+   * 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}
+   */
+
+
+  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}
+     */
+
+    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
+     */
+
+
+    function injectApi() {
+      if (!isApiReady()) {
+        window.require([youtubeApi], function () {
+          var check = function 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: function 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: 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;
+      }
+    };
+  }
+
+  return youtubeManagerFactory;
+
+});