volleyballsimtypes 0.0.162 → 0.0.164

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

@@ -0,0 +1,21 @@
+"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("./player"), exports);
+__exportStar(require("./performance-stats"), exports);
+__exportStar(require("./role"), exports);
+__exportStar(require("./trait"), exports);
+__exportStar(require("./rarity"), exports);

package/dist/cjs/src/service/player/performance-stats.d.ts

@@ -0,0 +1,30 @@
+export interface PerformanceStatsParams {
+    readonly setting: number;
+    readonly pass: number;
+    readonly reception: number;
+    readonly spike: number;
+    readonly backAttack: number;
+    readonly jump: number;
+    readonly block: number;
+    readonly awareness: number;
+    readonly serve: number;
+    readonly defense: number;
+    readonly stamina: number;
+}
+export type PerformanceStatsKey = keyof PerformanceStatsParams;
+export declare class PerformanceStats {
+    readonly setting: number;
+    readonly pass: number;
+    readonly reception: number;
+    readonly spike: number;
+    readonly backAttack: number;
+    readonly jump: number;
+    readonly block: number;
+    readonly awareness: number;
+    readonly serve: number;
+    readonly defense: number;
+    readonly stamina: number;
+    constructor(opts: PerformanceStatsParams);
+    toString(): string;
+    static fromAverage(average: number): PerformanceStats;
+}

package/dist/cjs/src/service/player/performance-stats.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceStats = void 0;
+const utils_1 = require("../utils");
+class PerformanceStats {
+    constructor(opts) {
+        this.serve = opts.serve;
+        this.pass = opts.pass;
+        this.setting = opts.setting;
+        this.reception = opts.reception;
+        this.spike = opts.spike;
+        this.backAttack = opts.backAttack;
+        this.jump = opts.jump;
+        this.block = opts.block;
+        this.awareness = opts.awareness;
+        this.defense = opts.defense;
+        this.stamina = opts.stamina;
+    }
+    toString() {
+        return (0, utils_1.getKeys)(this).map(key => `${key}: ${this[key]}`).join(', ');
+    }
+    static fromAverage(average) {
+        return new PerformanceStats({
+            setting: average,
+            pass: average,
+            reception: average,
+            spike: average,
+            backAttack: average,
+            jump: average,
+            block: average,
+            awareness: average,
+            serve: average,
+            defense: average,
+            stamina: average
+        });
+    }
+}
+exports.PerformanceStats = PerformanceStats;

package/dist/cjs/src/service/player/player.d.ts

@@ -0,0 +1,49 @@
+import { PerformanceStats } from './performance-stats';
+import { Role } from './role';
+import { Trait } from './trait';
+import { Country } from '../country';
+import * as GeneralStat from '../../formula/stats';
+import { Rarity } from './rarity';
+export declare class Stat {
+    readonly name: GeneralStat.Stats;
+    readonly value: number;
+    constructor({ name, value }: {
+        name: GeneralStat.Stats;
+        value: number;
+    });
+    toString(): string;
+}
+interface PlayerParams {
+    readonly id: string;
+    readonly name: Name;
+    readonly country: Country;
+    readonly stats: PerformanceStats;
+    readonly roles: Role[];
+    readonly traits: Trait[];
+    readonly rarity: Rarity;
+}
+export declare class Name {
+    readonly first: string;
+    readonly last: string;
+    constructor({ first, last }: {
+        first: string;
+        last: string;
+    });
+    toString(): string;
+}
+export declare class Player {
+    readonly id: string;
+    readonly name: Name;
+    readonly country: Country;
+    readonly stats: PerformanceStats;
+    readonly roles: Role[];
+    readonly traits: Trait[];
+    readonly generalStats: Stat[];
+    readonly rarity: Rarity;
+    constructor({ id, name, country, stats, roles, traits, rarity }: PlayerParams);
+    static sortPlayers(roles: Role[]): (p1: Player, p2: Player) => number;
+    static compareStats(p1: Player, p2: Player): number;
+    canPlayLibero(): boolean;
+    toString(): string;
+}
+export {};

