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

package/angular-connect.module.d.ts

@@ -6,14 +6,11 @@ import { HasuraGraphQLOptions } from './angular-hasura-graphql.module';
 import { DataPersistence } from './persistence';
 import { FirebaseAppConfig } from './types';
 import * as i0 from "@angular/core";
-import * as i1 from "@angular/fire/app";
-import * as i2 from "@angular/fire/app-check";
-import * as i3 from "@angular/fire/storage";
-import * as i4 from "./angular-elastic-search.module";
-import * as i5 from "./angular-vertex-search.module";
-import * as i6 from "./angular-firebase-auth.module";
-import * as i7 from "./angular-firestore.module";
-import * as i8 from "./angular-hasura-graphql.module";
+import * as i1 from "./angular-elastic-search.module";
+import * as i2 from "./angular-vertex-search.module";
+import * as i3 from "./angular-firebase-auth.module";
+import * as i4 from "./angular-firestore.module";
+import * as i5 from "./angular-hasura-graphql.module";
 export declare class AngularConnectModule {
     static initializeApp(defaultShop: Shops, options: {
         firebase?: FirebaseOptions;
@@ -31,6 +28,6 @@ export declare class AngularConnectModule {
     private static selectCategoryStructureAdapter;
     private static createProviderIfExists;
     static ɵfac: i0.ɵɵFactoryDeclaration<AngularConnectModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularConnectModule, never, [typeof i1.FirebaseAppModule, typeof i2.AppCheckModule, typeof i3.StorageModule, typeof i4.AngularElasticSeachModule, typeof i5.AngularVertexSeachModule, typeof i6.AngularFirebaseAuthModule, typeof i7.AngularFirestoreModule, typeof i8.AngularHasuraGraphQLModule], never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularConnectModule, never, [typeof i1.AngularElasticSeachModule, typeof i2.AngularVertexSeachModule, typeof i3.AngularFirebaseAuthModule, typeof i4.AngularFirestoreModule, typeof i5.AngularHasuraGraphQLModule], never>;
     static ɵinj: i0.ɵɵInjectorDeclaration<AngularConnectModule>;
 }

package/angular-firebase-auth.module.d.ts

@@ -2,10 +2,9 @@ import { ModuleWithProviders } from '@angular/core';
 import { FirebaseOptions } from '@angular/fire/app';
 import { FirebaseAppConfig } from './types';
 import * as i0 from "@angular/core";
-import * as i1 from "@angular/fire/auth";
 export declare class AngularFirebaseAuthModule {
     static initializeApp(options: FirebaseOptions, nameOrConfig?: string | FirebaseAppConfig): ModuleWithProviders<AngularFirebaseAuthModule>;
     static ɵfac: i0.ɵɵFactoryDeclaration<AngularFirebaseAuthModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularFirebaseAuthModule, never, [typeof i1.AuthModule], never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularFirebaseAuthModule, never, never, never>;
     static ɵinj: i0.ɵɵInjectorDeclaration<AngularFirebaseAuthModule>;
 }

package/angular-firestore.module.d.ts

@@ -4,7 +4,6 @@ import { AxiosElasticSearchConfig, FirestoreConstructorParams } from '@infrab4a/
 import { FirebaseAppConfig } from './types';
 import * as i0 from "@angular/core";
 import * as i1 from "./angular-elastic-search.module";
-import * as i2 from "@angular/fire/firestore";
 export type FirestoreOptions = Pick<FirestoreConstructorParams<any>, 'firestore' | 'interceptors'>;
 export declare class AngularFirestoreModule {
     static initializeApp(options: {
@@ -12,6 +11,6 @@ export declare class AngularFirestoreModule {
         elasticSearch: AxiosElasticSearchConfig;
     }, nameOrConfig?: string | FirebaseAppConfig): ModuleWithProviders<AngularFirestoreModule>;
     static ɵfac: i0.ɵɵFactoryDeclaration<AngularFirestoreModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularFirestoreModule, never, [typeof i1.AngularElasticSeachModule, typeof i2.FirestoreModule], never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularFirestoreModule, never, [typeof i1.AngularElasticSeachModule], never>;
     static ɵinj: i0.ɵɵInjectorDeclaration<AngularFirestoreModule>;
 }

package/esm2022/angular-connect.module.mjs

@@ -0,0 +1,288 @@
+import { NgModule } from '@angular/core';
+import { FirebaseApp, getApp, initializeApp, provideFirebaseApp } from '@angular/fire/app';
+import { initializeAppCheck, provideAppCheck } from '@angular/fire/app-check';
+import { getStorage, provideStorage, Storage } from '@angular/fire/storage';
+import { FirebaseFileUploaderService, isNil, ProductsVertexSearch, UpdateUserImage, } from '@infrab4a/connect';
+import { AngularElasticSeachModule } from './angular-elastic-search.module';
+import { AngularFirebaseAuthModule } from './angular-firebase-auth.module';
+import { AngularFirestoreModule } from './angular-firestore.module';
+import { AngularHasuraGraphQLModule } from './angular-hasura-graphql.module';
+import { AngularVertexSeachModule } from './angular-vertex-search.module';
+import { APP_CHECK_PROVIDER, BACKEND_URL, CATEGORY_STRUCTURE, DEFAULT_SHOP, ES_CONFIG, FIREBASE_APP_NAME, FIREBASE_OPTIONS, HASURA_OPTIONS, PERSISTENCE_PROVIDER, VERTEX_CONFIG, } from './consts';
+import { STORAGE_BASE_URL } from './consts/storage-base-url.const';
+import { CookieDataPersistence } from './persistence';
+import { AuthService, CartService, CatalogService, CategoryService, CheckoutService, CheckoutSubscriptionService, CouponService, HomeShopService, OrderProductReviewService, OrderService, WishlistService, } from './services';
+import { CartServicesFacade } from './services/cart';
+import { NewCategoryStructureAdapter, OldCategoryStructureAdapter } from './services/catalog/adapters';
+import { CatalogSearchContext } from './services/catalog/context/catalog-search.context';
+import { CatalogServiceFacade, CatalogStrategiesFacade, CategoryRepositoryFacade, CategoryServiceFacade, ProductCatalogFacade, } from './services/catalog/facades';
+import { BrandManagerHelper, CatalogFilterHelper, CatalogSortHelper, ProductFieldsHelper, } from './services/catalog/helpers';
+import { CatalogHelpersService, CatalogOperationsFacade, CatalogRepositoryService, ProductManagementFacade, } from './services/catalog/services';
+import { CategorySearchStrategy, ProfileSearchStrategy, TermSearchStrategy } from './services/catalog/strategies';
+import { CheckoutDependenciesFacade, CheckoutRepositoriesFacade } from './services/checkout';
+import { CouponRepositoriesFacade } from './services/coupon';
+import { HomeShopRepositoriesFacade } from './services/home-shop';
+import { ConfigurationFacade } from './services/shared';
+import * as i0 from "@angular/core";
+export 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?.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 }];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularConnectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: AngularConnectModule, imports: [AngularElasticSeachModule,
+            AngularVertexSeachModule,
+            AngularFirebaseAuthModule,
+            AngularFirestoreModule,
+            AngularHasuraGraphQLModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularConnectModule, providers: [
+            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))),
+            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: [AngularElasticSeachModule,
+            AngularVertexSeachModule,
+            AngularFirebaseAuthModule,
+            AngularFirestoreModule,
+            AngularHasuraGraphQLModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularConnectModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AngularElasticSeachModule,
+                        AngularVertexSeachModule,
+                        AngularFirebaseAuthModule,
+                        AngularFirestoreModule,
+                        AngularHasuraGraphQLModule,
+                    ],
+                    providers: [
+                        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))),
+                        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,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"angular-connect.module.js","sourceRoot":"","sources":["../../../projects/connect-angular/src/angular-connect.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injector, ModuleWithProviders, NgModule, Type } from '@angular/core'\nimport { FirebaseApp, FirebaseOptions, getApp, initializeApp, provideFirebaseApp } from '@angular/fire/app'\nimport { AppCheckOptions, initializeAppCheck, provideAppCheck } from '@angular/fire/app-check'\nimport { getStorage, provideStorage, Storage } from '@angular/fire/storage'\nimport {\n  AxiosElasticSearchConfig,\n  FileUploaderService,\n  FirebaseFileUploaderService,\n  isNil,\n  ProductsVertexSearch,\n  Shops,\n  UpdateUserImage,\n  UserRepository,\n  VertexSearchConfig,\n} from '@infrab4a/connect'\n\nimport { AngularElasticSeachModule } from './angular-elastic-search.module'\nimport { AngularFirebaseAuthModule } from './angular-firebase-auth.module'\nimport { AngularFirestoreModule } from './angular-firestore.module'\nimport { AngularHasuraGraphQLModule, HasuraGraphQLOptions } from './angular-hasura-graphql.module'\nimport { AngularVertexSeachModule } from './angular-vertex-search.module'\nimport {\n  APP_CHECK_PROVIDER,\n  BACKEND_URL,\n  CATEGORY_STRUCTURE,\n  DEFAULT_SHOP,\n  ES_CONFIG,\n  FIREBASE_APP_NAME,\n  FIREBASE_OPTIONS,\n  HASURA_OPTIONS,\n  PERSISTENCE_PROVIDER,\n  VERTEX_CONFIG,\n} from './consts'\nimport { STORAGE_BASE_URL } from './consts/storage-base-url.const'\nimport { CookieDataPersistence, DataPersistence } from './persistence'\nimport {\n  AuthService,\n  CartService,\n  CatalogService,\n  CategoryService,\n  CheckoutService,\n  CheckoutSubscriptionService,\n  CouponService,\n  HomeShopService,\n  OrderProductReviewService,\n  OrderService,\n  WishlistService,\n} from './services'\nimport { CartServicesFacade } from './services/cart'\nimport { NewCategoryStructureAdapter, OldCategoryStructureAdapter } from './services/catalog/adapters'\nimport { CatalogSearchContext } from './services/catalog/context/catalog-search.context'\nimport {\n  CatalogServiceFacade,\n  CatalogStrategiesFacade,\n  CategoryRepositoryFacade,\n  CategoryServiceFacade,\n  ProductCatalogFacade,\n} from './services/catalog/facades'\nimport {\n  BrandManagerHelper,\n  CatalogFilterHelper,\n  CatalogSortHelper,\n  ProductFieldsHelper,\n} from './services/catalog/helpers'\nimport {\n  CatalogHelpersService,\n  CatalogOperationsFacade,\n  CatalogRepositoryService,\n  ProductManagementFacade,\n} from './services/catalog/services'\nimport { CategorySearchStrategy, ProfileSearchStrategy, TermSearchStrategy } from './services/catalog/strategies'\nimport { CheckoutDependenciesFacade, CheckoutRepositoriesFacade } from './services/checkout'\nimport { CouponRepositoriesFacade } from './services/coupon'\nimport { HomeShopRepositoriesFacade } from './services/home-shop'\nimport { ConfigurationFacade } from './services/shared'\nimport { FirebaseAppConfig } from './types'\n\n@NgModule({\n  imports: [\n    AngularElasticSeachModule,\n    AngularVertexSeachModule,\n    AngularFirebaseAuthModule,\n    AngularFirestoreModule,\n    AngularHasuraGraphQLModule,\n  ],\n  providers: [\n    provideFirebaseApp((injector: Injector) => {\n      const appName = injector.get<string>(FIREBASE_APP_NAME)\n\n      try {\n        const app = appName ? getApp(appName) : getApp()\n\n        return app\n      } catch (error) {\n        console.warn('Firebase app not found, initializing new app')\n\n        if (error instanceof Error) console.error(error.message)\n\n        return initializeApp(injector.get(FIREBASE_OPTIONS), appName)\n      }\n    }),\n    provideAppCheck((injector: Injector) => {\n      const app = injector.get(FirebaseApp)\n\n      try {\n        const provider = injector.get<AppCheckOptions['provider']>(APP_CHECK_PROVIDER)\n\n        if (provider)\n          return initializeAppCheck(app, {\n            provider,\n            isTokenAutoRefreshEnabled: true,\n          })\n      } catch (error) {\n        if (error instanceof Error) console.error(error.message)\n\n        return\n      }\n    }),\n    provideStorage((injector: Injector) => getStorage(injector.get(FirebaseApp))),\n    AuthService,\n    CartService,\n    CatalogService,\n    CategoryService,\n    CheckoutService,\n    CheckoutSubscriptionService,\n    CouponService,\n    HomeShopService,\n    OrderService,\n    WishlistService,\n    ConfigurationFacade,\n    CartServicesFacade,\n    CheckoutRepositoriesFacade,\n    CheckoutDependenciesFacade,\n    CategoryRepositoryFacade,\n    ProductCatalogFacade,\n    CatalogServiceFacade,\n    CategoryServiceFacade,\n    CatalogStrategiesFacade,\n    CatalogOperationsFacade,\n    ProductManagementFacade,\n    {\n      provide: 'ProductServicesFacade',\n      useFactory: (productStockNotificationRepository: any, categoryRepository: any, productSearch: any) => ({\n        productStockNotificationRepository,\n        categoryRepository,\n        productSearch,\n      }),\n      deps: ['ProductStockNotificationRepository', 'CategoryRepository', 'ProductSearch'],\n    },\n    CatalogFilterHelper,\n    CatalogSortHelper,\n    ProductFieldsHelper,\n    BrandManagerHelper,\n    CatalogRepositoryService,\n    CatalogHelpersService,\n    CategorySearchStrategy,\n    TermSearchStrategy,\n    ProfileSearchStrategy,\n    {\n      provide: CatalogSearchContext,\n      useFactory: (\n        categoryStrategy: CategorySearchStrategy,\n        termStrategy: TermSearchStrategy,\n        profileStrategy: ProfileSearchStrategy,\n      ) => {\n        return new CatalogSearchContext(categoryStrategy, termStrategy, profileStrategy)\n      },\n      deps: [CategorySearchStrategy, TermSearchStrategy, ProfileSearchStrategy],\n    },\n    {\n      provide: UpdateUserImage,\n      useFactory: (userRepository: UserRepository, fileUploader: FileUploaderService) => {\n        return new UpdateUserImage(userRepository, fileUploader)\n      },\n      deps: ['UserRepository', 'FileUploaderService'],\n    },\n    {\n      provide: 'FileUploaderService',\n      useFactory: (storage: Storage, baseUrl: string) => {\n        return new FirebaseFileUploaderService(storage, baseUrl)\n      },\n      deps: [Storage, STORAGE_BASE_URL],\n    },\n    {\n      provide: 'ProductSearch',\n      useExisting: ProductsVertexSearch,\n    },\n    CouponRepositoriesFacade,\n    HomeShopRepositoriesFacade,\n    OrderProductReviewService,\n  ],\n})\nexport class AngularConnectModule {\n  static initializeApp(\n    defaultShop: Shops,\n    options: {\n      firebase?: FirebaseOptions\n      elasticSearch?: AxiosElasticSearchConfig\n      vertexConfig?: VertexSearchConfig\n      hasura: HasuraGraphQLOptions\n      backendUrl: string\n      oldCategoryStructure?: boolean\n      storageBaseUrl?: string\n      persistenceProvider?: Type<DataPersistence>\n      appCheckProvider?: AppCheckOptions['provider']\n    },\n    nameOrConfig?: string | FirebaseAppConfig,\n  ): ModuleWithProviders<AngularConnectModule> {\n    return {\n      ngModule: AngularConnectModule,\n      providers: [\n        ...this.buildCoreProviders(nameOrConfig, options),\n        ...this.buildConditionalProviders(defaultShop, options),\n      ],\n    }\n  }\n\n  private static buildCoreProviders(\n    nameOrConfig: string | FirebaseAppConfig,\n    options: {\n      appCheckProvider?: AppCheckOptions['provider']\n      oldCategoryStructure?: boolean\n      persistenceProvider?: Type<DataPersistence>\n    },\n  ) {\n    return [\n      { provide: FIREBASE_APP_NAME, useValue: nameOrConfig },\n      { provide: APP_CHECK_PROVIDER, useValue: options.appCheckProvider },\n      {\n        provide: CATEGORY_STRUCTURE,\n        useClass: this.selectCategoryStructureAdapter(options.oldCategoryStructure),\n      },\n      { provide: PERSISTENCE_PROVIDER, useClass: options?.persistenceProvider || CookieDataPersistence },\n    ]\n  }\n\n  private static buildConditionalProviders(\n    defaultShop: Shops,\n    options: {\n      firebase?: FirebaseOptions\n      elasticSearch?: AxiosElasticSearchConfig\n      vertexConfig?: VertexSearchConfig\n      hasura: HasuraGraphQLOptions\n      backendUrl: string\n      storageBaseUrl?: string\n    },\n  ) {\n    return [\n      ...this.createProviderIfExists(DEFAULT_SHOP, defaultShop),\n      ...this.createProviderIfExists(FIREBASE_OPTIONS, options.firebase),\n      ...this.createProviderIfExists(ES_CONFIG, options.elasticSearch),\n      ...this.createProviderIfExists(VERTEX_CONFIG, options.vertexConfig),\n      ...this.createProviderIfExists(HASURA_OPTIONS, options.hasura),\n      ...this.createProviderIfExists(BACKEND_URL, options.backendUrl),\n      ...this.createProviderIfExists(STORAGE_BASE_URL, options.storageBaseUrl),\n    ]\n  }\n\n  private static selectCategoryStructureAdapter(oldCategoryStructure?: boolean) {\n    return isNil(oldCategoryStructure) || oldCategoryStructure\n      ? OldCategoryStructureAdapter\n      : NewCategoryStructureAdapter\n  }\n\n  private static createProviderIfExists(token: any, value: any) {\n    return isNil(value) ? [] : [{ provide: token, useValue: value }]\n  }\n}\n"]}

