tenniscommon 1.0.1

package/dist/esm/common/training/index.js

@@ -0,0 +1,4 @@
+export * from './interfaces';
+export * from './initialData';
+export * from './initialStats';
+export * from './validation';

package/dist/esm/common/training/initialData.d.ts

@@ -0,0 +1,2 @@
+import { TrainingItem } from './interfaces';
+export declare function createInitialTrainingItem(playerId: string, date: Date): TrainingItem;

package/dist/esm/common/training/initialData.js

@@ -0,0 +1,11 @@
+import { TRAINING } from './interfaces';
+// Factory function for creating initial TrainingItem
+export function createInitialTrainingItem(playerId, date) {
+    return {
+        _id: '',
+        playerId: playerId,
+        date: date,
+        type: TRAINING.ACTIVITY.Individual,
+        time: 1,
+    };
+}

package/dist/esm/common/training/initialStats.d.ts

@@ -0,0 +1,2 @@
+import { TrainingTotals } from './interfaces';
+export declare const createDefaultTrainingTotal: () => TrainingTotals;

package/dist/esm/common/training/initialStats.js

@@ -0,0 +1,23 @@
+import { COMMONS_ARRAYS } from '../general';
+import { TRAINING_ARRAYS } from './interfaces';
+export const createDefaultTrainingTotal = () => {
+    const hoursPerType = {};
+    const hoursPerMonth = {};
+    const hoursPerMonthPerType = {};
+    TRAINING_ARRAYS.ACTIVITY.forEach(type => { hoursPerType[type] = 0; });
+    COMMONS_ARRAYS.MONTH.forEach(month => {
+        hoursPerMonth[month] = 0;
+        hoursPerMonthPerType[month] = {};
+        TRAINING_ARRAYS.ACTIVITY.forEach(type => {
+            hoursPerMonthPerType[month][type] = 0;
+        });
+    });
+    return {
+        totalHours: 0,
+        totalHoursLastMonth: 0,
+        averageHoursPerMonth: 0,
+        hoursPerType,
+        hoursPerMonth,
+        hoursPerMonthPerType,
+    };
+};

package/dist/esm/common/training/initialTotals.d.ts

@@ -0,0 +1,2 @@
+import { TrainingTotals } from './interfaces';
+export declare const createDefaultTrainingTotal: () => TrainingTotals;

package/dist/esm/common/training/initialTotals.js

@@ -0,0 +1,23 @@
+import { COMMONS_ARRAYS } from '../general';
+import { TRAINING_ARRAYS } from './interfaces';
+export const createDefaultTrainingTotal = () => {
+    const hoursPerType = {};
+    const hoursPerMonth = {};
+    const hoursPerMonthPerType = {};
+    TRAINING_ARRAYS.ACTIVITY.forEach(type => { hoursPerType[type] = 0; });
+    COMMONS_ARRAYS.MONTH.forEach(month => {
+        hoursPerMonth[month] = 0;
+        hoursPerMonthPerType[month] = {};
+        TRAINING_ARRAYS.ACTIVITY.forEach(type => {
+            hoursPerMonthPerType[month][type] = 0;
+        });
+    });
+    return {
+        totalHours: 0,
+        totalHoursLastMonth: 0,
+        averageHoursPerMonth: 0,
+        hoursPerType,
+        hoursPerMonth,
+        hoursPerMonthPerType,
+    };
+};

package/dist/esm/common/training/interfaces.d.ts

@@ -0,0 +1,40 @@
+import { ValueOf } from '../general';
+export declare const TRAINING: {
+    readonly ACTIVITY: {
+        readonly Squad: "Squad";
+        readonly Individual: "Individual";
+        readonly Lesson: "Lesson";
+        readonly Hit: "Hit";
+        readonly MatchPractice: "Match-Practice";
+        readonly Physical: "Physical";
+        readonly OtherSports: "Other Sports";
+    };
+};
+export type TRAINING_ACTIVITY_UNION = ValueOf<typeof TRAINING.ACTIVITY>;
+export declare const TRAINING_ARRAYS: {
+    ACTIVITY: TRAINING_ACTIVITY_UNION[];
+};
+export interface TrainingItem {
+    _id: string;
+    playerId: string;
+    date: Date;
+    type: TRAINING_ACTIVITY_UNION;
+    time: number;
+    spendingId?: string;
+}
+export interface TrainingTotals {
+    totalHours: number;
+    totalHoursLastMonth: number;
+    averageHoursPerMonth: number;
+    hoursPerType: {
+        [type: string]: number;
+    };
+    hoursPerMonth: {
+        [month: string]: number;
+    };
+    hoursPerMonthPerType: {
+        [month: string]: {
+            [type: string]: number;
+        };
+    };
+}

