@infrab4a/connect-angular 4.6.0-beta.2 → 4.6.1-beta.0

package/fesm2015/infrab4a-connect-angular.mjs

@@ -20,34 +20,34 @@ import * as i1$3 from '@angular/common/http';
 
 const ES_CONFIG = 'ES_CONFIG';
 
-class AngularElasticSeachModule {
-    static initializeApp(options) {
-        return {
-            ngModule: AngularElasticSeachModule,
-            providers: [{ provide: ES_CONFIG, useValue: options }],
-        };
-    }
-}
-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 AngularElasticSeachModule {
+    static initializeApp(options) {
+        return {
+            ngModule: AngularElasticSeachModule,
+            providers: [{ provide: ES_CONFIG, useValue: options }],
+        };
+    }
+}
+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],
+                        },
+                    ],
+                }]
         }] });
 
 const BACKEND_URL = 'BACKEND_URL';
@@ -56,2447 +56,2453 @@ const CATEGORY_STRUCTURE = 'CATEGORY_STRUCTURE';
 
 const DEFAULT_SHOP = 'DEFAULT_SHOP';
 
-const FIREBASE_APP_NAME = new InjectionToken('firebaseAppName');
+const FIREBASE_APP_NAME = new InjectionToken('firebaseAppName');
 const FIREBASE_OPTIONS = new InjectionToken('firebaseOptions');
 
 const HASURA_OPTIONS = 'HASURA_OPTIONS';
 
 const PERSISTENCE_PROVIDER = 'PERSISTENCE_PROVIDER';
 
-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.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: [provideAuth((injector) => getAuth(injector.get(FirebaseApp)))] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirebaseAuthModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [provideAuth((injector) => getAuth(injector.get(FirebaseApp)))],
-                    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 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.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: [provideAuth((injector) => getAuth(injector.get(FirebaseApp)))] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirebaseAuthModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [provideAuth((injector) => getAuth(injector.get(FirebaseApp)))],
+                    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 MobileOperationSystemCheckerHelper {
-    static isAppleDevice() {
-        var _a, _b;
-        return (['iPad Simulator', 'iPhone Simulator', 'iPod Simulator', 'iPad', 'iPhone', 'iPod'].includes(navigator === null || navigator === void 0 ? void 0 : navigator.platform) ||
-            (((_b = (_a = navigator === null || navigator === void 0 ? void 0 : navigator.userAgent) === null || _a === void 0 ? void 0 : _a.includes) === null || _b === void 0 ? void 0 : _b.call(_a, 'Mac')) && 'ontouchend' in (document || {})));
-    }
+class MobileOperationSystemCheckerHelper {
+    static isAppleDevice() {
+        var _a, _b;
+        return (['iPad Simulator', 'iPhone Simulator', 'iPod Simulator', 'iPad', 'iPhone', 'iPod'].includes(navigator === null || navigator === void 0 ? void 0 : navigator.platform) ||
+            (((_b = (_a = navigator === null || navigator === void 0 ? void 0 : navigator.userAgent) === null || _a === void 0 ? void 0 : _a.includes) === null || _b === void 0 ? void 0 : _b.call(_a, 'Mac')) && 'ontouchend' in (document || {})));
+    }
 }
 
-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$1.FirestoreModule] });
-AngularFirestoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirestoreModule, providers: [
-        {
-            provide: 'FirestoreOptions',
-            useFactory: (firestore, platformId) => ({
-                firestore: new ConnectFirestoreService(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: 'SubscriptionMaterializationRepository',
-            useFactory: (options) => {
-                return new SubscriptionMaterializationFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'SubscriptionSummaryRepository',
-            useFactory: (options) => {
-                return new SubscriptionSummaryFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: ProductVariantFirestoreRepository,
-            useFactory: (options, productRepository) => {
-                return new ProductVariantFirestoreRepository(options, productRepository);
-            },
-            deps: ['FirestoreOptions', ProductFirestoreRepository],
-        },
-    ], imports: [AngularElasticSeachModule,
-        provideFirestore((injector) => {
-            const platformId = injector.get(PLATFORM_ID);
-            if (isPlatformServer(platformId) || !MobileOperationSystemCheckerHelper.isAppleDevice())
-                return initializeFirestore(injector.get(FirebaseApp), {
-                    ignoreUndefinedProperties: true,
-                });
-            const firestore = initializeFirestore(injector.get(FirebaseApp), {
-                experimentalForceLongPolling: true,
-                ignoreUndefinedProperties: true,
-                localCache: memoryLocalCache(),
-            });
-            return firestore;
-        })] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirestoreModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [
-                        AngularElasticSeachModule,
-                        provideFirestore((injector) => {
-                            const platformId = injector.get(PLATFORM_ID);
-                            if (isPlatformServer(platformId) || !MobileOperationSystemCheckerHelper.isAppleDevice())
-                                return initializeFirestore(injector.get(FirebaseApp), {
-                                    ignoreUndefinedProperties: true,
-                                });
-                            const firestore = initializeFirestore(injector.get(FirebaseApp), {
-                                experimentalForceLongPolling: true,
-                                ignoreUndefinedProperties: true,
-                                localCache: memoryLocalCache(),
-                            });
-                            return firestore;
-                        }),
-                    ],
-                    providers: [
-                        {
-                            provide: 'FirestoreOptions',
-                            useFactory: (firestore, platformId) => ({
-                                firestore: new ConnectFirestoreService(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: 'SubscriptionMaterializationRepository',
-                            useFactory: (options) => {
-                                return new SubscriptionMaterializationFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'SubscriptionSummaryRepository',
-                            useFactory: (options) => {
-                                return new SubscriptionSummaryFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: ProductVariantFirestoreRepository,
-                            useFactory: (options, productRepository) => {
-                                return new ProductVariantFirestoreRepository(options, productRepository);
-                            },
-                            deps: ['FirestoreOptions', ProductFirestoreRepository],
-                        },
-                    ],
-                }]
+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$1.FirestoreModule] });
+AngularFirestoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirestoreModule, providers: [
+        {
+            provide: 'FirestoreOptions',
+            useFactory: (firestore, platformId) => ({
+                firestore: new ConnectFirestoreService(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: 'SubscriptionMaterializationRepository',
+            useFactory: (options) => {
+                return new SubscriptionMaterializationFirestoreRepository(options);
+            },
+            deps: ['FirestoreOptions'],
+        },
+        {
+            provide: 'SubscriptionSummaryRepository',
+            useFactory: (options) => {
+                return new SubscriptionSummaryFirestoreRepository(options);
+            },
+            deps: ['FirestoreOptions'],
+        },
+        {
+            provide: ProductVariantFirestoreRepository,
+            useFactory: (options, productRepository) => {
+                return new ProductVariantFirestoreRepository(options, productRepository);
+            },
+            deps: ['FirestoreOptions', ProductFirestoreRepository],
+        },
+    ], imports: [AngularElasticSeachModule,
+        provideFirestore((injector) => {
+            const platformId = injector.get(PLATFORM_ID);
+            if (isPlatformServer(platformId) || !MobileOperationSystemCheckerHelper.isAppleDevice())
+                return initializeFirestore(injector.get(FirebaseApp), {
+                    ignoreUndefinedProperties: true,
+                });
+            const firestore = initializeFirestore(injector.get(FirebaseApp), {
+                experimentalForceLongPolling: true,
+                ignoreUndefinedProperties: true,
+                localCache: memoryLocalCache(),
+            });
+            return firestore;
+        })] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirestoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AngularElasticSeachModule,
+                        provideFirestore((injector) => {
+                            const platformId = injector.get(PLATFORM_ID);
+                            if (isPlatformServer(platformId) || !MobileOperationSystemCheckerHelper.isAppleDevice())
+                                return initializeFirestore(injector.get(FirebaseApp), {
+                                    ignoreUndefinedProperties: true,
+                                });
+                            const firestore = initializeFirestore(injector.get(FirebaseApp), {
+                                experimentalForceLongPolling: true,
+                                ignoreUndefinedProperties: true,
+                                localCache: memoryLocalCache(),
+                            });
+                            return firestore;
+                        }),
+                    ],
+                    providers: [
+                        {
+                            provide: 'FirestoreOptions',
+                            useFactory: (firestore, platformId) => ({
+                                firestore: new ConnectFirestoreService(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: 'SubscriptionMaterializationRepository',
+                            useFactory: (options) => {
+                                return new SubscriptionMaterializationFirestoreRepository(options);
+                            },
+                            deps: ['FirestoreOptions'],
+                        },
+                        {
+                            provide: 'SubscriptionSummaryRepository',
+                            useFactory: (options) => {
+                                return new SubscriptionSummaryFirestoreRepository(options);
+                            },
+                            deps: ['FirestoreOptions'],
+                        },
+                        {
+                            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: 'ProductReviewsRepository',
-            useExisting: ProductReviewsHasuraGraphQLRepository,
-        },
-        {
-            provide: ProductReviewsHasuraGraphQLRepository,
-            useFactory: (hasuraConfig) => {
-                return new ProductReviewsHasuraGraphQLRepository(hasuraConfig);
-            },
-            deps: ['HasuraConfig'],
-        },
-        {
-            provide: 'VariantRepository',
-            useExisting: VariantHasuraGraphQLRepository,
-        },
-        {
-            provide: VariantHasuraGraphQLRepository,
-            useFactory: (hasuraConfig) => {
-                return new VariantHasuraGraphQLRepository(hasuraConfig);
-            },
-            deps: ['HasuraConfig'],
-        },
-        {
-            provide: 'ProductStockNotificationRepository',
-            useExisting: ProductStockNotificationHasuraGraphQLRepository,
-        },
-        {
-            provide: ProductStockNotificationHasuraGraphQLRepository,
-            useFactory: (hasuraConfig) => {
-                return new ProductStockNotificationHasuraGraphQLRepository(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),
-            deps: ['HasuraConfig'],
-        },
-        {
-            provide: 'CategoryCollectionChildrenRepository',
-            useExisting: CategoryCollectionChildrenHasuraGraphQLRepository,
-        },
-        {
-            provide: WishlistHasuraGraphQLRepository,
-            useFactory: (options, categoryFilterRepository) => {
-                return new WishlistHasuraGraphQLRepository(options, categoryFilterRepository);
-            },
-            deps: ['HasuraConfig', CategoryFilterHasuraGraphQLRepository],
-        },
-        {
-            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: 'ProductReviewsRepository',
-                            useExisting: ProductReviewsHasuraGraphQLRepository,
-                        },
-                        {
-                            provide: ProductReviewsHasuraGraphQLRepository,
-                            useFactory: (hasuraConfig) => {
-                                return new ProductReviewsHasuraGraphQLRepository(hasuraConfig);
-                            },
-                            deps: ['HasuraConfig'],
-                        },
-                        {
-                            provide: 'VariantRepository',
-                            useExisting: VariantHasuraGraphQLRepository,
-                        },
-                        {
-                            provide: VariantHasuraGraphQLRepository,
-                            useFactory: (hasuraConfig) => {
-                                return new VariantHasuraGraphQLRepository(hasuraConfig);
-                            },
-                            deps: ['HasuraConfig'],
-                        },
-                        {
-                            provide: 'ProductStockNotificationRepository',
-                            useExisting: ProductStockNotificationHasuraGraphQLRepository,
-                        },
-                        {
-                            provide: ProductStockNotificationHasuraGraphQLRepository,
-                            useFactory: (hasuraConfig) => {
-                                return new ProductStockNotificationHasuraGraphQLRepository(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),
-                            deps: ['HasuraConfig'],
-                        },
-                        {
-                            provide: 'CategoryCollectionChildrenRepository',
-                            useExisting: CategoryCollectionChildrenHasuraGraphQLRepository,
-                        },
-                        {
-                            provide: WishlistHasuraGraphQLRepository,
-                            useFactory: (options, categoryFilterRepository) => {
-                                return new WishlistHasuraGraphQLRepository(options, categoryFilterRepository);
-                            },
-                            deps: ['HasuraConfig', CategoryFilterHasuraGraphQLRepository],
-                        },
-                        {
-                            provide: 'WishlistRepository',
-                            useExisting: WishlistHasuraGraphQLRepository,
-                        },
-                    ],
-                }]
+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: 'ProductReviewsRepository',
+            useExisting: ProductReviewsHasuraGraphQLRepository,
+        },
+        {
+            provide: ProductReviewsHasuraGraphQLRepository,
+            useFactory: (hasuraConfig) => {
+                return new ProductReviewsHasuraGraphQLRepository(hasuraConfig);
+            },
+            deps: ['HasuraConfig'],
+        },
+        {
+            provide: 'VariantRepository',
+            useExisting: VariantHasuraGraphQLRepository,
+        },
+        {
+            provide: VariantHasuraGraphQLRepository,
+            useFactory: (hasuraConfig) => {
+                return new VariantHasuraGraphQLRepository(hasuraConfig);
+            },
+            deps: ['HasuraConfig'],
+        },
+        {
+            provide: 'ProductStockNotificationRepository',
+            useExisting: ProductStockNotificationHasuraGraphQLRepository,
+        },
+        {
+            provide: ProductStockNotificationHasuraGraphQLRepository,
+            useFactory: (hasuraConfig) => {
+                return new ProductStockNotificationHasuraGraphQLRepository(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),
+            deps: ['HasuraConfig'],
+        },
+        {
+            provide: 'CategoryCollectionChildrenRepository',
+            useExisting: CategoryCollectionChildrenHasuraGraphQLRepository,
+        },
+        {
+            provide: WishlistHasuraGraphQLRepository,
+            useFactory: (options, categoryFilterRepository) => {
+                return new WishlistHasuraGraphQLRepository(options, categoryFilterRepository);
+            },
+            deps: ['HasuraConfig', CategoryFilterHasuraGraphQLRepository],
+        },
+        {
+            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: 'ProductReviewsRepository',
+                            useExisting: ProductReviewsHasuraGraphQLRepository,
+                        },
+                        {
+                            provide: ProductReviewsHasuraGraphQLRepository,
+                            useFactory: (hasuraConfig) => {
+                                return new ProductReviewsHasuraGraphQLRepository(hasuraConfig);
+                            },
+                            deps: ['HasuraConfig'],
+                        },
+                        {
+                            provide: 'VariantRepository',
+                            useExisting: VariantHasuraGraphQLRepository,
+                        },
+                        {
+                            provide: VariantHasuraGraphQLRepository,
+                            useFactory: (hasuraConfig) => {
+                                return new VariantHasuraGraphQLRepository(hasuraConfig);
+                            },
+                            deps: ['HasuraConfig'],
+                        },
+                        {
+                            provide: 'ProductStockNotificationRepository',
+                            useExisting: ProductStockNotificationHasuraGraphQLRepository,
+                        },
+                        {
+                            provide: ProductStockNotificationHasuraGraphQLRepository,
+                            useFactory: (hasuraConfig) => {
+                                return new ProductStockNotificationHasuraGraphQLRepository(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),
+                            deps: ['HasuraConfig'],
+                        },
+                        {
+                            provide: 'CategoryCollectionChildrenRepository',
+                            useExisting: CategoryCollectionChildrenHasuraGraphQLRepository,
+                        },
+                        {
+                            provide: WishlistHasuraGraphQLRepository,
+                            useFactory: (options, categoryFilterRepository) => {
+                                return new WishlistHasuraGraphQLRepository(options, categoryFilterRepository);
+                            },
+                            deps: ['HasuraConfig', CategoryFilterHasuraGraphQLRepository],
+                        },
+                        {
+                            provide: 'WishlistRepository',
+                            useExisting: WishlistHasuraGraphQLRepository,
+                        },
+                    ],
+                }]
         }] });
 
 const STORAGE_BASE_URL = 'STORAGE_BASE_URL';
 
-class CookieDataPersistence {
-    get(key) {
-        return of(cookie.get(key));
-    }
-    remove(key) {
-        return of(cookie.remove(key));
-    }
-    set(key, value) {
-        return from(cookie.set(key, value)).pipe(map(() => { }));
-    }
-}
-CookieDataPersistence.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CookieDataPersistence, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-CookieDataPersistence.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CookieDataPersistence });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CookieDataPersistence, decorators: [{
-            type: Injectable
+class CookieDataPersistence {
+    get(key) {
+        return of(cookie.get(key));
+    }
+    remove(key) {
+        return of(cookie.remove(key));
+    }
+    set(key, value) {
+        return from(cookie.set(key, value)).pipe(map(() => { }));
+    }
+}
+CookieDataPersistence.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CookieDataPersistence, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CookieDataPersistence.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CookieDataPersistence });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CookieDataPersistence, decorators: [{
+            type: Injectable
         }] });
 
