tenniscommon 1.0.1

package/README.md

@@ -0,0 +1,40 @@
+# Project Name
+
+Tennis Types for my project
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Installation
+
+To install the dependencies, run:
+
+```sh
+npm install
+```
+
+## Usage
+
+Provide instructions and examples for using your project. Here’s an example:
+
+```sh
+node your-script.js
+```
+
+```javascript
+const yourPackage = require('your-package-name');
+
+// Your code here
+```
+
+## Contributing
+
+Feel free to contribute by submitting a pull request. Please make sure to update tests as appropriate.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.

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

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

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

@@ -0,0 +1,148 @@
+"use strict";
+//Common functions
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertJsonToArrayWithTwoNumbers = exports.normalizeKey = exports.convertJsonToArray = exports.getAgeGroup = exports.getCurrentDateInDDMMYYYY = exports.getMonthByName = exports.getCurrentMonthNumber = exports.getMonthNameByOffset = exports.CurrentYearMinus12 = exports.CurrentMonth = exports.COLLECTION = exports.COMMONS_ARRAYS = exports.COMMONS = void 0;
+exports.getCurrentYear = getCurrentYear;
+exports.convertToDate = convertToDate;
+exports.configDate = configDate;
+exports.isValidPassword = isValidPassword;
+exports.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',
+    },
+};
+exports.COMMONS_ARRAYS = {
+    WEEKDAY: Object.values(exports.COMMONS.WEEKDAY),
+    MONTH: Object.values(exports.COMMONS.MONTH),
+    BOOLEAN: Object.values(exports.COMMONS.BOOLEAN),
+};
+exports.COLLECTION = {
+    matchplaySingles: "matchplaySingles",
+    matchplayDoubles: "matchplayDoubles",
+    opponent: "opponent",
+    performance: "performance",
+    player: "player",
+    spending: "spending",
+    trainingWeekly: "trainingWeekly",
+    training: "training",
+    tournament: "tournament",
+};
+exports.CurrentMonth = new Date().toLocaleString('default', { month: 'long' });
+exports.CurrentYearMinus12 = new Date().getFullYear() - 12;
+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' });
+};
+exports.getMonthNameByOffset = getMonthNameByOffset;
+function getCurrentYear(date) {
+    const currentDate = date ? date : new Date();
+    return currentDate.getFullYear();
+}
+const getCurrentMonthNumber = (date) => {
+    const currentDate = date ? date : new Date();
+    return currentDate.getMonth() + 1;
+};
+exports.getCurrentMonthNumber = getCurrentMonthNumber;
+const getMonthByName = (date) => {
+    const currentDate = date ? new Date(date) : new Date();
+    return exports.COMMONS_ARRAYS.MONTH[currentDate.getMonth()];
+};
+exports.getMonthByName = getMonthByName;
+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}`;
+};
+exports.getCurrentDateInDDMMYYYY = getCurrentDateInDDMMYYYY;
+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';
+    }
+};
+exports.getAgeGroup = getAgeGroup;
+const convertJsonToArray = (json, objectName, objectValue) => {
+    return Object.entries(json).map(([key, value]) => ({
+        [objectName]: key,
+        [objectValue]: value,
+    }));
+};
+exports.convertJsonToArray = convertJsonToArray;
+const normalizeKey = (key) => {
+    return key.toLowerCase().replace(/\s+/g, '-'); // Replace spaces with dashes
+};
+exports.normalizeKey = normalizeKey;
+const convertJsonToArrayWithTwoNumbers = (json, objectName, singlesKey, doublesKey) => {
+    return Object.entries(json).map(([key, value]) => ({
+        [objectName]: key,
+        [singlesKey]: value.singles,
+        [doublesKey]: value.doubles,
+    }));
+};
+exports.convertJsonToArrayWithTwoNumbers = convertJsonToArrayWithTwoNumbers;
+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;
+}
+function configDate(playerConfig) {
+    let parsedDate = new Date();
+    if (playerConfig.calendarUseToday === exports.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;
+}
+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/cjs/common/general/index.d.ts

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

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

@@ -0,0 +1,18 @@
+"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("./generalInterfaces"), exports);
+__exportStar(require("./generalUtils"), exports);

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

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

package/dist/cjs/common/matchplay/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/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/cjs/common/matchplay/initialData.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitialMatchplaySinglesItem = createInitialMatchplaySinglesItem;
+exports.createInitialMatchplayDoublesItem = createInitialMatchplayDoublesItem;
+const interfaces_1 = require("./interfaces");
+function createInitialMatchplaySinglesItem(playerId, date) {
+    return {
+        _id: '',
+        playerId: playerId,
+        date: date,
+        tournamentId: '',
+        tournamentYearId: '',
+        matchFormat: interfaces_1.MATCH.FORMAT.Singles,
+        matchAgeGroup: interfaces_1.MATCH.AGE_GROUP.U14,
+        matchRound: interfaces_1.MATCH.ROUND.QF,
+        matchSurface: interfaces_1.MATCH.SURFACE.Hard,
+        matchLocation: interfaces_1.MATCH.LOCATION.Indoor,
+        matchSetFormat: interfaces_1.MATCH.SET_FORMAT.Full,
+        matchResult: interfaces_1.MATCH.RESULT.Win,
+        partnerId: undefined,
+        opponentId: '',
+        opponentIdTwo: undefined,
+        firstSetWon: interfaces_1.MATCH.WINNER.Player,
+        secondSetWon: interfaces_1.MATCH.WINNER.Player,
+        decidingSetFormat: undefined,
+        decidingSetWon: undefined,
+        firstSet: '',
+        firstSetTieBreak: undefined,
+        secondSet: '',
+        secondSetTieBreak: undefined,
+        decidingSet: undefined,
+        decidingSetTieBreak: undefined,
+        comment: '',
+    };
+}
+function createInitialMatchplayDoublesItem(playerId, date) {
+    return {
+        _id: '',
+        playerId: playerId,
+        date: date,
+        tournamentId: '',
+        tournamentYearId: '',
+        matchFormat: interfaces_1.MATCH.FORMAT.Doubles,
+        matchAgeGroup: interfaces_1.MATCH.AGE_GROUP.U14,
+        matchRound: interfaces_1.MATCH.ROUND.QF,
+        matchSurface: interfaces_1.MATCH.SURFACE.Hard,
+        matchLocation: interfaces_1.MATCH.LOCATION.Indoor,
+        matchSetFormat: interfaces_1.MATCH.SET_FORMAT.Full,
+        matchResult: interfaces_1.MATCH.RESULT.Win,
+        partnerId: '',
+        opponentId: '',
+        opponentIdTwo: '',
+        firstSetWon: interfaces_1.MATCH.WINNER.Player,
+        secondSetWon: interfaces_1.MATCH.WINNER.Player,
+        decidingSetFormat: undefined,
+        decidingSetWon: undefined,
+        firstSet: '',
+        firstSetTieBreak: undefined,
+        secondSet: '',
+        secondSetTieBreak: undefined,
+        decidingSet: undefined,
+        decidingSetTieBreak: undefined,
+        comment: '',
+    };
+}

package/dist/cjs/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/cjs/common/matchplay/initialStats.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSpecificStats = exports.createMatchStats = exports.createEnhancedStatsPack = exports.createBasicStatsPack = exports.createStatsPack = exports.createMatchplayStats = void 0;
+const interfaces_1 = require("./interfaces");
+const createMatchplayStats = () => {
+    return {
+        Career: (0, exports.createStatsPack)(),
+        CareerSingles: (0, exports.createStatsPack)(),
+        CareerDoubles: (0, exports.createStatsPack)(),
+        combinedMatchesPerMonth: {},
+    };
+};
+exports.createMatchplayStats = createMatchplayStats;
+const createStatsPack = () => {
+    const statsPack = {
+        basicStatsPack: (0, exports.createBasicStatsPack)(),
+        enhancedStatsPack: (0, exports.createEnhancedStatsPack)(),
+    };
+    return statsPack;
+};
+exports.createStatsPack = createStatsPack;
+const createBasicStatsPack = () => {
+    const basicStatsPack = {
+        overall: (0, exports.createMatchStats)(),
+        firstSet: (0, exports.createSpecificStats)(),
+        firstSetTieBreak: (0, exports.createSpecificStats)(),
+        secondSet: (0, exports.createSpecificStats)(),
+        secondSetTieBreak: (0, exports.createSpecificStats)(),
+        firstAndSecondSets: (0, exports.createSpecificStats)(),
+        firstAndSecondSetTieBreaks: (0, exports.createSpecificStats)(),
+        decidingSet: (0, exports.createSpecificStats)(),
+        decidingSetTieBreak: (0, exports.createSpecificStats)(),
+        champTieBreak: (0, exports.createSpecificStats)(),
+        secondSetWinAfterFirstSetLoss: (0, exports.createSpecificStats)(),
+        games: (0, exports.createSpecificStats)(),
+    };
+    return basicStatsPack;
+};
+exports.createBasicStatsPack = createBasicStatsPack;
+const createEnhancedStatsPack = () => {
+    const matchStatsPack = {
+        matchStats_ByFormat: {},
+        matchStats_ByAgeGroup: {},
+        matchStats_ByRound: {},
+        matchStats_BySurface: {},
+        matchStats_ByLocation: {},
+        matchStats_BySetFormat: {},
+        matchStats_ByFirstSetWin: (0, exports.createMatchStats)(),
+        matchStats_ByFirstSetLost: (0, exports.createMatchStats)(),
+        matchStats_ByFirstSetTiebreak: (0, exports.createMatchStats)(),
+        matchStats_BySecondSetWin: (0, exports.createMatchStats)(),
+        matchStats_BySecondSetLost: (0, exports.createMatchStats)(),
+        matchStats_BySecondSetTiebreak: (0, exports.createMatchStats)(),
+        matchStats_ByGoingToDecidingSet: (0, exports.createMatchStats)(),
+        matchStats_ByDecidingSetFormat: {},
+        matchStats_ByDecidingSetWin: (0, exports.createMatchStats)(),
+        matchStats_ByDecidingSetLost: (0, exports.createMatchStats)(),
+    };
+    // Initializing byFormat
+    interfaces_1.MATCH_ARRAYS.FORMAT.forEach(key => {
+        matchStatsPack.matchStats_ByFormat[key] = (0, exports.createMatchStats)();
+    });
+    // Initializing byAgeGroup
+    interfaces_1.MATCH_ARRAYS.AGE_GROUP.forEach(key => {
+        matchStatsPack.matchStats_ByAgeGroup[key] = (0, exports.createMatchStats)();
+    });
+    // Initializing byRound
+    interfaces_1.MATCH_ARRAYS.ROUND.forEach(key => {
+        matchStatsPack.matchStats_ByRound[key] = (0, exports.createMatchStats)();
+    });
+    // Initializing bySurface
+    interfaces_1.MATCH_ARRAYS.SURFACE.forEach(key => {
+        matchStatsPack.matchStats_BySurface[key] = (0, exports.createMatchStats)();
+    });
+    // Initializing byLocation
+    interfaces_1.MATCH_ARRAYS.LOCATION.forEach(key => {
+        matchStatsPack.matchStats_ByLocation[key] = (0, exports.createMatchStats)();
+    });
+    // Initializing bySetFormat
+    interfaces_1.MATCH_ARRAYS.SET_FORMAT.forEach(key => {
+        matchStatsPack.matchStats_BySetFormat[key] = (0, exports.createMatchStats)();
+    });
+    // Initializing byDecidingSetFormat
+    interfaces_1.MATCH_ARRAYS.DECIDING_SET_FORMAT.forEach(key => {
+        matchStatsPack.matchStats_ByDecidingSetFormat[key] = (0, exports.createMatchStats)();
+    });
+    return matchStatsPack;
+};
+exports.createEnhancedStatsPack = createEnhancedStatsPack;
+const createMatchStats = () => ({
+    matches: 0,
+    won: 0,
+    lost: 0,
+    wonPercentage: 0,
+    lostPercentage: 0,
+});
+exports.createMatchStats = createMatchStats;
+const createSpecificStats = () => ({
+    total: 0,
+    won: 0,
+    lost: 0,
+    wonPercentage: 0,
+    lostPercentage: 0,
+});
+exports.createSpecificStats = createSpecificStats;

package/dist/cjs/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/cjs/common/matchplay/initialTotals.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultMatchStats = exports.createDefaultByType = exports.createDefaultMatchplayTotals = void 0;
+const interfaces_1 = require("./interfaces");
+const createDefaultMatchplayTotals = () => {
+    return {
+        Career: (0, exports.createDefaultByType)(),
+        CareerSingles: (0, exports.createDefaultByType)(),
+        CareerDoubles: (0, exports.createDefaultByType)(),
+        singlesMatchesPerMonth: {},
+        doublesMatchesPerMonth: {},
+        matchesPerMonth: {},
+    };
+};
+exports.createDefaultMatchplayTotals = createDefaultMatchplayTotals;
+const createDefaultByType = () => {
+    const byType = {
+        overall: (0, exports.createDefaultMatchStats)(),
+        byFormat: {},
+        byAgeGroup: {},
+        byRound: {},
+        bySurface: {},
+        byLocation: {},
+        bySetFormat: {},
+        byThirdSetFormat: {},
+        byGoingToThirdSet: (0, exports.createDefaultMatchStats)(),
+        byFirstSetLost: (0, exports.createDefaultMatchStats)(),
+        byFirstSetWin: (0, exports.createDefaultMatchStats)(),
+        byFirstSetTiebreak: (0, exports.createDefaultMatchStats)(),
+        bySecondSetTiebreak: (0, exports.createDefaultMatchStats)(),
+        justFirstSetTiebreaks: (0, exports.createDefaultMatchStats)(),
+        justSecondSetTiebreaks: (0, exports.createDefaultMatchStats)(),
+    };
+    // Initializing byFormat
+    interfaces_1.MATCH_ARRAYS.FORMAT.forEach(key => {
+        byType.byFormat[key] = (0, exports.createDefaultMatchStats)();
+    });
+    // Initializing byAgeGroup
+    interfaces_1.MATCH_ARRAYS.AGE_GROUP.forEach(key => {
+        byType.byAgeGroup[key] = (0, exports.createDefaultMatchStats)();
+    });
+    // Initializing byRound
+    interfaces_1.MATCH_ARRAYS.ROUND.forEach(key => {
+        byType.byRound[key] = (0, exports.createDefaultMatchStats)();
+    });
+    // Initializing bySurface
+    interfaces_1.MATCH_ARRAYS.SURFACE.forEach(key => {
+        byType.bySurface[key] = (0, exports.createDefaultMatchStats)();
+    });
+    // Initializing byLocation
+    interfaces_1.MATCH_ARRAYS.LOCATION.forEach(key => {
+        byType.byLocation[key] = (0, exports.createDefaultMatchStats)();
+    });
+    // Initializing bySetFormat
+    interfaces_1.MATCH_ARRAYS.SET_FORMAT.forEach(key => {
+        byType.bySetFormat[key] = (0, exports.createDefaultMatchStats)();
+    });
+    // Initializing byThirdSetFormat
+    interfaces_1.MATCH_ARRAYS.TIEBREAK.forEach(key => {
+        byType.byThirdSetFormat[key] = (0, exports.createDefaultMatchStats)();
+    });
+    return byType;
+};
+exports.createDefaultByType = createDefaultByType;
+const createDefaultMatchStats = () => ({
+    matches: 0,
+    won: 0,
+    lost: 0,
+    wonPercentage: 0,
+    lostPercentage: 0,
+});
+exports.createDefaultMatchStats = createDefaultMatchStats;