@doctocar/tooling 0.3.1-11 → 0.3.1-12

package/dist/firebase/firestore/utils/company/index.js

@@ -1,17 +0,0 @@
-"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("./isIndividualCompany.util"), exports);

package/dist/firebase/firestore/utils/company/isIndividualCompany.util.d.ts

@@ -1,2 +0,0 @@
-import type { ProfessionalCompanyDetails } from "../../types";
-export declare function isIndividualCompany(companyDetails: ProfessionalCompanyDetails): boolean;

package/dist/firebase/firestore/utils/company/isIndividualCompany.util.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIndividualCompany = isIndividualCompany;
-const enums_1 = require("../../../../enums");
-function isIndividualCompany(companyDetails) {
-    switch (companyDetails.registrationCountry) {
-        case enums_1.SupportedCountryIsoCodes.FRANCE: {
-            const registration = companyDetails.registration[enums_1.SupportedCountryIsoCodes.FRANCE];
-            if (!registration)
-                return false;
-            return (registration.legalForm ===
-                enums_1.SupportedFrenchCompanyLegalForms.ENTREPRISE_INDIVIDUELLE ||
-                registration.legalForm ===
-                    enums_1.SupportedFrenchCompanyLegalForms.MICRO_ENTREPRENEUR);
-        }
-        default:
-            return false;
-    }
-}

package/dist/firebase/firestore/utils/dataValidators/company/__tests__/isCompanyVatValid.util.test.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/company/__tests__/isCompanyVatValid.util.test.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const enums_1 = require("../../../../enums");
-const isCompanyVatValid_util_1 = require("../isCompanyVatValid.util");
-describe("isCompanyVatValid", () => {
-    let companyVatDetails;
-    it("should return true for valid VAT details", () => {
-        companyVatDetails = {
-            isVATExempt: false,
-            vatNumber: "123456789",
-            vatNumberVerificationStatus: enums_1.VatVerificationStatus.VERIFIED,
-        };
-        expect((0, isCompanyVatValid_util_1.isCompanyVatValid)(companyVatDetails)).toBe(true);
-    });
-    it("should return false for invalid VAT details", () => {
-        companyVatDetails = {
-            isVATExempt: false,
-            vatNumber: "",
-            vatNumberVerificationStatus: enums_1.VatVerificationStatus.PENDING,
-        };
-        expect((0, isCompanyVatValid_util_1.isCompanyVatValid)(companyVatDetails)).toBe(false);
-    });
-    it("should return true for VAT exempt companies", () => {
-        companyVatDetails = {
-            isVATExempt: true,
-            vatNumber: "",
-        };
-        expect((0, isCompanyVatValid_util_1.isCompanyVatValid)(companyVatDetails)).toBe(true);
-    });
-});

package/dist/firebase/firestore/utils/dataValidators/company/__tests__/isLegalAddressValid.util.test.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/company/__tests__/isLegalAddressValid.util.test.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const enums_1 = require("../../../../../../enums");
-const isLegalAddressValid_util_1 = require("../isLegalAddressValid.util");
-describe("isLegalAddressValid", () => {
-    it("should return true for a valid legal address", () => {
-        const legalAddress = {
-            line1: "123 Main St",
-            postalCode: "12345",
-            city: "Test City",
-            country: enums_1.SupportedCountryIsoCodes.FRANCE,
-        };
-        expect((0, isLegalAddressValid_util_1.isLegalAddressValid)(legalAddress)).toBe(true);
-    });
-    it("should return false for an invalid country code", () => {
-        const legalAddress = {
-            line1: "123 Main St",
-            postalCode: "12345",
-            city: "Test City",
-            country: "XX",
-        };
-        expect((0, isLegalAddressValid_util_1.isLegalAddressValid)(legalAddress)).toBe(false);
-    });
-});

package/dist/firebase/firestore/utils/dataValidators/company/isCompanyVatValid.util.d.ts

@@ -1,2 +0,0 @@
-import type { CompanyVATDetails } from "../../../types";
-export declare function isCompanyVatValid(companyVatDetails: CompanyVATDetails): boolean;