package/dist/cjs/src/service/player/player.js

@@ -0,0 +1,114 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Player = exports.Name = exports.Stat = void 0;
+const role_1 = require("./role");
+const utils_1 = require("../utils");
+const GeneralStat = __importStar(require("../../formula/stats"));
+class Stat {
+    constructor({ name, value }) {
+        this.name = name;
+        this.value = value;
+    }
+    toString() {
+        return `${this.name}: ${this.value}`;
+    }
+}
+exports.Stat = Stat;
+class Name {
+    constructor({ first, last }) {
+        this.first = first;
+        this.last = last;
+    }
+    toString() {
+        return `${this.first} ${this.last}`;
+    }
+}
+exports.Name = Name;
+class Player {
+    constructor({ id, name, country, stats, roles, traits, rarity }) {
+        (0, utils_1.validateUUID)(id);
+        this.id = id;
+        this.name = name;
+        this.country = country;
+        this.stats = stats;
+        this.roles = roles;
+        this.traits = traits;
+        this.rarity = rarity;
+        this.generalStats = GeneralStat.ALL_STATS.map(stat => ({
+            name: stat,
+            value: GeneralStat.calculateScore(stats, stat)
+        }));
+    }
+    // Used as a base sorting function for players
+    static sortPlayers(roles) {
+        return (p1, p2) => roles.reduce((x, role) => {
+            const p2Score = role_1.Role.calculateScore(p2.stats, role);
+            const p1Score = role_1.Role.calculateScore(p1.stats, role);
+            return x + p2Score - p1Score;
+        }, 0);
+    }
+    static compareStats(p1, p2) {
+        const compareFn = (acc, current) => {
+            let x = current.value;
+            switch (current.name) {
+                case 'ATTACK':
+                    x *= 0.35;
+                    break;
+                case 'DEFENSE':
+                    x *= 0.35;
+                    break;
+                case 'SERVE':
+                    x *= 0.2;
+                    break;
+                case 'PHYSICAL':
+                    x *= 0.1;
+                    break;
+                default:
+                    x *= 0;
+            }
+            return acc + x;
+        };
+        const s1 = p1.generalStats.reduce(compareFn, 0);
+        const s2 = p2.generalStats.reduce(compareFn, 0);
+        return s2 - s1;
+    }
+    canPlayLibero() {
+        return this.roles.includes(role_1.Role.LIBERO);
+    }
+    toString() {
+        return JSON.stringify({
+            id: this.id,
+            name: this.name.toString(),
+            country: this.country.toString(),
+            stats: this.stats.toString(),
+            rarity: this.rarity,
+            roles: `[${this.roles.map(r => r.toString()).join(',')}]`,
+            traits: `[${this.traits.map(r => r.toString()).join(',')}]`,
+            generalStats: `[${this.generalStats.map(r => r.toString()).join(',')}]`
+        });
+    }
+}
+exports.Player = Player;

package/dist/cjs/src/service/player/rarity.d.ts

@@ -0,0 +1,14 @@
+export declare enum Rarity {
+    COMMON = "COMMON",
+    RARE = "RARE",
+    LEGENDARY = "LEGENDARY",
+    MYTHIC = "MYTHIC",
+    SPECIAL = "SPECIAL"
+}
+export declare const RarityRanges: {
+    COMMON: number[];
+    RARE: number[];
+    LEGENDARY: number[];
+    MYTHIC: number[];
+    SPECIAL: number[];
+};

