@doctocar/tooling 0.3.1-3 → 0.3.1-31

package/dist/firebase/firestore/utils/services/__tests__/getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow.test.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("../../../../../enums");
+const enums_2 = require("../../../enums");
+const stubs_1 = require("../../stubs");
+const getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow_1 = require("../getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow");
+const errorCases = [
+    {
+        name: "Should throw an error if the service is not offered by the service provider",
+        serviceProviderUserPublicDocument: (0, stubs_1.firestoreServiceProviderUserPublicDocumentStub)({
+            services: {
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.providerServiceStub)({
+                    isActive: true,
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                    pricingAndDurationByVehicleType: {
+                        [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            type: enums_2.VehicleTypes.SEDAN,
+                            isActive: true,
+                            pricePreTaxInCents: 2000,
+                            durationInMinutes: 30,
+                            currency: enums_1.SupportedIsoCurrency.EUR,
+                        }),
+                    },
+                }),
+            },
+        }),
+        serviceType: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+        vehicleType: enums_2.VehicleTypes.SEDAN,
+        error: new Error(`Service “${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT}” is not offered by this service provider.`),
+    },
+    {
+        name: "Should throw an error if the service is not active",
+        serviceProviderUserPublicDocument: (0, stubs_1.firestoreServiceProviderUserPublicDocumentStub)({
+            services: {
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.providerServiceStub)({
+                    isActive: false,
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                    pricingAndDurationByVehicleType: {
+                        [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            type: enums_2.VehicleTypes.SEDAN,
+                            isActive: true,
+                            pricePreTaxInCents: 2000,
+                            durationInMinutes: 30,
+                            currency: enums_1.SupportedIsoCurrency.EUR,
+                        }),
+                    },
+                }),
+            },
+        }),
+        serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+        vehicleType: enums_2.VehicleTypes.SEDAN,
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not offered by this service provider.`),
+    },
+    {
+        name: "Should throw an error if the vehicle type is not active for the service",
+        serviceProviderUserPublicDocument: (0, stubs_1.firestoreServiceProviderUserPublicDocumentStub)({
+            services: {
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.providerServiceStub)({
+                    isActive: true,
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                    pricingAndDurationByVehicleType: {
+                        [enums_2.VehicleTypes.VAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            type: enums_2.VehicleTypes.VAN,
+                            isActive: false,
+                            pricePreTaxInCents: 2500,
+                            durationInMinutes: 45,
+                            currency: enums_1.SupportedIsoCurrency.EUR,
+                        }),
+                    },
+                }),
+            },
+        }),
+        serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+        vehicleType: enums_2.VehicleTypes.VAN,
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.VAN}”.`),
+    },
+    {
+        name: "Should throw an error if the service does not have pricing and duration for the vehicle type",
+        serviceProviderUserPublicDocument: (0, stubs_1.firestoreServiceProviderUserPublicDocumentStub)({
+            services: {
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.providerServiceStub)({
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                    isActive: true,
+                    pricingAndDurationByVehicleType: {},
+                }),
+            },
+        }),
+        serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+        vehicleType: enums_2.VehicleTypes.SEDAN,
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
+    },
+    {
+        name: "Should throw an error if the service pricing and duration for the vehicle type is missing required pricePreTaxInCents fields",
+        serviceProviderUserPublicDocument: (0, stubs_1.firestoreServiceProviderUserPublicDocumentStub)({
+            services: {
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.providerServiceStub)({
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                    pricingAndDurationByVehicleType: {
+                        [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            type: enums_2.VehicleTypes.SEDAN,
+                            isActive: true,
+                            pricePreTaxInCents: undefined,
+                            durationInMinutes: 30,
+                            currency: enums_1.SupportedIsoCurrency.EUR,
+                        }),
+                    },
+                }),
+            },
+        }),
+        serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+        vehicleType: enums_2.VehicleTypes.SEDAN,
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
+    },
+    {
+        name: "Should throw an error if the service pricing and duration for the vehicle type is missing required durationInMinutes fields",
+        serviceProviderUserPublicDocument: (0, stubs_1.firestoreServiceProviderUserPublicDocumentStub)({
+            services: {
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.providerServiceStub)({
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                    pricingAndDurationByVehicleType: {
+                        [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            type: enums_2.VehicleTypes.SEDAN,
+                            isActive: true,
+                            pricePreTaxInCents: 2000,
+                            durationInMinutes: undefined,
+                            currency: enums_1.SupportedIsoCurrency.EUR,
+                        }),
+                    },
+                }),
+            },
+        }),
+        serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+        vehicleType: enums_2.VehicleTypes.SEDAN,
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
+    },
+    {
+        name: "Should throw an error if the service pricing and duration for the vehicle type is missing required currency fields",
+        serviceProviderUserPublicDocument: (0, stubs_1.firestoreServiceProviderUserPublicDocumentStub)({
+            services: {
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.providerServiceStub)({
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                    pricingAndDurationByVehicleType: {
+                        [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            type: enums_2.VehicleTypes.SEDAN,
+                            isActive: true,
+                            pricePreTaxInCents: 2000,
+                            durationInMinutes: 30,
+                            currency: undefined,
+                        }),
+                    },
+                }),
+            },
+        }),
+        serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+        vehicleType: enums_2.VehicleTypes.SEDAN,
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
+    },
+    {
+        name: "Should throw an error if the service pricing and duration for the vehicle type is missing required type fields",
+        serviceProviderUserPublicDocument: (0, stubs_1.firestoreServiceProviderUserPublicDocumentStub)({
+            services: {
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.providerServiceStub)({
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                    pricingAndDurationByVehicleType: {
+                        [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            type: undefined,
+                            isActive: true,
+                            pricePreTaxInCents: 2000,
+                            durationInMinutes: 30,
+                            currency: enums_1.SupportedIsoCurrency.EUR,
+                        }),
+                    },
+                }),
+            },
+        }),
+        serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+        vehicleType: enums_2.VehicleTypes.SEDAN,
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
+    },
+];
+describe("getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow", () => {
+    let serviceProviderUserPublicDocument;
+    beforeEach(() => {
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreServiceProviderUserPublicDocumentStub)({
+                services: {
+                    [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.providerServiceStub)({
+                        type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                        pricingAndDurationByVehicleType: {
+                            [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                type: enums_2.VehicleTypes.SEDAN,
+                                isActive: true,
+                                pricePreTaxInCents: 2000,
+                                durationInMinutes: 30,
+                                currency: enums_1.SupportedIsoCurrency.EUR,
+                            }),
+                        },
+                    }),
+                },
+            });
+    });
+    it("should return the correct pricing and duration for a valid service and vehicle type (Happy path)", () => {
+        const result = (0, getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow_1.getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow)({
+            serviceProviderUserPublicDocument,
+            serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+            vehicleType: enums_2.VehicleTypes.SEDAN,
+        });
+        expect(result).toEqual({
+            isActive: true,
+            durationInMinutes: 30,
+            pricePreTaxInCents: 2000,
+            type: enums_2.VehicleTypes.SEDAN,
+            currency: enums_1.SupportedIsoCurrency.EUR,
+        });
+    });
+    describe("error cases", () => {
+        test.each(errorCases)("should throw error if $name", async ({ serviceProviderUserPublicDocument, serviceType, vehicleType, error, }) => {
+            expect(() => (0, getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow_1.getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow)({
+                serviceProviderUserPublicDocument,
+                serviceType,
+                vehicleType,
+            })).toThrow(error);
+        });
+    });
+});

