volleyballsimtypes 0.0.358 → 0.0.359

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

@@ -1,20 +0,0 @@
-import { Player } from '../player';
-import { Country } from '../country';
-import { Tactics } from './tactics';
-export declare class Team {
-    readonly id: string;
-    readonly roster: Player[];
-    readonly name: string;
-    readonly shortName: string;
-    readonly divisionId: string;
-    readonly tactics?: Tactics;
-    readonly country: Country;
-    private _rating;
-    static create(input: unknown): Team;
-    private constructor();
-    get rating(): number;
-    set rating(value: number);
-    isPlayerInRoster(player: Player): boolean;
-    toString(): string;
-    updateRating(rankingPoints: number): void;
-}

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

@@ -1,47 +0,0 @@
-import { Tactics } from './tactics';
-import { TeamInputSchema } from './schemas/team.z';
-export class Team {
-    static create(input) {
-        const result = TeamInputSchema.safeParse(input);
-        if (!result.success) {
-            throw new Error(`INVALID_TEAM: ${result.error.message}. RECEIVED=${(() => { try {
-                return JSON.stringify(input);
-            }
-            catch {
-                return String(input);
-            } })()}`);
-        }
-        return new Team({
-            ...result.data,
-            tactics: result.data.tactics != null ? Tactics.create(result.data.tactics) : undefined
-        });
-    }
-    constructor({ id, rating, name, shortName, divisionId, country, roster, tactics }) {
-        this.id = id;
-        this._rating = rating;
-        this.roster = roster;
-        this.tactics = tactics;
-        this.name = name;
-        this.shortName = shortName;
-        this.divisionId = divisionId;
-        this.country = country;
-    }
-    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;
-    }
-}

package/dist/esm/src/service/test-helpers.d.ts

@@ -1,38 +0,0 @@
-import { Country } from './country';
-import { Player } from './player';
-import { Team } from './team';
-import { Match } from './match';
-import { MatchSet } from './match/match-set';
-export declare function makeCountry(): Country;
-export declare function makePlayer(country: Country, statValue?: number): Player;
-export declare function makeTeam(opts?: {
-    rating?: number;
-}): Team;
-/** Creates a finished MatchSet with no rallies (schema allows empty rallies at non-zero score). */
-export declare function makeFinishedSet(homeScore: number, awayScore: number, order?: number): MatchSet;
-/**
- * Creates a COMPLETE Match where the home team wins 3-0.
- * Sets: 25-10, 25-12, 25-8.
- */
-export declare function makeMatch30(homeTeam: Team, awayTeam: Team): Match;
-/**
- * Creates a COMPLETE Match where the home team wins 3-1.
- * Sets (home wins 3, away wins 1): 25-20, 20-25, 25-18, 25-15.
- */
-export declare function makeMatch31(homeTeam: Team, awayTeam: Team): Match;
-/**
- * Creates a PENDING Match (no sets, no score).
- */
-export declare function makePendingMatch(homeTeam: Team, awayTeam: Team): Match;
-/**
- * Computes all derived Standing fields from raw win/loss counts so that
- * Standing.create() passes its superRefine validation.
- */
-export declare function standingInput(teamId: string, opts?: {
-    won30?: number;
-    won31?: number;
-    won32?: number;
-    lost03?: number;
-    lost13?: number;
-    lost23?: number;
-}): object;

package/dist/esm/src/service/test-helpers.js

