@infrab4a/connect-angular 5.1.0 → 6.0.0-alpha.0

package/src/angular-firestore.module.ts

@@ -0,0 +1,371 @@
+import { isPlatformBrowser, isPlatformServer } from '@angular/common'
+import { Injector, ModuleWithProviders, NgModule, PLATFORM_ID } from '@angular/core'
+import { FirebaseApp, FirebaseOptions } from '@angular/fire/app'
+import { Firestore, initializeFirestore, memoryLocalCache, provideFirestore } from '@angular/fire/firestore'
+import {
+  AxiosElasticSearchConfig,
+  BeautyProfileRepository,
+  Buy2WinFirestoreRepository,
+  Buy2WinRepository,
+  CampaignDashboardFirestoreRepository,
+  CampaignDashboardRepository,
+  CampaignHashtagFirestoreRepository,
+  CampaignHashtagRepository,
+  CategoryFirestoreRepository,
+  CategoryRepository,
+  CheckoutFirestoreRepository,
+  CheckoutRepository,
+  CheckoutSubscriptionFirestoreRepository,
+  CheckoutSubscriptionRepository,
+  ConnectFirestoreService,
+  CouponFirestoreRepository,
+  CouponRepository,
+  EditionRepository,
+  FirestoreConstructorParams,
+  FirestoreIntertceptorRequestParams,
+  GroupFirestoreRepository,
+  GroupRepository,
+  HomeFirestoreRepository,
+  HomeRepository,
+  LeadFirestoreRepository,
+  LeadRepository,
+  LegacyOrderFirestoreRepository,
+  LegacyOrderRepository,
+  LogFirestoreRepository,
+  LogRepository,
+  OrderBlockedFirestoreRepository,
+  OrderBlockedRepository,
+  OrderFirestoreRepository,
+  OrderRepository,
+  PaymentFirestoreRepository,
+  PaymentRepository,
+  ProductFirestoreRepository,
+  ProductRepository,
+  ProductVariantFirestoreRepository,
+  SequenceFirestoreRepository,
+  ShopMenuFirestoreRepository,
+  ShopMenuRepository,
+  ShopSettingsFirestoreRepository,
+  ShopSettingsRepository,
+  SubscriptionEditionFirestoreRepository,
+  SubscriptionFirestoreRepository,
+  SubscriptionMaterializationFirestoreRepository,
+  SubscriptionMaterializationRepository,
+  SubscriptionPaymentFirestoreRepository,
+  SubscriptionPaymentRepository,
+  SubscriptionPlanFirestoreRepository,
+  SubscriptionPlanRepository,
+  SubscriptionProductFirestoreRepository,
+  SubscriptionProductRepository,
+  SubscriptionRepository,
+  SubscriptionSummaryFirestoreRepository,
+  SubscriptionSummaryRepository,
+  UserAddressFirestoreRepository,
+  UserAddressRepository,
+  UserBeautyProfileFirestoreRepository,
+  UserFirestoreRepository,
+  UserPaymentMethodFirestoreRepository,
+  UserPaymentMethodRepository,
+  UserRepository,
+  VariantRepository,
+} from '@infrab4a/connect'
+
+import { AngularElasticSeachModule } from './angular-elastic-search.module'
+import { ES_CONFIG, FIREBASE_APP_NAME, FIREBASE_OPTIONS } from './consts'
+import { MobileOperationSystemCheckerHelper } from './helpers'
+import { FirebaseAppConfig } from './types'
+
+export type FirestoreOptions = Pick<FirestoreConstructorParams<any>, 'firestore' | 'interceptors'>
+
+@NgModule({
+  imports: [
+    AngularElasticSeachModule,
+    provideFirestore((injector: 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: Firestore, platformId: string): FirestoreOptions => ({
+        firestore: new ConnectFirestoreService(firestore),
+        interceptors: {
+          request: (request: FirestoreIntertceptorRequestParams<any> & { interval: ReturnType<typeof setTimeout> }) => {
+            if (isPlatformBrowser(platformId)) return request
+
+            const interval = setInterval(() => {}, 100)
+
+            request.interval = interval
+
+            return request
+          },
+          response: (
+            response: any,
+            request: FirestoreIntertceptorRequestParams<any> & { interval: ReturnType<typeof setTimeout> },
+          ) => {
+            if (isPlatformBrowser(platformId)) return response
+
+            clearInterval(request.interval)
+
+            return response
+          },
+        },
+      }),
+      deps: [Firestore, PLATFORM_ID],
+    },
+    {
+      provide: 'BeautyProfileRepository',
+      useFactory: (config: FirestoreOptions, userRepository: UserFirestoreRepository): BeautyProfileRepository => {
+        return new UserBeautyProfileFirestoreRepository(config, userRepository)
+      },
+      deps: ['FirestoreOptions', 'UserRepository'],
+    },
+    {
+      provide: 'Buy2WinRepository',
+      useFactory: (options: FirestoreOptions): Buy2WinRepository => {
+        return new Buy2WinFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: CategoryFirestoreRepository,
+      useFactory: (options: FirestoreOptions): CategoryRepository => {
+        return new CategoryFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'CheckoutRepository',
+      useFactory: (options: FirestoreOptions): CheckoutRepository => {
+        return new CheckoutFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'CheckoutSubscriptionRepository',
+      useFactory: (options: FirestoreOptions): CheckoutSubscriptionRepository => {
+        return new CheckoutSubscriptionFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'CouponRepository',
+      useFactory: (options: FirestoreOptions): CouponRepository => {
+        return new CouponFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'CampaignHashtagRepository',
+      useFactory: (options: FirestoreOptions): CampaignHashtagRepository => {
+        return new CampaignHashtagFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'CampaignDashboardRepository',
+      useFactory: (options: FirestoreOptions): CampaignDashboardRepository => {
+        return new CampaignDashboardFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'EditionRepository',
+      useFactory: (
+        options: FirestoreOptions,
+        subscriptionRepository: SubscriptionFirestoreRepository,
+      ): EditionRepository => {
+        return new SubscriptionEditionFirestoreRepository(options, subscriptionRepository)
+      },
+      deps: ['FirestoreOptions', 'SubscriptionRepository'],
+    },
+    {
+      provide: 'GroupRepository',
+      useFactory: (options: FirestoreOptions): GroupRepository => {
+        return new GroupFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'HomeRepository',
+      useFactory: (options: FirestoreOptions): HomeRepository => {
+        return new HomeFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'LeadRepository',
+      useFactory: (options: FirestoreOptions): LeadRepository => {
+        return new LeadFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'LegacyOrderRepository',
+      useFactory: (options: FirestoreOptions): LegacyOrderRepository => {
+        return new LegacyOrderFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'ShopMenuRepository',
+      useFactory: (options: FirestoreOptions): ShopMenuRepository => {
+        return new ShopMenuFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'OrderRepository',
+      useFactory: (options: FirestoreOptions): OrderRepository => {
+        return new OrderFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'PaymentRepository',
+      useFactory: (options: FirestoreOptions): PaymentRepository => {
+        return new PaymentFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: ProductFirestoreRepository,
+      useFactory: (options: FirestoreOptions): ProductRepository => {
+        return new ProductFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'ShopSettingsRepository',
+      useFactory: (options: FirestoreOptions): ShopSettingsRepository => {
+        return new ShopSettingsFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'SubscriptionPaymentRepository',
+      useFactory: (
+        options: FirestoreOptions,
+        subscriptionRepository: SubscriptionFirestoreRepository,
+      ): SubscriptionPaymentRepository => {
+        return new SubscriptionPaymentFirestoreRepository(options, subscriptionRepository)
+      },
+      deps: ['FirestoreOptions', 'SubscriptionRepository'],
+    },
+    {
+      provide: 'SubscriptionPlanRepository',
+      useFactory: (options: FirestoreOptions): SubscriptionPlanRepository => {
+        return new SubscriptionPlanFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'SubscriptionProductRepository',
+      useFactory: (options: FirestoreOptions): SubscriptionProductRepository => {
+        return new SubscriptionProductFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'SubscriptionRepository',
+      useFactory: (options: FirestoreOptions): SubscriptionRepository => {
+        return new SubscriptionFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'UserRepository',
+      useFactory: (options: FirestoreOptions): UserRepository => {
+        return new UserFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'UserAddressRepository',
+      useFactory: (options: FirestoreOptions, userRepository: UserFirestoreRepository): UserAddressRepository => {
+        return new UserAddressFirestoreRepository(options, userRepository)
+      },
+      deps: ['FirestoreOptions', 'UserRepository'],
+    },
+    {
+      provide: 'UserPaymentMethodRepository',
+      useFactory: (options: FirestoreOptions, userRepository: UserFirestoreRepository): UserPaymentMethodRepository => {
+        return new UserPaymentMethodFirestoreRepository(options, userRepository)
+      },
+      deps: ['FirestoreOptions', 'UserRepository'],
+    },
+    {
+      provide: 'SubscriptionMaterializationRepository',
+      useFactory: (options: FirestoreOptions): SubscriptionMaterializationRepository => {
+        return new SubscriptionMaterializationFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'SubscriptionSummaryRepository',
+      useFactory: (options: FirestoreOptions): SubscriptionSummaryRepository => {
+        return new SubscriptionSummaryFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: ProductVariantFirestoreRepository,
+      useFactory: (options: FirestoreOptions, productRepository: ProductFirestoreRepository): VariantRepository => {
+        return new ProductVariantFirestoreRepository(options, productRepository)
+      },
+      deps: ['FirestoreOptions', ProductFirestoreRepository],
+    },
+    {
+      provide: 'OrderBlockedRepository',
+      useFactory: (options: FirestoreOptions): OrderBlockedRepository => {
+        return new OrderBlockedFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'LogRepository',
+      useFactory: (options: FirestoreOptions): LogRepository => {
+        return new LogFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+    {
+      provide: 'SequenceRepository',
+      useFactory: (options: FirestoreOptions): SequenceFirestoreRepository => {
+        return new SequenceFirestoreRepository(options)
+      },
+      deps: ['FirestoreOptions'],
+    },
+  ],
+})
+export class AngularFirestoreModule {
+  static initializeApp(
+    options: {
+      firebase: FirebaseOptions
+      elasticSearch: AxiosElasticSearchConfig
+    },
+    nameOrConfig?: string | FirebaseAppConfig,
+  ): ModuleWithProviders<AngularFirestoreModule> {
+    return {
+      ngModule: AngularFirestoreModule,
+      providers: [
+        { provide: FIREBASE_OPTIONS, useValue: options.firebase },
+        { provide: FIREBASE_APP_NAME, useValue: nameOrConfig },
+        { provide: ES_CONFIG, useValue: options.elasticSearch },
+      ],
+    }
+  }
+}

package/src/angular-hasura-graphql.module.ts

@@ -0,0 +1,219 @@
+import { isPlatformBrowser } from '@angular/common'
+import { ModuleWithProviders, NgModule, PLATFORM_ID } from '@angular/core'
+import {
+  CacheConfig,
+  CategoryCollectionChildrenHasuraGraphQLRepository,
+  CategoryFilterHasuraGraphQLRepository,
+  CategoryFilterRepository,
+  CategoryHasuraGraphQLRepository,
+  CategoryProductHasuraGraphQLRepository,
+  CategoryRepository,
+  FilterHasuraGraphQLRepository,
+  FilterOptionHasuraGraphQLRepository,
+  FilterOptionRepository,
+  FilterRepository,
+  GraphQLParams,
+  HasuraConstructorParams,
+  HasuraGraphQLAuthOptions,
+  ProductErrors,
+  ProductErrorsHasuraGraphQLRepository,
+  ProductErrorsRepository,
+  ProductHasuraGraphQLRepository,
+  ProductRepository,
+  ProductReviewHasuraGraphQLRepository,
+  ProductReviewRepository,
+  ProductStockNotificationHasuraGraphQLRepository,
+  ProductStockNotificationRepository,
+  VariantHasuraGraphQLRepository,
+  VariantRepository,
+  WishlistHasuraGraphQLRepository,
+} from '@infrab4a/connect'
+
+import { HASURA_OPTIONS } from './consts'
+
+export type HasuraGraphQLOptions = { endpoint: string; credentials?: HasuraGraphQLAuthOptions; cache?: CacheConfig }
+
+@NgModule({
+  providers: [
+    {
+      provide: 'HasuraConfig',
+      useFactory: (options: HasuraGraphQLOptions, platformId: string) => ({
+        endpoint: options.endpoint,
+        authOptions: options.credentials,
+        cache: options.cache,
+        interceptors: {
+          request: (request: GraphQLParams<any> & { interval: ReturnType<typeof setTimeout> }) => {
+            if (isPlatformBrowser(platformId)) return request
+
+            const interval = setInterval(() => {}, 100)
+
+            request.interval = interval
+
+            return request
+          },
+          response: (response: any, request: GraphQLParams<any> & { interval: ReturnType<typeof setTimeout> }) => {
+            if (isPlatformBrowser(platformId)) return response
+
+            clearInterval(request.interval)
+
+            return response
+          },
+        },
+      }),
+      deps: [HASURA_OPTIONS, PLATFORM_ID],
+    },
+    {
+      provide: 'CategoryRepository',
+      useExisting: CategoryHasuraGraphQLRepository,
+    },
+    {
+      provide: CategoryHasuraGraphQLRepository,
+      useFactory: (
+        options: any,
+        productRepository: ProductHasuraGraphQLRepository,
+        categoryFilterRepository: CategoryFilterHasuraGraphQLRepository,
+      ): CategoryRepository => {
+        return new CategoryHasuraGraphQLRepository(options, productRepository, categoryFilterRepository)
+      },
+      deps: ['HasuraConfig', ProductHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository],
+    },
+    {
+      provide: 'ProductRepository',
+      useExisting: ProductHasuraGraphQLRepository,
+    },
+    {
+      provide: ProductHasuraGraphQLRepository,
+      useFactory: (hasuraConfig: any): ProductRepository => {
+        return new ProductHasuraGraphQLRepository(hasuraConfig)
+      },
+      deps: ['HasuraConfig'],
+    },
+    {
+      provide: 'ProductReviewRepository',
+      useExisting: ProductReviewHasuraGraphQLRepository,
+    },
+    {
+      provide: ProductReviewHasuraGraphQLRepository,
+      useFactory: (hasuraConfig: any): ProductReviewRepository => {
+        return new ProductReviewHasuraGraphQLRepository(hasuraConfig)
+      },
+      deps: ['HasuraConfig'],
+    },
+    {
+      provide: 'VariantRepository',
+      useExisting: VariantHasuraGraphQLRepository,
+    },
+    {
+      provide: VariantHasuraGraphQLRepository,
+      useFactory: (hasuraConfig: any): VariantRepository => {
+        return new VariantHasuraGraphQLRepository(hasuraConfig)
+      },
+      deps: ['HasuraConfig'],
+    },
+    {
+      provide: 'ProductStockNotificationRepository',
+      useExisting: ProductStockNotificationHasuraGraphQLRepository,
+    },
+    {
+      provide: ProductStockNotificationHasuraGraphQLRepository,
+      useFactory: (hasuraConfig: any): ProductStockNotificationRepository => {
+        return new ProductStockNotificationHasuraGraphQLRepository(hasuraConfig)
+      },
+      deps: ['HasuraConfig'],
+    },
+    {
+      provide: 'CategoryFilterRepository',
+      useExisting: CategoryFilterHasuraGraphQLRepository,
+    },
+    {
+      provide: CategoryFilterHasuraGraphQLRepository,
+      useFactory: (options: any): CategoryFilterRepository => {
+        return new CategoryFilterHasuraGraphQLRepository(options)
+      },
+      deps: ['HasuraConfig'],
+    },
+    {
+      provide: 'FilterOptionRepository',
+      useExisting: FilterOptionHasuraGraphQLRepository,
+    },
+    {
+      provide: FilterOptionHasuraGraphQLRepository,
+      useFactory: (options: any): FilterOptionRepository => {
+        return new FilterOptionHasuraGraphQLRepository(options)
+      },
+      deps: ['HasuraConfig'],
+    },
+    {
+      provide: 'FilterRepository',
+      useExisting: FilterHasuraGraphQLRepository,
+    },
+    {
+      provide: FilterHasuraGraphQLRepository,
+      useFactory: (
+        options: any,
+        filterOptionRepository: FilterOptionHasuraGraphQLRepository,
+        categoryFilterRepository: CategoryFilterHasuraGraphQLRepository,
+      ): FilterRepository => {
+        return new FilterHasuraGraphQLRepository(options, filterOptionRepository, categoryFilterRepository)
+      },
+      deps: ['HasuraConfig', FilterOptionHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository],
+    },
+    {
+      provide: CategoryCollectionChildrenHasuraGraphQLRepository,
+      useFactory: (options: any): CategoryCollectionChildrenHasuraGraphQLRepository =>
+        new CategoryCollectionChildrenHasuraGraphQLRepository(options),
+      deps: ['HasuraConfig'],
+    },
+    {
+      provide: 'CategoryCollectionChildrenRepository',
+      useExisting: CategoryCollectionChildrenHasuraGraphQLRepository,
+    },
+    {
+      provide: CategoryProductHasuraGraphQLRepository,
+      useFactory: (options: any): CategoryProductHasuraGraphQLRepository => {
+        return new CategoryProductHasuraGraphQLRepository(options)
+      },
+      deps: ['HasuraConfig'],
+    },
+    {
+      provide: 'CategoryProductRepository',
+      useExisting: CategoryProductHasuraGraphQLRepository,
+    },
+    {
+      provide: WishlistHasuraGraphQLRepository,
+      useFactory: (
+        options: any,
+        categoryProductRepository: CategoryProductHasuraGraphQLRepository,
+      ): WishlistHasuraGraphQLRepository => {
+        return new WishlistHasuraGraphQLRepository(options, categoryProductRepository)
+      },
+      deps: ['HasuraConfig', CategoryProductHasuraGraphQLRepository],
+    },
+    {
+      provide: 'WishlistRepository',
+      useExisting: WishlistHasuraGraphQLRepository,
+    },
+    {
+      provide: ProductErrorsHasuraGraphQLRepository,
+      useFactory: (
+        options: HasuraConstructorParams<ProductErrors>,
+        productRepository: ProductHasuraGraphQLRepository,
+      ): ProductErrorsRepository => {
+        return new ProductErrorsHasuraGraphQLRepository(options, productRepository)
+      },
+      deps: ['HasuraConfig', ProductHasuraGraphQLRepository],
+    },
+    {
+      provide: 'ProductErrorsRepository',
+      useExisting: ProductErrorsHasuraGraphQLRepository,
+    },
+  ],
+})
+export class AngularHasuraGraphQLModule {
+  static initializeApp(options: HasuraGraphQLOptions): ModuleWithProviders<AngularHasuraGraphQLModule> {
+    return {
+      ngModule: AngularHasuraGraphQLModule,
+      providers: [{ provide: HASURA_OPTIONS, useValue: options }],
+    }
+  }
+}

package/src/angular-vertex-search.module.ts

@@ -0,0 +1,23 @@
+import { ModuleWithProviders, NgModule } from '@angular/core'
+import { ProductsVertexSearch, VertexAxiosAdapter, VertexSearchConfig } from '@infrab4a/connect'
+
+import { VERTEX_CONFIG } from './consts'
+
+@NgModule({
+  providers: [
+    {
+      provide: ProductsVertexSearch,
+      useFactory: (configuration: VertexSearchConfig): ProductsVertexSearch =>
+        new ProductsVertexSearch(new VertexAxiosAdapter(configuration)),
+      deps: [VERTEX_CONFIG],
+    },
+  ],
+})
+export class AngularVertexSeachModule {
+  static initializeApp(options: VertexSearchConfig): ModuleWithProviders<AngularVertexSeachModule> {
+    return {
+      ngModule: AngularVertexSeachModule,
+      providers: [{ provide: VERTEX_CONFIG, useValue: options }],
+    }
+  }
+}

package/src/consts/backend-url.const.ts

@@ -0,0 +1 @@
+export const BACKEND_URL = 'BACKEND_URL'

package/src/consts/category-structure.ts

@@ -0,0 +1 @@
+export const CATEGORY_STRUCTURE = 'CATEGORY_STRUCTURE'

package/src/consts/default-shop.const.ts

@@ -0,0 +1 @@
+export const DEFAULT_SHOP = 'DEFAULT_SHOP'

package/src/consts/es-config.const.ts

@@ -0,0 +1 @@
+export const ES_CONFIG = 'ES_CONFIG'

package/src/consts/firebase-const.ts

@@ -0,0 +1,5 @@
+import { InjectionToken } from '@angular/core'
+
+export const FIREBASE_APP_NAME = new InjectionToken('firebaseAppName')
+export const FIREBASE_OPTIONS = new InjectionToken('firebaseOptions')
+export const APP_CHECK_PROVIDER = new InjectionToken('appCheckProvider')

package/src/consts/hasura-options.const.ts

@@ -0,0 +1 @@
+export const HASURA_OPTIONS = 'HASURA_OPTIONS'

package/src/consts/index.ts

@@ -0,0 +1,8 @@
+export * from './backend-url.const'
+export * from './category-structure'
+export * from './default-shop.const'
+export * from './es-config.const'
+export * from './firebase-const'
+export * from './hasura-options.const'
+export * from './persistence.const'
+export * from './vertex-config.const'

package/src/consts/persistence.const.ts

@@ -0,0 +1 @@
+export const PERSISTENCE_PROVIDER = 'PERSISTENCE_PROVIDER'

package/src/consts/storage-base-url.const.ts

@@ -0,0 +1 @@
+export const STORAGE_BASE_URL = 'STORAGE_BASE_URL'

package/src/consts/vertex-config.const.ts

@@ -0,0 +1 @@
+export const VERTEX_CONFIG = 'VERTEX_CONFIG'

package/src/helpers/index.ts

@@ -0,0 +1 @@
+export * from './mobile-operation-system-checker.helper'

package/src/helpers/mobile-operation-system-checker.helper.ts

@@ -0,0 +1,10 @@
+export class MobileOperationSystemCheckerHelper {
+  static isAppleDevice() {
+    return (
+      ['iPad Simulator', 'iPhone Simulator', 'iPod Simulator', 'iPad', 'iPhone', 'iPod'].includes(
+        navigator?.platform,
+      ) ||
+      (navigator?.userAgent?.includes?.('Mac') && 'ontouchend' in (document || {}))
+    )
+  }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './angular-connect.module'
+export * from './angular-firebase-auth.module'
+export * from './angular-firestore.module'
+export * from './angular-hasura-graphql.module'
+export * from './persistence'
+export * from './services'