package/dist/firebase/firestore/utils/services/areAllRequestedProfessionalUserServicesActiveForVehicleType.d.ts

@@ -0,0 +1,2 @@
+import type { AreAllRequestedProfessionalUserServicesActiveForVehicleTypeArgs } from "./types";
+export declare function areAllRequestedProfessionalUserServicesActiveForVehicleType({ servicesTypes, professionalServices, vehicleType, }: AreAllRequestedProfessionalUserServicesActiveForVehicleTypeArgs): boolean;

package/dist/firebase/firestore/utils/services/areAllRequestedProfessionalUserServicesActiveForVehicleType.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areAllRequestedProfessionalUserServicesActiveForVehicleType = areAllRequestedProfessionalUserServicesActiveForVehicleType;
+function areAllRequestedProfessionalUserServicesActiveForVehicleType({ servicesTypes, professionalServices, vehicleType, }) {
+    for (const serviceType of new Set(servicesTypes)) {
+        const professionalService = professionalServices?.[serviceType];
+        if (professionalService?.isActive !== true)
+            return false;
+        const perVehicule = professionalService.pricingAndDurationByVehicleType?.[vehicleType];
+        if (perVehicule?.isActive !== true)
+            return false;
+    }
+    return true;
+}

package/dist/firebase/firestore/utils/services/computeTotalProfessionalServiceDurationInMinutesForVehicleType.d.ts

