tenniscommon 1.0.1

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

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+// Add a match to Singles
+export const singlesMatchplayItemSchema = 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.')),
+    tournamentId: z.string().min(1, 'Tournament is required.'),
+    tournamentYearId: z.string().min(1, 'Tournament Year is required.'),
+    matchFormat: z.string().min(1, 'Match Format is required.'),
+    matchAgeGroup: z.string().min(1, 'Match Age Group is required.'),
+    matchRound: z.string().min(1, 'Tournament Round is required.'),
+    matchSurface: z.string().min(1, 'Match Surface is required.'),
+    matchLocation: z.string().min(1, 'Match Location is required.'),
+    matchSetFormat: z.string().min(1, 'Match Set Format is required.'),
+    matchResult: z.string().min(1, 'Match Result is required.'),
+    partnerId: z.string().optional(),
+    opponentId: z.string().min(1, 'Opponent is required.'),
+    opponentIdTeo: z.string().optional(),
+    firstSetWon: z.string().min(1, 'First Set Winner is required.'),
+    secondSetWon: z.string().min(1, 'Second Set Winner is required.'),
+    decidingSetFormat: z.string().optional(),
+    decidingSetWon: z.string().optional(),
+    firstSet: z.string().min(1, 'First Set Score is required.'),
+    firstSetTieBreak: z.string().optional(),
+    secondSet: z.string().min(1, 'Second Set Score is required.'),
+    secondSetTieBreak: z.string().optional(),
+    decidingSet: z.string().optional(),
+    decidingSetTieBreak: z.string().optional(),
+    comment: z.string().optional(),
+})
+    .refine(data => !(data.firstSet === '7-6' || data.firstSet === '6-7') || !!data.firstSetTieBreak, {
+    message: 'First Set Tie Break Score is required',
+    path: ['firstSetTieBreak'],
+})
+    .refine(data => !(data.secondSet === '7-6' || data.secondSet === '6-7') || !!data.secondSetTieBreak, {
+    message: 'Second Set Tie Break Score is required',
+    path: ['secondSetTieBreak'],
+})
+    .refine(data => data.firstSetWon === data.secondSetWon || !!data.decidingSetFormat, {
+    message: 'Deciding Set format is required.',
+    path: ['decidingSetFormat'],
+})
+    .refine(data => data.firstSetWon === data.secondSetWon || !!data.decidingSetWon, {
+    message: 'Deciding Set Winner is required',
+    path: ['decidingSetWon'],
+})
+    .refine(data => data.firstSetWon === data.secondSetWon || !!data.decidingSet, {
+    message: 'Deciding Set Score is required',
+    path: ['decidingSet'],
+})
+    .refine(data => data.firstSetWon === data.secondSetWon || !(data.decidingSet === '7-6' || data.decidingSet === '6-7') || !!data.decidingSetTieBreak, {
+    message: 'Deciding Set Tie Break is required',
+    path: ['decidingSetTieBreak'],
+});
+// Add a match to Doubles
+export const doublesMatchplayItemSchema = 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.')),
+    tournamentId: z.string().min(1, 'Tournament is required.'),
+    tournamentYearId: z.string().min(1, 'Tournament Year is required.'),
+    matchFormat: z.string().min(1, 'Match Format is required.'),
+    matchAgeGroup: z.string().min(1, 'Match Age Group is required.'),
+    matchRound: z.string().min(1, 'Tournament Round is required.'),
+    matchSurface: z.string().min(1, 'Match Surface is required.'),
+    matchLocation: z.string().min(1, 'Match Location is required.'),
+    matchSetFormat: z.string().min(1, 'Match Set Format is required.'),
+    matchResult: z.string().min(1, 'Match Result is required.'),
+    partnerId: z.string().min(1, 'Partner is required.'),
+    opponentId: z.string().min(1, 'Opponent is required.'),
+    opponentIdTwo: z.string().min(1, 'Opponent two is required.'),
+    firstSetWon: z.string().min(1, 'First Set Winner is required.'),
+    secondSetWon: z.string().min(1, 'Second Set Winner is required.'),
+    decidingSetFormat: z.string().optional(),
+    decidingSetWon: z.string().optional(),
+    firstSet: z.string().min(1, 'First Set Score is required.'),
+    firstSetTieBreak: z.string().optional(),
+    secondSet: z.string().min(1, 'Second Set Score is required.'),
+    secondSetTieBreak: z.string().optional(),
+    decidingSet: z.string().optional(),
+    decidingSetTieBreak: z.string().optional(),
+    comment: z.string().optional(),
+})
+    .refine(data => !(data.firstSet === '7-6' || data.firstSet === '6-7') || !!data.firstSetTieBreak, {
+    message: 'First Set Tie Break Score is required',
+    path: ['firstSetTieBreak'],
+})
+    .refine(data => !(data.secondSet === '7-6' || data.secondSet === '6-7') || !!data.secondSetTieBreak, {
+    message: 'Second Set Tie Break Score is required',
+    path: ['secondSetTieBreak'],
+})
+    .refine(data => data.firstSetWon === data.secondSetWon || !!data.decidingSetFormat, {
+    message: 'Deciding Set format is required.',
+    path: ['decidingSetFormat'],
+})
+    .refine(data => data.firstSetWon === data.secondSetWon || !!data.decidingSetWon, {
+    message: 'Deciding Set Winner is required',
+    path: ['decidingSetWon'],
+})
+    .refine(data => data.firstSetWon === data.secondSetWon || !!data.decidingSet, {
+    message: 'Deciding Set Score is required',
+    path: ['decidingSet'],
+})
+    .refine(data => data.firstSetWon === data.secondSetWon || !(data.decidingSet === '7-6' || data.decidingSet === '6-7') || !!data.decidingSetTieBreak, {
+    message: 'Deciding Set Tie Break is required',
+    path: ['decidingSetTieBreak'],
+});

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

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

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

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

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

