@umituz/react-native-firebase 1.13.6 → 1.13.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.6",
-  "description": "Unified Firebase package for React Native apps - Centralized initialization and core services (Auth, Firestore, Analytics).",
+  "version": "1.13.7",
+  "description": "Unified Firebase package for React Native apps - Auth and Firestore services using Firebase JS SDK (no native modules).",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "scripts": {
@@ -14,13 +14,12 @@
   "keywords": [
     "react-native",
     "firebase",
-    "firebase-core",
+    "firebase-js-sdk",
     "auth",
     "authentication",
     "firestore",
     "database",
     "repository",
-    "analytics",
     "ddd",
     "domain-driven-design"
   ],

package/src/index.ts

@@ -4,15 +4,13 @@
  * Domain-Driven Design (DDD) Architecture
  *
  * This package provides Firebase App initialization and core services:
- * - Auth
- * - Firestore
- * - Analytics
+ * - Auth (Firebase JS SDK)
+ * - Firestore (Firebase JS SDK)
  *
  * Usage:
  *   import { initializeFirebase, getFirebaseApp } from '@umituz/react-native-firebase';
  *   import { useFirebaseAuth } from '@umituz/react-native-firebase';
  *   import { getFirestore, BaseRepository } from '@umituz/react-native-firebase';
- *   import { firebaseAnalyticsService } from '@umituz/react-native-firebase';
  */
 
 // =============================================================================
@@ -58,9 +56,3 @@ export * from './auth';
 
 export * from './firestore';
 
-// =============================================================================
-// ANALYTICS MODULE
-// =============================================================================
-
-export * from './analytics';
-

package/src/analytics/application/ports/IAnalyticsService.ts

@@ -1,92 +0,0 @@
-/**
- * Analytics Service Interface
- * 
- * Application Layer - Port
- * Defines the contract for analytics operations
- */
-
-export interface IAnalyticsService {
-    /**
-     * Initialize the analytics service
-     * @param userId Optional user ID to associate with analytics
-     */
-    init(userId?: string): Promise<void>;
-
-    /**
-     * Set the current user ID
-     * @param userId The unique user identifier
-     */
-    setUserId(userId: string): Promise<void>;
-
-    /**
-     * Log a custom event
-     * @param eventName Name of the event
-     * @param params Optional key-value pairs of parameters
-     */
-    logEvent(
-        eventName: string,
-        params?: Record<string, string | number | boolean | null>,
-    ): Promise<void>;
-
-    /**
-     * Set a user property
-     * @param key Property key
-     * @param value Property value
-     */
-    setUserProperty(key: string, value: string): Promise<void>;
-
-    /**
-     * Set multiple user properties at once
-     * @param properties Key-value pairs of user properties
-     */
-    setUserProperties(properties: Record<string, string>): Promise<void>;
-
-    /**
-     * Clear all user data and reset initialization state
-     */
-    clearUserData(): Promise<void>;
-
-    /**
-     * Get the current user ID if set
-     */
-    getCurrentUserId(): string | null;
-
-    /**
-     * Log a screen view event
-     */
-    logScreenView(params: { screen_name: string; screen_class?: string }): Promise<void>;
-
-    /**
-     * Log time spent on a screen
-     */
-    logScreenTime(params: {
-        screen_name: string;
-        screen_class?: string;
-        time_spent_seconds: number;
-    }): Promise<void>;
-
-    /**
-     * Log a navigation event between screens
-     */
-    logNavigation(params: {
-        from_screen: string;
-        to_screen: string;
-        screen_class?: string;
-    }): Promise<void>;
-
-    /**
-     * Log a button click event
-     */
-    logButtonClick(params: {
-        button_id: string;
-        button_name?: string;
-        screen_name: string;
-        screen_class?: string;
-    }): Promise<void>;
-
-    /**
-     * Enable or disable analytics collection
-     * @param enabled Whether collection should be enabled
-     */
-    setAnalyticsCollectionEnabled(enabled: boolean): Promise<void>;
-}

package/src/analytics/index.ts

@@ -1,20 +0,0 @@
-/**
- * Firebase Analytics Module
- */
-
-export { firebaseAnalyticsService } from './infrastructure/services/FirebaseAnalyticsService';
-export type { IAnalyticsService } from './infrastructure/services/FirebaseAnalyticsService';
-export { analyticsInitializerService } from './infrastructure/services/analytics-initializer.service';
-export type { AnalyticsInstance } from './infrastructure/services/analytics-initializer.service';
-export { analyticsEventService } from './infrastructure/services/analytics-event.service';
-export { analyticsUserService } from './infrastructure/services/analytics-user.service';
-export { performanceTracker } from './infrastructure/services/PerformanceTracker';
-
-// Hooks
-export { useScreenView } from './presentation/hooks/useScreenView';
-export { useScreenTime } from './presentation/hooks/useScreenTime';
-export { useNavigationTracking } from './presentation/hooks/useNavigationTracking';
-export { useNavigationAnalytics } from './presentation/hooks/useNavigationAnalytics';
-
-// Utility Functions
-export { trackButtonClick, trackCRUDOperation } from './presentation/utils/analyticsUtils';

package/src/analytics/infrastructure/adapters/index.ts

@@ -1,10 +0,0 @@
-/**
- * Analytics Adapters
- * Platform-specific implementations
- */
-
-export { webAnalyticsAdapter } from './web-analytics.adapter';
-export type { WebAnalyticsAdapter } from './web-analytics.adapter';
-export { nativeAnalyticsAdapter } from './native-analytics.adapter';
-export type { NativeAnalyticsAdapter } from './native-analytics.adapter';
-

package/src/analytics/infrastructure/adapters/native-analytics.adapter.ts

@@ -1,63 +0,0 @@
-/**
- * Native Analytics Adapter
- * Single Responsibility: Handle Firebase Analytics native implementation
- * Uses React Native Firebase v23+ modular API
- *
- * NOTE: This adapter uses optional import to support Expo Go.
- * Native modules are only available in development builds or standalone apps.
- */
-
-// Optional import - will be null in Expo Go
-let nativeAnalytics: any = null;
-try {
-  // eslint-disable-next-line @typescript-eslint/no-var-requires
-  nativeAnalytics = require('@react-native-firebase/analytics');
-} catch {
-  // Native module not available (e.g., Expo Go)
-  // eslint-disable-next-line no-console
-  if (__DEV__) console.warn('⚠️ Firebase Analytics: Native module not available');
-}
-
-export interface NativeAnalyticsAdapter {
-  getAnalytics(): any;
-  logEvent(analytics: any, eventName: string, params?: Record<string, any>): Promise<void>;
-  setUserId(analytics: any, userId: string): Promise<void>;
-  setUserProperties(analytics: any, properties: Record<string, string>): Promise<void>;
-  resetAnalyticsData(analytics: any): Promise<void>;
-  setAnalyticsCollectionEnabled(analytics: any, enabled: boolean): Promise<void>;
-}
-
-declare const __DEV__: boolean;
-
-export const nativeAnalyticsAdapter: NativeAnalyticsAdapter | null = nativeAnalytics
-  ? {
-      getAnalytics(): any {
-        return nativeAnalytics.getAnalytics();
-      },
-      async logEvent(
-        analytics: any,
-        eventName: string,
-        params?: Record<string, any>,
-      ): Promise<void> {
-        await nativeAnalytics.logEvent(analytics, eventName, params);
-      },
-      async setUserId(analytics: any, userId: string): Promise<void> {
-        await nativeAnalytics.setUserId(analytics, userId);
-      },
-      async setUserProperties(
-        analytics: any,
-        properties: Record<string, string>,
-      ): Promise<void> {
-        await nativeAnalytics.setUserProperties(analytics, properties);
-      },
-      async resetAnalyticsData(analytics: any): Promise<void> {
-        await nativeAnalytics.resetAnalyticsData(analytics);
-      },
-      async setAnalyticsCollectionEnabled(
-        analytics: any,
-        enabled: boolean,
-      ): Promise<void> {
-        await nativeAnalytics.setAnalyticsCollectionEnabled(analytics, enabled);
-      },
-    }
-  : null;

package/src/analytics/infrastructure/adapters/web-analytics.adapter.ts

@@ -1,63 +0,0 @@
-/**
- * Web Analytics Adapter
- * Single Responsibility: Handle Firebase Analytics web implementation
- */
-
-export interface WebAnalyticsAdapter {
-  isSupported(): Promise<boolean>;
-  getAnalytics(app: any): any;
-  logEvent(analytics: any, eventName: string, params?: Record<string, any>): Promise<void>;
-  setUserId(analytics: any, userId: string): Promise<void>;
-  setUserProperties(analytics: any, properties: Record<string, string>): Promise<void>;
-}
-
-let webAnalyticsModule: any = null;
-
-try {
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const {
-    getAnalytics,
-    logEvent,
-    setUserId,
-    setUserProperties,
-    isSupported,
-  } = require('firebase/analytics');
-  webAnalyticsModule = {
-    getAnalytics,
-    logEvent,
-    setUserId,
-    setUserProperties,
-    isSupported,
-  };
-} catch {
-  // firebase/analytics not available
-}
-
-export const webAnalyticsAdapter: WebAnalyticsAdapter | null = webAnalyticsModule
-  ? {
-      async isSupported(): Promise<boolean> {
-        if (!webAnalyticsModule.isSupported) return true;
-        return webAnalyticsModule.isSupported();
-      },
-      getAnalytics(app: any): any {
-        return webAnalyticsModule.getAnalytics(app);
-      },
-      async logEvent(
-        analytics: any,
-        eventName: string,
-        params?: Record<string, any>,
-      ): Promise<void> {
-        await webAnalyticsModule.logEvent(analytics, eventName, params);
-      },
-      async setUserId(analytics: any, userId: string): Promise<void> {
-        await webAnalyticsModule.setUserId(analytics, userId);
-      },
-      async setUserProperties(
-        analytics: any,
-        properties: Record<string, string>,
-      ): Promise<void> {
-        await webAnalyticsModule.setUserProperties(analytics, properties);
-      },
-    }
-  : null;
-

package/src/analytics/infrastructure/services/FirebaseAnalyticsService.ts

@@ -1,165 +0,0 @@
-/**
- * Firebase Analytics Service
- * Single Responsibility: Orchestrate analytics operations
- * Delegates to specialized services for initialization, events, and user management
- */
-
-import { analyticsInitializerService } from './analytics-initializer.service';
-import { analyticsEventService } from './analytics-event.service';
-import { analyticsUserService } from './analytics-user.service';
-import type { AnalyticsInstance } from './analytics-initializer.service';
-import type { IAnalyticsService } from '../../application/ports/IAnalyticsService';
-import { nativeAnalyticsAdapter } from '../adapters/native-analytics.adapter';
-
-export type { IAnalyticsService };
-
-class FirebaseAnalyticsService implements IAnalyticsService {
-  private isInitialized = false;
-  private userId: string | null = null;
-  private userProperties: Record<string, string> = {};
-  private analyticsInstance: AnalyticsInstance | null = null;
-
-  async init(userId?: string): Promise<void> {
-    if (this.isInitialized) {
-      if (userId && userId !== this.userId) {
-        await this.setUserId(userId);
-      }
-      return;
-    }
-
-    try {
-      this.analyticsInstance = await analyticsInitializerService.initialize();
-
-      if (this.analyticsInstance) {
-        if (userId) {
-          this.userId = userId;
-          await analyticsUserService.setUserId(this.analyticsInstance, userId);
-        }
-
-        // Explicitly enable analytics collection to ensure it's active
-        await this.setAnalyticsCollectionEnabled(true);
-      }
-    } catch (_error) {
-      // Analytics is non-critical, fail silently
-    } finally {
-      this.isInitialized = true;
-    }
-  }
-
-  async setAnalyticsCollectionEnabled(enabled: boolean): Promise<void> {
-    if (!this.analyticsInstance) {
-      return;
-    }
-
-    try {
-      if (this.analyticsInstance.platform === 'native' && nativeAnalyticsAdapter) {
-        await nativeAnalyticsAdapter.setAnalyticsCollectionEnabled(
-          this.analyticsInstance.instance,
-          enabled,
-        );
-      }
-    } catch (_error) {
-      // Fail silently
-    }
-  }
-
-  async setUserId(userId: string): Promise<void> {
-    if (!this.isInitialized || !this.analyticsInstance) {
-      // Not initialized yet, will be set during init
-      return;
-    }
-
-    if (this.userId === userId) {
-      // Already set to this user ID
-      return;
-    }
-
-    try {
-      this.userId = userId;
-      await analyticsUserService.setUserId(this.analyticsInstance, userId);
-    } catch (_error) {
-      // Analytics is non-critical, fail silently
-    }
-  }
-
-  async logEvent(
-    eventName: string,
-    params?: Record<string, string | number | boolean | null>,
-  ): Promise<void> {
-    if (!this.isInitialized) {
-      return;
-    }
-    await analyticsEventService.logEvent(this.analyticsInstance, eventName, params);
-  }
-
-  async setUserProperty(key: string, value: string): Promise<void> {
-    this.userProperties[key] = value;
-    await analyticsUserService.setUserProperty(this.analyticsInstance, key, value);
-  }
-
-  async setUserProperties(properties: Record<string, string>): Promise<void> {
-    await analyticsUserService.setUserProperties(this.analyticsInstance, properties);
-    Object.assign(this.userProperties, properties);
-  }
-
-  async clearUserData(): Promise<void> {
-    await analyticsUserService.clearUserData(this.analyticsInstance);
-    this.userId = null;
-    this.userProperties = {};
-    this.isInitialized = false;
-  }
-
-  getCurrentUserId(): string | null {
-    return this.userId;
-  }
-
-  async logScreenView(params: {
-    screen_name: string;
-    screen_class?: string;
-  }): Promise<void> {
-    await this.logEvent('screen_view', {
-      screen_name: params.screen_name,
-      screen_class: params.screen_class || params.screen_name,
-    });
-  }
-
-  async logScreenTime(params: {
-    screen_name: string;
-    screen_class?: string;
-    time_spent_seconds: number;
-  }): Promise<void> {
-    await this.logEvent('screen_time', {
-      screen_name: params.screen_name,
-      screen_class: params.screen_class || params.screen_name,
-      time_spent_seconds: params.time_spent_seconds,
-    });
-  }
-
-  async logNavigation(params: {
-    from_screen: string;
-    to_screen: string;
-    screen_class?: string;
-  }): Promise<void> {
-    await this.logEvent('navigation', {
-      from_screen: params.from_screen,
-      to_screen: params.to_screen,
-      screen_class: params.screen_class || params.to_screen,
-    });
-  }
-
-  async logButtonClick(params: {
-    button_id: string;
-    button_name?: string;
-    screen_name: string;
-    screen_class?: string;
-  }): Promise<void> {
-    await this.logEvent('button_click', {
-      button_id: params.button_id,
-      button_name: params.button_name || params.button_id,
-      screen_name: params.screen_name,
-      screen_class: params.screen_class || params.screen_name,
-    });
-  }
-}
-
-export const firebaseAnalyticsService = new FirebaseAnalyticsService();

package/src/analytics/infrastructure/services/PerformanceTracker.ts

@@ -1,49 +0,0 @@
-/**
- * Performance Tracker Service
- * 
- * Single Responsibility: Track performance metrics of operations
- */
-
-export class PerformanceTracker {
-    private activeTracks = new Map<string, number>();
-
-    /**
-     * Start tracking an operation
-     */
-    start(trackingId: string): void {
-        this.activeTracks.set(trackingId, Date.now());
-    }
-
-    /**
-     * End tracking and return duration
-     */
-    async end(trackingId: string, params: Record<string, any> = {}): Promise<number> {
-        const startTime = this.activeTracks.get(trackingId);
-        if (!startTime) return 0;
-
-        const duration = Date.now() - startTime;
-        this.activeTracks.delete(trackingId);
-
-        // In a full implementation, this could send to Firebase Performance
-        // For now, we just log it or handle it as a custom metric
-        if (__DEV__) {
-            console.log(`⏱️ [Performance] ${trackingId}: ${duration}ms`, params);
-        }
-
-        return duration;
-    }
-
-    /**
-     * Track a function execution
-     */
-    async track<T>(trackingId: string, fn: () => Promise<T>): Promise<T> {
-        this.start(trackingId);
-        try {
-            return await fn();
-        } finally {
-            await this.end(trackingId);
-        }
-    }
-}
-
-export const performanceTracker = new PerformanceTracker();

package/src/analytics/infrastructure/services/analytics-event.service.ts

@@ -1,72 +0,0 @@
-/**
- * Analytics Event Service
- * Single Responsibility: Handle event logging operations
- */
-
-import { webAnalyticsAdapter } from '../adapters/web-analytics.adapter';
-import { nativeAnalyticsAdapter } from '../adapters/native-analytics.adapter';
-import type { AnalyticsInstance } from './analytics-initializer.service';
-
-export class AnalyticsEventService {
-  /**
-   * Log event to analytics
-   */
-  async logEvent(
-    analyticsInstance: AnalyticsInstance | null,
-    eventName: string,
-    params?: Record<string, string | number | boolean | null>,
-  ): Promise<void> {
-    if (!analyticsInstance) {
-      /* eslint-disable-next-line no-console */
-      if (__DEV__) {
-        console.warn('⚠️ Firebase Analytics: Cannot log event - Analytics not initialized', {
-          eventName,
-          reason: 'Analytics instance is null (native module not available in Expo Go)',
-        });
-      }
-      return;
-    }
-
-    try {
-      if (analyticsInstance.platform === 'native' && nativeAnalyticsAdapter) {
-        await nativeAnalyticsAdapter.logEvent(
-          analyticsInstance.instance,
-          eventName,
-          params,
-        );
-        /* eslint-disable-next-line no-console */
-        if (__DEV__) {
-          console.log('📊 Firebase Analytics Event (native):', {
-            eventName,
-            params,
-            platform: 'iOS/Android',
-          });
-        }
-      } else if (analyticsInstance.platform === 'web' && webAnalyticsAdapter) {
-        await webAnalyticsAdapter.logEvent(
-          analyticsInstance.instance,
-          eventName,
-          params,
-        );
-        /* eslint-disable-next-line no-console */
-        if (__DEV__) {
-          console.log('📊 Firebase Analytics Event:', {
-            eventName,
-            params,
-          });
-        }
-      }
-    } catch (error) {
-      /* eslint-disable-next-line no-console */
-      if (__DEV__) {
-        console.warn('⚠️ Firebase Analytics: Failed to log event', {
-          eventName,
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-    }
-  }
-}
-
-export const analyticsEventService = new AnalyticsEventService();
-

package/src/analytics/infrastructure/services/analytics-initializer.service.ts

@@ -1,141 +0,0 @@
-/**
- * Analytics Initializer Service
- * Single Responsibility: Handle analytics initialization logic
- */
-
-import { Platform } from 'react-native';
-import { getFirebaseApp } from '../../../infrastructure/config/FirebaseClient';
-import { webAnalyticsAdapter } from '../adapters/web-analytics.adapter';
-import { nativeAnalyticsAdapter } from '../adapters/native-analytics.adapter';
-
-export interface AnalyticsInstance {
-  instance: any;
-  platform: 'web' | 'native';
-}
-
-export class AnalyticsInitializerService {
-  private static nativeWarningLogged = false;
-
-  /**
-   * Initialize analytics instance
-   * Returns null if initialization fails
-   */
-  async initialize(): Promise<AnalyticsInstance | null> {
-    // Platform-specific initialization
-    // iOS/Android: Only use native
-    // Web: Only use web
-    if (Platform.OS === 'web') {
-      if (webAnalyticsAdapter) {
-        return this.initializeWeb();
-      }
-      return null;
-    }
-
-    // iOS/Android: Try native only
-    if (nativeAnalyticsAdapter) {
-      return this.initializeNative();
-    }
-
-    // Native not available on iOS/Android - return null
-    // Only log warning once
-    if (__DEV__ && !AnalyticsInitializerService.nativeWarningLogged) {
-      AnalyticsInitializerService.nativeWarningLogged = true;
-      /* eslint-disable-next-line no-console */
-      console.warn(
-        '⚠️ Firebase Analytics: Native module not available on iOS/Android (Expo Go limitation)',
-      );
-    }
-    return null;
-  }
-
-  private async initializeNative(): Promise<AnalyticsInstance | null> {
-    try {
-      if (!nativeAnalyticsAdapter) {
-        /* eslint-disable-next-line no-console */
-        if (__DEV__) {
-          console.warn(
-            '⚠️ Firebase Analytics: Native adapter not available - ensure @react-native-firebase/app and @react-native-firebase/analytics are installed',
-          );
-        }
-        return null;
-      }
-
-      const instance = nativeAnalyticsAdapter.getAnalytics();
-      if (!instance) {
-        /* eslint-disable-next-line no-console */
-        if (__DEV__) {
-          console.warn('⚠️ Firebase Analytics: getAnalytics() returned null');
-        }
-        return null;
-      }
-
-      /* eslint-disable-next-line no-console */
-      if (__DEV__) {
-        console.log('✅ Firebase Analytics initialized (native)');
-      }
-      return { instance, platform: 'native' };
-    } catch (error: any) {
-      /* eslint-disable-next-line no-console */
-      if (__DEV__) {
-        const errorMessage = error?.message || String(error);
-        if (errorMessage.includes('No Firebase App') || errorMessage.includes('has been created')) {
-          console.warn(
-            '⚠️ Firebase Analytics: Firebase App not initialized. Please add GoogleService-Info.plist to ios/ directory and rebuild the app.',
-          );
-        } else {
-          console.warn('⚠️ Firebase Analytics: Native initialization failed', error);
-        }
-      }
-      return null;
-    }
-  }
-
-  private async initializeWeb(): Promise<AnalyticsInstance | null> {
-    try {
-      // Check if Analytics is supported
-      if (webAnalyticsAdapter) {
-        const isSupported = await webAnalyticsAdapter.isSupported();
-        if (!isSupported) {
-          /* eslint-disable-next-line no-console */
-          if (__DEV__) {
-            console.warn('⚠️ Firebase Analytics: Not supported in this environment (web)');
-          }
-          return null;
-        }
-      }
-
-      const app = getFirebaseApp();
-      if (!app) {
-        /* eslint-disable-next-line no-console */
-        if (__DEV__) {
-          console.warn('⚠️ Firebase Analytics: Firebase app not available');
-        }
-        return null;
-      }
-
-      try {
-        const instance = webAnalyticsAdapter!.getAnalytics(app);
-        /* eslint-disable-next-line no-console */
-        if (__DEV__) {
-          console.log('✅ Firebase Analytics initialized (web)');
-        }
-        return { instance, platform: 'web' };
-      } catch (analyticsError) {
-        /* eslint-disable-next-line no-console */
-        if (__DEV__) {
-          console.warn('⚠️ Firebase Analytics: getAnalytics failed', analyticsError);
-        }
-        return null;
-      }
-    } catch (error) {
-      /* eslint-disable-next-line no-console */
-      if (__DEV__) {
-        console.warn('⚠️ Firebase Analytics: Web initialization failed', error);
-      }
-      return null;
-    }
-  }
-}
-
-export const analyticsInitializerService = new AnalyticsInitializerService();
-

package/src/analytics/infrastructure/services/analytics-user.service.ts

@@ -1,98 +0,0 @@
-/**
- * Analytics User Service
- * Single Responsibility: Handle user-related analytics operations
- */
-
-import { webAnalyticsAdapter } from '../adapters/web-analytics.adapter';
-import { nativeAnalyticsAdapter } from '../adapters/native-analytics.adapter';
-import type { AnalyticsInstance } from './analytics-initializer.service';
-
-export class AnalyticsUserService {
-  /**
-   * Set user ID
-   */
-  async setUserId(
-    analyticsInstance: AnalyticsInstance | null,
-    userId: string,
-  ): Promise<void> {
-    if (!analyticsInstance) {
-      return;
-    }
-
-    try {
-      if (analyticsInstance.platform === 'native' && nativeAnalyticsAdapter) {
-        await nativeAnalyticsAdapter.setUserId(analyticsInstance.instance, userId);
-      } else if (analyticsInstance.platform === 'web' && webAnalyticsAdapter) {
-        await webAnalyticsAdapter.setUserId(analyticsInstance.instance, userId);
-      }
-    } catch (_error) {
-      // Silent fail
-    }
-  }
-
-  /**
-   * Set user property
-   */
-  async setUserProperty(
-    analyticsInstance: AnalyticsInstance | null,
-    key: string,
-    value: string,
-  ): Promise<void> {
-    if (!analyticsInstance) {
-      return;
-    }
-
-    try {
-      if (analyticsInstance.platform === 'native' && nativeAnalyticsAdapter) {
-        await nativeAnalyticsAdapter.setUserProperties(analyticsInstance.instance, {
-          [key]: value,
-        });
-      } else if (analyticsInstance.platform === 'web' && webAnalyticsAdapter) {
-        await webAnalyticsAdapter.setUserProperties(analyticsInstance.instance, {
-          [key]: value,
-        });
-      }
-    } catch (_error) {
-      // Silent fail
-    }
-  }
-
-  /**
-   * Set multiple user properties
-   */
-  async setUserProperties(
-    analyticsInstance: AnalyticsInstance | null,
-    properties: Record<string, string>,
-  ): Promise<void> {
-    for (const [key, value] of Object.entries(properties)) {
-      await this.setUserProperty(analyticsInstance, key, value);
-    }
-  }
-
-  /**
-   * Clear user data
-   */
-  async clearUserData(analyticsInstance: AnalyticsInstance | null): Promise<void> {
-    if (!analyticsInstance) {
-      return;
-    }
-
-    try {
-      if (analyticsInstance.platform === 'native' && nativeAnalyticsAdapter) {
-        await nativeAnalyticsAdapter.setUserId(analyticsInstance.instance, '');
-        await nativeAnalyticsAdapter.setUserProperties(analyticsInstance.instance, {});
-        if (nativeAnalyticsAdapter.resetAnalyticsData) {
-          await nativeAnalyticsAdapter.resetAnalyticsData(analyticsInstance.instance);
-        }
-      } else if (analyticsInstance.platform === 'web' && webAnalyticsAdapter) {
-        await webAnalyticsAdapter.setUserId(analyticsInstance.instance, '');
-        await webAnalyticsAdapter.setUserProperties(analyticsInstance.instance, {});
-      }
-    } catch (_error) {
-      // Silent fail
-    }
-  }
-}
-
-export const analyticsUserService = new AnalyticsUserService();
-

package/src/analytics/infrastructure/services/index.ts

@@ -1,12 +0,0 @@
-/**
- * Analytics Infrastructure Services
- * Public API exports
- */
-
-export { firebaseAnalyticsService } from './FirebaseAnalyticsService';
-export type { IAnalyticsService } from './FirebaseAnalyticsService';
-export { analyticsInitializerService } from './analytics-initializer.service';
-export type { AnalyticsInstance } from './analytics-initializer.service';
-export { analyticsEventService } from './analytics-event.service';
-export { analyticsUserService } from './analytics-user.service';
-

package/src/analytics/presentation/decorators/PerformanceDecorator.ts

@@ -1,73 +0,0 @@
-/**
- * Performance Decorator
- *
- * DDD Pattern: Decorator for automatic performance tracking
- */
-
-import { performanceTracker } from '../../infrastructure/services/PerformanceTracker';
-
-export function TrackPerformance(operationName?: string) {
-  return function (
-    target: any,
-    propertyKey: string,
-    descriptor: PropertyDescriptor
-  ) {
-    const originalMethod = descriptor.value;
-    const operation = operationName || `${target?.constructor?.name || 'Unknown'}.${propertyKey}`;
-
-    descriptor.value = async function (...args: unknown[]) {
-      const trackingId = `${operation}_${Date.now()}`;
-      return await performanceTracker.track(trackingId, async () => {
-        return await originalMethod.apply(this, args);
-      });
-    };
-
-    return descriptor;
-  };
-}
-
-export function TrackOperation(
-  operationName: string,
-  errorType: 'database' | 'network' | 'auth' | 'cache' | 'generic' = 'generic'
-) {
-  return function (
-    _target: unknown,
-    propertyKey: string,
-    descriptor: PropertyDescriptor
-  ) {
-    const originalMethod = descriptor.value;
-
-    descriptor.value = async function (...args: unknown[]) {
-      const trackingId = `${operationName}_${Date.now()}`;
-      const startTime = Date.now();
-
-      try {
-        performanceTracker.start(trackingId);
-        const result = await originalMethod.apply(this, args);
-
-        await performanceTracker.end(trackingId, {
-          operation: operationName,
-          method: propertyKey,
-          success: true,
-        });
-
-        return result;
-      } catch (error) {
-        await performanceTracker.end(trackingId, {
-          operation: operationName,
-          method: propertyKey,
-          success: false,
-          errorType,
-          duration_ms: Date.now() - startTime,
-        });
-
-
-
-        throw error;
-      }
-    };
-
-    return descriptor;
-  };
-}
-

package/src/analytics/presentation/decorators/TrackingDecorator.ts

@@ -1,38 +0,0 @@
-/**
- * Tracking Decorator
- * 
- * DDD Pattern: Decorator for automatic event tracking
- */
-
-import { firebaseAnalyticsService } from '../../infrastructure/services/FirebaseAnalyticsService';
-
-/**
- * Decorator to automatically log an event when a method is called
- */
-export function TrackEvent(eventName: string, params?: Record<string, any>) {
-    return function (
-        _target: any,
-        _propertyKey: string,
-        descriptor: PropertyDescriptor
-    ) {
-        const originalMethod = descriptor.value;
-
-        descriptor.value = async function (...args: any[]) {
-            try {
-                await firebaseAnalyticsService.logEvent(eventName, params);
-            } catch (error) {
-                // Fail silently to not disrupt app flow
-            }
-            return originalMethod.apply(this, args);
-        };
-
-        return descriptor;
-    };
-}
-
-/**
- * Functional utility to track an event
- */
-export async function trackEvent(eventName: string, params?: Record<string, any>): Promise<void> {
-    await firebaseAnalyticsService.logEvent(eventName, params);
-}

package/src/analytics/presentation/hooks/useNavigationAnalytics.ts

@@ -1,118 +0,0 @@
-/**
- * useNavigationAnalytics Hook
- *
- * Tracks navigation analytics at app level for NavigationContainer
- * Migrated to Firebase modular SDK (v22+)
- *
- * Features:
- * - Screen view tracking
- * - Screen time measurement
- * - Navigation flow analytics
- *
- * @example
- * ```typescript
- * import { useNavigationAnalytics } from '@umituz/react-native-firebase';
- *
- * function App() {
- *   const { handleNavigationReady, handleNavigationStateChange } = useNavigationAnalytics();
- *
- *   return (
- *     <NavigationContainer
- *       onReady={() => handleNavigationReady(navigationRef)}
- *       onStateChange={() => handleNavigationStateChange(navigationRef)}
- *     >
- *       <AppNavigator />
- *     </NavigationContainer>
- *   );
- * }
- * ```
- */
-
-import { useRef } from "react";
-import { firebaseAnalyticsService } from "../../infrastructure/services/FirebaseAnalyticsService";
-
-export const useNavigationAnalytics = () => {
-  const routeNameRef = useRef<string | undefined>(undefined);
-  const screenStartTimeRef = useRef<number | undefined>(undefined);
-
-  const getActiveRouteName = (state: any): string | undefined => {
-    if (!state || !state.routes) return undefined;
-    const route = state.routes[state.index];
-    if (route.state) {
-      return getActiveRouteName(route.state);
-    }
-    return route.name;
-  };
-
-  const handleNavigationReady = (navigationRef: any) => {
-    const currentRouteName = getActiveRouteName(
-      navigationRef.current?.getRootState(),
-    );
-    routeNameRef.current = currentRouteName;
-    screenStartTimeRef.current = Date.now();
-
-    if (currentRouteName) {
-      firebaseAnalyticsService
-        .logScreenView({
-          screen_name: currentRouteName,
-          screen_class: currentRouteName,
-        })
-        .catch(() => {
-          // Silent fail - analytics is non-critical
-        });
-    }
-  };
-
-  const handleNavigationStateChange = async (navigationRef: any) => {
-    const previousRouteName = routeNameRef.current;
-    const currentRouteName = getActiveRouteName(
-      navigationRef.current?.getRootState(),
-    );
-
-    if (previousRouteName !== currentRouteName && currentRouteName) {
-      if (previousRouteName && screenStartTimeRef.current) {
-        const timeSpent = Math.round(
-          (Date.now() - screenStartTimeRef.current) / 1000,
-        );
-        await firebaseAnalyticsService
-          .logScreenTime({
-            screen_name: previousRouteName,
-            screen_class: previousRouteName,
-            time_spent_seconds: timeSpent,
-          })
-          .catch(() => {
-            // Silent fail - analytics is non-critical
-          });
-      }
-
-      await firebaseAnalyticsService
-        .logScreenView({
-          screen_name: currentRouteName,
-          screen_class: currentRouteName,
-        })
-        .catch(() => {
-          // Silent fail - analytics is non-critical
-        });
-
-      if (previousRouteName) {
-        await firebaseAnalyticsService
-          .logNavigation({
-            from_screen: previousRouteName,
-            to_screen: currentRouteName,
-            screen_class: currentRouteName,
-          })
-          .catch(() => {
-            // Silent fail - analytics is non-critical
-          });
-      }
-
-      routeNameRef.current = currentRouteName;
-      screenStartTimeRef.current = Date.now();
-    }
-  };
-
-  return {
-    handleNavigationReady,
-    handleNavigationStateChange,
-  };
-};

package/src/analytics/presentation/hooks/useNavigationTracking.ts

@@ -1,62 +0,0 @@
-/**
- * useNavigationTracking Hook
- *
- * Tracks navigation between screens for user journey analysis.
- * Logs navigation events when user navigates from one screen to another.
- *
- * Platform-agnostic: Works on Web, iOS, and Android
- *
- * @example
- * ```typescript
- * import { useNavigationTracking } from '@umituz/react-native-firebase-analytics';
- *
- * function MyScreen() {
- *   useNavigationTracking('home', 'HomeScreen');
- *   // ... rest of component
- * }
- * ```
- */
-
-import { useRef, useCallback } from "react";
-import { useFocusEffect } from "@react-navigation/native";
-import { firebaseAnalyticsService } from "../../infrastructure/services/FirebaseAnalyticsService";
-
-/**
- * Track navigation between screens
- * @param screenName - Current screen name (e.g., 'home', 'decks', 'settings')
- * @param screenClass - Current screen class name (e.g., 'HomeScreen', 'DecksScreen')
- */
-export function useNavigationTracking(
-  screenName: string,
-  screenClass?: string,
-): void {
-  const previousScreenRef = useRef<string | null>(null);
-  const isFirstFocusRef = useRef(true);
-
-  useFocusEffect(
-    useCallback(() => {
-      // Skip first focus (app start)
-      if (isFirstFocusRef.current) {
-        isFirstFocusRef.current = false;
-        previousScreenRef.current = screenName;
-        return;
-      }
-
-      // Log navigation if coming from another screen
-      if (previousScreenRef.current && previousScreenRef.current !== screenName) {
-        firebaseAnalyticsService
-          .logNavigation({
-            from_screen: previousScreenRef.current,
-            to_screen: screenName,
-            screen_class: screenClass || screenName,
-          })
-          .catch(() => {
-            // Silent fail - analytics is non-critical
-          });
-      }
-
-      previousScreenRef.current = screenName;
-    }, [screenName, screenClass]),
-  );
-}
-

package/src/analytics/presentation/hooks/useScreenTime.ts

@@ -1,69 +0,0 @@
-/**
- * useScreenTime Hook
- *
- * Tracks how long users spend on each screen.
- * Automatically logs screen_time event when screen is unfocused.
- *
- * Platform-agnostic: Works on Web, iOS, and Android
- *
- * @example
- * ```typescript
- * import { useScreenTime } from '@umituz/react-native-firebase-analytics';
- *
- * function MyScreen() {
- *   useScreenTime('home', 'HomeScreen');
- *   // ... rest of component
- * }
- * ```
- */
-
-import { useRef, useCallback } from "react";
-import { useFocusEffect } from "@react-navigation/native";
-import { firebaseAnalyticsService } from "../../infrastructure/services/FirebaseAnalyticsService";
-
-/**
- * Track screen time when screen is focused/unfocused
- * @param screenName - Screen name (e.g., 'home', 'decks', 'settings')
- * @param screenClass - Screen class name (e.g., 'HomeScreen', 'DecksScreen')
- */
-export function useScreenTime(screenName: string, screenClass?: string): void {
-  const startTimeRef = useRef<number | null>(null);
-
-  useFocusEffect(
-    useCallback(() => {
-      // Record start time when screen is focused
-      startTimeRef.current = Date.now();
-
-      return () => {
-        // Calculate time spent when screen is unfocused
-        if (startTimeRef.current !== null) {
-          const timeSpent = Math.round((Date.now() - startTimeRef.current) / 1000); // seconds
-
-          // Only log if user spent at least 1 second on screen
-          if (timeSpent >= 1) {
-            /* eslint-disable-next-line no-console */
-            if (__DEV__) {
-              console.log("📊 Screen time tracked:", {
-                screen: screenName,
-                timeSpent: `${timeSpent}s`,
-              });
-            }
-
-            firebaseAnalyticsService
-              .logScreenTime({
-                screen_name: screenName,
-                screen_class: screenClass || screenName,
-                time_spent_seconds: timeSpent,
-              })
-              .catch(() => {
-                // Silent fail - analytics is non-critical
-              });
-          }
-
-          startTimeRef.current = null;
-        }
-      };
-    }, [screenName, screenClass]),
-  );
-}
-

package/src/analytics/presentation/hooks/useScreenView.ts

@@ -1,70 +0,0 @@
-/**
- * useScreenView Hook
- *
- * Comprehensive screen tracking hook that combines:
- * - Screen view tracking (when screen is focused)
- * - Screen time tracking (how long user stays on screen)
- * - Navigation tracking (from/to screen transitions)
- *
- * Platform-agnostic: Works on Web, iOS, and Android
- *
- * @example
- * ```typescript
- * import { useScreenView } from '@umituz/react-native-firebase-analytics';
- *
- * function MyScreen() {
- *   useScreenView('home', 'HomeScreen');
- *   // ... rest of component
- * }
- * ```
- */
-
-import { useCallback } from "react";
-import { useFocusEffect } from "@react-navigation/native";
-import { InteractionManager } from "react-native";
-import { firebaseAnalyticsService } from "../../infrastructure/services/FirebaseAnalyticsService";
-import { useScreenTime } from "./useScreenTime";
-import { useNavigationTracking } from "./useNavigationTracking";
-
-/**
- * Track screen view, time, and navigation when screen is focused
- * @param screenName - Screen name (e.g., 'home', 'decks', 'settings')
- * @param screenClass - Screen class name (e.g., 'HomeScreen', 'DecksScreen')
- */
-export function useScreenView(screenName: string, screenClass?: string): void {
-  // Track screen time (how long user stays on screen)
-  useScreenTime(screenName, screenClass);
-
-  // Track navigation (from/to screen transitions)
-  useNavigationTracking(screenName, screenClass);
-
-  // Track screen view (when screen is focused)
-  useFocusEffect(
-    useCallback(() => {
-      // Defer analytics until screen transition animation completes
-      const task = InteractionManager.runAfterInteractions(() => {
-        /* eslint-disable-next-line no-console */
-        if (__DEV__) {
-          console.log("📊 Screen view tracked:", {
-            screen: screenName,
-            screenClass: screenClass || screenName,
-          });
-        }
-
-        firebaseAnalyticsService
-          .logScreenView({
-            screen_name: screenName,
-            screen_class: screenClass || screenName,
-          })
-          .catch(() => {
-            // Silent fail - analytics is non-critical
-          });
-      });
-
-      return () => {
-        task.cancel();
-      };
-    }, [screenName, screenClass]),
-  );
-}
-

package/src/analytics/presentation/utils/analyticsUtils.ts

@@ -1,78 +0,0 @@
-/**
- * Analytics Utilities
- *
- * Helper functions for tracking user interactions and events.
- * Platform-agnostic: Works on Web, iOS, and Android
- */
-
-import { firebaseAnalyticsService } from "../../infrastructure/services/FirebaseAnalyticsService";
-
-/**
- * Track button click
- * @param buttonId - Unique button identifier (e.g., 'create_deck', 'delete_card')
- * @param options - Optional parameters
- */
-export function trackButtonClick(
-  buttonId: string,
-  options?: {
-    buttonName?: string;
-    screenName?: string;
-    screenClass?: string;
-    [key: string]: string | number | boolean | null | undefined;
-  },
-): void {
-  const { buttonName, screenName, screenClass, ...additionalParams } =
-    options || {};
-
-  const params = {
-    button_id: buttonId,
-    button_name: buttonName || buttonId,
-    screen_name: screenName || "unknown",
-    screen_class: screenClass || screenName || "unknown",
-    ...additionalParams,
-  };
-
-  /* eslint-disable-next-line no-console */
-  if (__DEV__) {
-    console.log("📊 Button click tracked:", {
-      buttonId,
-      buttonName: buttonName || buttonId,
-      screenName: screenName || "unknown",
-      ...additionalParams,
-    });
-  }
-
-  firebaseAnalyticsService
-    .logButtonClick(params)
-    .catch(() => {
-      // Silent fail - analytics is non-critical
-    });
-}
-
-/**
- * Track CRUD operation
- * @param operation - Operation type ('create', 'update', 'delete', 'read')
- * @param entityType - Entity type ('deck', 'card', 'category', etc.)
- * @param entityId - Entity ID
- * @param additionalParams - Additional parameters to track
- */
-export function trackCRUDOperation(
-  operation: "create" | "update" | "delete" | "read",
-  entityType: string,
-  entityId: string,
-  additionalParams?: Record<string, string | number | boolean | null>,
-): void {
-  const eventName = `${entityType}_${operation}d`;
-
-  firebaseAnalyticsService
-    .logEvent(eventName, {
-      [`${entityType}_id`]: entityId,
-      operation,
-      entity_type: entityType,
-      ...additionalParams,
-    })
-    .catch(() => {
-      // Silent fail - analytics is non-critical
-    });
-}
-