Tracking de l'application VApp (IHM du jeu)

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

@@ -0,0 +1,117 @@
+(function (factory) {
+    typeof define === 'function' && define.amd ? define(factory) :
+    factory();
+})((function () { 'use strict';
+
+    var scheduledIntervalIdentifiers = new Map();
+    var scheduledTimeoutIdentifiers = new Map();
+    var clearScheduledInterval = function clearScheduledInterval(timerId) {
+      var identifier = scheduledIntervalIdentifiers.get(timerId);
+      if (identifier !== undefined) {
+        clearTimeout(identifier);
+        scheduledIntervalIdentifiers["delete"](timerId);
+      } else {
+        throw new Error("There is no interval scheduled with the given id \"".concat(timerId, "\"."));
+      }
+    };
+    var clearScheduledTimeout = function clearScheduledTimeout(timerId) {
+      var identifier = scheduledTimeoutIdentifiers.get(timerId);
+      if (identifier !== undefined) {
+        clearTimeout(identifier);
+        scheduledTimeoutIdentifiers["delete"](timerId);
+      } else {
+        throw new Error("There is no timeout scheduled with the given id \"".concat(timerId, "\"."));
+      }
+    };
+    var computeDelayAndExpectedCallbackTime = function computeDelayAndExpectedCallbackTime(delay, nowInMainThread) {
+      var now;
+      var remainingDelay;
+      var nowInWorker = performance.now();
+      var elapsed = Math.max(0, nowInWorker - nowInMainThread);
+      now = nowInWorker;
+      remainingDelay = delay - elapsed;
+      var expected = now + remainingDelay;
+      return {
+        expected: expected,
+        remainingDelay: remainingDelay
+      };
+    };
+    var setTimeoutCallback = function setTimeoutCallback(identifiers, timerId, expected, timerType) {
+      var now = performance.now();
+      if (now > expected) {
+        postMessage({
+          id: null,
+          method: 'call',
+          params: {
+            timerId: timerId,
+            timerType: timerType
+          }
+        });
+      } else {
+        identifiers.set(timerId, setTimeout(setTimeoutCallback, expected - now, identifiers, timerId, expected, timerType));
+      }
+    };
+    var scheduleInterval = function scheduleInterval(delay, timerId, nowInMainThread) {
+      var _computeDelayAndExpec = computeDelayAndExpectedCallbackTime(delay, nowInMainThread),
+        expected = _computeDelayAndExpec.expected,
+        remainingDelay = _computeDelayAndExpec.remainingDelay;
+      scheduledIntervalIdentifiers.set(timerId, setTimeout(setTimeoutCallback, remainingDelay, scheduledIntervalIdentifiers, timerId, expected, 'interval'));
+    };
+    var scheduleTimeout = function scheduleTimeout(delay, timerId, nowInMainThread) {
+      var _computeDelayAndExpec2 = computeDelayAndExpectedCallbackTime(delay, nowInMainThread),
+        expected = _computeDelayAndExpec2.expected,
+        remainingDelay = _computeDelayAndExpec2.remainingDelay;
+      scheduledTimeoutIdentifiers.set(timerId, setTimeout(setTimeoutCallback, remainingDelay, scheduledTimeoutIdentifiers, timerId, expected, 'timeout'));
+    };
+
+    addEventListener('message', function (_ref) {
+      var data = _ref.data;
+      try {
+        if (data.method === 'clear') {
+          var id = data.id,
+            _data$params = data.params,
+            timerId = _data$params.timerId,
+            timerType = _data$params.timerType;
+          if (timerType === 'interval') {
+            clearScheduledInterval(timerId);
+            postMessage({
+              error: null,
+              id: id
+            });
+          } else if (timerType === 'timeout') {
+            clearScheduledTimeout(timerId);
+            postMessage({
+              error: null,
+              id: id
+            });
+          } else {
+            throw new Error("The given type \"".concat(timerType, "\" is not supported"));
+          }
+        } else if (data.method === 'set') {
+          var _data$params2 = data.params,
+            delay = _data$params2.delay,
+            now = _data$params2.now,
+            _timerId = _data$params2.timerId,
+            _timerType = _data$params2.timerType;
+          if (_timerType === 'interval') {
+            scheduleInterval(delay, _timerId, now);
+          } else if (_timerType === 'timeout') {
+            scheduleTimeout(delay, _timerId, now);
+          } else {
+            throw new Error("The given type \"".concat(_timerType, "\" is not supported"));
+          }
+        } else {
+          throw new Error("The given method \"".concat(data.method, "\" is not supported"));
+        }
+      } catch (err) {
+        postMessage({
+          error: {
+            message: err.message
+          },
+          id: data.id,
+          result: null
+        });
+      }
+    });
+
+}));