svelte-firekit 0.0.11 → 0.0.13

package/dist/firebase/auth/auth-manager.svelte.d.ts

@@ -1,4 +1,3 @@
-import { type User } from "firebase/auth";
 import { type DocumentData } from "firebase/firestore";
 type UserClaims = Record<string, any>;
 interface UserData extends DocumentData {
@@ -22,15 +21,17 @@ interface GuardConfig {
 }
 export declare class FirekitAuthManager {
     private static instance;
+    private readonly SESSION_TIMEOUT;
+    private activityInterval;
+    private _initPromise;
     private _user;
     private _userData;
     private _claims;
     private _initialized;
-    private _initPromise;
     private _loading;
     private _error;
+    private _currentSession;
     private _lastValidationTime;
-    private readonly VALIDATION_THROTTLE;
     readonly isLoggedIn: boolean;
     readonly uid: string | undefined;
     readonly email: string | null | undefined;
@@ -40,13 +41,28 @@ export declare class FirekitAuthManager {
     readonly claims: UserClaims;
     readonly data: UserData | null;
     readonly initialized: boolean;
+    readonly loading: boolean;
+    readonly error: Error | null;
+    readonly sessionActive: boolean;
     private constructor();
     static getInstance(): FirekitAuthManager;
     private initialize;
     waitForInit(): Promise<void>;
+    private handleAuthStateChange;
     private loadUserData;
     private loadUserClaims;
-    get user(): User | null | undefined;
+    private setupActivityTracking;
+    private initializeSession;
+    private updateLastActivity;
+    private checkSession;
+    private handleSessionTimeout;
+    private clearSession;
+    private handleError;
+    private generateDeviceId;
+    private getPlatformInfo;
+    private validateClaims;
+    private handleRedirect;
+    validateAuth({ authRequired, redirectTo, requiredClaims, requiredData, allowIf, redirectParams, }?: GuardConfig): Promise<boolean>;
     updateEmailUser(email: string): Promise<void>;
     updatePassword(password: string): Promise<void>;
     updateProfileInfo({ displayName, photoURL, }: {
@@ -55,19 +71,17 @@ export declare class FirekitAuthManager {
     }): Promise<void>;
     updateUserData(data: Partial<UserData>): Promise<void>;
     saveUserData(data: UserData): Promise<void>;
+    sendVerificationEmail(): Promise<void>;
+    refreshUserData(): Promise<void>;
     hasRequiredClaims(requiredClaims: string[]): boolean;
     isAdmin(): boolean;
     isPremium(): boolean;
-    private shouldThrottleValidation;
-    private handleRedirect;
-    private validateClaims;
-    validateAuth({ authRequired, redirectTo, requiredClaims, requiredData, allowIf, redirectParams, }?: GuardConfig): Promise<boolean>;
     requireAuth(redirectTo?: string, redirectParams?: Record<string, string>): Promise<boolean>;
     requireNoAuth(redirectTo?: string, redirectParams?: Record<string, string>): Promise<boolean>;
     requireClaims(claims: string[], redirectTo?: string, redirectParams?: Record<string, string>): Promise<boolean>;
     requireData(validator: (data: DocumentData | null) => boolean, redirectTo?: string, redirectParams?: Record<string, string>): Promise<boolean>;
-    get loading(): boolean;
-    get error(): Error | null;
+    logOut(): Promise<void>;
+    destroy(): void;
 }
 export declare const firekitAuthManager: FirekitAuthManager;
 export {};

package/dist/firebase/auth/auth-manager.svelte.js

@@ -2,23 +2,33 @@ import { browser } from "$app/environment";
 import { goto } from "$app/navigation";
 import { firebaseService } from "../firebase.js";
 import { toast } from "svelte-sonner";
-import { onAuthStateChanged, updateCurrentUser, updateEmail, updatePassword, updatePhoneNumber, updateProfile, } from "firebase/auth";
+import { onAuthStateChanged, updateEmail, updatePassword, updateProfile, sendEmailVerification, } from "firebase/auth";
 import { doc, getDoc, setDoc, updateDoc, } from "firebase/firestore";
-import { firekitAuth } from "./auth.js";
+class AuthError extends Error {
+    code;
+    originalError;
+    constructor(message, code = 'unknown', originalError) {
+        super(message);
+        this.code = code;
+        this.originalError = originalError;
+        this.name = 'AuthError';
+    }
+}
 export class FirekitAuthManager {
     static instance;
-    // User-related states
+    SESSION_TIMEOUT = 30 * 60 * 1000; // 30 minutes
+    activityInterval = null;
+    _initPromise = null;
+    // State using Svelte 5 runes
     _user = $state();
     _userData = $state(null);
     _claims = $state({});
     _initialized = $state(false);
-    _initPromise = null;
-    // Auth-Guard related states
     _loading = $state(true);
     _error = $state(null);
-    _lastValidationTime = 0;
-    VALIDATION_THROTTLE = 1000; // 1 second
-    // Derived states
+    _currentSession = $state(null);
+    _lastValidationTime = $state(0);
+    // Derived state
     isLoggedIn = $derived(Boolean(this._user));
     uid = $derived(this._user?.uid);
     email = $derived(this._user?.email);
@@ -28,9 +38,13 @@ export class FirekitAuthManager {
     claims = $derived(this._claims);
     data = $derived(this._userData);
     initialized = $derived(this._initialized);
+    loading = $derived(this._loading);
+    error = $derived(this._error);
+    sessionActive = $derived(Boolean(this._currentSession));
     constructor() {
         if (browser) {
             this.initialize();
+            this.setupActivityTracking();
         }
     }
     static getInstance() {
@@ -43,16 +57,11 @@ export class FirekitAuthManager {
         if (this._initialized)
             return;
         this._initPromise = new Promise((resolve) => {
-            onAuthStateChanged(firebaseService.getAuthInstance(), async (user) => {
-                this._user = user;
-                if (user) {
-                    await Promise.all([this.loadUserData(), this.loadUserClaims()]);
-                }
-                else {
-                    this._userData = null;
-                    this._claims = {};
-                }
-                this._initialized = true;
+            const auth = firebaseService.getAuthInstance();
+            if (!auth)
+                throw new AuthError('Firebase Auth not initialized', 'init_failed');
+            onAuthStateChanged(auth, async (user) => {
+                await this.handleAuthStateChange(user);
                 resolve();
             });
         });
@@ -62,19 +71,44 @@ export class FirekitAuthManager {
             return;
         return this._initPromise || Promise.resolve();
     }
-    async loadUserData() {
-        if (!this._user?.uid)
-            return;
-        const docRef = doc(firebaseService.getDb(), "users", this._user.uid);
+    async handleAuthStateChange(user) {
+        this._loading = true;
+        try {
+            if (user) {
+                this._user = user;
+                await Promise.all([
+                    this.loadUserData(user.uid),
+                    this.loadUserClaims(user)
+                ]);
+                this.initializeSession();
+            }
+            else {
+                this._user = null;
+                this._userData = null;
+                this._claims = {};
+                this.clearSession();
+            }
+            this._initialized = true;
+            this._error = null;
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+        finally {
+            this._loading = false;
+        }
+    }
+    async loadUserData(uid) {
+        const docRef = doc(firebaseService.getDb(), "users", uid);
         const docSnap = await getDoc(docRef);
         if (docSnap.exists()) {
             this._userData = docSnap.data();
         }
         else {
             const initialData = {
-                displayName: this._user.displayName || "",
-                email: this._user.email || "",
-                photoURL: this._user.photoURL || "",
+                displayName: this._user?.displayName || "",
+                email: this._user?.email || "",
+                photoURL: this._user?.photoURL || "",
                 createdAt: new Date(),
                 updatedAt: new Date(),
                 isProfileComplete: false,
@@ -82,83 +116,70 @@ export class FirekitAuthManager {
             await this.saveUserData(initialData);
         }
     }
-    async loadUserClaims() {
-        if (!this._user)
-            return;
-        const tokenResult = await this._user.getIdTokenResult();
+    async loadUserClaims(user) {
+        const tokenResult = await user.getIdTokenResult();
         this._claims = tokenResult.claims;
     }
-    get user() {
-        return this._user;
-    }
-    async updateEmailUser(email) {
-        if (!this._user)
-            throw new Error("No authenticated user");
-        try {
-            await updateEmail(this._user, email);
-            await this.updateUserData({ email });
-            toast.success("Email updated successfully!", {
-                description: "Please note that you will be logged out, and you will need to log in again using your new email address.",
+    setupActivityTracking() {
+        if (browser) {
+            ['mousedown', 'keydown', 'scroll', 'touchstart'].forEach(eventName => {
+                window.addEventListener(eventName, () => this.updateLastActivity());
             });
-            setTimeout(async () => {
-                await firekitAuth.logOut();
-            }, 4500);
-        }
-        catch (error) {
-            toast.error(error.message);
+            this.activityInterval = setInterval(() => this.checkSession(), 60000);
         }
     }
-    async updatePassword(password) {
-        if (!this._user)
-            throw new Error("No authenticated user");
-        await updatePassword(this._user, password);
+    initializeSession() {
+        this._currentSession = {
+            lastActivity: Date.now(),
+            deviceId: this.generateDeviceId(),
+            platform: this.getPlatformInfo()
+        };
     }
-    async updateProfileInfo({ displayName, photoURL, }) {
-        if (!this._user)
-            throw new Error("No authenticated user");
-        if (!displayName && !photoURL)
+    updateLastActivity() {
+        if (this._currentSession) {
+            this._currentSession.lastActivity = Date.now();
+        }
+    }
+    async checkSession() {
+        if (!this._currentSession)
             return;
-        if (displayName)
-            await updateProfile(this._user, { displayName });
-        if (photoURL)
-            await updateProfile(this._user, { photoURL });
+        const inactiveTime = Date.now() - this._currentSession.lastActivity;
+        if (inactiveTime > this.SESSION_TIMEOUT) {
+            await this.handleSessionTimeout();
+        }
     }
-    async updateUserData(data) {
-        if (!this._user?.uid)
-            throw new Error("No authenticated user");
-        const docRef = doc(firebaseService.getDb(), "users", this._user.uid);
-        const updateData = { ...data, updatedAt: new Date() };
-        await updateDoc(docRef, updateData);
-        await this.loadUserData();
+    async handleSessionTimeout() {
+        toast.warning('Session expired due to inactivity', {
+            description: 'Please log in again to continue.',
+            duration: 5000
+        });
+        await this.logOut();
     }
-    async saveUserData(data) {
-        if (!this._user?.uid)
-            throw new Error("No authenticated user");
-        const docRef = doc(firebaseService.getDb(), "users", this._user.uid);
-        const saveData = {
-            ...data,
-            createdAt: data.createdAt || new Date(),
-            updatedAt: new Date(),
-        };
-        await setDoc(docRef, saveData);
-        await this.loadUserData();
+    clearSession() {
+        this._currentSession = null;
+        if (this.activityInterval) {
+            clearInterval(this.activityInterval);
+            this.activityInterval = null;
+        }
     }
-    hasRequiredClaims(requiredClaims) {
-        return requiredClaims.every((claim) => this._claims[claim]);
+    handleError(error) {
+        const authError = error instanceof AuthError
+            ? error
+            : new AuthError(error instanceof Error ? error.message : 'An unknown error occurred', 'unknown', error instanceof Error ? error : undefined);
+        this._error = authError;
+        this._loading = false;
+        console.error('[FirekitAuthManager]', authError);
     }
-    isAdmin() {
-        return Boolean(this._claims.admin);
+    generateDeviceId() {
+        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
     }
-    isPremium() {
-        return Boolean(this._claims.premium);
+    getPlatformInfo() {
+        if (!browser)
+            return 'server';
+        return `${navigator.platform} - ${navigator.userAgent}`;
     }
-    shouldThrottleValidation() {
-        const now = Date.now();
-        if (now - this._lastValidationTime < this.VALIDATION_THROTTLE) {
-            return true;
-        }
-        this._lastValidationTime = now;
-        return false;
+    validateClaims(requiredClaims, userClaims) {
+        return requiredClaims.every(claim => userClaims[claim]);
     }
     async handleRedirect(redirectTo, params) {
         const url = new URL(redirectTo, window.location.origin);
@@ -169,42 +190,41 @@ export class FirekitAuthManager {
         }
         await goto(url.toString());
     }
-    async validateClaims(requiredClaims, userClaims) {
-        if (!requiredClaims.length)
-            return true;
-        if (!userClaims)
-            return false;
-        return requiredClaims.every((claim) => userClaims[claim]);
-    }
+    // Public Methods
     async validateAuth({ authRequired = true, redirectTo = "/login", requiredClaims = [], requiredData, allowIf, redirectParams, } = {}) {
         if (!browser)
             return true;
-        if (this.shouldThrottleValidation())
-            return true;
+        const now = Date.now();
+        if (now - this._lastValidationTime < 1000)
+            return false;
+        this._lastValidationTime = now;
         try {
             this._loading = true;
             this._error = null;
             await this.waitForInit();
-            const isAuthenticated = this.isLoggedIn;
-            if (authRequired && !isAuthenticated) {
+            // Basic auth validation
+            if (authRequired && !this._user) {
                 await this.handleRedirect(redirectTo, {
                     ...redirectParams,
                     returnTo: window.location.pathname,
                 });
                 return false;
             }
+            if (!authRequired && this._user) {
+                await this.handleRedirect(redirectTo, redirectParams);
+                return false;
+            }
+            // Custom conditions
             if (allowIf && !allowIf(this)) {
                 await this.handleRedirect(redirectTo, redirectParams);
                 return false;
             }
-            if (requiredClaims.length > 0) {
-                const userClaims = await firekitAuthManager.user?.getIdTokenResult();
-                const hasClaims = await this.validateClaims(requiredClaims, userClaims?.claims);
-                if (!hasClaims) {
-                    await this.handleRedirect(redirectTo, redirectParams);
-                    return false;
-                }
+            // Claims validation
+            if (requiredClaims.length > 0 && !this.validateClaims(requiredClaims, this._claims)) {
+                await this.handleRedirect(redirectTo, redirectParams);
+                return false;
             }
+            // Data validation
             if (requiredData && !requiredData(this._userData)) {
                 await this.handleRedirect(redirectTo, redirectParams);
                 return false;
@@ -212,13 +232,128 @@ export class FirekitAuthManager {
             return true;
         }
         catch (error) {
-            this._error = error instanceof Error ? error : new Error(String(error));
+            this.handleError(error);
             return false;
         }
         finally {
             this._loading = false;
         }
     }
+    async updateEmailUser(email) {
+        if (!this._user)
+            throw new AuthError("No authenticated user", "no_user");
+        try {
+            await updateEmail(this._user, email);
+            await this.updateUserData({ email });
+            toast.success("Email updated successfully!", {
+                description: "Please note that you will be logged out, and you will need to log in again using your new email address.",
+            });
+            setTimeout(async () => {
+                await this.logOut();
+            }, 4500);
+        }
+        catch (error) {
+            this.handleError(error);
+            throw error;
+        }
+    }
+    async updatePassword(password) {
+        if (!this._user)
+            throw new AuthError("No authenticated user", "no_user");
+        try {
+            await updatePassword(this._user, password);
+        }
+        catch (error) {
+            this.handleError(error);
+            throw error;
+        }
+    }
+    async updateProfileInfo({ displayName, photoURL, }) {
+        if (!this._user)
+            throw new AuthError("No authenticated user", "no_user");
+        if (!displayName && !photoURL)
+            return;
+        try {
+            if (displayName)
+                await updateProfile(this._user, { displayName });
+            if (photoURL)
+                await updateProfile(this._user, { photoURL });
+            await this.updateUserData({ displayName, photoURL });
+        }
+        catch (error) {
+            this.handleError(error);
+            throw error;
+        }
+    }
+    async updateUserData(data) {
+        if (!this._user?.uid)
+            throw new AuthError("No authenticated user", "no_user");
+        try {
+            const docRef = doc(firebaseService.getDb(), "users", this._user.uid);
+            const updateData = { ...data, updatedAt: new Date() };
+            await updateDoc(docRef, updateData);
+            await this.loadUserData(this._user.uid);
+        }
+        catch (error) {
+            this.handleError(error);
+            throw error;
+        }
+    }
+    async saveUserData(data) {
+        if (!this._user?.uid)
+            throw new AuthError("No authenticated user", "no_user");
+        try {
+            const docRef = doc(firebaseService.getDb(), "users", this._user.uid);
+            const saveData = {
+                ...data,
+                createdAt: data.createdAt || new Date(),
+                updatedAt: new Date(),
+            };
+            await setDoc(docRef, saveData);
+            await this.loadUserData(this._user.uid);
+        }
+        catch (error) {
+            this.handleError(error);
+            throw error;
+        }
+    }
+    async sendVerificationEmail() {
+        if (!this._user)
+            throw new AuthError('No authenticated user', 'no_user');
+        try {
+            await sendEmailVerification(this._user);
+            toast.success('Verification email sent!');
+        }
+        catch (error) {
+            this.handleError(error);
+            throw error;
+        }
+    }
+    async refreshUserData() {
+        if (!this._user)
+            return;
+        try {
+            await Promise.all([
+                this.loadUserData(this._user.uid),
+                this.loadUserClaims(this._user)
+            ]);
+        }
+        catch (error) {
+            this.handleError(error);
+            throw error;
+        }
+    }
+    // Helper methods
+    hasRequiredClaims(requiredClaims) {
+        return requiredClaims.every((claim) => this._claims[claim]);
+    }
+    isAdmin() {
+        return Boolean(this._claims.admin);
+    }
+    isPremium() {
+        return Boolean(this._claims.premium);
+    }
+    // Convenience methods for route guards
     async requireAuth(redirectTo = "/login", redirectParams) {
         return this.validateAuth({
             authRequired: true,
@@ -247,11 +382,20 @@ export class FirekitAuthManager {
             redirectParams,
         });
     }
-    get loading() {
-        return this._loading;
+    async logOut() {
+        try {
+            await firebaseService.getAuthInstance().signOut();
+            this.clearSession();
+        }
+        catch (error) {
+            this.handleError(error);
+            throw error;
+        }
     }
-    get error() {
-        return this._error;
+    // Cleanup
+    destroy() {
+        this.clearSession();
+        // Additional cleanup if needed
     }
 }
 export const firekitAuthManager = FirekitAuthManager.getInstance();

package/dist/firebase/firestore/document-mutations.svelte.d.ts

@@ -7,7 +7,7 @@ declare class FirekitDocumentMutations {
     set<T extends DocumentData>(path: string, data: WithFieldValue<T>, options?: {
         merge?: boolean;
         timestamps?: boolean;
-    }): Promise<void>;
+    }): Promise<string>;
     update<T extends DocumentData>(path: string, data: PartialWithFieldValue<T>, options?: {
         timestamps?: boolean;
     }): Promise<void>;

package/dist/firebase/firestore/document-mutations.svelte.js

@@ -22,7 +22,7 @@ class FirekitDocumentMutations {
         timestamps: true,
     }) {
         const firestore = firebaseService.getDb();
-        const docRef = doc(firestore, path);
+        const docRef = doc(collection(firestore, path));
         const dataToSet = {
             ...data,
             ...(options.timestamps && {
@@ -31,8 +31,10 @@ class FirekitDocumentMutations {
                 updatedAt: serverTimestamp(),
                 updatedBy: firekitAuthManager.uid,
             }),
+            uid: docRef.id,
         };
-        return setDoc(docRef, dataToSet, { merge: options.merge });
+        await setDoc(docRef, dataToSet, { merge: options.merge });
+        return docRef.id;
     }
     async update(path, data, options = { timestamps: true }) {
         const firestore = firebaseService.getDb();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "svelte-firekit",
-	"version": "0.0.11",
+	"version": "0.0.13",
 	"license": "MIT",
 	"scripts": {
 		"dev": "vite dev",

package/dist/firebase/auth/auth-guard.svelte.d.ts

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

package/dist/firebase/auth/auth-guard.svelte.js

@@ -1,119 +0,0 @@
-"use strict";
-// import { browser } from "$app/environment";
-// import { goto } from "$app/navigation";
-// import type { DocumentData } from "firebase/firestore";
-// import { firekitUser } from "./user.svelte.js";
-// type UserClaims = Record<string, any>;
-// interface GuardConfig {
-//     authRequired?: boolean;
-//     redirectTo?: string;
-//     requiredClaims?: string[];
-//     requiredData?: (data: DocumentData | null) => boolean;
-//     allowIf?: (user: typeof firekitUser) => boolean;
-//     redirectParams?: Record<string, string>;
-// }
-// export class FirekitAuthGuard {
-//     private static instance: FirekitAuthGuard;
-//     private _loading = $state(true);
-//     private _error = $state<Error | null>(null);
-//     private _lastValidationTime = 0;
-//     private readonly VALIDATION_THROTTLE = 1000; // 1 second
-//     private constructor() { }
-//     static getInstance(): FirekitAuthGuard {
-//         if (!FirekitAuthGuard.instance) {
-//             FirekitAuthGuard.instance = new FirekitAuthGuard();
-//         }
-//         return FirekitAuthGuard.instance;
-//     }
-//     private shouldThrottleValidation(): boolean {
-//         const now = Date.now();
-//         if (now - this._lastValidationTime < this.VALIDATION_THROTTLE) {
-//             return true;
-//         }
-//         this._lastValidationTime = now;
-//         return false;
-//     }
-//     private async handleRedirect(redirectTo: string, params?: Record<string, string>): Promise<void> {
-//         const url = new URL(redirectTo, window.location.origin);
-//         if (params) {
-//             Object.entries(params).forEach(([key, value]) => {
-//                 url.searchParams.append(key, value);
-//             });
-//         }
-//         await goto(url.toString());
-//     }
-//     private async validateClaims(requiredClaims: string[], userClaims?: UserClaims): Promise<boolean> {
-//         if (!requiredClaims.length) return true;
-//         if (!userClaims) return false;
-//         return requiredClaims.every(claim => userClaims[claim]);
-//     }
-//     async validateAuth({
-//         authRequired = true,
-//         redirectTo = '/login',
-//         requiredClaims = [],
-//         requiredData,
-//         allowIf,
-//         redirectParams
-//     }: GuardConfig = {}): Promise<boolean> {
-//         if (!browser) return true;
-//         if (this.shouldThrottleValidation()) return true;
-//         try {
-//             this._loading = true;
-//             this._error = null;
-//             await firekitUser.waitForInit();
-//             const isAuthenticated = firekitUser.isLoggedIn;
-//             if (authRequired && !isAuthenticated) {
-//                 await this.handleRedirect(redirectTo, {
-//                     ...redirectParams,
-//                     returnTo: window.location.pathname
-//                 });
-//                 return false;
-//             }
-//             if (allowIf && !allowIf(firekitUser)) {
-//                 await this.handleRedirect(redirectTo, redirectParams);
-//                 return false;
-//             }
-//             if (requiredClaims.length > 0) {
-//                 const userClaims = await firekitUser.user?.getIdTokenResult();
-//                 const hasClaims = await this.validateClaims(requiredClaims, userClaims?.claims);
-//                 if (!hasClaims) {
-//                     await this.handleRedirect(redirectTo, redirectParams);
-//                     return false;
-//                 }
-//             }
-//             if (requiredData && !requiredData(firekitUser.data)) {
-//                 await this.handleRedirect(redirectTo, redirectParams);
-//                 return false;
-//             }
-//             return true;
-//         } catch (error) {
-//             this._error = error instanceof Error ? error : new Error(String(error));
-//             return false;
-//         } finally {
-//             this._loading = false;
-//         }
-//     }
-//     async requireAuth(redirectTo = '/login', redirectParams?: Record<string, string>) {
-//         return this.validateAuth({ authRequired: true, redirectTo, redirectParams });
-//     }
-//     async requireNoAuth(redirectTo = '/dashboard', redirectParams?: Record<string, string>) {
-//         return this.validateAuth({ authRequired: false, redirectTo, redirectParams });
-//     }
-//     async requireClaims(claims: string[], redirectTo = '/login', redirectParams?: Record<string, string>) {
-//         return this.validateAuth({ requiredClaims: claims, redirectTo, redirectParams });
-//     }
-//     async requireData(
-//         validator: (data: DocumentData | null) => boolean,
-//         redirectTo = '/login',
-//         redirectParams?: Record<string, string>
-//     ) {
-//         return this.validateAuth({ requiredData: validator, redirectTo, redirectParams });
-//     }
-//     get loading() {
-//         return this._loading;
-//     }
-//     get error() {
-//         return this._error;
-//     }
-// }
-// export const firekitAuthGuard = FirekitAuthGuard.getInstance();

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

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

package/dist/firebase/auth/user.svelte.js

@@ -1,177 +0,0 @@
-"use strict";
-// import { browser } from "$app/environment";
-// import { firebaseService } from "../firebase.js";
-// import {
-//   onAuthStateChanged,
-//   updateCurrentUser,
-//   updateEmail,
-//   updatePassword,
-//   updatePhoneNumber,
-//   updateProfile,
-//   type User,
-// } from "firebase/auth";
-// import {
-//   doc,
-//   getDoc,
-//   setDoc,
-//   updateDoc,
-//   type DocumentData,
-// } from "firebase/firestore";
-// import { toast } from "svelte-sonner";
-// import { firekitAuth } from "./auth.js";
-// interface UserClaims {
-//   [key: string]: any;
-//   admin?: boolean;
-//   premium?: boolean;
-// }
-// interface UserData extends DocumentData {
-//   displayName?: string;
-//   email?: string;
-//   photoURL?: string;
-//   createdAt?: Date;
-//   updatedAt?: Date;
-//   isProfileComplete?: boolean;
-//   role?: string;
-//   settings?: Record<string, any>;
-//   [key: string]: any;
-// }
-// export class FirekitUser {
-//   private static instance: FirekitUser;
-//   private _user: User | null | undefined = $state();
-//   private _userData: UserData | null = $state(null);
-//   private _claims: UserClaims = $state({});
-//   private _initialized = $state(false);
-//   readonly isLoggedIn = $derived(Boolean(this._user));
-//   readonly uid = $derived(this._user?.uid);
-//   readonly email = $derived(this._user?.email);
-//   readonly displayName = $derived(this._user?.displayName);
-//   readonly photoURL = $derived(this._user?.photoURL);
-//   readonly emailVerified = $derived(this._user?.emailVerified);
-//   readonly claims = $derived(this._claims);
-//   readonly data = $derived(this._userData);
-//   readonly initialized = $derived(this._initialized);
-//   private _initPromise: Promise<void> | null = null;
-//   constructor() {
-//     if (browser) {
-//       // Add this check
-//       this.initialize();
-//     }
-//   }
-//   private async initialize(): Promise<void> {
-//     if (this._initialized) return;
-//     return new Promise((resolve) => {
-//       onAuthStateChanged(firebaseService.getAuthInstance(), async (user) => {
-//         this._user = user;
-//         if (user) {
-//           await Promise.all([this.loadUserData(), this.loadUserClaims()]);
-//         } else {
-//           this._userData = null;
-//           this._claims = {};
-//         }
-//         this._initialized = true;
-//         resolve();
-//       });
-//     });
-//   }
-//   async waitForInit(): Promise<void> {
-//     if (this._initialized) return;
-//     return this._initPromise || Promise.resolve();
-//   }
-//   static getInstance(): FirekitUser {
-//     if (!FirekitUser.instance) {
-//       FirekitUser.instance = new FirekitUser();
-//     }
-//     return FirekitUser.instance;
-//   }
-//   private async loadUserData() {
-//     if (!this._user?.uid) return;
-//     const docRef = doc(firebaseService.getDb(), "users", this._user.uid);
-//     const docSnap = await getDoc(docRef);
-//     if (docSnap.exists()) {
-//       this._userData = docSnap.data() as UserData;
-//     } else {
-//       // Initialize user document if it doesn't exist
-//       const initialData: UserData = {
-//         displayName: this._user.displayName || "",
-//         email: this._user.email || "",
-//         photoURL: this._user.photoURL || "",
-//         createdAt: new Date(),
-//         updatedAt: new Date(),
-//         isProfileComplete: false,
-//       };
-//       await this.saveUserData(initialData);
-//     }
-//   }
-//   private async loadUserClaims() {
-//     if (!this._user) return;
-//     const tokenResult = await this._user.getIdTokenResult();
-//     this._claims = tokenResult.claims as UserClaims;
-//   }
-//   get user(): User | null | undefined {
-//     return this._user;
-//   }
-//   async updateEmailUser(email: string) {
-//     let message: string = "";
-//     if (!this._user) throw new Error("No authenticated user");
-//     try {
-//       await updateEmail(this._user, email);
-//       await this.updateUserData({ email });
-//       toast.success("Email updated successfully!", {
-//         description:
-//           "Please note that you will be logged out, and you will need to log in again using your new email address.",
-//       });
-//       setTimeout(async () => {
-//         await firekitAuth.logOut();
-//       }, 4500);
-//     } catch (error) {
-//       toast.error(error.message);
-//     }
-//   }
-//   async updatePassword(password: string) {
-//     if (!this._user) throw new Error("No authenticated user");
-//     await updatePassword(this._user, password);
-//   }
-//   async updateProfileInfo({
-//     displayName,
-//     photoURL,
-//   }: {
-//     displayName?: string;
-//     photoURL?: string;
-//   }) {
-//     if (!this._user) throw new Error("No authenticated user");
-//     if (!displayName && !photoURL) return;
-//     if (displayName) await updateProfile(this._user, { displayName });
-//     if (photoURL) await updateProfile(this._user, { photoURL });
-//   }
-//   async updateUserData(data: Partial<UserData>) {
-//     if (!this._user?.uid) throw new Error("No authenticated user");
-//     const docRef = doc(firebaseService.getDb(), "users", this._user.uid);
-//     const updateData = {
-//       ...data,
-//       updatedAt: new Date(),
-//     };
-//     await updateDoc(docRef, updateData);
-//     await this.loadUserData(); // Reload user data
-//   }
-//   async saveUserData(data: UserData) {
-//     if (!this._user?.uid) throw new Error("No authenticated user");
-//     const docRef = doc(firebaseService.getDb(), "users", this._user.uid);
-//     const saveData = {
-//       ...data,
-//       createdAt: data.createdAt || new Date(),
-//       updatedAt: new Date(),
-//     };
-//     await setDoc(docRef, saveData);
-//     await this.loadUserData(); // Reload user data
-//   }
-//   hasRequiredClaims(requiredClaims: string[]): boolean {
-//     return requiredClaims.every((claim) => this._claims[claim]);
-//   }
-//   isAdmin(): boolean {
-//     return Boolean(this._claims.admin);
-//   }
-//   isPremium(): boolean {
-//     return Boolean(this._claims.premium);
-//   }
-// }
-// export const firekitUser = FirekitUser.getInstance();