@stacksee/analytics 0.4.2 → 0.4.4

package/dist/src/adapters/server/server-analytics.d.ts

@@ -1,23 +1,426 @@
-import { AnalyticsConfig, EventContext } from '../../core/events/types.js';
+import { AnalyticsConfig, EventContext } from '../../../../src/core/events/types.js';
 type DefaultEventMap = Record<string, Record<string, unknown>>;
 export declare class ServerAnalytics<TEventMap extends DefaultEventMap = DefaultEventMap> {
     private providers;
     private config;
     private initialized;
+    /**
+     * Creates a new ServerAnalytics instance for server-side event tracking.
+     *
+     * The server analytics instance is designed for Node.js environments including
+     * long-running servers, serverless functions, and edge computing environments.
+     *
+     * @param config Analytics configuration including providers and default context
+     * @param config.providers Array of analytics provider instances (e.g., PostHogServerProvider)
+     * @param config.defaultContext Optional default context to include with all events
+     *
+     * @example
+     * ```typescript
+     * import { ServerAnalytics } from '@stacksee/analytics/server';
+     * import { PostHogServerProvider } from '@stacksee/analytics/providers/posthog';
+     *
+     * const analytics = new ServerAnalytics({
+     *   providers: [
+     *     new PostHogServerProvider({
+     *       apiKey: process.env.POSTHOG_API_KEY,
+     *       host: process.env.POSTHOG_HOST
+     *     })
+     *   ],
+     *   defaultContext: {
+     *     app: { version: '1.0.0', environment: 'production' }
+     *   }
+     * });
+     *
+     * analytics.initialize();
+     * ```
+     */
     constructor(config: AnalyticsConfig);
+    /**
+     * Initializes all analytics providers.
+     *
+     * This method must be called before tracking events. It initializes all configured
+     * providers synchronously. Unlike the browser version, server initialization is
+     * typically synchronous as providers don't need to load external scripts.
+     *
+     * The method is safe to call multiple times and will not re-initialize if already done.
+     *
+     * @example
+     * ```typescript
+     * const analytics = new ServerAnalytics({ providers: [] });
+     *
+     * // Initialize before tracking events
+     * analytics.initialize();
+     *
+     * // Now ready to track events
+     * await analytics.track('api_request', { endpoint: '/users' });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // In a serverless function
+     * export async function handler(req, res) {
+     *   const analytics = new ServerAnalytics({ providers: [] });
+     *   analytics.initialize(); // Quick synchronous initialization
+     *
+     *   await analytics.track('function_invoked', {
+     *     path: req.path,
+     *     method: req.method
+     *   });
+     *
+     *   await analytics.shutdown(); // Important for serverless
+     * }
+     * ```
+     */
     initialize(): void;
+    /**
+     * Identifies a user with optional traits.
+     *
+     * Associates subsequent events with the specified user ID and optionally
+     * sets user properties. This method is typically called when processing
+     * authentication or when you have user context available on the server.
+     *
+     * @param userId Unique identifier for the user (e.g., database ID, email)
+     * @param traits Optional user properties and characteristics
+     *
+     * @example
+     * ```typescript
+     * // Basic user identification
+     * analytics.identify('user-123');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Identify with user traits from database
+     * analytics.identify('user-123', {
+     *   email: 'john@example.com',
+     *   name: 'John Doe',
+     *   plan: 'enterprise',
+     *   company: 'Acme Corp',
+     *   createdAt: '2024-01-15T10:00:00Z',
+     *   lastSeenAt: new Date().toISOString()
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // In an API authentication middleware
+     * async function authMiddleware(req, res, next) {
+     *   const user = await getUserFromToken(req.headers.authorization);
+     *
+     *   analytics.identify(user.id, {
+     *     email: user.email,
+     *     role: user.role,
+     *     organization: user.organization
+     *   });
+     *
+     *   req.user = user;
+     *   next();
+     * }
+     * ```
+     */
     identify(userId: string, traits?: Record<string, unknown>): void;
+    /**
+     * Tracks a custom event with properties and optional context.
+     *
+     * This is the main method for tracking business events on the server side.
+     * The method sends the event to all configured providers and waits for completion.
+     * Failed providers don't prevent others from succeeding.
+     *
+     * Server-side tracking typically includes additional context like IP addresses,
+     * user agents, and server-specific metadata that isn't available on the client.
+     *
+     * @param eventName Name of the event to track (must match your event definitions)
+     * @param properties Event-specific properties and data
+     * @param options Optional configuration including user ID, session ID, and context
+     * @param options.userId User ID to associate with this event
+     * @param options.sessionId Session ID to associate with this event
+     * @param options.context Additional context for this event
+     * @returns Promise that resolves when tracking is complete for all providers
+     *
+     * @example
+     * ```typescript
+     * // Basic event tracking
+     * await analytics.track('api_request', {
+     *   endpoint: '/api/users',
+     *   method: 'GET',
+     *   responseTime: 150,
+     *   statusCode: 200
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Track with user context
+     * await analytics.track('purchase_completed', {
+     *   orderId: 'order-123',
+     *   amount: 99.99,
+     *   currency: 'USD',
+     *   itemCount: 3
+     * }, {
+     *   userId: 'user-456',
+     *   sessionId: 'session-789',
+     *   context: {
+     *     page: { path: '/checkout/complete' },
+     *     device: { userAgent: req.headers['user-agent'] },
+     *     ip: req.ip
+     *   }
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // In an Express.js route handler
+     * app.post('/api/users', async (req, res) => {
+     *   const user = await createUser(req.body);
+     *
+     *   // Track user creation with server context
+     *   await analytics.track('user_created', {
+     *     userId: user.id,
+     *     email: user.email,
+     *     plan: user.plan
+     *   }, {
+     *     userId: user.id,
+     *     context: {
+     *       page: { path: req.path },
+     *       device: { userAgent: req.headers['user-agent'] },
+     *       ip: req.ip,
+     *       server: { version: process.env.APP_VERSION }
+     *     }
+     *   });
+     *
+     *   res.json(user);
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Error handling in tracking
+     * try {
+     *   await analytics.track('payment_processed', {
+     *     amount: 100,
+     *     currency: 'USD'
+     *   });
+     * } catch (error) {
+     *   // This only catches initialization errors
+     *   // Individual provider failures are logged but don't throw
+     *   console.error('Failed to track event:', error);
+     * }
+     * ```
+     */
     track<TEventName extends keyof TEventMap & string>(eventName: TEventName, properties: TEventMap[TEventName], options?: {
         userId?: string;
         sessionId?: string;
         context?: EventContext;
     }): Promise<void>;
+    /**
+     * Tracks a page view event from the server side.
+     *
+     * Server-side page view tracking is useful for server-rendered applications,
+     * SSR frameworks, or when you want to ensure page views are tracked even
+     * if client-side JavaScript fails.
+     *
+     * @param properties Optional properties to include with the page view
+     * @param options Optional configuration including context
+     * @param options.context Additional context for this page view
+     *
+     * @example
+     * ```typescript
+     * // Basic server-side page view
+     * analytics.pageView();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Page view with server context
+     * analytics.pageView({
+     *   loadTime: 250,
+     *   template: 'product-detail',
+     *   ssr: true
+     * }, {
+     *   context: {
+     *     page: {
+     *       path: '/products/widget-123',
+     *       title: 'Amazing Widget - Product Details'
+     *     },
+     *     device: {
+     *       userAgent: req.headers['user-agent']
+     *     },
+     *     server: {
+     *       renderTime: 45,
+     *       cacheHit: false
+     *     }
+     *   }
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // In a Next.js API route or middleware
+     * export async function middleware(req) {
+     *   if (req.nextUrl.pathname.startsWith('/product/')) {
+     *     analytics.pageView({
+     *       category: 'product',
+     *       productId: req.nextUrl.pathname.split('/').pop()
+     *     }, {
+     *       context: {
+     *         page: { path: req.nextUrl.pathname },
+     *         device: { userAgent: req.headers.get('user-agent') },
+     *         referrer: req.headers.get('referer')
+     *       }
+     *     });
+     *   }
+     * }
+     * ```
+     */
     pageView(properties?: Record<string, unknown>, options?: {
         context?: EventContext;
     }): void;
+    /**
+     * Tracks when a user leaves a page from the server side.
+     *
+     * Server-side page leave tracking is less common than client-side but can be
+     * useful in certain scenarios like tracking session timeouts, or when combined
+     * with server-side session management.
+     *
+     * Note: Not all analytics providers support page leave events. The method
+     * will only call providers that implement the pageLeave method.
+     *
+     * @param properties Optional properties to include with the page leave event
+     * @param options Optional configuration including context
+     * @param options.context Additional context for this page leave
+     *
+     * @example
+     * ```typescript
+     * // Basic page leave tracking
+     * analytics.pageLeave();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Page leave with session context
+     * analytics.pageLeave({
+     *   sessionDuration: 45000, // 45 seconds
+     *   pagesViewed: 3,
+     *   exitReason: 'session_timeout'
+     * }, {
+     *   context: {
+     *     session: {
+     *       id: 'session-123',
+     *       startTime: sessionStartTime,
+     *       endTime: Date.now()
+     *     },
+     *     server: {
+     *       reason: 'inactivity_timeout'
+     *     }
+     *   }
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // In a session cleanup job
+     * async function cleanupExpiredSessions() {
+     *   const expiredSessions = await getExpiredSessions();
+     *
+     *   for (const session of expiredSessions) {
+     *     analytics.pageLeave({
+     *       sessionId: session.id,
+     *       duration: session.duration,
+     *       reason: 'expired'
+     *     });
+     *
+     *     await removeSession(session.id);
+     *   }
+     * }
+     * ```
+     */
     pageLeave(properties?: Record<string, unknown>, options?: {
         context?: EventContext;
     }): void;
+    /**
+     * Shuts down all analytics providers and flushes pending events.
+     *
+     * This method is crucial for server environments, especially serverless functions,
+     * as it ensures all events are sent before the process terminates. Some providers
+     * batch events and need an explicit flush to send them.
+     *
+     * Always call this method before your server shuts down or before a serverless
+     * function completes execution.
+     *
+     * @returns Promise that resolves when all providers have been shut down
+     *
+     * @example
+     * ```typescript
+     * // Basic shutdown
+     * await analytics.shutdown();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // In a serverless function
+     * export async function handler(event, context) {
+     *   const analytics = new ServerAnalytics({ providers: [] });
+     *   analytics.initialize();
+     *
+     *   try {
+     *     // Process the event
+     *     await processEvent(event);
+     *
+     *     // Track completion
+     *     await analytics.track('function_completed', {
+     *       duration: Date.now() - startTime,
+     *       success: true
+     *     });
+     *   } catch (error) {
+     *     await analytics.track('function_failed', {
+     *       error: error.message,
+     *       duration: Date.now() - startTime
+     *     });
+     *   } finally {
+     *     // Always shutdown to flush events
+     *     await analytics.shutdown();
+     *   }
+     *
+     *   return { statusCode: 200 };
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // In an Express.js server
+     * const server = app.listen(3000);
+     *
+     * // Graceful shutdown
+     * process.on('SIGTERM', async () => {
+     *   console.log('Shutting down gracefully...');
+     *
+     *   server.close(async () => {
+     *     // Flush analytics events before exit
+     *     await analytics.shutdown();
+     *     process.exit(0);
+     *   });
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // With Vercel's waitUntil
+     * import { waitUntil } from '@vercel/functions';
+     *
+     * export default async function handler(req, res) {
+     *   // Process request
+     *   const result = await processRequest(req);
+     *
+     *   // Track in background without blocking response
+     *   waitUntil(
+     *     analytics.track('api_request', { endpoint: req.url })
+     *       .then(() => analytics.shutdown())
+     *   );
+     *
+     *   return res.json(result);
+     * }
+     * ```
+     */
     shutdown(): Promise<void>;
     private getCategoryFromEventName;
 }

