tenniscommon 1.0.1

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

@@ -0,0 +1,204 @@
+import { z } from 'zod';
+export declare const playerConfigSchema: z.ZodObject<{
+    theme: z.ZodString;
+    dataTableRows: z.ZodNumber;
+    budget: z.ZodNumber;
+    calendarUseToday: z.ZodEffects<z.ZodString, {
+        value: boolean;
+        error: null;
+    } | {
+        value: null;
+        error: string;
+    }, string>;
+    calendarDefaultDate: z.ZodEffects<z.ZodEffects<z.ZodDate, Date, Date>, Date, unknown>;
+    born: z.ZodNumber;
+    spendingCosts: z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        cost: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        cost: number;
+        category: string;
+    }, {
+        cost: number;
+        category: string;
+    }>, "atleastone">;
+    globalFilterTimeFrame: z.ZodString;
+    globalFilterSpecificYear: z.ZodNumber;
+    globalFilterSetFormat: z.ZodString;
+    globalFilterAgeGroup: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    born: number;
+    theme: string;
+    dataTableRows: number;
+    budget: number;
+    calendarUseToday: {
+        value: boolean;
+        error: null;
+    } | {
+        value: null;
+        error: string;
+    };
+    calendarDefaultDate: Date;
+    spendingCosts: [{
+        cost: number;
+        category: string;
+    }, ...{
+        cost: number;
+        category: string;
+    }[]];
+    globalFilterTimeFrame: string;
+    globalFilterSpecificYear: number;
+    globalFilterSetFormat: string;
+    globalFilterAgeGroup: string;
+}, {
+    born: number;
+    theme: string;
+    dataTableRows: number;
+    budget: number;
+    calendarUseToday: string;
+    spendingCosts: [{
+        cost: number;
+        category: string;
+    }, ...{
+        cost: number;
+        category: string;
+    }[]];
+    globalFilterTimeFrame: string;
+    globalFilterSpecificYear: number;
+    globalFilterSetFormat: string;
+    globalFilterAgeGroup: string;
+    calendarDefaultDate?: unknown;
+}>;
+export declare const playerDataSchema: z.ZodObject<{
+    firstname: z.ZodString;
+    lastname: z.ZodString;
+    born: z.ZodNumber;
+    password: z.ZodOptional<z.ZodString>;
+    email: z.ZodString;
+    config: z.ZodObject<{
+        theme: z.ZodString;
+        dataTableRows: z.ZodNumber;
+        budget: z.ZodNumber;
+        calendarUseToday: z.ZodEffects<z.ZodString, {
+            value: boolean;
+            error: null;
+        } | {
+            value: null;
+            error: string;
+        }, string>;
+        calendarDefaultDate: z.ZodEffects<z.ZodEffects<z.ZodDate, Date, Date>, Date, unknown>;
+        born: z.ZodNumber;
+        spendingCosts: z.ZodArray<z.ZodObject<{
+            category: z.ZodString;
+            cost: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            cost: number;
+            category: string;
+        }, {
+            cost: number;
+            category: string;
+        }>, "atleastone">;
+        globalFilterTimeFrame: z.ZodString;
+        globalFilterSpecificYear: z.ZodNumber;
+        globalFilterSetFormat: z.ZodString;
+        globalFilterAgeGroup: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        born: number;
+        theme: string;
+        dataTableRows: number;
+        budget: number;
+        calendarUseToday: {
+            value: boolean;
+            error: null;
+        } | {
+            value: null;
+            error: string;
+        };
+        calendarDefaultDate: Date;
+        spendingCosts: [{
+            cost: number;
+            category: string;
+        }, ...{
+            cost: number;
+            category: string;
+        }[]];
+        globalFilterTimeFrame: string;
+        globalFilterSpecificYear: number;
+        globalFilterSetFormat: string;
+        globalFilterAgeGroup: string;
+    }, {
+        born: number;
+        theme: string;
+        dataTableRows: number;
+        budget: number;
+        calendarUseToday: string;
+        spendingCosts: [{
+            cost: number;
+            category: string;
+        }, ...{
+            cost: number;
+            category: string;
+        }[]];
+        globalFilterTimeFrame: string;
+        globalFilterSpecificYear: number;
+        globalFilterSetFormat: string;
+        globalFilterAgeGroup: string;
+        calendarDefaultDate?: unknown;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    firstname: string;
+    lastname: string;
+    born: number;
+    config: {
+        born: number;
+        theme: string;
+        dataTableRows: number;
+        budget: number;
+        calendarUseToday: {
+            value: boolean;
+            error: null;
+        } | {
+            value: null;
+            error: string;
+        };
+        calendarDefaultDate: Date;
+        spendingCosts: [{
+            cost: number;
+            category: string;
+        }, ...{
+            cost: number;
+            category: string;
+        }[]];
+        globalFilterTimeFrame: string;
+        globalFilterSpecificYear: number;
+        globalFilterSetFormat: string;
+        globalFilterAgeGroup: string;
+    };
+    password?: string | undefined;
+}, {
+    email: string;
+    firstname: string;
+    lastname: string;
+    born: number;
+    config: {
+        born: number;
+        theme: string;
+        dataTableRows: number;
+        budget: number;
+        calendarUseToday: string;
+        spendingCosts: [{
+            cost: number;
+            category: string;
+        }, ...{
+            cost: number;
+            category: string;
+        }[]];
+        globalFilterTimeFrame: string;
+        globalFilterSpecificYear: number;
+        globalFilterSetFormat: string;
+        globalFilterAgeGroup: string;
+        calendarDefaultDate?: unknown;
+    };
+    password?: string | undefined;
+}>;

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

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+// Define schema for a single SpendingCost
+const SpendingCostSchema = z.object({
+    category: z.string().min(1, 'Category is required.'),
+    cost: z.number().nonnegative('Cost must be a non-negative number.'),
+});
+//Add and Update Config
+export const playerConfigSchema = z.object({
+    theme: z.string().min(1, 'Theme is required.'),
+    dataTableRows: z.number().nonnegative('Data Table Rows must be a non-negative number.'),
+    budget: z.number().nonnegative('Budget must be a non-negative number.'),
+    calendarUseToday: z.string().transform((val) => {
+        if (val === 'Yes')
+            return { value: true, error: null };
+        if (val === 'No')
+            return { value: false, error: null };
+        return { value: null, error: 'Invalid value; must be "Yes" or "No"' };
+    }),
+    calendarDefaultDate: z.preprocess((arg) => (typeof arg === 'string' || arg instanceof Date ? new Date(arg) : undefined), z.date().refine(date => !isNaN(date.getTime()), 'Invalid date.')),
+    born: z.number().int().gte(1950, 'Year must be greater than 1950.'),
+    spendingCosts: z.array(SpendingCostSchema).nonempty('Spending Costs is required.'),
+    globalFilterTimeFrame: z.string().min(1, 'Global Filter Time Frame is required.'),
+    globalFilterSpecificYear: z.number().int().gte(1950, 'Year must be greater than 1950.'),
+    globalFilterSetFormat: z.string().min(1, 'Global Filter Set Format is required.'),
+    globalFilterAgeGroup: z.string().min(1, 'Global Filter Age Group is required.'),
+});
+//Add Config
+export const playerDataSchema = z.object({
+    firstname: z.string().min(1, 'First name is required.'),
+    lastname: z.string().min(1, 'Last name is required.'),
+    born: z.number().int().gte(1950, 'Year must be greater than 1950.'),
+    password: z.string().optional(),
+    email: z.string().email('Invalid email address.'),
+    config: playerConfigSchema,
+});

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

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { SPENDING } from './interfaces';
+// Factory function for creating initial SpendingItem
+export function createInitialSpendingItem(playerId, date) {
+    return {
+        _id: '',
+        playerId: playerId,
+        date: date,
+        type: SPENDING.TYPE.Tournament,
+        cost: 0,
+        linkedToTraining: false,
+    };
+}

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

@@ -0,0 +1,2 @@
+import { SpendingTotals } from './interfaces';
+export declare const createDefaultSpendingTotal: (budget?: number) => SpendingTotals;

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

@@ -0,0 +1,25 @@
+import { SPENDING_ARRAYS } from './interfaces';
+import { COMMONS_ARRAYS } from '../general';
+export const createDefaultSpendingTotal = (budget = 0) => {
+    const costPerType = {};
+    const costPerMonth = {};
+    const costPerMonthPerType = {};
+    SPENDING_ARRAYS.TYPE.forEach(type => (costPerType[type] = 0));
+    COMMONS_ARRAYS.MONTH.forEach(month => {
+        costPerMonth[month] = 0;
+        costPerMonthPerType[month] = {};
+        SPENDING_ARRAYS.TYPE.forEach(type => {
+            costPerMonthPerType[month][type] = 0;
+        });
+    });
+    return {
+        totalCost: 0,
+        budget,
+        budgetRemaining: budget,
+        costPerType,
+        costPerMonth,
+        costPerMonthPerType,
+        totalCostLastMonth: 0,
+        averageSpendingPerMonth: 0
+    };
+};

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

@@ -0,0 +1,2 @@
+import { SpendingTotals } from './interfaces';
+export declare const createDefaultSpendingTotal: (budget?: number) => SpendingTotals;

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

@@ -0,0 +1,25 @@
+import { SPENDING_ARRAYS } from './interfaces';
+import { COMMONS_ARRAYS } from '../general';
+export const createDefaultSpendingTotal = (budget = 0) => {
+    const costPerType = {};
+    const costPerMonth = {};
+    const costPerMonthPerType = {};
+    SPENDING_ARRAYS.TYPE.forEach(type => (costPerType[type] = 0));
+    COMMONS_ARRAYS.MONTH.forEach(month => {
+        costPerMonth[month] = 0;
+        costPerMonthPerType[month] = {};
+        SPENDING_ARRAYS.TYPE.forEach(type => {
+            costPerMonthPerType[month][type] = 0;
+        });
+    });
+    return {
+        totalCost: 0,
+        budget,
+        budgetRemaining: budget,
+        costPerType,
+        costPerMonth,
+        costPerMonthPerType,
+        totalCostLastMonth: 0,
+        averageSpendingPerMonth: 0
+    };
+};

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

@@ -0,0 +1,61 @@
+import { ValueOf } from '../general';
+export declare const SPENDING: {
+    readonly TYPE: {
+        readonly None: "None";
+        readonly Tournament: "Tournament";
+        readonly Accommodation: "Accommodation";
+        readonly Equipment: "Equipment";
+        readonly Strings: "Strings";
+        readonly CourtHire: "Court Hire";
+        readonly Hit: "Hit";
+        readonly Gym: "Gym";
+        readonly Squad: "Squad";
+        readonly Lesson: "Lesson";
+        readonly Physical: "Physical";
+        readonly Physio: "Physio";
+        readonly Membership: "Membership";
+    };
+};
+export declare const createInitialSpendingCosts: () => {
+    category: string;
+    cost: number;
+}[];
+export type SPENDING_TYPE_UNION = ValueOf<typeof SPENDING.TYPE>;
+export declare const SPENDING_ARRAYS: {
+    TYPE: SPENDING_TYPE_UNION[];
+};
+export interface SpendingItem {
+    _id: string;
+    playerId: string;
+    date: Date;
+    type: SPENDING_TYPE_UNION;
+    cost: number;
+    linkedToTraining: boolean;
+}
+export interface SpendingTotals {
+    totalCost: number;
+    totalCostLastMonth: number;
+    averageSpendingPerMonth: number;
+    budget: number;
+    budgetRemaining: number;
+    costPerType: {
+        [type: string]: number;
+    };
+    costPerMonth: {
+        [month: string]: number;
+    };
+    costPerMonthPerType: {
+        [month: string]: {
+            [type: string]: number;
+        };
+    };
+}
+export interface MonthlyCostPerType {
+    [month: string]: {
+        [type: string]: number;
+    };
+}
+export interface SpendingCosts {
+    category: string;
+    cost: number;
+}

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

@@ -0,0 +1,37 @@
+export const SPENDING = {
+    TYPE: {
+        None: 'None',
+        Tournament: 'Tournament',
+        Accommodation: 'Accommodation',
+        Equipment: 'Equipment',
+        Strings: 'Strings',
+        CourtHire: 'Court Hire',
+        Hit: 'Hit',
+        Gym: 'Gym',
+        Squad: 'Squad',
+        Lesson: 'Lesson',
+        Physical: 'Physical',
+        Physio: 'Physio',
+        Membership: 'Membership',
+    },
+};
+export const createInitialSpendingCosts = () => {
+    return [
+        { category: 'None', cost: 0 },
+        { category: 'Tournament', cost: 50 },
+        { category: 'Accommodation', cost: 175 },
+        { category: 'Equipment', cost: 100 },
+        { category: 'Strings', cost: 40 },
+        { category: 'Court Hire', cost: 7.5 },
+        { category: 'Hit', cost: 15 },
+        { category: 'Gym', cost: 25 },
+        { category: 'Squad', cost: 0 },
+        { category: 'Lesson', cost: 35 },
+        { category: 'Physical', cost: 30 },
+        { category: 'Physio', cost: 55 },
+        { category: 'Membership', cost: 120 }
+    ];
+};
+export const SPENDING_ARRAYS = {
+    TYPE: Object.values(SPENDING.TYPE),
+};

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

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

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { SPENDING } from './interfaces';
+// Add spending to
+export const spendingItemSchema = 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.').refine(value => value !== SPENDING.TYPE.None, {
+        message: 'Type cannot be "None".',
+    }),
+    cost: z.number().gt(0, 'Cost must be greater than zero.'),
+    linkedToTraining: z.boolean(),
+});
+export const spendingItemSchemaFromTraining = 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(),
+    linkedToTraining: z.boolean(),
+});

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

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

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

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

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

