@movalib/movalib-commons 1.0.67 → 1.0.68

package/dist/src/ScheduleFields.js

@@ -0,0 +1,202 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FR_WEEK_DAYS = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var react_1 = require("react");
+var material_1 = require("@mui/material");
+var AddRounded_1 = __importDefault(require("@mui/icons-material/AddRounded"));
+var DeleteRounded_1 = __importDefault(require("@mui/icons-material/DeleteRounded"));
+var x_date_pickers_1 = require("@mui/x-date-pickers");
+var theme_1 = __importDefault(require("../theme")); // Import du thème personnalisé
+var Enums_1 = require("./helpers/Enums");
+var Logger_1 = __importDefault(require("./helpers/Logger"));
+exports.FR_WEEK_DAYS = ['Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi', 'Dimanche'];
+var initialSchedules = [
+    { day: Enums_1.DayOfWeek.MONDAY, checked: false, allDay: false, intervals: [{ startTime: null, endTime: null, countryCode: 'fr', error: null }] },
+    { day: Enums_1.DayOfWeek.TUESDAY, checked: false, allDay: false, intervals: [{ startTime: null, endTime: null, countryCode: 'fr', error: null }] },
+    { day: Enums_1.DayOfWeek.WEDNESDAY, checked: false, allDay: false, intervals: [{ startTime: null, endTime: null, countryCode: 'fr', error: null }] },
+    { day: Enums_1.DayOfWeek.THURSDAY, checked: false, allDay: false, intervals: [{ startTime: null, endTime: null, countryCode: 'fr', error: null }] },
+    { day: Enums_1.DayOfWeek.FRIDAY, checked: false, allDay: false, intervals: [{ startTime: null, endTime: null, countryCode: 'fr', error: null }] },
+    { day: Enums_1.DayOfWeek.SATURDAY, checked: false, allDay: false, intervals: [{ startTime: null, endTime: null, countryCode: 'fr', error: null }] },
+    { day: Enums_1.DayOfWeek.SUNDAY, checked: false, allDay: false, intervals: [{ startTime: null, endTime: null, countryCode: 'fr', error: null }] },
+];
+var ScheduleFields = function (_a) {
+    var timePickerStep = _a.timePickerStep, schedules = _a.schedules, size = _a.size, onChange = _a.onChange;
+    var mergeSchedules = function (apiSchedules) {
+        // Créez une copie profonde du tableau initialSchedules pour éviter toute mutation accidentelle
+        var mergedSchedules = JSON.parse(JSON.stringify(initialSchedules));
+        // Parcourez chaque élément de apiSchedules et mettez à jour updatedSchedules
+        var today = new Date().toISOString().substring(0, 10);
+        var _loop_1 = function (apiSchedule) {
+            var dayIndex = mergedSchedules.findIndex(function (schedule) { return schedule.day === apiSchedule.dayOfWeek; });
+            if (dayIndex !== -1) {
+                mergedSchedules[dayIndex].checked = apiSchedule.intervals.length > 0;
+                mergedSchedules[dayIndex].intervals = apiSchedule.intervals.map(function (interval) { return (__assign(__assign({}, interval), { 
+                    // On injecte une date fictive même si nous n'utilisons que l'heure, le Timepicker attend une Date JS Valide
+                    startTime: new Date("".concat(today, "T").concat(interval.startTime)), endTime: new Date("".concat(today, "T").concat(interval.endTime)), error: null })); });
+                mergedSchedules[dayIndex].allDay = apiSchedule.isAllWorkingDay;
+            }
+        };
+        for (var _i = 0, apiSchedules_1 = apiSchedules; _i < apiSchedules_1.length; _i++) {
+            var apiSchedule = apiSchedules_1[_i];
+            _loop_1(apiSchedule);
+        }
+        Logger_1.default.info(mergedSchedules);
+        return mergedSchedules;
+    };
+    /**
+     * Cette fonction renvoie une liste de DaySchedule depuis une liste de Schedule
+     * @returns
+     */
+    var initializeFromSchedules = function () {
+        if (schedules && schedules.length > 0) {
+            return schedules.map(function (s) {
+                var iList = s.intervals.map(function (i) { return ({
+                    startTime: new Date(i.startTime),
+                    endTime: new Date(i.endTime),
+                    countryCode: i.countryCode,
+                    error: null,
+                }); });
+                return {
+                    day: s.dayOfWeek,
+                    checked: iList.length > 0,
+                    intervals: iList,
+                };
+            });
+        }
+        return [];
+    };
+    // Si des schedules sont transmises on initialise un nouveau tableau de DaySchedule[]
+    var _b = (0, react_1.useState)(initialSchedules), schedule = _b[0], setSchedule = _b[1];
+    // Chargement initial des données du garage
+    (0, react_1.useEffect)(function () {
+        if (schedules && schedules.length > 0) {
+            setSchedule(mergeSchedules(schedules));
+        }
+    }, [schedules]); // Exécute le hook à chaque fois que les schedules transmis en props changent
+    var handleDayChecked = function (dayIndex) { return function (event) {
+        var newSchedule = __spreadArray([], schedule, true);
+        newSchedule[dayIndex].checked = event.target.checked;
+        // On réinitialise aussi les intervals
+        newSchedule[dayIndex].intervals = [{ startTime: null, endTime: null, countryCode: 'fr', error: null }];
+        onChange(newSchedule);
+        setSchedule(newSchedule);
+    }; };
+    var handleAllDayChecked = function (e, value, dayIndex) { return function (event) {
+        e.preventDefault();
+        var newSchedule = __spreadArray([], schedule, true);
+        newSchedule[dayIndex].allDay = event.target.checked;
+        onChange(newSchedule);
+        setSchedule(newSchedule);
+    }; };
+    var validateInterval = function (start, end) {
+        if (start instanceof Date && end instanceof Date && start.getTime() > end.getTime()) {
+            return "L'heure de début doit être antérieure à l'heure de fin";
+        }
+        return null;
+    };
+    var validateIntervals = function (intervals) {
+        var _a, _b, _c, _d;
+        // On tri les intervals par date de début
+        var sortedIntervals = __spreadArray([], intervals, true).sort(function (a, b) {
+            return a.startTime && b.startTime ? a.startTime.toISOString().localeCompare(b.startTime.toISOString()) : 0;
+        });
+        console.log(sortedIntervals);
+        for (var i = 0; i < sortedIntervals.length; i++) {
+            if (((_a = sortedIntervals[i].startTime) === null || _a === void 0 ? void 0 : _a.toString().localeCompare((_b = sortedIntervals[i].endTime) === null || _b === void 0 ? void 0 : _b.toString())) >= 0 ||
+                (i < sortedIntervals.length - 1 &&
+                    ((_c = sortedIntervals[i].endTime) === null || _c === void 0 ? void 0 : _c.toString().localeCompare((_d = sortedIntervals[i + 1].startTime) === null || _d === void 0 ? void 0 : _d.toString())) > 0)) {
+                return 'Attention vos intervales se chevauchent'; // start time is after or equal to end time, or end time of current interval is after start time of next interval
+            }
+        }
+        return null; // all intervals are valid and there are no overlapping intervals
+    };
+    var handleIntervalChange = function (dayIndex, intervalIndex, type) {
+        return function (newValue) {
+            var newSchedule = __spreadArray([], schedule, true);
+            newSchedule[dayIndex].intervals[intervalIndex][type] = newValue;
+            newSchedule[dayIndex].intervals[intervalIndex].error = validateInterval(newSchedule[dayIndex].intervals[intervalIndex].startTime, newSchedule[dayIndex].intervals[intervalIndex].endTime);
+            //Contrôle le chevauchement d'intervales
+            if (type === 'endTime' && intervalIndex > 0 && !newSchedule[dayIndex].intervals[intervalIndex].error) {
+                console.log(dayIndex);
+                console.log(newSchedule[dayIndex].intervals);
+                newSchedule[dayIndex].intervals[intervalIndex].error = validateIntervals(newSchedule[dayIndex].intervals);
+            }
+            setSchedule(newSchedule);
+            onChange(newSchedule);
+        };
+    };
+    var addInterval = function (dayIndex) { return function () {
+        Logger_1.default.info(dayIndex);
+        var newSchedule = __spreadArray([], schedule, true);
+        newSchedule[dayIndex].intervals.push({ startTime: null, endTime: null, countryCode: 'fr', error: null });
+        Logger_1.default.info(newSchedule);
+        setSchedule(newSchedule);
+    }; };
+    var deleteInterval = function (dayIndex, intervalIndex) { return function () {
+        var newSchedule = __spreadArray([], schedule, true);
+        newSchedule[dayIndex].intervals.splice(intervalIndex, 1);
+        onChange(newSchedule);
+        setSchedule(newSchedule);
+    }; };
+    var getDayOfWeekIndex = function (day) {
+        if (day) {
+            // Convertir les valeurs de l'énumération en un tableau
+            var daysArray = Object.values(Enums_1.DayOfWeek);
+            return daysArray.indexOf(day);
+        }
+        return -1;
+    };
+    return ((0, jsx_runtime_1.jsx)(material_1.Grid, __assign({ container: true, spacing: 1, sx: { minWidth: '650px', maxWidth: '800px' } }, { children: schedule.map(function (daySchedule, dayIndex) { return ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)(material_1.Grid, { item: true, xs: 1 }), (0, jsx_runtime_1.jsx)(material_1.Grid, __assign({ item: true, xs: 2 }, { children: (0, jsx_runtime_1.jsx)(material_1.FormControlLabel, { control: (0, jsx_runtime_1.jsx)(material_1.Checkbox, { checked: daySchedule.checked, onChange: handleDayChecked(dayIndex) }), label: exports.FR_WEEK_DAYS[getDayOfWeekIndex(daySchedule.day)] }) }), dayIndex + 1), (0, jsx_runtime_1.jsx)(material_1.Grid, __assign({ item: true, xs: 7 }, { children: daySchedule.intervals.map(function (interval, intervalIndex) { return ((0, jsx_runtime_1.jsxs)(material_1.Grid, __assign({ container: true, style: { paddingTop: intervalIndex > 0 ? theme_1.default.spacing(1) : 0 } }, { children: [(0, jsx_runtime_1.jsx)(material_1.Grid, __assign({ item: true, xs: 6, sx: { textAlign: 'center' } }, { children: (0, jsx_runtime_1.jsx)(x_date_pickers_1.TimePicker, { views: ['hours', 'minutes'], minutesStep: timePickerStep !== null && timePickerStep !== void 0 ? timePickerStep : 30, disabled: !daySchedule.checked, value: interval.startTime, formatDensity: 'dense', onChange: handleIntervalChange(dayIndex, intervalIndex, 'startTime'), slotProps: {
+                                        textField: {
+                                            size: 'small',
+                                            sx: {
+                                                width: '150px',
+                                                minWidth: '100px',
+                                                padding: 0,
+                                            },
+                                        },
+                                        actionBar: {
+                                            sx: { display: 'none' },
+                                        },
+                                    } }) }), (intervalIndex + 1) * Math.random()), (0, jsx_runtime_1.jsxs)(material_1.Grid, __assign({ item: true, xs: 6, sx: { display: 'contents' } }, { children: [(0, jsx_runtime_1.jsx)(x_date_pickers_1.TimePicker, { minutesStep: timePickerStep !== null && timePickerStep !== void 0 ? timePickerStep : 30, disabled: !(interval.startTime instanceof Date), value: interval.endTime, formatDensity: 'dense', onChange: handleIntervalChange(dayIndex, intervalIndex, 'endTime'), 
+                                        //onClose={handleIntervalClose}
+                                        closeOnSelect: false, slotProps: {
+                                            textField: {
+                                                size: 'small',
+                                                sx: {
+                                                    width: '150px',
+                                                    minWidth: '100px',
+                                                    padding: 0,
+                                                },
+                                            },
+                                            actionBar: {
+                                                sx: { display: 'none' },
+                                            },
+                                        } }), intervalIndex > 0 &&
+                                        (0, jsx_runtime_1.jsx)(material_1.IconButton, __assign({ onClick: deleteInterval(dayIndex, intervalIndex), disabled: !daySchedule.checked, sx: { ml: 2 } }, { children: (0, jsx_runtime_1.jsx)(DeleteRounded_1.default, {}) }))] }), (intervalIndex + 1) * Math.random()), (0, jsx_runtime_1.jsx)(material_1.Grid, __assign({ item: true, xs: 12 }, { children: interval.error && (0, jsx_runtime_1.jsx)(material_1.FormHelperText, __assign({ error: true, sx: { mb: 1 } }, { children: interval.error })) }), (intervalIndex + 1) * Math.random())] }), intervalIndex + 1)); }) }), (dayIndex + 1) * Math.random()), (0, jsx_runtime_1.jsx)(material_1.Grid, __assign({ item: true, xs: 1, sx: { pl: 0 } }, { children: (0, jsx_runtime_1.jsx)(material_1.IconButton, __assign({ onClick: addInterval(dayIndex), disabled: !daySchedule.checked }, { children: (0, jsx_runtime_1.jsx)(AddRounded_1.default, {}) })) }), (dayIndex + 1) * Math.random()), (0, jsx_runtime_1.jsx)(material_1.Grid, { item: true, xs: 1 })] })); }) })));
+};
+exports.default = ScheduleFields;