package/dist/firebase/firestore/utils/dataValidators/company/isCompanyVatValid.util.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCompanyVatValid = isCompanyVatValid;
-const enums_1 = require("../../../enums");
-function isCompanyVatValid(companyVatDetails) {
-    return (companyVatDetails.isVATExempt ||
-        (Boolean(companyVatDetails.vatNumber) &&
-            companyVatDetails.vatNumberVerificationStatus ===
-                enums_1.VatVerificationStatus.VERIFIED));
-}

package/dist/firebase/firestore/utils/dataValidators/company/isLegalAddressValid.util.d.ts

@@ -1,2 +0,0 @@
-import type { LegalAddress } from "../../../types";
-export declare function isLegalAddressValid(legalAddress: LegalAddress): boolean;

package/dist/firebase/firestore/utils/dataValidators/company/isLegalAddressValid.util.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isLegalAddressValid = isLegalAddressValid;
-const enums_1 = require("../../../../../enums");
-function isLegalAddressValid(legalAddress) {
-    return Object.values(enums_1.SupportedCountryIsoCodes).includes(legalAddress.country);
-}

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidProfessionalService.test.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidProfessionalService.test.js

@@ -1,177 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const enums_1 = require("../../../../../../enums");
-const errors_1 = require("../../../../../../errors");
-const enums_2 = require("../../../../enums");
-const stubs_1 = require("../../../stubs");
-const isValidProfessionalService_1 = require("../isValidProfessionalService");
-const isValidServicePricingAndDurationForVehicle_1 = require("../isValidServicePricingAndDurationForVehicle");
-jest.mock("../isValidVehicleForProfessionalService");
-jest.mock("../isValidServicePricingAndDurationForVehicle");
-describe("isValidProfessionalService", () => {
-    let defaultProps;
-    let isValidServicePricingAndDurationForVehicleMock;
-    let isValidServicePricingAndDurationForVehicleReturnValue;
-    beforeEach(() => {
-        defaultProps = {
-            professionalService: {
-                isActive: true,
-                type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
-                pricingAndDurationByVehicleType: {
-                    [enums_2.VehicleTypes.SEDAN]: {
-                        isActive: true,
-                        type: enums_2.VehicleTypes.SEDAN,
-                        pricePreTaxInCents: 2000,
-                        currency: enums_1.SupportedIsoCurrency.EUR,
-                        durationInMinutes: 30,
-                    },
-                },
-            },
-            countryProfessionalServicePublicConfig: (0, stubs_1.countryServicesPublicConfigStub)({
-                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)({}),
-            }),
-        };
-        isValidServicePricingAndDurationForVehicleMock =
-            isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle;
-        isValidServicePricingAndDurationForVehicleReturnValue = true;
-        isValidServicePricingAndDurationForVehicleMock.mockImplementation(() => {
-            return isValidServicePricingAndDurationForVehicleReturnValue;
-        });
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    it("should not throw if is a valid service with empty pricing and empty subservice", async () => {
-        await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).resolves.not.toThrow();
-    });
-    describe("Active", () => {
-        it("should throw if the active field is not a boolean", async () => {
-            defaultProps.professionalService.isActive = "yes";
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Professional service is active is required and must be a boolean", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_IS_ACTIVE));
-            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
-        });
-        it("should throw if the active field is not provided", async () => {
-            defaultProps.professionalService.isActive = undefined;
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Professional service is active is required and must be a boolean", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_IS_ACTIVE));
-            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
-        });
-    });
-    describe("Service type", () => {
-        it("should throw if the service type is not a valid ServicesTypes", async () => {
-            defaultProps.professionalService.type = "INVALID_TYPE";
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
-            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
-        });
-        it("should throw if the type is not provided", async () => {
-            defaultProps.professionalService.type = undefined;
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
-            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
-        });
-    });
-    describe("Professional service public config", () => {
-        it("should throw if the professional service public config is not defined for the professional service type", async () => {
-            defaultProps.countryProfessionalServicePublicConfig = {};
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Professional service public config is not defined for the professional service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_TYPE));
-            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
-        });
-    });
-    describe("Price and duration", () => {
-        it("should not throw if isValidServicePricingAndDurationForVehicle return true", async () => {
-            isValidServicePricingAndDurationForVehicleReturnValue = true;
-            isValidServicePricingAndDurationForVehicleMock.mockReturnValue(isValidServicePricingAndDurationForVehicleReturnValue);
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).resolves.not.toThrow();
-            expect(isValidServicePricingAndDurationForVehicleMock).toHaveBeenCalledTimes(1);
-            expect(isValidServicePricingAndDurationForVehicleMock).toHaveBeenCalledWith({
-                professionalServicePublicConfig: defaultProps.countryProfessionalServicePublicConfig[defaultProps.professionalService.type],
-                servicePricingAndDuration: defaultProps.professionalService.pricingAndDurationByVehicleType[enums_2.VehicleTypes.SEDAN],
-            });
-        });
-        it("Should throw if isValidServicePricingAndDurationForVehicle return false", async () => {
-            isValidServicePricingAndDurationForVehicleReturnValue = false;
-            isValidServicePricingAndDurationForVehicleMock.mockReturnValue(isValidServicePricingAndDurationForVehicleReturnValue);
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
-        });
-    });
-    describe("parentsServices", () => {
-        it("Should throw if a service does not have the parents services indicated in the config", async () => {
-            defaultProps.professionalService = {
-                isActive: true,
-                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
-                parentsServices: [],
-                pricingAndDurationByVehicleType: {},
-            };
-            defaultProps.countryProfessionalServicePublicConfig =
-                (0, stubs_1.countryServicesPublicConfigStub)({
-                    [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
-                        parentsServices: [
-                            enums_2.ServicesTypes.INTERIOR_CLEANING,
-                            enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
-                        ],
-                    }),
-                });
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
-        });
-        it("Should not throw if a valid service have the parents services indicated in the config", async () => {
-            defaultProps.professionalService = {
-                isActive: true,
-                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
-                parentsServices: [
-                    enums_2.ServicesTypes.INTERIOR_CLEANING,
-                    enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
-                ],
-                pricingAndDurationByVehicleType: {},
-            };
-            defaultProps.countryProfessionalServicePublicConfig =
-                (0, stubs_1.countryServicesPublicConfigStub)({
-                    [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
-                        parentsServices: [
-                            enums_2.ServicesTypes.INTERIOR_CLEANING,
-                            enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
-                        ],
-                    }),
-                });
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).resolves.not.toThrow();
-        });
-        it("Should throw if a valid service have the parents services indicated in the config but miss one", async () => {
-            defaultProps.professionalService = {
-                isActive: true,
-                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
-                parentsServices: [enums_2.ServicesTypes.INTERIOR_CLEANING],
-                pricingAndDurationByVehicleType: {},
-            };
-            defaultProps.countryProfessionalServicePublicConfig =
-                (0, stubs_1.countryServicesPublicConfigStub)({
-                    [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
-                        parentsServices: [
-                            enums_2.ServicesTypes.INTERIOR_CLEANING,
-                            enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
-                        ],
-                    }),
-                });
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
-        });
-        it("Should throw if a valid service have the parents services indicated in the config but have one more", async () => {
-            defaultProps.professionalService = {
-                isActive: true,
-                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
-                parentsServices: [
-                    enums_2.ServicesTypes.INTERIOR_CLEANING,
-                    enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
-                    enums_2.ServicesTypes.EXTERIOR_CLEANING,
-                ],
-                pricingAndDurationByVehicleType: {},
-            };
-            defaultProps.countryProfessionalServicePublicConfig =
-                (0, stubs_1.countryServicesPublicConfigStub)({
-                    [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
-                        parentsServices: [
-                            enums_2.ServicesTypes.INTERIOR_CLEANING,
-                            enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
-                        ],
-                    }),
-                });
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
-        });
-    });
-});

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidProfessionalServicePricingAndDurationForVehicle.test.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidProfessionalServicePricingAndDurationForVehicle.test.js

