volleyballsimtypes 0.0.217 → 0.0.358

package/dist/cjs/src/service/utils/index.js

@@ -1,20 +1,20 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./string-utils"), exports);
-__exportStar(require("./object-utils"), exports);
-__exportStar(require("./number-utils"), exports);
-__exportStar(require("./rng-utils"), exports);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./object-utils"), exports);
+__exportStar(require("./number-utils"), exports);
+__exportStar(require("./rng-utils"), exports);
+__exportStar(require("./faker-generators"), exports);

package/dist/cjs/src/service/utils/number-utils.d.ts

@@ -1,2 +1,4 @@
-export declare function clamp(min: number, max: number, value: number): number;
-export declare function erf(x: number): number;
+export declare function randomNumber(min: number, max: number): number;
+export declare function nextPowerOf2(n: number): number;
+export declare function clamp(min: number, max: number, value: number): number;
+export declare function erf(x: number): number;

package/dist/cjs/src/service/utils/number-utils.js

@@ -1,25 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.erf = exports.clamp = void 0;
-function clamp(min, max, value) {
-    return Math.max(min, Math.min(value, max));
-}
-exports.clamp = clamp;
-// Approximation of the error function
-function erf(x) {
-    // constants
-    const a1 = 0.254829592;
-    const a2 = -0.284496736;
-    const a3 = 1.421413741;
-    const a4 = -1.453152027;
-    const a5 = 1.061405429;
-    const p = 0.3275911;
-    // Save the sign of x
-    const sign = x < 0 ? -1 : 1;
-    x = Math.abs(x);
-    // Abramowitz & Stegun 7.1.26
-    const t = 1.0 / (1.0 + p * x);
-    const y = 1.0 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-x * x);
-    return sign * y;
-}
-exports.erf = erf;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomNumber = randomNumber;
+exports.nextPowerOf2 = nextPowerOf2;
+exports.clamp = clamp;
+exports.erf = erf;
+function randomNumber(min, max) {
+    return Math.random() * (max - min) + min;
+}
+function nextPowerOf2(n) { return n <= 1 ? 1 : 2 ** Math.ceil(Math.log2(n)); }
+function clamp(min, max, value) {
+    return Math.max(min, Math.min(value, max));
+}
+// Approximation of the error function
+function erf(x) {
+    // constants
+    const a1 = 0.254829592;
+    const a2 = -0.284496736;
+    const a3 = 1.421413741;
+    const a4 = -1.453152027;
+    const a5 = 1.061405429;
+    const p = 0.3275911;
+    // Save the sign of x
+    const sign = x < 0 ? -1 : 1;
+    x = Math.abs(x);
+    // Abramowitz & Stegun 7.1.26
+    const t = 1.0 / (1.0 + p * x);
+    const y = 1.0 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-x * x);
+    return sign * y;
+}

