volleyballsimtypes 0.0.358 → 0.0.359

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

@@ -1,80 +0,0 @@
-import { RarityEnum } from './rarity';
-import { randomInt } from 'node:crypto';
-import rawTraits from '../../stat-config/traits.json';
-import { shuffle } from '../utils';
-const traits = rawTraits;
-export var TraitEnum;
-(function (TraitEnum) {
-    /**
-     * When triggered, all actions before the net crossing have a bonus.
-     * Can only be triggered during the first or second touch.
-     */
-    TraitEnum["MASTER_MIND"] = "MASTER_MIND";
-    /**
-     * When this player is part of the front row, they will always be part of the blocking block
-     */
-    TraitEnum["MOVING_WALL"] = "MOVING_WALL";
-    /**
-     * Enables the player making the second touch to spike or dump
-     */
-    TraitEnum["SURPRISE_ATTACK"] = "SURPRISE_ATTACK";
-    /**
-     * Boosts the stat of the action taken and allows the player to choose the best target for the action.
-     */
-    TraitEnum["MARKSMAN"] = "MARKSMAN";
-    /**
-     * The server will perform an extra strong serve.
-     */
-    TraitEnum["METEOR_SERVE"] = "METEOR_SERVE";
-    /**
-     * The player has a 50% chance to perform an action with no energy decrease
-     */
-    TraitEnum["VIGOROUS"] = "VIGOROUS";
-    /**
-     * The player with this trait has a chance to take the receiver's place if their reception stat is higher.
-     */
-    TraitEnum["GUARDIAN"] = "GUARDIAN";
-    /**
-     * Enables the server to perform a float serve, which checks against receiver overhand instead.
-     */
-    TraitEnum["FLOAT_SERVE"] = "FLOAT_SERVE";
-    /**
-     * Gives the player a chance to perform a perfect reception.
-     */
-    TraitEnum["DEFENSIVE_SPECIALIST"] = "DEFENSIVE_SPECIALIST";
-})(TraitEnum || (TraitEnum = {}));
-export function assignTraits(roles, rarity, maxTraits) {
-    let traitCount;
-    switch (rarity) {
-        case RarityEnum.COMMON: {
-            traitCount = maxTraits === true ? 0 : randomInt(0, 1);
-            break;
-        }
-        case RarityEnum.RARE: {
-            traitCount = maxTraits === true ? 1 : randomInt(0, 2);
-            break;
-        }
-        case RarityEnum.LEGENDARY: {
-            traitCount = maxTraits === true ? 2 : randomInt(1, 3);
-            break;
-        }
-        case RarityEnum.MYTHIC: {
-            traitCount = maxTraits === true ? 3 : randomInt(2, 4);
-            break;
-        }
-        case RarityEnum.SPECIAL: {
-            traitCount = 4;
-            break;
-        }
-        default:
-            throw new Error('INVALID_RARITY');
-    }
-    if (traitCount < 1)
-        return [];
-    const filteredTraits = traits.filter((trait) => {
-        const setA = new Set(trait.roles);
-        return roles.some(el => setA.has(el));
-    }).map(trait => trait.name);
-    return shuffle(filteredTraits).slice(0, traitCount);
-}
-export const traitMap = new Map(traits.map((trait) => [trait.name, trait]));

package/dist/esm/src/service/team/formation.d.ts

@@ -1,30 +0,0 @@
-import { Role } from '../player';
-import { CourtPosition } from '../match';
-interface PositionRole {
-    readonly [CourtPosition.LEFT_FRONT]: Role[];
-    readonly [CourtPosition.MIDDLE_FRONT]: Role[];
-    readonly [CourtPosition.RIGHT_FRONT]: Role[];
-    readonly [CourtPosition.LEFT_BACK]: Role[];
-    readonly [CourtPosition.MIDDLE_BACK]: Role[];
-    readonly [CourtPosition.RIGHT_BACK]: Role[];
-}
-export interface SubPriority {
-    readonly MIDDLE_BLOCKER: number;
-    readonly OUTSIDE_HITTER: number;
-    readonly OPPOSITE_HITTER: number;
-    readonly SETTER: number;
-    readonly LIBERO: number;
-}
-export declare class Formation {
-    static readonly '5-1': Formation;
-    static readonly '4-2': Formation;
-    static readonly '6-2': Formation;
-    readonly name: string;
-    readonly initialRotation: PositionRole;
-    readonly base: PositionRole;
-    readonly liberoSubPriority: SubPriority;
-    static create(input: unknown): Formation;
-    private constructor();
-    static getFormations(): Formation[];
-}
-export {};