@@ -1,129 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const enums_1 = require("../../../../../../enums");
-const constants_1 = require("../../../../constants");
-const enums_2 = require("../../../../enums");
-const stubs_1 = require("../../../stubs");
-const isValidProfessionalServicePricingAndDurationForVehicle_1 = require("../isValidProfessionalServicePricingAndDurationForVehicle");
-describe("isValidProfessionalServicePricingAndDurationForVehicle", () => {
-    let defaultProps;
-    let minimumPriceInCents;
-    let maximumPriceInCents;
-    let durationInMinutes;
-    beforeEach(() => {
-        minimumPriceInCents = constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
-        maximumPriceInCents =
-            constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS * 10;
-        durationInMinutes =
-            constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
-        defaultProps = {
-            professionalServicePublicConfig: (0, stubs_1.firestoreServicesPublicConfigStub)({
-                byVehicleType: {
-                    [enums_2.VehicleTypes.CITY_CAR]: {
-                        durationInMinutes: durationInMinutes,
-                        minimumPriceInCents: minimumPriceInCents,
-                        maximumPriceInCents: maximumPriceInCents,
-                        recommendedPriceInCents: maximumPriceInCents,
-                    },
-                    [enums_2.VehicleTypes.SUV]: {
-                        durationInMinutes: durationInMinutes,
-                        minimumPriceInCents: minimumPriceInCents,
-                        maximumPriceInCents: maximumPriceInCents,
-                        recommendedPriceInCents: maximumPriceInCents,
-                    },
-                    [enums_2.VehicleTypes.MOTORCYCLE]: {
-                        durationInMinutes: durationInMinutes,
-                        minimumPriceInCents: minimumPriceInCents,
-                        maximumPriceInCents: maximumPriceInCents,
-                        recommendedPriceInCents: maximumPriceInCents,
-                    },
-                    [enums_2.VehicleTypes.SEDAN]: {
-                        durationInMinutes: durationInMinutes,
-                        minimumPriceInCents: minimumPriceInCents,
-                        maximumPriceInCents: maximumPriceInCents,
-                        recommendedPriceInCents: maximumPriceInCents,
-                    },
-                    [enums_2.VehicleTypes.PICKUP_TRUCK]: {
-                        durationInMinutes: durationInMinutes,
-                        minimumPriceInCents: minimumPriceInCents,
-                        maximumPriceInCents: maximumPriceInCents,
-                        recommendedPriceInCents: maximumPriceInCents,
-                    },
-                    [enums_2.VehicleTypes.VAN]: {
-                        durationInMinutes: durationInMinutes,
-                        minimumPriceInCents: minimumPriceInCents,
-                        maximumPriceInCents: maximumPriceInCents,
-                        recommendedPriceInCents: maximumPriceInCents,
-                    },
-                },
-                allowedVehicles: [enums_2.VehicleTypes.CITY_CAR],
-            }),
-            servicePricingAndDuration: {
-                isActive: true,
-                type: enums_2.VehicleTypes.CITY_CAR,
-                pricePreTaxInCents: minimumPriceInCents,
-                currency: enums_1.SupportedIsoCurrency.EUR,
-                durationInMinutes: durationInMinutes,
-            },
-        };
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    it("should return true if pricing is valid for service", () => {
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(true);
-    });
-    it("Should return false if active is not a boolean", () => {
-        defaultProps.servicePricingAndDuration.isActive = "Not a boolean";
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if pricePreTaxInCents is not a number", () => {
-        defaultProps.servicePricingAndDuration.pricePreTaxInCents =
-            "Not a number";
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if pricePreTaxInCents is less than the service minimum", () => {
-        defaultProps.servicePricingAndDuration.pricePreTaxInCents =
-            minimumPriceInCents -
-                constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if pricePreTaxInCents is more than PROFESSIONAL_SERVICE_MAXIMUM_PRICE_IN_CENTS", () => {
-        defaultProps.servicePricingAndDuration.pricePreTaxInCents =
-            maximumPriceInCents +
-                constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if pricePreTaxInCents is not a multiple of PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS", () => {
-        defaultProps.servicePricingAndDuration.pricePreTaxInCents =
-            maximumPriceInCents - 1;
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if SupportedIsoCurrency is not a valid currency", () => {
-        defaultProps.servicePricingAndDuration.currency =
-            "Not a valid currency";
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if durationInMinutes is not a number", () => {
-        defaultProps.servicePricingAndDuration.durationInMinutes =
-            "Not a number";
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if durationInMinutes is less than the duration for the service", () => {
-        defaultProps.servicePricingAndDuration.durationInMinutes =
-            durationInMinutes -
-                constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if durationInMinutes is more than the duration for the service", () => {
-        defaultProps.servicePricingAndDuration.durationInMinutes =
-            durationInMinutes +
-                constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if the type is not a valid vehicle type", () => {
-        defaultProps.servicePricingAndDuration.type = "Not a vehicle type";
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-});

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidProfessionalServiceType.test.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidProfessionalServiceType.test.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const enums_1 = require("../../../../enums");
-const isValidProfessionalServiceType_1 = require("../isValidProfessionalServiceType");
-describe("isValidProfessionalServiceType", () => {
-    describe.each(Object.values(enums_1.ServicesTypes))("when the service type is %p", (serviceType) => {
-        it("should return true", () => {
-            expect((0, isValidProfessionalServiceType_1.isValidProfessionalServiceType)(serviceType)).toBe(true);
-        });
-    });
-    it("should return false when the service type is unknown", () => {
-        expect((0, isValidProfessionalServiceType_1.isValidProfessionalServiceType)("UNKNOWN_SERVICE_TYPE")).toBe(false);
-    });
-});

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidServicePricingAndDurationForVehicle.test.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidServicePricingAndDurationForVehicle.test.js

@@ -1,136 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const enums_1 = require("../../../../../../enums");
-const constants_1 = require("../../../../constants");
-const enums_2 = require("../../../../enums");
-const stubs_1 = require("../../../stubs");
-const isValidServicePricingAndDurationForVehicle_1 = require("../isValidServicePricingAndDurationForVehicle");
-describe("isValidServicePricingAndDurationForVehicle", () => {
-    let defaultProps;
-    let minimumPriceInCents;
-    let maximumPriceInCents;
-    let durationInMinutes;
-    beforeEach(() => {
-        minimumPriceInCents = constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
-        maximumPriceInCents =
-            constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS * 10;
-        durationInMinutes =
-            constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
-        defaultProps = {
-            servicePublicConfig: (0, stubs_1.firestoreServicesPublicConfigStub)({
-                byVehicleType: {
-                    [enums_2.VehicleTypes.CITY_CAR]: {
-                        durationInMinutes: durationInMinutes,
-                        minimumPriceInCents: minimumPriceInCents,
-                        maximumPriceInCents: maximumPriceInCents,
-                        recommendedPriceInCents: maximumPriceInCents,
-                    },
-                    [enums_2.VehicleTypes.SUV]: {
-                        durationInMinutes: durationInMinutes,
-                        minimumPriceInCents: minimumPriceInCents,
-                        maximumPriceInCents: maximumPriceInCents,
-                        recommendedPriceInCents: maximumPriceInCents,
-                    },
-                    [enums_2.VehicleTypes.MOTORCYCLE]: {
-                        durationInMinutes: durationInMinutes,
-                        minimumPriceInCents: minimumPriceInCents,
-                        maximumPriceInCents: maximumPriceInCents,
-                        recommendedPriceInCents: maximumPriceInCents,
-                    },
-                    [enums_2.VehicleTypes.SEDAN]: {
-                        durationInMinutes: durationInMinutes,
-                        minimumPriceInCents: minimumPriceInCents,
-                        maximumPriceInCents: maximumPriceInCents,
-                        recommendedPriceInCents: maximumPriceInCents,
-                    },
-                    [enums_2.VehicleTypes.PICKUP_TRUCK]: {
-                        durationInMinutes: durationInMinutes,
-                        minimumPriceInCents: minimumPriceInCents,
-                        maximumPriceInCents: maximumPriceInCents,
-                        recommendedPriceInCents: maximumPriceInCents,
-                    },
-                    [enums_2.VehicleTypes.VAN]: {
-                        durationInMinutes: durationInMinutes,
-                        minimumPriceInCents: minimumPriceInCents,
-                        maximumPriceInCents: maximumPriceInCents,
-                        recommendedPriceInCents: maximumPriceInCents,
-                    },
-                },
-            }),
-            servicePricingAndDurationForVehicle: {
-                isActive: true,
-                type: enums_2.VehicleTypes.CITY_CAR,
-                pricePreTaxInCents: minimumPriceInCents,
-                currency: enums_1.SupportedIsoCurrency.EUR,
-                durationInMinutes: durationInMinutes,
-            },
-        };
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    it("should return true if pricing is valid for service", () => {
-        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(true);
-    });
-    it("Should return false if active is not a boolean", () => {
-        defaultProps.servicePricingAndDurationForVehicle.isActive =
-            "Not a boolean";
-        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if service public config is not defined for the vehicle type", () => {
-        defaultProps.servicePublicConfig.byVehicleType = {
-            [enums_2.VehicleTypes.CITY_CAR]: undefined,
-        };
-        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if pricePreTaxInCents is not a number", () => {
-        defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
-            "Not a number";
-        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if pricePreTaxInCents is less than the service minimum", () => {
-        defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
-            minimumPriceInCents -
-                constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
-        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if pricePreTaxInCents is more than PROFESSIONAL_SERVICE_MAXIMUM_PRICE_IN_CENTS", () => {
-        defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
-            maximumPriceInCents +
-                constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
-        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if pricePreTaxInCents is not a multiple of PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS", () => {
-        defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
-            maximumPriceInCents - 1;
-        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if SupportedIsoCurrency is not a valid currency", () => {
-        defaultProps.servicePricingAndDurationForVehicle.currency =
-            "Not a valid currency";
-        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if durationInMinutes is not a number", () => {
-        defaultProps.servicePricingAndDurationForVehicle.durationInMinutes =
-            "Not a number";
-        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if durationInMinutes is less than the duration for the service", () => {
-        defaultProps.servicePricingAndDurationForVehicle.durationInMinutes =
-            durationInMinutes -
-                constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
-        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if durationInMinutes is more than the duration for the service", () => {
-        defaultProps.servicePricingAndDurationForVehicle.durationInMinutes =
-            durationInMinutes +
-                constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
-        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-    it("Should return false if the type is not a valid vehicle type", () => {
-        defaultProps.servicePricingAndDurationForVehicle.type =
-            "Not a vehicle type";
-        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
-    });
-});

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidVehicleForProfessionalService.test.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidVehicleForProfessionalService.test.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const enums_1 = require("../../../../enums");
-const stubs_1 = require("../../../stubs");
-const isValidVehicleForProfessionalService_1 = require("../isValidVehicleForProfessionalService");
-describe("isValidVehicleForProfessionalService", () => {
-    it("should return true if is a valid vehicle for the service", () => {
-        expect((0, isValidVehicleForProfessionalService_1.isValidVehicleForProfessionalService)({
-            professionalServicePublicConfig: (0, stubs_1.firestoreServicesPublicConfigStub)({
-                allowedVehicles: [enums_1.VehicleTypes.CITY_CAR, enums_1.VehicleTypes.SEDAN],
-            }),
-            vehicleType: enums_1.VehicleTypes.CITY_CAR,
-        })).toBe(true);
-    });
-    it("should return false if is a valid vehicle but not allowed for the service", () => {
-        expect((0, isValidVehicleForProfessionalService_1.isValidVehicleForProfessionalService)({
-            professionalServicePublicConfig: (0, stubs_1.firestoreServicesPublicConfigStub)({
-                allowedVehicles: [enums_1.VehicleTypes.CITY_CAR, enums_1.VehicleTypes.SEDAN],
-            }),
-            vehicleType: enums_1.VehicleTypes.MOTORCYCLE,
-        })).toBe(false);
-    });
-    it("should return false if is an unknown vehicle", () => {
-        expect((0, isValidVehicleForProfessionalService_1.isValidVehicleForProfessionalService)({
-            professionalServicePublicConfig: (0, stubs_1.firestoreServicesPublicConfigStub)({
-                allowedVehicles: [enums_1.VehicleTypes.CITY_CAR, enums_1.VehicleTypes.SEDAN],
-            }),
-            vehicleType: "UNKNOWN_VEHICLE",
-        })).toBe(false);
-    });
-});