package/dist/cjs/src/service/player/rarity.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RarityRanges = exports.Rarity = void 0;
+var Rarity;
+(function (Rarity) {
+    Rarity["COMMON"] = "COMMON";
+    Rarity["RARE"] = "RARE";
+    Rarity["LEGENDARY"] = "LEGENDARY";
+    Rarity["MYTHIC"] = "MYTHIC";
+    Rarity["SPECIAL"] = "SPECIAL";
+})(Rarity = exports.Rarity || (exports.Rarity = {}));
+exports.RarityRanges = {
+    [Rarity.COMMON]: [0, 50],
+    [Rarity.RARE]: [51, 70],
+    [Rarity.LEGENDARY]: [71, 85],
+    [Rarity.MYTHIC]: [86, 98],
+    [Rarity.SPECIAL]: [99, 100]
+};

package/dist/cjs/src/service/player/role.d.ts

@@ -0,0 +1,16 @@
+import { Roles } from '../../formula';
+import { PerformanceStats } from './performance-stats';
+export declare class Role {
+    static readonly SETTER: Role;
+    static readonly LIBERO: Role;
+    static readonly OUTSIDE_HITTER: Role;
+    static readonly OPPOSITE_HITTER: Role;
+    static readonly MIDDLE_BLOCKER: Role;
+    private static readonly ROLES;
+    readonly name: Roles;
+    private constructor();
+    toString(): string;
+    static getRoles(): Role[];
+    static calculateScore(stats: PerformanceStats, role: Role): number;
+    static assignRoles(stats: PerformanceStats): Role[];
+}

package/dist/cjs/src/service/player/role.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Role = void 0;
+const formula_1 = require("../../formula");
+class Role {
+    constructor(name) {
+        this.name = name;
+    }
+    toString() {
+        return this.name;
+    }
+    static getRoles() {
+        return [...Role.ROLES];
+    }
+    static calculateScore(stats, role) {
+        const weights = formula_1.rolesFormula.find(r => r.role === role.name);
+        if (weights == null)
+            throw new Error('COULD_NOT_FIND_ROLE_WEIGHT');
+        const score = Object.entries(weights.weight)
+            .reduce((score, [key, value]) => score + (stats[key] * weights.weight[key]), 0);
+        return Math.round(score);
+    }
+    static assignRoles(stats) {
+        const scores = this.getRoles().map(role => ({
+            role,
+            score: this.calculateScore(stats, role)
+        })).sort((x, y) => y.score - x.score);
+        const out = [scores[0].role];
+        if (scores[1].score >= 75) {
+            out.push(scores[1].role);
+        }
+        if (scores[2].score >= 85) {
+            out.push(scores[2].role);
+        }
+        return out;
+    }
+}
+exports.Role = Role;
+Role.SETTER = new Role('SETTER');
+Role.LIBERO = new Role('LIBERO');
+Role.OUTSIDE_HITTER = new Role('OUTSIDE_HITTER');
+Role.OPPOSITE_HITTER = new Role('OPPOSITE_HITTER');
+Role.MIDDLE_BLOCKER = new Role('MIDDLE_BLOCKER');
+Role.ROLES = [Role.LIBERO, Role.SETTER, Role.OPPOSITE_HITTER, Role.OUTSIDE_HITTER, Role.MIDDLE_BLOCKER];

package/dist/cjs/src/service/player/trait.d.ts

@@ -0,0 +1,22 @@
+import * as GeneralStat from '../../formula/stats';
+import { PerformanceStats } from './performance-stats';
+import { Rarity } from './rarity';
+export declare class Trait {
+    static readonly MASTER_MIND: Trait;
+    static readonly MOVING_WALL: Trait;
+    static readonly MARKSMAN: Trait;
+    static readonly METEOR_SERVE: Trait;
+    static readonly VIGOROUS: Trait;
+    static readonly GUARDIAN: Trait;
+    readonly id: string;
+    readonly name: string;
+    readonly modifier: number;
+    readonly chance: number;
+    readonly statThreshold: number;
+    readonly stat: GeneralStat.Stats;
+    readonly weight: number;
+    private constructor();
+    static getTraits(): Trait[];
+    static assignTraits(performanceStats: PerformanceStats, rarity: Rarity): Trait[];
+    toString(): string;
+}

package/dist/cjs/src/service/player/trait.js