package/dist/esm/common/training/interfaces.js

@@ -0,0 +1,14 @@
+export const TRAINING = {
+    ACTIVITY: {
+        Squad: 'Squad',
+        Individual: 'Individual',
+        Lesson: 'Lesson',
+        Hit: 'Hit',
+        MatchPractice: 'Match-Practice',
+        Physical: 'Physical',
+        OtherSports: 'Other Sports',
+    },
+};
+export const TRAINING_ARRAYS = {
+    ACTIVITY: Object.values(TRAINING.ACTIVITY),
+};

package/dist/esm/common/training/validation.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const trainingItemSchema: z.ZodObject<{
+    playerId: z.ZodString;
+    date: z.ZodEffects<z.ZodEffects<z.ZodDate, Date, Date>, Date, unknown>;
+    type: z.ZodString;
+    time: z.ZodNumber;
+    spendingId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    time: number;
+    date: Date;
+    playerId: string;
+    spendingId?: string | undefined;
+}, {
+    type: string;
+    time: number;
+    playerId: string;
+    date?: unknown;
+    spendingId?: string | undefined;
+}>;

package/dist/esm/common/training/validation.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export const trainingItemSchema = z.object({
+    playerId: z.string().min(1, 'PlayerId is required.'),
+    date: z.preprocess((arg) => (typeof arg === 'string' || arg instanceof Date ? new Date(arg) : undefined), z.date().refine(date => !isNaN(date.getTime()), 'Invalid date.')),
+    type: z.string().min(1, 'Type is required.'),
+    time: z.number().nonnegative('Time must be a non-negative number.'),
+    spendingId: z.string().optional()
+});

package/dist/esm/common/trainingWeekly/index.d.ts

@@ -0,0 +1,3 @@
+export * from './interfaces';
+export * from './initialData';
+export * from './validation';

package/dist/esm/common/trainingWeekly/index.js

@@ -0,0 +1,3 @@
+export * from './interfaces';
+export * from './initialData';
+export * from './validation';

package/dist/esm/common/trainingWeekly/initialData.d.ts

@@ -0,0 +1,2 @@
+import { TrainingWeeklyItem } from './interfaces';
+export declare function createInitialTrainingWeeklyItem(playerId: string): TrainingWeeklyItem;

package/dist/esm/common/trainingWeekly/initialData.js

@@ -0,0 +1,14 @@
+import { SPENDING } from '../spending';
+import { COMMONS } from '../general';
+import { TRAINING } from '../training';
+export function createInitialTrainingWeeklyItem(playerId) {
+    return {
+        _id: '',
+        playerId: playerId,
+        day: COMMONS.WEEKDAY.Monday,
+        type: TRAINING.ACTIVITY.Individual,
+        time: 1,
+        spendingType: SPENDING.TYPE.CourtHire,
+        cost: 0,
+    };
+}

package/dist/esm/common/trainingWeekly/interfaces.d.ts

@@ -0,0 +1,12 @@
+import { TRAINING_ACTIVITY_UNION } from '../training';
+import { SPENDING_TYPE_UNION } from '../spending';
+import { WEEKDAY_UNION } from '../general';
+export interface TrainingWeeklyItem {
+    _id: string;
+    playerId: string;
+    day: WEEKDAY_UNION;
+    type: TRAINING_ACTIVITY_UNION;
+    time: number;
+    spendingType: SPENDING_TYPE_UNION;
+    cost: number;
+}