package/dist/cjs/src/service/utils/number-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/src/service/utils/number-utils.test.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const number_utils_1 = require("./number-utils");
+// ─── clamp ───────────────────────────────────────────────────────────────────
+(0, globals_1.describe)('clamp()', () => {
+    (0, globals_1.it)('returns value when within range', () => {
+        (0, globals_1.expect)((0, number_utils_1.clamp)(0, 10, 5)).toBe(5);
+    });
+    (0, globals_1.it)('clamps to min when value is below', () => {
+        (0, globals_1.expect)((0, number_utils_1.clamp)(0, 10, -5)).toBe(0);
+    });
+    (0, globals_1.it)('clamps to max when value is above', () => {
+        (0, globals_1.expect)((0, number_utils_1.clamp)(0, 10, 15)).toBe(10);
+    });
+    (0, globals_1.it)('returns min when value equals min', () => {
+        (0, globals_1.expect)((0, number_utils_1.clamp)(0, 10, 0)).toBe(0);
+    });
+    (0, globals_1.it)('returns max when value equals max', () => {
+        (0, globals_1.expect)((0, number_utils_1.clamp)(0, 10, 10)).toBe(10);
+    });
+    (0, globals_1.it)('works with floating-point bounds', () => {
+        (0, globals_1.expect)((0, number_utils_1.clamp)(0.5, 9.5, 3.7)).toBeCloseTo(3.7, 10);
+        (0, globals_1.expect)((0, number_utils_1.clamp)(0.5, 9.5, 0.1)).toBeCloseTo(0.5, 10);
+        (0, globals_1.expect)((0, number_utils_1.clamp)(0.5, 9.5, 99)).toBeCloseTo(9.5, 10);
+    });
+});
+// ─── nextPowerOf2 ─────────────────────────────────────────────────────────────
+(0, globals_1.describe)('nextPowerOf2()', () => {
+    (0, globals_1.it)('returns 1 for n = 0', () => {
+        (0, globals_1.expect)((0, number_utils_1.nextPowerOf2)(0)).toBe(1);
+    });
+    (0, globals_1.it)('returns 1 for n = 1', () => {
+        (0, globals_1.expect)((0, number_utils_1.nextPowerOf2)(1)).toBe(1);
+    });
+    (0, globals_1.it)('returns the same value for exact powers of 2', () => {
+        (0, globals_1.expect)((0, number_utils_1.nextPowerOf2)(2)).toBe(2);
+        (0, globals_1.expect)((0, number_utils_1.nextPowerOf2)(4)).toBe(4);
+        (0, globals_1.expect)((0, number_utils_1.nextPowerOf2)(8)).toBe(8);
+        (0, globals_1.expect)((0, number_utils_1.nextPowerOf2)(16)).toBe(16);
+        (0, globals_1.expect)((0, number_utils_1.nextPowerOf2)(32)).toBe(32);
+    });
+    (0, globals_1.it)('rounds up to the next power of 2 for non-powers', () => {
+        (0, globals_1.expect)((0, number_utils_1.nextPowerOf2)(3)).toBe(4);
+        (0, globals_1.expect)((0, number_utils_1.nextPowerOf2)(5)).toBe(8);
+        (0, globals_1.expect)((0, number_utils_1.nextPowerOf2)(9)).toBe(16);
+        (0, globals_1.expect)((0, number_utils_1.nextPowerOf2)(17)).toBe(32);
+    });
+});
+// ─── erf ─────────────────────────────────────────────────────────────────────
+(0, globals_1.describe)('erf()', () => {
+    (0, globals_1.it)('returns ~0 for erf(0)', () => {
+        (0, globals_1.expect)((0, number_utils_1.erf)(0)).toBeCloseTo(0, 5);
+    });
+    (0, globals_1.it)('is antisymmetric: erf(-x) === -erf(x)', () => {
+        (0, globals_1.expect)((0, number_utils_1.erf)(-1)).toBeCloseTo(-(0, number_utils_1.erf)(1), 10);
+        (0, globals_1.expect)((0, number_utils_1.erf)(-0.5)).toBeCloseTo(-(0, number_utils_1.erf)(0.5), 10);
+    });
+    (0, globals_1.it)('approximates erf(1) ≈ 0.8427', () => {
+        (0, globals_1.expect)((0, number_utils_1.erf)(1)).toBeCloseTo(0.8427, 3);
+    });
+    (0, globals_1.it)('approximates erf(0.5) ≈ 0.5205', () => {
+        (0, globals_1.expect)((0, number_utils_1.erf)(0.5)).toBeCloseTo(0.5205, 3);
+    });
+    (0, globals_1.it)('approaches 1 for large positive input', () => {
+        (0, globals_1.expect)((0, number_utils_1.erf)(4)).toBeCloseTo(1, 4);
+    });
+    (0, globals_1.it)('approaches -1 for large negative input', () => {
+        (0, globals_1.expect)((0, number_utils_1.erf)(-4)).toBeCloseTo(-1, 4);
+    });
+});