package/dist/src/client/index.d.ts

@@ -1,7 +1,7 @@
-export { createClientAnalytics, createAnalytics, getAnalytics, track, identify, pageView, pageLeave, reset, type ClientAnalyticsConfig, } from '../client.js';
-export { BrowserAnalytics } from '../adapters/client/browser-analytics.js';
-export { PostHogClientProvider } from '../providers/posthog/client.js';
+export { createClientAnalytics, createAnalytics, getAnalytics, track, identify, pageView, pageLeave, reset, type ClientAnalyticsConfig, } from '../../../src/client.js';
+export { BrowserAnalytics } from '../../../src/adapters/client/browser-analytics.js';
+export { PostHogClientProvider } from '../../../src/providers/posthog/client.js';
 export type { PostHogConfig } from 'posthog-js';
-export { BaseAnalyticsProvider } from '../providers/base.provider.js';
-export type { EventCategory, BaseEvent, EventContext, AnalyticsProvider, AnalyticsConfig, } from '../core/events/types.js';
-export type { CreateEventDefinition, ExtractEventNames, ExtractEventPropertiesFromCollection, EventCollection, AnyEventName, AnyEventProperties, } from '../core/events/index.js';
+export { BaseAnalyticsProvider } from '../../../src/providers/base.provider.js';
+export type { EventCategory, BaseEvent, EventContext, AnalyticsProvider, AnalyticsConfig, } from '../../../src/core/events/types.js';
+export type { CreateEventDefinition, ExtractEventNames, ExtractEventPropertiesFromCollection, EventCollection, AnyEventName, AnyEventProperties, } from '../../../src/core/events/index.js';