package/dist/esm/common/trainingWeekly/interfaces.js

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

package/dist/esm/common/trainingWeekly/validation.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export declare const trainingWeeklyItemSchema: z.ZodObject<{
+    playerId: z.ZodString;
+    day: z.ZodString;
+    type: z.ZodString;
+    time: z.ZodNumber;
+    spendingType: z.ZodString;
+    cost: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    time: number;
+    day: string;
+    playerId: string;
+    cost: number;
+    spendingType: string;
+}, {
+    type: string;
+    time: number;
+    day: string;
+    playerId: string;
+    cost: number;
+    spendingType: string;
+}>;

package/dist/esm/common/trainingWeekly/validation.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export const trainingWeeklyItemSchema = z.object({
+    playerId: z.string().min(1, 'PlayerId is required.'),
+    day: z.string().min(1, 'Day is required.'),
+    type: z.string().min(1, 'Type is required.'),
+    time: z.number().nonnegative('Time must be a non-negative number.'),
+    spendingType: z.string().min(1, 'Spending Type is required.'),
+    cost: z.number().nonnegative('Cost must be a non-negative number.')
+});

package/dist/types/common/general/generalInterfaces.d.ts

@@ -0,0 +1,16 @@
+import { ZodIssue } from 'zod';
+export interface FetchOptions extends RequestInit {
+    headers?: HeadersInit;
+}
+export interface FetchResponse<T, E = ZodIssue[]> {
+    ok: boolean;
+    status: number;
+    message: string;
+    body: T;
+    errors?: E;
+}
+export interface DeleteResponse {
+    message: string;
+}
+export type FilterOption<T> = T | 'all';
+export type ValueOf<T> = T[keyof T];

package/dist/types/common/general/generalUtils.d.ts

@@ -0,0 +1,88 @@
+import { PlayerConfig } from '../player';
+import { ValueOf } from './generalInterfaces';
+export declare const COMMONS: {
+    readonly WEEKDAY: {
+        readonly Monday: "Monday";
+        readonly Tuesday: "Tuesday";
+        readonly Wednesday: "Wednesday";
+        readonly Thursday: "Thursday";
+        readonly Friday: "Friday";
+        readonly Saturday: "Saturday";
+        readonly Sunday: "Sunday";
+    };
+    readonly MONTH: {
+        readonly January: "January";
+        readonly February: "February";
+        readonly March: "March";
+        readonly April: "April";
+        readonly May: "May";
+        readonly June: "June";
+        readonly July: "July";
+        readonly August: "August";
+        readonly September: "September";
+        readonly October: "October";
+        readonly November: "November";
+        readonly December: "December";
+    };
+    readonly BOOLEAN: {
+        readonly Yes: "Yes";
+        readonly No: "No";
+    };
+};
+export type keyValuePair = {
+    id: string;
+    name: string;
+};
+export type WEEKDAY_UNION = ValueOf<typeof COMMONS.WEEKDAY>;
+export type MONTH_UNION = ValueOf<typeof COMMONS.MONTH>;
+export type BOOLEAN_UNION = ValueOf<typeof COMMONS.BOOLEAN>;
+export declare const COMMONS_ARRAYS: {
+    WEEKDAY: WEEKDAY_UNION[];
+    MONTH: MONTH_UNION[];
+    BOOLEAN: BOOLEAN_UNION[];
+};
+export declare const COLLECTION: {
+    readonly matchplaySingles: "matchplaySingles";
+    readonly matchplayDoubles: "matchplayDoubles";
+    readonly opponent: "opponent";
+    readonly performance: "performance";
+    readonly player: "player";
+    readonly spending: "spending";
+    readonly trainingWeekly: "trainingWeekly";
+    readonly training: "training";
+    readonly tournament: "tournament";
+};
+export declare const CurrentMonth: string;
+export declare const CurrentYearMinus12: number;
+export declare const getMonthNameByOffset: (offset: number) => string;
+export declare function getCurrentYear(date?: Date): number;
+export declare const getCurrentMonthNumber: (date?: Date) => number;
+export declare const getMonthByName: (date?: string) => string;
+export declare const getCurrentDateInDDMMYYYY: (date: Date) => string;
+export declare const getAgeGroup: (birthYear: number) => string;
+type KeyValue<T extends string, U extends string> = {
+    [key in T]: string;
+} & {
+    [value in U]: number;
+};
+export declare const convertJsonToArray: <T extends string, U extends string>(json: {
+    [s: string]: number;
+}, objectName: T, objectValue: U) => KeyValue<T, U>[];
+export declare const normalizeKey: (key: string) => string;
+type KeyValueWithTwoNumbers<T extends string, U extends string, V extends string> = {
+    [key in T]: string;
+} & {
+    [key in U]: number;
+} & {
+    [key in V]: number;
+};
+export declare const convertJsonToArrayWithTwoNumbers: <T extends string, U extends string, V extends string>(json: {
+    [s: string]: {
+        singles: number;
+        doubles: number;
+    };
+}, objectName: T, singlesKey: U, doublesKey: V) => KeyValueWithTwoNumbers<T, U, V>[];
+export declare function convertToDate(dateInput: string | Date): Date;
+export declare function configDate(playerConfig: PlayerConfig): Date;
+export declare function isValidPassword(password: string): boolean;
+export {};