package/dist/src/helpers/ApiHelper.d.ts

@@ -0,0 +1,20 @@
+import { APIMethod } from "./Enums";
+export declare const API_BASE_URL: string;
+export type APIResponse<T> = {
+    success: boolean;
+    data?: T;
+    error?: string;
+};
+export type APIRequest = {
+    url: string;
+    method: APIMethod;
+    body?: string | FormData;
+};
+/**
+ * ATTENTION : cela signifie que toutes les requêtes du Front seront de type "preflight"
+ * Il faut penser à configurer l'API pour autoriser les headers
+ * @param options
+ * @param dispatch
+ * @returns
+ */
+export declare const request: (options: APIRequest) => Promise<APIResponse<any>>;

package/dist/src/helpers/ApiHelper.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.request = exports.API_BASE_URL = void 0;
+var CookieUtils_1 = require("./CookieUtils");
+var Logger_1 = __importDefault(require("./Logger"));
+exports.API_BASE_URL = (_a = process.env.REACT_APP_API_URL) !== null && _a !== void 0 ? _a : 'https://localhost:8443/api';
+function handleError(error) {
+    var msg = error.message.includes('fetch') ? "Connexion impossible" : error.message;
+    return {
+        success: false,
+        error: msg
+    };
+}
+function handleResponse(response) {
+    var contentType = response.headers.get("content-type");
+    var isJson = contentType && contentType.includes("application/json");
+    var dataPromise = isJson ? response.json() : response.text();
+    return dataPromise.then(function (data) {
+        if (!response.ok) {
+            Logger_1.default.error(data);
+            var errorMsg = void 0;
+            switch (response.status) {
+                case 403:
+                    errorMsg = 'Accès non autorisé (403)';
+                    break;
+                case 404:
+                    errorMsg = 'La ressource demandée est introuvable (404)';
+                    break;
+                case 500:
+                    errorMsg = 'Une erreur interne du serveur est survenue (500)';
+                    break;
+                default:
+                    errorMsg = (typeof data === 'string') ? data : "Une erreur est survenue (".concat(response.status, ")");
+                    break;
+            }
+            return { success: false, error: errorMsg };
+        }
+        return { success: true, data: data };
+    });
+}
+/**
+ * ATTENTION : cela signifie que toutes les requêtes du Front seront de type "preflight"
+ * Il faut penser à configurer l'API pour autoriser les headers
+ * @param options
+ * @param dispatch
+ * @returns
+ */
+var request = function (options) {
+    var headers = new Headers();
+    // Si le corps est de type FormData, il ne faut pas définir le content-type manuellement (le navigateur prend le relai est injecte un boundary (délimiteur)
+    if (!(options.body instanceof FormData)) {
+        headers.append('Content-Type', 'application/json');
+    }
+    // Récupération du TOKEN depuis les cookies et intégration au header
+    if ((0, CookieUtils_1.readCookie)(CookieUtils_1.COOKIE_GARAGE_TOKEN)) {
+        headers.append('Authorization', 'Bearer ' + (0, CookieUtils_1.readCookie)(CookieUtils_1.COOKIE_GARAGE_TOKEN));
+    }
+    // On intègre les headers aux options
+    var defaults = { headers: headers };
+    options = Object.assign({}, defaults, options);
+    Logger_1.default.info(options);
+    // Appel API
+    return fetch(options.url, options)
+        .then(handleResponse)
+        .catch(function (error) {
+        Logger_1.default.error('There has been a problem with your fetch operation : ', error.message);
+        return handleError(error);
+    });
+};
+exports.request = request;