@@ -0,0 +1,3 @@
+import { OpponentItem, OpponentStats } from './interfaces';
+export declare function createInitialOpponentItem(playerId: string, born: number): OpponentItem;
+export declare function createOpponentStats(name: string, hand: string): OpponentStats;

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

@@ -0,0 +1,21 @@
+import { HAND } from './interfaces';
+import { COMMONS } from '../general';
+import { createBasicStatsPack } from '../matchplay';
+export function createInitialOpponentItem(playerId, born) {
+    return {
+        _id: '',
+        playerId: playerId,
+        name: '',
+        born: born,
+        hand: HAND.Right,
+        show: COMMONS.BOOLEAN.Yes,
+        comment: '',
+    };
+}
+export function createOpponentStats(name, hand) {
+    return {
+        name: name,
+        hand: hand,
+        basicStatsPack: createBasicStatsPack(),
+    };
+}

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

@@ -0,0 +1,22 @@
+import { BOOLEAN_UNION } from '../general';
+import { BasicStatsPack } from '../matchplay';
+export declare const HAND: {
+    readonly Left: "Left";
+    readonly Right: "Right";
+};
+export type HAND_UNION = typeof HAND[keyof typeof HAND];
+export declare const HAND_ARRAY: HAND_UNION[];
+export interface OpponentItem {
+    _id: string;
+    playerId: string;
+    name: string;
+    born: number;
+    hand: HAND_UNION;
+    show: BOOLEAN_UNION;
+    comment: string;
+}
+export interface OpponentStats {
+    name: string;
+    hand: string;
+    basicStatsPack: BasicStatsPack;
+}

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

@@ -0,0 +1,5 @@
+export const HAND = {
+    Left: 'Left',
+    Right: 'Right',
+};
+export const HAND_ARRAY = Object.values(HAND);

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export declare const opponentItemSchema: z.ZodObject<{
+    playerId: z.ZodString;
+    name: z.ZodString;
+    born: z.ZodNumber;
+    hand: z.ZodString;
+    show: z.ZodString;
+    comment: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    show: string;
+    playerId: string;
+    born: number;
+    hand: string;
+    comment?: string | undefined;
+}, {
+    name: string;
+    show: string;
+    playerId: string;
+    born: number;
+    hand: string;
+    comment?: string | undefined;
+}>;

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

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+// Add opponent to
+export const opponentItemSchema = z.object({
+    playerId: z.string().min(1, 'PlayerId is required.'),
+    name: z.string().min(1, 'Name is required.'),
+    born: z.number().int().gte(1950, 'Year must be greater than 1950.'),
+    hand: z.string().min(1, 'Dominant Hand is required.'),
+    show: z.string().min(1, 'Show is required.'),
+    comment: z.string().optional(),
+});

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { PERFORMANCE } from './interfaces';
+export function createInitialPerformanceItem(playerId, date) {
+    return {
+        _id: '',
+        playerId: playerId,
+        date: date,
+        type: PERFORMANCE.ACTIVITY.CourtSpeedTest1,
+        cost: 0,
+    };
+}

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

