svelte-firekit 0.1.9 → 0.2.1

package/dist/services/performance.d.ts

@@ -0,0 +1,60 @@
+import { type PerformanceTrace } from 'firebase/performance';
+/**
+ * Firebase Performance Monitoring wrapper.
+ *
+ * Lazily initializes the Performance SDK and provides helpers for
+ * creating and managing custom traces.
+ *
+ * @example
+ * ```ts
+ * import { firekitPerformance } from 'svelte-firekit';
+ *
+ * const perf = firekitPerformance();
+ * const t = perf.startTrace('load-user-profile');
+ * await loadUserProfile();
+ * t.stop();
+ * ```
+ */
+declare class FirekitPerformance {
+    private static instance;
+    private _perf;
+    private constructor();
+    static getInstance(): FirekitPerformance;
+    private _getOrInit;
+    /**
+     * Starts a custom trace and returns it.
+     * Call `.stop()` when the measured operation completes.
+     *
+     * @example
+     * ```ts
+     * const t = firekitPerformance.startTrace('checkout-flow');
+     * t.putAttribute('userId', uid);
+     * await processCheckout();
+     * t.stop();
+     * ```
+     */
+    startTrace(name: string): PerformanceTrace & {
+        stop: () => void;
+    };
+    /**
+     * Measures the duration of an async operation and records it as a trace.
+     *
+     * @example
+     * ```ts
+     * const data = await firekitPerformance.measure('fetch-products', () => fetchProducts());
+     * ```
+     */
+    measure<T>(name: string, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Enables or disables performance data collection.
+     * Useful for respecting user consent preferences.
+     */
+    setCollectionEnabled(enabled: boolean): void;
+    /**
+     * Enables or disables automatic instrumentation
+     * (page load, network request monitoring).
+     */
+    setInstrumentationEnabled(enabled: boolean): void;
+}
+export declare const firekitPerformance: FirekitPerformance;
+export type { PerformanceTrace };

package/dist/services/performance.js

@@ -0,0 +1,118 @@
+import { getPerformance, initializePerformance, trace } from 'firebase/performance';
+import { firebaseService } from '../firebase.js';
+function getApp() {
+    const app = firebaseService.getFirebaseApp();
+    if (!app)
+        throw new Error('Firebase app is not initialized.');
+    return app;
+}
+/**
+ * Firebase Performance Monitoring wrapper.
+ *
+ * Lazily initializes the Performance SDK and provides helpers for
+ * creating and managing custom traces.
+ *
+ * @example
+ * ```ts
+ * import { firekitPerformance } from 'svelte-firekit';
+ *
+ * const perf = firekitPerformance();
+ * const t = perf.startTrace('load-user-profile');
+ * await loadUserProfile();
+ * t.stop();
+ * ```
+ */
+class FirekitPerformance {
+    static instance;
+    _perf = null;
+    constructor() { }
+    static getInstance() {
+        if (!FirekitPerformance.instance) {
+            FirekitPerformance.instance = new FirekitPerformance();
+        }
+        return FirekitPerformance.instance;
+    }
+    _getOrInit() {
+        if (typeof window === 'undefined')
+            return null;
+        if (this._perf)
+            return this._perf;
+        try {
+            const app = getApp();
+            this._perf = getPerformance(app);
+            return this._perf;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Starts a custom trace and returns it.
+     * Call `.stop()` when the measured operation completes.
+     *
+     * @example
+     * ```ts
+     * const t = firekitPerformance.startTrace('checkout-flow');
+     * t.putAttribute('userId', uid);
+     * await processCheckout();
+     * t.stop();
+     * ```
+     */
+    startTrace(name) {
+        const perf = this._getOrInit();
+        if (!perf) {
+            // Return a no-op trace when Performance is unavailable (e.g. SSR)
+            return {
+                start: () => { },
+                stop: () => { },
+                record: () => { },
+                putAttribute: () => { },
+                getAttribute: () => undefined,
+                removeAttribute: () => { },
+                getAttributes: () => ({}),
+                putMetric: () => { },
+                getMetric: () => 0,
+                incrementMetric: () => { }
+            };
+        }
+        const t = trace(perf, name);
+        t.start();
+        return t;
+    }
+    /**
+     * Measures the duration of an async operation and records it as a trace.
+     *
+     * @example
+     * ```ts
+     * const data = await firekitPerformance.measure('fetch-products', () => fetchProducts());
+     * ```
+     */
+    async measure(name, fn) {
+        const t = this.startTrace(name);
+        try {
+            return await fn();
+        }
+        finally {
+            t.stop();
+        }
+    }
+    /**
+     * Enables or disables performance data collection.
+     * Useful for respecting user consent preferences.
+     */
+    setCollectionEnabled(enabled) {
+        const perf = this._getOrInit();
+        if (perf)
+            perf.dataCollectionEnabled = enabled;
+    }
+    /**
+     * Enables or disables automatic instrumentation
+     * (page load, network request monitoring).
+     */
+    setInstrumentationEnabled(enabled) {
+        const perf = this._getOrInit();
+        if (perf)
+            perf.instrumentationEnabled = enabled;
+    }
+}
+export const firekitPerformance = FirekitPerformance.getInstance();

package/dist/services/presence.svelte.d.ts

@@ -1,43 +1,29 @@
+import { type PresenceConfig, type SessionData, type PresenceStats, type Location, PresenceError } from '../types/presence.js';
 /**
- * @fileoverview FirekitPresence - Clean presence tracking for Svelte applications
- * @module FirekitPresence
- * @version 1.0.0
- */
-import { type PresenceConfig, type Location, type SessionData, type PresenceStats, PresenceError } from '../types/presence.js';
-/**
- * Main presence tracking service
+ * Reactive user presence tracking via Firebase Realtime Database.
+ *
+ * Monitors RTDB `.info/connected`, writes session data on connect,
+ * registers `onDisconnect` cleanup, and tracks page visibility changes.
  *
- * @class FirekitPresence
  * @example
- * ```typescript
+ * ```ts
  * import { firekitPresence } from 'svelte-firekit';
- *
- * // Initialize
- * await firekitPresence.initialize(user, {
- *   geolocation: { enabled: true, type: 'browser' },
- *   sessionTTL: 30 * 60 * 1000
- * });
- *
- * // Access reactive state
- * $: console.log('Status:', firekitPresence.status);
+ * await firekitPresence.initialize(user, { sessionTTL: 30 * 60 * 1000 });
  * ```
  */
 declare class FirekitPresence {
     private static instance;
-    private config;
-    private geolocationService;
-    private connectedListener;
-    private currentUser;
     private _initialized;
     private _status;
     private _loading;
     private _error;
     private _currentSession;
     private _sessions;
+    private _config;
+    private _geo;
+    private _connectedUnsub;
+    private _currentUser;
     private constructor();
-    /**
-     * Gets singleton instance of FirekitPresence
-     */
     static getInstance(): FirekitPresence;
     get initialized(): boolean;
     get status(): SessionData['status'];
@@ -47,74 +33,20 @@ declare class FirekitPresence {
     get sessions(): SessionData[];
     get location(): Location | null;
     get hasLocationConsent(): boolean;
-    /**
-     * Initialize presence tracking
-     * @param user Current authenticated user
-     * @param config Presence configuration options
-     */
-    initialize(user: any, config?: PresenceConfig): Promise<void>;
-    /**
-     * Set up Firebase connection monitoring
-     */
-    private setupConnectionMonitoring;
-    /**
-     * Set up disconnect handler for graceful offline transitions
-     */
-    private setupDisconnectHandler;
-    /**
-     * Set up page visibility listener
-     */
-    private setupVisibilityListener;
-    /**
-     * Set presence status
-     */
+    initialize(user: {
+        uid: string;
+    }, config?: PresenceConfig): Promise<void>;
+    private _setupConnectionMonitoring;
+    private _setupDisconnectHandler;
+    private _onVisibilityChange;
     setPresence(status: SessionData['status']): Promise<void>;
-    /**
-     * Load all sessions for current user
-     */
-    private loadSessions;
-    /**
-     * Get presence statistics
-     */
-    getPresenceStats(): PresenceStats;
-    /**
-     * Request location consent manually
-     */
-    requestLocationConsent(): Promise<boolean>;
-    /**
-     * Get current user's online sessions count
-     */
-    getOnlineSessionsCount(): number;
-    /**
-     * Check if user is online on any device
-     */
-    isUserOnline(): boolean;
-    /**
-     * Get sessions by status
-     */
+    private _loadSessions;
+    getStats(): PresenceStats;
+    isOnline(): boolean;
     getSessionsByStatus(status: SessionData['status']): SessionData[];
-    /**
-     * Force refresh presence data
-     */
+    requestLocationConsent(): Promise<boolean>;
     refresh(): Promise<void>;
-    /**
-     * Dispose of all resources and cleanup
-     */
     dispose(): Promise<void>;
 }
-/**
- * Pre-initialized singleton instance of FirekitPresence.
- *
- * @example
- * ```typescript
- * import { firekitPresence } from 'svelte-firekit';
- *
- * // Initialize presence tracking
- * await firekitPresence.initialize(user, {
- *   geolocation: { enabled: true, type: 'browser' },
- *   sessionTTL: 30 * 60 * 1000
- * });
- * ```
- */
 export declare const firekitPresence: FirekitPresence;
 export {};