package/dist/src/helpers/CookieUtils.d.ts

@@ -0,0 +1,6 @@
+export declare const COOKIE_GARAGE_TOKEN: string;
+export declare const COOKIE_INDIVIDUAL_TOKEN: string;
+export declare const COOKIE_DEFAULT_EXPIRES: number;
+export declare const createCookie: (name: string, value: string) => void;
+export declare const deleteCookie: (name: string) => void;
+export declare const readCookie: (name: string) => string | undefined;

package/dist/src/helpers/CookieUtils.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCookie = exports.deleteCookie = exports.createCookie = exports.COOKIE_DEFAULT_EXPIRES = exports.COOKIE_INDIVIDUAL_TOKEN = exports.COOKIE_GARAGE_TOKEN = void 0;
+var js_cookie_1 = __importDefault(require("js-cookie"));
+exports.COOKIE_GARAGE_TOKEN = 'movalibGarageToken';
+exports.COOKIE_INDIVIDUAL_TOKEN = 'movalibIndividualToken';
+exports.COOKIE_DEFAULT_EXPIRES = 7;
+var createCookie = function (name, value) {
+    if (name && value) {
+        js_cookie_1.default.set(name, value, { expires: exports.COOKIE_DEFAULT_EXPIRES, sameSite: 'None', secure: true });
+    }
+};
+exports.createCookie = createCookie;
+var deleteCookie = function (name) {
+    if (name) {
+        js_cookie_1.default.remove(name);
+    }
+};
+exports.deleteCookie = deleteCookie;
+var readCookie = function (name) {
+    if (name) {
+        return js_cookie_1.default.get(name);
+    }
+};
+exports.readCookie = readCookie;