@@ -0,0 +1,3 @@
+import { TournamentItem, TournamentYearItem } from './interfaces';
+export declare function createInitialTournamentYearItem(date: Date): TournamentYearItem;
+export declare function createInitialTournamentItem(playerId: string): TournamentItem;

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

@@ -0,0 +1,23 @@
+import { COMMONS } from '../general';
+import { TOURNAMENT } from './interfaces';
+// Factory function for creating initial TournamentYearItem
+export function createInitialTournamentYearItem(date) {
+    return {
+        yearId: '',
+        year: date.getFullYear(),
+        date: date,
+        category: TOURNAMENT.CATEGORY.T500,
+        show: COMMONS.BOOLEAN.Yes,
+        comment: '',
+    };
+}
+// Factory function for creating initial TournamentItem
+export function createInitialTournamentItem(playerId) {
+    return {
+        _id: '',
+        playerId: playerId,
+        name: '',
+        type: TOURNAMENT.TYPE.TennisIreland,
+        tournamentYears: [], // Alternatively, you can use [createInitialTournamentYearItem()] if you need to initialize with a default year item
+    };
+}

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

@@ -0,0 +1,43 @@
+import { BOOLEAN_UNION } from '../general';
+import { ValueOf } from '../general';
+export declare const TOURNAMENT: {
+    readonly TYPE: {
+        readonly TennisIreland: "Tennis Ireland";
+        readonly TennisEuropean: "Tennis European";
+        readonly BelfastAndDistrictLeague: "Belfast And District League";
+    };
+    readonly CATEGORY: {
+        readonly WTN: "WTN Only";
+        readonly T100: "T100";
+        readonly T200: "T200";
+        readonly T500: "T500";
+        readonly T1000: "T1000";
+        readonly T1250: "T1250";
+        readonly T1500: "T1500";
+        readonly T2000: "T2000";
+        readonly EuropeC1: "Europe C1";
+        readonly EuropeC2: "Europe C2";
+        readonly EuropeC3: "Europe C3";
+    };
+};
+export type TOURNAMENT_TYPE_UNION = ValueOf<typeof TOURNAMENT.TYPE>;
+export type TOURNAMENT_CATEGORY_UNION = ValueOf<typeof TOURNAMENT.CATEGORY>;
+export declare const TOURNAMENT_ARRAYS: {
+    TYPE: TOURNAMENT_TYPE_UNION[];
+    CATEGORY: TOURNAMENT_CATEGORY_UNION[];
+};
+export interface TournamentItem {
+    _id: string;
+    playerId: string;
+    name: string;
+    type: TOURNAMENT_TYPE_UNION;
+    tournamentYears: TournamentYearItem[];
+}
+export interface TournamentYearItem {
+    yearId: string;
+    year: number;
+    date: Date;
+    category: TOURNAMENT_CATEGORY_UNION;
+    show: BOOLEAN_UNION;
+    comment: string;
+}

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