@@ -0,0 +1,2 @@
+import type { ComputeTotalProfessionalServiceDurationInMinutesForVehicleTypeArgs } from "./types";
+export declare function computeTotalProfessionalServiceDurationInMinutesForVehicleType({ servicesTypes, professionalServices, vehicleType, }: ComputeTotalProfessionalServiceDurationInMinutesForVehicleTypeArgs): number;

package/dist/firebase/firestore/utils/services/computeTotalProfessionalServiceDurationInMinutesForVehicleType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeTotalProfessionalServiceDurationInMinutesForVehicleType = computeTotalProfessionalServiceDurationInMinutesForVehicleType;
+function computeTotalProfessionalServiceDurationInMinutesForVehicleType({ servicesTypes, professionalServices, vehicleType, }) {
+    let totalServiceDurationInMinutes = 0;
+    for (const serviceType of servicesTypes) {
+        if (!professionalServices?.[serviceType]?.pricingAndDurationByVehicleType?.[vehicleType]?.durationInMinutes) {
+            throw new Error(`computeTotalProfessionalServiceDurationInMinutes: Service type ${serviceType} not found for vehicle type ${vehicleType}`);
+        }
+        else {
+            totalServiceDurationInMinutes +=
+                professionalServices[serviceType].pricingAndDurationByVehicleType[vehicleType].durationInMinutes;
+        }
+    }
+    return totalServiceDurationInMinutes;
+}

package/dist/firebase/firestore/utils/services/computeTotalServiceProviderServiceDurationInMinutesForVehicleType.d.ts

@@ -0,0 +1,2 @@
+import type { ComputeTotalServiceProviderServiceDurationInMinutesForVehicleTypeArgs } from "./types";
+export declare function computeTotalServiceProviderServiceDurationInMinutesForVehicleType({ servicesTypes, services, vehicleType, }: ComputeTotalServiceProviderServiceDurationInMinutesForVehicleTypeArgs): number;

package/dist/firebase/firestore/utils/services/computeTotalServiceProviderServiceDurationInMinutesForVehicleType.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeTotalServiceProviderServiceDurationInMinutesForVehicleType = computeTotalServiceProviderServiceDurationInMinutesForVehicleType;
+function computeTotalServiceProviderServiceDurationInMinutesForVehicleType({ servicesTypes, services, vehicleType, }) {
+    let totalServiceDurationInMinutes = 0;
+    for (const serviceType of servicesTypes) {
+        if (!services?.[serviceType]?.pricingAndDurationByVehicleType?.[vehicleType]
+            ?.durationInMinutes) {
+            throw new Error(`computeTotalServiceProviderServiceDurationInMinutes: Service type ${serviceType} not found for vehicle type ${vehicleType}`);
+        }
+        else {
+            totalServiceDurationInMinutes +=
+                services[serviceType].pricingAndDurationByVehicleType[vehicleType]
+                    .durationInMinutes;
+        }
+    }
+    return totalServiceDurationInMinutes;
+}

package/dist/firebase/firestore/utils/services/createProfessionalServiceVehicleComboKey.d.ts

@@ -0,0 +1,2 @@
+import type { ServicesTypes, VehicleTypes } from "../../enums";
+export declare function createProfessionalServiceVehicleComboKey(professionalServiceType: ServicesTypes, vehicleType: VehicleTypes): string;

package/dist/firebase/firestore/utils/services/createProfessionalServiceVehicleComboKey.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProfessionalServiceVehicleComboKey = createProfessionalServiceVehicleComboKey;
+function createProfessionalServiceVehicleComboKey(professionalServiceType, vehicleType) {
+    return `${professionalServiceType}_${vehicleType}`;
+}