-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 === null || fireUser === void 0 ? void 0 : fireUser.isAnonymous,
-        })));
-    }
-    getUser() {
-        return this.getFireUser().pipe(map((user) => user === null || user === void 0 ? void 0 : 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.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']
-                    }] }];
+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 === null || fireUser === void 0 ? void 0 : fireUser.isAnonymous,
+        })));
+    }
+    getUser() {
+        return this.getFireUser().pipe(map((user) => user === null || user === void 0 ? void 0 : 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.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']
+                    }] }];
     } });
 
-class CouponService {
-    constructor(couponRepository, defaultShop, orderRepository, categoryRepository) {
-        this.couponRepository = couponRepository;
-        this.defaultShop = defaultShop;
-        this.orderRepository = orderRepository;
-        this.categoryRepository = categoryRepository;
-        this.emailIsFromCollaborator = (userEmail) => !!(userEmail === null || userEmail === void 0 ? void 0 : 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));
-    }
-    couponValidation(coupon, checkoutType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!coupon)
-                throw 'Cupom inválido.';
-            if ((coupon === null || coupon === void 0 ? void 0 : coupon.beginAt) && (coupon === null || coupon === void 0 ? void 0 : coupon.beginAt.getTime()) > new Date().getTime())
-                throw 'Cupom inválido.';
-            if ((coupon === null || coupon === void 0 ? void 0 : coupon.expiresIn) && (coupon === null || coupon === void 0 ? void 0 : 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;
-        });
-    }
-    couponRulesValidation(coupon, checkoutType, checkout, plan) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 === null || checkout === void 0 ? void 0 : checkout.user);
-            if (!validUser)
-                throw 'Usuário não elegível.';
-            const couponUseLimits = this.getCouponUseLimits(coupon, checkoutType, checkout.user);
-            if (couponUseLimits.firstOrder) {
-                const ordersUser = yield this.getOrdersFromUser(checkout.user.email.toLocaleLowerCase());
-                if (couponUseLimits.firstOrder && ordersUser.length >= 1)
-                    throw 'Limite de uso atingido';
-            }
-            if (!couponUseLimits.unlimited || couponUseLimits.limitedPerUser) {
-                const orders = yield 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.';
-                }
-            }
-            const hasProductCategories = yield this.hasProductCategories(coupon, checkout);
-            if (!hasProductCategories)
-                throw 'Seu carrinho não possui produtos elegíveis para desconto.';
-            const hasMinSubTotal = yield 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);
-        return of(discount);
-    }
-    calcDiscountShopping(coupon, checkout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let discountInfo = null;
-            if (checkout.user.isSubscriber && coupon.discount.subscriber.value) {
-                discountInfo = yield this.calcDiscountByType(coupon.discount.subscriber.type, coupon.discount.subscriber.value, coupon.productsCategories, checkout);
-            }
-            else {
-                discountInfo = yield this.calcDiscountByType(coupon.discount.non_subscriber.type, coupon.discount.non_subscriber.value, coupon.productsCategories, checkout);
-            }
-            return { discount: discountInfo.discount, lineItems: discountInfo.lineItems };
-        });
-    }
-    calcDiscountByType(type, value, categories, checkout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let discount = 0;
-            let lineItensElegibleForDiscount = yield this.getLineItensEligebleForDiscount(categories, checkout);
-            const subTotal = this.calcCheckoutSubtotal(lineItensElegibleForDiscount, checkout.user);
-            if (type == CouponTypes.ABSOLUTE) {
-                discount = value > subTotal ? subTotal : value;
-            }
-            else {
-                discount = subTotal * (value / 100);
-            }
-            const lineItems = this.calcLineItenDiscount(type, lineItensElegibleForDiscount, value, subTotal);
-            return { discount, lineItems };
-        });
-    }
-    hasMinSubTotal(coupon, checkout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!coupon.minSubTotalValue)
-                return true;
-            let lineItensDiscount = yield this.getLineItensEligebleForDiscount(coupon.productsCategories, checkout);
-            const subTotal = this.calcCheckoutSubtotal(lineItensDiscount, checkout.user);
-            if (coupon.minSubTotalValue <= subTotal)
-                return true;
-            return false;
-        });
-    }
-    hasProductCategories(coupon, checkout) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!coupon.productsCategories || !coupon.productsCategories.length) {
-                return true;
-            }
-            const couponCategories = yield this.getCouponCategoriesId(coupon.productsCategories);
-            const hasCategories = (_a = checkout.lineItems) === null || _a === void 0 ? void 0 : _a.filter((i) => {
-                var _a;
-                if (!i.categories || !((_a = i.categories) === null || _a === void 0 ? void 0 : _a.length))
-                    return true;
-                return i.categories.some((c) => couponCategories.some((cat) => cat == 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.toLocaleLowerCase()))
-            userTypes.push(Exclusivities.COLLABORATORS);
-        if (coupon.exclusivityType.includes(Exclusivities.SPECIFIC_USER) &&
-            coupon.userExclusiveEmail.includes(user.email.toLocaleLowerCase()))
-            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));
-    }
-    getCouponCategoriesId(productsCategories) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const couponCategories = [];
-            for (let index = 0; index < productsCategories.length; index++) {
-                const category = yield this.categoryRepository.get({
-                    id: productsCategories[index],
-                });
-                if (category) {
-                    const children = yield this.categoryRepository.getChildren(parseInt(productsCategories[index]));
-                    couponCategories.push(category.id, ...children.map((c) => c.id.toString()));
-                }
-            }
-            return [...new Set(couponCategories)];
-        });
-    }
-    getLineItensEligebleForDiscount(productsCategories, checkout) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            let lineItensDiscount = [];
-            const couponCategories = yield this.getCouponCategoriesId(productsCategories);
-            if (productsCategories && productsCategories.length) {
-                lineItensDiscount = (_a = checkout.lineItems) === null || _a === void 0 ? void 0 : _a.filter((i) => {
-                    var _a;
-                    if ((_a = i.categories) === null || _a === void 0 ? void 0 : _a.length) {
-                        return i.categories.some((c) => couponCategories.some((cat) => cat == c));
-                    }
-                    return true;
-                });
-            }
-            else {
-                lineItensDiscount = checkout.lineItems;
-            }
-            return lineItensDiscount;
-        });
-    }
-    calcCheckoutSubtotal(lineItens, user) {
-        return ((lineItens === null || lineItens === void 0 ? void 0 : lineItens.reduce((acc, curr) => {
-            var _a;
-            return (user === null || user === void 0 ? void 0 : user.isSubscriber) && curr.price.subscriberPrice
-                ? acc + ((_a = curr.price) === null || _a === void 0 ? void 0 : _a.subscriberPrice) * curr.quantity
-                : acc + curr.pricePaid * curr.quantity;
-        }, 0)) || 0);
-    }
-    getOrdersWithCoupon(coupon) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.orderRepository
-                .find({
-                filters: {
-                    coupon: { id: coupon.id },
-                    payment: { status: 'paid' },
-                },
-            })
-                .then((result) => result.data);
-        });
-    }
-    getOrdersFromUser(email) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.orderRepository
-                .find({
-                filters: {
-                    user: { email: { operator: Where.EQUALS, value: email } },
-                    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;
-    }
-    calcLineItenDiscount(type, lineItems, couponDiscount, subTotal) {
-        let lineItemsDiscount = [];
-        if (type === CouponTypes.ABSOLUTE) {
-            const couponDiscountMax = couponDiscount > subTotal ? subTotal : couponDiscount;
-            lineItemsDiscount = lineItems.map((item) => {
-                const totalItemPercentage = item.pricePaid / subTotal;
-                const discountItem = couponDiscountMax * totalItemPercentage;
-                return Object.assign(Object.assign({}, item), { discount: Number(discountItem.toFixed(2)) });
-            });
-        }
-        else {
-            lineItemsDiscount = lineItems.map((item) => {
-                const discountItem = item.pricePaid * (couponDiscount / 100);
-                return Object.assign(Object.assign({}, item), { discount: Number(discountItem.toFixed(2)) });
-            });
-        }
-        return lineItemsDiscount;
-    }
-}
-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.ɵ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,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['CouponRepository']
-                    }] }, { type: i1$2.Shops, decorators: [{
-                        type: Inject,
-                        args: [DEFAULT_SHOP]
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['OrderRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['CategoryRepository']
-                    }] }];
+class CouponService {
+    constructor(couponRepository, defaultShop, orderRepository, categoryRepository) {
+        this.couponRepository = couponRepository;
+        this.defaultShop = defaultShop;
+        this.orderRepository = orderRepository;
+        this.categoryRepository = categoryRepository;
+        this.emailIsFromCollaborator = (userEmail) => !!(userEmail === null || userEmail === void 0 ? void 0 : 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));
+    }
+    couponValidation(coupon, checkoutType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!coupon)
+                throw 'Cupom inválido.';
+            if ((coupon === null || coupon === void 0 ? void 0 : coupon.beginAt) && (coupon === null || coupon === void 0 ? void 0 : coupon.beginAt.getTime()) > new Date().getTime())
+                throw 'Cupom inválido.';
+            if ((coupon === null || coupon === void 0 ? void 0 : coupon.expiresIn) && (coupon === null || coupon === void 0 ? void 0 : 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;
+        });
+    }
+    couponRulesValidation(coupon, checkoutType, checkout, plan) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 === null || checkout === void 0 ? void 0 : checkout.user);
+            if (!validUser)
+                throw 'Usuário não elegível.';
+            const couponUseLimits = this.getCouponUseLimits(coupon, checkoutType, checkout.user);
+            if (couponUseLimits.firstOrder) {
+                const ordersUser = yield this.getOrdersFromUser(checkout.user.email.toLocaleLowerCase());
+                if (couponUseLimits.firstOrder && ordersUser.length >= 1)
+                    throw 'Limite de uso atingido';
+            }
+            if (!couponUseLimits.unlimited || couponUseLimits.limitedPerUser) {
+                const orders = yield 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.';
+                }
+            }
+            const hasProductCategories = yield this.hasProductCategories(coupon, checkout);
+            if (!hasProductCategories)
+                throw 'Seu carrinho não possui produtos elegíveis para desconto.';
+            const hasMinSubTotal = yield 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);
+        return of(discount);
+    }
+    calcDiscountShopping(coupon, checkout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let discountInfo = null;
+            if (checkout.user.isSubscriber && coupon.discount.subscriber.value) {
+                discountInfo = yield this.calcDiscountByType(coupon.discount.subscriber.type, coupon.discount.subscriber.value, coupon.productsCategories, checkout);
+            }
+            else {
+                discountInfo = yield this.calcDiscountByType(coupon.discount.non_subscriber.type, coupon.discount.non_subscriber.value, coupon.productsCategories, checkout);
+            }
+            return { discount: discountInfo.discount, lineItems: discountInfo.lineItems };
+        });
+    }
+    calcDiscountByType(type, value, categories, checkout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let discount = 0;
+            let lineItensElegibleForDiscount = yield this.getLineItensEligebleForDiscount(categories, checkout);
+            const subTotal = this.calcCheckoutSubtotal(lineItensElegibleForDiscount, checkout.user);
+            if (type == CouponTypes.ABSOLUTE) {
+                discount = value > subTotal ? subTotal : value;
+            }
+            else {
+                discount = subTotal * (value / 100);
+            }
+            const lineItems = this.calcLineItenDiscount(type, lineItensElegibleForDiscount, value, subTotal);
+            return { discount, lineItems };
+        });
+    }
+    hasMinSubTotal(coupon, checkout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!coupon.minSubTotalValue)
+                return true;
+            let lineItensDiscount = yield this.getLineItensEligebleForDiscount(coupon.productsCategories, checkout);
+            const subTotal = this.calcCheckoutSubtotal(lineItensDiscount, checkout.user);
+            if (coupon.minSubTotalValue <= subTotal)
+                return true;
+            return false;
+        });
+    }
+    hasProductCategories(coupon, checkout) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!coupon.productsCategories || !coupon.productsCategories.length) {
+                return true;
+            }
+            const couponCategories = yield this.getCouponCategoriesId(coupon.productsCategories);
+            const hasCategories = (_a = checkout.lineItems) === null || _a === void 0 ? void 0 : _a.filter((i) => {
+                var _a;
+                if (!i.categories || !((_a = i.categories) === null || _a === void 0 ? void 0 : _a.length))
+                    return true;
+                return i.categories.some((c) => couponCategories.some((cat) => cat == 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.toLocaleLowerCase()))
+            userTypes.push(Exclusivities.COLLABORATORS);
+        if (coupon.exclusivityType.includes(Exclusivities.SPECIFIC_USER) &&
+            coupon.userExclusiveEmail.includes(user.email.toLocaleLowerCase()))
+            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));
+    }
+    getCouponCategoriesId(productsCategories) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const couponCategories = [];
+            for (let index = 0; index < productsCategories.length; index++) {
+                const category = yield this.categoryRepository.get({
+                    id: productsCategories[index],
+                });
+                if (category) {
+                    const children = yield this.categoryRepository.getChildren(parseInt(productsCategories[index]));
+                    couponCategories.push(category.id, ...children.map((c) => c.id.toString()));
+                }
+            }
+            return [...new Set(couponCategories)];
+        });
+    }
+    getLineItensEligebleForDiscount(productsCategories, checkout) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            let lineItensDiscount = [];
+            const couponCategories = yield this.getCouponCategoriesId(productsCategories);
+            if (productsCategories && productsCategories.length) {
+                lineItensDiscount = (_a = checkout.lineItems) === null || _a === void 0 ? void 0 : _a.filter((i) => {
+                    var _a;
+                    if ((_a = i.categories) === null || _a === void 0 ? void 0 : _a.length) {
+                        return i.categories.some((c) => couponCategories.some((cat) => cat == c));
+                    }
+                    return true;
+                });
+            }
+            else {
+                lineItensDiscount = checkout.lineItems;
+            }
+            return lineItensDiscount;
+        });
+    }
+    calcCheckoutSubtotal(lineItens, user) {
+        return ((lineItens === null || lineItens === void 0 ? void 0 : lineItens.reduce((acc, curr) => {
+            var _a;
+            return (user === null || user === void 0 ? void 0 : user.isSubscriber) && curr.price.subscriberPrice
+                ? acc + ((_a = curr.price) === null || _a === void 0 ? void 0 : _a.subscriberPrice) * curr.quantity
+                : acc + curr.pricePaid * curr.quantity;
+        }, 0)) || 0);
+    }
+    getOrdersWithCoupon(coupon) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.orderRepository
+                .find({
+                filters: {
+                    coupon: { id: coupon.id },
+                    payment: { status: 'paid' },
+                },
+            })
+                .then((result) => result.data);
+        });
+    }
+    getOrdersFromUser(email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.orderRepository
+                .find({
+                filters: {
+                    user: { email: { operator: Where.EQUALS, value: email } },
+                    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;
+    }
+    calcLineItenDiscount(type, lineItems, couponDiscount, subTotal) {
+        let lineItemsDiscount = [];
+        if (type === CouponTypes.ABSOLUTE) {
+            const couponDiscountMax = couponDiscount > subTotal ? subTotal : couponDiscount;
+            lineItemsDiscount = lineItems.map((item) => {
+                const totalItemPercentage = item.pricePaid / subTotal;
+                const discountItem = couponDiscountMax * totalItemPercentage;
+                return Object.assign(Object.assign({}, item), { discount: Number(discountItem.toFixed(2)) });
+            });
+        }
+        else {
+            lineItemsDiscount = lineItems.map((item) => {
+                const discountItem = item.pricePaid * (couponDiscount / 100);
+                return Object.assign(Object.assign({}, item), { discount: Number(discountItem.toFixed(2)) });
+            });
+        }
+        return lineItemsDiscount;
+    }
+}
+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.ɵ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,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['CouponRepository']
+                    }] }, { type: i1$2.Shops, decorators: [{
+                        type: Inject,
+                        args: [DEFAULT_SHOP]
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['OrderRepository']
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['CategoryRepository']
+                    }] }];
     } });
 
