Tracking de l'application VApp (IHM du jeu)

VApp/node_modules/fast-unique-numbers/src/factories/add-unique-number.ts

@@ -0,0 +1,11 @@
+import { TAddUniqueNumberFactory } from '../types';
+
+export const createAddUniqueNumber: TAddUniqueNumberFactory = (generateUniqueNumber) => {
+    return (set) => {
+        const number = generateUniqueNumber(set);
+
+        set.add(number);
+
+        return number;
+    };
+};

VApp/node_modules/fast-unique-numbers/src/factories/cache.ts

@@ -0,0 +1,9 @@
+import { TCacheFactory } from '../types';
+
+export const createCache: TCacheFactory = (lastNumberWeakMap) => {
+    return (collection, nextNumber) => {
+        lastNumberWeakMap.set(collection, nextNumber);
+
+        return nextNumber;
+    };
+};

VApp/node_modules/fast-unique-numbers/src/factories/generate-unique-number.ts

@@ -0,0 +1,55 @@
+import { TGenerateUniqueNumberFactory } from '../types';
+
+/*
+ * The value of the constant Number.MAX_SAFE_INTEGER equals (2 ** 53 - 1) but it
+ * is fairly new.
+ */
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER === undefined ? 9007199254740991 : Number.MAX_SAFE_INTEGER;
+const TWO_TO_THE_POWER_OF_TWENTY_NINE = 536870912;
+const TWO_TO_THE_POWER_OF_THIRTY = TWO_TO_THE_POWER_OF_TWENTY_NINE * 2;
+
+export const createGenerateUniqueNumber: TGenerateUniqueNumberFactory = (cache, lastNumberWeakMap) => {
+    return (collection) => {
+        const lastNumber = lastNumberWeakMap.get(collection);
+
+        /*
+         * Let's try the cheapest algorithm first. It might fail to produce a new
+         * number, but it is so cheap that it is okay to take the risk. Just
+         * increase the last number by one or reset it to 0 if we reached the upper
+         * bound of SMIs (which stands for small integers). When the last number is
+         * unknown it is assumed that the collection contains zero based consecutive
+         * numbers.
+         */
+        let nextNumber = lastNumber === undefined ? collection.size : lastNumber < TWO_TO_THE_POWER_OF_THIRTY ? lastNumber + 1 : 0;
+
+        if (!collection.has(nextNumber)) {
+            return cache(collection, nextNumber);
+        }
+
+        /*
+         * If there are less than half of 2 ** 30 numbers stored in the collection,
+         * the chance to generate a new random number in the range from 0 to 2 ** 30
+         * is at least 50%. It's benifitial to use only SMIs because they perform
+         * much better in any environment based on V8.
+         */
+        if (collection.size < TWO_TO_THE_POWER_OF_TWENTY_NINE) {
+            while (collection.has(nextNumber)) {
+                nextNumber = Math.floor(Math.random() * TWO_TO_THE_POWER_OF_THIRTY);
+            }
+
+            return cache(collection, nextNumber);
+        }
+
+        // Quickly check if there is a theoretical chance to generate a new number.
+        if (collection.size > MAX_SAFE_INTEGER) {
+            throw new Error('Congratulations, you created a collection of unique numbers which uses all available integers!');
+        }
+
+        // Otherwise use the full scale of safely usable integers.
+        while (collection.has(nextNumber)) {
+            nextNumber = Math.floor(Math.random() * MAX_SAFE_INTEGER);
+        }
+
+        return cache(collection, nextNumber);
+    };
+};

VApp/node_modules/fast-unique-numbers/src/module.ts

@@ -0,0 +1,17 @@
+import { createAddUniqueNumber } from './factories/add-unique-number';
+import { createCache } from './factories/cache';
+import { createGenerateUniqueNumber } from './factories/generate-unique-number';
+
+/*
+ * @todo Explicitly referencing the barrel file seems to be necessary when enabling the
+ * isolatedModules compiler option.
+ */
+export * from './types/index';
+
+const LAST_NUMBER_WEAK_MAP = new WeakMap<Map<number, any> | Set<number>, number>();
+
+const cache = createCache(LAST_NUMBER_WEAK_MAP);
+const generateUniqueNumber = createGenerateUniqueNumber(cache, LAST_NUMBER_WEAK_MAP);
+const addUniqueNumber = createAddUniqueNumber(generateUniqueNumber);
+
+export { addUniqueNumber, generateUniqueNumber };

VApp/node_modules/fast-unique-numbers/src/tsconfig.json

@@ -0,0 +1,6 @@
+{
+    "compilerOptions": {
+        "isolatedModules": true
+    },
+    "extends": "tsconfig-holy-grail/src/tsconfig-universal"
+}

VApp/node_modules/fast-unique-numbers/src/types/add-unique-number-factory.ts

@@ -0,0 +1,4 @@
+import { TAddUniqueNumberFunction } from './add-unique-number-function';
+import { TGenerateUniqueNumberFunction } from './generate-unique-number-function';
+
+export type TAddUniqueNumberFactory = (generateUniqueNumber: TGenerateUniqueNumberFunction) => TAddUniqueNumberFunction;

VApp/node_modules/fast-unique-numbers/src/types/add-unique-number-function.ts

@@ -0,0 +1 @@
+export type TAddUniqueNumberFunction = (set: Set<number>) => number;

VApp/node_modules/fast-unique-numbers/src/types/cache-factory.ts

@@ -0,0 +1,3 @@
+import { TCacheFunction } from './cache-function';
+
+export type TCacheFactory = (lastNumberWeakMap: WeakMap<Map<number, any> | Set<number>, number>) => TCacheFunction;

VApp/node_modules/fast-unique-numbers/src/types/cache-function.ts

@@ -0,0 +1 @@
+export type TCacheFunction = (collection: Map<number, any> | Set<number>, nextNumber: number) => number;

VApp/node_modules/fast-unique-numbers/src/types/generate-unique-number-factory.ts

@@ -0,0 +1,7 @@
+import { TCacheFunction } from './cache-function';
+import { TGenerateUniqueNumberFunction } from './generate-unique-number-function';
+
+export type TGenerateUniqueNumberFactory = (
+    cache: TCacheFunction,
+    lastNumberWeakMap: WeakMap<Map<number, any> | Set<number>, number>
+) => TGenerateUniqueNumberFunction;

VApp/node_modules/fast-unique-numbers/src/types/generate-unique-number-function.ts

@@ -0,0 +1 @@
+export type TGenerateUniqueNumberFunction = (collection: Map<number, any> | Set<number>) => number;

VApp/node_modules/fast-unique-numbers/src/types/index.ts

@@ -0,0 +1,6 @@
+export * from './add-unique-number-factory';
+export * from './add-unique-number-function';
+export * from './cache-factory';
+export * from './cache-function';
+export * from './generate-unique-number-factory';
+export * from './generate-unique-number-function';