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

package/src/angular-firestore.module.ts

@@ -1,371 +0,0 @@
-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

@@ -1,219 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

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

package/src/consts/category-structure.ts

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

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

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

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

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

package/src/consts/firebase-const.ts

@@ -1,5 +0,0 @@
-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

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

package/src/consts/index.ts

@@ -1,8 +0,0 @@
-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

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

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

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

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

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

package/src/helpers/index.ts

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

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

@@ -1,10 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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'