@@ -1,153 +0,0 @@
-/**
- * Minimal object factories for unit tests.
- * NOT exported from any barrel — import directly from this file.
- */
-import { v4 as uuidv4 } from 'uuid';
-import { Country } from './country';
-import { Player } from './player';
-import { Team } from './team';
-import { Match } from './match';
-import { MatchSet } from './match/match-set';
-import { StatusEnum } from '../data/common';
-import { RarityEnum } from './player/rarity';
-import { RoleEnum } from './player/role';
-import { performanceStatKeys } from './player/performance-stats-keys';
-// ─── Country ─────────────────────────────────────────────────────────────────
-export function makeCountry() {
-    return Country.create({
-        id: uuidv4(),
-        name: 'Test Country',
-        alpha2: 'TC',
-        alpha3: 'TCN',
-        code: 'TCN',
-        iso31662: 'TC-TEST'
-    });
-}
-// ─── Player ───────────────────────────────────────────────────────────────────
-export function makePlayer(country, statValue = 50) {
-    const stats = Object.fromEntries(performanceStatKeys.map((k) => [k, statValue]));
-    return Player.create({
-        id: uuidv4(),
-        name: { first: 'Test', last: 'Player' },
-        country,
-        stats,
-        roles: [RoleEnum.OUTSIDE_HITTER],
-        traits: [],
-        rarity: RarityEnum.COMMON
-    });
-}
-// ─── Team ─────────────────────────────────────────────────────────────────────
-export function makeTeam(opts = {}) {
-    const country = makeCountry();
-    const player = makePlayer(country);
-    return Team.create({
-        id: uuidv4(),
-        rating: opts.rating ?? 100,
-        name: 'Test Team',
-        shortName: 'TST',
-        divisionId: uuidv4(),
-        roster: [player],
-        country
-    });
-}
-// ─── MatchSet ────────────────────────────────────────────────────────────────
-/** Creates a finished MatchSet with no rallies (schema allows empty rallies at non-zero score). */
-export function makeFinishedSet(homeScore, awayScore, order = 0) {
-    return MatchSet.create({
-        id: uuidv4(),
-        order,
-        isTieBreak: false,
-        homePlayerPosition: [],
-        awayPlayerPosition: [],
-        homeScore,
-        awayScore,
-        boxScores: [],
-        rallies: []
-    });
-}
-// ─── Match ───────────────────────────────────────────────────────────────────
-/**
- * Creates a COMPLETE Match where the home team wins 3-0.
- * Sets: 25-10, 25-12, 25-8.
- */
-export function makeMatch30(homeTeam, awayTeam) {
-    const sets = [
-        makeFinishedSet(25, 10, 0),
-        makeFinishedSet(25, 12, 1),
-        makeFinishedSet(25, 8, 2)
-    ];
-    return Match.create({
-        id: uuidv4(),
-        homeTeam,
-        awayTeam,
-        scheduledDate: new Date(),
-        status: StatusEnum.COMPLETE,
-        homeScore: 3,
-        awayScore: 0,
-        sets,
-        winner: homeTeam
-    });
-}
-/**
- * Creates a COMPLETE Match where the home team wins 3-1.
- * Sets (home wins 3, away wins 1): 25-20, 20-25, 25-18, 25-15.
- */
-export function makeMatch31(homeTeam, awayTeam) {
-    const sets = [
-        makeFinishedSet(25, 20, 0),
-        makeFinishedSet(20, 25, 1),
-        makeFinishedSet(25, 18, 2),
-        makeFinishedSet(25, 15, 3)
-    ];
-    return Match.create({
-        id: uuidv4(),
-        homeTeam,
-        awayTeam,
-        scheduledDate: new Date(),
-        status: StatusEnum.COMPLETE,
-        homeScore: 3,
-        awayScore: 1,
-        sets,
-        winner: homeTeam
-    });
-}
-/**
- * Creates a PENDING Match (no sets, no score).
- */
-export function makePendingMatch(homeTeam, awayTeam) {
-    return Match.create({
-        id: uuidv4(),
-        homeTeam,
-        awayTeam,
-        scheduledDate: new Date(),
-        status: StatusEnum.PENDING
-    });
-}
-// ─── Standing input ───────────────────────────────────────────────────────────
-/**
- * Computes all derived Standing fields from raw win/loss counts so that
- * Standing.create() passes its superRefine validation.
- */
-export function standingInput(teamId, opts = {}) {
-    const w30 = opts.won30 ?? 0;
-    const w31 = opts.won31 ?? 0;
-    const w32 = opts.won32 ?? 0;
-    const l03 = opts.lost03 ?? 0;
-    const l13 = opts.lost13 ?? 0;
-    const l23 = opts.lost23 ?? 0;
-    return {
-        teamId,
-        won30: w30,
-        won31: w31,
-        won32: w32,
-        lost03: l03,
-        lost13: l13,
-        lost23: l23,
-        points: (w30 + w31) * 3 + w32 * 2 + l23,
-        setsWon: (w32 + w31 + w30) * 3 + l23 * 2 + l13,
-        setsLost: (l03 + l13 + l23) * 3 + w32 * 2 + w31,
-        matchesWon: w30 + w31 + w32,
-        matchesLost: l03 + l13 + l23,
-        totalMatches: w30 + w31 + w32 + l03 + l13 + l23
-    };
-}

package/dist/esm/src/service/utils/faker-generators.d.ts

@@ -1,25 +0,0 @@
-export declare function getFakerInstance(locales: string[]): FakerLike;
-interface FakerLike {
-    location: {
-        city: () => string;
-        state?: () => string;
-        county?: () => string;
-    };
-    person: {
-        firstName: () => string;
-        lastName: () => string;
-    };
-    word: {
-        adjective: () => string;
-        noun: () => string;
-    };
-    datatype: {
-        boolean: () => boolean;
-    };
-}
-export declare function generateGenericTeamNames(locales: string[], amount: number): string[];
-export declare function generatePlayerName(locales: string[], amount: number): Array<{
-    first: string;
-    last: string;
-}>;
-export {};

