@infrab4a/connect-angular 4.0.0-beta.48 → 4.0.0-beta.5

package/fesm2020/infrab4a-connect-angular.mjs

@@ -1,25 +1,49 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, NgModule, PLATFORM_ID, Injectable, Inject } from '@angular/core';
-import * as i1$3 from '@infrab4a/connect';
-import { Authentication, AuthenticationFirebaseAuthService, Register, RegisterFirebaseAuthService, SignOut, RecoveryPassword, ProductsIndex, AxiosAdapter, UserBeautyProfileFirestoreRepository, Buy2WinFirestoreRepository, CategoryFirestoreRepository, CheckoutFirestoreRepository, CheckoutSubscriptionFirestoreRepository, CouponFirestoreRepository, CampaignHashtagFirestoreRepository, CampaignDashboardFirestoreRepository, SubscriptionEditionFirestoreRepository, HomeFirestoreRepository, LeadFirestoreRepository, LegacyOrderFirestoreRepository, ShopMenuFirestoreRepository, OrderFirestoreRepository, PaymentFirestoreRepository, ProductFirestoreRepository, ShopSettingsFirestoreRepository, SubscriptionPaymentFirestoreRepository, SubscriptionPlanFirestoreRepository, SubscriptionProductFirestoreRepository, SubscriptionFirestoreRepository, UserFirestoreRepository, UserAddressFirestoreRepository, UserPaymentMethodFirestoreRepository, ProductVariantFirestoreRepository, CategoryHasuraGraphQLRepository, ProductHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository, VariantHasuraGraphQLRepository, FilterOptionHasuraGraphQLRepository, FilterHasuraGraphQLRepository, CategoryCollectionChildrenHasuraGraphQLRepository, WishlistHasuraGraphQLRepository, Where, Shops, CheckoutTypes, CouponTypes, Exclusivities, isNil, NotFoundError, Checkout, pick, LineItem, RoundProductPricesHelper, set, Category, CheckoutSubscription, Product, RequiredArgumentError, add, Order } from '@infrab4a/connect';
-import * as i1 from '@angular/fire/app';
-import { provideFirebaseApp, initializeApp, FirebaseApp } from '@angular/fire/app';
-import * as i1$1 from '@angular/fire/auth';
-import { Auth, provideAuth, getAuth, getIdToken, authState } from '@angular/fire/auth';
-import { isPlatformBrowser } from '@angular/common';
-import * as i1$2 from '@angular/fire/firestore';
-import { Firestore, provideFirestore, getFirestore, initializeFirestore, enableIndexedDbPersistence, docSnapshots, doc } from '@angular/fire/firestore';
-import { initializeApp as initializeApp$1 } from 'firebase/app';
-import { combineLatest, from, of, throwError, Subject, iif, forkJoin } from 'rxjs';
+import { Injectable, Inject, InjectionToken, NgModule, PLATFORM_ID } from '@angular/core';
+import * as i1 from '@angular/fire/auth';
+import { getIdToken, authState, Auth, provideAuth, getAuth } from '@angular/fire/auth';
+import { combineLatest, of, from, throwError, Subject, iif, forkJoin } from 'rxjs';
 import { map, mergeMap, catchError, concatMap, tap } from 'rxjs/operators';
+import * as i2 from '@infrab4a/connect';
+import { Where, Shops, CheckoutTypes, CouponTypes, Exclusivities, Status, isNil, NotFoundError, Checkout, pick, LineItem, CheckoutSubscription, Order, Category, Product, RequiredArgumentError, add, Authentication, AuthenticationFirebaseAuthService, Register, RegisterFirebaseAuthService, SignOut, RecoveryPassword, ProductsIndex, AxiosAdapter, UserBeautyProfileFirestoreRepository, Buy2WinFirestoreRepository, CategoryFirestoreRepository, CheckoutFirestoreRepository, CheckoutSubscriptionFirestoreRepository, CouponFirestoreRepository, SubscriptionEditionFirestoreRepository, HomeFirestoreRepository, LeadFirestoreRepository, LegacyOrderFirestoreRepository, ShopMenuFirestoreRepository, OrderFirestoreRepository, PaymentFirestoreRepository, ProductFirestoreRepository, SubscriptionPaymentFirestoreRepository, SubscriptionPlanFirestoreRepository, SubscriptionProductFirestoreRepository, SubscriptionFirestoreRepository, UserFirestoreRepository, UserAddressFirestoreRepository, UserPaymentMethodFirestoreRepository, ProductVariantFirestoreRepository, CategoryHasuraGraphQLRepository, ProductHasuraGraphQLRepository, VariantHasuraGraphQLRepository } from '@infrab4a/connect';
 import cookie from 'js-cookie';
-import { __decorate, __metadata } from 'tslib';
-import { Type } from 'class-transformer';
-import * as i1$4 from '@angular/common/http';
-
-const BACKEND_URL = 'BACKEND_URL';
+import { CustomError } from 'ts-custom-error';
+import * as i1$1 from '@angular/fire/firestore';
+import { docSnapshots, doc, Firestore, provideFirestore, getFirestore } from '@angular/fire/firestore';
+import * as i1$2 from '@angular/fire/app';
+import { provideFirebaseApp, initializeApp } from '@angular/fire/app';
+import { isPlatformBrowser } from '@angular/common';
 
-const CATEGORY_STRUCTURE = 'CATEGORY_STRUCTURE';
+class AuthService {
+    constructor(angularFireAuth, userRepository) {
+        this.angularFireAuth = angularFireAuth;
+        this.userRepository = userRepository;
+    }
+    getAuthstate() {
+        const observables = [this.getFireUser(), this.getUser()];
+        return combineLatest(observables).pipe(map(([fireUser, user]) => ({
+            user,
+            isAnonymous: fireUser?.isAnonymous,
+        })));
+    }
+    getUser() {
+        return this.getFireUser().pipe(map((user) => user?.uid), mergeMap((id) => (id ? this.userRepository.get({ id }) : of(null))), catchError(() => of(null)));
+    }
+    getTokenId() {
+        return from(getIdToken(this.angularFireAuth.currentUser));
+    }
+    getFireUser() {
+        return authState(this.angularFireAuth).pipe(catchError(() => of(null)));
+    }
+}
+AuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AuthService, deps: [{ token: i1.Auth }, { token: 'UserRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AuthService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Auth }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['UserRepository']
+                }] }]; } });
 
 const DEFAULT_SHOP = 'DEFAULT_SHOP';
 
@@ -30,961 +54,152 @@ const FIREBASE_OPTIONS = new InjectionToken('firebaseOptions');
 
 const HASURA_OPTIONS = 'HASURA_OPTIONS';
 
-class AngularFirebaseAuthModule {
-    static initializeApp(options, nameOrConfig) {
-        return {
-            ngModule: AngularFirebaseAuthModule,
-            providers: [
-                { provide: FIREBASE_OPTIONS, useValue: options },
-                { provide: FIREBASE_APP_NAME, useValue: nameOrConfig },
-            ],
-        };
-    }
-}
-AngularFirebaseAuthModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirebaseAuthModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AngularFirebaseAuthModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularFirebaseAuthModule, imports: [i1.FirebaseAppModule, i1$1.AuthModule] });
-AngularFirebaseAuthModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirebaseAuthModule, providers: [
-        {
-            provide: 'Authentication',
-            useFactory: (authenticationService, userRepository) => {
-                return new Authentication(authenticationService, userRepository);
-            },
-            deps: ['AuthenticationService', 'UserRepository'],
-        },
-        {
-            provide: 'AuthenticationService',
-            useFactory: (angularFireAuth) => {
-                return new AuthenticationFirebaseAuthService(angularFireAuth);
-            },
-            deps: [Auth],
-        },
-        {
-            provide: 'Register',
-            useFactory: (registerService, userRepository) => {
-                return new Register(registerService, userRepository);
-            },
-            deps: ['RegisterService', 'UserRepository'],
-        },
-        {
-            provide: 'RegisterService',
-            useFactory: (angularFireAuth) => {
-                return new RegisterFirebaseAuthService(angularFireAuth);
-            },
-            deps: [Auth],
-        },
-        {
-            provide: 'SignOut',
-            useFactory: (authenticationService) => {
-                return new SignOut(authenticationService);
-            },
-            deps: ['AuthenticationService'],
-        },
-        {
-            provide: 'RecoveryPassword',
-            useFactory: (authenticationService) => {
-                return new RecoveryPassword(authenticationService);
-            },
-            deps: ['AuthenticationService'],
-        },
-    ], imports: [provideFirebaseApp((injector) => {
-            const appName = injector.get(FIREBASE_APP_NAME);
-            return appName
-                ? initializeApp(injector.get(FIREBASE_OPTIONS), appName)
-                : initializeApp(injector.get(FIREBASE_OPTIONS));
-        }),
-        provideAuth(() => getAuth())] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirebaseAuthModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [
-                        provideFirebaseApp((injector) => {
-                            const appName = injector.get(FIREBASE_APP_NAME);
-                            return appName
-                                ? initializeApp(injector.get(FIREBASE_OPTIONS), appName)
-                                : initializeApp(injector.get(FIREBASE_OPTIONS));
-                        }),
-                        provideAuth(() => getAuth()),
-                    ],
-                    providers: [
-                        {
-                            provide: 'Authentication',
-                            useFactory: (authenticationService, userRepository) => {
-                                return new Authentication(authenticationService, userRepository);
-                            },
-                            deps: ['AuthenticationService', 'UserRepository'],
-                        },
-                        {
-                            provide: 'AuthenticationService',
-                            useFactory: (angularFireAuth) => {
-                                return new AuthenticationFirebaseAuthService(angularFireAuth);
-                            },
-                            deps: [Auth],
-                        },
-                        {
-                            provide: 'Register',
-                            useFactory: (registerService, userRepository) => {
-                                return new Register(registerService, userRepository);
-                            },
-                            deps: ['RegisterService', 'UserRepository'],
-                        },
-                        {
-                            provide: 'RegisterService',
-                            useFactory: (angularFireAuth) => {
-                                return new RegisterFirebaseAuthService(angularFireAuth);
-                            },
-                            deps: [Auth],
-                        },
-                        {
-                            provide: 'SignOut',
-                            useFactory: (authenticationService) => {
-                                return new SignOut(authenticationService);
-                            },
-                            deps: ['AuthenticationService'],
-                        },
-                        {
-                            provide: 'RecoveryPassword',
-                            useFactory: (authenticationService) => {
-                                return new RecoveryPassword(authenticationService);
-                            },
-                            deps: ['AuthenticationService'],
-                        },
-                    ],
-                }]
-        }] });
-
-class AngularElasticSeachModule {
-    static initializeApp(options) {
-        return {
-            ngModule: AngularElasticSeachModule,
-            providers: [{ provide: ES_CONFIG, useValue: options }],
-        };
+class InvalidCouponError extends CustomError {
+    constructor(message) {
+        super(message);
     }
 }
-AngularElasticSeachModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularElasticSeachModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AngularElasticSeachModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularElasticSeachModule });
-AngularElasticSeachModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularElasticSeachModule, providers: [
-        {
-            provide: ProductsIndex,
-            useFactory: (configuration) => new ProductsIndex(new AxiosAdapter(configuration)),
-            deps: [ES_CONFIG],
-        },
-    ] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularElasticSeachModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    providers: [
-                        {
-                            provide: ProductsIndex,
-                            useFactory: (configuration) => new ProductsIndex(new AxiosAdapter(configuration)),
-                            deps: [ES_CONFIG],
-                        },
-                    ],
-                }]
-        }] });
 