package/dist/esm/src/service/team/formation.js

@@ -1,104 +0,0 @@
-import { RoleEnum } from '../player';
-import { CourtPosition } from '../match';
-import { FormationInputSchema } from './schemas/formation.z';
-export class Formation {
-    static create(input) {
-        const result = FormationInputSchema.safeParse(input);
-        if (!result.success) {
-            throw new Error(`INVALID_FORMATION: ${result.error.message}. RECEIVED=${(() => { try {
-                return JSON.stringify(input);
-            }
-            catch {
-                return String(input);
-            } })()}`);
-        }
-        return new Formation(result.data);
-    }
-    constructor({ name, initialRotation, base, liberoSubPriority }) {
-        this.name = name;
-        this.initialRotation = initialRotation;
-        this.base = base;
-        this.liberoSubPriority = liberoSubPriority;
-    }
-    static getFormations() {
-        return [this['4-2'], this['5-1'], this['6-2']];
-    }
-}
-Formation['5-1'] = Formation.create({
-    name: '5-1',
-    initialRotation: {
-        1: [RoleEnum.SETTER],
-        2: [RoleEnum.OUTSIDE_HITTER],
-        3: [RoleEnum.MIDDLE_BLOCKER],
-        4: [RoleEnum.OPPOSITE_HITTER],
-        5: [RoleEnum.OUTSIDE_HITTER],
-        6: [RoleEnum.MIDDLE_BLOCKER]
-    },
-    base: {
-        1: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER],
-        2: [RoleEnum.OPPOSITE_HITTER],
-        3: [RoleEnum.MIDDLE_BLOCKER],
-        4: [RoleEnum.OUTSIDE_HITTER],
-        5: [RoleEnum.OUTSIDE_HITTER],
-        6: [RoleEnum.LIBERO, RoleEnum.MIDDLE_BLOCKER]
-    },
-    liberoSubPriority: {
-        MIDDLE_BLOCKER: 1,
-        OUTSIDE_HITTER: 10,
-        OPPOSITE_HITTER: 100,
-        SETTER: 1000,
-        LIBERO: 10000
-    }
-});
-Formation['4-2'] = Formation.create({
-    name: '4-2',
-    initialRotation: {
-        1: [RoleEnum.SETTER],
-        2: [RoleEnum.OUTSIDE_HITTER],
-        3: [RoleEnum.MIDDLE_BLOCKER],
-        4: [RoleEnum.SETTER],
-        5: [RoleEnum.OUTSIDE_HITTER],
-        6: [RoleEnum.MIDDLE_BLOCKER]
-    },
-    base: {
-        1: [RoleEnum.SETTER],
-        2: [RoleEnum.SETTER],
-        3: [RoleEnum.MIDDLE_BLOCKER],
-        4: [RoleEnum.OUTSIDE_HITTER],
-        5: [RoleEnum.OUTSIDE_HITTER],
-        6: [RoleEnum.LIBERO, RoleEnum.MIDDLE_BLOCKER]
-    },
-    liberoSubPriority: {
-        MIDDLE_BLOCKER: 1,
-        OUTSIDE_HITTER: 10,
-        OPPOSITE_HITTER: 100,
-        SETTER: 1000,
-        LIBERO: 10000
-    }
-});
-Formation['6-2'] = Formation.create({
-    name: '6-2',
-    initialRotation: {
-        1: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER, RoleEnum.OUTSIDE_HITTER],
-        2: [RoleEnum.OUTSIDE_HITTER],
-        3: [RoleEnum.MIDDLE_BLOCKER],
-        4: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER, RoleEnum.OUTSIDE_HITTER],
-        5: [RoleEnum.OUTSIDE_HITTER],
-        6: [RoleEnum.MIDDLE_BLOCKER]
-    },
-    base: {
-        1: [RoleEnum.SETTER, RoleEnum.OPPOSITE_HITTER],
-        2: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER],
-        3: [RoleEnum.MIDDLE_BLOCKER],
-        4: [RoleEnum.OUTSIDE_HITTER],
-        5: [RoleEnum.OUTSIDE_HITTER],
-        6: [RoleEnum.LIBERO, RoleEnum.MIDDLE_BLOCKER]
-    },
-    liberoSubPriority: {
-        MIDDLE_BLOCKER: 1,
-        OUTSIDE_HITTER: 10,
-        OPPOSITE_HITTER: 100,
-        SETTER: 1000,
-        LIBERO: 10000
-    }
-});

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