package/dist/firebase/firestore/utils/services/createProfessionalServiceVehicleComboKey.util.d.ts

@@ -1,2 +1,2 @@
-import type { ProfessionalServicesTypes, VehicleTypes } from "../../enums";
-export declare function createProfessionalServiceVehicleComboKey(professionalServiceType: ProfessionalServicesTypes, vehicleType: VehicleTypes): string;
+import type { ServicesTypes, VehicleTypes } from "../../enums";
+export declare function createProfessionalServiceVehicleComboKey(professionalServiceType: ServicesTypes, vehicleType: VehicleTypes): string;

package/dist/firebase/firestore/utils/services/createServiceVehicleComboKey.d.ts

@@ -0,0 +1,2 @@
+import type { ServicesTypes, VehicleTypes } from "../../enums";
+export declare function createServiceVehicleComboKey(serviceType: ServicesTypes, vehicleType: VehicleTypes): string;

package/dist/firebase/firestore/utils/services/createServiceVehicleComboKey.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServiceVehicleComboKey = createServiceVehicleComboKey;
+function createServiceVehicleComboKey(serviceType, vehicleType) {
+    return `${serviceType}_${vehicleType}`;
+}

package/dist/firebase/firestore/utils/services/getActiveServicePricingAndDurationForVehicleOrThrow.d.ts

@@ -0,0 +1,3 @@
+import type { ServicePricingAndDurationForVehicle } from "../../types";
+import type { GetActiveServicePricingAndDurationForVehicleOrThrowParams } from "./types";
+export declare function getActiveServicePricingAndDurationForVehicleOrThrow({ professionalUserPublicDocument, serviceType, vehicleType, }: GetActiveServicePricingAndDurationForVehicleOrThrowParams): ServicePricingAndDurationForVehicle;

package/dist/firebase/firestore/utils/services/getActiveServicePricingAndDurationForVehicleOrThrow.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActiveServicePricingAndDurationForVehicleOrThrow = getActiveServicePricingAndDurationForVehicleOrThrow;
+function getActiveServicePricingAndDurationForVehicleOrThrow({ professionalUserPublicDocument, serviceType, vehicleType, }) {
+    const service = professionalUserPublicDocument.professionalServices?.[serviceType];
+    if (!service || !service.isActive) {
+        throw new Error(`Service “${serviceType}” is not offered by this professional.`);
+    }
+    const pricingAndDurationForVehicle = service.pricingAndDurationByVehicleType?.[vehicleType];
+    if (!pricingAndDurationForVehicle ||
+        !pricingAndDurationForVehicle.isActive ||
+        !pricingAndDurationForVehicle.type ||
+        !pricingAndDurationForVehicle.pricePreTaxInCents ||
+        !pricingAndDurationForVehicle.durationInMinutes ||
+        !pricingAndDurationForVehicle.currency) {
+        throw new Error(`Service “${serviceType}” is not available for vehicle type “${vehicleType}”.`);
+    }
+    return pricingAndDurationForVehicle;
+}

package/dist/firebase/firestore/utils/services/getActiveServiceProviderServicePricingAndDurationForVehicleOrThrow.d.ts

@@ -0,0 +1,3 @@
+import type { ServicePricingAndDurationForVehicle } from "../../types";
+import type { GetActiveServiceProviderServicePricingAndDurationForVehicleOrThrowParams } from "./types";
+export declare function getActiveServiceProviderServicePricingAndDurationForVehicleOrThrow({ professionalUserPublicDocument, serviceType, vehicleType, }: GetActiveServiceProviderServicePricingAndDurationForVehicleOrThrowParams): ServicePricingAndDurationForVehicle;

