svelte-firekit 0.0.1 → 0.0.2

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

@@ -0,0 +1,21 @@
+declare class FirekitAuth {
+    private static instance;
+    private auth;
+    private firestore;
+    private constructor();
+    static getInstance(): FirekitAuth;
+    signInWithGoogle(): Promise<void>;
+    signInWithEmail(email: string, password: string): Promise<void>;
+    registerWithEmail(email: string, password: string, displayName: string): Promise<void>;
+    private updateUserInFirestore;
+    logOut(): Promise<void>;
+    sendPasswordReset(email: string): Promise<void>;
+    sendEmailVerificationToUser(): Promise<void>;
+    updateUserProfile(profile: {
+        displayName?: string;
+        photoURL?: string;
+    }): Promise<void>;
+    updateUserPassword(newPassword: string): Promise<void>;
+}
+export declare const firekitAuth: FirekitAuth;
+export {};

package/dist/firebase/auth/auth.js

@@ -0,0 +1,71 @@
+import { GoogleAuthProvider, sendPasswordResetEmail, signInWithEmailAndPassword, signInWithPopup, signOut, createUserWithEmailAndPassword, sendEmailVerification, updateProfile, updatePassword } from 'firebase/auth';
+import { doc, setDoc } from 'firebase/firestore';
+import { firebaseService } from '../firebase.js';
+class FirekitAuth {
+    static instance;
+    auth = firebaseService.getAuthInstance();
+    firestore = firebaseService.getDb();
+    constructor() { }
+    static getInstance() {
+        if (!FirekitAuth.instance) {
+            FirekitAuth.instance = new FirekitAuth();
+        }
+        return FirekitAuth.instance;
+    }
+    async signInWithGoogle() {
+        const provider = new GoogleAuthProvider();
+        const result = await signInWithPopup(this.auth, provider);
+        await this.updateUserInFirestore(result.user);
+    }
+    async signInWithEmail(email, password) {
+        const result = await signInWithEmailAndPassword(this.auth, email, password);
+        await this.updateUserInFirestore(result.user);
+    }
+    async registerWithEmail(email, password, displayName) {
+        const result = await createUserWithEmailAndPassword(this.auth, email, password);
+        const user = result.user;
+        if (user) {
+            await updateProfile(user, { displayName });
+            await this.updateUserInFirestore(user);
+            await sendEmailVerification(user);
+        }
+    }
+    async updateUserInFirestore(user) {
+        const ref = doc(this.firestore, 'users', user.uid);
+        const userData = {
+            uid: user.uid,
+            email: user.email,
+            emailVerified: user.emailVerified,
+            displayName: user.displayName,
+            photoURL: user.photoURL,
+            isAnonymous: user.isAnonymous,
+            providerId: user.providerId,
+            phoneNumber: user.phoneNumber,
+            providerData: user.providerData
+        };
+        await setDoc(ref, userData, { merge: true });
+    }
+    async logOut() {
+        await signOut(this.auth);
+    }
+    async sendPasswordReset(email) {
+        await sendPasswordResetEmail(this.auth, email);
+    }
+    async sendEmailVerificationToUser() {
+        if (this.auth.currentUser) {
+            await sendEmailVerification(this.auth.currentUser);
+        }
+    }
+    async updateUserProfile(profile) {
+        if (this.auth.currentUser) {
+            await updateProfile(this.auth.currentUser, profile);
+            await this.updateUserInFirestore(this.auth.currentUser);
+        }
+    }
+    async updateUserPassword(newPassword) {
+        if (this.auth.currentUser) {
+            await updatePassword(this.auth.currentUser, newPassword);
+        }
+    }
+}
+export const firekitAuth = FirekitAuth.getInstance();

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

@@ -0,0 +1,50 @@
+import { type User } from "firebase/auth";
+import { type DocumentData } from 'firebase/firestore';
+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 declare class FirekitUser {
+    private static instance;
+    private _user;
+    private _userData;
+    private _claims;
+    readonly isLoggedIn: boolean;
+    readonly uid: string | undefined;
+    readonly email: string | null | undefined;
+    readonly displayName: string | null | undefined;
+    readonly photoURL: string | null | undefined;
+    readonly emailVerified: boolean | undefined;
+    readonly claims: UserClaims;
+    readonly data: UserData | null;
+    constructor();
+    static getInstance(): FirekitUser;
+    private loadUserData;
+    private loadUserClaims;
+    get user(): User | null | undefined;
+    updateEmail(email: string): Promise<void>;
+    updatePassword(password: string): Promise<void>;
+    updateProfile({ displayName, photoURL }: {
+        displayName?: string;
+        photoURL?: string;
+    }): Promise<void>;
+    updateUserData(data: Partial<UserData>): Promise<void>;
+    saveUserData(data: UserData): Promise<void>;
+    hasRequiredClaims(requiredClaims: string[]): boolean;
+    isAdmin(): boolean;
+    isPremium(): boolean;
+}
+export declare const firekitUser: FirekitUser;
+export {};

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