@@ -1,4 +0,0 @@
-export * from './team';
-export * from './team-generator';
-export * from './formation';
-export * from './tactics';

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

@@ -1,4 +0,0 @@
-export * from './team';
-export * from './team-generator';
-export * from './formation';
-export * from './tactics';

package/dist/esm/src/service/team/schemas/formation.z.d.ts

@@ -1,101 +0,0 @@
-import { z } from 'zod';
-import { RoleEnum } from '../../player';
-export declare const FormationInputSchema: z.ZodObject<{
-    name: z.ZodString;
-    initialRotation: z.ZodObject<{
-        4: z.ZodArray<z.ZodEnum<{
-            SETTER: RoleEnum.SETTER;
-            LIBERO: RoleEnum.LIBERO;
-            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
-            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
-            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
-        }>>;
-        3: z.ZodArray<z.ZodEnum<{
-            SETTER: RoleEnum.SETTER;
-            LIBERO: RoleEnum.LIBERO;
-            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
-            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
-            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
-        }>>;
-        2: z.ZodArray<z.ZodEnum<{
-            SETTER: RoleEnum.SETTER;
-            LIBERO: RoleEnum.LIBERO;
-            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
-            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
-            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
-        }>>;
-        5: z.ZodArray<z.ZodEnum<{
-            SETTER: RoleEnum.SETTER;
-            LIBERO: RoleEnum.LIBERO;
-            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
-            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
-            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
-        }>>;
-        6: z.ZodArray<z.ZodEnum<{
-            SETTER: RoleEnum.SETTER;
-            LIBERO: RoleEnum.LIBERO;
-            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
-            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
-            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
-        }>>;
-        1: z.ZodArray<z.ZodEnum<{
-            SETTER: RoleEnum.SETTER;
-            LIBERO: RoleEnum.LIBERO;
-            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
-            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
-            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
-        }>>;
-    }, z.core.$strip>;
-    base: z.ZodObject<{
-        4: z.ZodArray<z.ZodEnum<{
-            SETTER: RoleEnum.SETTER;
-            LIBERO: RoleEnum.LIBERO;
-            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
-            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
-            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
-        }>>;
-        3: z.ZodArray<z.ZodEnum<{
-            SETTER: RoleEnum.SETTER;
-            LIBERO: RoleEnum.LIBERO;
-            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
-            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
-            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
-        }>>;
-        2: z.ZodArray<z.ZodEnum<{
-            SETTER: RoleEnum.SETTER;
-            LIBERO: RoleEnum.LIBERO;
-            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
-            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
-            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
-        }>>;
-        5: z.ZodArray<z.ZodEnum<{
-            SETTER: RoleEnum.SETTER;
-            LIBERO: RoleEnum.LIBERO;
-            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
-            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
-            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
-        }>>;
-        6: z.ZodArray<z.ZodEnum<{
-            SETTER: RoleEnum.SETTER;
-            LIBERO: RoleEnum.LIBERO;
-            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
-            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
-            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
-        }>>;
-        1: z.ZodArray<z.ZodEnum<{
-            SETTER: RoleEnum.SETTER;
-            LIBERO: RoleEnum.LIBERO;
-            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
-            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
-            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
-        }>>;
-    }, z.core.$strip>;
-    liberoSubPriority: z.ZodObject<{
-        MIDDLE_BLOCKER: z.ZodNumber;
-        OUTSIDE_HITTER: z.ZodNumber;
-        OPPOSITE_HITTER: z.ZodNumber;
-        SETTER: z.ZodNumber;
-        LIBERO: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type FormationInput = z.infer<typeof FormationInputSchema>;

package/dist/esm/src/service/team/schemas/formation.z.js

@@ -1,30 +0,0 @@
-import { z } from 'zod';
-import { RoleEnum } from '../../player';
-const roleSchema = z.enum(Object.values(RoleEnum));
-const LEFT_FRONT = 4;
-const MIDDLE_FRONT = 3;
-const RIGHT_FRONT = 2;
-const LEFT_BACK = 5;
-const MIDDLE_BACK = 6;
-const RIGHT_BACK = 1;
-const positionRoleSchema = z.object({
-    [LEFT_FRONT]: z.array(roleSchema).min(1),
-    [MIDDLE_FRONT]: z.array(roleSchema).min(1),
-    [RIGHT_FRONT]: z.array(roleSchema).min(1),
-    [LEFT_BACK]: z.array(roleSchema).min(1),
-    [MIDDLE_BACK]: z.array(roleSchema).min(1),
-    [RIGHT_BACK]: z.array(roleSchema).min(1)
-});
-const subPrioritySchema = z.object({
-    MIDDLE_BLOCKER: z.number().int().min(1),
-    OUTSIDE_HITTER: z.number().int().min(1),
-    OPPOSITE_HITTER: z.number().int().min(1),
-    SETTER: z.number().int().min(1),
-    LIBERO: z.number().int().min(1)
-});
-export const FormationInputSchema = z.object({
-    name: z.string().trim().min(1),
-    initialRotation: positionRoleSchema,
-    base: positionRoleSchema,
-    liberoSubPriority: subPrioritySchema
-});

package/dist/esm/src/service/team/schemas/tactics.z.d.ts

@@ -1,18 +0,0 @@
-import { z } from 'zod';
-import { Player } from '../../player';
-export declare const TacticsInputSchema: z.ZodObject<{
-    lineup: z.ZodObject<{
-        4: z.ZodCustom<Player, Player>;
-        3: z.ZodCustom<Player, Player>;
-        2: z.ZodCustom<Player, Player>;
-        5: z.ZodCustom<Player, Player>;
-        6: z.ZodCustom<Player, Player>;
-        1: z.ZodCustom<Player, Player>;
-        0: z.ZodOptional<z.ZodCustom<Player, Player>>;
-        bench: z.ZodArray<z.ZodCustom<Player, Player>>;
-    }, z.core.$strip>;
-    substitutionTolerance: z.ZodNumber;
-    liberoReplacements: z.ZodArray<z.ZodCustom<Player, Player>>;
-    pinchServerSubs: z.ZodCustom<Map<Player, Player>, Map<Player, Player>>;
-}, z.core.$strip>;
-export type TacticsInput = z.infer<typeof TacticsInputSchema>;

package/dist/esm/src/service/team/schemas/tactics.z.js

@@ -1,49 +0,0 @@
-import { z } from 'zod';
-import { Player } from '../../player';
-const playerInstanceSchema = z.custom((v) => v instanceof Player, {
-    message: 'INVALID_PLAYER_INSTANCE'
-});
-const LEFT_FRONT = 4;
-const MIDDLE_FRONT = 3;
-const RIGHT_FRONT = 2;
-const LEFT_BACK = 5;
-const MIDDLE_BACK = 6;
-const RIGHT_BACK = 1;
-const LIBERO_ZONE = 0;
-const lineupSchema = z.object({
-    [LEFT_FRONT]: playerInstanceSchema,
-    [MIDDLE_FRONT]: playerInstanceSchema,
-    [RIGHT_FRONT]: playerInstanceSchema,
-    [LEFT_BACK]: playerInstanceSchema,
-    [MIDDLE_BACK]: playerInstanceSchema,
-    [RIGHT_BACK]: playerInstanceSchema,
-    [LIBERO_ZONE]: playerInstanceSchema.optional(),
-    bench: z.array(playerInstanceSchema)
-}).superRefine((data, ctx) => {
-    const players = [
-        data[LEFT_FRONT],
-        data[MIDDLE_FRONT],
-        data[RIGHT_FRONT],
-        data[LEFT_BACK],
-        data[MIDDLE_BACK],
-        data[RIGHT_BACK],
-        ...(data[LIBERO_ZONE] != null ? [data[LIBERO_ZONE]] : []),
-        ...data.bench
-    ];
-    const ids = players.map(p => p.id);
-    const uniqueCount = new Set(ids).size;
-    if (uniqueCount !== ids.length) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'LINEUP_HAS_DUPLICATE_PLAYERS',
-            path: ['bench']
-        });
-    }
-});
-export const TacticsInputSchema = z.object({
-    lineup: lineupSchema,
-    substitutionTolerance: z.number().int().min(1).max(50),
-    liberoReplacements: z.array(playerInstanceSchema),
-    pinchServerSubs: z.custom((v) => v instanceof Map &&
-        Array.from(v.entries()).every(([k, val]) => k instanceof Player && val instanceof Player), { message: 'INVALID_PINCH_SERVER_SUBS' })
-});