@@ -0,0 +1,148 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trait = void 0;
+const GeneralStat = __importStar(require("../../formula/stats"));
+const rarity_1 = require("./rarity");
+const node_crypto_1 = require("node:crypto");
+class Trait {
+    constructor({ id, name, modifier, chance, statThreshold, stat, weight }) {
+        this.id = id;
+        this.name = name;
+        this.modifier = modifier;
+        this.chance = chance;
+        this.statThreshold = statThreshold;
+        this.stat = stat;
+        this.weight = weight;
+    }
+    static getTraits() {
+        return [Trait.GUARDIAN, Trait.MARKSMAN, Trait.METEOR_SERVE, Trait.VIGOROUS, Trait.MOVING_WALL, Trait.MASTER_MIND];
+    }
+    static assignTraits(performanceStats, rarity) {
+        let traitCount;
+        switch (rarity) {
+            case rarity_1.Rarity.COMMON: {
+                traitCount = 0;
+                break;
+            }
+            case rarity_1.Rarity.RARE: {
+                traitCount = (0, node_crypto_1.randomInt)(0, 1);
+                break;
+            }
+            case rarity_1.Rarity.LEGENDARY: {
+                traitCount = (0, node_crypto_1.randomInt)(0, 2);
+                break;
+            }
+            case rarity_1.Rarity.MYTHIC: {
+                traitCount = (0, node_crypto_1.randomInt)(1, 3);
+                break;
+            }
+            case rarity_1.Rarity.SPECIAL: {
+                traitCount = (0, node_crypto_1.randomInt)(2, 3);
+                break;
+            }
+            default:
+                throw new Error('INVALID_RARITY');
+        }
+        if (traitCount < 1)
+            return [];
+        const qualifiedTraits = this.getTraits()
+            .filter(trait => GeneralStat.calculateScore(performanceStats, trait.stat) >= trait.statThreshold);
+        return qualifiedTraits.sort((t1, t2) => t2.weight - t1.weight)
+            .slice(0, traitCount);
+    }
+    toString() {
+        return JSON.stringify({
+            name: this.name,
+            modifier: this.modifier,
+            statThreshold: this.statThreshold,
+            chance: this.chance,
+            stat: this.stat,
+            weight: this.weight
+        });
+    }
+}
+exports.Trait = Trait;
+// A Setter gets a bonus to their score, and the receiving attacker gets a bonus as well.
+// Stacks with attacker bonus
+Trait.MASTER_MIND = new Trait({
+    id: '0117a315-a743-43e3-9ec2-ad5cf700ef08',
+    name: 'Master Mind',
+    modifier: 1.1,
+    chance: 0.2,
+    statThreshold: 80,
+    stat: 'ATTACK',
+    weight: 10
+});
+// Will always participate in blocking regardless of chance and adds
+Trait.MOVING_WALL = new Trait({
+    id: '304c53f6-5e7a-44d3-9625-f10d8109421a',
+    name: 'Moving Wall',
+    modifier: 1.1,
+    chance: 1,
+    statThreshold: 75,
+    stat: 'DEFENSE',
+    weight: 5
+});
+// On attack, will always pick the worst receiver and adds a 10% to score
+Trait.MARKSMAN = new Trait({
+    id: 'ace3458e-69ab-487c-a9c0-d656f705d8dd',
+    name: 'Marksman',
+    modifier: 1.05,
+    chance: 0.3,
+    statThreshold: 75,
+    stat: 'ATTACK',
+    weight: 5
+});
+// Increases the score of the serve by 10% when serve type is Jumping.
+Trait.METEOR_SERVE = new Trait({
+    id: 'c929a79d-5866-40d6-bbd6-b0b67a929c4c',
+    name: 'Meteor Serve',
+    modifier: 1.1,
+    chance: 0.1,
+    statThreshold: 75,
+    stat: 'SERVE',
+    weight: 10
+});
+// Has a 50% chance of taking an action without decreasing energy.
+Trait.VIGOROUS = new Trait({
+    id: 'f9599b87-b3b2-49ce-8224-470f6fe6ed64',
+    name: 'Vigorous',
+    modifier: 1,
+    statThreshold: 60,
+    chance: 0.5,
+    stat: 'PHYSICAL',
+    weight: 1
+});
+// Takes place of the receiver and increases reception score by 15%, guaranteeing success. Can only trigger in back-row.
+Trait.GUARDIAN = new Trait({
+    id: 'c3291953-9256-4559-b5a9-955ccb8f9a6f',
+    name: 'Guardian',
+    chance: 0.2,
+    statThreshold: 75,
+    modifier: 1.15,
+    stat: 'DEFENSE',
+    weight: 10
+});

