@dereekb/dbx-analytics 1.1.0 → 2.1.0

package/lib/analytics/analytics.service.d.ts

@@ -1,87 +1,87 @@
 import { Observable, BehaviorSubject, Subscription } from 'rxjs';
-import { AnalyticsEvent, AnalyticsEventData, AnalyticsEventName, AnalyticsUser, NewUserAnalyticsEventData, UserAnalyticsEvent } from './analytics';
-import { AnalyticsStreamEvent, AnalyticsStreamEventType } from './analytics.stream';
+import { DbxAnalyticsEvent, DbxAnalyticsEventData, DbxAnalyticsEventName, DbxAnalyticsUser, NewUserAnalyticsEventData, DbxUserAnalyticsEvent } from './analytics';
+import { DbxAnalyticsStreamEvent, DbxAnalyticsStreamEventType } from './analytics.stream';
 import { Maybe, Destroyable } from '@dereekb/util';
 import * as i0 from "@angular/core";
-export declare abstract class AnalyticsEventEmitterService {
-    abstract sendNewUserEvent(user: AnalyticsUser, data: NewUserAnalyticsEventData): void;
-    abstract sendUserLoginEvent(user: AnalyticsUser, data?: AnalyticsEventData): void;
-    abstract sendUserLogoutEvent(data?: AnalyticsEventData): void;
-    abstract sendUserPropertiesEvent(user: AnalyticsUser, data?: AnalyticsEventData): void;
-    abstract sendEventData(name: AnalyticsEventName, data?: AnalyticsEventData): void;
-    abstract sendEvent(event: AnalyticsEvent): void;
+export declare abstract class DbxAnalyticsEventEmitterService {
+    abstract sendNewUserEvent(user: DbxAnalyticsUser, data: NewUserAnalyticsEventData): void;
+    abstract sendUserLoginEvent(user: DbxAnalyticsUser, data?: DbxAnalyticsEventData): void;
+    abstract sendUserLogoutEvent(data?: DbxAnalyticsEventData): void;
+    abstract sendUserPropertiesEvent(user: DbxAnalyticsUser, data?: DbxAnalyticsEventData): void;
+    abstract sendEventData(name: DbxAnalyticsEventName, data?: DbxAnalyticsEventData): void;
+    abstract sendEvent(event: DbxAnalyticsEvent): void;
     abstract sendPageView(page?: string): void;
 }
-export declare abstract class AnalyticsEventStreamService {
-    abstract readonly events$: Observable<AnalyticsStreamEvent>;
+export declare abstract class DbxAnalyticsEventStreamService {
+    abstract readonly events$: Observable<DbxAnalyticsStreamEvent>;
 }
-export declare abstract class AnalyticsUserSource {
-    abstract readonly analyticsUser$: Observable<Maybe<AnalyticsUser>>;
+export declare abstract class DbxAnalyticsUserSource {
+    abstract readonly analyticsUser$: Observable<Maybe<DbxAnalyticsUser>>;
 }
-export declare abstract class AnalyticsServiceListener {
-    abstract listenToService(service: AnalyticsService): void;
+export declare abstract class DbxAnalyticsServiceListener {
+    abstract listenToService(service: DbxAnalyticsService): void;
 }
 /**
  * Abstract AnalyticsServiceListener implementation.
  */
-export declare abstract class AbstractAnalyticsServiceListener implements AnalyticsServiceListener, Destroyable {
+export declare abstract class AbstractDbxAnalyticsServiceListener implements DbxAnalyticsServiceListener, Destroyable {
     private _sub;
-    protected _analytics: BehaviorSubject<Maybe<AnalyticsService>>;
-    readonly analytics$: Observable<AnalyticsService>;
-    readonly analyticsEvents$: Observable<AnalyticsStreamEvent>;
-    listenToService(service: AnalyticsService): void;
+    protected _analytics: BehaviorSubject<Maybe<DbxAnalyticsService>>;
+    readonly analytics$: Observable<DbxAnalyticsService>;
+    readonly analyticsEvents$: Observable<DbxAnalyticsStreamEvent>;
+    listenToService(service: DbxAnalyticsService): void;
     protected abstract _initializeServiceSubscription(): Subscription | false;
     destroy(): void;
 }
-export declare abstract class AnalyticsServiceConfiguration {
-    listeners: AnalyticsServiceListener[];
+export declare abstract class DbxAnalyticsServiceConfiguration {
+    listeners: DbxAnalyticsServiceListener[];
     isProduction?: boolean;
     logEvents?: boolean;
-    userSource?: AnalyticsUserSource;
+    userSource?: DbxAnalyticsUserSource;
 }
-export declare class AnalyticsStreamEventAnalyticsEventWrapper implements AnalyticsStreamEvent {
-    readonly event: UserAnalyticsEvent;
-    readonly type: AnalyticsStreamEventType;
-    constructor(event: UserAnalyticsEvent, type?: AnalyticsStreamEventType);
-    get user(): Maybe<AnalyticsUser>;
+export declare class DbxAnalyticsStreamEventAnalyticsEventWrapper implements DbxAnalyticsStreamEvent {
+    readonly event: DbxUserAnalyticsEvent;
+    readonly type: DbxAnalyticsStreamEventType;
+    constructor(event: DbxUserAnalyticsEvent, type?: DbxAnalyticsStreamEventType);
+    get user(): Maybe<DbxAnalyticsUser>;
     get userId(): string | undefined;
 }
 /**
  * Primary analytics service that emits analytics events that components can listen to.
  */
-export declare class AnalyticsService implements AnalyticsEventStreamService, AnalyticsEventEmitterService, Destroyable {
+export declare class DbxAnalyticsService implements DbxAnalyticsEventStreamService, DbxAnalyticsEventEmitterService, Destroyable {
     private _config;
     static readonly USER_REGISTRATION_EVENT_NAME = "User Registered";
     static readonly USER_LOGIN_EVENT_NAME = "User Login";
     static readonly USER_LOGOUT_EVENT_NAME = "User Logout";
     static readonly USER_PROPERTIES_EVENT_NAME = "User Properties";
     private _subject;
-    readonly events$: Observable<AnalyticsStreamEvent>;
+    readonly events$: Observable<DbxAnalyticsStreamEvent>;
     private _userSource;
-    readonly user$: Observable<Maybe<AnalyticsUser>>;
+    readonly user$: Observable<Maybe<DbxAnalyticsUser>>;
     private _userSourceSub;
     private _loggerSub;
-    constructor(_config: AnalyticsServiceConfiguration, userSource?: Maybe<AnalyticsUserSource>);
+    constructor(_config: DbxAnalyticsServiceConfiguration, userSource?: Maybe<DbxAnalyticsUserSource>);
     /**
      * Sets the user directly.
      */
-    setUser(user: Maybe<AnalyticsUser>): void;
-    setUserSource(source: AnalyticsUserSource): void;
+    setUser(user: Maybe<DbxAnalyticsUser>): void;
+    setUserSource(source: DbxAnalyticsUserSource): void;
     /**
      * Sends an event.
      */
-    sendNewUserEvent(user: AnalyticsUser, data: NewUserAnalyticsEventData): void;
-    sendUserLoginEvent(user: AnalyticsUser, data?: AnalyticsEventData): void;
-    sendUserLogoutEvent(data?: AnalyticsEventData, clearUser?: boolean): void;
-    sendUserPropertiesEvent(user: AnalyticsUser, data?: AnalyticsEventData): void;
-    sendEventData(name: AnalyticsEventName, data?: AnalyticsEventData): void;
-    sendEventType(eventType: AnalyticsEventName): void;
-    sendEvent(event: AnalyticsEvent): void;
+    sendNewUserEvent(user: DbxAnalyticsUser, data: NewUserAnalyticsEventData): void;
+    sendUserLoginEvent(user: DbxAnalyticsUser, data?: DbxAnalyticsEventData): void;
+    sendUserLogoutEvent(data?: DbxAnalyticsEventData, clearUser?: boolean): void;
+    sendUserPropertiesEvent(user: DbxAnalyticsUser, data?: DbxAnalyticsEventData): void;
+    sendEventData(name: DbxAnalyticsEventName, data?: DbxAnalyticsEventData): void;
+    sendEventType(eventType: DbxAnalyticsEventName): void;
+    sendEvent(event: DbxAnalyticsEvent): void;
     sendPageView(page?: string): void;
-    protected sendNextEvent(event: AnalyticsEvent | undefined, type: AnalyticsStreamEventType, userOverride?: AnalyticsUser): void;
-    protected nextEvent(event: UserAnalyticsEvent, type: AnalyticsStreamEventType): void;
+    protected sendNextEvent(event: DbxAnalyticsEvent | undefined, type: DbxAnalyticsStreamEventType, userOverride?: DbxAnalyticsUser): void;
+    protected nextEvent(event: DbxUserAnalyticsEvent, type: DbxAnalyticsStreamEventType): void;
     private _init;
     destroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AnalyticsService, [null, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AnalyticsService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAnalyticsService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxAnalyticsService>;
 }

package/lib/analytics/analytics.stream.d.ts

@@ -1,6 +1,6 @@
 import { Maybe } from "@dereekb/util";
-import { AnalyticsUser, UserAnalyticsEvent, AnalyticsUserId } from "./analytics";
-export declare enum AnalyticsStreamEventType {
+import { DbxAnalyticsUser, DbxUserAnalyticsEvent, DbxAnalyticsUserId } from "./analytics";
+export declare enum DbxAnalyticsStreamEventType {
     PageView = 0,
     UserChange = 1,
     NewUserEvent = 2,
@@ -9,9 +9,9 @@ export declare enum AnalyticsStreamEventType {
     UserPropertiesEvent = 5,
     Event = 6
 }
-export interface AnalyticsStreamEvent {
-    readonly type: AnalyticsStreamEventType;
-    readonly user?: Maybe<AnalyticsUser>;
-    readonly event?: UserAnalyticsEvent;
-    readonly userId?: AnalyticsUserId;
+export interface DbxAnalyticsStreamEvent {
+    readonly type: DbxAnalyticsStreamEventType;
+    readonly user?: Maybe<DbxAnalyticsUser>;
+    readonly event?: DbxUserAnalyticsEvent;
+    readonly userId?: DbxAnalyticsUserId;
 }

package/lib/providers/segment/segment.listener.service.d.ts

@@ -1,18 +1,18 @@
 /// <reference types="segment-analytics" />
-import { AbstractAnalyticsServiceListener, AnalyticsStreamEvent } from '../../analytics';
-import { SegmentApiService } from './segment.service';
+import { AbstractDbxAnalyticsServiceListener, DbxAnalyticsStreamEvent } from '../../analytics';
+import { DbxAnalyticsSegmentApiService } from './segment.service';
 import * as i0 from "@angular/core";
 /**
- * AnalyticsServiceListener adapter for Segment.
+ * DbxAnalyticsServiceListener adapter for Segment.
  */
-export declare class SegmentAnalyticsListenerService extends AbstractAnalyticsServiceListener {
+export declare class DbxAnalyticsSegmentServiceListener extends AbstractDbxAnalyticsServiceListener {
     private _segmentApi;
-    constructor(_segmentApi: SegmentApiService);
+    constructor(_segmentApi: DbxAnalyticsSegmentApiService);
     protected _initializeServiceSubscription(): import("rxjs").Subscription;
-    protected handleStreamEvent(api: SegmentAnalytics.AnalyticsJS, streamEvent: AnalyticsStreamEvent): void;
-    protected updateWithNewUserEvent(api: SegmentAnalytics.AnalyticsJS, streamEvent: AnalyticsStreamEvent): void;
-    protected updateWithEvent(api: SegmentAnalytics.AnalyticsJS, streamEvent: AnalyticsStreamEvent, name?: string): void;
+    protected handleStreamEvent(api: SegmentAnalytics.AnalyticsJS, streamEvent: DbxAnalyticsStreamEvent): void;
+    protected updateWithNewUserEvent(api: SegmentAnalytics.AnalyticsJS, streamEvent: DbxAnalyticsStreamEvent): void;
+    protected updateWithEvent(api: SegmentAnalytics.AnalyticsJS, streamEvent: DbxAnalyticsStreamEvent, name?: string): void;
     private changeUser;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentAnalyticsListenerService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SegmentAnalyticsListenerService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAnalyticsSegmentServiceListener, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxAnalyticsSegmentServiceListener>;
 }

package/lib/providers/segment/segment.module.d.ts

@@ -1,8 +1,8 @@
 import { ModuleWithProviders } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare class SegmentModule {
-    static forRoot(preloadService?: boolean): ModuleWithProviders<SegmentModule>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<SegmentModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<SegmentModule>;
+export declare class DbxAnalyticsSegmentModule {
+    static forRoot(preloadService?: boolean): ModuleWithProviders<DbxAnalyticsSegmentModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAnalyticsSegmentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxAnalyticsSegmentModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxAnalyticsSegmentModule>;
 }

package/lib/providers/segment/segment.service.d.ts

@@ -3,7 +3,7 @@ import { InjectionToken } from '@angular/core';
 import { AbstractAsyncWindowLoadedService } from '@dereekb/browser';
 import * as i0 from "@angular/core";
 export declare const PRELOAD_SEGMENT_TOKEN: InjectionToken<string>;
-export declare class SegmentApiServiceConfig {
+export declare class DbxAnalyticsSegmentApiServiceConfig {
     writeKey: string;
     logging: boolean;
     active: boolean;
@@ -14,14 +14,14 @@ export declare class SegmentApiServiceConfig {
  *
  * This requires some setup in index.html.
  */
-export declare class SegmentApiService extends AbstractAsyncWindowLoadedService<SegmentAnalytics.AnalyticsJS> {
+export declare class DbxAnalyticsSegmentApiService extends AbstractAsyncWindowLoadedService<SegmentAnalytics.AnalyticsJS> {
     private _config;
     static readonly SEGMENT_API_WINDOW_KEY = "analytics";
     static readonly SEGMENT_READY_KEY = "SegmentReady";
-    constructor(_config: SegmentApiServiceConfig, preload?: boolean);
-    get config(): SegmentApiServiceConfig;
+    constructor(_config: DbxAnalyticsSegmentApiServiceConfig, preload?: boolean);
+    get config(): DbxAnalyticsSegmentApiServiceConfig;
     protected _prepareCompleteLoadingService(): Promise<void>;
     protected _initService(service: SegmentAnalytics.AnalyticsJS): Promise<SegmentAnalytics.AnalyticsJS>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentApiService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SegmentApiService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAnalyticsSegmentApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxAnalyticsSegmentApiService>;
 }

package/package.json

@@ -1,23 +1,20 @@
 {
   "name": "@dereekb/dbx-analytics",
-  "version": "1.1.0",
+  "version": "2.1.0",
   "peerDependencies": {
     "@angular/common": "^13.1.0",
     "@angular/core": "^13.1.0",
-    "@dereekb/rxjs": "1.1.0",
-    "rxjs": "^7.5.2",
-    "@dereekb/util": "1.1.0",
+    "@dereekb/rxjs": "2.1.0",
+    "rxjs": "^7.0.0",
+    "@dereekb/util": "2.1.0",
     "extra-set": "^2.2.11",
+    "make-error": "^1.3.0",
     "ms": "^3.0.0-canary.1",
-    "@dereekb/dbx-core": "1.1.0",
+    "@dereekb/dbx-core": "2.1.0",
     "@ngrx/component-store": "^13.0.2",
-    "@ngrx/data": "^13.0.2",
-    "@ngrx/effects": "^13.0.2",
-    "@ngrx/entity": "^13.0.2",
-    "@ngrx/store": "^13.0.2",
     "@angular/platform-browser": "^13.0.0",
     "date-fns": "^2.28.0",
-    "@dereekb/date": "1.1.0",
+    "@dereekb/date": "2.1.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.13.2",
     "date-fns-tz": "^1.2.2",
@@ -25,7 +22,7 @@
     "@angular/router": "^13.0.0",
     "@uirouter/core": "^6.0.8",
     "@uirouter/angular": "^9.1.0",
-    "@dereekb/browser": "1.1.0"
+    "@dereekb/browser": "2.1.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"