package/dist/src/helpers/Enums.d.ts

@@ -1,3 +1,10 @@
+export declare enum APIMethod {
+    GET = "GET",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    POST = "POST",
+    DELETE = "DELETE"
+}
 export declare enum DateFormatTypes {
     SHORT_FORMAT_DATE = "dd/MM/yyyy",
     LONG_FORMAT_DATETIME = "dd/MM/yyyy HH:mm:ss",
@@ -72,7 +79,7 @@ export declare enum MovaAppType {
     /**
     * Application Utilisateur (automobiliste)
     */
-    USER = "USER",
+    INDIVIDUAL = "INDIVIDUAL",
     /**
      * Application Administrateur (MovaTeam)
      */

package/dist/src/helpers/Enums.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoleType = exports.MovaAppType = exports.DocumentType = exports.DocumentState = exports.DayOfWeek = exports.EventType = exports.EventState = exports.DigitalPassportIndex = exports.Gender = exports.DateFormatTypes = void 0;
+exports.RoleType = exports.MovaAppType = exports.DocumentType = exports.DocumentState = exports.DayOfWeek = exports.EventType = exports.EventState = exports.DigitalPassportIndex = exports.Gender = exports.DateFormatTypes = exports.APIMethod = void 0;
+var APIMethod;
+(function (APIMethod) {
+    APIMethod["GET"] = "GET";
+    APIMethod["PUT"] = "PUT";
+    APIMethod["PATCH"] = "PATCH";
+    APIMethod["POST"] = "POST";
+    APIMethod["DELETE"] = "DELETE";
+})(APIMethod = exports.APIMethod || (exports.APIMethod = {}));
 var DateFormatTypes;
 (function (DateFormatTypes) {
     DateFormatTypes["SHORT_FORMAT_DATE"] = "dd/MM/yyyy";
@@ -84,7 +92,7 @@ var MovaAppType;
     /**
     * Application Utilisateur (automobiliste)
     */
-    MovaAppType["USER"] = "USER";
+    MovaAppType["INDIVIDUAL"] = "INDIVIDUAL";
     /**
      * Application Administrateur (MovaTeam)
      */

package/dist/src/helpers/Tools.d.ts

@@ -1,8 +1,12 @@
 import VehicleTire from "../models/VehicleTire";
 import { MovaFormField } from "./Types";
+import { CSSProperties } from "react";
+export declare const flexEnd: CSSProperties;
+export declare const flexCenter: CSSProperties;
+export declare const isEmpty: (data: Object) => boolean;
 export declare const formatFrenchVehiclePlate: (input: string | undefined) => string;
-export declare function formatVehicleTire(vehicleTire: VehicleTire): string;
-export declare function formatVehicleTireStr(input: string): string;
+export declare const formatVehicleTire: (vehicleTire: VehicleTire) => string;
+export declare const formatVehicleTireStr: (input: string) => string;
 /**
  * Valide un champ de formulaire en utilisant une fonction de validation personnalisée.
  *

package/dist/src/helpers/Tools.js

@@ -1,6 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateField = exports.formatVehicleTireStr = exports.formatVehicleTire = exports.formatFrenchVehiclePlate = void 0;
+exports.validateField = exports.formatVehicleTireStr = exports.formatVehicleTire = exports.formatFrenchVehiclePlate = exports.isEmpty = exports.flexCenter = exports.flexEnd = void 0;
+exports.flexEnd = {
+    display: 'flex',
+    justifyContent: 'end',
+    alignItems: 'center'
+};
+exports.flexCenter = {
+    display: 'flex',
+    justifyContent: 'center',
+    alignItems: 'center'
+};
+var isEmpty = function (data) {
+    return Object.keys(data).length === 0;
+};
+exports.isEmpty = isEmpty;
 var formatFrenchVehiclePlate = function (input) {
     if (input) {
         // Supprimer tous les caractères non alphanumériques
@@ -17,15 +31,15 @@ var formatFrenchVehiclePlate = function (input) {
     return "";
 };
 exports.formatFrenchVehiclePlate = formatFrenchVehiclePlate;
-function formatVehicleTire(vehicleTire) {
+var formatVehicleTire = function (vehicleTire) {
     if (vehicleTire) {
         var concatened = "".concat(vehicleTire.width).concat(vehicleTire.height).concat(vehicleTire.diameter).concat(vehicleTire.speedIndex);
-        return formatVehicleTireStr(concatened);
+        return (0, exports.formatVehicleTireStr)(concatened);
     }
     return '';
-}
+};
 exports.formatVehicleTire = formatVehicleTire;
-function formatVehicleTireStr(input) {
+var formatVehicleTireStr = function (input) {
     var formatted = input.toUpperCase().replace(/[^0-9A-QS-Za-qs-z]/g, '').slice(0, 10);
     if (formatted.length >= 3) {
         formatted = "".concat(formatted.substring(0, 3), " / ").concat(formatted.substring(3));
@@ -41,9 +55,8 @@ function formatVehicleTireStr(input) {
     }
     console.log(formatted);
     return formatted;
-}
+};
 exports.formatVehicleTireStr = formatVehicleTireStr;
-;
 /**
  * Valide un champ de formulaire en utilisant une fonction de validation personnalisée.
  *

package/dist/src/services/AuthenticationService.d.ts

@@ -0,0 +1,6 @@
+import { APIResponse } from "../helpers/ApiHelper";
+import { MovaAppType } from "../helpers/Enums";
+import User from "../models/User";
+export default class AuthenticationService {
+    static login(appType: MovaAppType, email: string, password: string): Promise<APIResponse<User>>;
+}

package/dist/src/services/AuthenticationService.js

@@ -0,0 +1,106 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var ApiHelper_1 = require("../helpers/ApiHelper");
+var CookieUtils_1 = require("../helpers/CookieUtils");
+var Enums_1 = require("../helpers/Enums");
+var Logger_1 = __importDefault(require("../helpers/Logger"));
+var UserService_1 = __importDefault(require("./UserService"));
+var AuthenticationService = /** @class */ (function () {
+    function AuthenticationService() {
+    }
+    AuthenticationService.login = function (appType, email, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, tokenCookie, tokenResponse, userResponse, errorMsg, error_1, errorMessage;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 5, , 6]);
+                        url = '';
+                        tokenCookie = '';
+                        Logger_1.default.info(ApiHelper_1.API_BASE_URL);
+                        switch (appType) {
+                            case Enums_1.MovaAppType.GARAGE:
+                                url = "".concat(ApiHelper_1.API_BASE_URL, "/garage/login");
+                                tokenCookie = CookieUtils_1.COOKIE_GARAGE_TOKEN;
+                                break;
+                            case Enums_1.MovaAppType.INDIVIDUAL:
+                                url = "".concat(ApiHelper_1.API_BASE_URL, "/login");
+                                tokenCookie = CookieUtils_1.COOKIE_INDIVIDUAL_TOKEN;
+                                break;
+                        }
+                        return [4 /*yield*/, (0, ApiHelper_1.request)({
+                                url: url,
+                                method: Enums_1.APIMethod.POST,
+                                body: JSON.stringify({
+                                    email: email,
+                                    password: password
+                                })
+                            })];
+                    case 1:
+                        tokenResponse = _a.sent();
+                        if (!tokenResponse.success) return [3 /*break*/, 3];
+                        Logger_1.default.info(tokenResponse);
+                        (0, CookieUtils_1.createCookie)(tokenCookie, tokenResponse.data.accessToken);
+                        return [4 /*yield*/, UserService_1.default.getCurrentUser()];
+                    case 2:
+                        userResponse = _a.sent();
+                        if (!userResponse || !userResponse.success) {
+                            errorMsg = 'Erreur au chargement de votre profil';
+                            Logger_1.default.error(errorMsg);
+                            return [2 /*return*/, { success: false, error: errorMsg }];
+                        }
+                        return [2 /*return*/, { success: true, data: userResponse.data }];
+                    case 3: return [2 /*return*/, tokenResponse];
+                    case 4: return [3 /*break*/, 6];
+                    case 5:
+                        error_1 = _a.sent();
+                        Logger_1.default.error('Error occurred during login:', error_1);
+                        errorMessage = error_1 instanceof Error ? error_1.message : 'Erreur inconnue';
+                        return [2 /*return*/, { success: false, error: errorMessage }];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return AuthenticationService;
+}());
+exports.default = AuthenticationService;

package/dist/src/services/GarageService.d.ts

@@ -0,0 +1,5 @@
+import { APIResponse } from "../helpers/ApiHelper";
+import Garage from "../models/Garage";
+export default class GarageService {
+    static getAdministratedGarages(): Promise<APIResponse<Garage[]>>;
+}

package/dist/src/services/GarageService.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ApiHelper_1 = require("../helpers/ApiHelper");
+var Enums_1 = require("../helpers/Enums");
+var GarageService = /** @class */ (function () {
+    function GarageService() {
+    }
+    GarageService.getAdministratedGarages = function () {
+        return (0, ApiHelper_1.request)({
+            url: "".concat(ApiHelper_1.API_BASE_URL, "/user/garages"),
+            method: Enums_1.APIMethod.GET,
+        });
+    };
+    return GarageService;
+}());
+exports.default = GarageService;

package/dist/src/services/UserService.d.ts

@@ -0,0 +1,10 @@
+import { APIResponse } from "../helpers/ApiHelper";
+import User from "../models/User";
+export default class UserService {
+    /**
+     * @param email
+     * @param password
+     * @returns
+     */
+    static getCurrentUser(): Promise<APIResponse<User>>;
+}