svelte-firekit 0.0.21 → 0.0.22

package/dist/auth/presence.svelte.js

@@ -1,6 +1,23 @@
 import { ref, onDisconnect, onValue, get, set } from 'firebase/database';
 import { firebaseService } from '../firebase.js';
 import { browser } from '$app/environment';
+/**
+ * Manages real-time user presence tracking with optional geolocation support
+ * @class
+ * @example
+ * ```typescript
+ * // Initialize presence tracking
+ * await presenceService.initialize(currentUser, {
+ *   geolocation: { enabled: true, type: 'browser' },
+ *   sessionTTL: 30 * 60 * 1000
+ * });
+ *
+ * // Listen for presence events
+ * presenceService.addEventListener((event) => {
+ *   console.log(event.type, event.data);
+ * });
+ * ```
+ */
 class PresenceService {
     static instance;
     connectedListener = null;
@@ -35,13 +52,26 @@ class PresenceService {
         return PresenceService.instance;
     }
     // Getters
+    /** Get current session data */
     get currentSession() { return this._currentSession; }
+    /** Get all active sessions */
     get sessions() { return this._sessions; }
+    /** Get current presence status */
     get status() { return this._status; }
+    /** Get loading state */
     get loading() { return this._loading; }
+    /** Get error state */
     get error() { return this._error; }
+    /** Check if service is initialized */
     get isInitialized() { return this.initialized; }
+    /** Check if location consent is granted */
     get hasLocationConsent() { return this.locationConsent; }
+    /**
+ * Initialize presence tracking
+ * @param {any} user Current user object
+ * @param {PresenceConfig} config Optional configuration
+ * @throws {Error} If initialization fails
+ */
     async initializePresence() {
         const connectedRef = ref(firebaseService.getDatabaseInstance(), '.info/connected');
         this.connectedListener = onValue(connectedRef, async (snapshot) => {
@@ -94,6 +124,10 @@ class PresenceService {
         const browser = browserInfo[1] || 'Unknown Browser';
         return `${browser}-${platform}`.replace(/[^a-zA-Z0-9-]/g, '');
     }
+    /**
+    * Request location tracking consent
+    * @returns {Promise<boolean>} Whether consent was granted
+    */
     async requestLocationConsent() {
         if (!this.config.geolocation?.enabled)
             return false;
@@ -303,6 +337,11 @@ class PresenceService {
             this.locationWatcher = null;
         }
     }
+    /**
+      * Add presence event listener
+      * @param {Function} callback Event callback function
+      * @returns {Function} Cleanup function to remove listener
+      */
     addEventListener(callback) {
         this.eventListeners.add(callback);
         return () => this.eventListeners.delete(callback);
@@ -310,6 +349,9 @@ class PresenceService {
     emitEvent(event) {
         this.eventListeners.forEach(callback => callback(event));
     }
+    /**
+         * Cleanup presence tracking
+         */
     dispose() {
         this.stopLocationWatcher();
         if (this.connectedListener) {

package/dist/auth/user.svelte.d.ts

@@ -1,25 +1,29 @@
 import { type User } from "firebase/auth";
 /**
  * FirekitUser provides a singleton class for managing Firebase authentication state and user operations.
+ * Implements state management using SvelteKit's $state and $derived.
+ *
  * @class
  * @example
  * ```typescript
- * // Get instance
+ * // Get instance and check auth state
  * const auth = firekitUser;
- *
- * // Check if user is logged in
  * if (auth.isLoggedIn) {
  *   console.log(auth.user);
  * }
  *
  * // Update user profile
  * await auth.updateDisplayName("John Doe");
+ * await auth.updatePhotoURL("https://example.com/photo.jpg");
  * ```
  */
 declare class FirekitUser {
     private static instance;
+    /** @private Current user object state */
     private _user;
+    /** @private Authentication initialization state */
     private _initialized;
+    /** @private User login state */
     private _isLoggedIn;
     /** Current user's UID */
     readonly uid: string | undefined;
@@ -31,6 +35,10 @@ declare class FirekitUser {
     readonly photoURL: string | null | undefined;
     /** Whether current user's email is verified */
     readonly emailVerified: boolean | undefined;
+    /**
+     * Private constructor that initializes auth state listener
+     * @private
+     */
     private constructor();
     /**
      * Gets the singleton instance of FirekitUser
@@ -57,7 +65,9 @@ declare class FirekitUser {
      * @param {string} email - The new email address
      * @throws {Error} If no user is authenticated
      * @example
+     * ```typescript
      * await firekitUser.updateEmailUser("new@email.com");
+     * ```
      */
     updateEmailUser(email: string): Promise<void>;
     /**
@@ -65,7 +75,9 @@ declare class FirekitUser {
      * @param {string} password - The new password
      * @throws {Error} If no user is authenticated
      * @example
+     * ```typescript
      * await firekitUser.updatePassword("newPassword123");
+     * ```
      */
     updatePassword(password: string): Promise<void>;
     /**
@@ -73,7 +85,9 @@ declare class FirekitUser {
      * @param {string} displayName - The new display name
      * @throws {Error} If no user is authenticated
      * @example
+     * ```typescript
      * await firekitUser.updateDisplayName("John Doe");
+     * ```
      */
     updateDisplayName(displayName: string): Promise<void>;
     /**
@@ -81,12 +95,16 @@ declare class FirekitUser {
      * @param {string} photoURL - The new photo URL
      * @throws {Error} If no user is authenticated
      * @example
+     * ```typescript
      * await firekitUser.updatePhotoURL("https://example.com/photo.jpg");
+     * ```
      */
     updatePhotoURL(photoURL: string): Promise<void>;
 }
 /**
- * Singleton instance of FirekitUser
+ * Pre-initialized singleton instance of FirekitUser.
+ * Use this to access auth state and user operations.
+ *
  * @const
  * @type {FirekitUser}
  */

package/dist/auth/user.svelte.js

@@ -1,26 +1,33 @@
+/**
+ * @module FirekitUser
+ */
 import { firebaseService } from "../firebase.js";
 import { onAuthStateChanged, updateEmail, updatePassword, updateProfile } from "firebase/auth";
 /**
  * FirekitUser provides a singleton class for managing Firebase authentication state and user operations.
+ * Implements state management using SvelteKit's $state and $derived.
+ *
  * @class
  * @example
  * ```typescript
- * // Get instance
+ * // Get instance and check auth state
  * const auth = firekitUser;
- *
- * // Check if user is logged in
  * if (auth.isLoggedIn) {
  *   console.log(auth.user);
  * }
  *
  * // Update user profile
  * await auth.updateDisplayName("John Doe");
+ * await auth.updatePhotoURL("https://example.com/photo.jpg");
  * ```
  */
 class FirekitUser {
     static instance;
+    /** @private Current user object state */
     _user = $state();
+    /** @private Authentication initialization state */
     _initialized = $state();
+    /** @private User login state */
     _isLoggedIn = $state();
     /** Current user's UID */
     uid = $derived(this._user?.uid);
@@ -32,6 +39,10 @@ class FirekitUser {
     photoURL = $derived(this._user?.photoURL);
     /** Whether current user's email is verified */
     emailVerified = $derived(this._user?.emailVerified);
+    /**
+     * Private constructor that initializes auth state listener
+     * @private
+     */
     constructor() {
         const auth = firebaseService.getAuthInstance();
         onAuthStateChanged(auth, async (user) => {
@@ -82,7 +93,9 @@ class FirekitUser {
      * @param {string} email - The new email address
      * @throws {Error} If no user is authenticated
      * @example
+     * ```typescript
      * await firekitUser.updateEmailUser("new@email.com");
+     * ```
      */
     async updateEmailUser(email) {
         if (!this._user)
@@ -94,7 +107,9 @@ class FirekitUser {
      * @param {string} password - The new password
      * @throws {Error} If no user is authenticated
      * @example
+     * ```typescript
      * await firekitUser.updatePassword("newPassword123");
+     * ```
      */
     async updatePassword(password) {
         if (!this._user)
@@ -106,7 +121,9 @@ class FirekitUser {
      * @param {string} displayName - The new display name
      * @throws {Error} If no user is authenticated
      * @example
+     * ```typescript
      * await firekitUser.updateDisplayName("John Doe");
+     * ```
      */
     async updateDisplayName(displayName) {
         if (!this._user)
@@ -118,7 +135,9 @@ class FirekitUser {
      * @param {string} photoURL - The new photo URL
      * @throws {Error} If no user is authenticated
      * @example
+     * ```typescript
      * await firekitUser.updatePhotoURL("https://example.com/photo.jpg");
+     * ```
      */
     async updatePhotoURL(photoURL) {
         if (!this._user)
@@ -127,7 +146,9 @@ class FirekitUser {
     }
 }
 /**
- * Singleton instance of FirekitUser
+ * Pre-initialized singleton instance of FirekitUser.
+ * Use this to access auth state and user operations.
+ *
  * @const
  * @type {FirekitUser}
  */

package/dist/config.d.ts

@@ -1,2 +1,12 @@
 import type { FirebaseOptions } from 'firebase/app';
+/**
+ * Pre-initialized Firebase configuration instance.
+ * Use this to get Firebase configuration options directly.
+ *
+ * @example
+ * import { firebaseConfig } from './firebase-config';
+ * import { initializeApp } from 'firebase/app';
+ *
+ * const app = initializeApp(firebaseConfig);
+ */
 export declare const firebaseConfig: FirebaseOptions;

package/dist/config.js

@@ -1,7 +1,42 @@
 import { PUBLIC_FIREBASE_API_KEY, PUBLIC_FIREBASE_AUTH_DOMAIN, PUBLIC_FIREBASE_PROJECT_ID, PUBLIC_FIREBASE_STORAGE_BUCKET, PUBLIC_FIREBASE_MESSAGING_SENDER_ID, PUBLIC_FIREBASE_APP_ID, PUBLIC_FIREBASE_MEASUREMENT_ID } from '$env/static/public';
+/**
+ * @module FirebaseConfig
+ */
+/**
+ * Required environment variables for Firebase configuration.
+ * These must be defined in your .env file or environment.
+ * @typedef {Object} FirebaseEnvVars
+ * @property {string} PUBLIC_FIREBASE_API_KEY - Firebase API key
+ * @property {string} PUBLIC_FIREBASE_AUTH_DOMAIN - Firebase auth domain
+ * @property {string} PUBLIC_FIREBASE_PROJECT_ID - Firebase project ID
+ * @property {string} PUBLIC_FIREBASE_STORAGE_BUCKET - Firebase storage bucket
+ * @property {string} PUBLIC_FIREBASE_MESSAGING_SENDER_ID - Firebase messaging sender ID
+ * @property {string} PUBLIC_FIREBASE_APP_ID - Firebase app ID
+ * @property {string} PUBLIC_FIREBASE_MEASUREMENT_ID - Firebase measurement ID
+ */
+/**
+ * Singleton class that manages Firebase configuration.
+ * Implements the Singleton pattern to ensure only one Firebase config instance exists.
+ *
+ * @example
+ * // Get Firebase configuration
+ * const config = FirebaseConfig.getInstance().getConfig();
+ *
+ * // Initialize Firebase app
+ * const app = initializeApp(config);
+ *
+ * @throws {Error} If any required Firebase configuration variables are missing
+ */
 class FirebaseConfig {
     static instance;
     config;
+    /**
+     * Private constructor to prevent direct instantiation.
+     * Validates all required environment variables are present and creates config.
+     *
+     * @private
+     * @throws {Error} If any required Firebase configuration variables are missing
+     */
     constructor() {
         const missingVars = this.getMissingFirebaseConfigVars();
         if (missingVars.length > 0) {
@@ -17,6 +52,12 @@ class FirebaseConfig {
             measurementId: PUBLIC_FIREBASE_MEASUREMENT_ID
         };
     }
+    /**
+     * Checks for missing required Firebase configuration variables.
+     *
+     * @private
+     * @returns {string[]} Array of missing environment variable names
+     */
     getMissingFirebaseConfigVars() {
         const requiredVars = {
             'PUBLIC_FIREBASE_API_KEY': PUBLIC_FIREBASE_API_KEY,
@@ -31,14 +72,36 @@ class FirebaseConfig {
             .filter(([_, value]) => !value)
             .map(([key]) => key);
     }
+    /**
+     * Gets the singleton instance of FirebaseConfig.
+     * Creates a new instance if one doesn't exist.
+     *
+     * @returns {FirebaseConfig} The singleton FirebaseConfig instance
+     * @throws {Error} If any required Firebase configuration variables are missing
+     */
     static getInstance() {
         if (!FirebaseConfig.instance) {
             FirebaseConfig.instance = new FirebaseConfig();
         }
         return FirebaseConfig.instance;
     }
+    /**
+     * Gets the Firebase configuration options.
+     *
+     * @returns {FirebaseOptions} The Firebase configuration options
+     */
     getConfig() {
         return this.config;
     }
 }
+/**
+ * Pre-initialized Firebase configuration instance.
+ * Use this to get Firebase configuration options directly.
+ *
+ * @example
+ * import { firebaseConfig } from './firebase-config';
+ * import { initializeApp } from 'firebase/app';
+ *
+ * const app = initializeApp(firebaseConfig);
+ */
 export const firebaseConfig = FirebaseConfig.getInstance().getConfig();

package/dist/firebase.d.ts

@@ -4,6 +4,17 @@ import { type Auth } from 'firebase/auth';
 import { type Functions } from 'firebase/functions';
 import { type Database } from 'firebase/database';
 import { type FirebaseStorage } from 'firebase/storage';
+/**
+ * Singleton service class that manages Firebase service instances.
+ * Handles initialization and access to Firebase app and its various services.
+ *
+ * @example
+ * // Get Firestore instance
+ * const db = firebaseService.getDbInstance();
+ *
+ * // Get Auth instance
+ * const auth = firebaseService.getAuthInstance();
+ */
 declare class FirebaseService {
     private static instance;
     private firebaseApp;
@@ -12,16 +23,74 @@ declare class FirebaseService {
     private functions;
     private database;
     private storage;
+    /** Flag to determine if code is running in browser environment */
     private readonly isBrowser;
+    /** @private */
     private constructor();
+    /**
+     * Gets the singleton instance of FirebaseService.
+     * Creates a new instance if one doesn't exist.
+     *
+     * @returns {FirebaseService} The singleton FirebaseService instance
+     */
     static getInstance(): FirebaseService;
+    /**
+     * Initializes or retrieves the Firebase app instance.
+     * Also initializes Firestore if running in browser environment.
+     *
+     * @returns {FirebaseApp} The Firebase app instance
+     */
     getFirebaseApp(): FirebaseApp;
+    /**
+     * Initializes Firestore with persistent cache and multi-tab support.
+     * Only runs in browser environment.
+     *
+     * @private
+     */
     private initializeFirestoreInstance;
+    /**
+     * Gets the Firestore instance, initializing it if necessary.
+     *
+     * @returns {Firestore} The Firestore instance
+     */
     getDbInstance(): Firestore;
+    /**
+     * Gets the Authentication instance, initializing it if necessary.
+     *
+     * @returns {Auth} The Authentication instance
+     */
     getAuthInstance(): Auth;
+    /**
+     * Gets the Cloud Functions instance, initializing it if necessary.
+     *
+     * @returns {Functions} The Cloud Functions instance
+     */
     getFunctionsInstance(): Functions;
+    /**
+     * Gets the Realtime Database instance, initializing it if necessary.
+     *
+     * @returns {Database} The Realtime Database instance
+     */
     getDatabaseInstance(): Database;
+    /**
+     * Gets the Storage instance, initializing it if necessary.
+     *
+     * @returns {FirebaseStorage} The Storage instance
+     */
     getStorageInstance(): FirebaseStorage;
 }
+/**
+ * Pre-initialized Firebase service instance.
+ * Use this to access Firebase services directly.
+ *
+ * @example
+ * import { firebaseService } from './firebase-service';
+ *
+ * // Get Firestore
+ * const db = firebaseService.getDbInstance();
+ *
+ * // Get Auth
+ * const auth = firebaseService.getAuthInstance();
+ */
 export declare const firebaseService: FirebaseService;
 export {};

package/dist/firebase.js

@@ -1,10 +1,21 @@
 import { initializeApp, getApps } from 'firebase/app';
-import { initializeFirestore, CACHE_SIZE_UNLIMITED, persistentLocalCache, persistentMultipleTabManager, enablePersistentCacheIndexAutoCreation, getPersistentCacheIndexManager, writeBatch } from 'firebase/firestore';
+import { initializeFirestore, CACHE_SIZE_UNLIMITED, persistentLocalCache, persistentMultipleTabManager, enablePersistentCacheIndexAutoCreation, getPersistentCacheIndexManager, } from 'firebase/firestore';
 import { getAuth } from 'firebase/auth';
 import { getFunctions } from 'firebase/functions';
 import { getDatabase } from 'firebase/database';
 import { getStorage } from 'firebase/storage';
 import { firebaseConfig } from './config.js';
+/**
+ * Singleton service class that manages Firebase service instances.
+ * Handles initialization and access to Firebase app and its various services.
+ *
+ * @example
+ * // Get Firestore instance
+ * const db = firebaseService.getDbInstance();
+ *
+ * // Get Auth instance
+ * const auth = firebaseService.getAuthInstance();
+ */
 class FirebaseService {
     static instance;
     firebaseApp = null;
@@ -13,15 +24,28 @@ class FirebaseService {
     functions = null;
     database = null;
     storage = null;
+    /** Flag to determine if code is running in browser environment */
     isBrowser = typeof window !== 'undefined';
-    constructor() {
-    }
+    /** @private */
+    constructor() { }
+    /**
+     * Gets the singleton instance of FirebaseService.
+     * Creates a new instance if one doesn't exist.
+     *
+     * @returns {FirebaseService} The singleton FirebaseService instance
+     */
     static getInstance() {
         if (!FirebaseService.instance) {
             FirebaseService.instance = new FirebaseService();
         }
         return FirebaseService.instance;
     }
+    /**
+     * Initializes or retrieves the Firebase app instance.
+     * Also initializes Firestore if running in browser environment.
+     *
+     * @returns {FirebaseApp} The Firebase app instance
+     */
     getFirebaseApp() {
         if (this.firebaseApp)
             return this.firebaseApp;
@@ -36,6 +60,12 @@ class FirebaseService {
         this.initializeFirestoreInstance();
         return this.firebaseApp;
     }
+    /**
+     * Initializes Firestore with persistent cache and multi-tab support.
+     * Only runs in browser environment.
+     *
+     * @private
+     */
     initializeFirestoreInstance() {
         if (this.db || !this.isBrowser)
             return;
@@ -54,30 +84,68 @@ class FirebaseService {
             console.warn('Failed to initialize the Firestore cache index manager');
         }
     }
+    /**
+     * Gets the Firestore instance, initializing it if necessary.
+     *
+     * @returns {Firestore} The Firestore instance
+     */
     getDbInstance() {
         if (!this.db)
             this.getFirebaseApp();
         return this.db;
     }
+    /**
+     * Gets the Authentication instance, initializing it if necessary.
+     *
+     * @returns {Auth} The Authentication instance
+     */
     getAuthInstance() {
         if (!this.auth)
             this.auth = getAuth(this.getFirebaseApp());
         return this.auth;
     }
+    /**
+     * Gets the Cloud Functions instance, initializing it if necessary.
+     *
+     * @returns {Functions} The Cloud Functions instance
+     */
     getFunctionsInstance() {
         if (!this.functions)
             this.functions = getFunctions(this.getFirebaseApp());
         return this.functions;
     }
+    /**
+     * Gets the Realtime Database instance, initializing it if necessary.
+     *
+     * @returns {Database} The Realtime Database instance
+     */
     getDatabaseInstance() {
         if (!this.database)
             this.database = getDatabase(this.getFirebaseApp());
         return this.database;
     }
+    /**
+     * Gets the Storage instance, initializing it if necessary.
+     *
+     * @returns {FirebaseStorage} The Storage instance
+     */
     getStorageInstance() {
         if (!this.storage)
             this.storage = getStorage(this.getFirebaseApp());
         return this.storage;
     }
 }
+/**
+ * Pre-initialized Firebase service instance.
+ * Use this to access Firebase services directly.
+ *
+ * @example
+ * import { firebaseService } from './firebase-service';
+ *
+ * // Get Firestore
+ * const db = firebaseService.getDbInstance();
+ *
+ * // Get Auth
+ * const auth = firebaseService.getAuthInstance();
+ */
 export const firebaseService = FirebaseService.getInstance();