package/dist/esm/src/service/team/schemas/team.z.d.ts

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-import { Player } from '../../player';
-import { Country } from '../../country';
-export declare const TeamInputSchema: z.ZodObject<{
-    id: z.ZodUUID;
-    rating: z.ZodNumber;
-    name: z.ZodString;
-    shortName: z.ZodString;
-    divisionId: z.ZodUUID;
-    roster: z.ZodArray<z.ZodCustom<Player, Player>>;
-    country: z.ZodCustom<Country, Country>;
-    tactics: z.ZodOptional<z.ZodObject<{
-        lineup: z.ZodObject<{
-            4: z.ZodCustom<Player, Player>;
-            3: z.ZodCustom<Player, Player>;
-            2: z.ZodCustom<Player, Player>;
-            5: z.ZodCustom<Player, Player>;
-            6: z.ZodCustom<Player, Player>;
-            1: z.ZodCustom<Player, Player>;
-            0: z.ZodOptional<z.ZodCustom<Player, Player>>;
-            bench: z.ZodArray<z.ZodCustom<Player, Player>>;
-        }, z.core.$strip>;
-        substitutionTolerance: z.ZodNumber;
-        liberoReplacements: z.ZodArray<z.ZodCustom<Player, Player>>;
-        pinchServerSubs: z.ZodCustom<Map<Player, Player>, Map<Player, Player>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type TeamInput = z.infer<typeof TeamInputSchema>;

package/dist/esm/src/service/team/schemas/team.z.js

@@ -1,29 +0,0 @@
-import { z } from 'zod';
-import { Player } from '../../player';
-import { Country } from '../../country';
-import { TacticsInputSchema } from './tactics.z';
-const playerInstanceSchema = z.custom((v) => v instanceof Player, {
-    message: 'INVALID_PLAYER_INSTANCE'
-});
-const countrySchema = z.custom((v) => v instanceof Country, {
-    message: 'INVALID_COUNTRY_INSTANCE'
-});
-export const TeamInputSchema = z.object({
-    id: z.uuid(),
-    rating: z.number().finite(),
-    name: z.string().trim().min(1),
-    shortName: z.string().trim().min(1),
-    divisionId: z.uuid(),
-    roster: z.array(playerInstanceSchema),
-    country: countrySchema,
-    tactics: TacticsInputSchema.optional()
-}).superRefine((data, ctx) => {
-    const ids = data.roster.map(p => p.id);
-    if (new Set(ids).size !== ids.length) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'TEAM_ROSTER_HAS_DUPLICATE_PLAYERS',
-            path: ['roster']
-        });
-    }
-});