package/dist/firebase/firestore/utils/services/getActiveServiceProviderServicePricingAndDurationForVehicleOrThrow.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActiveServiceProviderServicePricingAndDurationForVehicleOrThrow = getActiveServiceProviderServicePricingAndDurationForVehicleOrThrow;
+function getActiveServiceProviderServicePricingAndDurationForVehicleOrThrow({ professionalUserPublicDocument, serviceType, vehicleType, }) {
+    const professionalService = professionalUserPublicDocument.professionalServices?.[serviceType];
+    if (!professionalService || !professionalService.isActive) {
+        throw new Error(`Service “${serviceType}” is not offered by this professional.`);
+    }
+    const pricingAndDurationForVehicle = professionalService.pricingAndDurationByVehicleType?.[vehicleType];
+    if (!pricingAndDurationForVehicle ||
+        !pricingAndDurationForVehicle.isActive ||
+        !pricingAndDurationForVehicle.type ||
+        !pricingAndDurationForVehicle.pricePreTaxInCents ||
+        !pricingAndDurationForVehicle.durationInMinutes ||
+        !pricingAndDurationForVehicle.currency) {
+        throw new Error(`Service “${serviceType}” is not available for vehicle type “${vehicleType}”.`);
+    }
+    return pricingAndDurationForVehicle;
+}

package/dist/firebase/firestore/utils/services/getAvailableServiceProviderServicesForVehicleType.d.ts

@@ -0,0 +1,6 @@
+import type { FirestoreServicesPublicConfig } from "../../types";
+import type { GetAvailableServiceProviderServicesForVehicleTypeParams } from "./types";
+export declare function getAvailableServiceProviderServicesForVehicleType({ countryServicesPublicConfig, professionalUserPublicDocument, vehicleType, }: GetAvailableServiceProviderServicesForVehicleTypeParams): {
+    mainServices: FirestoreServicesPublicConfig[];
+    subServices: FirestoreServicesPublicConfig[];
+};

package/dist/firebase/firestore/utils/services/getAvailableServiceProviderServicesForVehicleType.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableServiceProviderServicesForVehicleType = getAvailableServiceProviderServicesForVehicleType;
+const configs_1 = require("../configs");
+function getAvailableServiceProviderServicesForVehicleType({ countryServicesPublicConfig, professionalUserPublicDocument, vehicleType, }) {
+    const { mainServicesPublicConfig, subServicesPublicConfig } = (0, configs_1.getAvailableServicesPublicConfigForVehicleType)({
+        countryServicesPublicConfig,
+        vehicleType,
+    });
+    const filterByServiceProviderActiveServices = (servicesPublicConfig) => {
+        return servicesPublicConfig.filter((servicePublicConfig) => {
+            const professionalService = professionalUserPublicDocument.professionalServices[servicePublicConfig.type];
+            if (!professionalService)
+                return false;
+            if (!professionalService.isActive)
+                return false;
+            const pricingAndDurationForVehicle = professionalService.pricingAndDurationByVehicleType[vehicleType];
+            if (!pricingAndDurationForVehicle)
+                return false;
+            if (!pricingAndDurationForVehicle.isActive)
+                return false;
+            return true;
+        });
+    };
+    return {
+        mainServices: filterByServiceProviderActiveServices(mainServicesPublicConfig),
+        subServices: filterByServiceProviderActiveServices(subServicesPublicConfig),
+    };
+}

package/dist/firebase/firestore/utils/services/getAvailableServiceProviderServicesTypesForVehicleType.d.ts

@@ -0,0 +1,6 @@
+import type { ServicesTypes } from "../../../..";
+import type { GetAvailableServiceProviderServicesTypesForVehicleTypeParams } from "./types";
+export declare function getAvailableServiceProviderServicesTypesForVehicleType({ countryServicesPublicConfig, professionalUserPublicDocument, vehicleType, }: GetAvailableServiceProviderServicesTypesForVehicleTypeParams): {
+    mainAvailableServicesTypes: ServicesTypes[];
+    subAvailableServicesTypes: ServicesTypes[];
+};