-class CheckoutService {
-    constructor(couponService, checkoutRepository, userRepository, defaultShop, dataPersistence) {
-        this.couponService = couponService;
-        this.checkoutRepository = checkoutRepository;
-        this.userRepository = userRepository;
-        this.defaultShop = defaultShop;
-        this.dataPersistence = dataPersistence;
-    }
-    getCheckout(checkoutData) {
-        return this.dataPersistence
-            .get('checkoutId')
-            .pipe(concatMap((id) => (!isNil(id) ? this.checkoutRepository.get({ id }) : this.createCheckout(checkoutData))));
-    }
-    getUserByCheckout(checkoutId) {
-        return from(this.checkoutRepository.get({ id: checkoutId })).pipe(concatMap((checkout) => { var _a; return ((_a = checkout === null || checkout === void 0 ? void 0 : checkout.user) === null || _a === void 0 ? void 0 : _a.id) ? of(checkout.user) : from(this.userRepository.get({ id: checkout.user.id })); }), concatMap((user) => of(user) || throwError(() => new NotFoundError('User is not found'))));
-    }
-    updateCheckoutLineItems(checkout) {
-        return from(this.checkoutRepository.update(Checkout.toInstance({ id: checkout.id, lineItems: checkout.lineItems })));
-    }
-    updateCheckoutUser(checkout) {
-        return from(this.checkoutRepository.update(Checkout.toInstance({ id: checkout.id, user: checkout.user })));
-    }
-    clearCheckoutFromSession() {
-        return this.dataPersistence.remove('checkoutId');
-    }
-    calcDiscount(coupon) {
-        return this.getCheckout().pipe(concatMap((checkout) => __awaiter(this, void 0, void 0, function* () { return yield this.couponService.calcDiscountShopping(coupon, checkout); })));
-    }
-    checkCoupon(nickname, checkoutType) {
-        return this.getCheckout().pipe(concatMap((checkout) => this.couponService.checkCoupon(nickname, CheckoutTypes.ECOMMERCE, checkout, null).pipe()));
-    }
-    createCheckout(checkoutData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const checkout = yield this.checkoutRepository.create(Object.assign(Object.assign({ createdAt: new Date() }, Checkout.toInstance(pick(checkoutData, ['user', 'shop'])).toPlain()), { shop: (checkoutData === null || checkoutData === void 0 ? void 0 : checkoutData.shop) || this.defaultShop }));
-            yield this.dataPersistence.set('checkoutId', checkout.id).toPromise();
-            return checkout;
-        });
-    }
-}
-CheckoutService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutService, deps: [{ token: CouponService }, { token: 'CheckoutRepository' }, { token: 'UserRepository' }, { token: DEFAULT_SHOP }, { token: PERSISTENCE_PROVIDER }], target: i0.ɵɵFactoryTarget.Injectable });
-CheckoutService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: CouponService }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['CheckoutRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['UserRepository']
-                    }] }, { type: i1$2.Shops, decorators: [{
-                        type: Inject,
-                        args: [DEFAULT_SHOP]
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: [PERSISTENCE_PROVIDER]
-                    }] }];
+class CheckoutService {
+    constructor(couponService, checkoutRepository, userRepository, defaultShop, dataPersistence) {
+        this.couponService = couponService;
+        this.checkoutRepository = checkoutRepository;
+        this.userRepository = userRepository;
+        this.defaultShop = defaultShop;
+        this.dataPersistence = dataPersistence;
+    }
+    getCheckout(checkoutData) {
+        return this.dataPersistence
+            .get('checkoutId')
+            .pipe(concatMap((id) => (!isNil(id) ? this.checkoutRepository.get({ id }) : this.createCheckout(checkoutData))));
+    }
+    getUserByCheckout(checkoutId) {
+        return from(this.checkoutRepository.get({ id: checkoutId })).pipe(concatMap((checkout) => { var _a; return ((_a = checkout === null || checkout === void 0 ? void 0 : checkout.user) === null || _a === void 0 ? void 0 : _a.id) ? of(checkout.user) : from(this.userRepository.get({ id: checkout.user.id })); }), concatMap((user) => of(user) || throwError(() => new NotFoundError('User is not found'))));
+    }
+    updateCheckoutLineItems(checkout) {
+        return from(this.checkoutRepository.update(Checkout.toInstance({ id: checkout.id, lineItems: checkout.lineItems })));
+    }
+    updateCheckoutUser(checkout) {
+        return from(this.checkoutRepository.update(Checkout.toInstance({ id: checkout.id, user: checkout.user })));
+    }
+    clearCheckoutFromSession() {
+        return this.dataPersistence.remove('checkoutId');
+    }
+    calcDiscount(coupon) {
+        return this.getCheckout().pipe(concatMap((checkout) => __awaiter(this, void 0, void 0, function* () { return yield this.couponService.calcDiscountShopping(coupon, checkout); })));
+    }
+    checkCoupon(nickname, checkoutType) {
+        return this.getCheckout().pipe(concatMap((checkout) => this.couponService.checkCoupon(nickname, CheckoutTypes.ECOMMERCE, checkout, null).pipe()));
+    }
+    createCheckout(checkoutData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const checkout = yield this.checkoutRepository.create(Object.assign(Object.assign({ createdAt: new Date() }, Checkout.toInstance(pick(checkoutData, ['user', 'shop'])).toPlain()), { shop: (checkoutData === null || checkoutData === void 0 ? void 0 : checkoutData.shop) || this.defaultShop }));
+            yield this.dataPersistence.set('checkoutId', checkout.id).toPromise();
+            return checkout;
+        });
+    }
+}
+CheckoutService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutService, deps: [{ token: CouponService }, { token: 'CheckoutRepository' }, { token: 'UserRepository' }, { token: DEFAULT_SHOP }, { token: PERSISTENCE_PROVIDER }], target: i0.ɵɵFactoryTarget.Injectable });
+CheckoutService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () {
+        return [{ type: CouponService }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['CheckoutRepository']
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['UserRepository']
+                    }] }, { type: i1$2.Shops, decorators: [{
+                        type: Inject,
+                        args: [DEFAULT_SHOP]
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [PERSISTENCE_PROVIDER]
+                    }] }];
     } });
 