package/dist/esm/src/service/team/tactics.d.ts

@@ -1,27 +0,0 @@
-import { CourtPosition } from '../match';
-import { Player } from '../player';
-export interface StartingLineup {
-    readonly [CourtPosition.LEFT_FRONT]: Player;
-    readonly [CourtPosition.MIDDLE_FRONT]: Player;
-    readonly [CourtPosition.RIGHT_FRONT]: Player;
-    readonly [CourtPosition.LEFT_BACK]: Player;
-    readonly [CourtPosition.MIDDLE_BACK]: Player;
-    readonly [CourtPosition.RIGHT_BACK]: Player;
-    readonly [CourtPosition.LIBERO_ZONE]?: Player;
-    readonly bench: Player[];
-}
-export interface TacticsOpts {
-    readonly lineup: StartingLineup;
-    readonly substitutionTolerance: number;
-    readonly liberoReplacements: Player[];
-    readonly pinchServerSubs: Map<Player, Player>;
-}
-export declare class Tactics {
-    readonly lineup: StartingLineup;
-    readonly substitutionTolerance: number;
-    readonly liberoReplacements: Player[];
-    readonly pinchServerSubs: Map<Player, Player>;
-    static create(input: unknown): Tactics;
-    private constructor();
-    findPlayerInLineup(id: string): CourtPosition | undefined;
-}

