@oat-sa/tao-core-ui 1.64.1 → 1.64.2

package/src/mediaplayer/utils/reminder.js

@@ -1,184 +1,184 @@
-/**
- * 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}
- */
-export default function reminderManagerFactory() {
-    // Keep track of the running state
-    let running = false;
-
-    // Timestamp of the last start
-    let last = 0;
-
-    // A list of reminders to callback
-    const 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 => {
-        if (state && state.timeout) {
-            clearTimeout(state.timeout);
-            state.timeout = null;
-        }
-    };
-
-    /**
-     * Cancel the schedule for all reminders.
-     * @private
-     */
-    const stopAllReminders = () => reminders.forEach(stopReminder);
-
-    /**
-     * Schedule all reminders.
-     * @private
-     */
-    const startAllReminders = () => {
-        reminders.forEach((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() {
-            running = true;
-            last = performance.now();
-            startAllReminders();
-            return this;
-        },
-
-        /**
-         * Cancels all scheduled reminders.
-         *
-         * @returns {reminderManager}
-         * @function stop
-         * @memberOf reminderManager
-         */
-        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(cb, delay) {
-            if ('function' === typeof cb && delay) {
-                stopReminder(reminders.get(cb));
-                reminders.set(cb, { 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(cb) {
-            if ('undefined' !== typeof cb) {
-                stopReminder(reminders.get(cb));
-                reminders.delete(cb);
-            } else {
-                stopAllReminders();
-                reminders.clear();
-            }
-            return this;
-        }
-    };
-}
+/**
+ * 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}
+ */
+export default function reminderManagerFactory() {
+    // Keep track of the running state
+    let running = false;
+
+    // Timestamp of the last start
+    let last = 0;
+
+    // A list of reminders to callback
+    const 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 => {
+        if (state && state.timeout) {
+            clearTimeout(state.timeout);
+            state.timeout = null;
+        }
+    };
+
+    /**
+     * Cancel the schedule for all reminders.
+     * @private
+     */
+    const stopAllReminders = () => reminders.forEach(stopReminder);
+
+    /**
+     * Schedule all reminders.
+     * @private
+     */
+    const startAllReminders = () => {
+        reminders.forEach((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() {
+            running = true;
+            last = performance.now();
+            startAllReminders();
+            return this;
+        },
+
+        /**
+         * Cancels all scheduled reminders.
+         *
+         * @returns {reminderManager}
+         * @function stop
+         * @memberOf reminderManager
+         */
+        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(cb, delay) {
+            if ('function' === typeof cb && delay) {
+                stopReminder(reminders.get(cb));
+                reminders.set(cb, { 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(cb) {
+            if ('undefined' !== typeof cb) {
+                stopReminder(reminders.get(cb));
+                reminders.delete(cb);
+            } else {
+                stopAllReminders();
+                reminders.clear();
+            }
+            return this;
+        }
+    };
+}

package/src/mediaplayer/utils/timeObserver.js

@@ -1,143 +1,143 @@
-/**
- * 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 ;
- */
-
-import eventifier from 'core/eventifier';
-
-/**
- * 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}
- */
-export default function timeObserverFactory(interval = 1) {
-    // Current time position
-    let position = 0;
-
-    // Total duration expected
-    let duration = 0;
-
-    // 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
-         */
-        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(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(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(seekPosition) {
-            position = seek = seekPosition;
-            return this;
-        }
-    });
-}
+/**
+ * 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 ;
+ */
+
+import eventifier from 'core/eventifier';
+
+/**
+ * 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}
+ */
+export default function timeObserverFactory(interval = 1) {
+    // Current time position
+    let position = 0;
+
+    // Total duration expected
+    let duration = 0;
+
+    // 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
+         */
+        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(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(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(seekPosition) {
+            position = seek = seekPosition;
+            return this;
+        }
+    });
+}