@@ -0,0 +1,115 @@
+import { firebaseService } from '../firebase.js';
+import { onAuthStateChanged, updateCurrentUser, updateEmail, updatePassword } from "firebase/auth";
+import { doc, getDoc, setDoc, updateDoc } from 'firebase/firestore';
+export class FirekitUser {
+    static instance;
+    _user = $state();
+    _userData = $state(null);
+    _claims = $state({});
+    isLoggedIn = $derived(Boolean(this._user));
+    uid = $derived(this._user?.uid);
+    email = $derived(this._user?.email);
+    displayName = $derived(this._user?.displayName);
+    photoURL = $derived(this._user?.photoURL);
+    emailVerified = $derived(this._user?.emailVerified);
+    claims = $derived(this._claims);
+    data = $derived(this._userData);
+    constructor() {
+        onAuthStateChanged(firebaseService.getAuthInstance(), async (user) => {
+            this._user = user;
+            if (user) {
+                await Promise.all([
+                    this.loadUserData(),
+                    this.loadUserClaims()
+                ]);
+            }
+            else {
+                this._userData = null;
+                this._claims = {};
+            }
+        });
+    }
+    static getInstance() {
+        if (!FirekitUser.instance) {
+            FirekitUser.instance = new FirekitUser();
+        }
+        return FirekitUser.instance;
+    }
+    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();
+        }
+        else {
+            // Initialize user document if it doesn't exist
+            const initialData = {
+                displayName: this._user.displayName || '',
+                email: this._user.email || '',
+                photoURL: this._user.photoURL || '',
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                isProfileComplete: false
+            };
+            await this.saveUserData(initialData);
+        }
+    }
+    async loadUserClaims() {
+        if (!this._user)
+            return;
+        const tokenResult = await this._user.getIdTokenResult();
+        this._claims = tokenResult.claims;
+    }
+    get user() {
+        return this._user;
+    }
+    async updateEmail(email) {
+        if (!this._user)
+            throw new Error('No authenticated user');
+        await updateEmail(this._user, email);
+    }
+    async updatePassword(password) {
+        if (!this._user)
+            throw new Error('No authenticated user');
+        await updatePassword(this._user, password);
+    }
+    async updateProfile({ displayName, photoURL }) {
+        if (!this._user)
+            throw new Error('No authenticated user');
+    }
+    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(); // Reload user data
+    }
+    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(); // Reload user data
+    }
+    hasRequiredClaims(requiredClaims) {
+        return requiredClaims.every(claim => this._claims[claim]);
+    }
+    isAdmin() {
+        return Boolean(this._claims.admin);
+    }
+    isPremium() {
+        return Boolean(this._claims.premium);
+    }
+}
+export const firekitUser = new FirekitUser();

package/dist/firebase/config.js