package/dist/firebase/firestore/utils/services/getAvailableServiceProviderServicesTypesForVehicleType.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableServiceProviderServicesTypesForVehicleType = getAvailableServiceProviderServicesTypesForVehicleType;
+const configs_1 = require("../configs");
+function getAvailableServiceProviderServicesTypesForVehicleType({ countryServicesPublicConfig, professionalUserPublicDocument, vehicleType, }) {
+    const { mainServicesPublicConfigList, subServicesPublicConfigList } = (0, configs_1.getAvailableServicesPublicConfigForVehicleType)({
+        countryServicesPublicConfig,
+        vehicleType,
+    });
+    const configMainAvailableServicesTypes = mainServicesPublicConfigList.map((servicePublicConfig) => servicePublicConfig.type);
+    const configSubAvailableServicesTypes = subServicesPublicConfigList.map((servicePublicConfig) => servicePublicConfig.type);
+    const filterByServiceProviderActiveServices = (servicesTypes) => {
+        return servicesTypes.filter((serviceType) => {
+            const professionalService = professionalUserPublicDocument.professionalServices[serviceType];
+            if (!professionalService)
+                return false;
+            if (!professionalService.isActive)
+                return false;
+            const pricingAndDurationForVehicle = professionalService.pricingAndDurationByVehicleType[vehicleType];
+            if (!pricingAndDurationForVehicle)
+                return false;
+            if (!pricingAndDurationForVehicle.isActive)
+                return false;
+            return true;
+        });
+    };
+    return {
+        mainAvailableServicesTypes: filterByServiceProviderActiveServices(configMainAvailableServicesTypes),
+        subAvailableServicesTypes: filterByServiceProviderActiveServices(configSubAvailableServicesTypes),
+    };
+}

package/dist/firebase/firestore/utils/services/getBookableServiceProviderServicesForVehicleType.d.ts

@@ -0,0 +1,5 @@
+import type { GetBookableServiceProviderServicesForVehicleTypeParams } from "./types";
+export declare function getBookableServiceProviderServicesForVehicleType({ countryServicesPublicConfig, serviceProviderUserPublicDocument, vehicleType, }: GetBookableServiceProviderServicesForVehicleTypeParams): {
+    availableMainServiceProviderServices: (import("../..").ProviderService<import("../..").ServicesTypes.INTERIOR_CLEANING> | import("../..").ProviderService<import("../..").ServicesTypes.EXTERIOR_CLEANING> | import("../..").ProviderService<import("../..").ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING> | import("../..").ProviderService<import("../..").ServicesTypes.LEATHER_SEAT_SHAMPOO_AND_TREATMENT> | import("../..").ProviderService<import("../..").ServicesTypes.FABRIC_SEAT_SHAMPOO> | import("../..").ProviderService<import("../..").ServicesTypes.CARPET_SHAMPOO> | import("../..").ProviderService<import("../..").ServicesTypes.CEILING_CLEANING> | import("../..").ProviderService<import("../..").ServicesTypes.ANIMAL_HAIR_TREATMENT>)[];
+    availableSubServiceProviderServices: (import("../..").ProviderService<import("../..").ServicesTypes.INTERIOR_CLEANING> | import("../..").ProviderService<import("../..").ServicesTypes.EXTERIOR_CLEANING> | import("../..").ProviderService<import("../..").ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING> | import("../..").ProviderService<import("../..").ServicesTypes.LEATHER_SEAT_SHAMPOO_AND_TREATMENT> | import("../..").ProviderService<import("../..").ServicesTypes.FABRIC_SEAT_SHAMPOO> | import("../..").ProviderService<import("../..").ServicesTypes.CARPET_SHAMPOO> | import("../..").ProviderService<import("../..").ServicesTypes.CEILING_CLEANING> | import("../..").ProviderService<import("../..").ServicesTypes.ANIMAL_HAIR_TREATMENT>)[];
+};

package/dist/firebase/firestore/utils/services/getBookableServiceProviderServicesForVehicleType.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBookableServiceProviderServicesForVehicleType = getBookableServiceProviderServicesForVehicleType;
+const configs_1 = require("../configs");
+function getBookableServiceProviderServicesForVehicleType({ countryServicesPublicConfig, serviceProviderUserPublicDocument, vehicleType, }) {
+    const { availableMainServicesPublicConfigList, availableSubServicesPublicConfigList, } = (0, configs_1.getAvailableServicesPublicConfigForVehicleType)({
+        countryServicesPublicConfig,
+        vehicleType,
+    });
+    const configMainAvailableServicesTypes = availableMainServicesPublicConfigList.map((servicePublicConfig) => servicePublicConfig.type);
+    const configSubAvailableServicesTypes = availableSubServicesPublicConfigList.map((servicePublicConfig) => servicePublicConfig.type);
+    return {
+        availableMainServiceProviderServices: configMainAvailableServicesTypes.flatMap((serviceType) => {
+            const providerService = serviceProviderUserPublicDocument.services[serviceType];
+            if (!providerService || !providerService.isActive)
+                return [];
+            const pricingAndDurationForVehicle = providerService.pricingAndDurationByVehicleType[vehicleType];
+            if (!pricingAndDurationForVehicle?.isActive)
+                return [];
+            return [providerService];
+        }),
+        availableSubServiceProviderServices: configSubAvailableServicesTypes.flatMap((serviceType) => {
+            const providerService = serviceProviderUserPublicDocument.services[serviceType];
+            if (!providerService || !providerService.isActive)
+                return [];
+            const pricingAndDurationForVehicle = providerService.pricingAndDurationByVehicleType[vehicleType];
+            if (!pricingAndDurationForVehicle?.isActive)
+                return [];
+            return [providerService];
+        }),
+    };
+}