package/dist/esm/src/service/utils/faker-generators.js

@@ -1,77 +0,0 @@
-import { allFakers, faker as FakerModule } from '@faker-js/faker';
-function isFakerKey(k) {
-    return k in allFakers;
-}
-export function getFakerInstance(locales) {
-    for (const locale of locales) {
-        if (isFakerKey(locale)) {
-            return allFakers[locale];
-        }
-    }
-    for (const locale of locales) {
-        const l = locale.split('_')[0];
-        if (isFakerKey(l)) {
-            return allFakers[l];
-        }
-    }
-    return FakerModule;
-}
-function clean(s) {
-    return s.replace(/\s+/g, ' ').trim();
-}
-function capitalize(s) {
-    return s.charAt(0).toUpperCase() + s.slice(1);
-}
-function nonEmpty(s) {
-    return s != null && s.length > 0 ? s : undefined;
-}
-function generateTeamName(faker) {
-    if (faker.datatype.boolean()) {
-        const city = nonEmpty(faker.location.city()) ??
-            nonEmpty(faker.location.state?.()) ??
-            nonEmpty(faker.location.county?.()) ??
-            faker.word.noun();
-        const mascot = capitalize(faker.word.noun());
-        return clean(`${city} ${mascot}`);
-    }
-    else {
-        const adjective = capitalize(faker.word.adjective());
-        const noun = capitalize(faker.word.noun());
-        return clean(`${adjective} ${noun}`);
-    }
-}
-const MAX_LAST_NAME_LENGTH = 16;
-const MAX_TEAM_NAME_LENGTH = 22;
-export function generateGenericTeamNames(locales, amount) {
-    if (amount <= 0)
-        return [];
-    const faker = getFakerInstance(locales);
-    const results = new Set();
-    const maxAttempts = amount * 20;
-    let attempts = 0;
-    while (results.size < amount && attempts < maxAttempts) {
-        const name = generateTeamName(faker);
-        if (name.length <= MAX_TEAM_NAME_LENGTH) {
-            results.add(name);
-        }
-        attempts++;
-    }
-    // Safety net: if the locale consistently generates long names, crop and add
-    while (results.size < amount) {
-        results.add(generateTeamName(faker).slice(0, MAX_TEAM_NAME_LENGTH));
-    }
-    return Array.from(results);
-}
-export function generatePlayerName(locales, amount) {
-    if (amount <= 0)
-        return [];
-    const faker = getFakerInstance(locales);
-    return Array.from({ length: amount }, () => {
-        const first = clean(faker.person.firstName());
-        let last = clean(faker.person.lastName());
-        while (last.length > MAX_LAST_NAME_LENGTH) {
-            last = clean(faker.person.lastName());
-        }
-        return { first, last };
-    });
-}

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

@@ -1,4 +0,0 @@
-export * from './object-utils';
-export * from './number-utils';
-export * from './rng-utils';
-export * from './faker-generators';

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

@@ -1,4 +0,0 @@
-export * from './object-utils';
-export * from './number-utils';
-export * from './rng-utils';
-export * from './faker-generators';

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

@@ -1,4 +0,0 @@
-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/esm/src/service/utils/number-utils.js

@@ -1,24 +0,0 @@
-export function randomNumber(min, max) {
-    return Math.random() * (max - min) + min;
-}
-export function nextPowerOf2(n) { return n <= 1 ? 1 : 2 ** Math.ceil(Math.log2(n)); }
-export function clamp(min, max, value) {
-    return Math.max(min, Math.min(value, max));
-}
-// Approximation of the error function
-export 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/esm/src/service/utils/number-utils.test.d.ts

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

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

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

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

@@ -1,4 +0,0 @@
-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/esm/src/service/utils/object-utils.js

@@ -1 +0,0 @@
-export const getKeys = Object.keys;

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

@@ -1,11 +0,0 @@
-/**
- * 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/esm/src/service/utils/rng-utils.js

@@ -1,55 +0,0 @@
-import { clamp } from './number-utils';
-/**
- * Fisher-Yates shuffle algorithm
- * Shuffles array IN-PLACE
- * @param {any[]} array
- */
-export 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;
-}
-export function calculateProbability(score, scale, minP, maxP) {
-    const x = score / scale;
-    const sigmoid = 1 / (1 + Math.exp(-x));
-    const p = minP + (maxP - minP) * sigmoid;
-    return clamp(0, 1, p);
-}
-export 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/esm/src/service/utils/rng-utils.test.d.ts

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

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

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

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

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

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

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