@@ -0,0 +1,44 @@
+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';
+class FirebaseConfig {
+    static instance;
+    config;
+    constructor() {
+        const missingVars = this.getMissingFirebaseConfigVars();
+        if (missingVars.length > 0) {
+            throw Error(`The following Firebase configuration variables are missing: ${missingVars.join(', ')}`);
+        }
+        this.config = {
+            apiKey: PUBLIC_FIREBASE_API_KEY,
+            authDomain: PUBLIC_FIREBASE_AUTH_DOMAIN,
+            projectId: PUBLIC_FIREBASE_PROJECT_ID,
+            storageBucket: PUBLIC_FIREBASE_STORAGE_BUCKET,
+            messagingSenderId: PUBLIC_FIREBASE_MESSAGING_SENDER_ID,
+            appId: PUBLIC_FIREBASE_APP_ID,
+            measurementId: PUBLIC_FIREBASE_MEASUREMENT_ID
+        };
+    }
+    getMissingFirebaseConfigVars() {
+        const requiredVars = {
+            'PUBLIC_FIREBASE_API_KEY': PUBLIC_FIREBASE_API_KEY,
+            'PUBLIC_FIREBASE_AUTH_DOMAIN': PUBLIC_FIREBASE_AUTH_DOMAIN,
+            'PUBLIC_FIREBASE_PROJECT_ID': PUBLIC_FIREBASE_PROJECT_ID,
+            'PUBLIC_FIREBASE_STORAGE_BUCKET': PUBLIC_FIREBASE_STORAGE_BUCKET,
+            'PUBLIC_FIREBASE_MESSAGING_SENDER_ID': PUBLIC_FIREBASE_MESSAGING_SENDER_ID,
+            'PUBLIC_FIREBASE_APP_ID': PUBLIC_FIREBASE_APP_ID,
+            'PUBLIC_FIREBASE_MEASUREMENT_ID': PUBLIC_FIREBASE_MEASUREMENT_ID
+        };
+        return Object.entries(requiredVars)
+            .filter(([_, value]) => !value)
+            .map(([key]) => key);
+    }
+    static getInstance() {
+        if (!FirebaseConfig.instance) {
+            FirebaseConfig.instance = new FirebaseConfig();
+        }
+        return FirebaseConfig.instance;
+    }
+    getConfig() {
+        return this.config;
+    }
+}
+export const firebaseConfig = FirebaseConfig.getInstance().getConfig();

package/dist/firebase/firebase.d.ts

@@ -0,0 +1,28 @@
+import { type FirebaseApp } from 'firebase/app';
+import { type Firestore } from 'firebase/firestore';
+import { type Auth } from 'firebase/auth';
+import { type Functions } from 'firebase/functions';
+import { type Database } from 'firebase/database';
+import { type FirebaseStorage } from 'firebase/storage';
+declare class FirebaseService {
+    private static instance;
+    private firebaseApp;
+    private db;
+    private auth;
+    private functions;
+    private database;
+    private storage;
+    private readonly isBrowser;
+    private constructor();
+    static getInstance(): FirebaseService;
+    getFirebaseApp(): FirebaseApp;
+    private initializeFirestoreInstance;
+    getDb(): Firestore;
+    getAuthInstance(): Auth;
+    getFunctionsInstance(): Functions;
+    getDatabaseInstance(): Database;
+    getStorageInstance(): FirebaseStorage;
+    getBatch(): import("@firebase/firestore").WriteBatch;
+}
+export declare const firebaseService: FirebaseService;
+export {};

package/dist/firebase/firebase.js

@@ -0,0 +1,86 @@
+import { initializeApp, getApps } from 'firebase/app';
+import { initializeFirestore, CACHE_SIZE_UNLIMITED, persistentLocalCache, persistentMultipleTabManager, enablePersistentCacheIndexAutoCreation, getPersistentCacheIndexManager, writeBatch } 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';
+class FirebaseService {
+    static instance;
+    firebaseApp = null;
+    db = null;
+    auth = null;
+    functions = null;
+    database = null;
+    storage = null;
+    isBrowser = typeof window !== 'undefined';
+    constructor() {
+    }
+    static getInstance() {
+        if (!FirebaseService.instance) {
+            FirebaseService.instance = new FirebaseService();
+        }
+        return FirebaseService.instance;
+    }
+    getFirebaseApp() {
+        if (this.firebaseApp)
+            return this.firebaseApp;
+        const existingApps = getApps();
+        if (existingApps.length) {
+            this.firebaseApp = existingApps[0];
+        }
+        else {
+            this.firebaseApp = initializeApp(firebaseConfig);
+            console.log(`${firebaseConfig.projectId} initialized on ${this.isBrowser ? 'client' : 'server'}`);
+        }
+        this.initializeFirestoreInstance();
+        return this.firebaseApp;
+    }
+    initializeFirestoreInstance() {
+        if (this.db || !this.isBrowser)
+            return;
+        this.db = initializeFirestore(this.firebaseApp, {
+            localCache: persistentLocalCache({
+                cacheSizeBytes: CACHE_SIZE_UNLIMITED,
+                tabManager: persistentMultipleTabManager()
+            }),
+        });
+        const indexManager = getPersistentCacheIndexManager(this.db);
+        if (indexManager) {
+            enablePersistentCacheIndexAutoCreation(indexManager);
+            console.log('Firestore persistent cache indexing is enabled');
+        }
+        else {
+            console.warn('Failed to initialize the Firestore cache index manager');
+        }
+    }
+    getDb() {
+        if (!this.db)
+            this.getFirebaseApp();
+        return this.db;
+    }
+    getAuthInstance() {
+        if (!this.auth)
+            this.auth = getAuth(this.getFirebaseApp());
+        return this.auth;
+    }
+    getFunctionsInstance() {
+        if (!this.functions)
+            this.functions = getFunctions(this.getFirebaseApp());
+        return this.functions;
+    }
+    getDatabaseInstance() {
+        if (!this.database)
+            this.database = getDatabase(this.getFirebaseApp());
+        return this.database;
+    }
+    getStorageInstance() {
+        if (!this.storage)
+            this.storage = getStorage(this.getFirebaseApp());
+        return this.storage;
+    }
+    getBatch() {
+        return writeBatch(this.getDb());
+    }
+}
+export const firebaseService = FirebaseService.getInstance();