package/dist/types/common/general/index.d.ts

@@ -0,0 +1,2 @@
+export * from './generalInterfaces';
+export * from './generalUtils';

package/dist/types/common/matchplay/index.d.ts

@@ -0,0 +1,4 @@
+export * from './interfaces';
+export * from './initialData';
+export * from './initialStats';
+export * from './validation';

package/dist/types/common/matchplay/initialData.d.ts

@@ -0,0 +1,3 @@
+import { MatchplayItem } from './interfaces';
+export declare function createInitialMatchplaySinglesItem(playerId: string, date: Date): MatchplayItem;
+export declare function createInitialMatchplayDoublesItem(playerId: string, date: Date): MatchplayItem;

package/dist/types/common/matchplay/initialStats.d.ts

@@ -0,0 +1,7 @@
+import { MatchplayStats, EnhancedStatsPack, MatchStats, BasicStatsPack, SpecificStats, StatsPack } from './interfaces';
+export declare const createMatchplayStats: () => MatchplayStats;
+export declare const createStatsPack: () => StatsPack;
+export declare const createBasicStatsPack: () => BasicStatsPack;
+export declare const createEnhancedStatsPack: () => EnhancedStatsPack;
+export declare const createMatchStats: () => MatchStats;
+export declare const createSpecificStats: () => SpecificStats;

package/dist/types/common/matchplay/initialTotals.d.ts

@@ -0,0 +1,4 @@
+import { ByType, MatchplayTotals, MatchStats } from './interfaces';
+export declare const createDefaultMatchplayTotals: () => MatchplayTotals;
+export declare const createDefaultByType: () => ByType;
+export declare const createDefaultMatchStats: () => MatchStats;

package/dist/types/common/matchplay/interfaces.d.ts