package/dist/cjs/src/service/utils/object-utils.d.ts

@@ -1,4 +1,4 @@
-export declare const getKeys: <T extends object>(obj: T) => (keyof T)[];
-export type DataProps<T> = {
-    [K in keyof T as T[K] extends (...args: any[]) => any ? never : K]: T[K];
-};
+export declare const getKeys: <T extends object>(obj: T) => Array<keyof T>;
+export type DataProps<T> = {
+    [K in keyof T as T[K] extends (...args: any[]) => any ? never : K]: T[K];
+};

package/dist/cjs/src/service/utils/object-utils.js

@@ -1,4 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getKeys = void 0;
-exports.getKeys = Object.keys;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKeys = void 0;
+exports.getKeys = Object.keys;

package/dist/cjs/src/service/utils/rng-utils.d.ts

@@ -1,7 +1,11 @@
-/**
- * Fisher-Yates shuffle algorithm
- * Shuffles array IN-PLACE
- * @param {any[]} array
- */
-export declare function shuffle<Type>(array: Type[]): Type[];
-export declare function calculateProbability(score: number, scale: number, minP: number, maxP: number): number;
+/**
+ * Fisher-Yates shuffle algorithm
+ * Shuffles array IN-PLACE
+ * @param {any[]} array
+ */
+export declare function shuffle<Type>(array: Type[]): Type[];
+export declare function calculateProbability(score: number, scale: number, minP: number, maxP: number): number;
+export declare function createUniqueRandomPicker(min: number, max: number, rng?: () => number): {
+    next: () => number;
+    reset: () => void;
+};

package/dist/cjs/src/service/utils/rng-utils.js

@@ -1,32 +1,60 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateProbability = exports.shuffle = void 0;
-const number_utils_1 = require("./number-utils");
-/**
- * Fisher-Yates shuffle algorithm
- * Shuffles array IN-PLACE
- * @param {any[]} array
- */
-function shuffle(array) {
-    let m = array.length;
-    let t;
-    let i;
-    // While there remain elements to shuffle…
-    while (m > 0) {
-        // Pick a remaining element…
-        i = Math.floor(Math.random() * m--);
-        // And swap it with the current element.
-        t = array[m];
-        array[m] = array[i];
-        array[i] = t;
-    }
-    return array;
-}
-exports.shuffle = shuffle;
-function calculateProbability(score, scale, minP, maxP) {
-    const x = score / scale;
-    const sigmoid = 1 / (1 + Math.exp(-x));
-    const p = minP + (maxP - minP) * sigmoid;
-    return (0, number_utils_1.clamp)(0, 1, p);
-}
-exports.calculateProbability = calculateProbability;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shuffle = shuffle;
+exports.calculateProbability = calculateProbability;
+exports.createUniqueRandomPicker = createUniqueRandomPicker;
+const number_utils_1 = require("./number-utils");
+/**
+ * Fisher-Yates shuffle algorithm
+ * Shuffles array IN-PLACE
+ * @param {any[]} array
+ */
+function shuffle(array) {
+    let m = array.length;
+    let t;
+    let i;
+    // While there remain elements to shuffle…
+    while (m > 0) {
+        // Pick a remaining element…
+        i = Math.floor(Math.random() * m--);
+        // And swap it with the current element.
+        t = array[m];
+        array[m] = array[i];
+        array[i] = t;
+    }
+    return array;
+}
+function calculateProbability(score, scale, minP, maxP) {
+    const x = score / scale;
+    const sigmoid = 1 / (1 + Math.exp(-x));
+    const p = minP + (maxP - minP) * sigmoid;
+    return (0, number_utils_1.clamp)(0, 1, p);
+}
+function createUniqueRandomPicker(min, max, rng = Math.random) {
+    if (!Number.isInteger(min) || !Number.isInteger(max) || min > max) {
+        throw new Error('Invalid range');
+    }
+    let pool = [];
+    function refill() {
+        pool = [];
+        for (let i = min; i <= max; i++)
+            pool.push(i);
+        // Fisher–Yates shuffle
+        for (let i = pool.length - 1; i > 0; i--) {
+            const j = Math.floor(rng() * (i + 1));
+            [pool[i], pool[j]] = [pool[j], pool[i]];
+        }
+    }
+    refill();
+    return {
+        next() {
+            const aux = pool.pop();
+            if (aux == null)
+                return NaN;
+            return aux;
+        },
+        reset() {
+            refill();
+        }
+    };
+}