-class CartService {
-    constructor(authService, checkoutService, defaultShop, productRepository, categoryRepository, variantRepository, buy2WinRepository) {
-        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) => {
-            var _a;
-            const items = [];
-            const index = (_a = checkoutLoaded.lineItems) === null || _a === void 0 ? void 0 : _a.map((checkoutItem) => checkoutItem.id).indexOf(lineItem.id);
-            if (index > -1) {
-                checkoutLoaded.lineItems[index].quantity += quantity;
-                checkoutLoaded.lineItems[index].pricePaid = lineItem.pricePaid;
-            }
-            else
-                checkoutLoaded.lineItems = items.concat(checkoutLoaded.lineItems ? checkoutLoaded.lineItems.concat([lineItem]) : [lineItem]);
-            return this.checkoutService
-                .updateCheckoutLineItems(checkoutLoaded)
-                .pipe(map((updatedCheckout) => this.generateCartObject(updatedCheckout.lineItems)));
-        }));
-        this.generateCartObject = (items) => (items === null || items === void 0 ? void 0 : items.reduce((cart, item) => {
-            var _a;
-            return (Object.assign(Object.assign({}, cart), { [item.id]: LineItem.toInstance(Object.assign(Object.assign({}, (cart[item.id] || item)), { quantity: (((_a = cart[item.id]) === null || _a === void 0 ? void 0 : _a.quantity) || 0) + (item.quantity ? item.quantity : 1) })) }));
-        }, {})) || {};
-        this.buildLineItem = ({ checkout, item, quantity, }) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g;
-            const product = yield this.getProductData(item.id);
-            item.quantity = (item === null || item === void 0 ? void 0 : item.quantity) || ((_b = (_a = checkout === null || checkout === void 0 ? void 0 : checkout.lineItems) === null || _a === void 0 ? void 0 : _a.find((lineItem) => lineItem.id === item.id)) === null || _b === void 0 ? void 0 : _b.quantity) || 0;
-            if (this.checkMaxStock(product.stock.quantity, item.quantity || 0, quantity || 0))
-                throw new Error('Desculpe! Temos apenas ' + ((_c = product.stock) === null || _c === void 0 ? void 0 : _c.quantity) + ' em estoque.');
-            const image = item.image || ((_d = item.images) === null || _d === void 0 ? void 0 : _d.shift());
-            const { id, name, EAN, slug, stock, price, weight, sku, type } = item;
-            const isGift = item.isGift || null;
-            const pricePaid = this.getProductPrice({
-                product: item,
-                shop: checkout.shop || this.defaultShop,
-                isSubscriber: (_e = checkout.user) === null || _e === void 0 ? void 0 : _e.isSubscriber,
-            });
-            RoundProductPricesHelper.roundProductPrices(item);
-            return {
-                checkout,
-                lineItem: LineItem.toInstance({
-                    id,
-                    name: name !== null && name !== void 0 ? name : product.name,
-                    EAN: EAN !== null && EAN !== void 0 ? EAN : product.EAN,
-                    brand: product.brand,
-                    slug: slug !== null && slug !== void 0 ? slug : product.slug,
-                    sku: sku !== null && sku !== void 0 ? sku : product.sku,
-                    stock,
-                    price: this.roundPrice(price),
-                    image,
-                    weight: weight !== null && weight !== void 0 ? weight : product.weight,
-                    quantity: (item.quantity || 0) + (quantity || 0),
-                    pricePaid,
-                    discount: 0,
-                    categories: (_f = product.categories) !== null && _f !== void 0 ? _f : [],
-                    isGift: isGift !== null && isGift !== void 0 ? isGift : null,
-                    costPrice: (_g = product.costPrice) !== null && _g !== void 0 ? _g : 0,
-                    type,
-                }),
-            };
-        });
-        this.getProductPrice = ({ product, isSubscriber, }) => {
-            const info = product.price;
-            if (product.isGift)
-                return 0;
-            return isSubscriber && info.subscriberPrice > 0
-                ? Number(info.subscriberPrice.toFixed(2))
-                : Number(info.price.toFixed(2));
-        };
-        this.checkMaxStock = (currentStock, currentItemQtd, quantityToAdd) => {
-            const maxStock = currentStock || 0;
-            const currentItemAmount = currentItemQtd || 0;
-            return currentItemAmount + quantityToAdd > maxStock;
-        };
-    }
-    addItem(item, quantity = 1) {
-        return from(this.checkoutService.getCheckout()).pipe(concatMap((checkout) => __awaiter(this, void 0, void 0, function* () { return yield this.buildLineItem({ checkout, item, quantity: quantity || 1 }); })), mergeMap(({ checkout, lineItem }) => this.updateLineItemInCart(lineItem, quantity || 1, checkout)), tap((cart) => this.cartSubject.next(cart)));
-    }
-    decreaseItem(item) {
-        return this.checkoutService.getCheckout().pipe(map((checkout) => {
-            var _a;
-            const checkoutItem = (_a = checkout.lineItems) === null || _a === void 0 ? void 0 : _a.find((lineItem) => lineItem.id === item.id);
-            if (!isNil(checkoutItem))
-                checkoutItem.quantity -= checkoutItem.quantity > 1 ? 1 : 0;
-            return checkout;
-        }), concatMap((checkout) => this.checkoutService.updateCheckoutLineItems(checkout)), map((checkout) => this.generateCartObject(checkout.lineItems)), tap((cart) => this.cartSubject.next(cart)));
-    }
-    getCart(checkout) {
-        this.buildCartFromCheckout(checkout).subscribe((cart) => this.cartSubject.next(cart));
-        return this.cartSubject;
-    }
-    /**
-     * @deprecated The method should not be used
-     */
-    getVariantPriceDiscount(item) {
-        return this.authService.getUser().pipe(concatMap((user) => iif(() => user.isSubscriber && !!item.price.subscriberPrice, of(item.price.subscriberPrice), of(item.price.price))), catchError(() => of(item.price.price)));
-    }
-    removeItem(item) {
-        return this.checkoutService.getCheckout().pipe(map((checkout) => {
-            const index = checkout.lineItems.findIndex((lineItem) => lineItem.id === item.id);
-            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(Object.assign(Object.assign({}, checkout.toPlain()), { user })))), concatMap((checkout) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            return yield this.checkoutService
-                .updateCheckoutLineItems(Checkout.toInstance(Object.assign(Object.assign({}, checkout.toPlain()), { lineItems: ((_a = checkout.lineItems) === null || _a === void 0 ? void 0 : _a.length)
-                    ? yield Promise.all((_b = checkout.lineItems) === null || _b === void 0 ? void 0 : _b.map((item) => __awaiter(this, void 0, void 0, function* () { return (yield 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) => {
-            this.checkoutService.clearCheckoutFromSession();
-            return checkout;
-        }), concatMap((oldCheckout) => this.buildCartFromCheckout(oldCheckout)), tap((cart) => this.cartSubject.next(cart)));
-    }
-    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 Object.assign(Object.assign(Object.assign({}, productPrice), { price: Number(price.toFixed(2)), fullPrice: Number(fullPrice.toFixed(2)) }), (subscriberPrice && { subscriberPrice: Number(subscriberPrice.toFixed(2)) }));
-    }
-    getProductData(productId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let product;
-            let variant;
-            try {
-                product = yield this.productRepository.get({ id: productId });
-            }
-            catch (error) {
-                if (!(error instanceof NotFoundError))
-                    throw error;
-                const { data: variants } = yield this.variantRepository.find({ filters: { id: productId } });
-                variant = variants.shift();
-                if (!variant)
-                    throw error;
-                product = yield this.productRepository.get({ id: variant.productId });
-            }
-            return Object.assign(Object.assign({}, product.toPlain()), (variant && Object.assign({}, variant.toPlain())));
-        });
-    }
-    getGifts() {
-        return this.checkoutService.getCheckout().pipe(mergeMap((checkout) => __awaiter(this, void 0, void 0, function* () {
-            const notGiftItems = checkout.lineItems ? checkout.lineItems.filter((item) => !item.isGift) : [];
-            if (!notGiftItems.length)
-                return Object.assign(Object.assign({}, checkout), { lineItems: [] });
-            const cartTotal = notGiftItems.reduce((a, b) => a + b.pricePaid * b.quantity, 0);
-            const campaigns = yield 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 Object.assign(Object.assign({}, checkout), { lineItems: notGiftItems });
-            const elegibleCampaigns = [];
-            for (const campaign of campaigns) {
-                const today = new Date().getTime();
-                if (!(campaign.startDate.getTime() <= today) && !(campaign.endDate.getTime() >= today))
-                    continue;
-                if (campaign.activeCategory) {
-                    const categoriesCampaing = campaign.categories.map((c) => c.id.toString());
-                    const categoriesCampaingFullTree = [];
-                    for (const id of categoriesCampaing) {
-                        const children = yield 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) => {
-                        var _a;
-                        if (!l.categories || !((_a = l.categories) === null || _a === void 0 ? void 0 : _a.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 Object.assign(Object.assign({}, checkout), { lineItems: notGiftItems });
-            const campaingnProducts = [];
-            for (const campaign of elegibleCampaigns) {
-                let elegibleProducts = [];
-                for (const product of campaign.products) {
-                    const { data: productData } = yield 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 Object.assign(Object.assign({}, checkout), { lineItems: notGiftItems });
-            const gifts = this.giftToLineItems([].concat(...campaingnProducts));
-            return Object.assign(Object.assign({}, 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) => {
-            var _a;
-            const { brand, categories, id, name, price, sku, slug, stock, weight, EAN } = item;
-            const image = ((_a = item === null || item === void 0 ? void 0 : item.miniatures) === null || _a === void 0 ? void 0 : _a.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.ɵ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$2.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$2.Buy2WinFirestoreRepository, decorators: [{
-                        type: Inject,
-                        args: ['Buy2WinRepository']
-                    }] }];
+class CartService {
+    constructor(authService, checkoutService, defaultShop, productRepository, categoryRepository, variantRepository, buy2WinRepository) {
+        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) => {
+            var _a;
+            const items = [];
+            const index = (_a = checkoutLoaded.lineItems) === null || _a === void 0 ? void 0 : _a.map((checkoutItem) => checkoutItem.id).indexOf(lineItem.id);
+            if (index > -1) {
+                checkoutLoaded.lineItems[index].quantity += quantity;
+                checkoutLoaded.lineItems[index].pricePaid = lineItem.pricePaid;
+            }
+            else
+                checkoutLoaded.lineItems = items.concat(checkoutLoaded.lineItems ? checkoutLoaded.lineItems.concat([lineItem]) : [lineItem]);
+            return this.checkoutService
+                .updateCheckoutLineItems(checkoutLoaded)
+                .pipe(map((updatedCheckout) => this.generateCartObject(updatedCheckout.lineItems)));
+        }));
+        this.generateCartObject = (items) => (items === null || items === void 0 ? void 0 : items.reduce((cart, item) => {
+            var _a;
+            return (Object.assign(Object.assign({}, cart), { [item.id]: LineItem.toInstance(Object.assign(Object.assign({}, (cart[item.id] || item)), { quantity: (((_a = cart[item.id]) === null || _a === void 0 ? void 0 : _a.quantity) || 0) + (item.quantity ? item.quantity : 1) })) }));
+        }, {})) || {};
+        this.buildLineItem = ({ checkout, item, quantity, }) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g;
+            const product = yield this.getProductData(item.id);
+            item.quantity = (item === null || item === void 0 ? void 0 : item.quantity) || ((_b = (_a = checkout === null || checkout === void 0 ? void 0 : checkout.lineItems) === null || _a === void 0 ? void 0 : _a.find((lineItem) => lineItem.id === item.id)) === null || _b === void 0 ? void 0 : _b.quantity) || 0;
+            if (this.checkMaxStock(product.stock.quantity, item.quantity || 0, quantity || 0))
+                throw new Error('Desculpe! Temos apenas ' + ((_c = product.stock) === null || _c === void 0 ? void 0 : _c.quantity) + ' em estoque.');
+            const image = item.image || ((_d = item.images) === null || _d === void 0 ? void 0 : _d.shift());
+            const { id, name, EAN, slug, stock, price, weight, sku, type } = item;
+            const isGift = item.isGift || null;
+            const pricePaid = this.getProductPrice({
+                product: item,
+                shop: checkout.shop || this.defaultShop,
+                isSubscriber: (_e = checkout.user) === null || _e === void 0 ? void 0 : _e.isSubscriber,
+            });
+            RoundProductPricesHelper.roundProductPrices(item);
+            return {
+                checkout,
+                lineItem: LineItem.toInstance({
+                    id,
+                    name: name !== null && name !== void 0 ? name : product.name,
+                    EAN: EAN !== null && EAN !== void 0 ? EAN : product.EAN,
+                    brand: product.brand,
+                    slug: slug !== null && slug !== void 0 ? slug : product.slug,
+                    sku: sku !== null && sku !== void 0 ? sku : product.sku,
+                    stock,
+                    price: this.roundPrice(price),
+                    image,
+                    weight: weight !== null && weight !== void 0 ? weight : product.weight,
+                    quantity: (item.quantity || 0) + (quantity || 0),
+                    pricePaid,
+                    discount: 0,
+                    categories: (_f = product.categories) !== null && _f !== void 0 ? _f : [],
+                    isGift: isGift !== null && isGift !== void 0 ? isGift : null,
+                    costPrice: (_g = product.costPrice) !== null && _g !== void 0 ? _g : 0,
+                    type,
+                }),
+            };
+        });
+        this.getProductPrice = ({ product, isSubscriber, }) => {
+            const info = product.price;
+            if (product.isGift)
+                return 0;
+            return isSubscriber && info.subscriberPrice > 0
+                ? Number(info.subscriberPrice.toFixed(2))
+                : Number(info.price.toFixed(2));
+        };
+        this.checkMaxStock = (currentStock, currentItemQtd, quantityToAdd) => {
+            const maxStock = currentStock || 0;
+            const currentItemAmount = currentItemQtd || 0;
+            return currentItemAmount + quantityToAdd > maxStock;
+        };
+    }
+    addItem(item, quantity = 1) {
+        return from(this.checkoutService.getCheckout()).pipe(concatMap((checkout) => __awaiter(this, void 0, void 0, function* () { return yield this.buildLineItem({ checkout, item, quantity: quantity || 1 }); })), mergeMap(({ checkout, lineItem }) => this.updateLineItemInCart(lineItem, quantity || 1, checkout)), tap((cart) => this.cartSubject.next(cart)));
+    }
+    decreaseItem(item) {
+        return this.checkoutService.getCheckout().pipe(map((checkout) => {
+            var _a;
+            const checkoutItem = (_a = checkout.lineItems) === null || _a === void 0 ? void 0 : _a.find((lineItem) => lineItem.id === item.id);
+            if (!isNil(checkoutItem))
+                checkoutItem.quantity -= checkoutItem.quantity > 1 ? 1 : 0;
+            return checkout;
+        }), concatMap((checkout) => this.checkoutService.updateCheckoutLineItems(checkout)), map((checkout) => this.generateCartObject(checkout.lineItems)), tap((cart) => this.cartSubject.next(cart)));
+    }
+    getCart(checkout) {
+        this.buildCartFromCheckout(checkout).subscribe((cart) => this.cartSubject.next(cart));
+        return this.cartSubject;
+    }
+    /**
+     * @deprecated The method should not be used
+     */
+    getVariantPriceDiscount(item) {
+        return this.authService.getUser().pipe(concatMap((user) => iif(() => user.isSubscriber && !!item.price.subscriberPrice, of(item.price.subscriberPrice), of(item.price.price))), catchError(() => of(item.price.price)));
+    }
+    removeItem(item) {
+        return this.checkoutService.getCheckout().pipe(map((checkout) => {
+            const index = checkout.lineItems.findIndex((lineItem) => lineItem.id === item.id);
+            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(Object.assign(Object.assign({}, checkout.toPlain()), { user })))), concatMap((checkout) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            return yield this.checkoutService
+                .updateCheckoutLineItems(Checkout.toInstance(Object.assign(Object.assign({}, checkout.toPlain()), { lineItems: ((_a = checkout.lineItems) === null || _a === void 0 ? void 0 : _a.length)
+                    ? yield Promise.all((_b = checkout.lineItems) === null || _b === void 0 ? void 0 : _b.map((item) => __awaiter(this, void 0, void 0, function* () { return (yield 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) => {
+            this.checkoutService.clearCheckoutFromSession();
+            return checkout;
+        }), concatMap((oldCheckout) => this.buildCartFromCheckout(oldCheckout)), tap((cart) => this.cartSubject.next(cart)));
+    }
+    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 Object.assign(Object.assign(Object.assign({}, productPrice), { price: Number(price.toFixed(2)), fullPrice: Number(fullPrice.toFixed(2)) }), (subscriberPrice && { subscriberPrice: Number(subscriberPrice.toFixed(2)) }));
+    }
+    getProductData(productId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let product;
+            let variant;
+            try {
+                product = yield this.productRepository.get({ id: productId });
+            }
+            catch (error) {
+                if (!(error instanceof NotFoundError))
+                    throw error;
+                const { data: variants } = yield this.variantRepository.find({ filters: { id: productId } });
+                variant = variants.shift();
+                if (!variant)
+                    throw error;
+                product = yield this.productRepository.get({ id: variant.productId });
+            }
+            return Object.assign(Object.assign({}, product.toPlain()), (variant && Object.assign({}, variant.toPlain())));
+        });
+    }
+    getGifts() {
+        return this.checkoutService.getCheckout().pipe(mergeMap((checkout) => __awaiter(this, void 0, void 0, function* () {
+            const notGiftItems = checkout.lineItems ? checkout.lineItems.filter((item) => !item.isGift) : [];
+            if (!notGiftItems.length)
+                return Object.assign(Object.assign({}, checkout), { lineItems: [] });
+            const cartTotal = notGiftItems.reduce((a, b) => a + b.pricePaid * b.quantity, 0);
+            const campaigns = yield 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 Object.assign(Object.assign({}, checkout), { lineItems: notGiftItems });
+            const elegibleCampaigns = [];
+            for (const campaign of campaigns) {
+                const today = new Date().getTime();
+                if (!(campaign.startDate.getTime() <= today) && !(campaign.endDate.getTime() >= today))
+                    continue;
+                if (campaign.activeCategory) {
+                    const categoriesCampaing = campaign.categories.map((c) => c.id.toString());
+                    const categoriesCampaingFullTree = [];
+                    for (const id of categoriesCampaing) {
+                        const children = yield 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) => {
+                        var _a;
+                        if (!l.categories || !((_a = l.categories) === null || _a === void 0 ? void 0 : _a.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 Object.assign(Object.assign({}, checkout), { lineItems: notGiftItems });
+            const campaingnProducts = [];
+            for (const campaign of elegibleCampaigns) {
+                let elegibleProducts = [];
+                for (const product of campaign.products) {
+                    const { data: productData } = yield 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 Object.assign(Object.assign({}, checkout), { lineItems: notGiftItems });
+            const gifts = this.giftToLineItems([].concat(...campaingnProducts));
+            return Object.assign(Object.assign({}, 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) => {
+            var _a;
+            const { brand, categories, id, name, price, sku, slug, stock, weight, EAN } = item;
+            const image = ((_a = item === null || item === void 0 ? void 0 : item.miniatures) === null || _a === void 0 ? void 0 : _a.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.ɵ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$2.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$2.Buy2WinFirestoreRepository, decorators: [{
+                        type: Inject,
+                        args: ['Buy2WinRepository']
+                    }] }];
     } });
 
-class NewCategoryStructureAdapter {
-    constructor(categoryRepository) {
-        this.categoryRepository = categoryRepository;
-    }
-    buildProductFilterByCategory(category) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const loadedCategory = yield this.getCategory(category);
-            if (loadedCategory.isCollection)
-                return { id: { operator: Where.IN, value: loadedCategory.products } };
-            const categoryIds = [...(yield this.getAllCategoriesIdFromCategory(category)), category.id.toString()];
-            return {
-                category: {
-                    id: {
-                        operator: Where.IN,
-                        value: categoryIds,
-                    },
-                },
-            };
-        });
-    }
-    getAllCategoriesIdFromCategory(category) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.categoryRepository
-                .getChildren(+category.id)
-                .then((categories) => categories.map((category) => category.id.toString()));
-        });
-    }
-    getCategory(category) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const collectionCategory = category.isCollection ||
-                (isNil(category.isCollection) && !((_a = category.products) === null || _a === void 0 ? void 0 : _a.length)) ||
-                category.isWishlist ||
-                category.brandCategory;
-            return collectionCategory ? this.categoryRepository.get({ id: category.id }) : category;
-        });
-    }
-}
-NewCategoryStructureAdapter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: NewCategoryStructureAdapter, deps: [{ token: 'CategoryRepository' }], 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']
-                    }] }];
+class NewCategoryStructureAdapter {
+    constructor(categoryRepository) {
+        this.categoryRepository = categoryRepository;
+    }
+    buildProductFilterByCategory(category) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const loadedCategory = yield this.getCategory(category);
+            if (loadedCategory.isCollection)
+                return { id: { operator: Where.IN, value: loadedCategory.products } };
+            const categoryIds = [...(yield this.getAllCategoriesIdFromCategory(category)), category.id.toString()];
+            return {
+                category: {
+                    id: {
+                        operator: Where.IN,
+                        value: categoryIds,
+                    },
+                },
+            };
+        });
+    }
+    getAllCategoriesIdFromCategory(category) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.categoryRepository
+                .getChildren(+category.id)
+                .then((categories) => categories.map((category) => category.id.toString()));
+        });
+    }
+    getCategory(category) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const collectionCategory = category.isCollection ||
+                (isNil(category.isCollection) && !((_a = category.products) === null || _a === void 0 ? void 0 : _a.length)) ||
+                category.isWishlist ||
+                category.brandCategory;
+            return collectionCategory ? this.categoryRepository.get({ id: category.id }) : category;
+        });
+    }
+}
+NewCategoryStructureAdapter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: NewCategoryStructureAdapter, deps: [{ token: 'CategoryRepository' }], 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']
+                    }] }];
     } });
 