@@ -0,0 +1,68 @@
+import { ValueOf } from '../general';
+export declare const PERFORMANCE: {
+    readonly ACTIVITY: {
+        readonly CourtSpeedTest1: "Court Speed Test 1";
+        readonly CourtSpeedTest2: "Court Speed Test 2";
+        readonly MurrayAgilityExercise: "Murray Agility Exercise";
+        readonly SixPointAgilityExercise: "Six Point Agility Exercise";
+        readonly SitAndReachFlexibility: "Sit And Reach Flexibility";
+        readonly PlankCoreTest: "Plank Core Test";
+        readonly VerticalPowerJumpTest: "Vertical Power Jump Test";
+        readonly WallThrows: "Wall Throws";
+        readonly SkipTest90Secs: "Skip Test 90Secs";
+        readonly BleepTest20m: "Bleep Test 20m";
+        readonly FourKmRun: "Four Km Run";
+        readonly HillSprints: "Hill Sprints";
+    };
+    readonly UNITS: {
+        readonly CourtSpeedTest1: "seconds";
+        readonly CourtSpeedTest2: "seconds";
+        readonly MurrayAgilityExercise: "centimeters";
+        readonly SixPointAgilityExercise: "centimeters";
+        readonly SitAndReachFlexibility: "centimeters";
+        readonly PlankCoreTest: "kg";
+        readonly VerticalPowerJumpTest: "centimeters";
+        readonly WallThrows: "throws";
+        readonly SkipTest90Secs: "jumps";
+        readonly BleepTest20m: "levels";
+        readonly FourKmRun: "minutes";
+        readonly HillSprints: "seconds";
+    };
+};
+export type PERFORMANCE_ACTIVITY_UNION = ValueOf<typeof PERFORMANCE.ACTIVITY>;
+export declare const PERFORMANCE_ARRAYS: {
+    ACTIVITY: PERFORMANCE_ACTIVITY_UNION[];
+};
+export interface PerformanceType {
+    type: PERFORMANCE_ACTIVITY_UNION;
+    unit: string;
+}
+export declare const PERFORMANCE_TYPES: PerformanceType[];
+export interface PerformanceItem {
+    _id: string;
+    playerId: string;
+    date: Date;
+    type: PERFORMANCE_ACTIVITY_UNION;
+    cost: number;
+}
+export interface PerformanceTotals {
+    TotalsPerYear: {
+        year: number;
+        totalCost: number;
+        totalCostLastMonth: number;
+        averageSpendingPerMonth: number;
+        budget: number;
+        budgetRemaining: number;
+        costPerType: {
+            [type: string]: number;
+        };
+        costPerMonth: {
+            [month: string]: number;
+        };
+        costPerMonthPerType: {
+            [month: string]: {
+                [type: string]: number;
+            };
+        };
+    }[];
+}

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

@@ -0,0 +1,34 @@
+export const PERFORMANCE = {
+    ACTIVITY: {
+        CourtSpeedTest1: 'Court Speed Test 1',
+        CourtSpeedTest2: 'Court Speed Test 2',
+        MurrayAgilityExercise: 'Murray Agility Exercise',
+        SixPointAgilityExercise: 'Six Point Agility Exercise',
+        SitAndReachFlexibility: 'Sit And Reach Flexibility',
+        PlankCoreTest: 'Plank Core Test',
+        VerticalPowerJumpTest: 'Vertical Power Jump Test',
+        WallThrows: 'Wall Throws',
+        SkipTest90Secs: 'Skip Test 90Secs',
+        BleepTest20m: 'Bleep Test 20m',
+        FourKmRun: 'Four Km Run',
+        HillSprints: 'Hill Sprints',
+    },
+    UNITS: {
+        CourtSpeedTest1: 'seconds',
+        CourtSpeedTest2: 'seconds',
+        MurrayAgilityExercise: 'centimeters',
+        SixPointAgilityExercise: 'centimeters',
+        SitAndReachFlexibility: 'centimeters',
+        PlankCoreTest: 'kg',
+        VerticalPowerJumpTest: 'centimeters',
+        WallThrows: 'throws',
+        SkipTest90Secs: 'jumps',
+        BleepTest20m: 'levels',
+        FourKmRun: 'minutes',
+        HillSprints: 'seconds',
+    },
+};
+export const PERFORMANCE_ARRAYS = {
+    ACTIVITY: Object.values(PERFORMANCE.ACTIVITY),
+};
+export const PERFORMANCE_TYPES = Object.entries(PERFORMANCE.UNITS).map(([type, unit]) => ({ type, unit }));

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const performanceItemSchema: z.ZodObject<{
+    playerId: z.ZodString;
+    date: z.ZodEffects<z.ZodEffects<z.ZodDate, Date, Date>, Date, unknown>;
+    type: z.ZodString;
+    cost: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    date: Date;
+    playerId: string;
+    cost: number;
+}, {
+    type: string;
+    playerId: string;
+    cost: number;
+    date?: unknown;
+}>;

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+// Add performance testing to
+export const performanceItemSchema = 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.'),
+    cost: z.number(),
+});

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

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

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

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

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