package/dist/cjs/src/service/utils/rng-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/src/service/utils/rng-utils.test.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const rng_utils_1 = require("./rng-utils");
+// ─── shuffle ─────────────────────────────────────────────────────────────────
+(0, globals_1.describe)('shuffle()', () => {
+    (0, globals_1.it)('returns the same array reference (in-place)', () => {
+        const arr = [1, 2, 3, 4, 5];
+        (0, globals_1.expect)((0, rng_utils_1.shuffle)(arr)).toBe(arr);
+    });
+    (0, globals_1.it)('preserves all elements', () => {
+        const original = [1, 2, 3, 4, 5];
+        const result = (0, rng_utils_1.shuffle)([...original]);
+        (0, globals_1.expect)(result.sort((a, b) => a - b)).toEqual(original);
+    });
+    (0, globals_1.it)('handles an empty array', () => {
+        (0, globals_1.expect)((0, rng_utils_1.shuffle)([])).toEqual([]);
+    });
+    (0, globals_1.it)('handles a single-element array', () => {
+        (0, globals_1.expect)((0, rng_utils_1.shuffle)([42])).toEqual([42]);
+    });
+    (0, globals_1.it)('works with string elements', () => {
+        const original = ['a', 'b', 'c', 'd'];
+        const result = (0, rng_utils_1.shuffle)([...original]);
+        (0, globals_1.expect)(result.sort()).toEqual(original.sort());
+    });
+});
+// ─── calculateProbability ────────────────────────────────────────────────────
+(0, globals_1.describe)('calculateProbability()', () => {
+    (0, globals_1.it)('returns 0.5 when score is 0 over full [0, 1] range', () => {
+        (0, globals_1.expect)((0, rng_utils_1.calculateProbability)(0, 100, 0, 1)).toBeCloseTo(0.5, 5);
+    });
+    (0, globals_1.it)('always returns a value within [0, 1]', () => {
+        for (const score of [-1000, -100, -10, 0, 10, 100, 1000]) {
+            const p = (0, rng_utils_1.calculateProbability)(score, 50, 0, 1);
+            (0, globals_1.expect)(p).toBeGreaterThanOrEqual(0);
+            (0, globals_1.expect)(p).toBeLessThanOrEqual(1);
+        }
+    });
+    (0, globals_1.it)('clamps to maxP for very high scores', () => {
+        (0, globals_1.expect)((0, rng_utils_1.calculateProbability)(1e9, 1, 0.1, 0.9)).toBeCloseTo(0.9, 5);
+    });
+    (0, globals_1.it)('clamps to minP for very negative scores', () => {
+        (0, globals_1.expect)((0, rng_utils_1.calculateProbability)(-1e9, 1, 0.1, 0.9)).toBeCloseTo(0.1, 5);
+    });
+    (0, globals_1.it)('returns a higher probability for a higher score (monotone)', () => {
+        const p1 = (0, rng_utils_1.calculateProbability)(10, 100, 0, 1);
+        const p2 = (0, rng_utils_1.calculateProbability)(50, 100, 0, 1);
+        (0, globals_1.expect)(p2).toBeGreaterThan(p1);
+    });
+});
+// ─── createUniqueRandomPicker ────────────────────────────────────────────────
+(0, globals_1.describe)('createUniqueRandomPicker()', () => {
+    (0, globals_1.it)('throws when min > max', () => {
+        (0, globals_1.expect)(() => (0, rng_utils_1.createUniqueRandomPicker)(5, 3)).toThrow('Invalid range');
+    });
+    (0, globals_1.it)('throws for non-integer min', () => {
+        (0, globals_1.expect)(() => (0, rng_utils_1.createUniqueRandomPicker)(0.5, 3)).toThrow('Invalid range');
+    });
+    (0, globals_1.it)('throws for non-integer max', () => {
+        (0, globals_1.expect)(() => (0, rng_utils_1.createUniqueRandomPicker)(0, 2.5)).toThrow('Invalid range');
+    });
+    (0, globals_1.it)('yields each number in [min, max] exactly once per cycle', () => {
+        const picker = (0, rng_utils_1.createUniqueRandomPicker)(1, 5);
+        const results = [];
+        for (let i = 0; i < 5; i++)
+            results.push(picker.next());
+        (0, globals_1.expect)(results.sort((a, b) => a - b)).toEqual([1, 2, 3, 4, 5]);
+    });
+    (0, globals_1.it)('returns NaN after exhausting the pool before reset', () => {
+        const picker = (0, rng_utils_1.createUniqueRandomPicker)(1, 2);
+        picker.next();
+        picker.next();
+        (0, globals_1.expect)(picker.next()).toBeNaN();
+    });
+    (0, globals_1.it)('replenishes the full pool after reset()', () => {
+        const picker = (0, rng_utils_1.createUniqueRandomPicker)(1, 3);
+        for (let i = 0; i < 3; i++)
+            picker.next();
+        picker.reset();
+        const results = [];
+        for (let i = 0; i < 3; i++)
+            results.push(picker.next());
+        (0, globals_1.expect)(results.sort((a, b) => a - b)).toEqual([1, 2, 3]);
+    });
+    (0, globals_1.it)('works for a single-value range', () => {
+        const picker = (0, rng_utils_1.createUniqueRandomPicker)(7, 7);
+        (0, globals_1.expect)(picker.next()).toBe(7);
+        (0, globals_1.expect)(picker.next()).toBeNaN();
+    });
+    (0, globals_1.it)('accepts min === 0', () => {
+        const picker = (0, rng_utils_1.createUniqueRandomPicker)(0, 2);
+        const results = [picker.next(), picker.next(), picker.next()];
+        (0, globals_1.expect)(results.sort((a, b) => a - b)).toEqual([0, 1, 2]);
+    });
+    (0, globals_1.it)('uses a custom rng deterministically', () => {
+        // rng always returns 0 → j=0 in every Fisher-Yates step → pool reversed
+        const picker = (0, rng_utils_1.createUniqueRandomPicker)(0, 2, () => 0);
+        const results = [picker.next(), picker.next(), picker.next()];
+        (0, globals_1.expect)(results.sort((a, b) => a - b)).toEqual([0, 1, 2]);
+    });
+});

package/dist/cjs/src/stat-config/index.d.ts

@@ -0,0 +1,4 @@
+import rolesJSON from './roles.json';
+import traitsJSON from './traits.json';
+import statCapsJSON from './stat-caps.json';
+export { rolesJSON, traitsJSON, statCapsJSON };

package/dist/cjs/src/stat-config/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statCapsJSON = exports.traitsJSON = exports.rolesJSON = void 0;
+const roles_json_1 = __importDefault(require("./roles.json"));
+exports.rolesJSON = roles_json_1.default;
+const traits_json_1 = __importDefault(require("./traits.json"));
+exports.traitsJSON = traits_json_1.default;
+const stat_caps_json_1 = __importDefault(require("./stat-caps.json"));
+exports.statCapsJSON = stat_caps_json_1.default;