-class OldCategoryStructureAdapter {
-    constructor(categoryRepository) {
-        this.categoryRepository = categoryRepository;
-    }
-    buildProductFilterByCategory(category) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const productsIds = ((_a = category.products) === null || _a === void 0 ? void 0 : _a.length)
-                ? category.products
-                : yield 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 OldCategoryStructureAdapter {
+    constructor(categoryRepository) {
+        this.categoryRepository = categoryRepository;
+    }
+    buildProductFilterByCategory(category) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const productsIds = ((_a = category.products) === null || _a === void 0 ? void 0 : _a.length)
+                ? category.products
+                : yield 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 CatalogService {
-    constructor(productRepository, productStockNotificationRepository, categoryRepository, categoryStructureAdapter, shop, productIndex) {
-        this.productRepository = productRepository;
-        this.productStockNotificationRepository = productStockNotificationRepository;
-        this.categoryRepository = categoryRepository;
-        this.categoryStructureAdapter = categoryStructureAdapter;
-        this.shop = shop;
-        this.productIndex = productIndex;
-        this.productsByTerm = {};
-        this.buildFilterQuery = ({ clubDiscount, brands, prices, gender, tags, rate, customOptions, }) => {
-            const filters = {};
-            if (clubDiscount === null || clubDiscount === void 0 ? void 0 : clubDiscount.length)
-                set(filters, 'price.subscriberDiscountPercentage', { operator: Where.IN, value: clubDiscount });
-            if (brands === null || brands === void 0 ? void 0 : brands.length)
-                filters.brand = { operator: Where.IN, value: brands };
-            if (gender === null || gender === void 0 ? void 0 : gender.length)
-                filters.gender = { operator: Where.IN, value: gender };
-            if ((prices === null || prices === void 0 ? void 0 : prices.min) || (prices === null || prices === void 0 ? void 0 : 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 === null || tags === void 0 ? void 0 : tags.length)
-                filters.tags = { operator: Where.LIKE, value: tags };
-            if (customOptions === null || customOptions === void 0 ? void 0 : 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',
-                    rate: 'desc',
-                    stock: 'desc',
-                    name: 'asc',
-                };
-            if (sort === 'biggest-price')
-                return { subscriberPrice: 'desc', rate: 'desc', shoppingCount: 'desc' };
-            if (sort === 'lowest-price')
-                return { subscriberPrice: 'asc', rate: 'desc', shoppingCount: 'desc' };
-            if (sort === 'best-rating')
-                return { rate: 'desc', shoppingCount: 'desc', stock: 'desc', name: 'asc' };
-            if (sort === 'news')
-                return { createdAt: 'desc' };
-            if (sort === 'biggest-discount')
-                return { subscriberDiscountPercentage: 'desc', rate: 'desc', shoppingCount: 'desc' };
-        };
-        this.buildLimitQuery = (options) => {
-            const limit = (options === null || options === void 0 ? void 0 : options.perPage) || 20;
-            return {
-                limit,
-                offset: (((options === null || options === void 0 ? void 0 : options.page) || 1) - 1) * limit,
-            };
-        };
-        this.hasProfile = (options) => 'profile' in options;
-        this.hasTerm = (options) => 'term' in options;
-        this.hasCategory = (options) => 'category' in options;
-    }
-    fetchProducts(options) {
-        var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            const limits = this.buildLimitQuery(options);
-            if (this.hasProfile(options) && ((_a = options.filters) === null || _a === void 0 ? void 0 : _a.customOptions))
-                throw new InvalidArgumentError(`It couldn't filled customOptions when profile is given`);
-            if (this.hasProfile(options) && ((_b = options.filters) === null || _b === void 0 ? void 0 : _b.tags))
-                throw new InvalidArgumentError(`It couldn't filled tags when profile is given`);
-            if (this.hasTerm(options) && ((_c = options.filters) === null || _c === void 0 ? void 0 : _c.customOptions))
-                throw new InvalidArgumentError(`It couldn't filled customOptions when term is given`);
-            return yield this.findCatalog(options, limits).then(({ data, count: total, maximum, minimal, distinct }) => {
-                var _a, _b, _c, _d, _e, _f, _g, _h;
-                return ({
-                    products: { data: data.map((product) => RoundProductPricesHelper.roundProductPrices(product)), total },
-                    pages: Math.ceil(total / limits.limit),
-                    prices: {
-                        price: { min: +((_b = (_a = minimal === null || minimal === void 0 ? void 0 : minimal.price) === null || _a === void 0 ? void 0 : _a.price) === null || _b === void 0 ? void 0 : _b.toFixed(2)), max: +((_d = (_c = maximum === null || maximum === void 0 ? void 0 : maximum.price) === null || _c === void 0 ? void 0 : _c.price) === null || _d === void 0 ? void 0 : _d.toFixed(2)) },
-                        subscriberPrice: {
-                            min: +((_f = (_e = minimal === null || minimal === void 0 ? void 0 : minimal.price) === null || _e === void 0 ? void 0 : _e.subscriberPrice) === null || _f === void 0 ? void 0 : _f.toFixed(2)),
-                            max: +((_h = (_g = maximum === null || maximum === void 0 ? void 0 : maximum.price) === null || _g === void 0 ? void 0 : _g.subscriberPrice) === null || _h === void 0 ? void 0 : _h.toFixed(2)),
-                        },
-                    },
-                    brands: distinct === null || distinct === void 0 ? void 0 : distinct.brand,
-                });
-            });
-        });
-    }
-    addCustomerToStockNotification(shop, productId, name, email) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.productStockNotificationRepository.addCustomerEmail(shop, productId, name, email);
-        });
-    }
-    findCatalog(options, limits) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.hasTerm(options) && options.sort === 'most-relevant') {
-                const productsIds = yield this.findCatalogIdsByElasticSearch(options.term);
-                return this.findCatalogAndSortByMostRevelantByTerm(productsIds, options, limits);
-            }
-            if (this.hasCategory(options) && options.sort === 'most-relevant') {
-                const mostRelevant = (_a = options.category.mostRelevant) !== null && _a !== void 0 ? _a : [];
-                const productsIds = yield this.productRepository
-                    .findCatalog({
-                    fields: ['id'],
-                    filters: Object.assign(Object.assign({}, (yield this.buildMainFilter(options))), this.buildFilterQuery((options === null || options === void 0 ? void 0 : options.filters) || {})),
-                })
-                    .then((products) => products.data.map((product) => product.id));
-                return this.findCatalogAndSortByMostRevelant(mostRelevant, productsIds, options, limits);
-            }
-            const repoParams = Object.assign(Object.assign({ filters: Object.assign(Object.assign({}, (yield this.buildMainFilter(options))), this.buildFilterQuery((options === null || options === void 0 ? void 0 : options.filters) || {})) }, ((options === null || options === void 0 ? void 0 : options.sort) ? { orderBy: this.buildSortQuery(options === null || options === void 0 ? void 0 : options.sort) } : {})), { limits, options: Object.assign({ minimal: ['price'], maximum: ['price'] }, (!this.hasCategory(options) ? { distinct: ['brand'] } : {})) });
-            if (['biggest-price', 'lowest-price', 'biggest-discount', 'best-rating'].includes(options.sort))
-                return this.productRepository.findCatalog(repoParams);
-            return this.productRepository.findCatalog(repoParams, (options === null || options === void 0 ? void 0 : options.mainGender) || this.shop === Shops.MENSMARKET ? 'male' : 'female');
-        });
-    }
-    buildMainFilter({ category, profile, term, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (category)
-                return this.categoryStructureAdapter.buildProductFilterByCategory(category);
-            if (profile)
-                return { tags: { operator: Where.LIKE, value: profile } };
-            if (term)
-                return this.productIndex
-                    .search(term, 999, this.shop)
-                    .then((data) => ({ id: { operator: Where.IN, value: data.hits.map(({ _source }) => _source.id) } }));
-        });
-    }
-    findCatalogAndSortByMostRevelant(mostRelevants, productIds, options, limits) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const mostRelevantProductsIds = [...new Set(mostRelevants.concat(productIds))];
-            const totalResult = yield this.productRepository.findCatalog({
-                filters: Object.assign({ id: { operator: Where.IN, value: mostRelevantProductsIds } }, this.buildFilterQuery((options === null || options === void 0 ? void 0 : options.filters) || {})),
-                orderBy: this.buildSortQuery('news'),
-                options: {
-                    minimal: ['price'],
-                    maximum: ['price'],
-                    distinct: ['brand'],
-                },
-            }, (options === null || options === void 0 ? void 0 : options.mainGender) || this.shop === Shops.MENSMARKET ? 'male' : 'female');
-            const firstProducts = totalResult.data.filter((product) => mostRelevants.includes(product.id));
-            const lastProducts = totalResult.data.filter((product) => !mostRelevants.includes(product.id));
-            const categoryMostRelevants = firstProducts.concat(lastProducts);
-            const resultFinal = categoryMostRelevants.slice(limits.offset, limits.offset + limits.limit);
-            return {
-                data: resultFinal,
-                count: totalResult.count,
-                maximum: totalResult.maximum,
-                minimal: totalResult.minimal,
-                distinct: totalResult.distinct,
-            };
-        });
-    }
-    findCatalogAndSortByMostRevelantByTerm(productIds, options, limits) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const totalResult = yield this.productRepository.findCatalog({
-                fields: ['id', 'stock'],
-                filters: Object.assign({ id: { operator: Where.IN, value: productIds } }, this.buildFilterQuery((options === null || options === void 0 ? void 0 : options.filters) || {})),
-                options: {
-                    minimal: ['price'],
-                    maximum: ['price'],
-                    distinct: ['brand'],
-                },
-            }, (options === null || options === void 0 ? void 0 : options.mainGender) || this.shop === Shops.MENSMARKET ? 'male' : 'female');
-            const stockData = totalResult.data.filter((product) => product.stock.quantity > 0);
-            const stockOut = totalResult.data.filter((product) => product.stock.quantity <= 0);
-            const productIdsStock = productIds.filter((product) => stockData.some((result) => result.id == product));
-            const productIdsStockOut = productIds.filter((product) => stockOut.some((result) => result.id == product));
-            const limitedProductId = productIdsStock
-                .concat(productIdsStockOut)
-                .slice(limits.offset, limits.offset + limits.limit);
-            const orderedId = productIds.filter((product) => limitedProductId.includes(product));
-            const productResult = yield this.productRepository.findCatalog({
-                filters: {
-                    id: { operator: Where.IN, value: orderedId },
-                },
-            });
-            return {
-                data: limitedProductId.map((id) => productResult.data.find((product) => product.id === id)).filter(Boolean),
-                count: totalResult.count,
-                maximum: totalResult.maximum,
-                minimal: totalResult.minimal,
-                distinct: totalResult.distinct,
-            };
-        });
-    }
-    findCatalogIdsByElasticSearch(term) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.productsByTerm[term])
-                return this.productsByTerm[term];
-            return (this.productsByTerm[term] = yield this.productIndex
-                .search(term, 999, this.shop)
-                .then(({ hits: products }) => {
-                const withStock = products.filter(({ _source }) => _source.stock.quantity > 0);
-                const withOutStock = products.filter(({ _source }) => _source.stock.quantity <= 0);
-                const sorted = [...withStock, ...withOutStock];
-                return [...new Set(sorted.map(({ _source }) => _source.id))];
-            }));
-        });
-    }
-}
-CatalogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogService, deps: [{ token: 'ProductRepository' }, { token: 'ProductStockNotificationRepository' }, { token: 'CategoryRepository' }, { token: CATEGORY_STRUCTURE }, { token: DEFAULT_SHOP }, { token: i1$2.ProductsIndex }], 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: ['ProductStockNotificationRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['CategoryRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: [CATEGORY_STRUCTURE]
-                    }] }, { type: i1$2.Shops, decorators: [{
-                        type: Inject,
-                        args: [DEFAULT_SHOP]
-                    }] }, { type: i1$2.ProductsIndex }];
+class CatalogService {
+    constructor(productRepository, productStockNotificationRepository, categoryRepository, categoryStructureAdapter, shop, productIndex) {
+        this.productRepository = productRepository;
+        this.productStockNotificationRepository = productStockNotificationRepository;
+        this.categoryRepository = categoryRepository;
+        this.categoryStructureAdapter = categoryStructureAdapter;
+        this.shop = shop;
+        this.productIndex = productIndex;
+        this.productsByTerm = {};
+        this.buildFilterQuery = ({ clubDiscount, brands, prices, gender, tags, rate, customOptions, }) => {
+            const filters = {};
+            if (clubDiscount === null || clubDiscount === void 0 ? void 0 : clubDiscount.length)
+                set(filters, 'price.subscriberDiscountPercentage', { operator: Where.IN, value: clubDiscount });
+            if (brands === null || brands === void 0 ? void 0 : brands.length)
+                filters.brand = { operator: Where.IN, value: brands };
+            if (gender === null || gender === void 0 ? void 0 : gender.length)
+                filters.gender = { operator: Where.IN, value: gender };
+            if ((prices === null || prices === void 0 ? void 0 : prices.min) || (prices === null || prices === void 0 ? void 0 : 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 === null || tags === void 0 ? void 0 : tags.length)
+                filters.tags = { operator: Where.LIKE, value: tags };
+            if (customOptions === null || customOptions === void 0 ? void 0 : 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',
+                    rate: 'desc',
+                    stock: 'desc',
+                    name: 'asc',
+                };
+            if (sort === 'biggest-price')
+                return { subscriberPrice: 'desc', rate: 'desc', shoppingCount: 'desc' };
+            if (sort === 'lowest-price')
+                return { subscriberPrice: 'asc', rate: 'desc', shoppingCount: 'desc' };
+            if (sort === 'best-rating')
+                return { rate: 'desc', shoppingCount: 'desc', stock: 'desc', name: 'asc' };
+            if (sort === 'news')
+                return { createdAt: 'desc' };
+            if (sort === 'biggest-discount')
+                return { subscriberDiscountPercentage: 'desc', rate: 'desc', shoppingCount: 'desc' };
+        };
+        this.buildLimitQuery = (options) => {
+            const limit = (options === null || options === void 0 ? void 0 : options.perPage) || 20;
+            return {
+                limit,
+                offset: (((options === null || options === void 0 ? void 0 : options.page) || 1) - 1) * limit,
+            };
+        };
+        this.hasProfile = (options) => 'profile' in options;
+        this.hasTerm = (options) => 'term' in options;
+        this.hasCategory = (options) => 'category' in options;
+    }
+    fetchProducts(options) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const limits = this.buildLimitQuery(options);
+            if (this.hasProfile(options) && ((_a = options.filters) === null || _a === void 0 ? void 0 : _a.customOptions))
+                throw new InvalidArgumentError(`It couldn't filled customOptions when profile is given`);
+            if (this.hasProfile(options) && ((_b = options.filters) === null || _b === void 0 ? void 0 : _b.tags))
+                throw new InvalidArgumentError(`It couldn't filled tags when profile is given`);
+            if (this.hasTerm(options) && ((_c = options.filters) === null || _c === void 0 ? void 0 : _c.customOptions))
+                throw new InvalidArgumentError(`It couldn't filled customOptions when term is given`);
+            return yield this.findCatalog(options, limits).then(({ data, count: total, maximum, minimal, distinct }) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h;
+                return ({
+                    products: { data: data.map((product) => RoundProductPricesHelper.roundProductPrices(product)), total },
+                    pages: Math.ceil(total / limits.limit),
+                    prices: {
+                        price: { min: +((_b = (_a = minimal === null || minimal === void 0 ? void 0 : minimal.price) === null || _a === void 0 ? void 0 : _a.price) === null || _b === void 0 ? void 0 : _b.toFixed(2)), max: +((_d = (_c = maximum === null || maximum === void 0 ? void 0 : maximum.price) === null || _c === void 0 ? void 0 : _c.price) === null || _d === void 0 ? void 0 : _d.toFixed(2)) },
+                        subscriberPrice: {
+                            min: +((_f = (_e = minimal === null || minimal === void 0 ? void 0 : minimal.price) === null || _e === void 0 ? void 0 : _e.subscriberPrice) === null || _f === void 0 ? void 0 : _f.toFixed(2)),
+                            max: +((_h = (_g = maximum === null || maximum === void 0 ? void 0 : maximum.price) === null || _g === void 0 ? void 0 : _g.subscriberPrice) === null || _h === void 0 ? void 0 : _h.toFixed(2)),
+                        },
+                    },
+                    brands: distinct === null || distinct === void 0 ? void 0 : distinct.brand,
+                });
+            });
+        });
+    }
+    addCustomerToStockNotification(shop, productId, name, email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.productStockNotificationRepository.addCustomerEmail(shop, productId, name, email);
+        });
+    }
+    findCatalog(options, limits) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.hasTerm(options) && options.sort === 'most-relevant') {
+                const productsIds = yield this.findCatalogIdsByElasticSearch(options.term);
+                return this.findCatalogAndSortByMostRevelantByTerm(productsIds, options, limits);
+            }
+            if (this.hasCategory(options) && options.sort === 'most-relevant') {
+                const mostRelevant = (_a = options.category.getMostRelevantByShop(this.shop)) !== null && _a !== void 0 ? _a : [];
+                const productsIds = yield this.productRepository
+                    .findCatalog({
+                    fields: ['id'],
+                    filters: Object.assign(Object.assign({}, (yield this.buildMainFilter(options))), this.buildFilterQuery((options === null || options === void 0 ? void 0 : options.filters) || {})),
+                })
+                    .then((products) => products.data.map((product) => product.id));
+                return this.findCatalogAndSortByMostRevelant(mostRelevant, productsIds, options, limits);
+            }
+            const repoParams = Object.assign(Object.assign({ filters: Object.assign(Object.assign({}, (yield this.buildMainFilter(options))), this.buildFilterQuery((options === null || options === void 0 ? void 0 : options.filters) || {})) }, ((options === null || options === void 0 ? void 0 : options.sort) ? { orderBy: this.buildSortQuery(options === null || options === void 0 ? void 0 : options.sort) } : {})), { limits, options: Object.assign({ minimal: ['price'], maximum: ['price'] }, (!this.hasCategory(options) ? { distinct: ['brand'] } : {})) });
+            if (['biggest-price', 'lowest-price', 'biggest-discount', 'best-rating'].includes(options.sort))
+                return this.productRepository.findCatalog(repoParams);
+            return this.productRepository.findCatalog(repoParams, (options === null || options === void 0 ? void 0 : options.mainGender) || this.shop === Shops.MENSMARKET ? 'male' : 'female');
+        });
+    }
+    buildMainFilter({ category, profile, term, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (category)
+                return this.categoryStructureAdapter.buildProductFilterByCategory(category);
+            if (profile)
+                return { tags: { operator: Where.LIKE, value: profile } };
+            if (term)
+                return this.productIndex
+                    .search(term, 999, this.shop)
+                    .then((data) => ({ id: { operator: Where.IN, value: data.hits.map(({ _source }) => _source.id) } }));
+        });
+    }
+    findCatalogAndSortByMostRevelant(mostRelevants, productIds, options, limits) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mostRelevantProductsIds = [...new Set(mostRelevants.concat(productIds))];
+            const totalResult = yield this.productRepository.findCatalog({
+                filters: Object.assign({ id: { operator: Where.IN, value: mostRelevantProductsIds } }, this.buildFilterQuery((options === null || options === void 0 ? void 0 : options.filters) || {})),
+                orderBy: this.buildSortQuery('news'),
+                options: {
+                    minimal: ['price'],
+                    maximum: ['price'],
+                    distinct: ['brand'],
+                },
+            }, (options === null || options === void 0 ? void 0 : options.mainGender) || this.shop === Shops.MENSMARKET ? 'male' : 'female');
+            const firstProducts = totalResult.data.filter((product) => mostRelevants.includes(product.id));
+            const lastProducts = totalResult.data.filter((product) => !mostRelevants.includes(product.id));
+            const categoryMostRelevants = firstProducts.concat(lastProducts);
+            const resultFinal = categoryMostRelevants.slice(limits.offset, limits.offset + limits.limit);
+            return {
+                data: resultFinal,
+                count: totalResult.count,
+                maximum: totalResult.maximum,
+                minimal: totalResult.minimal,
+                distinct: totalResult.distinct,
+            };
+        });
+    }
+    findCatalogAndSortByMostRevelantByTerm(productIds, options, limits) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const totalResult = yield this.productRepository.findCatalog({
+                fields: ['id', 'stock'],
+                filters: Object.assign({ id: { operator: Where.IN, value: productIds } }, this.buildFilterQuery((options === null || options === void 0 ? void 0 : options.filters) || {})),
+                options: {
+                    minimal: ['price'],
+                    maximum: ['price'],
+                    distinct: ['brand'],
+                },
+            }, (options === null || options === void 0 ? void 0 : options.mainGender) || this.shop === Shops.MENSMARKET ? 'male' : 'female');
+            const stockData = totalResult.data.filter((product) => product.stock.quantity > 0);
+            const stockOut = totalResult.data.filter((product) => product.stock.quantity <= 0);
+            const productIdsStock = productIds.filter((product) => stockData.some((result) => result.id == product));
+            const productIdsStockOut = productIds.filter((product) => stockOut.some((result) => result.id == product));
+            const limitedProductId = productIdsStock
+                .concat(productIdsStockOut)
+                .slice(limits.offset, limits.offset + limits.limit);
+            const orderedId = productIds.filter((product) => limitedProductId.includes(product));
+            const productResult = yield this.productRepository.findCatalog({
+                filters: {
+                    id: { operator: Where.IN, value: orderedId },
+                },
+            });
+            return {
+                data: limitedProductId.map((id) => productResult.data.find((product) => product.id === id)).filter(Boolean),
+                count: totalResult.count,
+                maximum: totalResult.maximum,
+                minimal: totalResult.minimal,
+                distinct: totalResult.distinct,
+            };
+        });
+    }
+    findCatalogIdsByElasticSearch(term) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.productsByTerm[term])
+                return this.productsByTerm[term];
+            return (this.productsByTerm[term] = yield this.productIndex
+                .search(term, 999, this.shop)
+                .then(({ hits: products }) => {
+                const withStock = products.filter(({ _source }) => _source.stock.quantity > 0);
+                const withOutStock = products.filter(({ _source }) => _source.stock.quantity <= 0);
+                const sorted = [...withStock, ...withOutStock];
+                return [...new Set(sorted.map(({ _source }) => _source.id))];
+            }));
+        });
+    }
+}
+CatalogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogService, deps: [{ token: 'ProductRepository' }, { token: 'ProductStockNotificationRepository' }, { token: 'CategoryRepository' }, { token: CATEGORY_STRUCTURE }, { token: DEFAULT_SHOP }, { token: i1$2.ProductsIndex }], 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: ['ProductStockNotificationRepository']
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['CategoryRepository']
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [CATEGORY_STRUCTURE]
+                    }] }, { type: i1$2.Shops, decorators: [{
+                        type: Inject,
+                        args: [DEFAULT_SHOP]
+                    }] }, { type: i1$2.ProductsIndex }];
     } });
 