-class MobileOperationSystemCheckerHelper {
-    static isAppleDevice() {
-        return (['iPad Simulator', 'iPhone Simulator', 'iPod Simulator', 'iPad', 'iPhone', 'iPod'].includes(navigator?.platform) ||
-            (navigator?.userAgent?.includes?.('Mac') && 'ontouchend' in (document || {})));
+class GroupInvalidCouponError extends CustomError {
+    constructor(errors) {
+        super('Many coupon errors throw');
+        this.errors = errors;
     }
 }
 
-class AngularFirestoreModule {
-    static initializeApp(options, nameOrConfig) {
-        return {
-            ngModule: AngularFirestoreModule,
-            providers: [
-                { provide: FIREBASE_OPTIONS, useValue: options.firebase },
-                { provide: FIREBASE_APP_NAME, useValue: nameOrConfig },
-                { provide: ES_CONFIG, useValue: options.elasticSearch },
-            ],
-        };
+class CouponService {
+    constructor(couponRepository, defaultShop, orderRepository, subscriptionRepository, categoryRepository) {
+        this.couponRepository = couponRepository;
+        this.defaultShop = defaultShop;
+        this.orderRepository = orderRepository;
+        this.subscriptionRepository = subscriptionRepository;
+        this.categoryRepository = categoryRepository;
+        this.emailIsFromCollaborator = (userEmail) => !!userEmail?.match(/@b4a.com.br/g);
     }
-}
-AngularFirestoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirestoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AngularFirestoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularFirestoreModule, imports: [AngularElasticSeachModule, i1.FirebaseAppModule, i1$2.FirestoreModule] });
-AngularFirestoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirestoreModule, providers: [
-        {
-            provide: 'FirestoreOptions',
-            useFactory: (firestore, platformId) => ({
-                firestore,
-                interceptors: {
-                    request: (request) => {
-                        if (isPlatformBrowser(platformId))
-                            return request;
-                        const interval = setInterval(() => { }, 100);
-                        request.interval = interval;
-                        return request;
-                    },
-                    response: (response, request) => {
-                        if (isPlatformBrowser(platformId))
-                            return response;
-                        clearInterval(request.interval);
-                        return response;
-                    },
-                },
-            }),
-            deps: [Firestore, PLATFORM_ID],
-        },
-        {
-            provide: 'BeautyProfileRepository',
-            useFactory: (config, userRepository) => {
-                return new UserBeautyProfileFirestoreRepository(config, userRepository);
-            },
-            deps: ['FirestoreOptions', 'UserRepository'],
-        },
-        {
-            provide: 'Buy2WinRepository',
-            useFactory: (options) => {
-                return new Buy2WinFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: CategoryFirestoreRepository,
-            useFactory: (options) => {
-                return new CategoryFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'CheckoutRepository',
-            useFactory: (options) => {
-                return new CheckoutFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'CheckoutSubscriptionRepository',
-            useFactory: (options) => {
-                return new CheckoutSubscriptionFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'CouponRepository',
-            useFactory: (options) => {
-                return new CouponFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'CampaignHashtagRepository',
-            useFactory: (options) => {
-                return new CampaignHashtagFirestoreRepository(options);
+    checkCoupon(nickname, userEmail, checkoutType, plan, checkout, isSubscription) {
+        return from(this.couponRepository.find({
+            filters: {
+                nickname: { operator: Where.EQUALS, value: nickname },
+                active: { operator: Where.EQUALS, value: true },
             },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'CampaignDashboardRepository',
-            useFactory: (options) => {
-                return new CampaignDashboardFirestoreRepository(options);
+        })).pipe(concatMap((coupons) => this.checkCouponRules(coupons, checkoutType, plan, checkout, isSubscription)), concatMap((coupon) => this.checkCouponUseAndLimit(coupon, userEmail, checkout)), map((coupon) => this.isValidCoupon(coupon, userEmail)), map((coupon) => coupon));
+    }
+    checkCouponRules(coupons, checkoutType, plan, checkout, isSubscription) {
+        // Caso não ache nenhum cupom, retorna erro
+        if (coupons.count < 1) {
+            return throwError('Cupom inválido.');
+        }
+        // Get Primeiro Cupom (o find do repository retorna um array)
+        const coupon = coupons.data.shift();
+        // Verifica se o cupom é aplicavel na loja
+        const isInShop = coupon.shopAvailability === Shops.ALL || coupon.shopAvailability === this.defaultShop;
+        // Cupon não aplicavel a loja retorna erro
+        if (!isInShop)
+            return throwError('Cupom inválido para loja.');
+        // Verifica se o coupon é aplicado no checkout que está sendo realizado
+        const isCheckoutType = coupon.checkoutType === CheckoutTypes.ALL || coupon.checkoutType === checkoutType;
+        // Cupon não aplicavel ao checkout retorna erro
+        if (!isCheckoutType)
+            return throwError('Cupom inválido. Erro de checkout.');
+        // Verifica se o cupom é ou pode ser aplicado para subscription
+        if (checkoutType === CheckoutTypes.ALL || checkoutType === CheckoutTypes.SUBSCRIPTION) {
+            // Se o cupom tiver um plano associado, verifica se é o mesmo plano do checkout da assinatura
+            if (coupon.plan && coupon.plan.toUpperCase() !== plan.toUpperCase())
+                return throwError('Cupom inválido para sua assinatura.');
+        }
+        if (isSubscription)
+            return of(coupon);
+        // Verifica se possui o valor minimo de compra para utilização do cupom
+        const hasMinSubTotal = this.hasMinSubTotal(coupon, checkout);
+        // Se não tem valor mínimo atingido, retorna erro
+        if (!hasMinSubTotal)
+            return throwError('Valor mínimo não atingido');
+        return of(coupon);
+    }
+    isValidCoupon(coupon, userEmail) {
+        // Verifica a data de inicio de validade do cupom
+        if (coupon?.beginAt > new Date())
+            throw new InvalidCouponError('Cupom ainda não liberado.');
+        // Verifica a data de validade do cupom
+        if (coupon?.expiresIn < new Date())
+            throw new InvalidCouponError('Cupom expirado.');
+        return coupon;
+    }
+    async checkCouponUseAndLimit(coupon, userEmail, checkout) {
+        const orders = await this.orderRepository.find({
+            filters: {
+                coupon: { id: coupon.id },
+                payment: { status: 'paid' },
             },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'EditionRepository',
-            useFactory: (options, subscriptionRepository) => {
-                return new SubscriptionEditionFirestoreRepository(options, subscriptionRepository);
-            },
-            deps: ['FirestoreOptions', 'SubscriptionRepository'],
-        },
-        {
-            provide: 'HomeRepository',
-            useFactory: (options) => {
-                return new HomeFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'LeadRepository',
-            useFactory: (options) => {
-                return new LeadFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'LegacyOrderRepository',
-            useFactory: (options) => {
-                return new LegacyOrderFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'ShopMenuRepository',
-            useFactory: (options) => {
-                return new ShopMenuFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'OrderRepository',
-            useFactory: (options) => {
-                return new OrderFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'PaymentRepository',
-            useFactory: (options) => {
-                return new PaymentFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: ProductFirestoreRepository,
-            useFactory: (options) => {
-                return new ProductFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'ShopSettingsRepository',
-            useFactory: (options) => {
-                return new ShopSettingsFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'SubscriptionPaymentRepository',
-            useFactory: (options, subscriptionRepository) => {
-                return new SubscriptionPaymentFirestoreRepository(options, subscriptionRepository);
-            },
-            deps: ['FirestoreOptions', 'SubscriptionRepository'],
-        },
-        {
-            provide: 'SubscriptionPlanRepository',
-            useFactory: (options) => {
-                return new SubscriptionPlanFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'SubscriptionProductRepository',
-            useFactory: (options) => {
-                return new SubscriptionProductFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'SubscriptionRepository',
-            useFactory: (options) => {
-                return new SubscriptionFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'UserRepository',
-            useFactory: (options) => {
-                return new UserFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'UserAddressRepository',
-            useFactory: (options, userRepository) => {
-                return new UserAddressFirestoreRepository(options, userRepository);
-            },
-            deps: ['FirestoreOptions', 'UserRepository'],
-        },
-        {
-            provide: 'UserPaymentMethodRepository',
-            useFactory: (options, userRepository) => {
-                return new UserPaymentMethodFirestoreRepository(options, userRepository);
-            },
-            deps: ['FirestoreOptions', 'UserRepository'],
-        },
-        {
-            provide: ProductVariantFirestoreRepository,
-            useFactory: (options, productRepository) => {
-                return new ProductVariantFirestoreRepository(options, productRepository);
-            },
-            deps: ['FirestoreOptions', ProductFirestoreRepository],
-        },
-    ], imports: [AngularElasticSeachModule,
-        provideFirebaseApp((injector) => {
-            const appName = injector.get(FIREBASE_APP_NAME);
-            return appName
-                ? initializeApp$1(injector.get(FIREBASE_OPTIONS), appName)
-                : initializeApp$1(injector.get(FIREBASE_OPTIONS));
-        }),
-        provideFirestore((injector) => {
-            if (!MobileOperationSystemCheckerHelper.isAppleDevice())
-                return getFirestore();
-            const firestore = initializeFirestore(injector.get(FirebaseApp), { experimentalForceLongPolling: true });
-            enableIndexedDbPersistence(firestore).catch(console.error);
-            return firestore;
-        })] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirestoreModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [
-                        AngularElasticSeachModule,
-                        provideFirebaseApp((injector) => {
-                            const appName = injector.get(FIREBASE_APP_NAME);
-                            return appName
-                                ? initializeApp$1(injector.get(FIREBASE_OPTIONS), appName)
-                                : initializeApp$1(injector.get(FIREBASE_OPTIONS));
-                        }),
-                        provideFirestore((injector) => {
-                            if (!MobileOperationSystemCheckerHelper.isAppleDevice())
-                                return getFirestore();
-                            const firestore = initializeFirestore(injector.get(FirebaseApp), { experimentalForceLongPolling: true });
-                            enableIndexedDbPersistence(firestore).catch(console.error);
-                            return firestore;
-                        }),
-                    ],
-                    providers: [
-                        {
-                            provide: 'FirestoreOptions',
-                            useFactory: (firestore, platformId) => ({
-                                firestore,
-                                interceptors: {
-                                    request: (request) => {
-                                        if (isPlatformBrowser(platformId))
-                                            return request;
-                                        const interval = setInterval(() => { }, 100);
-                                        request.interval = interval;
-                                        return request;
-                                    },
-                                    response: (response, request) => {
-                                        if (isPlatformBrowser(platformId))
-                                            return response;
-                                        clearInterval(request.interval);
-                                        return response;
-                                    },
-                                },
-                            }),
-                            deps: [Firestore, PLATFORM_ID],
-                        },
-                        {
-                            provide: 'BeautyProfileRepository',
-                            useFactory: (config, userRepository) => {
-                                return new UserBeautyProfileFirestoreRepository(config, userRepository);
-                            },
-                            deps: ['FirestoreOptions', 'UserRepository'],
-                        },
-                        {
-                            provide: 'Buy2WinRepository',
-                            useFactory: (options) => {
-                                return new Buy2WinFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: CategoryFirestoreRepository,
-                            useFactory: (options) => {
-                                return new CategoryFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'CheckoutRepository',
-                            useFactory: (options) => {
-                                return new CheckoutFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'CheckoutSubscriptionRepository',
-                            useFactory: (options) => {
-                                return new CheckoutSubscriptionFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'CouponRepository',
-                            useFactory: (options) => {
-                                return new CouponFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'CampaignHashtagRepository',
-                            useFactory: (options) => {
-                                return new CampaignHashtagFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'CampaignDashboardRepository',
-                            useFactory: (options) => {
-                                return new CampaignDashboardFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'EditionRepository',
-                            useFactory: (options, subscriptionRepository) => {
-                                return new SubscriptionEditionFirestoreRepository(options, subscriptionRepository);
-                            },
-                            deps: ['FirestoreOptions', 'SubscriptionRepository'],
-                        },
-                        {
-                            provide: 'HomeRepository',
-                            useFactory: (options) => {
-                                return new HomeFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'LeadRepository',
-                            useFactory: (options) => {
-                                return new LeadFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'LegacyOrderRepository',
-                            useFactory: (options) => {
-                                return new LegacyOrderFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'ShopMenuRepository',
-                            useFactory: (options) => {
-                                return new ShopMenuFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'OrderRepository',
-                            useFactory: (options) => {
-                                return new OrderFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'PaymentRepository',
-                            useFactory: (options) => {
-                                return new PaymentFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: ProductFirestoreRepository,
-                            useFactory: (options) => {
-                                return new ProductFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'ShopSettingsRepository',
-                            useFactory: (options) => {
-                                return new ShopSettingsFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'SubscriptionPaymentRepository',
-                            useFactory: (options, subscriptionRepository) => {
-                                return new SubscriptionPaymentFirestoreRepository(options, subscriptionRepository);
-                            },
-                            deps: ['FirestoreOptions', 'SubscriptionRepository'],
-                        },
-                        {
-                            provide: 'SubscriptionPlanRepository',
-                            useFactory: (options) => {
-                                return new SubscriptionPlanFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'SubscriptionProductRepository',
-                            useFactory: (options) => {
-                                return new SubscriptionProductFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'SubscriptionRepository',
-                            useFactory: (options) => {
-                                return new SubscriptionFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'UserRepository',
-                            useFactory: (options) => {
-                                return new UserFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'UserAddressRepository',
-                            useFactory: (options, userRepository) => {
-                                return new UserAddressFirestoreRepository(options, userRepository);
-                            },
-                            deps: ['FirestoreOptions', 'UserRepository'],
-                        },
-                        {
-                            provide: 'UserPaymentMethodRepository',
-                            useFactory: (options, userRepository) => {
-                                return new UserPaymentMethodFirestoreRepository(options, userRepository);
-                            },
-                            deps: ['FirestoreOptions', 'UserRepository'],
-                        },
-                        {
-                            provide: ProductVariantFirestoreRepository,
-                            useFactory: (options, productRepository) => {
-                                return new ProductVariantFirestoreRepository(options, productRepository);
-                            },
-                            deps: ['FirestoreOptions', ProductFirestoreRepository],
-                        },
-                    ],
-                }]
-        }] });
-
-class AngularHasuraGraphQLModule {
-    static initializeApp(options) {
-        return {
-            ngModule: AngularHasuraGraphQLModule,
-            providers: [{ provide: HASURA_OPTIONS, useValue: options }],
-        };
-    }
-}
-AngularHasuraGraphQLModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularHasuraGraphQLModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AngularHasuraGraphQLModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularHasuraGraphQLModule });
-AngularHasuraGraphQLModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularHasuraGraphQLModule, providers: [
-        {
-            provide: 'HasuraConfig',
-            useFactory: (options, platformId) => ({
-                endpoint: options.endpoint,
-                authOptions: options.credentials,
-                interceptors: {
-                    request: (request) => {
-                        if (isPlatformBrowser(platformId))
-                            return request;
-                        const interval = setInterval(() => { }, 100);
-                        request.interval = interval;
-                        return request;
-                    },
-                    response: (response, request) => {
-                        if (isPlatformBrowser(platformId))
-                            return response;
-                        clearInterval(request.interval);
-                        return response;
-                    },
-                },
-            }),
-            deps: [HASURA_OPTIONS, PLATFORM_ID],
-        },
-        {
-            provide: 'CategoryRepository',
-            useExisting: CategoryHasuraGraphQLRepository,
-        },
-        {
-            provide: CategoryHasuraGraphQLRepository,
-            useFactory: (options, productRepository, categoryFilterRepository) => {
-                return new CategoryHasuraGraphQLRepository(options, productRepository, categoryFilterRepository);
-            },
-            deps: ['HasuraConfig', ProductHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository],
-        },
-        {
-            provide: 'ProductRepository',
-            useExisting: ProductHasuraGraphQLRepository,
-        },
-        {
-            provide: ProductHasuraGraphQLRepository,
-            useFactory: (hasuraConfig) => {
-                return new ProductHasuraGraphQLRepository(hasuraConfig);
-            },
-            deps: ['HasuraConfig'],
-        },
-        {
-            provide: 'VariantRepository',
-            useExisting: VariantHasuraGraphQLRepository,
-        },
-        {
-            provide: VariantHasuraGraphQLRepository,
-            useFactory: (hasuraConfig) => {
-                return new VariantHasuraGraphQLRepository(hasuraConfig);
-            },
-            deps: ['HasuraConfig'],
-        },
-        {
-            provide: 'CategoryFilterRepository',
-            useExisting: CategoryFilterHasuraGraphQLRepository,
-        },
-        {
-            provide: CategoryFilterHasuraGraphQLRepository,
-            useFactory: (options) => {
-                return new CategoryFilterHasuraGraphQLRepository(options);
-            },
-            deps: ['HasuraConfig'],
-        },
-        {
-            provide: 'FilterOptionRepository',
-            useExisting: FilterOptionHasuraGraphQLRepository,
-        },
-        {
-            provide: FilterOptionHasuraGraphQLRepository,
-            useFactory: (options) => {
-                return new FilterOptionHasuraGraphQLRepository(options);
-            },
-            deps: ['HasuraConfig'],
-        },
-        {
-            provide: 'FilterRepository',
-            useExisting: FilterHasuraGraphQLRepository,
-        },
-        {
-            provide: FilterHasuraGraphQLRepository,
-            useFactory: (options, filterOptionRepository, categoryFilterRepository) => {
-                return new FilterHasuraGraphQLRepository(options, filterOptionRepository, categoryFilterRepository);
-            },
-            deps: ['HasuraConfig', FilterOptionHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository],
-        },
-        {
-            provide: CategoryCollectionChildrenHasuraGraphQLRepository,
-            useFactory: (options) => new CategoryCollectionChildrenHasuraGraphQLRepository(options.endpoint, options.credentials),
-        },
-        {
-            provide: 'CategoryCollectionChildrenRepository',
-            useExisting: CategoryCollectionChildrenHasuraGraphQLRepository,
-        },
-        {
-            provide: 'WishlistRepository',
-            useExisting: WishlistHasuraGraphQLRepository,
-        },
-    ] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularHasuraGraphQLModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    providers: [
-                        {
-                            provide: 'HasuraConfig',
-                            useFactory: (options, platformId) => ({
-                                endpoint: options.endpoint,
-                                authOptions: options.credentials,
-                                interceptors: {
-                                    request: (request) => {
-                                        if (isPlatformBrowser(platformId))
-                                            return request;
-                                        const interval = setInterval(() => { }, 100);
-                                        request.interval = interval;
-                                        return request;
-                                    },
-                                    response: (response, request) => {
-                                        if (isPlatformBrowser(platformId))
-                                            return response;
-                                        clearInterval(request.interval);
-                                        return response;
-                                    },
-                                },
-                            }),
-                            deps: [HASURA_OPTIONS, PLATFORM_ID],
-                        },
-                        {
-                            provide: 'CategoryRepository',
-                            useExisting: CategoryHasuraGraphQLRepository,
-                        },
-                        {
-                            provide: CategoryHasuraGraphQLRepository,
-                            useFactory: (options, productRepository, categoryFilterRepository) => {
-                                return new CategoryHasuraGraphQLRepository(options, productRepository, categoryFilterRepository);
-                            },
-                            deps: ['HasuraConfig', ProductHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository],
-                        },
-                        {
-                            provide: 'ProductRepository',
-                            useExisting: ProductHasuraGraphQLRepository,
-                        },
-                        {
-                            provide: ProductHasuraGraphQLRepository,
-                            useFactory: (hasuraConfig) => {
-                                return new ProductHasuraGraphQLRepository(hasuraConfig);
-                            },
-                            deps: ['HasuraConfig'],
-                        },
-                        {
-                            provide: 'VariantRepository',
-                            useExisting: VariantHasuraGraphQLRepository,
-                        },
-                        {
-                            provide: VariantHasuraGraphQLRepository,
-                            useFactory: (hasuraConfig) => {
-                                return new VariantHasuraGraphQLRepository(hasuraConfig);
-                            },
-                            deps: ['HasuraConfig'],
-                        },
-                        {
-                            provide: 'CategoryFilterRepository',
-                            useExisting: CategoryFilterHasuraGraphQLRepository,
-                        },
-                        {
-                            provide: CategoryFilterHasuraGraphQLRepository,
-                            useFactory: (options) => {
-                                return new CategoryFilterHasuraGraphQLRepository(options);
-                            },
-                            deps: ['HasuraConfig'],
-                        },
-                        {
-                            provide: 'FilterOptionRepository',
-                            useExisting: FilterOptionHasuraGraphQLRepository,
-                        },
-                        {
-                            provide: FilterOptionHasuraGraphQLRepository,
-                            useFactory: (options) => {
-                                return new FilterOptionHasuraGraphQLRepository(options);
-                            },
-                            deps: ['HasuraConfig'],
-                        },
-                        {
-                            provide: 'FilterRepository',
-                            useExisting: FilterHasuraGraphQLRepository,
-                        },
-                        {
-                            provide: FilterHasuraGraphQLRepository,
-                            useFactory: (options, filterOptionRepository, categoryFilterRepository) => {
-                                return new FilterHasuraGraphQLRepository(options, filterOptionRepository, categoryFilterRepository);
-                            },
-                            deps: ['HasuraConfig', FilterOptionHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository],
-                        },
-                        {
-                            provide: CategoryCollectionChildrenHasuraGraphQLRepository,
-                            useFactory: (options) => new CategoryCollectionChildrenHasuraGraphQLRepository(options.endpoint, options.credentials),
-                        },
-                        {
-                            provide: 'CategoryCollectionChildrenRepository',
-                            useExisting: CategoryCollectionChildrenHasuraGraphQLRepository,
-                        },
-                        {
-                            provide: 'WishlistRepository',
-                            useExisting: WishlistHasuraGraphQLRepository,
-                        },
-                    ],
-                }]
-        }] });
-
-class AuthService {
-    constructor(angularFireAuth, userRepository) {
-        this.angularFireAuth = angularFireAuth;
-        this.userRepository = userRepository;
-    }
-    getAuthstate() {
-        const observables = [this.getFireUser(), this.getUser()];
-        return combineLatest(observables).pipe(map(([fireUser, user]) => ({
-            user,
-            isAnonymous: fireUser?.isAnonymous,
-        })));
-    }
-    getUser() {
-        return this.getFireUser().pipe(map((user) => user?.uid), mergeMap((id) => (id ? from(this.userRepository.get({ id })).pipe(catchError(() => of(null))) : of(null))));
-    }
-    getTokenId() {
-        return from(getIdToken(this.angularFireAuth.currentUser));
-    }
-    getFireUser() {
-        return authState(this.angularFireAuth).pipe(catchError(() => of(null)));
-    }
-}
-AuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AuthService, deps: [{ token: i1$1.Auth }, { token: 'UserRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-AuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AuthService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AuthService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i1$1.Auth }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['UserRepository']
-                }] }]; } });
-
-class CouponService {
-    constructor(couponRepository, defaultShop, orderRepository, categoryRepository) {
-        this.couponRepository = couponRepository;
-        this.defaultShop = defaultShop;
-        this.orderRepository = orderRepository;
-        this.categoryRepository = categoryRepository;
-        this.emailIsFromCollaborator = (userEmail) => !!userEmail?.match(/@b4a.com.br/g);
-    }
-    checkCoupon(nickname, checkoutType, checkout, plan) {
-        return from(this.couponRepository
-            .find({
-            filters: {
-                nickname: { operator: Where.EQUALS, value: nickname },
-                active: { operator: Where.EQUALS, value: true },
-            },
-        })
-            .then((result) => result.data[0])).pipe(concatMap((coupon) => this.couponValidation(coupon, checkoutType)), concatMap((couponValid) => this.couponRulesValidation(couponValid, checkoutType, checkout, plan)), map((couponValidated) => couponValidated));
-    }
-    async couponValidation(coupon, checkoutType) {
-        if (!coupon)
-            throw 'Cupom inválido.';
-        if (coupon?.beginAt && coupon?.beginAt.getTime() > new Date().getTime())
-            throw 'Cupom inválido.';
-        if (coupon?.expiresIn && coupon?.expiresIn.getTime() < new Date().getTime())
-            throw 'Cupom expirado.';
-        const isInShop = coupon.shopAvailability === Shops.ALL || coupon.shopAvailability === this.defaultShop;
-        if (!isInShop)
-            throw 'Cupom inválido para loja.';
-        const isCheckoutType = coupon.checkoutType === CheckoutTypes.ALL || coupon.checkoutType === checkoutType;
-        if (!isCheckoutType)
-            throw 'Cupom inválido. Erro de checkout.';
-        return coupon;
-    }
-    async couponRulesValidation(coupon, checkoutType, checkout, plan) {
-        if (checkoutType == CheckoutTypes.SUBSCRIPTION) {
-            if (coupon.plan && coupon.plan.toUpperCase() !== plan.toUpperCase())
-                throw 'Cupom inválido para sua assinatura.';
-            return coupon;
-        }
-        const validUser = this.coupomUserValidation(coupon, checkout?.user);
+        });
+        // orders que usuario ja fez com o cupom
+        const ordersUserCoupon = orders.data.filter((o) => o.user.email == userEmail);
+        // Verifica o limite de uso de cupom por usuario
+        if (coupon.useLimitPerUser && ordersUserCoupon.length)
+            throw new InvalidCouponError('Limite de uso por usuário atingido.');
+        // Verifica o limite de uso geral por usuario
+        if (coupon.useLimit && orders.data.length >= coupon.useLimit)
+            throw new InvalidCouponError('Limite de uso atingido.');
+        const validUser = await this.userValidationAndSubscriptionStatus(coupon, userEmail);
         if (!validUser)
-            throw 'Usuário não elegível.';
-        const couponUseLimits = this.getCouponUseLimits(coupon, checkoutType, checkout.user);
-        if (!couponUseLimits.unlimited || couponUseLimits.limitedPerUser) {
-            const orders = await this.getOrdersWithCoupon(coupon);
-            if (!couponUseLimits.unlimited && couponUseLimits.total && orders.length >= couponUseLimits.total)
-                throw 'Limite de uso atingido.';
-            if (couponUseLimits.limitedPerUser) {
-                const ordersWithUser = this.countOrdersWithUser(orders, checkout.user.email);
-                if (ordersWithUser > 0)
-                    throw 'Limite de uso por usuário atingido.';
-            }
-        }
+            throw new InvalidCouponError('Usuário não elegível.');
         const hasProductCategories = await this.hasProductCategories(coupon, checkout);
         if (!hasProductCategories)
             throw 'Seu carrinho não possui produtos elegíveis para desconto.';
-        const hasMinSubTotal = await this.hasMinSubTotal(coupon, checkout);
-        if (!hasMinSubTotal)
-            throw `Valor mínimo de ${Intl.NumberFormat('pt-BR', { style: 'currency', currency: 'BRL' }).format(coupon.minSubTotalValue)} não atingido`;
         return coupon;
     }
     calcDiscountSubscription(coupon, checkout) {
+        //
         let discount = 0;
-        if (coupon.discount.subscription.type == CouponTypes.ABSOLUTE)
-            discount = coupon.discount.subscription.value;
-        else
-            discount = checkout.subscriptionPlan.recurrencePrice * (coupon.discount.subscription.value / 100);
+        if (coupon.type === CouponTypes.ABSOLUTE)
+            discount = coupon.discount;
+        else if (coupon.type === CouponTypes.PERCENTAGE)
+            discount = checkout.subscriptionPlan.recurrencePrice * (coupon.discount / 100);
         return of(discount);
     }
     async calcDiscountShopping(coupon, checkout) {
         let discount = 0;
-        if (checkout.user.isSubscriber && coupon.discount.subscriber.value) {
-            discount = await this.calcDiscountByType(coupon.discount.subscriber.type, coupon.discount.subscriber.value, coupon.productsCategories, checkout);
-        }
-        else {
-            discount = await this.calcDiscountByType(coupon.discount.non_subscriber.type, coupon.discount.non_subscriber.value, coupon.productsCategories, checkout);
+        switch (coupon.type) {
+            case CouponTypes.ABSOLUTE: {
+                discount = coupon.discount;
+                break;
+            }
+            case CouponTypes.PERCENTAGE: {
+                discount = await this.calcShoppingPercentageDiscount(coupon, checkout);
+                break;
+            }
         }
         return discount;
     }
-    async calcDiscountByType(type, value, categories, checkout) {
+    async calcShoppingPercentageDiscount(coupon, checkout) {
         let discount = 0;
-        let lineItensDiscount = await this.getLineItensEligebleForDiscount(categories, checkout);
-        const subTotal = this.calcCheckoutSubtotal(lineItensDiscount, checkout.user, checkout.shop);
-        if (type == CouponTypes.ABSOLUTE) {
-            discount = value > subTotal ? subTotal : value;
+        const shop = checkout.shop;
+        let lineItensDiscount = [];
+        const couponCategories = await this.getCouponCategoriesId(coupon);
+        if (coupon.productsCategories && coupon.productsCategories.length) {
+            lineItensDiscount = checkout.lineItems?.filter((i) => {
+                if (i.categories?.length) {
+                    return i.categories.some((c) => couponCategories.some((cat) => cat.id == c || cat.firestoreId == c));
+                }
+                return true;
+            });
         }
         else {
-            discount = subTotal * (value / 100);
+            lineItensDiscount = checkout.lineItems;
         }
+        const subTotal = lineItensDiscount.reduce((acc, curr) => checkout.user?.isSubscriber && curr.price?.subscriberPrice
+            ? acc + curr.price?.subscriberPrice * curr.quantity
+            : acc + curr.pricePaid * curr.quantity, 0) || 0;
+        discount = subTotal * (coupon.discount / 100);
         return discount;
     }
-    async hasMinSubTotal(coupon, checkout) {
+    hasMinSubTotal(coupon, checkout) {
         if (!coupon.minSubTotalValue)
             return true;
-        let lineItensDiscount = await this.getLineItensEligebleForDiscount(coupon.productsCategories, checkout);
-        const subTotal = this.calcCheckoutSubtotal(lineItensDiscount, checkout.user, checkout.shop);
+        const shop = checkout.shop;
+        let subTotal = checkout.lineItems?.reduce((acc, curr) => checkout.user?.isSubscriber && curr.price?.subscriberPrice
+            ? acc + curr.price?.subscriberPrice * curr.quantity
+            : acc + curr.pricePaid * curr.quantity, 0) || 0;
         if (coupon.minSubTotalValue <= subTotal)
             return true;
         return false;
@@ -993,93 +208,60 @@ class CouponService {
         if (!coupon.productsCategories || !coupon.productsCategories.length) {
             return true;
         }
-        const couponCategories = await this.getCouponCategoriesId(coupon.productsCategories);
+        const couponCategories = await this.getCouponCategoriesId(coupon);
         const hasCategories = checkout.lineItems?.filter((i) => {
             if (!i.categories || !i.categories?.length)
                 return true;
-            return i.categories.some((c) => couponCategories.some((cat) => cat == c));
+            return i.categories.some((c) => couponCategories.some((cat) => cat.id == c || cat.firestoreId == c));
         });
         return hasCategories.length ? true : false;
     }
-    coupomUserValidation(coupon, user) {
-        if (!user || coupon.exclusivityType.includes(Exclusivities.ALL_USERS))
-            return true;
-        let userTypes = [];
-        if (coupon.exclusivityType.includes(Exclusivities.COLLABORATORS) && this.emailIsFromCollaborator(user.email))
-            userTypes.push(Exclusivities.COLLABORATORS);
-        if (coupon.exclusivityType.includes(Exclusivities.SPECIFIC_USER) && coupon.userExclusiveEmail.includes(user.email))
-            userTypes.push(Exclusivities.SPECIFIC_USER);
-        if (coupon.exclusivityType.includes(Exclusivities.ACTIVE_SUBSCRIBER) &&
-            user.isSubscriber &&
-            user.subscriptionPlan != '')
-            userTypes.push(Exclusivities.ACTIVE_SUBSCRIBER);
-        if (user.isSubscriber &&
-            user.subscriptionPlan == '' &&
-            coupon.exclusivityType.includes(Exclusivities.INACTIVE_SUBSCRIBER))
-            userTypes.push(Exclusivities.INACTIVE_SUBSCRIBER);
-        if (coupon.exclusivityType.includes(Exclusivities.NON_SUBSCRIBER) && !user.isSubscriber)
-            userTypes.push(Exclusivities.NON_SUBSCRIBER);
-        return coupon.exclusivityType.some((r) => userTypes.includes(r));
-    }
-    async getCouponCategoriesId(productsCategories) {
-        const couponCategories = [];
-        for (let index = 0; index < productsCategories.length; index++) {
-            const category = await this.categoryRepository.get({
-                id: productsCategories[index],
-            });
-            if (category) {
-                const children = await this.categoryRepository.getChildren(parseInt(productsCategories[index]));
-                couponCategories.push(category.id, ...children.map((c) => c.id.toString()));
+    async userValidationAndSubscriptionStatus(coupon, userEmail) {
+        // Verifica se o email do usuário é coorporativo
+        if (!this.emailIsFromCollaborator(userEmail) && coupon.exclusivityType === Exclusivities.COLLABORATORS)
+            throw new InvalidCouponError('Você não é colaborador.');
+        // Verifica se o email do usuário é associado ao cupom de uso por usuario
+        if (coupon.exclusivityType === Exclusivities.SPECIFIC_USER && coupon.userExclusiveEmail !== userEmail)
+            throw new InvalidCouponError('Cupom não é válido para este usuário.');
+        const couponRuleSubscription = coupon.exclusivityType === Exclusivities.ACTIVE_SUBSCRIBER ||
+            coupon.exclusivityType === Exclusivities.INACTIVE_SUBSCRIBER ||
+            coupon.exclusivityType === Exclusivities.NON_SUBSCRIBER;
+        if (couponRuleSubscription && userEmail) {
+            const sub = await this.subscriptionRepository
+                .find({
+                filters: {
+                    user: {
+                        email: { operator: Where.EQUALS, value: userEmail },
+                    },
+                },
+            })
+                .then((sub) => sub.data);
+            const activeSubs = sub?.filter((s) => s.status === Status.ACTIVE);
+            switch (coupon.exclusivityType) {
+                case Exclusivities.ACTIVE_SUBSCRIBER:
+                    return activeSubs.length > 0;
+                case Exclusivities.INACTIVE_SUBSCRIBER:
+                    return activeSubs.length === 0;
+                case Exclusivities.NON_SUBSCRIBER:
+                    return sub.length === 0;
+                default:
+                    return false;
             }
         }
-        return [...new Set(couponCategories)];
+        return true;
     }
-    async getLineItensEligebleForDiscount(productsCategories, checkout) {
-        let lineItensDiscount = [];
-        const couponCategories = await this.getCouponCategoriesId(productsCategories);
-        if (productsCategories && productsCategories.length) {
-            lineItensDiscount = checkout.lineItems?.filter((i) => {
-                if (i.categories?.length) {
-                    return i.categories.some((c) => couponCategories.some((cat) => cat == c));
-                }
-                return true;
+    async getCouponCategoriesId(coupon) {
+        let couponCategories = [];
+        for (let index = 0; index < coupon.productsCategories.length; index++) {
+            let c = await this.categoryRepository.get({
+                id: coupon.productsCategories[index],
             });
+            couponCategories.push({ id: c.id, firestoreId: c.firestoreId });
         }
-        else {
-            lineItensDiscount = checkout.lineItems;
-        }
-        return lineItensDiscount;
-    }
-    calcCheckoutSubtotal(lineItens, user, shop) {
-        return (lineItens?.reduce((acc, curr) => user?.isSubscriber && curr.price.subscriberPrice
-            ? acc + curr.price?.subscriberPrice * curr.quantity
-            : acc + curr.pricePaid * curr.quantity, 0) || 0);
-    }
-    async getOrdersWithCoupon(coupon) {
-        return await this.orderRepository
-            .find({
-            filters: {
-                coupon: { id: coupon.id },
-                payment: { status: 'paid' },
-            },
-        })
-            .then((result) => result.data);
-    }
-    countOrdersWithUser(orders, email) {
-        return orders.filter((o) => o.user.email == email).length;
-    }
-    getCouponUseLimits(coupon, checkoutType, user) {
-        let couponUseLimits;
-        if (checkoutType == CheckoutTypes.ECOMMERCE || checkoutType == CheckoutTypes.ALL) {
-            couponUseLimits = user && user.isSubscriber ? coupon.useLimits.subscriber : coupon.useLimits.non_subscriber;
-        }
-        else {
-            couponUseLimits = coupon.useLimits.subscription;
-        }
-        return couponUseLimits;
+        return couponCategories;
     }
 }
-CouponService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CouponService, deps: [{ token: 'CouponRepository' }, { token: DEFAULT_SHOP }, { token: 'OrderRepository' }, { token: 'CategoryRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
+CouponService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CouponService, deps: [{ token: 'CouponRepository' }, { token: DEFAULT_SHOP }, { token: 'OrderRepository' }, { token: 'SubscriptionRepository' }, { token: 'CategoryRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
 CouponService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CouponService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CouponService, decorators: [{
             type: Injectable,
@@ -1089,12 +271,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImpor
         }], ctorParameters: function () { return [{ type: undefined, decorators: [{
                     type: Inject,
                     args: ['CouponRepository']
-                }] }, { type: i1$3.Shops, decorators: [{
+                }] }, { type: i2.Shops, decorators: [{
                     type: Inject,
                     args: [DEFAULT_SHOP]
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: ['OrderRepository']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['SubscriptionRepository']
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: ['CategoryRepository']
@@ -1131,7 +316,9 @@ class CheckoutService {
         return this.getCheckout().pipe(concatMap(async (checkout) => await this.couponService.calcDiscountShopping(coupon, checkout)));
     }
     checkCoupon(nickname, checkoutType) {
-        return this.getCheckout().pipe(concatMap((checkout) => this.couponService.checkCoupon(nickname, CheckoutTypes.ECOMMERCE, checkout, null).pipe()));
+        return this.getCheckout().pipe(concatMap((checkout) => this.couponService
+            .checkCoupon(nickname, checkout.user?.email, CheckoutTypes.ECOMMERCE, checkout.user.subscriptionPlan, checkout, false)
+            .pipe()));
     }
     async createCheckout(checkoutData) {
         const checkout = await this.checkoutRepository.create({
@@ -1156,24 +343,21 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImpor
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: ['UserRepository']
-                }] }, { type: i1$3.Shops, decorators: [{
+                }] }, { type: i2.Shops, decorators: [{
                     type: Inject,
                     args: [DEFAULT_SHOP]
                 }] }]; } });
 
 class CartService {
-    constructor(authService, checkoutService, defaultShop, productRepository, categoryRepository, variantRepository, buy2WinRepository) {
+    constructor(authService, checkoutService, defaultShop, productRepository) {
         this.authService = authService;
         this.checkoutService = checkoutService;
         this.defaultShop = defaultShop;
         this.productRepository = productRepository;
-        this.categoryRepository = categoryRepository;
-        this.variantRepository = variantRepository;
-        this.buy2WinRepository = buy2WinRepository;
         this.cartSubject = new Subject();
         this.updateLineItemInCart = (lineItem, quantity, checkout) => (isNil(checkout) ? this.checkoutService.getCheckout() : of(checkout)).pipe(concatMap((checkoutLoaded) => {
             const items = [];
-            const index = checkoutLoaded.lineItems?.map((checkoutItem) => checkoutItem.id).indexOf(lineItem.id);
+            const index = checkoutLoaded.lineItems?.map((checkoutItem) => checkoutItem.sku).indexOf(lineItem.sku);
             if (index > -1) {
                 checkoutLoaded.lineItems[index].quantity += quantity;
                 checkoutLoaded.lineItems[index].pricePaid = lineItem.pricePaid;
@@ -1184,27 +368,27 @@ class CartService {
                 .updateCheckoutLineItems(checkoutLoaded)
                 .pipe(map((updatedCheckout) => this.generateCartObject(updatedCheckout.lineItems)));
         }));
-        this.generateCartObject = (items) => items?.reduce((cart, item) => ({
-            ...cart,
-            [item.id]: LineItem.toInstance({
-                ...(cart[item.id] || item),
-                quantity: (cart[item.id]?.quantity || 0) + (item.quantity ? item.quantity : 1),
-            }),
-        }), {}) || {};
+        this.generateCartObject = (items) => {
+            const cart = {};
+            items?.forEach((item) => (cart[item.sku] = LineItem.toInstance({
+                ...(cart[item.sku] || item),
+                quantity: (cart[item.sku]?.quantity || 0) + (item.quantity ? item.quantity : 1),
+            })));
+            return cart;
+        };
         this.buildLineItem = async ({ checkout, item, quantity, }) => {
-            const product = await this.getProductData(item.id);
-            item.quantity = item?.quantity || checkout?.lineItems?.find((lineItem) => lineItem.id === item.id)?.quantity || 0;
+            const product = await this.productRepository.get({ id: item.id });
+            item.quantity = item?.quantity || checkout?.lineItems?.find((lineItem) => lineItem.sku === item.sku)?.quantity || 0;
             if (this.checkMaxStock(item, quantity || 0))
                 throw new Error('Desculpe! Temos apenas ' + item.stock?.quantity + ' em estoque.');
             const image = item.image || item.images?.shift();
-            const { id, name, EAN, slug, stock, price, weight, sku, type } = item;
+            const { id, name, EAN, brand, slug, stock, price, weight, categories, sku, type } = item;
             const isGift = item.isGift || null;
             const pricePaid = this.getProductPrice({
                 product: item,
                 shop: checkout.shop || this.defaultShop,
                 isSubscriber: checkout.user?.isSubscriber,
             });
-            RoundProductPricesHelper.roundProductPrices(item);
             return {
                 checkout,
                 lineItem: LineItem.toInstance({
@@ -1215,7 +399,7 @@ class CartService {
                     slug: slug ?? product.slug,
                     sku: sku ?? product.sku,
                     stock,
-                    price: this.roundPrice(price),
+                    price,
                     image,
                     weight: weight ?? product.weight,
                     quantity: (item.quantity || 0) + (quantity || 0),
@@ -1231,9 +415,7 @@ class CartService {
             const info = product.price;
             if (product.isGift)
                 return 0;
-            return isSubscriber && info.subscriberPrice > 0
-                ? Number(info.subscriberPrice.toFixed(2))
-                : Number(info.price.toFixed(2));
+            return isSubscriber && info.subscriberPrice > 0 ? info.subscriberPrice : info.price;
         };
         this.checkMaxStock = (item, quantity) => {
             const maxStock = item.stock?.quantity || 0;
@@ -1246,7 +428,7 @@ class CartService {
     }
     decreaseItem(item) {
         return this.checkoutService.getCheckout().pipe(map((checkout) => {
-            const checkoutItem = checkout.lineItems?.find((lineItem) => lineItem.id === item.id);
+            const checkoutItem = checkout.lineItems?.find((lineItem) => lineItem.sku === item.sku);
             if (!isNil(checkoutItem))
                 checkoutItem.quantity -= checkoutItem.quantity > 1 ? 1 : 0;
             return checkout;
@@ -1264,21 +446,17 @@ class CartService {
     }
     removeItem(item) {
         return this.checkoutService.getCheckout().pipe(map((checkout) => {
-            const index = checkout.lineItems.findIndex((lineItem) => lineItem.id === item.id);
+            const index = checkout.lineItems.findIndex((lineItem) => lineItem.sku === item.sku);
             if (index >= 0)
                 checkout.lineItems.splice(index, 1);
             return checkout;
         }), concatMap((checkout) => this.checkoutService.updateCheckoutLineItems(checkout)), map((checkout) => this.generateCartObject(checkout.lineItems)), tap((cart) => this.cartSubject.next(cart)));
     }
     updateUserCart(user) {
-        return this.checkoutService.getCheckout().pipe(concatMap((checkout) => this.checkoutService.updateCheckoutUser(Checkout.toInstance({ ...checkout.toPlain(), user }))), concatMap(async (checkout) => this.checkoutService
-            .updateCheckoutLineItems(Checkout.toInstance({
+        return this.checkoutService.getCheckout().pipe(concatMap((checkout) => this.checkoutService.updateCheckoutUser(Checkout.toInstance({ ...checkout.toPlain(), user }))), concatMap(async (checkout) => this.checkoutService.updateCheckoutLineItems(Checkout.toInstance({
             ...checkout.toPlain(),
-            lineItems: checkout.lineItems?.length
-                ? await Promise.all(checkout.lineItems?.map(async (item) => (await this.buildLineItem({ checkout, item })).lineItem))
-                : [],
-        }))
-            .toPromise()), map((checkout) => this.generateCartObject(checkout.lineItems)), tap((cart) => this.cartSubject.next(cart)));
+            lineItems: checkout.lineItems?.length ? await Promise.all(checkout.lineItems?.map(async (item) => (await this.buildLineItem({ checkout, item })).lineItem)) : [],
+        })).toPromise()), map(checkout => this.generateCartObject(checkout.lineItems)), tap((cart) => this.cartSubject.next(cart)));
     }
     clearCart() {
         return this.checkoutService.getCheckout().pipe(map((checkout) => {
@@ -1289,484 +467,19 @@ class CartService {
     buildCartFromCheckout(checkoutData) {
         return this.checkoutService.getCheckout(checkoutData).pipe(map((checkout) => checkout.lineItems), concatMap((lineItems) => of(this.generateCartObject(lineItems))));
     }
-    roundPrice(productPrice) {
-        const { price, fullPrice, subscriberPrice } = productPrice;
-        return {
-            ...productPrice,
-            price: Number(price.toFixed(2)),
-            fullPrice: Number(fullPrice.toFixed(2)),
-            ...(subscriberPrice && { subscriberPrice: Number(subscriberPrice.toFixed(2)) }),
-        };
-    }
-    async getProductData(productId) {
-        let product;
-        let variant;
-        try {
-            product = await this.productRepository.get({ id: productId });
-        }
-        catch (error) {
-            if (!(error instanceof NotFoundError))
-                throw error;
-            const { data: variants } = await this.variantRepository.find({ filters: { id: productId } });
-            variant = variants.shift();
-            if (!variant)
-                throw error;
-            product = await this.productRepository.get({ id: variant.productId });
-        }
-        return {
-            ...product.toPlain(),
-            ...(variant && { ...variant.toPlain() }),
-        };
-    }
-    getGifts() {
-        return this.checkoutService.getCheckout().pipe(mergeMap(async (checkout) => {
-            const notGiftItems = checkout.lineItems ? checkout.lineItems.filter((item) => !item.isGift) : [];
-            if (!notGiftItems.length)
-                return { ...checkout, lineItems: [] };
-            const cartTotal = notGiftItems.reduce((a, b) => a + b.pricePaid * b.quantity, 0);
-            const campaigns = await this.buy2WinRepository
-                .find({
-                filters: {
-                    active: { operator: Where.EQUALS, value: true },
-                    shop: { operator: Where.EQUALS, value: this.defaultShop },
-                },
-            })
-                .then((data) => data.data);
-            if (!campaigns.length)
-                return { ...checkout, lineItems: notGiftItems };
-            const elegibleCampaigns = [];
-            for (const campaign of campaigns) {
-                const today = new Date().getDate();
-                if (!(campaign.startDate.getDate() <= today) && !(campaign.endDate.getDate() >= today))
-                    continue;
-                if (campaign.activeCategory) {
-                    const categoriesCampaing = campaign.categories.map((c) => c.id.toString());
-                    const categoriesCampaingFullTree = [];
-                    for (const id of categoriesCampaing) {
-                        const children = await this.categoryRepository.getChildren(parseInt(id));
-                        categoriesCampaingFullTree.push(id, ...children.map((c) => c.id.toString()));
-                    }
-                    const categoriesCampaingTree = [...new Set(categoriesCampaingFullTree)];
-                    const filterProductsCategories = checkout.lineItems.filter((l) => {
-                        if (!l.categories || !l.categories?.length)
-                            return true;
-                        return l.categories.some((c) => categoriesCampaingTree.some((cat) => cat == c));
-                    });
-                    if (filterProductsCategories.length) {
-                        const cartTotalCategories = filterProductsCategories.reduce((a, b) => a + b.pricePaid * b.quantity, 0);
-                        if (cartTotalCategories >= campaign.cartValueMin)
-                            elegibleCampaigns.push(campaign);
-                    }
-                }
-                else {
-                    if (campaign.cartValue && campaign.cartValue > 0) {
-                        if (campaign.cartValue <= cartTotal)
-                            elegibleCampaigns.push(campaign);
-                    }
-                }
-            }
-            if (!elegibleCampaigns.length)
-                return { ...checkout, lineItems: notGiftItems };
-            const campaingnProducts = [];
-            for (const campaign of elegibleCampaigns) {
-                let elegibleProducts = [];
-                for (const product of campaign.products) {
-                    const { data: productData } = await this.productRepository.find({ filters: { sku: product } });
-                    if (!productData.length)
-                        continue;
-                    const gift = productData.shift();
-                    if (gift.stock.quantity < 1)
-                        continue;
-                    elegibleProducts.push(gift);
-                }
-                campaingnProducts.push(elegibleProducts);
-            }
-            if (!campaingnProducts.length)
-                return { ...checkout, lineItems: notGiftItems };
-            const gifts = this.giftToLineItems([].concat(...campaingnProducts));
-            return { ...checkout, lineItems: notGiftItems.concat(gifts) };
-        }), concatMap((checkout) => this.checkoutService.updateCheckoutLineItems(checkout)), map((checkout) => this.generateCartObject(checkout.lineItems)), tap((cart) => this.cartSubject.next(cart)));
-    }
-    giftToLineItems(items) {
-        return items.map((item) => {
-            const { brand, categories, id, name, price, sku, slug, stock, weight, EAN } = item;
-            const image = item?.miniatures?.length ? item.miniatures[0] : item.images[0];
-            return LineItem.toInstance({
-                brand,
-                categories,
-                id: id.toString(),
-                name,
-                price,
-                sku,
-                slug,
-                stock,
-                weight,
-                EAN,
-                image,
-                pricePaid: 0,
-                quantity: 1,
-                isGift: true,
-            });
-        });
-    }
 }
-CartService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CartService, deps: [{ token: AuthService }, { token: CheckoutService }, { token: DEFAULT_SHOP }, { token: 'ProductRepository' }, { token: 'CategoryRepository' }, { token: 'VariantRepository' }, { token: 'Buy2WinRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
+CartService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CartService, deps: [{ token: AuthService }, { token: CheckoutService }, { token: DEFAULT_SHOP }, { token: 'ProductRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
 CartService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CartService });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CartService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: AuthService }, { type: CheckoutService }, { type: i1$3.Shops, decorators: [{
+        }], ctorParameters: function () { return [{ type: AuthService }, { type: CheckoutService }, { type: i2.Shops, decorators: [{
                     type: Inject,
                     args: [DEFAULT_SHOP]
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: ['ProductRepository']
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['CategoryRepository']
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['VariantRepository']
-                }] }, { type: i1$3.Buy2WinFirestoreRepository, decorators: [{
-                    type: Inject,
-                    args: ['Buy2WinRepository']
-                }] }]; } });
-
-class CatalogService {
-    constructor(productRepository, categoryStructureAdapter, shop) {
-        this.productRepository = productRepository;
-        this.categoryStructureAdapter = categoryStructureAdapter;
-        this.shop = shop;
-        this.buildFilterQuery = ({ clubDiscount, brands, prices, gender, tags, rate, customOptions, }) => {
-            const filters = {};
-            if (clubDiscount?.length)
-                set(filters, 'price.subscriberDiscountPercentage', { operator: Where.IN, value: clubDiscount });
-            if (brands?.length)
-                filters.brand = { operator: Where.IN, value: brands };
-            if (gender?.length)
-                filters.tags = {
-                    operator: Where.IN,
-                    value: gender
-                        .map((genderOptions) => genderOptions === 'female' ? 'feminino' : genderOptions === 'male' ? 'masculino' : null)
-                        .filter(Boolean),
-                };
-            if (prices?.min || prices?.max)
-                set(filters, prices.subscriberPrice ? 'price.subscriberPrice' : 'price.price', [
-                    ...(prices.min ? [{ operator: Where.GTE, value: Math.round(prices.min) }] : []),
-                    ...(prices.max ? [{ operator: Where.LTE, value: Math.ceil(prices.max) }] : []),
-                ]);
-            if (rate)
-                filters.rate = { operator: Where.GTE, value: rate };
-            if (tags?.length)
-                filters.tags = { operator: Where.LIKE, value: tags };
-            if (customOptions?.length)
-                filters.filters = { operator: Where.LIKE, value: customOptions };
-            return filters;
-        };
-        this.buildSortQuery = (sort) => {
-            if (!sort || sort === 'most-relevant')
-                return {};
-            if (sort === 'best-sellers')
-                return { shoppingCount: 'desc' };
-            if (sort === 'biggest-price')
-                return { price: 'desc' };
-            if (sort === 'lowest-price')
-                return { price: 'asc' };
-            if (sort === 'best-rating')
-                return { rate: 'desc' };
-            if (sort === 'news')
-                return { createdAt: 'desc' };
-        };
-        this.buildLimitQuery = (options) => {
-            const limit = options?.perPage || 20;
-            return {
-                limit,
-                offset: ((options?.page || 1) - 1) * limit,
-            };
-        };
-    }
-    async fetchProducts(category, options) {
-        const limits = this.buildLimitQuery(options);
-        return await this.productRepository
-            .findCatalog({
-            filters: {
-                ...(await this.categoryStructureAdapter.buildProductFilterByCategory(category)),
-                ...this.buildFilterQuery(options?.filters || {}),
-            },
-            ...(options?.sort ? { orderBy: this.buildSortQuery(options?.sort) } : {}),
-            limits,
-            options: { minimal: ['price'], maximum: ['price'] },
-        }, options?.mainGender || this.shop === Shops.MENSMARKET ? 'male' : 'female')
-            .then(({ data, count: total, maximum, minimal }) => ({
-            products: { data: data.map((product) => RoundProductPricesHelper.roundProductPrices(product)), total },
-            pages: Math.ceil(total / limits.limit),
-            prices: {
-                price: { min: +minimal?.price?.price?.toFixed(2), max: +maximum?.price?.price?.toFixed(2) },
-                subscriberPrice: {
-                    min: +minimal?.price?.subscriberPrice?.toFixed(2),
-                    max: +maximum?.price?.subscriberPrice?.toFixed(2),
-                },
-            },
-        }));
-    }
-}
-CatalogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogService, deps: [{ token: 'ProductRepository' }, { token: CATEGORY_STRUCTURE }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['ProductRepository']
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [CATEGORY_STRUCTURE]
-                }] }, { type: i1$3.Shops, decorators: [{
-                    type: Inject,
-                    args: [DEFAULT_SHOP]
-                }] }]; } });
-
-class CategoryService {
-    constructor(productRepository, categoryRepository, categoryFilterRepository, categoryStructureAdapter, shop) {
-        this.productRepository = productRepository;
-        this.categoryRepository = categoryRepository;
-        this.categoryFilterRepository = categoryFilterRepository;
-        this.categoryStructureAdapter = categoryStructureAdapter;
-        this.shop = shop;
-    }
-    async fetchBrands(category, mainGender) {
-        const brands = await this.productRepository
-            .findCatalog({
-            filters: await this.categoryStructureAdapter.buildProductFilterByCategory(category),
-            fields: ['brand'],
-        }, mainGender || this.shop === Shops.MENSMARKET ? 'male' : 'female')
-            .then(({ data }) => Object.keys(data.map((product) => product.brand).reduce((brands, brand) => ({ ...brands, [brand]: true }), {})));
-        return this.categoryRepository
-            .find({ filters: { brandCategory: true }, orderBy: { name: 'asc' } })
-            .then(({ data }) => data.filter((category) => brands.includes(category.conditions.brand)));
-    }
-    async fetchFilterOptions(category, filters) {
-        return await this.categoryFilterRepository
-            .find({ filters: { categoryId: +category.id } })
-            .then(({ data }) => data.map((categoryFilter) => categoryFilter.filter));
-    }
-}
-CategoryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryService, deps: [{ token: 'ProductRepository' }, { token: 'CategoryRepository' }, { token: 'CategoryFilterRepository' }, { token: CATEGORY_STRUCTURE }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable });
-CategoryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['ProductRepository']
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['CategoryRepository']
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['CategoryFilterRepository']
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [CATEGORY_STRUCTURE]
-                }] }, { type: i1$3.Shops, decorators: [{
-                    type: Inject,
-                    args: [DEFAULT_SHOP]
-                }] }]; } });
-
-var ProductSorts;
-(function (ProductSorts) {
-    ProductSorts["MOST_RELEVANT"] = "most-relevant";
-    ProductSorts["BEST_SELLER"] = "best-sellers";
-    ProductSorts["BIGGEST_PRICE"] = "biggest-price";
-    ProductSorts["LOWEST_PRICE"] = "lowest-price";
-    ProductSorts["BIGGEST_DISCOUNT"] = "biggest-discount";
-    ProductSorts["BEST_RATING"] = "best-rating";
-    ProductSorts["NEWS"] = "news";
-})(ProductSorts || (ProductSorts = {}));
-
-class CategoryWithTree extends Category {
-}
-__decorate([
-    Type(() => CategoryWithTree),
-    __metadata("design:type", Array)
-], CategoryWithTree.prototype, "children", void 0);
-
-class UtilService {
-    constructor() { }
-    createSlug(name) {
-        return name
-            .toLowerCase()
-            .replace(/\s+/g, '-') // Replace spaces with -
-            .replace(/[ãàáäâ]/g, 'a') // Replace spaces with -
-            .replace(/[ẽèéëê]/g, 'e') // Replace spaces with -
-            .replace(/[ìíïî]/g, 'i') // Replace spaces with -
-            .replace(/[õòóöô]/g, 'o') // Replace spaces with -
-            .replace(/[ùúüû]/g, 'u') // Replace spaces with -
-            .replace(/[ñ]/g, 'n') // Replace spaces with -
-            .replace(/[ç]/g, 'c') // Replace spaces with -
-            .replace(/[&]/g, 'and') // Replace spaces with -
-            .replace(/[^\w\-]+/g, '') // Remove all non-word chars
-            .replace(/\-\-+/g, '-'); // Replace multiple - with single -
-    }
-}
-UtilService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: UtilService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-UtilService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: UtilService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: UtilService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return []; } });
-
-class NewCategoryStructureAdapter {
-    constructor(categoryRepository, categoryCollectionChildrenRepository) {
-        this.categoryRepository = categoryRepository;
-        this.categoryCollectionChildrenRepository = categoryCollectionChildrenRepository;
-    }
-    async buildProductFilterByCategory(category) {
-        const categoriesIds = (await this.isCollection(category))
-            ? await this.getAllCategoriesIdFromCollection(category)
-            : [...(await this.getAllCategoriesIdFromCategory(category)), category.id.toString()];
-        return { category: { id: { operator: Where.IN, value: categoriesIds } } };
-    }
-    async getAllCategoriesIdFromCategory(category) {
-        return this.categoryRepository
-            .getChildren(+category.id)
-            .then((categories) => categories.map((category) => category.id.toString()));
-    }
-    async getAllCategoriesIdFromCollection(category) {
-        return this.categoryCollectionChildrenRepository
-            .find({ filters: { collectionId: +category.id } })
-            .then(({ data }) => data.map((categoryCollection) => categoryCollection.categoryId.toString()));
-    }
-    async isCollection(category) {
-        return !isNil(category.isCollection)
-            ? category.isCollection
-            : this.categoryRepository.get({ id: category.id }).then((category) => category.isCollection);
-    }
-}
-NewCategoryStructureAdapter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: NewCategoryStructureAdapter, deps: [{ token: 'CategoryRepository' }, { token: 'CategoryCollectionChildrenRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-NewCategoryStructureAdapter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: NewCategoryStructureAdapter });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: NewCategoryStructureAdapter, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['CategoryRepository']
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['CategoryCollectionChildrenRepository']
-                }] }]; } });
-
-class OldCategoryStructureAdapter {
-    constructor(categoryRepository) {
-        this.categoryRepository = categoryRepository;
-    }
-    async buildProductFilterByCategory(category) {
-        const productsIds = category.products?.length
-            ? category.products
-            : await this.categoryRepository.get({ id: category.id }).then((categoryFound) => categoryFound.products);
-        return { id: { operator: Where.IN, value: productsIds } };
-    }
-}
-OldCategoryStructureAdapter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OldCategoryStructureAdapter, deps: [{ token: 'CategoryRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-OldCategoryStructureAdapter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OldCategoryStructureAdapter });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OldCategoryStructureAdapter, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['CategoryRepository']
                 }] }]; } });
 
-class WishlistService {
-    constructor(wishlistRepository, productRepository, categoryFilterRepository, categoryCollectionChildrenRepository, categoryStructureAdapter = new NewCategoryStructureAdapter(wishlistRepository, categoryCollectionChildrenRepository), shop, catalogService = new CatalogService(productRepository, categoryStructureAdapter, shop), categoryService = new CategoryService(productRepository, wishlistRepository, categoryFilterRepository, categoryStructureAdapter, shop), utilService) {
-        this.wishlistRepository = wishlistRepository;
-        this.shop = shop;
-        this.catalogService = catalogService;
-        this.categoryService = categoryService;
-        this.utilService = utilService;
-    }
-    getCatalogService() {
-        return this.catalogService;
-    }
-    getCategoryService() {
-        return this.categoryService;
-    }
-    async create(personId, title, description, userFullName) {
-        const data = {
-            slug: this.utilService.createSlug(`favoritos ${userFullName} ${title}`),
-            name: title,
-            description,
-            metadata: {
-                title: `${userFullName} - ${title}`,
-                description: `${userFullName} - ${description}`,
-            },
-            shop: this.shop,
-            shops: [this.shop],
-            personId,
-            brandCategory: false,
-            published: true,
-        };
-        const newWishlist = await this.wishlistRepository.create(data);
-        return this.wishlistRepository.update({ id: newWishlist.id, slug: `${newWishlist.id}-${newWishlist.slug}` });
-    }
-    update(id, title, description, userFullName) {
-        const data = {
-            id,
-            slug: this.utilService.createSlug(`${id}-favoritos ${userFullName} ${title}`),
-            name: title,
-            description,
-            metadata: {
-                title: `${userFullName} - ${title}`,
-                description: `${userFullName} - ${description}`,
-            },
-        };
-        return this.wishlistRepository.update(data);
-    }
-    delete(wishlistId) {
-        return this.wishlistRepository.delete({ id: wishlistId });
-    }
-    getWishlistBySlug(slug) {
-        return this.wishlistRepository.getWishlistBySlug(slug);
-    }
-    getWishlistsByPerson(personId) {
-        return this.wishlistRepository.getWishlistByPerson(personId);
-    }
-    async addProduct(wishlistId, productId) {
-        const wishlist = await this.wishlistRepository.get({ id: wishlistId });
-        const hasProduct = wishlist.products.some((p) => p == productId);
-        if (!hasProduct) {
-            wishlist.products = [...wishlist.products, productId];
-            return this.wishlistRepository.update({ id: wishlistId, products: wishlist.products });
-        }
-        return wishlist;
-    }
-    async removeProduct(wishlistId, productId) {
-        const wishlist = await this.wishlistRepository.get({ id: wishlistId });
-        const productIndex = wishlist.products.findIndex((p) => p == productId);
-        if (productIndex != -1) {
-            wishlist.products.splice(productIndex, 1);
-            if (!wishlist.products.length)
-                return this.wishlistRepository.update({ id: wishlistId, products: { action: 'remove' } });
-            return this.wishlistRepository.update({ id: wishlistId, products: wishlist.products });
-        }
-        return wishlist;
-    }
-}
-WishlistService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: WishlistService, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
-WishlistService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: WishlistService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: WishlistService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['WishlistRepository']
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['ProductRepository']
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['CategoryFilterRepository']
-                }] }, { type: undefined }, { type: undefined }, { type: i1$3.Shops, decorators: [{
-                    type: Inject,
-                    args: [DEFAULT_SHOP]
-                }] }, { type: undefined }, { type: undefined }, { type: UtilService }]; } });
-
 class CheckoutSubscriptionService {
     constructor(checkoutSubscriptionRepository, subscriptionRepository, couponService) {
         this.checkoutSubscriptionRepository = checkoutSubscriptionRepository;
@@ -1792,9 +505,7 @@ class CheckoutSubscriptionService {
         return of();
     }
     checkCoupon(nickname, userEmail) {
-        return this.getCheckoutSubscription().pipe(concatMap((checkout) => this.couponService
-            .checkCoupon(nickname, CheckoutTypes.SUBSCRIPTION, checkout, checkout.subscriptionPlan.name)
-            .pipe()));
+        return this.getCheckoutSubscription().pipe(concatMap((checkout) => this.couponService.checkCoupon(nickname, userEmail, CheckoutTypes.SUBSCRIPTION, checkout.subscriptionPlan.name, null, true).pipe()));
     }
     calcDiscountSubscription(coupon) {
         return this.getCheckoutSubscription().pipe(concatMap((checkout) => this.couponService.calcDiscountSubscription(coupon, checkout).pipe()));
@@ -1812,6 +523,28 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImpor
                     args: ['SubscriptionRepository']
                 }] }, { type: CouponService }]; } });
 
+class OrderService {
+    constructor(angularFirestore, orderRepository) {
+        this.angularFirestore = angularFirestore;
+        this.orderRepository = orderRepository;
+        this.orderSubject = new Subject();
+    }
+    getOrder(id) {
+        docSnapshots(doc(this.angularFirestore, `${this.orderRepository.collectionName}/${id}`))
+            .pipe(map((doc) => Order.toInstance(doc.data())))
+            .subscribe((doc) => this.orderSubject.next(doc));
+        return this.orderSubject;
+    }
+}
+OrderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OrderService, deps: [{ token: i1$1.Firestore }, { token: 'OrderRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
+OrderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OrderService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OrderService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1$1.Firestore }, { type: i2.OrderFirestoreRepository, decorators: [{
+                    type: Inject,
+                    args: ['OrderRepository']
+                }] }]; } });
+
 class HomeShopService {
     constructor(categoryRepository, homeRepository, productRepository, defaultShop) {
         this.categoryRepository = categoryRepository;
@@ -1914,136 +647,663 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImpor
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: ['ProductRepository']
-                }] }, { type: i1$3.Shops, decorators: [{
+                }] }, { type: i2.Shops, decorators: [{
                     type: Inject,
                     args: [DEFAULT_SHOP]
                 }] }]; } });
 
-class OrderService {
-    constructor(angularFirestore, orderRepository) {
-        this.angularFirestore = angularFirestore;
-        this.orderRepository = orderRepository;
-        this.orderSubject = new Subject();
+class AngularFirebaseAuthModule {
+    static initializeApp(options, nameOrConfig) {
+        return {
+            ngModule: AngularFirebaseAuthModule,
+            providers: [
+                { provide: FIREBASE_OPTIONS, useValue: options },
+                { provide: FIREBASE_APP_NAME, useValue: nameOrConfig },
+            ],
+        };
     }
-    getOrder(id) {
-        docSnapshots(doc(this.angularFirestore, `${this.orderRepository.collectionName}/${id}`))
-            .pipe(map((doc) => Order.toInstance(doc.data())))
-            .subscribe((doc) => this.orderSubject.next(doc));
-        return this.orderSubject;
+}
+AngularFirebaseAuthModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirebaseAuthModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AngularFirebaseAuthModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularFirebaseAuthModule, imports: [i1$2.FirebaseAppModule, i1.AuthModule] });
+AngularFirebaseAuthModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirebaseAuthModule, providers: [
+        {
+            provide: 'Authentication',
+            useFactory: (authenticationService, userRepository) => {
+                return new Authentication(authenticationService, userRepository);
+            },
+            deps: ['AuthenticationService', 'UserRepository'],
+        },
+        {
+            provide: 'AuthenticationService',
+            useFactory: (angularFireAuth) => {
+                return new AuthenticationFirebaseAuthService(angularFireAuth);
+            },
+            deps: [Auth],
+        },
+        {
+            provide: 'Register',
+            useFactory: (registerService, userRepository) => {
+                return new Register(registerService, userRepository);
+            },
+            deps: ['RegisterService', 'UserRepository'],
+        },
+        {
+            provide: 'RegisterService',
+            useFactory: (angularFireAuth) => {
+                return new RegisterFirebaseAuthService(angularFireAuth);
+            },
+            deps: [Auth],
+        },
+        {
+            provide: 'SignOut',
+            useFactory: (authenticationService) => {
+                return new SignOut(authenticationService);
+            },
+            deps: ['AuthenticationService'],
+        },
+        {
+            provide: 'RecoveryPassword',
+            useFactory: (authenticationService) => {
+                return new RecoveryPassword(authenticationService);
+            },
+            deps: ['AuthenticationService'],
+        },
+    ], imports: [provideFirebaseApp((injector) => {
+            const appName = injector.get(FIREBASE_APP_NAME);
+            return appName
+                ? initializeApp(injector.get(FIREBASE_OPTIONS), appName)
+                : initializeApp(injector.get(FIREBASE_OPTIONS));
+        }),
+        provideAuth(() => getAuth())] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirebaseAuthModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        provideFirebaseApp((injector) => {
+                            const appName = injector.get(FIREBASE_APP_NAME);
+                            return appName
+                                ? initializeApp(injector.get(FIREBASE_OPTIONS), appName)
+                                : initializeApp(injector.get(FIREBASE_OPTIONS));
+                        }),
+                        provideAuth(() => getAuth()),
+                    ],
+                    providers: [
+                        {
+                            provide: 'Authentication',
+                            useFactory: (authenticationService, userRepository) => {
+                                return new Authentication(authenticationService, userRepository);
+                            },
+                            deps: ['AuthenticationService', 'UserRepository'],
+                        },
+                        {
+                            provide: 'AuthenticationService',
+                            useFactory: (angularFireAuth) => {
+                                return new AuthenticationFirebaseAuthService(angularFireAuth);
+                            },
+                            deps: [Auth],
+                        },
+                        {
+                            provide: 'Register',
+                            useFactory: (registerService, userRepository) => {
+                                return new Register(registerService, userRepository);
+                            },
+                            deps: ['RegisterService', 'UserRepository'],
+                        },
+                        {
+                            provide: 'RegisterService',
+                            useFactory: (angularFireAuth) => {
+                                return new RegisterFirebaseAuthService(angularFireAuth);
+                            },
+                            deps: [Auth],
+                        },
+                        {
+                            provide: 'SignOut',
+                            useFactory: (authenticationService) => {
+                                return new SignOut(authenticationService);
+                            },
+                            deps: ['AuthenticationService'],
+                        },
+                        {
+                            provide: 'RecoveryPassword',
+                            useFactory: (authenticationService) => {
+                                return new RecoveryPassword(authenticationService);
+                            },
+                            deps: ['AuthenticationService'],
+                        },
+                    ],
+                }]
+        }] });
+
+class AngularElasticSeachModule {
+    static initializeApp(options) {
+        return {
+            ngModule: AngularElasticSeachModule,
+            providers: [{ provide: ES_CONFIG, useValue: options }],
+        };
     }
 }
-OrderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OrderService, deps: [{ token: i1$2.Firestore }, { token: 'OrderRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-OrderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OrderService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OrderService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i1$2.Firestore }, { type: i1$3.OrderFirestoreRepository, decorators: [{
-                    type: Inject,
-                    args: ['OrderRepository']
-                }] }]; } });
+AngularElasticSeachModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularElasticSeachModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AngularElasticSeachModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularElasticSeachModule });
+AngularElasticSeachModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularElasticSeachModule, providers: [
+        {
+            provide: ProductsIndex,
+            useFactory: (configuration) => {
+                return new ProductsIndex(new AxiosAdapter(configuration));
+            },
+            deps: [ES_CONFIG],
+        },
+    ] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularElasticSeachModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        {
+                            provide: ProductsIndex,
+                            useFactory: (configuration) => {
+                                return new ProductsIndex(new AxiosAdapter(configuration));
+                            },
+                            deps: [ES_CONFIG],
+                        },
+                    ],
+                }]
+        }] });
+
+class AngularFirestoreModule {
+    static initializeApp(options, nameOrConfig) {
+        return {
+            ngModule: AngularFirestoreModule,
+            providers: [
+                { provide: FIREBASE_OPTIONS, useValue: options.firebase },
+                { provide: FIREBASE_APP_NAME, useValue: nameOrConfig },
+                { provide: ES_CONFIG, useValue: options.elasticSearch },
+            ],
+        };
+    }
+}
+AngularFirestoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirestoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AngularFirestoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularFirestoreModule, imports: [AngularElasticSeachModule, i1$2.FirebaseAppModule, i1$1.FirestoreModule] });
+AngularFirestoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirestoreModule, providers: [
+        {
+            provide: 'BeautyProfileRepository',
+            useFactory: (firestore, userRepository) => {
+                return new UserBeautyProfileFirestoreRepository(firestore, userRepository);
+            },
+            deps: [Firestore, 'UserRepository'],
+        },
+        {
+            provide: 'Buy2WinRepository',
+            useFactory: (firestore) => {
+                return new Buy2WinFirestoreRepository(firestore);
+            },
+            deps: [Firestore],
+        },
+        {
+            provide: CategoryFirestoreRepository,
+            useFactory: (firestore) => {
+                return new CategoryFirestoreRepository(firestore);
+            },
+            deps: [Firestore],
+        },
+        {
+            provide: 'CheckoutRepository',
+            useFactory: (firestore) => {
+                return new CheckoutFirestoreRepository(firestore);
+            },
+            deps: [Firestore],
+        },
+        {
+            provide: 'CheckoutSubscriptionRepository',
+            useFactory: (firestore) => {
+                return new CheckoutSubscriptionFirestoreRepository(firestore);
+            },
+            deps: [Firestore],
+        },
+        {
+            provide: 'CouponRepository',
+            useFactory: (firestore) => {
+                return new CouponFirestoreRepository(firestore);
+            },
+            deps: [Firestore],
+        },
+        {
+            provide: 'EditionRepository',
+            useFactory: (firestore, subscriptionRepository) => {
+                return new SubscriptionEditionFirestoreRepository(firestore, subscriptionRepository);
+            },
+            deps: [Firestore, 'SubscriptionRepository'],
+        },
+        {
+            provide: 'HomeRepository',
+            useFactory: (firestore) => {
+                return new HomeFirestoreRepository(firestore);
+            },
+            deps: [Firestore],
+        },
+        {
+            provide: 'LeadRepository',
+            useFactory: (firestore) => {
+                return new LeadFirestoreRepository(firestore);
+            },
+            deps: [Firestore],
+        },
+        {
+            provide: 'LegacyOrderRepository',
+            useFactory: (firestore) => {
+                return new LegacyOrderFirestoreRepository(firestore);
+            },
+            deps: [Firestore],
+        },
+        {
+            provide: 'ShopMenuRepository',
+            useFactory: (firestore) => {
+                return new ShopMenuFirestoreRepository(firestore);
+            },
+            deps: [Firestore],
+        },
+        {
+            provide: 'OrderRepository',
+            useFactory: (firestore) => {
+                return new OrderFirestoreRepository(firestore);
+            },
+            deps: [Firestore],
+        },
+        {
+            provide: 'PaymentRepository',
+            useFactory: (firestore) => {
+                return new PaymentFirestoreRepository(firestore);
+            },
+            deps: [Firestore],
+        },
+        {
+            provide: ProductFirestoreRepository,
+            useFactory: (firestore) => {
+                return new ProductFirestoreRepository(firestore);
+            },
+            deps: [Firestore],
+        },
+        {
+            provide: 'SubscriptionPaymentRepository',
+            useFactory: (firestore, subscriptionRepository) => {
+                return new SubscriptionPaymentFirestoreRepository(firestore, subscriptionRepository);
+            },
+            deps: [Firestore, 'SubscriptionRepository'],
+        },
+        {
+            provide: 'SubscriptionPlanRepository',
+            useFactory: (firestore) => {
+                return new SubscriptionPlanFirestoreRepository(firestore);
+            },
+            deps: [Firestore],
+        },
+        {
+            provide: 'SubscriptionProductRepository',
+            useFactory: (firestore) => {
+                return new SubscriptionProductFirestoreRepository(firestore);
+            },
+            deps: [Firestore],
+        },
+        {
+            provide: 'SubscriptionRepository',
+            useFactory: (firestore) => {
+                return new SubscriptionFirestoreRepository(firestore);
+            },
+            deps: [Firestore],
+        },
+        {
+            provide: 'UserRepository',
+            useFactory: (firestore) => {
+                return new UserFirestoreRepository(firestore);
+            },
+            deps: [Firestore],
+        },
+        {
+            provide: 'UserAddressRepository',
+            useFactory: (firestore, userRepository) => {
+                return new UserAddressFirestoreRepository(firestore, userRepository);
+            },
+            deps: [Firestore, 'UserRepository'],
+        },
+        {
+            provide: 'UserPaymentMethodRepository',
+            useFactory: (firestore, userRepository) => {
+                return new UserPaymentMethodFirestoreRepository(firestore, userRepository);
+            },
+            deps: [Firestore, 'UserRepository'],
+        },
+        {
+            provide: ProductVariantFirestoreRepository,
+            useFactory: (firestore, productRepository) => {
+                return new ProductVariantFirestoreRepository(firestore, productRepository);
+            },
+            deps: [Firestore, ProductFirestoreRepository],
+        },
+    ], imports: [AngularElasticSeachModule,
+        provideFirebaseApp((injector) => {
+            const appName = injector.get(FIREBASE_APP_NAME);
+            return appName
+                ? initializeApp(injector.get(FIREBASE_OPTIONS), appName)
+                : initializeApp(injector.get(FIREBASE_OPTIONS));
+        }),
+        provideFirestore(() => getFirestore())] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirestoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AngularElasticSeachModule,
+                        provideFirebaseApp((injector) => {
+                            const appName = injector.get(FIREBASE_APP_NAME);
+                            return appName
+                                ? initializeApp(injector.get(FIREBASE_OPTIONS), appName)
+                                : initializeApp(injector.get(FIREBASE_OPTIONS));
+                        }),
+                        provideFirestore(() => getFirestore()),
+                    ],
+                    providers: [
+                        {
+                            provide: 'BeautyProfileRepository',
+                            useFactory: (firestore, userRepository) => {
+                                return new UserBeautyProfileFirestoreRepository(firestore, userRepository);
+                            },
+                            deps: [Firestore, 'UserRepository'],
+                        },
+                        {
+                            provide: 'Buy2WinRepository',
+                            useFactory: (firestore) => {
+                                return new Buy2WinFirestoreRepository(firestore);
+                            },
+                            deps: [Firestore],
+                        },
+                        {
+                            provide: CategoryFirestoreRepository,
+                            useFactory: (firestore) => {
+                                return new CategoryFirestoreRepository(firestore);
+                            },
+                            deps: [Firestore],
+                        },
+                        {
+                            provide: 'CheckoutRepository',
+                            useFactory: (firestore) => {
+                                return new CheckoutFirestoreRepository(firestore);
+                            },
+                            deps: [Firestore],
+                        },
+                        {
+                            provide: 'CheckoutSubscriptionRepository',
+                            useFactory: (firestore) => {
+                                return new CheckoutSubscriptionFirestoreRepository(firestore);
+                            },
+                            deps: [Firestore],
+                        },
+                        {
+                            provide: 'CouponRepository',
+                            useFactory: (firestore) => {
+                                return new CouponFirestoreRepository(firestore);
+                            },
+                            deps: [Firestore],
+                        },
+                        {
+                            provide: 'EditionRepository',
+                            useFactory: (firestore, subscriptionRepository) => {
+                                return new SubscriptionEditionFirestoreRepository(firestore, subscriptionRepository);
+                            },
+                            deps: [Firestore, 'SubscriptionRepository'],
+                        },
+                        {
+                            provide: 'HomeRepository',
+                            useFactory: (firestore) => {
+                                return new HomeFirestoreRepository(firestore);
+                            },
+                            deps: [Firestore],
+                        },
+                        {
+                            provide: 'LeadRepository',
+                            useFactory: (firestore) => {
+                                return new LeadFirestoreRepository(firestore);
+                            },
+                            deps: [Firestore],
+                        },
+                        {
+                            provide: 'LegacyOrderRepository',
+                            useFactory: (firestore) => {
+                                return new LegacyOrderFirestoreRepository(firestore);
+                            },
+                            deps: [Firestore],
+                        },
+                        {
+                            provide: 'ShopMenuRepository',
+                            useFactory: (firestore) => {
+                                return new ShopMenuFirestoreRepository(firestore);
+                            },
+                            deps: [Firestore],
+                        },
+                        {
+                            provide: 'OrderRepository',
+                            useFactory: (firestore) => {
+                                return new OrderFirestoreRepository(firestore);
+                            },
+                            deps: [Firestore],
+                        },
+                        {
+                            provide: 'PaymentRepository',
+                            useFactory: (firestore) => {
+                                return new PaymentFirestoreRepository(firestore);
+                            },
+                            deps: [Firestore],
+                        },
+                        {
+                            provide: ProductFirestoreRepository,
+                            useFactory: (firestore) => {
+                                return new ProductFirestoreRepository(firestore);
+                            },
+                            deps: [Firestore],
+                        },
+                        {
+                            provide: 'SubscriptionPaymentRepository',
+                            useFactory: (firestore, subscriptionRepository) => {
+                                return new SubscriptionPaymentFirestoreRepository(firestore, subscriptionRepository);
+                            },
+                            deps: [Firestore, 'SubscriptionRepository'],
+                        },
+                        {
+                            provide: 'SubscriptionPlanRepository',
+                            useFactory: (firestore) => {
+                                return new SubscriptionPlanFirestoreRepository(firestore);
+                            },
+                            deps: [Firestore],
+                        },
+                        {
+                            provide: 'SubscriptionProductRepository',
+                            useFactory: (firestore) => {
+                                return new SubscriptionProductFirestoreRepository(firestore);
+                            },
+                            deps: [Firestore],
+                        },
+                        {
+                            provide: 'SubscriptionRepository',
+                            useFactory: (firestore) => {
+                                return new SubscriptionFirestoreRepository(firestore);
+                            },
+                            deps: [Firestore],
+                        },
+                        {
+                            provide: 'UserRepository',
+                            useFactory: (firestore) => {
+                                return new UserFirestoreRepository(firestore);
+                            },
+                            deps: [Firestore],
+                        },
+                        {
+                            provide: 'UserAddressRepository',
+                            useFactory: (firestore, userRepository) => {
+                                return new UserAddressFirestoreRepository(firestore, userRepository);
+                            },
+                            deps: [Firestore, 'UserRepository'],
+                        },
+                        {
+                            provide: 'UserPaymentMethodRepository',
+                            useFactory: (firestore, userRepository) => {
+                                return new UserPaymentMethodFirestoreRepository(firestore, userRepository);
+                            },
+                            deps: [Firestore, 'UserRepository'],
+                        },
+                        {
+                            provide: ProductVariantFirestoreRepository,
+                            useFactory: (firestore, productRepository) => {
+                                return new ProductVariantFirestoreRepository(firestore, productRepository);
+                            },
+                            deps: [Firestore, ProductFirestoreRepository],
+                        },
+                    ],
+                }]
+        }] });
 