package/dist/esm/src/service/team/tactics.js

@@ -1,40 +0,0 @@
-import { CourtPosition } from '../match';
-import { TacticsInputSchema } from './schemas/tactics.z';
-export class Tactics {
-    static create(input) {
-        const result = TacticsInputSchema.safeParse(input);
-        if (!result.success) {
-            throw new Error(`INVALID_TACTICS: ${result.error.message}. RECEIVED=${(() => { try {
-                return JSON.stringify(input);
-            }
-            catch {
-                return String(input);
-            } })()}`);
-        }
-        return new Tactics(result.data);
-    }
-    constructor({ lineup, pinchServerSubs, liberoReplacements, substitutionTolerance = 1 }) {
-        this.lineup = lineup;
-        this.substitutionTolerance = substitutionTolerance;
-        this.pinchServerSubs = pinchServerSubs;
-        this.liberoReplacements = liberoReplacements;
-    }
-    findPlayerInLineup(id) {
-        if (this.lineup.bench.some(p => p.id === id))
-            return CourtPosition.NOT_IN_COURT;
-        if (this.lineup[CourtPosition.LEFT_FRONT].id === id)
-            return CourtPosition.LEFT_FRONT;
-        if (this.lineup[CourtPosition.MIDDLE_FRONT].id === id)
-            return CourtPosition.MIDDLE_FRONT;
-        if (this.lineup[CourtPosition.RIGHT_FRONT].id === id)
-            return CourtPosition.RIGHT_FRONT;
-        if (this.lineup[CourtPosition.LEFT_BACK].id === id)
-            return CourtPosition.LEFT_BACK;
-        if (this.lineup[CourtPosition.MIDDLE_BACK].id === id)
-            return CourtPosition.MIDDLE_BACK;
-        if (this.lineup[CourtPosition.RIGHT_BACK].id === id)
-            return CourtPosition.RIGHT_BACK;
-        if (this.lineup[CourtPosition.LIBERO_ZONE]?.id === id)
-            return CourtPosition.LIBERO_ZONE;
-    }
-}

package/dist/esm/src/service/team/team-generator.d.ts

@@ -1,15 +0,0 @@
-import { Player, RarityEnum, Role } from '../player';
-import { Team } from './team';
-import { Country } from '../country';
-import { Tactics } from './tactics';
-export declare class TeamGenerator {
-    static readonly TEAM_PER_DIVISION = 16;
-    static readonly RARITIES: RarityEnum[];
-    static readonly ROLES: Role[];
-    private static getFormation;
-    private static comparePlayers;
-    static createRoster(country: Country): Player[];
-    static createTeams(divisionId: string, country: Country): Team[];
-    static createTactics(roster: Player[]): Tactics;
-    private static createLineup;
-}

package/dist/esm/src/service/team/team-generator.js

