@infrab4a/connect-angular 5.4.6-beta.0 → 5.5.0-alpha.1

package/fesm2015/infrab4a-connect-angular.mjs

@@ -1,3491 +0,0 @@
-import * as i0 from '@angular/core';
-import { NgModule, InjectionToken, PLATFORM_ID, Injectable, Inject } from '@angular/core';
-import * as i1$3 from '@angular/fire/app';
-import { FirebaseApp, provideFirebaseApp, getApp, initializeApp } from '@angular/fire/app';
-import * as i2 from '@angular/fire/app-check';
-import { provideAppCheck, initializeAppCheck } from '@angular/fire/app-check';
-import * as i3$1 from '@angular/fire/storage';
-import { Storage, provideStorage, getStorage } from '@angular/fire/storage';
-import * as i3 from '@infrab4a/connect';
-import { ProductsIndex, AxiosAdapter, Authentication, AuthenticationFirebaseAuthService, Register, RegisterFirebaseAuthService, SignOut, RecoveryPassword, ConnectFirestoreService, UserBeautyProfileFirestoreRepository, Buy2WinFirestoreRepository, CategoryFirestoreRepository, CheckoutFirestoreRepository, CheckoutSubscriptionFirestoreRepository, CouponFirestoreRepository, CampaignHashtagFirestoreRepository, CampaignDashboardFirestoreRepository, SubscriptionEditionFirestoreRepository, GroupFirestoreRepository, HomeFirestoreRepository, LeadFirestoreRepository, LegacyOrderFirestoreRepository, ShopMenuFirestoreRepository, OrderFirestoreRepository, PaymentFirestoreRepository, ProductFirestoreRepository, ShopSettingsFirestoreRepository, SubscriptionPaymentFirestoreRepository, SubscriptionPlanFirestoreRepository, SubscriptionProductFirestoreRepository, SubscriptionFirestoreRepository, UserFirestoreRepository, UserAddressFirestoreRepository, UserPaymentMethodFirestoreRepository, SubscriptionMaterializationFirestoreRepository, SubscriptionSummaryFirestoreRepository, ProductVariantFirestoreRepository, OrderBlockedFirestoreRepository, LogFirestoreRepository, SequenceFirestoreRepository, CategoryHasuraGraphQLRepository, ProductHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository, ProductReviewHasuraGraphQLRepository, VariantHasuraGraphQLRepository, ProductStockNotificationHasuraGraphQLRepository, FilterOptionHasuraGraphQLRepository, FilterHasuraGraphQLRepository, CategoryCollectionChildrenHasuraGraphQLRepository, CategoryProductHasuraGraphQLRepository, WishlistHasuraGraphQLRepository, ProductErrorsHasuraGraphQLRepository, ProductsVertexSearch, VertexAxiosAdapter, isNil, NotFoundError, Checkout, pick, LineItem, Where, isEmpty, Shops, set, InvalidArgumentError, RoundProductPricesHelper, Category, WishlistLogType, PersonTypes, Wishlist, CheckoutTypes, CouponTypes, Exclusivities, OrderStatus, CheckoutSubscription, Product, RequiredArgumentError, add, ProductReview, Order, UpdateUserImage, FirebaseFileUploaderService } from '@infrab4a/connect';
-import * as i1 from '@angular/fire/auth';
-import { Auth, provideAuth, initializeAuth, indexedDBLocalPersistence, browserLocalPersistence, browserSessionPersistence, getAuth, getIdToken, authState } from '@angular/fire/auth';
-import { isPlatformBrowser, isPlatformServer } from '@angular/common';
-import * as i1$1 from '@angular/fire/firestore';
-import { Firestore, provideFirestore, initializeFirestore, memoryLocalCache, docSnapshots, doc } from '@angular/fire/firestore';
-import cookie from 'js-cookie';
-import { of, from, combineLatest, throwError, Subject, forkJoin } from 'rxjs';
-import { map, mergeMap, catchError, concatMap, tap } from 'rxjs/operators';
-import { __awaiter, __decorate, __metadata } from 'tslib';
-import * as i1$2 from '@angular/common/http';
-import { Type } from 'class-transformer';
-
-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],
-                        },
-                    ],
-                }]
-        }] });
-
-const BACKEND_URL = 'BACKEND_URL';
-
-const CATEGORY_STRUCTURE = 'CATEGORY_STRUCTURE';
-
-const DEFAULT_SHOP = 'DEFAULT_SHOP';
-
-const FIREBASE_APP_NAME = new InjectionToken('firebaseAppName');
-const FIREBASE_OPTIONS = new InjectionToken('firebaseOptions');
-const APP_CHECK_PROVIDER = new InjectionToken('appCheckProvider');
-
-const HASURA_OPTIONS = 'HASURA_OPTIONS';
-
-const PERSISTENCE_PROVIDER = 'PERSISTENCE_PROVIDER';
-
-const VERTEX_CONFIG = 'VERTEX_CONFIG';
-
-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) => {
-            const app = injector.get(FirebaseApp);
-            try {
-                return initializeAuth(app, {
-                    persistence: [indexedDBLocalPersistence, browserLocalPersistence, browserSessionPersistence],
-                });
-            }
-            catch (error) {
-                if (error instanceof Error)
-                    console.error('Error initializing auth', error.message);
-                return getAuth(app);
-            }
-        })] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirebaseAuthModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [
-                        provideAuth((injector) => {
-                            const app = injector.get(FirebaseApp);
-                            try {
-                                return initializeAuth(app, {
-                                    persistence: [indexedDBLocalPersistence, browserLocalPersistence, browserSessionPersistence],
-                                });
-                            }
-                            catch (error) {
-                                if (error instanceof Error)
-                                    console.error('Error initializing auth', error.message);
-                                return getAuth(app);
-                            }
-                        }),
-                    ],
-                    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 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: 'GroupRepository',
-            useFactory: (options) => {
-                return new GroupFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            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],
-        },
-        {
-            provide: 'OrderBlockedRepository',
-            useFactory: (options) => {
-                return new OrderBlockedFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'LogRepository',
-            useFactory: (options) => {
-                return new LogFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'SequenceRepository',
-            useFactory: (options) => {
-                return new SequenceFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-    ], 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: 'GroupRepository',
-                            useFactory: (options) => {
-                                return new GroupFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            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],
-                        },
-                        {
-                            provide: 'OrderBlockedRepository',
-                            useFactory: (options) => {
-                                return new OrderBlockedFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'LogRepository',
-                            useFactory: (options) => {
-                                return new LogFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                        {
-                            provide: 'SequenceRepository',
-                            useFactory: (options) => {
-                                return new SequenceFirestoreRepository(options);
-                            },
-                            deps: ['FirestoreOptions'],
-                        },
-                    ],
-                }]
-        }] });
-
-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,
-                cache: options.cache,
-                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: 'ProductReviewRepository',
-            useExisting: ProductReviewHasuraGraphQLRepository,
-        },
-        {
-            provide: ProductReviewHasuraGraphQLRepository,
-            useFactory: (hasuraConfig) => {
-                return new ProductReviewHasuraGraphQLRepository(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: CategoryProductHasuraGraphQLRepository,
-            useFactory: (options) => {
-                return new CategoryProductHasuraGraphQLRepository(options);
-            },
-            deps: ['HasuraConfig'],
-        },
-        {
-            provide: 'CategoryProductRepository',
-            useExisting: CategoryProductHasuraGraphQLRepository,
-        },
-        {
-            provide: WishlistHasuraGraphQLRepository,
-            useFactory: (options, categoryProductRepository) => {
-                return new WishlistHasuraGraphQLRepository(options, categoryProductRepository);
-            },
-            deps: ['HasuraConfig', CategoryProductHasuraGraphQLRepository],
-        },
-        {
-            provide: 'WishlistRepository',
-            useExisting: WishlistHasuraGraphQLRepository,
-        },
-        {
-            provide: ProductErrorsHasuraGraphQLRepository,
-            useFactory: (options, productRepository) => {
-                return new ProductErrorsHasuraGraphQLRepository(options, productRepository);
-            },
-            deps: ['HasuraConfig', ProductHasuraGraphQLRepository],
-        },
-        {
-            provide: 'ProductErrorsRepository',
-            useExisting: ProductErrorsHasuraGraphQLRepository,
-        },
-    ] });
-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,
-                                cache: options.cache,
-                                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: 'ProductReviewRepository',
-                            useExisting: ProductReviewHasuraGraphQLRepository,
-                        },
-                        {
-                            provide: ProductReviewHasuraGraphQLRepository,
-                            useFactory: (hasuraConfig) => {
-                                return new ProductReviewHasuraGraphQLRepository(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: CategoryProductHasuraGraphQLRepository,
-                            useFactory: (options) => {
-                                return new CategoryProductHasuraGraphQLRepository(options);
-                            },
-                            deps: ['HasuraConfig'],
-                        },
-                        {
-                            provide: 'CategoryProductRepository',
-                            useExisting: CategoryProductHasuraGraphQLRepository,
-                        },
-                        {
-                            provide: WishlistHasuraGraphQLRepository,
-                            useFactory: (options, categoryProductRepository) => {
-                                return new WishlistHasuraGraphQLRepository(options, categoryProductRepository);
-                            },
-                            deps: ['HasuraConfig', CategoryProductHasuraGraphQLRepository],
-                        },
-                        {
-                            provide: 'WishlistRepository',
-                            useExisting: WishlistHasuraGraphQLRepository,
-                        },
-                        {
-                            provide: ProductErrorsHasuraGraphQLRepository,
-                            useFactory: (options, productRepository) => {
-                                return new ProductErrorsHasuraGraphQLRepository(options, productRepository);
-                            },
-                            deps: ['HasuraConfig', ProductHasuraGraphQLRepository],
-                        },
-                        {
-                            provide: 'ProductErrorsRepository',
-                            useExisting: ProductErrorsHasuraGraphQLRepository,
-                        },
-                    ],
-                }]
-        }] });
-
-class AngularVertexSeachModule {
-    static initializeApp(options) {
-        return {
-            ngModule: AngularVertexSeachModule,
-            providers: [{ provide: VERTEX_CONFIG, useValue: options }],
-        };
-    }
-}
-AngularVertexSeachModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularVertexSeachModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AngularVertexSeachModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularVertexSeachModule });
-AngularVertexSeachModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularVertexSeachModule, providers: [
-        {
-            provide: ProductsVertexSearch,
-            useFactory: (configuration) => new ProductsVertexSearch(new VertexAxiosAdapter(configuration)),
-            deps: [VERTEX_CONFIG],
-        },
-    ] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularVertexSeachModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    providers: [
-                        {
-                            provide: ProductsVertexSearch,
-                            useFactory: (configuration) => new ProductsVertexSearch(new VertexAxiosAdapter(configuration)),
-                            deps: [VERTEX_CONFIG],
-                        },
-                    ],
-                }]
-        }] });
-
-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 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 CheckoutRepositoriesFacade {
-    constructor(checkoutRepository, userRepository) {
-        this.checkoutRepository = checkoutRepository;
-        this.userRepository = userRepository;
-    }
-}
-CheckoutRepositoriesFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutRepositoriesFacade, deps: [{ token: 'CheckoutRepository' }, { token: 'UserRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-CheckoutRepositoriesFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutRepositoriesFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutRepositoriesFacade, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['CheckoutRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['UserRepository']
-                    }] }];
-    } });
-
-class CheckoutDependenciesFacade {
-    constructor(dataPersistence, httpClient) {
-        this.dataPersistence = dataPersistence;
-        this.httpClient = httpClient;
-    }
-}
-CheckoutDependenciesFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutDependenciesFacade, deps: [{ token: PERSISTENCE_PROVIDER }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
-CheckoutDependenciesFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutDependenciesFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutDependenciesFacade, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [PERSISTENCE_PROVIDER]
-                    }] }, { type: i1$2.HttpClient }];
-    } });
-
-class ConfigurationFacade {
-    constructor(defaultShop, firebaseOptions) {
-        this.defaultShop = defaultShop;
-        this.firebaseOptions = firebaseOptions;
-    }
-    getCheckoutUrl() {
-        return `https://southamerica-east1-${this.firebaseOptions.projectId}.cloudfunctions.net`;
-    }
-    getProjectId() {
-        return this.firebaseOptions.projectId;
-    }
-}
-ConfigurationFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ConfigurationFacade, deps: [{ token: DEFAULT_SHOP }, { token: FIREBASE_OPTIONS }], target: i0.ɵɵFactoryTarget.Injectable });
-ConfigurationFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ConfigurationFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ConfigurationFacade, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: i3.Shops, decorators: [{
-                        type: Inject,
-                        args: [DEFAULT_SHOP]
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: [FIREBASE_OPTIONS]
-                    }] }];
-    } });
-
-class CheckoutService {
-    constructor(repositoriesFacade, dependenciesFacade, configurationFacade) {
-        this.repositoriesFacade = repositoriesFacade;
-        this.dependenciesFacade = dependenciesFacade;
-        this.configurationFacade = configurationFacade;
-        this.checkoutUrl = null;
-        this.checkoutUrl = this.configurationFacade.getCheckoutUrl();
-    }
-    getCheckout(checkoutData) {
-        return this.dependenciesFacade.dataPersistence
-            .get('checkoutId')
-            .pipe(concatMap((id) => !isNil(id) ? this.repositoriesFacade.checkoutRepository.get({ id }) : this.createCheckout(checkoutData)));
-    }
-    getUserByCheckout(checkoutId) {
-        return from(this.repositoriesFacade.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.repositoriesFacade.userRepository.get({ id: checkout.user.id }));
-        }), concatMap((user) => of(user) || throwError(() => new NotFoundError('User is not found'))));
-    }
-    updateCheckoutLineItems(checkout) {
-        return from(this.repositoriesFacade.checkoutRepository.update(Checkout.toInstance({ id: checkout.id, lineItems: checkout.lineItems })));
-    }
-    updateCheckoutUser(checkout) {
-        return from(this.repositoriesFacade.checkoutRepository.update(Checkout.toInstance({ id: checkout.id, user: checkout.user })));
-    }
-    clearCheckoutFromSession() {
-        return this.dependenciesFacade.dataPersistence.remove('checkoutId');
-    }
-    resetCheckoutValues() {
-        return this.getCheckout().pipe(concatMap((checkout) => this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutResetValues`, {
-            checkoutId: checkout.id,
-        })), concatMap(() => this.getCheckout()));
-    }
-    applyCouponDiscount(nickname, checkoutType) {
-        return this.getCheckout().pipe(concatMap((checkout) => this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutApplyDiscount`, {
-            checkoutId: checkout.id,
-            coupon: nickname,
-            checkoutType,
-        })), concatMap(() => this.getCheckout()), map((checkout) => checkout.coupon));
-    }
-    removeCouponDiscount() {
-        return this.getCheckout().pipe(concatMap((checkout) => this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutRemoveDiscount`, {
-            checkoutId: checkout.id,
-        })), concatMap(() => this.getCheckout()));
-    }
-    validateStockProducts() {
-        return this.getCheckout().pipe(concatMap((checkout) => this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutValidateProductStock`, {
-            checkoutId: checkout.id,
-        })));
-    }
-    selectShippingAddress(address) {
-        return this.getCheckout().pipe(concatMap((checkout) => {
-            return this.repositoriesFacade.checkoutRepository.update(Checkout.toInstance({ id: checkout.id, shippingAddress: address, billingAddress: address }));
-        }));
-    }
-    getAvailableShippingForProduct(productShipping) {
-        return this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutGetAvailableShipping`, {
-            checkoutId: null,
-            productShipping,
-        });
-    }
-    getAvailableShippingForCheckout() {
-        return this.getCheckout().pipe(concatMap((checkout) => this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutGetAvailableShipping`, {
-            checkoutId: checkout.id,
-            productShipping: null,
-        })));
-    }
-    selectShipping(option) {
-        return this.getCheckout().pipe(concatMap((checkout) => this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutSelectShipping`, {
-            checkoutId: checkout.id,
-            shippingOption: option,
-        })), concatMap(() => this.getCheckout()));
-    }
-    createOrder(checkoutPayload, paymentProvider, applicationVersion) {
-        return this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutV5`, {
-            data: Object.assign(Object.assign({}, checkoutPayload), { applicationVersion,
-                paymentProvider }),
-        });
-    }
-    createCheckout(checkoutData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const checkout = yield this.repositoriesFacade.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.configurationFacade.defaultShop }));
-            yield this.dependenciesFacade.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: CheckoutRepositoriesFacade }, { token: CheckoutDependenciesFacade }, { token: ConfigurationFacade }], 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: CheckoutRepositoriesFacade }, { type: CheckoutDependenciesFacade }, { type: ConfigurationFacade }]; } });
-
-class CartServicesFacade {
-    constructor(authService, checkoutService, httpClient) {
-        this.authService = authService;
-        this.checkoutService = checkoutService;
-        this.httpClient = httpClient;
-    }
-}
-CartServicesFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CartServicesFacade, deps: [{ token: AuthService }, { token: CheckoutService }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
-CartServicesFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CartServicesFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CartServicesFacade, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: AuthService }, { type: CheckoutService }, { type: i1$2.HttpClient }]; } });
-
-class CartService {
-    constructor(servicesFacade, configurationFacade) {
-        this.servicesFacade = servicesFacade;
-        this.configurationFacade = configurationFacade;
-        this.cartSubject = new Subject();
-        this.checkoutUrl = null;
-        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.checkoutUrl = this.configurationFacade.getCheckoutUrl();
-    }
-    addItem(item, quantity = 1) {
-        return this.servicesFacade.checkoutService.getCheckout().pipe(concatMap((checkout) => this.servicesFacade.httpClient.post(`${this.checkoutUrl}/checkoutAddItemToCart`, {
-            checkoutId: checkout.id,
-            productId: item.id,
-            quantity,
-        })), concatMap(() => this.servicesFacade.checkoutService.getCheckout()), map((updatedCheckout) => this.generateCartObject(updatedCheckout.lineItems)), tap((cart) => this.cartSubject.next(cart)));
-    }
-    decreaseItem(item) {
-        return this.servicesFacade.checkoutService.getCheckout().pipe(concatMap((checkout) => this.servicesFacade.httpClient.post(`${this.checkoutUrl}/checkoutDecreaseProductFromCart`, {
-            checkoutId: checkout.id,
-            productId: item.id,
-            quantity: 1,
-        })), concatMap(() => this.servicesFacade.checkoutService.getCheckout()), map((updatedCheckout) => this.generateCartObject(updatedCheckout.lineItems)), tap((cart) => this.cartSubject.next(cart)));
-    }
-    removeItem(item) {
-        return this.servicesFacade.checkoutService.getCheckout().pipe(concatMap((checkout) => this.servicesFacade.httpClient.post(`${this.checkoutUrl}/checkoutRemoveProductFromCart`, {
-            checkoutId: checkout.id,
-            productId: item.id,
-        })), concatMap(() => this.servicesFacade.checkoutService.getCheckout()), map((updatedCheckout) => this.generateCartObject(updatedCheckout.lineItems)), tap((cart) => this.cartSubject.next(cart)));
-    }
-    updateUserCart(user) {
-        return this.servicesFacade.checkoutService.getCheckout().pipe(concatMap((checkout) => this.servicesFacade.checkoutService.updateCheckoutUser(Checkout.toInstance(Object.assign(Object.assign({}, checkout.toPlain()), { user })))), concatMap((checkout) => {
-            return this.servicesFacade.httpClient.post(`${this.checkoutUrl}/checkoutUpdateUserCart`, {
-                checkoutId: checkout.id,
-            });
-        }), concatMap(() => this.servicesFacade.checkoutService.getCheckout()), map((updatedCheckout) => {
-            return this.generateCartObject(updatedCheckout.lineItems);
-        }), tap((cart) => this.cartSubject.next(cart)));
-    }
-    getCart(checkout) {
-        this.buildCartFromCheckout(checkout).subscribe((cart) => this.cartSubject.next(cart));
-        return this.cartSubject;
-    }
-    clearCart() {
-        return this.servicesFacade.checkoutService.getCheckout().pipe(map((checkout) => {
-            this.servicesFacade.checkoutService.clearCheckoutFromSession();
-            return checkout;
-        }), concatMap((oldCheckout) => this.buildCartFromCheckout(oldCheckout)), tap((cart) => this.cartSubject.next(cart)));
-    }
-    buildCartFromCheckout(checkoutData) {
-        return this.servicesFacade.checkoutService.getCheckout(checkoutData).pipe(map((checkout) => checkout.lineItems), concatMap((lineItems) => of(this.generateCartObject(lineItems))));
-    }
-}
-CartService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CartService, deps: [{ token: CartServicesFacade }, { token: ConfigurationFacade }], 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: CartServicesFacade }, { type: ConfigurationFacade }]; } });
-
-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 CatalogSearchContext {
-    constructor(categoryStrategy, termStrategy, profileStrategy) {
-        this.categoryStrategy = categoryStrategy;
-        this.termStrategy = termStrategy;
-        this.profileStrategy = profileStrategy;
-        this.strategies = new Map();
-        this.initializeStrategies();
-    }
-    executeSearch(params, shop, optionsCache) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const strategy = this.selectStrategy(params);
-            return strategy.search(params, shop, optionsCache);
-        });
-    }
-    initializeStrategies() {
-        this.strategies.set('category', this.categoryStrategy);
-        this.strategies.set('term', this.termStrategy);
-        this.strategies.set('profile', this.profileStrategy);
-    }
-    selectStrategy(params) {
-        var _a;
-        if (params.category) {
-            const strategy = this.strategies.get('category');
-            if (!strategy)
-                throw new Error('Category strategy not found');
-            return strategy;
-        }
-        if (params.term) {
-            const strategy = this.strategies.get('term');
-            if (!strategy)
-                throw new Error('Term strategy not found');
-            return strategy;
-        }
-        if ((_a = params.profile) === null || _a === void 0 ? void 0 : _a.length) {
-            const strategy = this.strategies.get('profile');
-            if (!strategy)
-                throw new Error('Profile strategy not found');
-            return strategy;
-        }
-        throw new Error('No valid search strategy found for the given parameters');
-    }
-}
-
-class CategorySearchStrategy {
-    constructor(repositoryService, helpersService) {
-        this.repositoryService = repositoryService;
-        this.helpersService = helpersService;
-    }
-    search(params, shop, optionsCache) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { category, filters, limits, sort, mainGender } = params;
-            if (!category) {
-                throw new Error('Category is required for CategorySearchStrategy');
-            }
-            const fields = this.helpersService.getFieldsHelper().getStandardFields();
-            if (sort === 'most-relevant') {
-                return this.searchWithMostRelevant({
-                    category,
-                    filters,
-                    limits,
-                    shop,
-                    mainGender,
-                    optionsCache,
-                    fields,
-                });
-            }
-            return this.searchDefault({
-                category,
-                filters,
-                limits,
-                shop,
-                mainGender,
-                sort,
-                optionsCache,
-                fields,
-            });
-        });
-    }
-    searchWithMostRelevant(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { category, filters, shop, optionsCache } = params;
-            const mostRelevant = category.isWishlist ? [] : category.getMostRelevantByShop(shop);
-            const productsIds = yield this.getProductIds(category, filters, optionsCache);
-            return this.findAndSortByMostRelevant({
-                mostRelevants: mostRelevant,
-                productIds: productsIds,
-                filters: params.filters,
-                limits: params.limits,
-                shop: params.shop,
-                mainGender: params.mainGender,
-                optionsCache: params.optionsCache,
-                fields: params.fields,
-            });
-        });
-    }
-    searchDefault(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { category, filters, limits, sort, optionsCache, fields } = params;
-            const productCatalog = this.repositoryService.getProductCatalog();
-            const filterHelper = this.helpersService.getFilterHelper();
-            const sortHelper = this.helpersService.getSortHelper();
-            const repoParams = Object.assign(Object.assign({ fields, filters: Object.assign(Object.assign({}, (yield productCatalog.categoryStructureAdapter.buildProductFilterByCategory(category))), filterHelper.buildFilterQuery(filters || {})) }, (sort ? { orderBy: sortHelper.buildSortQuery(sort) } : {})), { limits, options: {
-                    minimal: ['price'],
-                    maximum: ['price'],
-                    distinct: ['brand'],
-                } });
-            return productCatalog.productRepository.findCatalog(repoParams, null, optionsCache);
-        });
-    }
-    getProductIds(category, filters, optionsCache) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const productCatalog = this.repositoryService.getProductCatalog();
-            const filterHelper = this.helpersService.getFilterHelper();
-            return productCatalog.productRepository
-                .findCatalog({
-                fields: ['id'],
-                filters: Object.assign(Object.assign({}, (yield productCatalog.categoryStructureAdapter.buildProductFilterByCategory(category))), filterHelper.buildFilterQuery(filters || {})),
-            }, undefined, optionsCache)
-                .then((products) => products.data.map((product) => product.id));
-        });
-    }
-    findAndSortByMostRelevant(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { mostRelevants, productIds, filters, shop, mainGender, optionsCache, fields, limits } = params;
-            const productCatalog = this.repositoryService.getProductCatalog();
-            const filterHelper = this.helpersService.getFilterHelper();
-            const sortHelper = this.helpersService.getSortHelper();
-            const mostRelevantProductsIds = [...new Set(mostRelevants.concat(productIds))];
-            const totalResult = yield productCatalog.productRepository.findCatalog({
-                fields,
-                filters: Object.assign({ id: { operator: Where.IN, value: mostRelevantProductsIds } }, filterHelper.buildFilterQuery(filters || {})),
-                orderBy: sortHelper.buildSortQuery('best-sellers'),
-                options: Object.assign({ minimal: ['price'], maximum: ['price'] }, (isEmpty(filters === null || filters === void 0 ? void 0 : filters.brands) ? { distinct: ['brand'] } : {})),
-            }, mainGender || (shop === Shops.MENSMARKET ? 'male' : 'female'), optionsCache);
-            return this.sortProductsByRelevance(totalResult, mostRelevants, limits);
-        });
-    }
-    sortProductsByRelevance(totalResult, mostRelevants, limits) {
-        const mostRelevantWithoutStock = totalResult.data.filter((product) => mostRelevants.includes(product.id) && product.stock.quantity <= 0);
-        const firstProducts = totalResult.data
-            .filter((product) => mostRelevants.includes(product.id) && product.stock.quantity > 0)
-            .sort((a, b) => mostRelevants.indexOf(a.id) - mostRelevants.indexOf(b.id));
-        const lastProducts = totalResult.data
-            .filter((product) => !mostRelevants.includes(product.id))
-            .concat(mostRelevantWithoutStock);
-        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,
-        };
-    }
-}
-CategorySearchStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategorySearchStrategy, deps: [{ token: CatalogRepositoryService }, { token: CatalogHelpersService }], target: i0.ɵɵFactoryTarget.Injectable });
-CategorySearchStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategorySearchStrategy });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategorySearchStrategy, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: CatalogRepositoryService }, { type: CatalogHelpersService }]; } });
-
-class ProfileSearchStrategy {
-    constructor(repositoryService, helpersService) {
-        this.repositoryService = repositoryService;
-        this.helpersService = helpersService;
-    }
-    search(params, shop, optionsCache) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { profile, filters, limits, sort, mainGender } = params;
-            if (!profile) {
-                throw new Error('Profile is required for ProfileSearchStrategy');
-            }
-            const productCatalog = this.repositoryService.getProductCatalog();
-            const filterHelper = this.helpersService.getFilterHelper();
-            const sortHelper = this.helpersService.getSortHelper();
-            const fieldsHelper = this.helpersService.getFieldsHelper();
-            const repoParams = Object.assign(Object.assign({ fields: fieldsHelper.getStandardFields(), filters: Object.assign({ tagsProfile: { operator: Where.LIKE, value: profile } }, filterHelper.buildFilterQuery(filters || {})) }, (sort ? { orderBy: sortHelper.buildSortQuery(sort) } : {})), { limits, options: {
-                    minimal: ['price'],
-                    maximum: ['price'],
-                    distinct: ['brand'],
-                } });
-            return productCatalog.productRepository.findCatalog(repoParams, mainGender || (shop === Shops.MENSMARKET ? 'male' : 'female'), optionsCache);
-        });
-    }
-}
-ProfileSearchStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProfileSearchStrategy, deps: [{ token: CatalogRepositoryService }, { token: CatalogHelpersService }], target: i0.ɵɵFactoryTarget.Injectable });
-ProfileSearchStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProfileSearchStrategy });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProfileSearchStrategy, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: CatalogRepositoryService }, { type: CatalogHelpersService }]; } });
-
-class TermSearchStrategy {
-    constructor(repositoryService, helpersService) {
-        this.repositoryService = repositoryService;
-        this.helpersService = helpersService;
-        this.productsByTerm = {};
-    }
-    search(params, shop, _optionsCache) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { term, filters, limits, sort, mainGender } = params;
-            if (!term) {
-                throw new Error('Term is required for TermSearchStrategy');
-            }
-            const productIds = yield this.findCatalogIdsBySearch(term, shop);
-            if (sort === 'most-relevant') {
-                return this.searchWithMostRelevant({
-                    productIds,
-                    filters,
-                    limits,
-                    shop,
-                    mainGender,
-                });
-            }
-            return this.searchDefault({
-                productIds,
-                filters,
-                limits,
-                shop,
-                mainGender,
-                fields: this.helpersService.getFieldsHelper().getStandardFields(),
-            });
-        });
-    }
-    searchWithMostRelevant(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { productIds, filters, shop, mainGender } = params;
-            const productCatalog = this.repositoryService.getProductCatalog();
-            const filterHelper = this.helpersService.getFilterHelper();
-            const totalResult = yield productCatalog.productRepository.findCatalog({
-                fields: ['id', 'stock', 'gender'],
-                filters: Object.assign({ id: { operator: Where.IN, value: productIds }, published: { operator: Where.EQUALS, value: true } }, filterHelper.buildFilterQuery(filters || {})),
-                options: Object.assign({ minimal: ['price'], maximum: ['price'] }, (isEmpty(filters === null || filters === void 0 ? void 0 : filters.brands) ? { distinct: ['brand'] } : {})),
-            });
-            return this.sortByTermRelevance({
-                productIds,
-                totalResult,
-                limits: params.limits,
-                filters,
-                fieldsHelper: this.helpersService.getFieldsHelper(),
-            });
-        });
-    }
-    searchDefault(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { productIds, filters, limits, shop, mainGender, fields } = params;
-            const productCatalog = this.repositoryService.getProductCatalog();
-            const filterHelper = this.helpersService.getFilterHelper();
-            return productCatalog.productRepository.findCatalog({
-                fields,
-                filters: Object.assign({ id: { operator: Where.IN, value: productIds }, published: { operator: Where.EQUALS, value: true } }, filterHelper.buildFilterQuery(filters || {})),
-                limits,
-                options: {
-                    minimal: ['price'],
-                    maximum: ['price'],
-                    distinct: ['brand'],
-                },
-            });
-        });
-    }
-    sortByTermRelevance(params) {
-        const { productIds, totalResult, limits, filters, fieldsHelper } = params;
-        // const defaultGender = filters?.gender?.at(0) || 'male'
-        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);
-        return this.getDetailedProducts(limitedProductId, totalResult, fieldsHelper);
-    }
-    getDetailedProducts(orderedId, totalResult, fieldsHelper) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const productCatalog = this.repositoryService.getProductCatalog();
-            const fields = fieldsHelper.getStandardFields();
-            const productResult = yield productCatalog.productRepository.findCatalog({
-                filters: {
-                    id: { operator: Where.IN, value: orderedId },
-                },
-                fields,
-            });
-            return {
-                data: orderedId.map((id) => productResult.data.find((product) => product.id === id)).filter(Boolean),
-                count: totalResult.count,
-                maximum: totalResult.maximum,
-                minimal: totalResult.minimal,
-                distinct: totalResult.distinct,
-            };
-        });
-    }
-    findCatalogIdsBySearch(term, shop) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.productsByTerm[term])
-                return this.productsByTerm[term];
-            const productServices = this.repositoryService.getProductServices();
-            return (this.productsByTerm[term] = yield productServices.productSearch
-                .search(term, 999, shop === Shops.GLAMSHOP ? 'female' : 'male')
-                .then((products) => [...new Set(products.map((product) => product.id))]));
-        });
-    }
-}
-TermSearchStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: TermSearchStrategy, deps: [{ token: CatalogRepositoryService }, { token: CatalogHelpersService }], target: i0.ɵɵFactoryTarget.Injectable });
-TermSearchStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: TermSearchStrategy });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: TermSearchStrategy, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: CatalogRepositoryService }, { type: CatalogHelpersService }]; } });
-
-class CatalogStrategiesFacade {
-    constructor(categoryStrategy, termStrategy, profileStrategy) {
-        this.categoryStrategy = categoryStrategy;
-        this.termStrategy = termStrategy;
-        this.profileStrategy = profileStrategy;
-    }
-}
-CatalogStrategiesFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogStrategiesFacade, deps: [{ token: CategorySearchStrategy }, { token: TermSearchStrategy }, { token: ProfileSearchStrategy }], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogStrategiesFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogStrategiesFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogStrategiesFacade, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: CategorySearchStrategy }, { type: TermSearchStrategy }, { type: ProfileSearchStrategy }]; } });
-
-class CatalogServiceFacade {
-    constructor(helpersService, strategiesFacade, shop) {
-        this.helpersService = helpersService;
-        this.strategiesFacade = strategiesFacade;
-        this.shop = shop;
-        const searchContext = new CatalogSearchContext(this.strategiesFacade.categoryStrategy, this.strategiesFacade.termStrategy, this.strategiesFacade.profileStrategy);
-        this.catalogService = new CatalogService(searchContext, this.helpersService, this.shop);
-    }
-    getCatalogService() {
-        return this.catalogService;
-    }
-}
-CatalogServiceFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogServiceFacade, deps: [{ token: CatalogHelpersService }, { token: CatalogStrategiesFacade }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogServiceFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogServiceFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogServiceFacade, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: CatalogHelpersService }, { type: CatalogStrategiesFacade }, { type: i3.Shops, decorators: [{
-                        type: Inject,
-                        args: [DEFAULT_SHOP]
-                    }] }];
-    } });
-
-class CategoryRepositoryFacade {
-    constructor(categoryRepository, categoryFilterRepository) {
-        this.categoryRepository = categoryRepository;
-        this.categoryFilterRepository = categoryFilterRepository;
-    }
-}
-CategoryRepositoryFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryRepositoryFacade, deps: [{ token: 'CategoryRepository' }, { token: 'CategoryFilterRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-CategoryRepositoryFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryRepositoryFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryRepositoryFacade, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['CategoryRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['CategoryFilterRepository']
-                    }] }];
-    } });
-
-class CategoryService {
-    constructor(categoryFacade, productCatalog, shop) {
-        this.categoryFacade = categoryFacade;
-        this.productCatalog = productCatalog;
-        this.shop = shop;
-    }
-    fetchBrands(category, options, optionsCache) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const brands = yield this.productCatalog.productRepository
-                .findCatalog({
-                filters: yield this.productCatalog.categoryStructureAdapter.buildProductFilterByCategory(category),
-                fields: ['brand'],
-            }, null, optionsCache)
-                .then(({ data }) => Object.keys(data.map((product) => product.brand).reduce((brands, brand) => (Object.assign(Object.assign({}, brands), { [brand]: true })), {})));
-            return this.categoryFacade.categoryRepository
-                .find({ filters: { brandCategory: true, shop: (options === null || options === void 0 ? void 0 : options.shop) || this.shop }, orderBy: { name: 'asc' } }, optionsCache)
-                .then(({ data }) => data.filter((category) => brands.includes(category.conditions.brand)));
-        });
-    }
-    getMenuBrands() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.categoryFacade.categoryRepository.getBrandsWithProducts();
-        });
-    }
-    fetchFilterOptions(category, optionsCache) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.categoryFacade.categoryFilterRepository
-                .find({ filters: { categoryId: +category.id } }, optionsCache)
-                .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: CategoryRepositoryFacade }, { token: ProductCatalogFacade }, { 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: CategoryRepositoryFacade }, { type: ProductCatalogFacade }, { type: i3.Shops, decorators: [{
-                        type: Inject,
-                        args: [DEFAULT_SHOP]
-                    }] }];
-    } });
-
-class ProductCatalogFacade {
-    constructor(productRepository, categoryStructureAdapter) {
-        this.productRepository = productRepository;
-        this.categoryStructureAdapter = categoryStructureAdapter;
-    }
-}
-ProductCatalogFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductCatalogFacade, deps: [{ token: 'ProductRepository' }, { token: CATEGORY_STRUCTURE }], target: i0.ɵɵFactoryTarget.Injectable });
-ProductCatalogFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductCatalogFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductCatalogFacade, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['ProductRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: [CATEGORY_STRUCTURE]
-                    }] }];
-    } });
-
-class CategoryServiceFacade {
-    constructor(categoryRepositoryFacade, productCatalogFacade, shop) {
-        this.categoryRepositoryFacade = categoryRepositoryFacade;
-        this.productCatalogFacade = productCatalogFacade;
-        this.shop = shop;
-        this.categoryService = new CategoryService(this.categoryRepositoryFacade, this.productCatalogFacade, this.shop);
-    }
-    getCategoryService() {
-        return this.categoryService;
-    }
-}
-CategoryServiceFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryServiceFacade, deps: [{ token: CategoryRepositoryFacade }, { token: ProductCatalogFacade }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable });
-CategoryServiceFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryServiceFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryServiceFacade, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: CategoryRepositoryFacade }, { type: ProductCatalogFacade }, { type: i3.Shops, decorators: [{
-                        type: Inject,
-                        args: [DEFAULT_SHOP]
-                    }] }];
-    } });
-
-class BrandManagerHelper {
-    constructor(productCatalog) {
-        this.productCatalog = productCatalog;
-        this.brandsList = {};
-    }
-    setBrandsList(options, brands) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const filterBrands = (_a = options.filters) === null || _a === void 0 ? void 0 : _a.brands;
-            const indexKey = this.buildIndexBrands(options);
-            if (isEmpty(brands) && options.filters) {
-                delete options.filters.brands;
-            }
-            this.brandsList[indexKey] = this.brandsList[indexKey] || brands || (yield this.fetchBrandsOnly(options));
-            this.brandsList[indexKey] = this.brandsList[indexKey].filter(Boolean);
-            if (options.filters) {
-                options.filters = Object.assign(Object.assign({}, options.filters), { brands: filterBrands });
-            }
-        });
-    }
-    getBrandsList(indexKey) {
-        return this.brandsList[indexKey];
-    }
-    buildIndexBrands(options) {
-        if (options.category)
-            return `category-${options.category.id}`;
-        if (options.term)
-            return `term-${options.term}`;
-        if (options.profile)
-            return `profile-${options.profile.join(',')}`;
-        return '';
-    }
-    fetchBrandsOnly(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.productCatalog.productRepository
-                .findCatalog({
-                fields: ['id'],
-                filters: {
-                    published: { operator: Where.EQUALS, value: true },
-                },
-                options: {
-                    distinct: ['brand'],
-                },
-            }, options.mainGender)
-                .then((result) => result.distinct.brand);
-        });
-    }
-}
-BrandManagerHelper.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: BrandManagerHelper, deps: [{ token: ProductCatalogFacade }], target: i0.ɵɵFactoryTarget.Injectable });
-BrandManagerHelper.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: BrandManagerHelper });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: BrandManagerHelper, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: ProductCatalogFacade }]; } });
-
-class CatalogFilterHelper {
-    buildFilterQuery(filters) {
-        var _a, _b, _c, _d, _e, _f, _g;
-        const filterQuery = {};
-        if ((_a = filters.clubDiscount) === null || _a === void 0 ? void 0 : _a.length) {
-            set(filterQuery, 'price.subscriberDiscountPercentage', {
-                operator: Where.IN,
-                value: filters.clubDiscount,
-            });
-        }
-        if ((_b = filters.brands) === null || _b === void 0 ? void 0 : _b.length) {
-            filterQuery.brand = { operator: Where.IN, value: filters.brands };
-        }
-        if ((_c = filters.gender) === null || _c === void 0 ? void 0 : _c.length) {
-            filterQuery.gender = { operator: Where.IN, value: filters.gender };
-        }
-        if (((_d = filters.prices) === null || _d === void 0 ? void 0 : _d.min) || ((_e = filters.prices) === null || _e === void 0 ? void 0 : _e.max)) {
-            const priceField = filters.prices.subscriberPrice ? 'price.subscriberPrice' : 'price.price';
-            const priceFilters = [
-                ...(filters.prices.min ? [{ operator: Where.GTE, value: Math.floor(filters.prices.min) }] : []),
-                ...(filters.prices.max ? [{ operator: Where.LTE, value: Math.ceil(filters.prices.max) }] : []),
-            ];
-            set(filterQuery, priceField, priceFilters);
-        }
-        if (filters.rate) {
-            filterQuery.rate = { operator: Where.GTE, value: filters.rate };
-        }
-        if ((_f = filters.tags) === null || _f === void 0 ? void 0 : _f.length) {
-            filterQuery.tagsProfile = { operator: Where.LIKE, value: filters.tags };
-        }
-        if ((_g = filters.customOptions) === null || _g === void 0 ? void 0 : _g.length) {
-            filterQuery.filters = { operator: Where.LIKE, value: filters.customOptions };
-        }
-        return filterQuery;
-    }
-}
-CatalogFilterHelper.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogFilterHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogFilterHelper.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogFilterHelper });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogFilterHelper, decorators: [{
-            type: Injectable
-        }] });
-
-class CatalogSortHelper {
-    buildSortQuery(sort) {
-        if (!sort || sort === 'most-relevant')
-            return {};
-        switch (sort) {
-            case 'best-sellers':
-                return {
-                    shoppingCount: 'desc',
-                    rate: 'desc',
-                    stock: 'desc',
-                    name: 'asc',
-                };
-            case 'biggest-price':
-                return {
-                    subscriberPrice: 'desc',
-                    rate: 'desc',
-                    shoppingCount: 'desc',
-                };
-            case 'lowest-price':
-                return {
-                    subscriberPrice: 'asc',
-                    rate: 'desc',
-                    shoppingCount: 'desc',
-                };
-            case 'best-rating':
-                return {
-                    rate: 'desc',
-                    shoppingCount: 'desc',
-                    stock: 'desc',
-                    name: 'asc',
-                };
-            case 'news':
-                return { createdAt: 'desc' };
-            case 'biggest-discount':
-                return {
-                    subscriberDiscountPercentage: 'desc',
-                    rate: 'desc',
-                    shoppingCount: 'desc',
-                };
-            default:
-                return {};
-        }
-    }
-}
-CatalogSortHelper.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogSortHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogSortHelper.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogSortHelper });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogSortHelper, decorators: [{
-            type: Injectable
-        }] });
-
-class ProductFieldsHelper {
-    getStandardFields() {
-        return [
-            'id',
-            'name',
-            'slug',
-            'images',
-            'miniatures',
-            'price',
-            'stock',
-            'published',
-            'CEST',
-            'EAN',
-            'NCM',
-            'brand',
-            'costPrice',
-            'hasVariants',
-            'isKit',
-            'sku',
-            'rate',
-            'tagsProfile',
-            'tagsCollection',
-            'type',
-            'shoppingCount',
-            'gender',
-            'createdAt',
-            'label',
-            'outlet',
-            'group',
-        ];
-    }
-}
-ProductFieldsHelper.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductFieldsHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-ProductFieldsHelper.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductFieldsHelper });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductFieldsHelper, decorators: [{
-            type: Injectable
-        }] });
-
-class CatalogOperationsFacade {
-    constructor(filterHelper, sortHelper, fieldsHelper) {
-        this.filterHelper = filterHelper;
-        this.sortHelper = sortHelper;
-        this.fieldsHelper = fieldsHelper;
-    }
-    getFilterHelper() {
-        return this.filterHelper;
-    }
-    getSortHelper() {
-        return this.sortHelper;
-    }
-    getFieldsHelper() {
-        return this.fieldsHelper;
-    }
-}
-CatalogOperationsFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogOperationsFacade, deps: [{ token: CatalogFilterHelper }, { token: CatalogSortHelper }, { token: ProductFieldsHelper }], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogOperationsFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogOperationsFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogOperationsFacade, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: CatalogFilterHelper }, { type: CatalogSortHelper }, { type: ProductFieldsHelper }]; } });
-
-class ProductManagementFacade {
-    constructor(brandManager, productServices) {
-        this.brandManager = brandManager;
-        this.productServices = productServices;
-    }
-    getBrandManager() {
-        return this.brandManager;
-    }
-    getProductServices() {
-        return this.productServices;
-    }
-}
-ProductManagementFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductManagementFacade, deps: [{ token: BrandManagerHelper }, { token: 'ProductServicesFacade' }], target: i0.ɵɵFactoryTarget.Injectable });
-ProductManagementFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductManagementFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductManagementFacade, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: BrandManagerHelper }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['ProductServicesFacade']
-                    }] }];
-    } });
-
-class CatalogHelpersService {
-    constructor(catalogOperations, productManagement) {
-        this.catalogOperations = catalogOperations;
-        this.productManagement = productManagement;
-    }
-    getFilterHelper() {
-        return this.catalogOperations.getFilterHelper();
-    }
-    getSortHelper() {
-        return this.catalogOperations.getSortHelper();
-    }
-    getFieldsHelper() {
-        return this.catalogOperations.getFieldsHelper();
-    }
-    getBrandManager() {
-        return this.productManagement.getBrandManager();
-    }
-    getProductServices() {
-        return this.productManagement.getProductServices();
-    }
-}
-CatalogHelpersService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogHelpersService, deps: [{ token: CatalogOperationsFacade }, { token: ProductManagementFacade }], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogHelpersService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogHelpersService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogHelpersService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: CatalogOperationsFacade }, { type: ProductManagementFacade }]; } });
-
-class CatalogRepositoryService {
-    constructor(productCatalog, productServices) {
-        this.productCatalog = productCatalog;
-        this.productServices = productServices;
-    }
-    getProductCatalog() {
-        return this.productCatalog;
-    }
-    getProductServices() {
-        return this.productServices;
-    }
-}
-CatalogRepositoryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogRepositoryService, deps: [{ token: ProductCatalogFacade }, { token: 'ProductServicesFacade' }], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogRepositoryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogRepositoryService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogRepositoryService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: ProductCatalogFacade }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['ProductServicesFacade']
-                    }] }];
-    } });
-
-class CatalogService {
-    constructor(searchContext, helpersService, shop) {
-        this.searchContext = searchContext;
-        this.helpersService = helpersService;
-        this.shop = shop;
-    }
-    fetchProducts(options, optionsCache) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.validateRequest(options);
-            const searchParams = this.buildSearchParams(options);
-            const { data, count: total, maximum, minimal, distinct, } = yield this.searchContext.executeSearch(searchParams, this.shop, optionsCache);
-            yield this.helpersService.getBrandManager().setBrandsList(searchParams, distinct === null || distinct === void 0 ? void 0 : distinct.brand);
-            return this.buildResponse({
-                data,
-                total,
-                maximum,
-                minimal,
-                searchParams,
-                options,
-            });
-        });
-    }
-    addCustomerToStockNotification(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { shop, productId, name, email } = params;
-            const productServices = this.helpersService.getProductServices();
-            return productServices.productStockNotificationRepository.addCustomerEmail({
-                shop,
-                productId,
-                name,
-                email,
-            });
-        });
-    }
-    validateRequest(options) {
-        var _a, _b, _c;
-        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`);
-        }
-    }
-    buildSearchParams(options) {
-        const limits = this.buildLimitQuery(options);
-        return {
-            category: this.hasCategory(options) ? options.category : undefined,
-            profile: this.hasProfile(options) ? options.profile : undefined,
-            term: this.hasTerm(options) ? options.term : undefined,
-            filters: options.filters,
-            mainGender: options.mainGender,
-            sort: options.sort,
-            limits,
-        };
-    }
-    buildResponse(params) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        const { data, total, maximum, minimal, searchParams } = params;
-        const limits = searchParams.limits;
-        const indexKey = this.helpersService.getBrandManager().buildIndexBrands(searchParams);
-        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)) || 0),
-                    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)) || 0),
-                },
-                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)) || 0),
-                    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)) || 0),
-                },
-            },
-            brands: this.helpersService.getBrandManager().getBrandsList(indexKey),
-        };
-    }
-    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,
-        };
-    }
-    hasProfile(options) {
-        return 'profile' in options;
-    }
-    hasTerm(options) {
-        return 'term' in options;
-    }
-    hasCategory(options) {
-        return 'category' in options;
-    }
-}
-CatalogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogService, deps: [{ token: CatalogSearchContext }, { token: CatalogHelpersService }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: CatalogSearchContext }, { type: CatalogHelpersService }, { type: i3.Shops, decorators: [{
-                        type: Inject,
-                        args: [DEFAULT_SHOP]
-                    }] }];
-    } });
-
-var ProductSorts;
-(function (ProductSorts) {
-    ProductSorts["MOST_RELEVANT"] = "most-relevant";
-    ProductSorts["BEST_SELLER"] = "best-sellers";
-    ProductSorts["BIGGEST_PRICE"] = "biggest-price";
-    ProductSorts["LOWEST_PRICE"] = "lowest-price";
-    ProductSorts["BIGGEST_DISCOUNT"] = "biggest-discount";
-    ProductSorts["BEST_RATING"] = "best-rating";
-    ProductSorts["NEWS"] = "news";
-})(ProductSorts || (ProductSorts = {}));
-
-class CategoryWithTree extends Category {
-}
-__decorate([
-    Type(() => CategoryWithTree),
-    __metadata("design:type", Array)
-], CategoryWithTree.prototype, "children", void 0);
-
-class WishlistService {
-    constructor(wishlistRepository, productRepository, logRepository, shop) {
-        this.wishlistRepository = wishlistRepository;
-        this.productRepository = productRepository;
-        this.logRepository = logRepository;
-        this.shop = shop;
-    }
-    initializeServices(catalogServiceFacade, categoryServiceFacade) {
-        this.catalogService = catalogServiceFacade.getCatalogService();
-        this.categoryService = categoryServiceFacade.getCategoryService();
-    }
-    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 wishlistData = this.buildWishlistData({
-                title,
-                description,
-                published,
-                userFullName,
-                userPhoto,
-                theme,
-                bannerUrl,
-                personType,
-                personIsSubscriber,
-                personId,
-            });
-            const existingWishlist = yield this.findExistingWishlistByPersonId(personId);
-            yield this.createWishlistLog(WishlistLogType.CREATE, wishlistData);
-            if (existingWishlist)
-                return existingWishlist;
-            return this.createNewWishlist(wishlistData);
-        });
-    }
-    buildWishlistData({ title, description, published, userFullName, userPhoto, theme, bannerUrl, personType, personIsSubscriber, personId, }) {
-        return {
-            slug: '',
-            name: title,
-            description,
-            metadatas: [
-                {
-                    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,
-        };
-    }
-    findExistingWishlistByPersonId(personId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const hasWishlist = yield this.wishlistRepository
-                .find({
-                filters: {
-                    personId,
-                },
-                options: {
-                    enableCount: false,
-                },
-                orderBy: {
-                    id: 'asc',
-                },
-            })
-                .then((res) => res.data);
-            return hasWishlist.length ? hasWishlist.at(0) : null;
-        });
-    }
-    createNewWishlist(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                id,
-                name: title,
-                description,
-                published,
-                metadatas: [
-                    {
-                        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,
-            };
-            yield this.createWishlistLog(WishlistLogType.UPDATE, data);
-            return this.wishlistRepository.update(data);
-        });
-    }
-    delete(wishlistId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const wishlist = yield this.findById(wishlistId);
-            yield this.createWishlistLog(WishlistLogType.DELETE, wishlist);
-            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);
-            const wishlistData = yield this.findById(wishlistId);
-            const productData = yield this.findProductById(productId);
-            yield this.createWishlistLog(WishlistLogType.ADD_PRODUCT, wishlistData, productData);
-            if (!hasProduct) {
-                wishlist.products = [...wishlist.products, productId];
-                yield this.wishlistRepository.addProduct(wishlistId, productId);
-            }
-            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);
-                const wishlistData = yield this.findById(wishlistId);
-                const productData = yield this.findProductById(productId);
-                yield this.createWishlistLog(WishlistLogType.REMOVE_PRODUCT, wishlistData, productData);
-                yield this.wishlistRepository.removeProduct(wishlistId, productId);
-            }
-            return wishlist;
-        });
-    }
-    findById(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.wishlistRepository
-                .find({
-                fields: ['id', 'name', 'description', 'personId', 'personIsSubscriber', 'personType', 'personName'],
-                filters: {
-                    id,
-                },
-            })
-                .then((res) => res.data.at(0));
-        });
-    }
-    findProductById(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.productRepository
-                .find({
-                fields: ['id', 'sku', 'EAN', 'name', 'brand'],
-                filters: {
-                    id,
-                },
-            })
-                .then((res) => res.data.at(0));
-        });
-    }
-    createWishlistLog(type, wishlist, product) {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (type) {
-                case WishlistLogType.CREATE:
-                case WishlistLogType.UPDATE:
-                case WishlistLogType.DELETE:
-                    yield this.createWishlistOperationLog(type, wishlist);
-                    break;
-                case WishlistLogType.ADD_PRODUCT:
-                case WishlistLogType.REMOVE_PRODUCT:
-                    yield this.createWishlistProductLog(type, wishlist, product);
-                    break;
-                default:
-                    break;
-            }
-        });
-    }
-    createWishlistOperationLog(type, wishlist) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const operation = this.getOperationTypeFromWishlistLogType(type);
-            yield this.logRepository.create({
-                collection: 'wishlist',
-                date: new Date(),
-                operation,
-                documentId: wishlist.id,
-                document: this.buildWishlistLogDocument(wishlist, type),
-            });
-        });
-    }
-    createWishlistProductLog(type, wishlist, product) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.logRepository.create({
-                collection: 'wishlist',
-                date: new Date(),
-                operation: 'UPDATE',
-                documentId: wishlist.id,
-                document: Object.assign(Object.assign({}, this.buildWishlistLogDocument(wishlist, type)), this.buildProductLogData(product)),
-            });
-        });
-    }
-    getOperationTypeFromWishlistLogType(type) {
-        if (type === WishlistLogType.CREATE)
-            return 'CREATE';
-        if (type === WishlistLogType.UPDATE)
-            return 'UPDATE';
-        return 'DELETE';
-    }
-    buildWishlistLogDocument(wishlist, type) {
-        return {
-            id: wishlist.id,
-            shop: this.shop,
-            name: wishlist.name,
-            description: wishlist.description,
-            published: wishlist.published,
-            type: type,
-            personType: wishlist.personType,
-            personId: wishlist.personId,
-            personName: wishlist.personName,
-            personIsSubscriber: wishlist.personIsSubscriber,
-        };
-    }
-    buildProductLogData(product) {
-        return {
-            productId: product.id,
-            productEAN: product.EAN,
-            productSKU: product.sku,
-            productName: product.name,
-            productBrand: product.brand,
-        };
-    }
-}
-WishlistService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: WishlistService, deps: [{ token: 'WishlistRepository' }, { token: 'ProductRepository' }, { token: 'LogRepository' }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable });
-WishlistService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: WishlistService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: WishlistService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['WishlistRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['ProductRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['LogRepository']
-                    }] }, { type: i3.Shops, decorators: [{
-                        type: Inject,
-                        args: [DEFAULT_SHOP]
-                    }] }];
-    } });
-
-class CouponRepositoriesFacade {
-    constructor(couponRepository, orderRepository, categoryRepository) {
-        this.couponRepository = couponRepository;
-        this.orderRepository = orderRepository;
-        this.categoryRepository = categoryRepository;
-    }
-}
-CouponRepositoriesFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CouponRepositoriesFacade, deps: [{ token: 'CouponRepository' }, { token: 'OrderRepository' }, { token: 'CategoryRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-CouponRepositoriesFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CouponRepositoriesFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CouponRepositoriesFacade, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['CouponRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['OrderRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['CategoryRepository']
-                    }] }];
-    } });
-
-class CouponService {
-    constructor(repositoriesFacade, configurationFacade) {
-        this.repositoriesFacade = repositoriesFacade;
-        this.configurationFacade = configurationFacade;
-        this.emailIsFromCollaborator = (userEmail) => !!(userEmail === null || userEmail === void 0 ? void 0 : userEmail.match(/@b4a.com.br/g));
-    }
-    checkCoupon(params) {
-        const { nickname, checkoutType, checkout, plan } = params;
-        return from(this.repositoriesFacade.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({ coupon: 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.configurationFacade.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(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { coupon, checkoutType, checkout, plan } = params;
-            if (checkoutType == CheckoutTypes.SUBSCRIPTION) {
-                return this.validateSubscriptionCoupon(coupon, plan);
-            }
-            return this.validateEcommerceCoupon(coupon, checkoutType, checkout);
-        });
-    }
-    validateSubscriptionCoupon(coupon, plan) {
-        if (coupon.plan && coupon.plan.toUpperCase() !== plan.toUpperCase()) {
-            throw 'Cupom inválido para sua assinatura.';
-        }
-        return coupon;
-    }
-    validateEcommerceCoupon(coupon, checkoutType, checkout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.validateUserEligibility(coupon, checkout === null || checkout === void 0 ? void 0 : checkout.user);
-            yield this.validateUsageLimits(coupon, checkoutType, checkout);
-            yield this.validateProductEligibility(coupon, checkout);
-            return coupon;
-        });
-    }
-    validateUserEligibility(coupon, user) {
-        const validUser = this.coupomUserValidation(coupon, user);
-        if (!validUser)
-            throw 'Usuário não elegível.';
-    }
-    validateUsageLimits(coupon, checkoutType, checkout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const couponUseLimits = this.getCouponUseLimits(coupon, checkoutType, checkout.user);
-            if (couponUseLimits.firstOrder) {
-                yield this.validateFirstOrderLimit(checkout.user.email);
-            }
-            if (!couponUseLimits.unlimited || couponUseLimits.limitedPerUser) {
-                yield this.validateCouponUsageLimits(coupon, couponUseLimits, checkout.user.email);
-            }
-        });
-    }
-    validateFirstOrderLimit(userEmail) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ordersUser = yield this.getOrdersFromUser(userEmail.toLocaleLowerCase());
-            if (ordersUser.length >= 1)
-                throw 'Limite de uso atingido';
-        });
-    }
-    validateCouponUsageLimits(coupon, couponUseLimits, userEmail) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ordersCoupon = yield this.getOrdersWithCoupon(coupon);
-            if (!couponUseLimits.unlimited && couponUseLimits.total && ordersCoupon.length >= couponUseLimits.total) {
-                throw 'Limite de uso atingido.';
-            }
-            if (couponUseLimits.limitedPerUser) {
-                const ordersWithUser = this.countOrdersWithUser(ordersCoupon, userEmail);
-                if (ordersWithUser > 0)
-                    throw 'Limite de uso por usuário atingido.';
-            }
-        });
-    }
-    validateProductEligibility(coupon, checkout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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) {
-                this.throwMinSubTotalError(coupon);
-            }
-        });
-    }
-    throwMinSubTotalError(coupon) {
-        var _a;
-        const formattedValue = Intl.NumberFormat('pt-BR', {
-            style: 'currency',
-            currency: 'BRL',
-        }).format(coupon.minSubTotalValue);
-        if ((_a = coupon.productsCategories) === null || _a === void 0 ? void 0 : _a.length) {
-            throw `Valor mínimo de ${formattedValue} não atingido na(s) categoria(s) elegíveis para o desconto.`;
-        }
-        throw `Valor mínimo de ${formattedValue} não atingido.`;
-    }
-    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);
-    }
-    hasMinSubTotal(coupon, checkout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!coupon.minSubTotalValue)
-                return true;
-            const 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, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!((_a = coupon.productsCategories) === null || _a === void 0 ? void 0 : _a.length)) {
-                return true;
-            }
-            const couponCategories = yield this.getCouponCategoriesId(coupon.productsCategories);
-            const hasCategories = (_b = checkout.lineItems) === null || _b === void 0 ? void 0 : _b.filter((item) => {
-                var _a;
-                if (item.isGift)
-                    return false;
-                if (!((_a = item.categories) === null || _a === void 0 ? void 0 : _a.length))
-                    return true;
-                return item.categories.some((c) => couponCategories.some((cat) => cat == c));
-            });
-            return (hasCategories === null || hasCategories === void 0 ? void 0 : hasCategories.length) ? true : false;
-        });
-    }
-    coupomUserValidation(coupon, user) {
-        if (!user || coupon.exclusivityType.includes(Exclusivities.ALL_USERS))
-            return true;
-        const 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.repositoriesFacade.categoryRepository.get({
-                    id: productsCategories[index],
-                });
-                if (category) {
-                    const children = yield this.repositoriesFacade.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 === null || productsCategories === void 0 ? void 0 : productsCategories.length) {
-                lineItensDiscount = (_a = checkout.lineItems) === null || _a === void 0 ? void 0 : _a.filter((item) => {
-                    var _a;
-                    if (item.isGift)
-                        return false;
-                    if ((_a = item.categories) === null || _a === void 0 ? void 0 : _a.length) {
-                        return item.categories.some((c) => couponCategories.some((cat) => cat == c));
-                    }
-                    return true;
-                });
-            }
-            else {
-                lineItensDiscount = checkout.lineItems.filter((item) => !item.isGift);
-            }
-            return lineItensDiscount;
-        });
-    }
-    calcCheckoutSubtotal(lineItens, user) {
-        return ((lineItens === null || lineItens === void 0 ? void 0 : lineItens.filter((item) => !item.isGift).reduce((acc, curr) => {
-            var _a, _b;
-            return (user === null || user === void 0 ? void 0 : user.isSubscriber) && ((_a = curr.price) === null || _a === void 0 ? void 0 : _a.subscriberPrice)
-                ? acc + ((_b = curr.price) === null || _b === void 0 ? void 0 : _b.subscriberPrice) * curr.quantity
-                : acc + curr.pricePaid * curr.quantity;
-        }, 0)) || 0);
-    }
-    getOrdersWithCoupon(coupon) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.repositoriesFacade.orderRepository
-                .find({
-                filters: {
-                    coupon: { id: coupon.id },
-                    status: { operator: Where.NOTEQUALS, value: OrderStatus.CANCELADO },
-                },
-            })
-                .then((result) => result.data);
-        });
-    }
-    getOrdersFromUser(email) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.repositoriesFacade.orderRepository
-                .find({
-                filters: {
-                    user: { email: { operator: Where.EQUALS, value: email } },
-                    status: { operator: Where.NOTEQUALS, value: OrderStatus.CANCELADO },
-                },
-            })
-                .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) {
-            if (coupon.exclusivityType.length === 1 &&
-                (coupon.exclusivityType.at(0) === Exclusivities.SPECIFIC_USER ||
-                    coupon.exclusivityType.at(0) === Exclusivities.COLLABORATORS))
-                couponUseLimits = coupon.useLimits.non_subscriber;
-            else
-                couponUseLimits = (user === null || user === void 0 ? void 0 : user.isSubscriber) ? coupon.useLimits.subscriber : coupon.useLimits.non_subscriber;
-        }
-        else {
-            couponUseLimits = coupon.useLimits.subscription;
-        }
-        return couponUseLimits;
-    }
-}
-CouponService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CouponService, deps: [{ token: CouponRepositoriesFacade }, { token: ConfigurationFacade }], 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: CouponRepositoriesFacade }, { type: ConfigurationFacade }]; } });
-
-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,
-            checkoutType: CheckoutTypes.SUBSCRIPTION,
-            checkout,
-            plan: 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(/[ãàáäâ]/g, 'a')
-            .replace(/[ẽèéëê]/g, 'e')
-            .replace(/[ìíïî]/g, 'i')
-            .replace(/[õòóöô]/g, 'o')
-            .replace(/[ùúüû]/g, 'u')
-            .replace(/[ñ]/g, 'n')
-            .replace(/[ç]/g, 'c')
-            .replace(/[&]/g, 'and')
-            .replace(/[^\w-]+/g, '')
-            .replace(/--+/g, '-');
-    }
-}
-
-class HomeShopRepositoriesFacade {
-    constructor(categoryRepository, homeRepository, productRepository) {
-        this.categoryRepository = categoryRepository;
-        this.homeRepository = homeRepository;
-        this.productRepository = productRepository;
-    }
-}
-HomeShopRepositoriesFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: HomeShopRepositoriesFacade, deps: [{ token: 'CategoryRepository' }, { token: 'HomeRepository' }, { token: 'ProductRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-HomeShopRepositoriesFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: HomeShopRepositoriesFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: HomeShopRepositoriesFacade, 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']
-                    }] }];
-    } });
-
-class HomeShopService {
-    get homeId() {
-        if (this.configurationFacade.defaultShop === Shops.GLAMSHOP)
-            return 'glamshop';
-        if (this.configurationFacade.defaultShop === Shops.MENSMARKET)
-            return 'mens_market';
-        return null;
-    }
-    constructor(repositoriesFacade, configurationFacade) {
-        this.repositoriesFacade = repositoriesFacade;
-        this.configurationFacade = configurationFacade;
-        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.repositoriesFacade.categoryRepository.getCategoriesForHome({
-            categoryIds: home.discoverCategories,
-            shop: this.configurationFacade.defaultShop,
-        })).pipe(map((groups) => groups.map(this.buildCategoryGroupWithRequiredData)))));
-    }
-    getFeaturedProducts(_gender) {
-        return this.getHomeConfiguration().pipe(concatMap((home) => from(this.repositoriesFacade.categoryRepository.getCategoriesForHome({
-            categoryIds: home.featuredCategories,
-            shop: this.configurationFacade.defaultShop,
-        })).pipe(map((groups) => groups.map(this.buildCategoryGroupWithRequiredData)))));
-    }
-    getVerticalProducts(gender) {
-        return this.getHomeConfiguration().pipe(concatMap((home) => forkJoin(home.verticalCarousels.filter(Boolean).map((id) => from(this.repositoriesFacade.categoryRepository.get({ id })).pipe(concatMap((category) => from(this.repositoriesFacade.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.repositoriesFacade.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.repositoriesFacade.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: HomeShopRepositoriesFacade }, { token: ConfigurationFacade }], 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: HomeShopRepositoriesFacade }, { type: ConfigurationFacade }]; } });
-
-class OrderProductReviewService {
-    constructor(orderRepository, productReviewRepository, variantRepository) {
-        this.orderRepository = orderRepository;
-        this.productReviewRepository = productReviewRepository;
-        this.variantRepository = variantRepository;
-    }
-    getPendingReviewsByEmail(email) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const products = [];
-            const orders = yield this.getOrdersByEmail(email);
-            if (orders.length) {
-                for (const order of orders) {
-                    const lineItems = order.lineItems.filter((item) => !item.isGift);
-                    for (const item of lineItems) {
-                        const productReview = yield this.getProductReview(order, item);
-                        if ((productReview === null || productReview === void 0 ? void 0 : productReview.status) != null)
-                            continue;
-                        products.push(this.buildProductReview(order, item, productReview));
-                    }
-                }
-            }
-            return products;
-        });
-    }
-    getOrdersByEmail(email) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { data: orders } = yield this.orderRepository.find({
-                filters: {
-                    user: {
-                        email: email,
-                    },
-                    status: OrderStatus.ENTREGUE,
-                    createdAt: {
-                        operator: Where.GTE,
-                        value: new Date(2024, 0, 0, 0, 0, 0).getTime(),
-                    },
-                },
-                orderBy: {
-                    createdAt: 'desc',
-                },
-            });
-            return orders;
-        });
-    }
-    getProductReview(order, item) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const products = [item.id];
-            const isVariant = yield this.variantRepository
-                .find({
-                filters: {
-                    id: item.id,
-                },
-            })
-                .then((res) => res.data.at(0));
-            if (isVariant)
-                products.push(isVariant.productId);
-            const productReview = yield this.productReviewRepository
-                .find({
-                filters: {
-                    orderId: { operator: Where.IN, value: [order.id, order.orderNumber].filter(Boolean) },
-                    productId: { operator: Where.IN, value: products },
-                },
-            })
-                .then((res) => res.data.at(0));
-            return productReview;
-        });
-    }
-    buildProductReview(order, item, review) {
-        return {
-            id: item.id,
-            orderId: order.id,
-            orderNumber: order.orderNumber,
-            isEdition: false,
-            name: item.name,
-            image: item.image,
-            deliveryDate: order.deliveredAt || null,
-            evaluationInAnalysis: review ? true : false,
-            rating: review ? review.rate : null,
-            shopProductSlug: item.slug,
-        };
-    }
-    createReview(review) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.productReviewRepository.create(ProductReview.toInstance({
-                productId: review.productId.toString(),
-                shop: review.shop,
-                rate: review.rate,
-                author: review.author,
-                email: review.email,
-                location: review.location,
-                review: review.comment,
-                title: review.title,
-                personId: review.personId,
-                points: review.points,
-                orderId: review.orderId,
-            }));
-        });
-    }
-}
-OrderProductReviewService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OrderProductReviewService, deps: [{ token: 'OrderRepository' }, { token: 'ProductReviewRepository' }, { token: 'VariantRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-OrderProductReviewService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OrderProductReviewService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OrderProductReviewService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: i3.OrderFirestoreRepository, decorators: [{
-                        type: Inject,
-                        args: ['OrderRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['ProductReviewRepository']
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: ['VariantRepository']
-                    }] }];
-    } });
-
-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: i3.OrderFirestoreRepository, decorators: [{
-                        type: Inject,
-                        args: ['OrderRepository']
-                    }] }];
-    } });
-
-class AngularConnectModule {
-    static initializeApp(defaultShop, options, nameOrConfig) {
-        return {
-            ngModule: AngularConnectModule,
-            providers: [
-                ...this.buildCoreProviders(nameOrConfig, options),
-                ...this.buildConditionalProviders(defaultShop, options),
-            ],
-        };
-    }
-    static buildCoreProviders(nameOrConfig, options) {
-        return [
-            { provide: FIREBASE_APP_NAME, useValue: nameOrConfig },
-            { provide: APP_CHECK_PROVIDER, useValue: options.appCheckProvider },
-            {
-                provide: CATEGORY_STRUCTURE,
-                useClass: this.selectCategoryStructureAdapter(options.oldCategoryStructure),
-            },
-            { provide: PERSISTENCE_PROVIDER, useClass: (options === null || options === void 0 ? void 0 : options.persistenceProvider) || CookieDataPersistence },
-        ];
-    }
-    static buildConditionalProviders(defaultShop, options) {
-        return [
-            ...this.createProviderIfExists(DEFAULT_SHOP, defaultShop),
-            ...this.createProviderIfExists(FIREBASE_OPTIONS, options.firebase),
-            ...this.createProviderIfExists(ES_CONFIG, options.elasticSearch),
-            ...this.createProviderIfExists(VERTEX_CONFIG, options.vertexConfig),
-            ...this.createProviderIfExists(HASURA_OPTIONS, options.hasura),
-            ...this.createProviderIfExists(BACKEND_URL, options.backendUrl),
-            ...this.createProviderIfExists(STORAGE_BASE_URL, options.storageBaseUrl),
-        ];
-    }
-    static selectCategoryStructureAdapter(oldCategoryStructure) {
-        return isNil(oldCategoryStructure) || oldCategoryStructure
-            ? OldCategoryStructureAdapter
-            : NewCategoryStructureAdapter;
-    }
-    static createProviderIfExists(token, value) {
-        return isNil(value) ? [] : [{ provide: token, useValue: value }];
-    }
-}
-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$3.FirebaseAppModule, i2.AppCheckModule, i3$1.StorageModule, AngularElasticSeachModule,
-        AngularVertexSeachModule,
-        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,
-        WishlistService,
-        ConfigurationFacade,
-        CartServicesFacade,
-        CheckoutRepositoriesFacade,
-        CheckoutDependenciesFacade,
-        CategoryRepositoryFacade,
-        ProductCatalogFacade,
-        CatalogServiceFacade,
-        CategoryServiceFacade,
-        CatalogStrategiesFacade,
-        CatalogOperationsFacade,
-        ProductManagementFacade,
-        {
-            provide: 'ProductServicesFacade',
-            useFactory: (productStockNotificationRepository, categoryRepository, productSearch) => ({
-                productStockNotificationRepository,
-                categoryRepository,
-                productSearch,
-            }),
-            deps: ['ProductStockNotificationRepository', 'CategoryRepository', 'ProductSearch'],
-        },
-        CatalogFilterHelper,
-        CatalogSortHelper,
-        ProductFieldsHelper,
-        BrandManagerHelper,
-        CatalogRepositoryService,
-        CatalogHelpersService,
-        CategorySearchStrategy,
-        TermSearchStrategy,
-        ProfileSearchStrategy,
-        {
-            provide: CatalogSearchContext,
-            useFactory: (categoryStrategy, termStrategy, profileStrategy) => {
-                return new CatalogSearchContext(categoryStrategy, termStrategy, profileStrategy);
-            },
-            deps: [CategorySearchStrategy, TermSearchStrategy, ProfileSearchStrategy],
-        },
-        {
-            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],
-        },
-        {
-            provide: 'ProductSearch',
-            useExisting: ProductsVertexSearch,
-        },
-        CouponRepositoriesFacade,
-        HomeShopRepositoriesFacade,
-        OrderProductReviewService,
-    ], imports: [provideFirebaseApp((injector) => {
-            const appName = injector.get(FIREBASE_APP_NAME);
-            try {
-                const app = appName ? getApp(appName) : getApp();
-                return app;
-            }
-            catch (error) {
-                console.warn('Firebase app not found, initializing new app');
-                if (error instanceof Error)
-                    console.error(error.message);
-                return initializeApp(injector.get(FIREBASE_OPTIONS), appName);
-            }
-        }),
-        provideAppCheck((injector) => {
-            const app = injector.get(FirebaseApp);
-            try {
-                const provider = injector.get(APP_CHECK_PROVIDER);
-                if (provider)
-                    return initializeAppCheck(app, {
-                        provider,
-                        isTokenAutoRefreshEnabled: true,
-                    });
-            }
-            catch (error) {
-                if (error instanceof Error)
-                    console.error(error.message);
-                return;
-            }
-        }),
-        provideStorage((injector) => getStorage(injector.get(FirebaseApp))),
-        AngularElasticSeachModule,
-        AngularVertexSeachModule,
-        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);
-                            try {
-                                const app = appName ? getApp(appName) : getApp();
-                                return app;
-                            }
-                            catch (error) {
-                                console.warn('Firebase app not found, initializing new app');
-                                if (error instanceof Error)
-                                    console.error(error.message);
-                                return initializeApp(injector.get(FIREBASE_OPTIONS), appName);
-                            }
-                        }),
-                        provideAppCheck((injector) => {
-                            const app = injector.get(FirebaseApp);
-                            try {
-                                const provider = injector.get(APP_CHECK_PROVIDER);
-                                if (provider)
-                                    return initializeAppCheck(app, {
-                                        provider,
-                                        isTokenAutoRefreshEnabled: true,
-                                    });
-                            }
-                            catch (error) {
-                                if (error instanceof Error)
-                                    console.error(error.message);
-                                return;
-                            }
-                        }),
-                        provideStorage((injector) => getStorage(injector.get(FirebaseApp))),
-                        AngularElasticSeachModule,
-                        AngularVertexSeachModule,
-                        AngularFirebaseAuthModule,
-                        AngularFirestoreModule,
-                        AngularHasuraGraphQLModule,
-                    ],
-                    providers: [
-                        AuthService,
-                        CartService,
-                        CatalogService,
-                        CategoryService,
-                        CheckoutService,
-                        CheckoutSubscriptionService,
-                        CouponService,
-                        HomeShopService,
-                        OrderService,
-                        WishlistService,
-                        ConfigurationFacade,
-                        CartServicesFacade,
-                        CheckoutRepositoriesFacade,
-                        CheckoutDependenciesFacade,
-                        CategoryRepositoryFacade,
-                        ProductCatalogFacade,
-                        CatalogServiceFacade,
-                        CategoryServiceFacade,
-                        CatalogStrategiesFacade,
-                        CatalogOperationsFacade,
-                        ProductManagementFacade,
-                        {
-                            provide: 'ProductServicesFacade',
-                            useFactory: (productStockNotificationRepository, categoryRepository, productSearch) => ({
-                                productStockNotificationRepository,
-                                categoryRepository,
-                                productSearch,
-                            }),
-                            deps: ['ProductStockNotificationRepository', 'CategoryRepository', 'ProductSearch'],
-                        },
-                        CatalogFilterHelper,
-                        CatalogSortHelper,
-                        ProductFieldsHelper,
-                        BrandManagerHelper,
-                        CatalogRepositoryService,
-                        CatalogHelpersService,
-                        CategorySearchStrategy,
-                        TermSearchStrategy,
-                        ProfileSearchStrategy,
-                        {
-                            provide: CatalogSearchContext,
-                            useFactory: (categoryStrategy, termStrategy, profileStrategy) => {
-                                return new CatalogSearchContext(categoryStrategy, termStrategy, profileStrategy);
-                            },
-                            deps: [CategorySearchStrategy, TermSearchStrategy, ProfileSearchStrategy],
-                        },
-                        {
-                            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],
-                        },
-                        {
-                            provide: 'ProductSearch',
-                            useExisting: ProductsVertexSearch,
-                        },
-                        CouponRepositoriesFacade,
-                        HomeShopRepositoriesFacade,
-                        OrderProductReviewService,
-                    ],
-                }]
-        }] });
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { AngularConnectModule, AngularFirebaseAuthModule, AngularFirestoreModule, AngularHasuraGraphQLModule, AuthService, CartService, CatalogService, CategoryService, CategoryWithTree, CheckoutService, CheckoutSubscriptionService, CookieDataPersistence, CouponService, HomeShopService, NewCategoryStructureAdapter, OldCategoryStructureAdapter, OrderProductReviewService, OrderService, ProductSorts, UtilHelper, WishlistService };
-//# sourceMappingURL=infrab4a-connect-angular.mjs.map