package/dist/firebase/firestore/awaitable-doc.svelte.d.ts

@@ -0,0 +1,15 @@
+import { type DocumentReference, type DocumentData } from "firebase/firestore";
+declare class FirekitAwaitableDoc<T> {
+    private _data;
+    private _loading;
+    private _error;
+    private docRef;
+    constructor(ref: string | DocumentReference<T>, startWith?: T);
+    private initializeDoc;
+    getData(): Promise<T | null>;
+    get data(): T | null;
+    get loading(): boolean;
+    get error(): Error | null;
+}
+export declare function firekitAwaitableDoc<T extends DocumentData>(path: string, startWith?: T): FirekitAwaitableDoc<T>;
+export {};

package/dist/firebase/firestore/awaitable-doc.svelte.js

@@ -0,0 +1,57 @@
+import { doc, getDoc, onSnapshot } from "firebase/firestore";
+import { firebaseService } from "../firebase.js";
+import { browser } from "$app/environment";
+class FirekitAwaitableDoc {
+    _data = $state(null);
+    _loading = $state(true);
+    _error = $state(null);
+    docRef = null;
+    constructor(ref, startWith) {
+        this._data = startWith ?? null;
+        if (browser) {
+            this.initializeDoc(ref);
+        }
+    }
+    async initializeDoc(ref) {
+        try {
+            const firestore = firebaseService.getDb();
+            this.docRef = typeof ref === "string"
+                ? doc(firestore, ref)
+                : ref;
+            // Initial fetch
+            const snapshot = await getDoc(this.docRef);
+            this._data = snapshot.exists() ? { id: snapshot.id, ...snapshot.data() } : null;
+            // Setup real-time updates
+            onSnapshot(this.docRef, (snapshot) => {
+                this._data = snapshot.exists() ? { id: snapshot.id, ...snapshot.data() } : null;
+                this._loading = false;
+                this._error = null;
+            }, (error) => {
+                this._error = error;
+                this._loading = false;
+            });
+        }
+        catch (error) {
+            this._error = error;
+            this._loading = false;
+        }
+    }
+    async getData() {
+        if (!this.docRef)
+            return null;
+        const snapshot = await getDoc(this.docRef);
+        return snapshot.exists() ? { id: snapshot.id, ...snapshot.data() } : null;
+    }
+    get data() {
+        return this._data;
+    }
+    get loading() {
+        return this._loading;
+    }
+    get error() {
+        return this._error;
+    }
+}
+export function firekitAwaitableDoc(path, startWith) {
+    return new FirekitAwaitableDoc(path, startWith);
+}

package/dist/firebase/firestore/collection.svelte.d.ts

@@ -0,0 +1,17 @@
+import { type CollectionReference, type DocumentData, type QueryConstraint } from "firebase/firestore";
+declare class FirekitCollection<T> {
+    private _data;
+    private _loading;
+    private _error;
+    private colRef;
+    private queryRef;
+    constructor(path: string, ...queryConstraints: QueryConstraint[]);
+    get data(): T[];
+    get loading(): boolean;
+    get error(): Error | null;
+    get empty(): boolean;
+    get size(): number;
+    get ref(): CollectionReference<T, DocumentData>;
+}
+export declare function firekitCollection<T extends DocumentData>(path: string, ...queryConstraints: QueryConstraint[]): FirekitCollection<T>;
+export {};

package/dist/firebase/firestore/collection.svelte.js