-class CategoryService {
-    constructor(productRepository, categoryRepository, categoryFilterRepository, categoryStructureAdapter, shop) {
-        this.productRepository = productRepository;
-        this.categoryRepository = categoryRepository;
-        this.categoryFilterRepository = categoryFilterRepository;
-        this.categoryStructureAdapter = categoryStructureAdapter;
-        this.shop = shop;
-    }
-    fetchBrands(category, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const brands = yield this.productRepository
-                .findCatalog({
-                filters: yield this.categoryStructureAdapter.buildProductFilterByCategory(category),
-                fields: ['brand'],
-            }, (options === null || options === void 0 ? void 0 : options.mainGender) ? options === null || options === void 0 ? void 0 : options.mainGender : this.shop === Shops.MENSMARKET ? 'male' : 'female')
-                .then(({ data }) => Object.keys(data.map((product) => product.brand).reduce((brands, brand) => (Object.assign(Object.assign({}, brands), { [brand]: true })), {})));
-            return this.categoryRepository
-                .find({ filters: { brandCategory: true, shop: (options === null || options === void 0 ? void 0 : options.shop) || this.shop }, orderBy: { name: 'asc' } })
-                .then(({ data }) => data.filter((category) => brands.includes(category.conditions.brand)));
-        });
-    }
-    fetchFilterOptions(category) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield 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$2.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;
+    }
+    fetchBrands(category, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const brands = yield this.productRepository
+                .findCatalog({
+                filters: yield this.categoryStructureAdapter.buildProductFilterByCategory(category),
+                fields: ['brand'],
+            }, (options === null || options === void 0 ? void 0 : options.mainGender) ? options === null || options === void 0 ? void 0 : options.mainGender : this.shop === Shops.MENSMARKET ? 'male' : 'female')
+                .then(({ data }) => Object.keys(data.map((product) => product.brand).reduce((brands, brand) => (Object.assign(Object.assign({}, brands), { [brand]: true })), {})));
+            return this.categoryRepository
+                .find({ filters: { brandCategory: true, shop: (options === null || options === void 0 ? void 0 : options.shop) || this.shop }, orderBy: { name: 'asc' } })
+                .then(({ data }) => data.filter((category) => brands.includes(category.conditions.brand)));
+        });
+    }
+    fetchFilterOptions(category) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield 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$2.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";
+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)
+class CategoryWithTree extends Category {
+}
+__decorate([
+    Type(() => CategoryWithTree),
+    __metadata("design:type", Array)
 ], CategoryWithTree.prototype, "children", void 0);
 