package/esm2022/angular-elastic-search.module.mjs

@@ -0,0 +1,34 @@
+import { NgModule } from '@angular/core';
+import { AxiosAdapter, ProductsIndex } from '@infrab4a/connect';
+import { ES_CONFIG } from './consts/es-config.const';
+import * as i0 from "@angular/core";
+export class AngularElasticSeachModule {
+    static initializeApp(options) {
+        return {
+            ngModule: AngularElasticSeachModule,
+            providers: [{ provide: ES_CONFIG, useValue: options }],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularElasticSeachModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: AngularElasticSeachModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularElasticSeachModule, providers: [
+            {
+                provide: ProductsIndex,
+                useFactory: (configuration) => new ProductsIndex(new AxiosAdapter(configuration)),
+                deps: [ES_CONFIG],
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularElasticSeachModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        {
+                            provide: ProductsIndex,
+                            useFactory: (configuration) => new ProductsIndex(new AxiosAdapter(configuration)),
+                            deps: [ES_CONFIG],
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/angular-firebase-auth.module.mjs

@@ -0,0 +1,140 @@
+import { NgModule } from '@angular/core';
+import { FirebaseApp } from '@angular/fire/app';
+import { Auth, browserLocalPersistence, browserSessionPersistence, getAuth, indexedDBLocalPersistence, initializeAuth, provideAuth, } from '@angular/fire/auth';
+import { Authentication, AuthenticationFirebaseAuthService, RecoveryPassword, Register, RegisterFirebaseAuthService, SignOut, } from '@infrab4a/connect';
+import { FIREBASE_APP_NAME, FIREBASE_OPTIONS } from './consts';
+import * as i0 from "@angular/core";
+export class AngularFirebaseAuthModule {
+    static initializeApp(options, nameOrConfig) {
+        return {
+            ngModule: AngularFirebaseAuthModule,
+            providers: [
+                { provide: FIREBASE_OPTIONS, useValue: options },
+                { provide: FIREBASE_APP_NAME, useValue: nameOrConfig },
+            ],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularFirebaseAuthModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: AngularFirebaseAuthModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularFirebaseAuthModule, providers: [
+            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);
+                }
+            }),
+            {
+                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'],
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularFirebaseAuthModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    providers: [
+                        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);
+                            }
+                        }),
+                        {
+                            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'],
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"angular-firebase-auth.module.js","sourceRoot":"","sources":["../../../projects/connect-angular/src/angular-firebase-auth.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injector, ModuleWithProviders, NgModule } from '@angular/core'\nimport { FirebaseApp, FirebaseOptions } from '@angular/fire/app'\nimport {\n  Auth,\n  browserLocalPersistence,\n  browserSessionPersistence,\n  getAuth,\n  indexedDBLocalPersistence,\n  initializeAuth,\n  provideAuth,\n} from '@angular/fire/auth'\nimport {\n  Authentication,\n  AuthenticationFirebaseAuthService,\n  AuthenticationService,\n  RecoveryPassword,\n  Register,\n  RegisterFirebaseAuthService,\n  RegisterService,\n  SignOut,\n  UserRepository,\n} from '@infrab4a/connect'\n\nimport { FIREBASE_APP_NAME, FIREBASE_OPTIONS } from './consts'\nimport { FirebaseAppConfig } from './types'\n\n@NgModule({\n  imports: [],\n  providers: [\n    provideAuth((injector: Injector) => {\n      const app = injector.get(FirebaseApp)\n\n      try {\n        return initializeAuth(app, {\n          persistence: [indexedDBLocalPersistence, browserLocalPersistence, browserSessionPersistence],\n        })\n      } catch (error) {\n        if (error instanceof Error) console.error('Error initializing auth', error.message)\n\n        return getAuth(app)\n      }\n    }),\n    {\n      provide: 'Authentication',\n      useFactory: (authenticationService: AuthenticationService, userRepository: UserRepository): Authentication => {\n        return new Authentication(authenticationService, userRepository)\n      },\n      deps: ['AuthenticationService', 'UserRepository'],\n    },\n    {\n      provide: 'AuthenticationService',\n      useFactory: (angularFireAuth: Auth): AuthenticationService => {\n        return new AuthenticationFirebaseAuthService(angularFireAuth)\n      },\n      deps: [Auth],\n    },\n    {\n      provide: 'Register',\n      useFactory: (registerService: RegisterService, userRepository: UserRepository): Register => {\n        return new Register(registerService, userRepository)\n      },\n      deps: ['RegisterService', 'UserRepository'],\n    },\n    {\n      provide: 'RegisterService',\n      useFactory: (angularFireAuth: Auth): RegisterService => {\n        return new RegisterFirebaseAuthService(angularFireAuth)\n      },\n      deps: [Auth],\n    },\n    {\n      provide: 'SignOut',\n      useFactory: (authenticationService: AuthenticationService): SignOut => {\n        return new SignOut(authenticationService)\n      },\n      deps: ['AuthenticationService'],\n    },\n    {\n      provide: 'RecoveryPassword',\n      useFactory: (authenticationService: AuthenticationService): RecoveryPassword => {\n        return new RecoveryPassword(authenticationService)\n      },\n      deps: ['AuthenticationService'],\n    },\n  ],\n})\nexport class AngularFirebaseAuthModule {\n  static initializeApp(\n    options: FirebaseOptions,\n    nameOrConfig?: string | FirebaseAppConfig,\n  ): ModuleWithProviders<AngularFirebaseAuthModule> {\n    return {\n      ngModule: AngularFirebaseAuthModule,\n      providers: [\n        { provide: FIREBASE_OPTIONS, useValue: options },\n        { provide: FIREBASE_APP_NAME, useValue: nameOrConfig },\n      ],\n    }\n  }\n}\n"]}