package/dist/src/client.d.ts

@@ -1,6 +1,6 @@
-import { BrowserAnalytics } from './adapters/client/browser-analytics.js';
-import { AnalyticsProvider } from './core/events/types.js';
-import { EventMapFromCollection } from './core/events/index.js';
+import { BrowserAnalytics } from '../../src/adapters/client/browser-analytics.js';
+import { AnalyticsProvider } from '../../src/core/events/types.js';
+import { EventMapFromCollection } from '../../src/core/events/index.js';
 type DefaultEventMap = Record<string, Record<string, unknown>>;
 export interface ClientAnalyticsConfig {
     providers?: AnalyticsProvider[];

package/dist/src/index.d.ts

@@ -1,6 +1,2 @@
-export type { EventCategory, BaseEvent, EventContext, AnalyticsProvider, AnalyticsConfig, } from './core/events/types.js';
-export type { CreateEventDefinition, ExtractEventNames, ExtractEventPropertiesFromCollection, EventCollection, AnyEventName, AnyEventProperties, EventMapFromCollection, } from './core/events/index.js';
-export { createAnalytics as createClientAnalytics, getAnalytics, track as trackClient, identify as identifyClient, pageView as pageViewClient, pageLeave as pageLeaveClient, reset as resetClient, type ClientAnalyticsConfig, } from './client.js';
-export { createServerAnalytics, ServerAnalytics, type ServerAnalyticsConfig, } from './server.js';
-export { BaseAnalyticsProvider, PostHogClientProvider, PostHogServerProvider, type PostHogConfig, type PostHogOptions, } from './providers/index.js';
-export { BrowserAnalytics } from './adapters/client/browser-analytics.js';
+export type { EventCategory, BaseEvent, EventContext, AnalyticsProvider, AnalyticsConfig, } from '../../src/core/events/types.js';
+export type { CreateEventDefinition, ExtractEventNames, ExtractEventPropertiesFromCollection, EventCollection, AnyEventName, AnyEventProperties, EventMapFromCollection, } from '../../src/core/events/index.js';

package/dist/src/providers/base.provider.d.ts

@@ -1,4 +1,4 @@
-import { AnalyticsProvider, BaseEvent, EventContext } from '../core/events/types.js';
+import { AnalyticsProvider, BaseEvent, EventContext } from '../../../src/core/events/types.js';
 export declare abstract class BaseAnalyticsProvider implements AnalyticsProvider {
     abstract name: string;
     protected debug: boolean;

package/dist/src/providers/client.d.ts

@@ -0,0 +1,3 @@
+export { BaseAnalyticsProvider } from './base.provider.js';
+export { PostHogClientProvider } from './posthog/client.js';
+export type { PostHogConfig } from 'posthog-js';

package/dist/src/providers/posthog/client.d.ts

@@ -1,5 +1,5 @@
-import { BaseEvent, EventContext } from '../../core/events/types.js';
-import { BaseAnalyticsProvider } from '../base.provider.js';
+import { BaseEvent, EventContext } from '../../../../src/core/events/types.js';
+import { BaseAnalyticsProvider } from '../../../../src/providers/base.provider.js';
 import { PostHogConfig } from 'posthog-js';
 export declare class PostHogClientProvider extends BaseAnalyticsProvider {
     name: string;

package/dist/src/providers/posthog/server.d.ts

@@ -1,5 +1,5 @@
-import { BaseEvent, EventContext } from '../../core/events/types.js';
-import { BaseAnalyticsProvider } from '../base.provider.js';
+import { BaseEvent, EventContext } from '../../../../src/core/events/types.js';
+import { BaseAnalyticsProvider } from '../../../../src/providers/base.provider.js';
 import { PostHogOptions } from 'posthog-node';
 export declare class PostHogServerProvider extends BaseAnalyticsProvider {
     name: string;

package/dist/src/providers/{index.d.ts → server.d.ts}

@@ -1,5 +1,3 @@
 export { BaseAnalyticsProvider } from './base.provider.js';
-export { PostHogClientProvider } from './posthog/client.js';
 export { PostHogServerProvider } from './posthog/server.js';
-export type { PostHogConfig } from 'posthog-js';
 export type { PostHogOptions } from 'posthog-node';

package/dist/src/server/index.d.ts

@@ -1,6 +1,6 @@
-export { createServerAnalytics, ServerAnalytics, type ServerAnalyticsConfig, } from '../server.js';
-export { PostHogServerProvider } from '../providers/posthog/server.js';
+export { createServerAnalytics, ServerAnalytics, type ServerAnalyticsConfig, } from '../../../src/server.js';
+export { PostHogServerProvider } from '../../../src/providers/posthog/server.js';
 export type { PostHogOptions } from 'posthog-node';
-export { BaseAnalyticsProvider } from '../providers/base.provider.js';
-export type { EventCategory, BaseEvent, EventContext, AnalyticsProvider, AnalyticsConfig, } from '../core/events/types.js';
-export type { CreateEventDefinition, ExtractEventNames, ExtractEventPropertiesFromCollection, EventCollection, AnyEventName, AnyEventProperties, } from '../core/events/index.js';
+export { BaseAnalyticsProvider } from '../../../src/providers/base.provider.js';
+export type { EventCategory, BaseEvent, EventContext, AnalyticsProvider, AnalyticsConfig, } from '../../../src/core/events/types.js';
+export type { CreateEventDefinition, ExtractEventNames, ExtractEventPropertiesFromCollection, EventCollection, AnyEventName, AnyEventProperties, } from '../../../src/core/events/index.js';

package/dist/src/server.d.ts

@@ -1,6 +1,6 @@
-import { ServerAnalytics } from './adapters/server/server-analytics.js';
-import { AnalyticsProvider } from './core/events/types.js';
-import { EventMapFromCollection } from './core/events/index.js';
+import { ServerAnalytics } from '../../src/adapters/server/server-analytics.js';
+import { AnalyticsProvider } from '../../src/core/events/types.js';
+import { EventMapFromCollection } from '../../src/core/events/index.js';
 export interface ServerAnalyticsConfig {
     providers?: AnalyticsProvider[];
     debug?: boolean;

package/dist/test/mock-provider.d.ts

@@ -1,5 +1,5 @@
-import { BaseAnalyticsProvider } from '../src/providers/base.provider';
-import { BaseEvent, EventContext } from '../src/core/events/types';
+import { BaseAnalyticsProvider } from '../../src/providers/base.provider';
+import { BaseEvent, EventContext } from '../../src/core/events/types';
 export declare class MockAnalyticsProvider extends BaseAnalyticsProvider {
     name: string;
     private initialized;

package/dist/test/providers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stacksee/analytics",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "A highly typed, provider-agnostic analytics library for TypeScript applications",
   "type": "module",
   "exports": {
@@ -16,9 +16,13 @@
       "types": "./dist/server.d.ts",
       "import": "./dist/server.js"
     },
-    "./providers": {
-      "types": "./dist/providers.d.ts",
-      "import": "./dist/providers.js"
+    "./providers/client": {
+      "types": "./dist/providers/client.d.ts",
+      "import": "./dist/providers/client.js"
+    },
+    "./providers/server": {
+      "types": "./dist/providers/server.d.ts",
+      "import": "./dist/providers/server.js"
     }
   },
   "main": "./dist/index.js",

package/readme.md

@@ -97,7 +97,7 @@ Tip: If you have a lot of events, you can also divide your events into multiple
 
 ```typescript
 import { createClientAnalytics } from '@stacksee/analytics/client';
-import { PostHogClientProvider } from '@stacksee/analytics/providers/posthog';
+import { PostHogClientProvider } from '@stacksee/analytics/providers/client';
 import type { AppEvents } from './events';
 
 // Initialize analytics with providers as plugins
@@ -138,7 +138,7 @@ analytics.identify('user-123', {
 
 ```typescript
 import { createServerAnalytics } from '@stacksee/analytics/server';
-import { PostHogServerProvider } from '@stacksee/analytics/providers/posthog';
+import { PostHogServerProvider } from '@stacksee/analytics/providers/server';
 import type { AppEvents } from './events';
 
 // Create analytics instance with providers as plugins
@@ -268,7 +268,7 @@ Here's a complete example using Svelte 5 that demonstrates both client and serve
 ```typescript
 // src/lib/config/analytics.ts
 import { createClientAnalytics } from '@stacksee/analytics/client';
-import { PostHogClientProvider } from '@stacksee/analytics/providers/posthog';
+import { PostHogClientProvider } from '@stacksee/analytics/providers/client';
 import { PUBLIC_POSTHOG_API_KEY, PUBLIC_POSTHOG_HOST } from '$env/static/public';
 
 // Define your events for the waitlist
@@ -306,7 +306,7 @@ export const clientAnalytics = createClientAnalytics<AppEvents>({
 ```typescript
 // src/lib/server/analytics.ts
 import { createServerAnalytics } from '@stacksee/analytics/server';
-import { PostHogServerProvider } from '@stacksee/analytics/providers/posthog';
+import { PostHogServerProvider } from '@stacksee/analytics/providers/server';
 import { AppEvents } from '$lib/config/analytics'; // Import AppEvents
 import { PUBLIC_POSTHOG_API_KEY, PUBLIC_POSTHOG_HOST } from '$env/static/public';
 
@@ -564,6 +564,12 @@ const analytics = await createClientAnalytics<typeof AppEvents>({
 
 ### Client-Only and Server-Only Providers
 
+**Important**: To avoid bundling Node.js dependencies in your client code, always use the environment-specific provider imports:
+
+- **Client-side**: `@stacksee/analytics/providers/client` - Only includes browser-compatible providers
+- **Server-side**: `@stacksee/analytics/providers/server` - Only includes Node.js providers  
+- **Both**: `@stacksee/analytics/providers` - Includes all providers (may cause bundling issues in browsers)
+
 Some analytics libraries are designed to work only in specific environments. For example:
 - **Client-only**: Google Analytics (gtag.js), Hotjar, FullStory
 - **Server-only**: Some enterprise analytics APIs that require secret keys
@@ -638,7 +644,7 @@ The plugin architecture makes it easy to send events to multiple analytics servi
 
 ```typescript
 import { createClientAnalytics } from '@stacksee/analytics/client';
-import { PostHogClientProvider } from '@stacksee/analytics/providers/posthog';
+import { PostHogClientProvider } from '@stacksee/analytics/providers/client';
 // Import your custom providers
 import { GoogleAnalyticsProvider } from './providers/google-analytics';
 import { MixpanelProvider } from './providers/mixpanel';