@@ -0,0 +1,58 @@
+import { collection, query, onSnapshot } from "firebase/firestore";
+import { firebaseService } from "../firebase.js";
+import { browser } from "$app/environment";
+class FirekitCollection {
+    _data = $state([]);
+    _loading = $state(true);
+    _error = $state(null);
+    colRef = null;
+    queryRef = null;
+    constructor(path, ...queryConstraints) {
+        if (browser) {
+            try {
+                const firestore = firebaseService.getDb();
+                this.colRef = collection(firestore, path);
+                this.queryRef = query(this.colRef, ...queryConstraints);
+                onSnapshot(this.queryRef, (snapshot) => {
+                    this._data = snapshot.docs.map(doc => ({
+                        id: doc.id,
+                        ...doc.data()
+                    }));
+                    this._loading = false;
+                    this._error = null;
+                }, (error) => {
+                    this._error = error;
+                    this._loading = false;
+                });
+            }
+            catch (error) {
+                this._error = error;
+                this._loading = false;
+            }
+        }
+    }
+    get data() {
+        return this._data;
+    }
+    get loading() {
+        return this._loading;
+    }
+    get error() {
+        return this._error;
+    }
+    get empty() {
+        return this._data.length === 0;
+    }
+    get size() {
+        return this._data.length;
+    }
+    get ref() {
+        if (!this.colRef) {
+            throw new Error("Collection reference is not available");
+        }
+        return this.colRef;
+    }
+}
+export function firekitCollection(path, ...queryConstraints) {
+    return new FirekitCollection(path, ...queryConstraints);
+}

package/dist/firebase/firestore/doc.svelte.d.ts

@@ -0,0 +1,16 @@
+import { DocumentReference } from "firebase/firestore";
+declare class FirekitDoc<T> {
+    private _data;
+    private _loading;
+    private _error;
+    private docRef;
+    constructor(ref: string | DocumentReference<T>, startWith?: T);
+    get data(): T | null;
+    get id(): string;
+    get loading(): boolean;
+    get error(): Error | null;
+    get ref(): DocumentReference<T, import("@firebase/firestore").DocumentData>;
+    get exists(): boolean;
+}
+export declare function firekitDoc<T>(ref: string | DocumentReference<T>, startWith?: T): FirekitDoc<T>;
+export {};

package/dist/firebase/firestore/doc.svelte.js

@@ -0,0 +1,56 @@
+import { doc, DocumentReference, onSnapshot } from "firebase/firestore";
+import { firebaseService } from "../firebase.js";
+import { browser } from "$app/environment";
+class FirekitDoc {
+    _data = $state(null);
+    _loading = $state(true);
+    _error = $state(null);
+    docRef = null;
+    constructor(ref, startWith) {
+        this._data = startWith ?? null;
+        if (browser) {
+            try {
+                const firestore = firebaseService.getDb();
+                this.docRef = typeof ref === "string"
+                    ? doc(firestore, ref)
+                    : ref;
+                onSnapshot(this.docRef, (snapshot) => {
+                    this._data = snapshot.data() ?? null;
+                    this._loading = false;
+                    this._error = null;
+                }, (error) => {
+                    this._error = error;
+                    this._loading = false;
+                });
+            }
+            catch (error) {
+                this._error = error;
+                this._loading = false;
+            }
+        }
+    }
+    get data() {
+        return this._data;
+    }
+    get id() {
+        return this.docRef?.id ?? '';
+    }
+    get loading() {
+        return this._loading;
+    }
+    get error() {
+        return this._error;
+    }
+    get ref() {
+        if (this.docRef === null) {
+            throw new Error("Document reference is not available yet.");
+        }
+        return this.docRef;
+    }
+    get exists() {
+        return this._data !== null;
+    }
+}
+export function firekitDoc(ref, startWith) {
+    return new FirekitDoc(ref, startWith);
+}

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

@@ -0,0 +1,18 @@
+import { type DocumentData, type WithFieldValue, type PartialWithFieldValue } from "firebase/firestore";
+declare class FirekitDocumentMutations {
+    constructor();
+    add<T extends DocumentData>(collectionPath: string, data: WithFieldValue<T>, options?: {
+        timestamps?: boolean;
+    }): Promise<import("@firebase/firestore").DocumentReference<DocumentData, DocumentData>>;
+    set<T extends DocumentData>(path: string, data: WithFieldValue<T>, options?: {
+        merge?: boolean;
+        timestamps?: boolean;
+    }): Promise<void>;
+    update<T extends DocumentData>(path: string, data: PartialWithFieldValue<T>, options?: {
+        timestamps?: boolean;
+    }): Promise<void>;
+    delete(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+}
+export declare const firekitDocMutations: FirekitDocumentMutations;
+export {};