@@ -0,0 +1,24 @@
+export const TOURNAMENT = {
+    TYPE: {
+        TennisIreland: 'Tennis Ireland',
+        TennisEuropean: 'Tennis European',
+        BelfastAndDistrictLeague: 'Belfast And District League',
+    },
+    CATEGORY: {
+        WTN: 'WTN Only',
+        T100: 'T100',
+        T200: 'T200',
+        T500: 'T500',
+        T1000: 'T1000',
+        T1250: 'T1250',
+        T1500: 'T1500',
+        T2000: 'T2000',
+        EuropeC1: 'Europe C1',
+        EuropeC2: 'Europe C2',
+        EuropeC3: 'Europe C3',
+    },
+};
+export const TOURNAMENT_ARRAYS = {
+    TYPE: Object.values(TOURNAMENT.TYPE),
+    CATEGORY: Object.values(TOURNAMENT.CATEGORY),
+};

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

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+export declare const tournamentYearItemSchema: z.ZodObject<{
+    year: z.ZodNumber;
+    date: z.ZodEffects<z.ZodEffects<z.ZodDate, Date, Date>, Date, unknown>;
+    category: z.ZodString;
+    show: z.ZodString;
+    comment: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    show: string;
+    year: number;
+    date: Date;
+    comment: string;
+    category: string;
+}, {
+    show: string;
+    year: number;
+    comment: string;
+    category: string;
+    date?: unknown;
+}>;
+export declare const tournamentItemSchema: z.ZodObject<{
+    playerId: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodString;
+    tournamentYears: z.ZodArray<z.ZodAny, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: string;
+    playerId: string;
+    tournamentYears: any[];
+}, {
+    name: string;
+    type: string;
+    playerId: string;
+    tournamentYears: any[];
+}>;
+export declare const tournamentPartialItemSchema: z.ZodObject<{
+    playerId: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: string;
+    playerId: string;
+}, {
+    name: string;
+    type: string;
+    playerId: string;
+}>;

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+// Add a tournament year to Year array
+export const tournamentYearItemSchema = z.object({
+    year: z.number().int().gte(1950, 'Year must be greater than 1950.'),
+    date: z.preprocess((arg) => (typeof arg === 'string' || arg instanceof Date ? new Date(arg) : undefined), z.date().refine(date => !isNaN(date.getTime()), 'Invalid date.')),
+    category: z.string().min(1, 'Category is required.'),
+    show: z.string().min(1, 'Show is required.'),
+    comment: z.string()
+});
+// Add a tournament to . Array must be empty with a new tournament record
+export const tournamentItemSchema = z.object({
+    playerId: z.string().min(1, 'PlayerId is required.'),
+    name: z.string().min(1, 'Name is required.'),
+    type: z.string().min(1, 'Type is required.'),
+    tournamentYears: z.array(z.any()).length(0, 'Year must be an empty array.'),
+});
+// Update a tournament to . Array will be undefined as this is for a partial update
+export const tournamentPartialItemSchema = z.object({
+    playerId: z.string().min(1, 'PlayerId is required.'),
+    name: z.string().min(1, 'Name is required.'),
+    type: z.string().min(1, 'Type is required.'),
+});

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

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