Tracking de l'application VApp (IHM du jeu)

VApp/node_modules/worker-timers-broker/build/es5/bundle.js

@@ -0,0 +1,162 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('fast-unique-numbers')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'fast-unique-numbers'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.workerTimersBroker = {}, global.fastUniqueNumbers));
+})(this, (function (exports, fastUniqueNumbers) { 'use strict';
+
+    var isCallNotification = function isCallNotification(message) {
+      return message.method !== undefined && message.method === 'call';
+    };
+
+    var isClearResponse = function isClearResponse(message) {
+      return message.error === null && typeof message.id === 'number';
+    };
+
+    var load = function load(url) {
+      // Prefilling the Maps with a function indexed by zero is necessary to be compliant with the specification.
+      var scheduledIntervalFunctions = new Map([[0, function () {}]]); // tslint:disable-line no-empty
+      var scheduledTimeoutFunctions = new Map([[0, function () {}]]); // tslint:disable-line no-empty
+      var unrespondedRequests = new Map();
+      var worker = new Worker(url);
+      worker.addEventListener('message', function (_ref) {
+        var data = _ref.data;
+        if (isCallNotification(data)) {
+          var _data$params = data.params,
+            timerId = _data$params.timerId,
+            timerType = _data$params.timerType;
+          if (timerType === 'interval') {
+            var idOrFunc = scheduledIntervalFunctions.get(timerId);
+            if (typeof idOrFunc === 'number') {
+              var timerIdAndTimerType = unrespondedRequests.get(idOrFunc);
+              if (timerIdAndTimerType === undefined || timerIdAndTimerType.timerId !== timerId || timerIdAndTimerType.timerType !== timerType) {
+                throw new Error('The timer is in an undefined state.');
+              }
+            } else if (typeof idOrFunc !== 'undefined') {
+              idOrFunc();
+            } else {
+              throw new Error('The timer is in an undefined state.');
+            }
+          } else if (timerType === 'timeout') {
+            var _idOrFunc = scheduledTimeoutFunctions.get(timerId);
+            if (typeof _idOrFunc === 'number') {
+              var _timerIdAndTimerType = unrespondedRequests.get(_idOrFunc);
+              if (_timerIdAndTimerType === undefined || _timerIdAndTimerType.timerId !== timerId || _timerIdAndTimerType.timerType !== timerType) {
+                throw new Error('The timer is in an undefined state.');
+              }
+            } else if (typeof _idOrFunc !== 'undefined') {
+              _idOrFunc();
+              // A timeout can be savely deleted because it is only called once.
+              scheduledTimeoutFunctions["delete"](timerId);
+            } else {
+              throw new Error('The timer is in an undefined state.');
+            }
+          }
+        } else if (isClearResponse(data)) {
+          var id = data.id;
+          var _timerIdAndTimerType2 = unrespondedRequests.get(id);
+          if (_timerIdAndTimerType2 === undefined) {
+            throw new Error('The timer is in an undefined state.');
+          }
+          var _timerId = _timerIdAndTimerType2.timerId,
+            _timerType = _timerIdAndTimerType2.timerType;
+          unrespondedRequests["delete"](id);
+          if (_timerType === 'interval') {
+            scheduledIntervalFunctions["delete"](_timerId);
+          } else {
+            scheduledTimeoutFunctions["delete"](_timerId);
+          }
+        } else {
+          var message = data.error.message;
+          throw new Error(message);
+        }
+      });
+      var clearInterval = function clearInterval(timerId) {
+        var id = fastUniqueNumbers.generateUniqueNumber(unrespondedRequests);
+        unrespondedRequests.set(id, {
+          timerId: timerId,
+          timerType: 'interval'
+        });
+        scheduledIntervalFunctions.set(timerId, id);
+        worker.postMessage({
+          id: id,
+          method: 'clear',
+          params: {
+            timerId: timerId,
+            timerType: 'interval'
+          }
+        });
+      };
+      var clearTimeout = function clearTimeout(timerId) {
+        var id = fastUniqueNumbers.generateUniqueNumber(unrespondedRequests);
+        unrespondedRequests.set(id, {
+          timerId: timerId,
+          timerType: 'timeout'
+        });
+        scheduledTimeoutFunctions.set(timerId, id);
+        worker.postMessage({
+          id: id,
+          method: 'clear',
+          params: {
+            timerId: timerId,
+            timerType: 'timeout'
+          }
+        });
+      };
+      var setInterval = function setInterval(func) {
+        var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+        var timerId = fastUniqueNumbers.generateUniqueNumber(scheduledIntervalFunctions);
+        scheduledIntervalFunctions.set(timerId, function () {
+          func();
+          // Doublecheck if the interval should still be rescheduled because it could have been cleared inside of func().
+          if (typeof scheduledIntervalFunctions.get(timerId) === 'function') {
+            worker.postMessage({
+              id: null,
+              method: 'set',
+              params: {
+                delay: delay,
+                now: performance.now(),
+                timerId: timerId,
+                timerType: 'interval'
+              }
+            });
+          }
+        });
+        worker.postMessage({
+          id: null,
+          method: 'set',
+          params: {
+            delay: delay,
+            now: performance.now(),
+            timerId: timerId,
+            timerType: 'interval'
+          }
+        });
+        return timerId;
+      };
+      var setTimeout = function setTimeout(func) {
+        var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+        var timerId = fastUniqueNumbers.generateUniqueNumber(scheduledTimeoutFunctions);
+        scheduledTimeoutFunctions.set(timerId, func);
+        worker.postMessage({
+          id: null,
+          method: 'set',
+          params: {
+            delay: delay,
+            now: performance.now(),
+            timerId: timerId,
+            timerType: 'timeout'
+          }
+        });
+        return timerId;
+      };
+      return {
+        clearInterval: clearInterval,
+        clearTimeout: clearTimeout,
+        setInterval: setInterval,
+        setTimeout: setTimeout
+      };
+    };
+
+    exports.load = load;
+
+}));