-class WishlistService {
-    constructor(wishlistRepository, shop, productRepository, categoryFilterRepository, categoryRepository, productStockNotificationRepository, productIndex) {
-        this.wishlistRepository = wishlistRepository;
-        this.shop = shop;
-        const categoryStructureAdapter = new NewCategoryStructureAdapter(wishlistRepository);
-        this.catalogService = new CatalogService(productRepository, productStockNotificationRepository, categoryRepository, categoryStructureAdapter, shop, productIndex);
-        this.categoryService = new CategoryService(productRepository, categoryRepository, categoryFilterRepository, categoryStructureAdapter, shop);
-    }
-    getCatalogService() {
-        return this.catalogService;
-    }
-    getCategoryService() {
-        return this.categoryService;
-    }
-    create({ personId, title, description, published, userFullName, userPhoto, theme, bannerUrl, personType, personIsSubscriber, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                slug: '',
-                name: title,
-                description,
-                metadata: {
-                    title: `${userFullName} - ${title}`,
-                    description: `${userFullName} - ${description}`,
-                },
-                shop: this.shop,
-                shops: [this.shop],
-                personId,
-                personName: userFullName,
-                personPhoto: userPhoto,
-                brandCategory: false,
-                published,
-                theme,
-                bannerUrl,
-                personType: personType !== null && personType !== void 0 ? personType : PersonTypes.NONE,
-                personIsSubscriber: personIsSubscriber !== null && personIsSubscriber !== void 0 ? personIsSubscriber : false,
-            };
-            const newWishlist = yield this.wishlistRepository.create(data);
-            yield this.wishlistRepository.update({ id: newWishlist.id, slug: newWishlist.id });
-            return Wishlist.toInstance(Object.assign(Object.assign({}, newWishlist.toPlain()), { slug: newWishlist.id }));
-        });
-    }
-    update({ id, title, description, published, userFullName, userPhoto, theme, bannerUrl, personType, personIsSubscriber, }) {
-        const data = {
-            id,
-            name: title,
-            description,
-            published,
-            metadata: {
-                title: `${userFullName} - ${title}`,
-                description: `${userFullName} - ${description}`,
-            },
-            personName: userFullName,
-            personPhoto: userPhoto,
-            theme,
-            bannerUrl,
-            personType: personType !== null && personType !== void 0 ? personType : PersonTypes.NONE,
-            personIsSubscriber: personIsSubscriber !== null && personIsSubscriber !== void 0 ? personIsSubscriber : false,
-        };
-        return this.wishlistRepository.update(data);
-    }
-    delete(wishlistId) {
-        return this.wishlistRepository.delete({ id: wishlistId });
-    }
-    getWishlistBySlug(slug) {
-        const [id] = slug.split('-');
-        if (+id)
-            return this.wishlistRepository.get({ id });
-        return this.wishlistRepository.getWishlistBySlug(slug);
-    }
-    getWishlistsByPerson(personId) {
-        return this.wishlistRepository.getWishlistByPerson(personId);
-    }
-    addProduct(wishlistId, productId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const wishlist = yield 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;
-        });
-    }
-    removeProduct(wishlistId, productId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const wishlist = yield 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: [{ token: 'WishlistRepository' }, { token: DEFAULT_SHOP }, { token: 'ProductRepository' }, { token: 'CategoryFilterRepository' }, { token: 'CategoryRepository' }, { token: 'ProductStockNotificationRepository' }, { token: i1$2.ProductsIndex }], 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: i1$2.Shops, decorators: [{
-                        type: Inject,
-                        args: [DEFAULT_SHOP]
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['ProductRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['CategoryFilterRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['CategoryRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['ProductStockNotificationRepository']
-                    }] }, { type: i1$2.ProductsIndex }];
+class WishlistService {
+    constructor(wishlistRepository, shop, productRepository, categoryFilterRepository, categoryRepository, productStockNotificationRepository, productIndex) {
+        this.wishlistRepository = wishlistRepository;
+        this.shop = shop;
+        const categoryStructureAdapter = new NewCategoryStructureAdapter(wishlistRepository);
+        this.catalogService = new CatalogService(productRepository, productStockNotificationRepository, categoryRepository, categoryStructureAdapter, shop, productIndex);
+        this.categoryService = new CategoryService(productRepository, categoryRepository, categoryFilterRepository, categoryStructureAdapter, shop);
+    }
+    getCatalogService() {
+        return this.catalogService;
+    }
+    getCategoryService() {
+        return this.categoryService;
+    }
+    create({ personId, title, description, published, userFullName, userPhoto, theme, bannerUrl, personType, personIsSubscriber, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = {
+                slug: '',
+                name: title,
+                description,
+                metadata: [
+                    {
+                        shop: this.shop,
+                        title: `${userFullName} - ${title}`,
+                        description: `${userFullName} - ${description}`,
+                    },
+                ],
+                shop: this.shop,
+                shops: [this.shop],
+                personId,
+                personName: userFullName,
+                personPhoto: userPhoto,
+                brandCategory: false,
+                published,
+                theme,
+                bannerUrl,
+                personType: personType !== null && personType !== void 0 ? personType : PersonTypes.NONE,
+                personIsSubscriber: personIsSubscriber !== null && personIsSubscriber !== void 0 ? personIsSubscriber : false,
+            };
+            const newWishlist = yield this.wishlistRepository.create(data);
+            yield this.wishlistRepository.update({ id: newWishlist.id, slug: newWishlist.id });
+            return Wishlist.toInstance(Object.assign(Object.assign({}, newWishlist.toPlain()), { slug: newWishlist.id }));
+        });
+    }
+    update({ id, title, description, published, userFullName, userPhoto, theme, bannerUrl, personType, personIsSubscriber, }) {
+        const data = {
+            id,
+            name: title,
+            description,
+            published,
+            metadata: [
+                {
+                    shop: this.shop,
+                    title: `${userFullName} - ${title}`,
+                    description: `${userFullName} - ${description}`,
+                },
+            ],
+            personName: userFullName,
+            personPhoto: userPhoto,
+            theme,
+            bannerUrl,
+            personType: personType !== null && personType !== void 0 ? personType : PersonTypes.NONE,
+            personIsSubscriber: personIsSubscriber !== null && personIsSubscriber !== void 0 ? personIsSubscriber : false,
+        };
+        return this.wishlistRepository.update(data);
+    }
+    delete(wishlistId) {
+        return this.wishlistRepository.delete({ id: wishlistId });
+    }
+    getWishlistBySlug(slug) {
+        const [id] = slug.split('-');
+        if (+id)
+            return this.wishlistRepository.get({ id });
+        return this.wishlistRepository.getWishlistBySlug(slug);
+    }
+    getWishlistsByPerson(personId) {
+        return this.wishlistRepository.getWishlistByPerson(personId);
+    }
+    addProduct(wishlistId, productId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wishlist = yield 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;
+        });
+    }
+    removeProduct(wishlistId, productId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wishlist = yield 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: [{ token: 'WishlistRepository' }, { token: DEFAULT_SHOP }, { token: 'ProductRepository' }, { token: 'CategoryFilterRepository' }, { token: 'CategoryRepository' }, { token: 'ProductStockNotificationRepository' }, { token: i1$2.ProductsIndex }], 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: i1$2.Shops, decorators: [{
+                        type: Inject,
+                        args: [DEFAULT_SHOP]
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['ProductRepository']
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['CategoryFilterRepository']
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['CategoryRepository']
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['ProductStockNotificationRepository']
+                    }] }, { type: i1$2.ProductsIndex }];
     } });
 
-class CheckoutSubscriptionService {
-    constructor(checkoutSubscriptionRepository, dataPersistence, couponService) {
-        this.checkoutSubscriptionRepository = checkoutSubscriptionRepository;
-        this.dataPersistence = dataPersistence;
-        this.couponService = couponService;
-    }
-    getCheckoutSubscription(checkoutData) {
-        return this.dataPersistence
-            .get('checkoutSubscriptionId')
-            .pipe(concatMap((id) => !isNil(id) ? this.checkoutSubscriptionRepository.get({ id }) : this.createCheckoutSubscription(checkoutData)));
-    }
-    clearCheckoutSubscriptionFromSession() {
-        return this.dataPersistence.remove('checkoutSubscriptionId');
-    }
-    checkCoupon(nickname, userEmail) {
-        return this.getCheckoutSubscription().pipe(concatMap((checkout) => this.couponService
-            .checkCoupon(nickname, CheckoutTypes.SUBSCRIPTION, checkout, checkout.subscriptionPlan.name)
-            .pipe()));
-    }
-    calcDiscountSubscription(coupon) {
-        return this.getCheckoutSubscription().pipe(concatMap((checkout) => this.couponService.calcDiscountSubscription(coupon, checkout).pipe()));
-    }
-    createCheckoutSubscription(checkoutData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const checkout = yield this.checkoutSubscriptionRepository.create(Object.assign({ createdAt: new Date() }, CheckoutSubscription.toInstance(pick(checkoutData, ['user', 'shop'])).toPlain()));
-            yield this.dataPersistence.set('checkoutSubscriptionId', checkout.id).toPromise();
-            return checkout;
-        });
-    }
-}
-CheckoutSubscriptionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutSubscriptionService, deps: [{ token: 'CheckoutSubscriptionRepository' }, { token: PERSISTENCE_PROVIDER }, { token: CouponService }], target: i0.ɵɵFactoryTarget.Injectable });
-CheckoutSubscriptionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutSubscriptionService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutSubscriptionService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['CheckoutSubscriptionRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: [PERSISTENCE_PROVIDER]
-                    }] }, { type: CouponService }];
+class CheckoutSubscriptionService {
+    constructor(checkoutSubscriptionRepository, dataPersistence, couponService) {
+        this.checkoutSubscriptionRepository = checkoutSubscriptionRepository;
+        this.dataPersistence = dataPersistence;
+        this.couponService = couponService;
+    }
+    getCheckoutSubscription(checkoutData) {
+        return this.dataPersistence
+            .get('checkoutSubscriptionId')
+            .pipe(concatMap((id) => !isNil(id) ? this.checkoutSubscriptionRepository.get({ id }) : this.createCheckoutSubscription(checkoutData)));
+    }
+    clearCheckoutSubscriptionFromSession() {
+        return this.dataPersistence.remove('checkoutSubscriptionId');
+    }
+    checkCoupon(nickname, userEmail) {
+        return this.getCheckoutSubscription().pipe(concatMap((checkout) => this.couponService
+            .checkCoupon(nickname, CheckoutTypes.SUBSCRIPTION, checkout, checkout.subscriptionPlan.name)
+            .pipe()));
+    }
+    calcDiscountSubscription(coupon) {
+        return this.getCheckoutSubscription().pipe(concatMap((checkout) => this.couponService.calcDiscountSubscription(coupon, checkout).pipe()));
+    }
+    createCheckoutSubscription(checkoutData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const checkout = yield this.checkoutSubscriptionRepository.create(Object.assign({ createdAt: new Date() }, CheckoutSubscription.toInstance(pick(checkoutData, ['user', 'shop'])).toPlain()));
+            yield this.dataPersistence.set('checkoutSubscriptionId', checkout.id).toPromise();
+            return checkout;
+        });
+    }
+}
+CheckoutSubscriptionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutSubscriptionService, deps: [{ token: 'CheckoutSubscriptionRepository' }, { token: PERSISTENCE_PROVIDER }, { token: CouponService }], target: i0.ɵɵFactoryTarget.Injectable });
+CheckoutSubscriptionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutSubscriptionService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutSubscriptionService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['CheckoutSubscriptionRepository']
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [PERSISTENCE_PROVIDER]
+                    }] }, { type: CouponService }];
     } });
 
-class UtilHelper {
-    static 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 -
-    }
+class UtilHelper {
+    static 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 -
+    }
 }
 
-class HomeShopService {
-    get homeId() {
-        if (this.defaultShop === Shops.GLAMSHOP)
-            return 'glamshop';
-        if (this.defaultShop === Shops.MENSMARKET)
-            return 'mens_market';
-        return null;
-    }
-    constructor(categoryRepository, homeRepository, productRepository, defaultShop) {
-        this.categoryRepository = categoryRepository;
-        this.homeRepository = homeRepository;
-        this.productRepository = productRepository;
-        this.defaultShop = defaultShop;
-        this.buildCategoryGroupWithRequiredData = (group) => {
-            var _a, _b;
-            return ({
-                category: Category.toInstance(pick(((_a = group === null || group === void 0 ? void 0 : group.category) === null || _a === void 0 ? void 0 : _a.toPlain()) || {}, ['id', 'name', 'slug', 'conditions'])),
-                products: ((_b = group === null || group === void 0 ? void 0 : group.products) === null || _b === void 0 ? void 0 : _b.map((product) => Product.toInstance(pick((product === null || product === void 0 ? void 0 : product.toPlain()) || {}, [
-                    'id',
-                    'price',
-                    'reviews',
-                    'hasVariants',
-                    'slug',
-                    'sku',
-                    'stock',
-                    'costPrice',
-                    'images',
-                    'miniatures',
-                    'name',
-                    'weight',
-                    'rate',
-                    'type',
-                    'brand',
-                ])))) || [],
-            });
-        };
-    }
-    getHomeData() {
-        return this.getHomeConfiguration().pipe(map((home) => { var _a; return (((_a = home === null || home === void 0 ? void 0 : home.data) === null || _a === void 0 ? void 0 : _a.expiresAt) > new Date() ? home : null); }), concatMap((home) => home
-            ? of(home)
-            : forkJoin([
-                this.getDiscoverProducts(this.gender),
-                this.getFeaturedProducts(this.gender),
-                this.getVerticalProducts(this.gender),
-            ]).pipe(map(([discoverProducts, featuredProducts, verticalProducts]) => ({
-                discoverProducts,
-                featuredProducts,
-                verticalProducts,
-            })), concatMap((data) => this.saveHomeData(data)))));
-    }
-    getBanners(type) {
-        return this.getHomeConfiguration().pipe(map((home) => {
-            if (type === 'brand')
-                return home.brandsCarousel;
-            if (type === 'buyToWin')
-                return [home.buyToWinBanner];
-            if (type === 'block')
-                return home.blockBanners;
-            if (type === 'blog')
-                return [home.blogBanner];
-            return [];
-        }));
-    }
-    getMinValueForFreeShipping() {
-        return this.getHomeConfiguration().pipe(map((home) => home.minValueForFreeShipping));
-    }
-    getDiscoverProducts(gender) {
-        return this.getHomeConfiguration().pipe(concatMap((home) => from(this.categoryRepository.getCategoriesForHome(home.discoverCategories, undefined, gender)).pipe(map((groups) => groups.map(this.buildCategoryGroupWithRequiredData)))));
-    }
-    getFeaturedProducts(gender) {
-        return this.getHomeConfiguration().pipe(concatMap((home) => from(this.categoryRepository.getCategoriesForHome(home.featuredCategories, undefined, gender)).pipe(map((groups) => groups.map(this.buildCategoryGroupWithRequiredData)))));
-    }
-    getVerticalProducts(gender) {
-        return this.getHomeConfiguration().pipe(concatMap((home) => forkJoin(home.verticalCarousels.filter(Boolean).map((id) => from(this.categoryRepository.get({ id })).pipe(concatMap((category) => from(this.productRepository.find({
-            filters: Object.assign({ categories: { operator: Where.IN, value: [category.id] } }, (gender ? { tags: { operator: Where.IN, value: [gender] } } : {})),
-            limits: { limit: 12 },
-        })).pipe(map((products) => ({ category, products })))), map(({ category, products }) => ({ category, products: products.data })), map(this.buildCategoryGroupWithRequiredData))))));
-    }
-    getHomeConfiguration() {
-        return of(this.homeConfiguration).pipe(concatMap((home) => home
-            ? of(home)
-            : !this.homeId
-                ? throwError(new RequiredArgumentError(['homeId']))
-                : from(this.homeRepository.get({ id: this.homeId })).pipe(tap((homeLoaded) => (this.homeConfiguration = homeLoaded)))));
-    }
-    saveHomeData(homeData) {
-        const data = {
-            createdAt: new Date(),
-            expiresAt: add(new Date(), { hours: 1 }),
-            data: homeData,
-        };
-        return from(this.homeRepository.update({
-            id: this.homeId,
-            data,
-        })).pipe(tap(() => (this.homeConfiguration.data = data)), map(() => this.homeConfiguration));
-    }
-    get gender() {
-        return this.homeId === 'mens_market' ? 'masculino' : undefined;
-    }
-}
-HomeShopService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: HomeShopService, deps: [{ token: 'CategoryRepository' }, { token: 'HomeRepository' }, { token: 'ProductRepository' }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable });
-HomeShopService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: HomeShopService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: HomeShopService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['CategoryRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['HomeRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['ProductRepository']
-                    }] }, { type: i1$2.Shops, decorators: [{
-                        type: Inject,
-                        args: [DEFAULT_SHOP]
-                    }] }];
+class HomeShopService {
+    get homeId() {
+        if (this.defaultShop === Shops.GLAMSHOP)
+            return 'glamshop';
+        if (this.defaultShop === Shops.MENSMARKET)
+            return 'mens_market';
+        return null;
+    }
+    constructor(categoryRepository, homeRepository, productRepository, defaultShop) {
+        this.categoryRepository = categoryRepository;
+        this.homeRepository = homeRepository;
+        this.productRepository = productRepository;
+        this.defaultShop = defaultShop;
+        this.buildCategoryGroupWithRequiredData = (group) => {
+            var _a, _b;
+            return ({
+                category: Category.toInstance(pick(((_a = group === null || group === void 0 ? void 0 : group.category) === null || _a === void 0 ? void 0 : _a.toPlain()) || {}, ['id', 'name', 'slug', 'conditions'])),
+                products: ((_b = group === null || group === void 0 ? void 0 : group.products) === null || _b === void 0 ? void 0 : _b.map((product) => Product.toInstance(pick((product === null || product === void 0 ? void 0 : product.toPlain()) || {}, [
+                    'id',
+                    'price',
+                    'reviews',
+                    'hasVariants',
+                    'slug',
+                    'sku',
+                    'stock',
+                    'costPrice',
+                    'images',
+                    'miniatures',
+                    'name',
+                    'weight',
+                    'rate',
+                    'type',
+                    'brand',
+                ])))) || [],
+            });
+        };
+    }
+    getHomeData() {
+        return this.getHomeConfiguration().pipe(map((home) => { var _a; return (((_a = home === null || home === void 0 ? void 0 : home.data) === null || _a === void 0 ? void 0 : _a.expiresAt) > new Date() ? home : null); }), concatMap((home) => home
+            ? of(home)
+            : forkJoin([
+                this.getDiscoverProducts(this.gender),
+                this.getFeaturedProducts(this.gender),
+                this.getVerticalProducts(this.gender),
+            ]).pipe(map(([discoverProducts, featuredProducts, verticalProducts]) => ({
+                discoverProducts,
+                featuredProducts,
+                verticalProducts,
+            })), concatMap((data) => this.saveHomeData(data)))));
+    }
+    getBanners(type) {
+        return this.getHomeConfiguration().pipe(map((home) => {
+            if (type === 'brand')
+                return home.brandsCarousel;
+            if (type === 'buyToWin')
+                return [home.buyToWinBanner];
+            if (type === 'block')
+                return home.blockBanners;
+            if (type === 'blog')
+                return [home.blogBanner];
+            return [];
+        }));
+    }
+    getMinValueForFreeShipping() {
+        return this.getHomeConfiguration().pipe(map((home) => home.minValueForFreeShipping));
+    }
+    getDiscoverProducts(gender) {
+        return this.getHomeConfiguration().pipe(concatMap((home) => from(this.categoryRepository.getCategoriesForHome(home.discoverCategories, undefined, gender)).pipe(map((groups) => groups.map(this.buildCategoryGroupWithRequiredData)))));
+    }
+    getFeaturedProducts(gender) {
+        return this.getHomeConfiguration().pipe(concatMap((home) => from(this.categoryRepository.getCategoriesForHome(home.featuredCategories, undefined, gender)).pipe(map((groups) => groups.map(this.buildCategoryGroupWithRequiredData)))));
+    }
+    getVerticalProducts(gender) {
+        return this.getHomeConfiguration().pipe(concatMap((home) => forkJoin(home.verticalCarousels.filter(Boolean).map((id) => from(this.categoryRepository.get({ id })).pipe(concatMap((category) => from(this.productRepository.find({
+            filters: Object.assign({ categories: { operator: Where.IN, value: [category.id] } }, (gender ? { tags: { operator: Where.IN, value: [gender] } } : {})),
+            limits: { limit: 12 },
+        })).pipe(map((products) => ({ category, products })))), map(({ category, products }) => ({ category, products: products.data })), map(this.buildCategoryGroupWithRequiredData))))));
+    }
+    getHomeConfiguration() {
+        return of(this.homeConfiguration).pipe(concatMap((home) => home
+            ? of(home)
+            : !this.homeId
+                ? throwError(new RequiredArgumentError(['homeId']))
+                : from(this.homeRepository.get({ id: this.homeId })).pipe(tap((homeLoaded) => (this.homeConfiguration = homeLoaded)))));
+    }
+    saveHomeData(homeData) {
+        const data = {
+            createdAt: new Date(),
+            expiresAt: add(new Date(), { hours: 1 }),
+            data: homeData,
+        };
+        return from(this.homeRepository.update({
+            id: this.homeId,
+            data,
+        })).pipe(tap(() => (this.homeConfiguration.data = data)), map(() => this.homeConfiguration));
+    }
+    get gender() {
+        return this.homeId === 'mens_market' ? 'masculino' : undefined;
+    }
+}
+HomeShopService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: HomeShopService, deps: [{ token: 'CategoryRepository' }, { token: 'HomeRepository' }, { token: 'ProductRepository' }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable });
+HomeShopService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: HomeShopService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: HomeShopService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['CategoryRepository']
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['HomeRepository']
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['ProductRepository']
+                    }] }, { type: i1$2.Shops, decorators: [{
+                        type: Inject,
+                        args: [DEFAULT_SHOP]
+                    }] }];
     } });
 