@@ -1,97 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { calculateRoleScore, Player, PlayerGenerator, RarityEnum, RoleEnum } from '../player';
-import { generateGenericTeamNames, randomNumber } from '../utils';
-import { Team } from './team';
-import { Tactics } from './tactics';
-import { Formation } from './formation';
-import { CourtPosition } from '../match';
-import logger from '../../logger';
-const buildBlock = (rarity, count) => Array.from({ length: count }, () => rarity);
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-export class TeamGenerator {
-    static getFormation() {
-        const n = Math.floor(Math.random() * 3);
-        switch (n) {
-            case 0:
-                return Formation['4-2'];
-            case 1:
-                return Formation['5-1'];
-            case 2:
-                return Formation['6-2'];
-            default:
-                throw new Error('INVALID NUMBER');
-        }
-    }
-    static comparePlayers(roles) {
-        return (p1, p2) => roles.reduce((x, role) => {
-            const p2Score = calculateRoleScore(p2.stats, role);
-            const p1Score = calculateRoleScore(p1.stats, role);
-            return x + p2Score - p1Score;
-        }, 0);
-    }
-    static createRoster(country) {
-        return TeamGenerator.RARITIES.map((rarity, i) => PlayerGenerator.generatePlayer(country, rarity, this.ROLES[i % TeamGenerator.ROLES.length]));
-    }
-    static createTeams(divisionId, country) {
-        const names = generateGenericTeamNames(country.locales, TeamGenerator.TEAM_PER_DIVISION);
-        logger.info(`Creating teams for division: ${divisionId}`);
-        return names.map((name) => {
-            logger.info(`Creating players for team: ${name}`);
-            const roster = TeamGenerator.createRoster(country);
-            const tactics = TeamGenerator.createTactics(roster);
-            const shortName = name.replace(/\s+/g, '')
-                .slice(0, 3)
-                .toUpperCase();
-            return Team.create({
-                id: uuidv4(),
-                divisionId,
-                name,
-                shortName,
-                roster,
-                country,
-                tactics,
-                rating: 100
-            });
-        });
-    }
-    static createTactics(roster) {
-        const lineup = TeamGenerator.createLineup(roster, TeamGenerator.getFormation());
-        return Tactics.create({
-            lineup,
-            liberoReplacements: [lineup[3], lineup[6]],
-            pinchServerSubs: new Map(),
-            substitutionTolerance: Math.round(randomNumber(1, 50))
-        });
-    }
-    static createLineup(players, formation) {
-        if (players.length < 6)
-            throw new Error('NOT_ENOUGH_PLAYERS_FOR_TEAM_1');
-        const out = {};
-        let courtPlayer;
-        const libero = players.filter((player) => player.roles.includes(RoleEnum.LIBERO))
-            .sort(TeamGenerator.comparePlayers([RoleEnum.LIBERO]))
-            .shift();
-        if (libero == null)
-            throw new Error('UNDEFINED_LIBERO');
-        const filtered = players.filter(player => player.id !== libero.id);
-        for (let i = 1; i < 7; i++) {
-            courtPlayer = filtered.sort(TeamGenerator.comparePlayers(formation.initialRotation[i]))
-                .shift();
-            if (courtPlayer == null)
-                throw new Error('NOT_ENOUGH_PLAYERS_FOR_TEAM_2');
-            out[i] = courtPlayer;
-        }
-        // Can only have 12 players in the team.
-        out.bench = filtered.sort(Player.compareStats)
-            .slice(0, 5);
-        out[CourtPosition.LIBERO_ZONE] = libero;
-        return out;
-    }
-}
-TeamGenerator.TEAM_PER_DIVISION = 16;
-TeamGenerator.RARITIES = [
-    ...buildBlock(RarityEnum.COMMON, 7),
-    ...buildBlock(RarityEnum.RARE, 5),
-    ...buildBlock(RarityEnum.LEGENDARY, 2)
-];
-TeamGenerator.ROLES = [RoleEnum.LIBERO, RoleEnum.MIDDLE_BLOCKER, RoleEnum.OPPOSITE_HITTER, RoleEnum.OUTSIDE_HITTER, RoleEnum.SETTER];