package/dist/firebase/firestore/utils/services/getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow.d.ts

@@ -0,0 +1,3 @@
+import type { ServicePricingAndDurationForVehicle } from "../../types";
+import type { GetServiceProviderActiveServicePricingAndDurationForVehicleOrThrowParams } from "./types";
+export declare function getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow({ serviceProviderUserPublicDocument, serviceType, vehicleType, }: GetServiceProviderActiveServicePricingAndDurationForVehicleOrThrowParams): ServicePricingAndDurationForVehicle;

package/dist/firebase/firestore/utils/services/getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow = getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow;
+function getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow({ serviceProviderUserPublicDocument, serviceType, vehicleType, }) {
+    const service = serviceProviderUserPublicDocument.services?.[serviceType];
+    if (!service || !service.isActive) {
+        throw new Error(`Service “${serviceType}” is not offered by this service provider.`);
+    }
+    const pricingAndDurationForVehicle = service.pricingAndDurationByVehicleType?.[vehicleType];
+    if (!pricingAndDurationForVehicle ||
+        !pricingAndDurationForVehicle.isActive ||
+        !pricingAndDurationForVehicle.type ||
+        !pricingAndDurationForVehicle.pricePreTaxInCents ||
+        !pricingAndDurationForVehicle.durationInMinutes ||
+        !pricingAndDurationForVehicle.currency) {
+        throw new Error(`Service “${serviceType}” is not available for vehicle type “${vehicleType}”.`);
+    }
+    return pricingAndDurationForVehicle;
+}

package/dist/firebase/firestore/utils/services/index.d.ts

@@ -1,5 +1,5 @@
-export * from "./createProfessionalServiceVehicleComboKey.util";
-export * from "./getActiveProfessionalServicePricingAndDurationForVehicleOrThrow";
+export * from "./createServiceVehicleComboKey";
+export * from "./getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow";
 export * from "./types";
-export * from "./computeTotalProfessionalServiceDurationInMinutesForVehicleType.util";
-export * from "./areAllRequestedProfessionalUserServicesActiveForVehicleType.util";
+export * from "./computeTotalServiceProviderServiceDurationInMinutesForVehicleType";
+export * from "./getBookableServiceProviderServicesForVehicleType";

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

@@ -14,8 +14,8 @@ 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("./createProfessionalServiceVehicleComboKey.util"), exports);
-__exportStar(require("./getActiveProfessionalServicePricingAndDurationForVehicleOrThrow"), exports);
+__exportStar(require("./createServiceVehicleComboKey"), exports);
+__exportStar(require("./getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow"), exports);
 __exportStar(require("./types"), exports);
-__exportStar(require("./computeTotalProfessionalServiceDurationInMinutesForVehicleType.util"), exports);
-__exportStar(require("./areAllRequestedProfessionalUserServicesActiveForVehicleType.util"), exports);
+__exportStar(require("./computeTotalServiceProviderServiceDurationInMinutesForVehicleType"), exports);
+__exportStar(require("./getBookableServiceProviderServicesForVehicleType"), exports);

package/dist/firebase/firestore/utils/services/types/AreAllRequestedProfessionalUserServicesActiveForVehicleTypeArgs.type..d.ts