-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: i1$2.OrderFirestoreRepository, decorators: [{
-                        type: Inject,
-                        args: ['OrderRepository']
-                    }] }];
+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: i1$2.OrderFirestoreRepository, decorators: [{
+                        type: Inject,
+                        args: ['OrderRepository']
+                    }] }];
     } });
 
-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 Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, s), { totalPrice: s.totalPrice / 2 });
-                    else
-                        return Object.assign(Object.assign({}, s), { totalPrice: 0 });
-                });
-            }
-            if (this.isHalfShippingBySubscription(shop, subscriptionPlan)) {
-                shippingMethods = shippingMethods.map((s) => {
-                    return Object.assign(Object.assign({}, 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;
-    }
-}
-ShippingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ShippingService, deps: [{ token: i1$3.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$3.HttpClient }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: [BACKEND_URL]
-                    }] }, { type: HomeShopService }];
+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 Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, s), { totalPrice: s.totalPrice / 2 });
+                    else
+                        return Object.assign(Object.assign({}, s), { totalPrice: 0 });
+                });
+            }
+            if (this.isHalfShippingBySubscription(shop, subscriptionPlan)) {
+                shippingMethods = shippingMethods.map((s) => {
+                    return Object.assign(Object.assign({}, 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;
+    }
+}
+ShippingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ShippingService, deps: [{ token: i1$3.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$3.HttpClient }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [BACKEND_URL]
+                    }] }, { type: HomeShopService }];
     } });
 
-class AngularConnectModule {
-    static initializeApp(defaultShop, options, nameOrConfig) {
-        return {
-            ngModule: AngularConnectModule,
-            providers: [
-                {
-                    provide: CATEGORY_STRUCTURE,
-                    useClass: isNil(options === null || options === void 0 ? void 0 : options.oldCategoryStructure) || (options === null || options === void 0 ? void 0 : options.oldCategoryStructure)
-                        ? OldCategoryStructureAdapter
-                        : NewCategoryStructureAdapter,
-                },
-                { provide: PERSISTENCE_PROVIDER, useClass: (options === null || options === void 0 ? void 0 : options.persistenceProvider) || CookieDataPersistence },
-                ...(isNil(defaultShop) ? [] : [{ provide: DEFAULT_SHOP, useValue: defaultShop }]),
-                ...(isNil(options === null || options === void 0 ? void 0 : options.firebase) ? [] : [{ provide: FIREBASE_OPTIONS, useValue: options === null || options === void 0 ? void 0 : options.firebase }]),
-                ...(isNil(options === null || options === void 0 ? void 0 : options.firebase) ? [] : [{ provide: FIREBASE_APP_NAME, useValue: nameOrConfig }]),
-                ...(isNil(options === null || options === void 0 ? void 0 : options.elasticSearch) ? [] : [{ provide: ES_CONFIG, useValue: options.elasticSearch }]),
-                ...(isNil(options === null || options === void 0 ? void 0 : options.hasura) ? [] : [{ provide: HASURA_OPTIONS, useValue: options.hasura }]),
-                ...(isNil(options === null || options === void 0 ? void 0 : options.backendUrl) ? [] : [{ provide: BACKEND_URL, useValue: options.backendUrl }]),
-                ...(isNil(options === null || options === void 0 ? void 0 : options.storageBaseUrl) ? [] : [{ provide: STORAGE_BASE_URL, useValue: options.storageBaseUrl }]),
-            ],
-        };
-    }
-}
-AngularConnectModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularConnectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AngularConnectModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularConnectModule, imports: [i1$4.FirebaseAppModule, i2.StorageModule, AngularElasticSeachModule,
-        AngularFirebaseAuthModule,
-        AngularFirestoreModule,
-        AngularHasuraGraphQLModule] });
-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,
-        {
-            provide: UpdateUserImage,
-            useFactory: (userRepository, fileUploader) => {
-                return new UpdateUserImage(userRepository, fileUploader);
-            },
-            deps: ['UserRepository', 'FileUploaderService'],
-        },
-        {
-            provide: 'FileUploaderService',
-            useFactory: (storage, baseUrl) => {
-                return new FirebaseFileUploaderService(storage, baseUrl);
-            },
-            deps: [Storage, STORAGE_BASE_URL],
-        },
-    ], imports: [provideFirebaseApp((injector) => {
-            const appName = injector.get(FIREBASE_APP_NAME) || '[DEFAULT]';
-            try {
-                return getApp(appName);
-            }
-            catch (error) {
-                return initializeApp(injector.get(FIREBASE_OPTIONS), appName);
-            }
-        }),
-        provideStorage((injector) => getStorage(injector.get(FirebaseApp))),
-        AngularElasticSeachModule,
-        AngularFirebaseAuthModule,
-        AngularFirestoreModule,
-        AngularHasuraGraphQLModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularConnectModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [
-                        provideFirebaseApp((injector) => {
-                            const appName = injector.get(FIREBASE_APP_NAME) || '[DEFAULT]';
-                            try {
-                                return getApp(appName);
-                            }
-                            catch (error) {
-                                return initializeApp(injector.get(FIREBASE_OPTIONS), appName);
-                            }
-                        }),
-                        provideStorage((injector) => getStorage(injector.get(FirebaseApp))),
-                        AngularElasticSeachModule,
-                        AngularFirebaseAuthModule,
-                        AngularFirestoreModule,
-                        AngularHasuraGraphQLModule,
-                    ],
-                    providers: [
-                        AuthService,
-                        CartService,
-                        CatalogService,
-                        CategoryService,
-                        CheckoutService,
-                        CheckoutSubscriptionService,
-                        CouponService,
-                        HomeShopService,
-                        OrderService,
-                        ShippingService,
-                        WishlistService,
-                        {
-                            provide: UpdateUserImage,
-                            useFactory: (userRepository, fileUploader) => {
-                                return new UpdateUserImage(userRepository, fileUploader);
-                            },
-                            deps: ['UserRepository', 'FileUploaderService'],
-                        },
-                        {
-                            provide: 'FileUploaderService',
-                            useFactory: (storage, baseUrl) => {
-                                return new FirebaseFileUploaderService(storage, baseUrl);
-                            },
-                            deps: [Storage, STORAGE_BASE_URL],
-                        },
-                    ],
-                }]
+class AngularConnectModule {
+    static initializeApp(defaultShop, options, nameOrConfig) {
+        return {
+            ngModule: AngularConnectModule,
+            providers: [
+                {
+                    provide: CATEGORY_STRUCTURE,
+                    useClass: isNil(options === null || options === void 0 ? void 0 : options.oldCategoryStructure) || (options === null || options === void 0 ? void 0 : options.oldCategoryStructure)
+                        ? OldCategoryStructureAdapter
+                        : NewCategoryStructureAdapter,
+                },
+                { provide: PERSISTENCE_PROVIDER, useClass: (options === null || options === void 0 ? void 0 : options.persistenceProvider) || CookieDataPersistence },
+                ...(isNil(defaultShop) ? [] : [{ provide: DEFAULT_SHOP, useValue: defaultShop }]),
+                ...(isNil(options === null || options === void 0 ? void 0 : options.firebase) ? [] : [{ provide: FIREBASE_OPTIONS, useValue: options === null || options === void 0 ? void 0 : options.firebase }]),
+                ...(isNil(options === null || options === void 0 ? void 0 : options.firebase) ? [] : [{ provide: FIREBASE_APP_NAME, useValue: nameOrConfig }]),
+                ...(isNil(options === null || options === void 0 ? void 0 : options.elasticSearch) ? [] : [{ provide: ES_CONFIG, useValue: options.elasticSearch }]),
+                ...(isNil(options === null || options === void 0 ? void 0 : options.hasura) ? [] : [{ provide: HASURA_OPTIONS, useValue: options.hasura }]),
+                ...(isNil(options === null || options === void 0 ? void 0 : options.backendUrl) ? [] : [{ provide: BACKEND_URL, useValue: options.backendUrl }]),
+                ...(isNil(options === null || options === void 0 ? void 0 : options.storageBaseUrl) ? [] : [{ provide: STORAGE_BASE_URL, useValue: options.storageBaseUrl }]),
+            ],
+        };
+    }
+}
+AngularConnectModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularConnectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AngularConnectModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularConnectModule, imports: [i1$4.FirebaseAppModule, i2.StorageModule, AngularElasticSeachModule,
+        AngularFirebaseAuthModule,
+        AngularFirestoreModule,
+        AngularHasuraGraphQLModule] });
+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,
+        {
+            provide: UpdateUserImage,
+            useFactory: (userRepository, fileUploader) => {
+                return new UpdateUserImage(userRepository, fileUploader);
+            },
+            deps: ['UserRepository', 'FileUploaderService'],
+        },
+        {
+            provide: 'FileUploaderService',
+            useFactory: (storage, baseUrl) => {
+                return new FirebaseFileUploaderService(storage, baseUrl);
+            },
+            deps: [Storage, STORAGE_BASE_URL],
+        },
+    ], imports: [provideFirebaseApp((injector) => {
+            const appName = injector.get(FIREBASE_APP_NAME) || '[DEFAULT]';
+            try {
+                return getApp(appName);
+            }
+            catch (error) {
+                return initializeApp(injector.get(FIREBASE_OPTIONS), appName);
+            }
+        }),
+        provideStorage((injector) => getStorage(injector.get(FirebaseApp))),
+        AngularElasticSeachModule,
+        AngularFirebaseAuthModule,
+        AngularFirestoreModule,
+        AngularHasuraGraphQLModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularConnectModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        provideFirebaseApp((injector) => {
+                            const appName = injector.get(FIREBASE_APP_NAME) || '[DEFAULT]';
+                            try {
+                                return getApp(appName);
+                            }
+                            catch (error) {
+                                return initializeApp(injector.get(FIREBASE_OPTIONS), appName);
+                            }
+                        }),
+                        provideStorage((injector) => getStorage(injector.get(FirebaseApp))),
+                        AngularElasticSeachModule,
+                        AngularFirebaseAuthModule,
+                        AngularFirestoreModule,
+                        AngularHasuraGraphQLModule,
+                    ],
+                    providers: [
+                        AuthService,
+                        CartService,
+                        CatalogService,
+                        CategoryService,
+                        CheckoutService,
+                        CheckoutSubscriptionService,
+                        CouponService,
+                        HomeShopService,
+                        OrderService,
+                        ShippingService,
+                        WishlistService,
+                        {
+                            provide: UpdateUserImage,
+                            useFactory: (userRepository, fileUploader) => {
+                                return new UpdateUserImage(userRepository, fileUploader);
+                            },
+                            deps: ['UserRepository', 'FileUploaderService'],
+                        },
+                        {
+                            provide: 'FileUploaderService',
+                            useFactory: (storage, baseUrl) => {
+                                return new FirebaseFileUploaderService(storage, baseUrl);
+                            },
+                            deps: [Storage, STORAGE_BASE_URL],
+                        },
+                    ],
+                }]
         }] });
 
-/**
- * Generated bundle index. Do not edit.
+/**
+ * Generated bundle index. Do not edit.
  */
 
 export { AngularConnectModule, AngularFirebaseAuthModule, AngularFirestoreModule, AngularHasuraGraphQLModule, AuthService, CartService, CatalogService, CategoryService, CategoryWithTree, CheckoutService, CheckoutSubscriptionService, CookieDataPersistence, CouponService, HomeShopService, NewCategoryStructureAdapter, OldCategoryStructureAdapter, OrderService, ProductSorts, ShippingService, UtilHelper, WishlistService };