package/dist/cjs/src/service/team/index.d.ts

@@ -0,0 +1 @@
+export * from './team';

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

@@ -0,0 +1,17 @@
+"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("./team"), exports);

package/dist/cjs/src/service/team/team.d.ts

@@ -0,0 +1,31 @@
+import { Coach } from '../coach';
+import { Player } from '../player';
+import { Country } from '../country';
+import { League } from '../competition';
+interface TeamParams {
+    readonly id: string;
+    readonly rating: number;
+    readonly name: string;
+    readonly shortName: string;
+    readonly roster: Player[];
+    readonly country?: Country;
+    readonly league?: League;
+    readonly coach?: Coach;
+}
+export declare class Team {
+    readonly id: string;
+    readonly roster: Player[];
+    readonly name: string;
+    readonly shortName: string;
+    readonly coach?: Coach;
+    readonly league?: League;
+    readonly country?: Country;
+    private _rating;
+    constructor({ id, rating, name, shortName, country, roster, coach, league }: TeamParams);
+    get rating(): number;
+    set rating(value: number);
+    isPlayerInRoster(player: Player): boolean;
+    toString(): string;
+    updateRating(rankingPoints: number): void;
+}
+export {};

package/dist/cjs/src/service/team/team.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Team = void 0;
+const utils_1 = require("../utils");
+class Team {
+    constructor({ id, rating, name, shortName, country, roster, coach, league }) {
+        (0, utils_1.validateUUID)(id);
+        this.id = id;
+        this._rating = rating;
+        this.roster = roster;
+        this.coach = coach;
+        this.name = name;
+        this.shortName = shortName;
+        this.country = country;
+        this.league = league;
+    }
+    get rating() {
+        return this._rating;
+    }
+    set rating(value) {
+        this._rating = value;
+    }
+    isPlayerInRoster(player) {
+        return this.roster.some(p => p.id === player.id);
+    }
+    toString() {
+        if (this.country == null) {
+            throw new Error('UNKNOWN_COUNTRY');
+        }
+        return `${this.name} [${this.shortName}] (${this.country?.name}) ELO=${this._rating}`;
+    }
+    updateRating(rankingPoints) {
+        this._rating += rankingPoints;
+    }
+}
+exports.Team = Team;

package/dist/cjs/src/service/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './string-utils';
+export * from './object-utils';

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

@@ -0,0 +1,18 @@
+"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);

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

@@ -0,0 +1 @@
+export declare const getKeys: <T extends object>(obj: T) => (keyof T)[];

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

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

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

@@ -0,0 +1,2 @@
+export declare function formatNumber(n: number): string;
+export declare function validateUUID(uuid: string): boolean;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateUUID = exports.formatNumber = void 0;
+function formatNumber(n) {
+    if (n < 0)
+        throw new Error('UNEXPECTED_NEGATIVE_NUMBER');
+    return n < 10 ? `0${n}` : `${n}`;
+}
+exports.formatNumber = formatNumber;
+function validateUUID(uuid) {
+    const regex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/;
+    if (!regex.test(uuid))
+        throw new Error('INVALID_UUID');
+    return true;
+}
+exports.validateUUID = validateUUID;