@@ -1,7 +1,7 @@
-import type { ProfessionalServicesTypes, VehicleTypes } from "../../../enums";
+import type { ServicesTypes, VehicleTypes } from "../../../enums";
 import type { FirestoreProfessionalUserPublicDocument } from "../../../types";
 export type AreAllRequestedProfessionalUserServicesActiveForVehicleTypeArgs = {
     professionalServices: FirestoreProfessionalUserPublicDocument["professionalServices"];
-    servicesTypes: ProfessionalServicesTypes[];
+    servicesTypes: ServicesTypes[];
     vehicleType: VehicleTypes;
 };

package/dist/firebase/firestore/utils/services/types/ComputeTotalProfessionalServiceDurationInMinutesForVehicleTypeArgs.type.d.ts

@@ -1,7 +1,7 @@
-import type { ProfessionalServicesTypes, VehicleTypes } from "../../../enums";
+import type { ServicesTypes, VehicleTypes } from "../../../enums";
 import type { FirestoreProfessionalUserPublicDocument } from "../../../types";
 export type ComputeTotalProfessionalServiceDurationInMinutesForVehicleTypeArgs = {
     professionalServices: FirestoreProfessionalUserPublicDocument["professionalServices"];
-    servicesTypes: ProfessionalServicesTypes[];
+    servicesTypes: ServicesTypes[];
     vehicleType: VehicleTypes;
 };

package/dist/firebase/firestore/utils/services/types/ComputeTotalServiceProviderServiceDurationInMinutesForVehicleTypeArgs.type.d.ts

@@ -0,0 +1,7 @@
+import type { ServicesTypes, VehicleTypes } from "../../../enums";
+import type { FirestoreServiceProviderUserPublicDocument } from "../../../types";
+export type ComputeTotalServiceProviderServiceDurationInMinutesForVehicleTypeArgs = {
+    services: FirestoreServiceProviderUserPublicDocument["services"];
+    servicesTypes: ServicesTypes[];
+    vehicleType: VehicleTypes;
+};

package/dist/firebase/firestore/utils/services/types/ComputeTotalServiceProviderServiceDurationInMinutesForVehicleTypeArgs.type.js

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

package/dist/firebase/firestore/utils/services/types/GetActiveProfessionalServicePricingAndDurationForVehicleOrThrowParams.type.d.ts

@@ -1,7 +1,7 @@
-import type { ProfessionalServicesTypes, VehicleTypes } from "../../../enums";
+import type { ServicesTypes, VehicleTypes } from "../../../enums";
 import type { FirestoreProfessionalUserPublicDocument } from "../../../types";
 export type GetActiveProfessionalServicePricingAndDurationForVehicleOrThrowParams = {
     professionalUserPublicDocument: FirestoreProfessionalUserPublicDocument;
-    professionalServiceType: ProfessionalServicesTypes;
+    professionalServiceType: ServicesTypes;
     vehicleType: VehicleTypes;
 };

package/dist/firebase/firestore/utils/services/types/GetActiveServicePricingAndDurationForVehicleOrThrowParams.type.d.ts

@@ -0,0 +1,7 @@
+import type { ServicesTypes, VehicleTypes } from "../../../enums";
+import type { FirestoreProfessionalUserPublicDocument } from "../../../types";
+export type GetActiveServicePricingAndDurationForVehicleOrThrowParams = {
+    professionalUserPublicDocument: FirestoreProfessionalUserPublicDocument;
+    serviceType: ServicesTypes;
+    vehicleType: VehicleTypes;
+};

package/dist/firebase/firestore/utils/services/types/GetActiveServicePricingAndDurationForVehicleOrThrowParams.type.js

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

package/dist/firebase/firestore/utils/services/types/GetActiveServiceProviderServicePricingAndDurationForVehicleOrThrowParams.type.d.ts

@@ -0,0 +1,7 @@
+import type { ServicesTypes, VehicleTypes } from "../../../enums";
+import type { FirestoreProfessionalUserPublicDocument } from "../../../types";
+export type GetActiveServiceProviderServicePricingAndDurationForVehicleOrThrowParams = {
+    professionalUserPublicDocument: FirestoreProfessionalUserPublicDocument;
+    serviceType: ServicesTypes;
+    vehicleType: VehicleTypes;
+};

package/dist/firebase/firestore/utils/services/types/GetActiveServiceProviderServicePricingAndDurationForVehicleOrThrowParams.type.js

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