tenniscommon 1.0.1

package/dist/cjs/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/cjs/common/tournament/validation.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tournamentPartialItemSchema = exports.tournamentItemSchema = exports.tournamentYearItemSchema = void 0;
+const zod_1 = require("zod");
+// Add a tournament year to Year array
+exports.tournamentYearItemSchema = zod_1.z.object({
+    year: zod_1.z.number().int().gte(1950, 'Year must be greater than 1950.'),
+    date: zod_1.z.preprocess((arg) => (typeof arg === 'string' || arg instanceof Date ? new Date(arg) : undefined), zod_1.z.date().refine(date => !isNaN(date.getTime()), 'Invalid date.')),
+    category: zod_1.z.string().min(1, 'Category is required.'),
+    show: zod_1.z.string().min(1, 'Show is required.'),
+    comment: zod_1.z.string()
+});
+// Add a tournament to . Array must be empty with a new tournament record
+exports.tournamentItemSchema = zod_1.z.object({
+    playerId: zod_1.z.string().min(1, 'PlayerId is required.'),
+    name: zod_1.z.string().min(1, 'Name is required.'),
+    type: zod_1.z.string().min(1, 'Type is required.'),
+    tournamentYears: zod_1.z.array(zod_1.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
+exports.tournamentPartialItemSchema = zod_1.z.object({
+    playerId: zod_1.z.string().min(1, 'PlayerId is required.'),
+    name: zod_1.z.string().min(1, 'Name is required.'),
+    type: zod_1.z.string().min(1, 'Type is required.'),
+});

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./initialData"), exports);
+__exportStar(require("./initialStats"), exports);
+__exportStar(require("./validation"), exports);

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitialTrainingItem = createInitialTrainingItem;
+const interfaces_1 = require("./interfaces");
+// Factory function for creating initial TrainingItem
+function createInitialTrainingItem(playerId, date) {
+    return {
+        _id: '',
+        playerId: playerId,
+        date: date,
+        type: interfaces_1.TRAINING.ACTIVITY.Individual,
+        time: 1,
+    };
+}

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultTrainingTotal = void 0;
+const general_1 = require("../general");
+const interfaces_1 = require("./interfaces");
+const createDefaultTrainingTotal = () => {
+    const hoursPerType = {};
+    const hoursPerMonth = {};
+    const hoursPerMonthPerType = {};
+    interfaces_1.TRAINING_ARRAYS.ACTIVITY.forEach(type => { hoursPerType[type] = 0; });
+    general_1.COMMONS_ARRAYS.MONTH.forEach(month => {
+        hoursPerMonth[month] = 0;
+        hoursPerMonthPerType[month] = {};
+        interfaces_1.TRAINING_ARRAYS.ACTIVITY.forEach(type => {
+            hoursPerMonthPerType[month][type] = 0;
+        });
+    });
+    return {
+        totalHours: 0,
+        totalHoursLastMonth: 0,
+        averageHoursPerMonth: 0,
+        hoursPerType,
+        hoursPerMonth,
+        hoursPerMonthPerType,
+    };
+};
+exports.createDefaultTrainingTotal = createDefaultTrainingTotal;

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultTrainingTotal = void 0;
+const general_1 = require("../general");
+const interfaces_1 = require("./interfaces");
+const createDefaultTrainingTotal = () => {
+    const hoursPerType = {};
+    const hoursPerMonth = {};
+    const hoursPerMonthPerType = {};
+    interfaces_1.TRAINING_ARRAYS.ACTIVITY.forEach(type => { hoursPerType[type] = 0; });
+    general_1.COMMONS_ARRAYS.MONTH.forEach(month => {
+        hoursPerMonth[month] = 0;
+        hoursPerMonthPerType[month] = {};
+        interfaces_1.TRAINING_ARRAYS.ACTIVITY.forEach(type => {
+            hoursPerMonthPerType[month][type] = 0;
+        });
+    });
+    return {
+        totalHours: 0,
+        totalHoursLastMonth: 0,
+        averageHoursPerMonth: 0,
+        hoursPerType,
+        hoursPerMonth,
+        hoursPerMonthPerType,
+    };
+};
+exports.createDefaultTrainingTotal = createDefaultTrainingTotal;

package/dist/cjs/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/cjs/common/training/interfaces.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRAINING_ARRAYS = exports.TRAINING = void 0;
+exports.TRAINING = {
+    ACTIVITY: {
+        Squad: 'Squad',
+        Individual: 'Individual',
+        Lesson: 'Lesson',
+        Hit: 'Hit',
+        MatchPractice: 'Match-Practice',
+        Physical: 'Physical',
+        OtherSports: 'Other Sports',
+    },
+};
+exports.TRAINING_ARRAYS = {
+    ACTIVITY: Object.values(exports.TRAINING.ACTIVITY),
+};

package/dist/cjs/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/cjs/common/training/validation.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trainingItemSchema = void 0;
+const zod_1 = require("zod");
+exports.trainingItemSchema = zod_1.z.object({
+    playerId: zod_1.z.string().min(1, 'PlayerId is required.'),
+    date: zod_1.z.preprocess((arg) => (typeof arg === 'string' || arg instanceof Date ? new Date(arg) : undefined), zod_1.z.date().refine(date => !isNaN(date.getTime()), 'Invalid date.')),
+    type: zod_1.z.string().min(1, 'Type is required.'),
+    time: zod_1.z.number().nonnegative('Time must be a non-negative number.'),
+    spendingId: zod_1.z.string().optional()
+});

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./initialData"), exports);
+__exportStar(require("./validation"), exports);

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitialTrainingWeeklyItem = createInitialTrainingWeeklyItem;
+const spending_1 = require("../spending");
+const general_1 = require("../general");
+const training_1 = require("../training");
+function createInitialTrainingWeeklyItem(playerId) {
+    return {
+        _id: '',
+        playerId: playerId,
+        day: general_1.COMMONS.WEEKDAY.Monday,
+        type: training_1.TRAINING.ACTIVITY.Individual,
+        time: 1,
+        spendingType: spending_1.SPENDING.TYPE.CourtHire,
+        cost: 0,
+    };
+}

package/dist/cjs/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/cjs/common/trainingWeekly/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/common/trainingWeekly/validation.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trainingWeeklyItemSchema = void 0;
+const zod_1 = require("zod");
+exports.trainingWeeklyItemSchema = zod_1.z.object({
+    playerId: zod_1.z.string().min(1, 'PlayerId is required.'),
+    day: zod_1.z.string().min(1, 'Day is required.'),
+    type: zod_1.z.string().min(1, 'Type is required.'),
+    time: zod_1.z.number().nonnegative('Time must be a non-negative number.'),
+    spendingType: zod_1.z.string().min(1, 'Spending Type is required.'),
+    cost: zod_1.z.number().nonnegative('Cost must be a non-negative number.')
+});

package/dist/esm/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/esm/common/general/generalInterfaces.js

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

package/dist/esm/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/esm/common/general/generalUtils.js

@@ -0,0 +1,133 @@
+//Common functions
+export const COMMONS = {
+    WEEKDAY: {
+        Monday: 'Monday',
+        Tuesday: 'Tuesday',
+        Wednesday: 'Wednesday',
+        Thursday: 'Thursday',
+        Friday: 'Friday',
+        Saturday: 'Saturday',
+        Sunday: 'Sunday',
+    },
+    MONTH: {
+        January: 'January',
+        February: 'February',
+        March: 'March',
+        April: 'April',
+        May: 'May',
+        June: 'June',
+        July: 'July',
+        August: 'August',
+        September: 'September',
+        October: 'October',
+        November: 'November',
+        December: 'December',
+    },
+    BOOLEAN: {
+        Yes: 'Yes',
+        No: 'No',
+    },
+};
+export const COMMONS_ARRAYS = {
+    WEEKDAY: Object.values(COMMONS.WEEKDAY),
+    MONTH: Object.values(COMMONS.MONTH),
+    BOOLEAN: Object.values(COMMONS.BOOLEAN),
+};
+export const COLLECTION = {
+    matchplaySingles: "matchplaySingles",
+    matchplayDoubles: "matchplayDoubles",
+    opponent: "opponent",
+    performance: "performance",
+    player: "player",
+    spending: "spending",
+    trainingWeekly: "trainingWeekly",
+    training: "training",
+    tournament: "tournament",
+};
+export const CurrentMonth = new Date().toLocaleString('default', { month: 'long' });
+export const CurrentYearMinus12 = new Date().getFullYear() - 12;
+export const getMonthNameByOffset = (offset) => {
+    // Get the current date
+    const date = new Date();
+    // Set the date to the target month, accounting for the offset
+    date.setMonth(date.getMonth() - offset);
+    // Return the name of the target month
+    return date.toLocaleString('default', { month: 'long' });
+};
+export function getCurrentYear(date) {
+    const currentDate = date ? date : new Date();
+    return currentDate.getFullYear();
+}
+export const getCurrentMonthNumber = (date) => {
+    const currentDate = date ? date : new Date();
+    return currentDate.getMonth() + 1;
+};
+export const getMonthByName = (date) => {
+    const currentDate = date ? new Date(date) : new Date();
+    return COMMONS_ARRAYS.MONTH[currentDate.getMonth()];
+};
+export const getCurrentDateInDDMMYYYY = (date) => {
+    const day = String(date.getDate()).padStart(2, '0');
+    const month = String(date.getMonth() + 1).padStart(2, '0'); // Months are zero-based
+    const year = date.getFullYear();
+    return `${day}/${month}/${year}`;
+};
+export const getAgeGroup = (birthYear) => {
+    const currentYear = new Date().getFullYear();
+    const age = currentYear - birthYear;
+    if (age < 11) {
+        return `Under ${11}`;
+    }
+    else if (age >= 11 && age < 18) {
+        return `Under ${age}`;
+    }
+    else {
+        return 'Adult';
+    }
+};
+export const convertJsonToArray = (json, objectName, objectValue) => {
+    return Object.entries(json).map(([key, value]) => ({
+        [objectName]: key,
+        [objectValue]: value,
+    }));
+};
+export const normalizeKey = (key) => {
+    return key.toLowerCase().replace(/\s+/g, '-'); // Replace spaces with dashes
+};
+export const convertJsonToArrayWithTwoNumbers = (json, objectName, singlesKey, doublesKey) => {
+    return Object.entries(json).map(([key, value]) => ({
+        [objectName]: key,
+        [singlesKey]: value.singles,
+        [doublesKey]: value.doubles,
+    }));
+};
+export function convertToDate(dateInput) {
+    const parsedDate = new Date(dateInput);
+    // Fallback to the current date if the parsed date is invalid
+    if (isNaN(parsedDate.getTime())) {
+        console.warn("Invalid date input, returning current date.");
+        return new Date();
+    }
+    return parsedDate;
+}
+export function configDate(playerConfig) {
+    let parsedDate = new Date();
+    if (playerConfig.calendarUseToday === COMMONS.BOOLEAN.No) {
+        parsedDate = new Date(playerConfig.calendarDefaultDate);
+        //Fallback to the current date if the parsed date is invalid
+        if (isNaN(parsedDate.getTime())) {
+            console.warn("Invalid date input, returning current date.");
+            return new Date();
+        }
+    }
+    return parsedDate;
+}
+export function isValidPassword(password) {
+    const minLength = 8;
+    //const hasUpperCase = /[A-Z]/.test(password);
+    const hasLowerCase = /[a-z]/.test(password);
+    //const hasDigit = /\d/.test(password);
+    //const hasSpecialChar = /[\W_]/.test(password); // including symbols and underscores
+    return password.length >= minLength && hasLowerCase;
+    //return password.length >= minLength && hasUpperCase && hasLowerCase && hasDigit && hasSpecialChar;
+}

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

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

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

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

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

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

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

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

package/dist/esm/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;