@@ -0,0 +1,184 @@
+import { ValueOf } from '../general';
+export declare const MATCH: {
+    readonly FORMAT: {
+        readonly Singles: "Singles";
+        readonly Doubles: "Doubles";
+    };
+    readonly SURFACE: {
+        readonly Grass: "Grass";
+        readonly Clay: "Clay";
+        readonly Hard: "Hard";
+    };
+    readonly WINNER: {
+        readonly Player: "Player";
+        readonly Opponent: "Opponent";
+    };
+    readonly DECIDING_SET_FORMAT: {
+        readonly ChampionshipTiebreak: "Championship Tiebreak";
+        readonly ThirdSet: "Thirdset";
+    };
+    readonly RESULT: {
+        readonly Win: "Win";
+        readonly Loss: "Loss";
+    };
+    readonly AGE_GROUP: {
+        readonly U12: "U12";
+        readonly U14: "U14";
+        readonly U16: "U16";
+        readonly U18: "U18";
+        readonly Adult: "Adult";
+    };
+    readonly ROUND: {
+        readonly RoundRobin: "Round Robin";
+        readonly Consolation: "Consolation";
+        readonly Qualifier: "Qualifier";
+        readonly Round64: "Round 64";
+        readonly Round32: "Round 32";
+        readonly Round16: "Round 16";
+        readonly QF: "QF";
+        readonly SF: "SF";
+        readonly Final: "Final";
+    };
+    readonly LOCATION: {
+        readonly Indoor: "Indoor";
+        readonly Outdoor: "Outdoor";
+    };
+    readonly SET_FORMAT: {
+        readonly Full: "Full";
+        readonly FourAll: "Four All";
+        readonly FastFour: "Fast Four";
+    };
+    readonly SET_SCORES_PLAYER: readonly ["6-0", "6-1", "6-2", "6-3", "6-4", "7-5", "7-6"];
+    readonly SET_SCORES_OPPONENT: readonly ["0-6", "1-6", "2-6", "3-6", "4-6", "5-7", "6-7"];
+    readonly FOUR_ALL_SET_SCORES_PLAYER: readonly ["4-0", "4-1", "4-2", "5-3", "5-4"];
+    readonly FOUR_ALL_SET_SCORES_OPPONENT: readonly ["0-4", "1-4", "2-4", "3-5", "4-5"];
+    readonly FAST_FOUR_SET_SCORES_PLAYER: readonly ["4-0", "4-1", "4-2", "4-3"];
+    readonly FAST_FOUR_SET_SCORES_OPPONENT: readonly ["0-4", "1-4", "2-4", "3-4"];
+    readonly TIE_BREAK_CHAMPIONSHIP_SCORES_PLAYER: readonly ["10-0", "10-1", "10-2", "10-3", "10-4", "10-5", "10-6", "10-7", "10-8", "11-9", "12-10", "13-11", "14-12", "15-13", "16-14"];
+    readonly TIE_BREAK_CHAMPIONSHIP_SCORES_OPPONENT: readonly ["0-10", "1-10", "2-10", "3-10", "4-10", "5-10", "6-10", "7-10", "8-10", "9-11", "10-12", "11-13", "12-14", "13-15", "14-16"];
+    readonly TIE_BREAK_SCORES_PLAYER: readonly ["7-0", "7-1", "7-2", "7-3", "7-4", "7-5", "8-6", "9-7", "10-8", "11-9", "12-10"];
+    readonly TIE_BREAK_SCORES_OPPONENT: readonly ["0-7", "1-7", "2-7", "3-7", "4-7", "5-7", "6-8", "7-9", "8-10", "9-11", "10-12"];
+};
+export type MATCH_FORMAT_UNION = ValueOf<typeof MATCH.FORMAT>;
+export type MATCH_SURFACE_UNION = ValueOf<typeof MATCH.SURFACE>;
+export type MATCH_WINNER_UNION = ValueOf<typeof MATCH.WINNER>;
+export type MATCH_DECIDING_SET_FORMAT_UNION = ValueOf<typeof MATCH.DECIDING_SET_FORMAT>;
+export type MATCH_RESULT_UNION = ValueOf<typeof MATCH.RESULT>;
+export type MATCH_AGE_GROUP_UNION = ValueOf<typeof MATCH.AGE_GROUP>;
+export type MATCH_ROUND_UNION = ValueOf<typeof MATCH.ROUND>;
+export type MATCH_LOCATION_UNION = ValueOf<typeof MATCH.LOCATION>;
+export type MATCH_SET_FORMAT_UNION = ValueOf<typeof MATCH.SET_FORMAT>;
+export declare const MATCH_ARRAYS: {
+    FORMAT: MATCH_FORMAT_UNION[];
+    SURFACE: MATCH_SURFACE_UNION[];
+    WINNER: MATCH_WINNER_UNION[];
+    DECIDING_SET_FORMAT: MATCH_DECIDING_SET_FORMAT_UNION[];
+    RESULT: MATCH_RESULT_UNION[];
+    AGE_GROUP: MATCH_AGE_GROUP_UNION[];
+    ROUND: MATCH_ROUND_UNION[];
+    LOCATION: MATCH_LOCATION_UNION[];
+    SET_FORMAT: MATCH_SET_FORMAT_UNION[];
+};
+export interface MatchplayItem {
+    _id: string;
+    playerId: string;
+    date: Date;
+    tournamentId: string;
+    tournamentYearId: string;
+    matchFormat: MATCH_FORMAT_UNION;
+    matchAgeGroup: MATCH_AGE_GROUP_UNION;
+    matchRound: MATCH_ROUND_UNION;
+    matchSurface: MATCH_SURFACE_UNION;
+    matchLocation: MATCH_LOCATION_UNION;
+    matchSetFormat: MATCH_SET_FORMAT_UNION;
+    matchResult: MATCH_RESULT_UNION;
+    partnerId?: string;
+    opponentId: string;
+    opponentIdTwo?: string;
+    firstSetWon: MATCH_WINNER_UNION;
+    secondSetWon: MATCH_WINNER_UNION;
+    decidingSetFormat?: MATCH_DECIDING_SET_FORMAT_UNION;
+    decidingSetWon?: MATCH_WINNER_UNION;
+    firstSet: string;
+    firstSetTieBreak?: string;
+    secondSet: string;
+    secondSetTieBreak?: string;
+    decidingSet?: string;
+    decidingSetTieBreak?: string;
+    comment: string;
+}
+export interface MatchplayStats {
+    Career: StatsPack;
+    CareerSingles: StatsPack;
+    CareerDoubles: StatsPack;
+    combinedMatchesPerMonth: {
+        [month: string]: {
+            singles: number;
+            doubles: number;
+        };
+    };
+}
+export interface MatchStats {
+    matches: number;
+    won: number;
+    lost: number;
+    wonPercentage: number;
+    lostPercentage: number;
+}
+export interface SpecificStats {
+    total: number;
+    won: number;
+    lost: number;
+    wonPercentage: number;
+    lostPercentage: number;
+}
+export interface StatsPack {
+    basicStatsPack: BasicStatsPack;
+    enhancedStatsPack: EnhancedStatsPack;
+}
+export interface EnhancedStatsPack {
+    matchStats_ByFormat: {
+        [key in MATCH_FORMAT_UNION]: MatchStats;
+    };
+    matchStats_ByAgeGroup: {
+        [key in MATCH_AGE_GROUP_UNION]: MatchStats;
+    };
+    matchStats_ByRound: {
+        [key in MATCH_ROUND_UNION]: MatchStats;
+    };
+    matchStats_BySurface: {
+        [key in MATCH_SURFACE_UNION]: MatchStats;
+    };
+    matchStats_ByLocation: {
+        [key in MATCH_LOCATION_UNION]: MatchStats;
+    };
+    matchStats_BySetFormat: {
+        [key in MATCH_SET_FORMAT_UNION]: MatchStats;
+    };
+    matchStats_ByFirstSetWin: MatchStats;
+    matchStats_ByFirstSetLost: MatchStats;
+    matchStats_ByFirstSetTiebreak: MatchStats;
+    matchStats_BySecondSetWin: MatchStats;
+    matchStats_BySecondSetLost: MatchStats;
+    matchStats_BySecondSetTiebreak: MatchStats;
+    matchStats_ByGoingToDecidingSet: MatchStats;
+    matchStats_ByDecidingSetFormat: {
+        [key in MATCH_DECIDING_SET_FORMAT_UNION]: MatchStats;
+    };
+    matchStats_ByDecidingSetWin: MatchStats;
+    matchStats_ByDecidingSetLost: MatchStats;
+}
+export interface BasicStatsPack {
+    overall: MatchStats;
+    firstSet: SpecificStats;
+    firstSetTieBreak: SpecificStats;
+    secondSet: SpecificStats;
+    secondSetTieBreak: SpecificStats;
+    firstAndSecondSets: SpecificStats;
+    firstAndSecondSetTieBreaks: SpecificStats;
+    decidingSet: SpecificStats;
+    decidingSetTieBreak: SpecificStats;
+    champTieBreak: SpecificStats;
+    secondSetWinAfterFirstSetLoss: SpecificStats;
+    games: SpecificStats;
+}