Tracking de l'application VApp (IHM du jeu)

VApp/node_modules/worker-timers-broker/src/module.ts

@@ -0,0 +1,173 @@
+import { generateUniqueNumber } from 'fast-unique-numbers';
+import { IClearRequest, ISetNotification, IWorkerEvent, TTimerType } from 'worker-timers-worker';
+import { isCallNotification } from './guards/call-notification';
+import { isClearResponse } from './guards/clear-response';
+
+export const load = (url: string) => {
+    // Prefilling the Maps with a function indexed by zero is necessary to be compliant with the specification.
+    const scheduledIntervalFunctions: Map<number, number | Function> = new Map([[0, () => {}]]); // tslint:disable-line no-empty
+    const scheduledTimeoutFunctions: Map<number, number | Function> = new Map([[0, () => {}]]); // tslint:disable-line no-empty
+    const unrespondedRequests: Map<number, { timerId: number; timerType: TTimerType }> = new Map();
+
+    const worker = new Worker(url);
+
+    worker.addEventListener('message', ({ data }: IWorkerEvent) => {
+        if (isCallNotification(data)) {
+            const {
+                params: { timerId, timerType }
+            } = data;
+
+            if (timerType === 'interval') {
+                const idOrFunc = scheduledIntervalFunctions.get(timerId);
+
+                if (typeof idOrFunc === 'number') {
+                    const 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') {
+                const idOrFunc = scheduledTimeoutFunctions.get(timerId);
+
+                if (typeof idOrFunc === 'number') {
+                    const 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)) {
+            const { id } = data;
+
+            const timerIdAndTimerType = unrespondedRequests.get(id);
+
+            if (timerIdAndTimerType === undefined) {
+                throw new Error('The timer is in an undefined state.');
+            }
+
+            const { timerId, timerType } = timerIdAndTimerType;
+
+            unrespondedRequests.delete(id);
+
+            if (timerType === 'interval') {
+                scheduledIntervalFunctions.delete(timerId);
+            } else {
+                scheduledTimeoutFunctions.delete(timerId);
+            }
+        } else {
+            const {
+                error: { message }
+            } = data;
+
+            throw new Error(message);
+        }
+    });
+
+    const clearInterval = (timerId: number) => {
+        const id = generateUniqueNumber(unrespondedRequests);
+
+        unrespondedRequests.set(id, { timerId, timerType: 'interval' });
+        scheduledIntervalFunctions.set(timerId, id);
+
+        worker.postMessage(<IClearRequest>{
+            id,
+            method: 'clear',
+            params: { timerId, timerType: 'interval' }
+        });
+    };
+
+    const clearTimeout = (timerId: number) => {
+        const id = generateUniqueNumber(unrespondedRequests);
+
+        unrespondedRequests.set(id, { timerId, timerType: 'timeout' });
+        scheduledTimeoutFunctions.set(timerId, id);
+
+        worker.postMessage(<IClearRequest>{
+            id,
+            method: 'clear',
+            params: { timerId, timerType: 'timeout' }
+        });
+    };
+
+    const setInterval = (func: Function, delay = 0) => {
+        const timerId = generateUniqueNumber(scheduledIntervalFunctions);
+
+        scheduledIntervalFunctions.set(timerId, () => {
+            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(<ISetNotification>{
+                    id: null,
+                    method: 'set',
+                    params: {
+                        delay,
+                        now: performance.now(),
+                        timerId,
+                        timerType: 'interval'
+                    }
+                });
+            }
+        });
+
+        worker.postMessage(<ISetNotification>{
+            id: null,
+            method: 'set',
+            params: {
+                delay,
+                now: performance.now(),
+                timerId,
+                timerType: 'interval'
+            }
+        });
+
+        return timerId;
+    };
+
+    const setTimeout = (func: Function, delay = 0) => {
+        const timerId = generateUniqueNumber(scheduledTimeoutFunctions);
+
+        scheduledTimeoutFunctions.set(timerId, func);
+
+        worker.postMessage(<ISetNotification>{
+            id: null,
+            method: 'set',
+            params: {
+                delay,
+                now: performance.now(),
+                timerId,
+                timerType: 'timeout'
+            }
+        });
+
+        return timerId;
+    };
+
+    return {
+        clearInterval,
+        clearTimeout,
+        setInterval,
+        setTimeout
+    };
+};