@@ -0,0 +1,37 @@
+import { PlayerConfig, PlayerData } from './interfaces';
+import { ValueOf } from '../general';
+export declare const GLOBAL: {
+    TIME: {
+        allYears: string;
+        currentYear: string;
+        lastYear: string;
+        last2Years: string;
+        last3Years: string;
+        last4Years: string;
+        last5Years: string;
+        specificYear: string;
+    };
+    SET: {
+        all: string;
+        full: string;
+        short: string;
+    };
+    AGE: {
+        all: string;
+        u12: string;
+        u14: string;
+        u16: string;
+        u18: string;
+        adult: string;
+    };
+};
+export type GLOBAL_TIME_UNION = ValueOf<typeof GLOBAL.TIME>;
+export type GLOBAL_SET_UNION = ValueOf<typeof GLOBAL.SET>;
+export type GLOBAL_AGE_UNION = ValueOf<typeof GLOBAL.AGE>;
+export declare const GLOBAL_ARRAYS: {
+    TIME: GLOBAL_TIME_UNION[];
+    SET: GLOBAL_SET_UNION[];
+    AGE: GLOBAL_SET_UNION[];
+};
+export declare const createInitialPlayerConfig: (born: number) => PlayerConfig;
+export declare const createInitialPlayerData: () => Omit<PlayerData, "_id">;

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

@@ -0,0 +1,55 @@
+import { COMMONS } from '../general';
+import { createInitialSpendingCosts } from '../spending';
+export const GLOBAL = {
+    TIME: {
+        allYears: 'All Years',
+        currentYear: 'Current Year',
+        lastYear: 'Last Year',
+        last2Years: 'Last 2 Years',
+        last3Years: 'Last 3 Years',
+        last4Years: 'Last 4 Years',
+        last5Years: 'Last 5 Years',
+        specificYear: 'Specific Year',
+    },
+    SET: {
+        all: 'All',
+        full: 'Full',
+        short: 'Short'
+    },
+    AGE: {
+        all: 'All',
+        u12: 'U12',
+        u14: 'U14',
+        u16: 'U16',
+        u18: 'U18',
+        adult: 'Adult',
+    },
+};
+export const GLOBAL_ARRAYS = {
+    TIME: Object.values(GLOBAL.TIME),
+    SET: Object.values(GLOBAL.SET),
+    AGE: Object.values(GLOBAL.AGE),
+};
+// Factory function for PlayerConfig
+export const createInitialPlayerConfig = (born) => ({
+    theme: 'theme-orange-light',
+    dataTableRows: 10,
+    budget: 10000,
+    calendarUseToday: COMMONS.BOOLEAN.Yes,
+    calendarDefaultDate: new Date(),
+    born: born,
+    spendingCosts: createInitialSpendingCosts(),
+    globalFilterTimeFrame: GLOBAL.TIME.allYears,
+    globalFilterSpecificYear: new Date().getFullYear(),
+    globalFilterSetFormat: GLOBAL.SET.full,
+    globalFilterAgeGroup: GLOBAL.AGE.u14,
+});
+// Factory function for PlayerData
+export const createInitialPlayerData = () => ({
+    firstname: '',
+    lastname: '',
+    born: new Date().getFullYear() - 18,
+    password: '',
+    email: '',
+    config: createInitialPlayerConfig(new Date().getFullYear() - 18),
+});

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

@@ -0,0 +1,28 @@
+import { ObjectId } from 'mongodb';
+import { SpendingCosts } from '../spending';
+export interface PlayerData {
+    _id?: ObjectId;
+    firstname: string;
+    lastname: string;
+    born: number;
+    password?: string;
+    email: string;
+    config: PlayerConfig;
+}
+export interface PlayerConfig {
+    theme: string;
+    dataTableRows: number;
+    budget: number;
+    calendarUseToday: string;
+    calendarDefaultDate: Date;
+    born: number;
+    spendingCosts: SpendingCosts[];
+    globalFilterTimeFrame: string;
+    globalFilterSpecificYear: number;
+    globalFilterSetFormat: string;
+    globalFilterAgeGroup: string;
+}
+export interface LoginResponse {
+    player: PlayerData;
+    token: string;
+}

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

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