-class ShippingService {
-    constructor(http, apiUrl, homeService) {
-        this.http = http;
-        this.apiUrl = apiUrl;
-        this.homeService = homeService;
-    }
-    getShippingMethods(shop, zip, weightGrams, totalPrice, personId, subscriptionPlan) {
-        return combineLatest([
-            this.homeService.getHomeData(),
-            this.http.get(`${this.apiUrl}open/checkshippingcompany?personId=${personId}&postalCode=${zip}&weightGrams=${weightGrams}`),
-        ]).pipe(map(([datas, shippingMethodsResponse]) => {
-            let shippingMethods = shippingMethodsResponse.result;
-            if (!shippingMethods.length)
-                return [];
-            shippingMethods = shippingMethods.map((shippingMethod) => {
-                if (shippingMethod.ShippingCompanyName == 'Same Day EG')
-                    shippingMethod.ShippingCompanyName = 'Same Day';
-                return shippingMethod;
-            });
-            const datasSameDayNotAvaliable = datas.sameDayNotAvaliable;
-            if (this.isHolidays(datasSameDayNotAvaliable)) {
-                shippingMethods = shippingMethods.filter((method) => method.serviceName !== 'Same Day');
-            }
-            if (totalPrice >= 200) {
-                shippingMethods = shippingMethods.map((s) => {
-                    if (s.serviceName !== 'Same Day')
-                        return { ...s, totalPrice: 0 };
-                    else
-                        return s;
-                });
-            }
-            if (shop == Shops.GLAMSHOP)
-                return shippingMethods;
-            if (this.isFreeShippingBySubscription(shop, subscriptionPlan)) {
-                shippingMethods = shippingMethods.map((s) => {
-                    if (s.serviceName == 'Same Day')
-                        return { ...s, totalPrice: s.totalPrice / 2 };
-                    else
-                        return { ...s, totalPrice: 0 };
-                });
-            }
-            if (this.isHalfShippingBySubscription(shop, subscriptionPlan)) {
-                shippingMethods = shippingMethods.map((s) => {
-                    return { ...s, totalPrice: s.totalPrice / 2 };
-                });
-            }
-            return shippingMethods;
-        }));
-    }
-    isFreeShippingBySubscription(shop, subscriptionPlan) {
-        if (!subscriptionPlan)
-            return false;
-        if (shop == Shops.MENSMARKET && subscriptionPlan == 'SELECT')
-            return true;
-        return false;
-    }
-    isHalfShippingBySubscription(shop, subscriptionPlan) {
-        if (!subscriptionPlan)
-            return false;
-        if (shop == Shops.MENSMARKET && subscriptionPlan == 'PRIME') {
-            return true;
-        }
-        return false;
-    }
-    isHolidays(datas) {
-        const today = new Date();
-        for (const key in datas) {
-            let start = new Date(`${today.getFullYear()}-${datas[key].beginDate}`);
-            let end = new Date(`${today.getFullYear()}-${datas[key].endDate}`);
-            if (start > end)
-                end = new Date(`${today.getFullYear() + 1}-${datas[key].endDate}`);
-            if (today >= start && today <= end)
-                return true;
-        }
-        return false;
+const processes = {};
+class AngularHasuraGraphQLModule {
+    static initializeApp(options) {
+        return {
+            ngModule: AngularHasuraGraphQLModule,
+            providers: [{ provide: HASURA_OPTIONS, useValue: options }],
+        };
     }
 }
-ShippingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ShippingService, deps: [{ token: i1$4.HttpClient }, { token: BACKEND_URL }, { token: HomeShopService }], target: i0.ɵɵFactoryTarget.Injectable });
-ShippingService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ShippingService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ShippingService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i1$4.HttpClient }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [BACKEND_URL]
-                }] }, { type: HomeShopService }]; } });
+AngularHasuraGraphQLModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularHasuraGraphQLModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AngularHasuraGraphQLModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularHasuraGraphQLModule });
+AngularHasuraGraphQLModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularHasuraGraphQLModule, providers: [
+        {
+            provide: 'HasuraConfig',
+            useFactory: (options, platformId) => ({
+                endpoint: options.endpoint,
+                authOptions: options.credentials,
+                interceptors: {
+                    request: (request) => {
+                        if (isPlatformBrowser(platformId))
+                            return request;
+                        const index = Date.now();
+                        processes[index] = true;
+                        request.proccess = index;
+                        console.log('request', request.proccess);
+                        return request;
+                    },
+                    response: (response) => {
+                        if (isPlatformBrowser(platformId))
+                            return response;
+                        console.log('response', response.proccess);
+                        delete processes[response.proccess];
+                    },
+                },
+            }),
+            deps: [HASURA_OPTIONS, PLATFORM_ID],
+        },
+        {
+            provide: 'CategoryRepository',
+            useExisting: CategoryHasuraGraphQLRepository,
+        },
+        {
+            provide: CategoryHasuraGraphQLRepository,
+            useFactory: (hasuraConfig, productRepository) => {
+                return new CategoryHasuraGraphQLRepository(hasuraConfig, productRepository);
+            },
+            deps: ['HasuraConfig', ProductHasuraGraphQLRepository],
+        },
+        {
+            provide: 'ProductRepository',
+            useExisting: ProductHasuraGraphQLRepository,
+        },
+        {
+            provide: ProductHasuraGraphQLRepository,
+            useFactory: (hasuraConfig) => {
+                return new ProductHasuraGraphQLRepository(hasuraConfig);
+            },
+            deps: ['HasuraConfig'],
+        },
+        {
+            provide: 'VariantRepository',
+            useExisting: VariantHasuraGraphQLRepository,
+        },
+        {
+            provide: VariantHasuraGraphQLRepository,
+            useFactory: (hasuraConfig) => {
+                return new VariantHasuraGraphQLRepository(hasuraConfig);
+            },
+            deps: ['HasuraConfig'],
+        },
+    ] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularHasuraGraphQLModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        {
+                            provide: 'HasuraConfig',
+                            useFactory: (options, platformId) => ({
+                                endpoint: options.endpoint,
+                                authOptions: options.credentials,
+                                interceptors: {
+                                    request: (request) => {
+                                        if (isPlatformBrowser(platformId))
+                                            return request;
+                                        const index = Date.now();
+                                        processes[index] = true;
+                                        request.proccess = index;
+                                        console.log('request', request.proccess);
+                                        return request;
+                                    },
+                                    response: (response) => {
+                                        if (isPlatformBrowser(platformId))
+                                            return response;
+                                        console.log('response', response.proccess);
+                                        delete processes[response.proccess];
+                                    },
+                                },
+                            }),
+                            deps: [HASURA_OPTIONS, PLATFORM_ID],
+                        },
+                        {
+                            provide: 'CategoryRepository',
+                            useExisting: CategoryHasuraGraphQLRepository,
+                        },
+                        {
+                            provide: CategoryHasuraGraphQLRepository,
+                            useFactory: (hasuraConfig, productRepository) => {
+                                return new CategoryHasuraGraphQLRepository(hasuraConfig, productRepository);
+                            },
+                            deps: ['HasuraConfig', ProductHasuraGraphQLRepository],
+                        },
+                        {
+                            provide: 'ProductRepository',
+                            useExisting: ProductHasuraGraphQLRepository,
+                        },
+                        {
+                            provide: ProductHasuraGraphQLRepository,
+                            useFactory: (hasuraConfig) => {
+                                return new ProductHasuraGraphQLRepository(hasuraConfig);
+                            },
+                            deps: ['HasuraConfig'],
+                        },
+                        {
+                            provide: 'VariantRepository',
+                            useExisting: VariantHasuraGraphQLRepository,
+                        },
+                        {
+                            provide: VariantHasuraGraphQLRepository,
+                            useFactory: (hasuraConfig) => {
+                                return new VariantHasuraGraphQLRepository(hasuraConfig);
+                            },
+                            deps: ['HasuraConfig'],
+                        },
+                    ],
+                }]
+        }] });
 
 class AngularConnectModule {
     static initializeApp(defaultShop, options, nameOrConfig) {
         return {
             ngModule: AngularConnectModule,
             providers: [
-                {
-                    provide: CATEGORY_STRUCTURE,
-                    useClass: isNil(options?.oldCategoryStructure) || options?.oldCategoryStructure
-                        ? OldCategoryStructureAdapter
-                        : NewCategoryStructureAdapter,
-                },
                 ...(isNil(defaultShop) ? [] : [{ provide: DEFAULT_SHOP, useValue: defaultShop }]),
                 ...(isNil(options?.firebase) ? [] : [{ provide: FIREBASE_OPTIONS, useValue: options?.firebase }]),
                 ...(isNil(options?.firebase) ? [] : [{ provide: FIREBASE_APP_NAME, useValue: nameOrConfig }]),
                 ...(isNil(options?.elasticSearch) ? [] : [{ provide: ES_CONFIG, useValue: options.elasticSearch }]),
                 ...(isNil(options?.hasura) ? [] : [{ provide: HASURA_OPTIONS, useValue: options.hasura }]),
-                ...(isNil(options?.backendUrl) ? [] : [{ provide: BACKEND_URL, useValue: options.backendUrl }]),
             ],
         };
     }
@@ -2053,15 +1313,11 @@ AngularConnectModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", ve
 AngularConnectModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularConnectModule, providers: [
         AuthService,
         CartService,
-        CatalogService,
-        CategoryService,
         CheckoutService,
         CheckoutSubscriptionService,
         CouponService,
         HomeShopService,
         OrderService,
-        ShippingService,
-        WishlistService,
     ], imports: [AngularFirebaseAuthModule, AngularFirestoreModule, AngularHasuraGraphQLModule] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularConnectModule, decorators: [{
             type: NgModule,
@@ -2070,15 +1326,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImpor
                     providers: [
                         AuthService,
                         CartService,
-                        CatalogService,
-                        CategoryService,
                         CheckoutService,
                         CheckoutSubscriptionService,
                         CouponService,
                         HomeShopService,
                         OrderService,
-                        ShippingService,
-                        WishlistService,
                     ],
                 }]
         }] });
@@ -2087,5 +1339,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AngularConnectModule, AngularFirebaseAuthModule, AngularFirestoreModule, AngularHasuraGraphQLModule, AuthService, CartService, CatalogService, CategoryService, CategoryWithTree, CheckoutService, CheckoutSubscriptionService, CouponService, HomeShopService, OrderService, ProductSorts, ShippingService, UtilService, WishlistService };
+export { AngularConnectModule, AngularFirebaseAuthModule, AngularFirestoreModule, AngularHasuraGraphQLModule, AuthService, CartService, CheckoutService, CheckoutSubscriptionService, CouponService, HomeShopService, OrderService };
 //# sourceMappingURL=infrab4a-connect-angular.mjs.map