svelte-firekit 0.0.18 → 0.0.20

package/dist/auth/auth.d.ts

@@ -4,7 +4,6 @@ declare class FirekitAuth {
     private firestore;
     private constructor();
     static getInstance(): FirekitAuth;
-    getDeviceIdentifier(): string;
     signInWithGoogle(): Promise<void>;
     signInWithEmail(email: string, password: string): Promise<void>;
     registerWithEmail(email: string, password: string, displayName: string): Promise<void>;
@@ -30,7 +29,6 @@ declare class FirekitAuth {
         success: boolean;
         message: string;
     }>;
-    updateUserSession(user: any): Promise<void>;
 }
 export declare const firekitAuth: FirekitAuth;
 export {};

package/dist/auth/auth.js

@@ -14,19 +14,14 @@ class FirekitAuth {
         }
         return FirekitAuth.instance;
     }
-    getDeviceIdentifier() {
-        return navigator.userAgent; // Puedes personalizar esto según tu preferencia.
-    }
     async signInWithGoogle() {
         const provider = new GoogleAuthProvider();
         const result = await signInWithPopup(this.auth, provider);
         await this.updateUserInFirestore(result.user);
-        await this.updateUserSession(result.user);
     }
     async signInWithEmail(email, password) {
         const result = await signInWithEmailAndPassword(this.auth, email, password);
         await this.updateUserInFirestore(result.user);
-        await this.updateUserSession(result.user);
     }
     async registerWithEmail(email, password, displayName) {
         const result = await createUserWithEmailAndPassword(this.auth, email, password);
@@ -34,7 +29,6 @@ class FirekitAuth {
         if (user) {
             await updateProfile(user, { displayName });
             await this.updateUserInFirestore(user);
-            await this.updateUserSession(user);
             await sendEmailVerification(user);
         }
     }
@@ -110,30 +104,5 @@ class FirekitAuth {
             throw new Error(error.message);
         }
     }
-    async updateUserSession(user) {
-        let nav = this.getDeviceIdentifier().replace(/[ /]/g, '');
-        const sessionId = `${user.uid}_${nav}`;
-        const db = firebaseService.getDatabaseInstance();
-        const userSessionsRef = ref(db, `sessions/${user.uid}`);
-        const userSessionsSnap = await get(userSessionsRef);
-        let sessionDatas = [];
-        if (userSessionsSnap.exists()) {
-            sessionDatas = userSessionsSnap.val().sessionDatas || [];
-            if (sessionDatas.some(session => session.uid === sessionId)) {
-                console.log('Session already registered from this device.');
-                return;
-            }
-        }
-        const newSessionData = {
-            uid: sessionId,
-            userId: user.uid,
-            device: this.getDeviceIdentifier(),
-            createdAt: new Date().toISOString(),
-            last_changed: new Date().toISOString(),
-            status: "online"
-        };
-        sessionDatas.push(newSessionData);
-        await set(userSessionsRef, { sessionDatas });
-    }
 }
 export const firekitAuth = FirekitAuth.getInstance();

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

@@ -0,0 +1,74 @@
+interface GeolocationConfig {
+    enabled: boolean;
+    type: 'browser' | 'ip' | 'custom';
+    customGeolocationFn?: () => Promise<{
+        latitude: number;
+        longitude: number;
+    }>;
+    ipServiceUrl?: string;
+    requireConsent?: boolean;
+}
+interface PresenceConfig {
+    geolocation?: GeolocationConfig;
+    sessionTTL?: number;
+    updateInterval?: number;
+}
+interface Location {
+    latitude: number | null;
+    longitude: number | null;
+    lastUpdated: string | null;
+}
+interface SessionData {
+    uid: string;
+    userId: string;
+    deviceId: string;
+    status: 'online' | 'offline' | 'away';
+    createdAt: string;
+    lastSeen: string;
+    location?: Location;
+}
+type PresenceEvent = {
+    type: 'status_change' | 'error' | 'init' | 'disconnect' | 'location_update';
+    data?: any;
+    error?: Error;
+    timestamp: number;
+};
+type PresenceEventCallback = (event: PresenceEvent) => void;
+declare class PresenceService {
+    private static instance;
+    private connectedListener;
+    private locationWatcher;
+    private currentUser;
+    private eventListeners;
+    private config;
+    private initialized;
+    private locationConsent;
+    private _currentSession;
+    private _sessions;
+    private _status;
+    private _loading;
+    private _error;
+    private constructor();
+    static getInstance(): PresenceService;
+    get currentSession(): SessionData | null;
+    get sessions(): SessionData[];
+    get status(): "online" | "offline" | "away";
+    get loading(): boolean;
+    get error(): Error | null;
+    get isInitialized(): boolean;
+    get hasLocationConsent(): boolean;
+    private initializePresence;
+    private setupVisibilityListener;
+    private getDeviceInfo;
+    requestLocationConsent(): Promise<boolean>;
+    private getLocation;
+    initialize(user: any, config?: PresenceConfig): Promise<void>;
+    private setPresence;
+    private startLocationWatcher;
+    private stopLocationWatcher;
+    addEventListener(callback: PresenceEventCallback): () => boolean;
+    private emitEvent;
+    dispose(): void;
+}
+export declare const presenceService: PresenceService;
+export {};

package/dist/auth/presence.svelte.js

@@ -0,0 +1,331 @@
+import { ref, onDisconnect, onValue, get, set } from 'firebase/database';
+import { firebaseService } from '../firebase.js';
+import { browser } from '$app/environment';
+class PresenceService {
+    static instance;
+    connectedListener = null;
+    locationWatcher = null;
+    currentUser = null;
+    eventListeners = new Set();
+    config = {
+        geolocation: {
+            enabled: false,
+            type: 'browser',
+            requireConsent: true
+        },
+        sessionTTL: 30 * 60 * 1000, // 30 minutes
+        updateInterval: 60 * 1000 // 1 minute
+    };
+    initialized = $state(false);
+    locationConsent = $state(false);
+    _currentSession = $state(null);
+    _sessions = $state([]);
+    _status = $state('offline');
+    _loading = $state(true);
+    _error = $state(null);
+    constructor() {
+        if (browser) {
+            this.setupVisibilityListener();
+        }
+    }
+    static getInstance() {
+        if (!PresenceService.instance) {
+            PresenceService.instance = new PresenceService();
+        }
+        return PresenceService.instance;
+    }
+    // Getters
+    get currentSession() { return this._currentSession; }
+    get sessions() { return this._sessions; }
+    get status() { return this._status; }
+    get loading() { return this._loading; }
+    get error() { return this._error; }
+    get isInitialized() { return this.initialized; }
+    get hasLocationConsent() { return this.locationConsent; }
+    async initializePresence() {
+        const connectedRef = ref(firebaseService.getDatabaseInstance(), '.info/connected');
+        this.connectedListener = onValue(connectedRef, async (snapshot) => {
+            if (snapshot.val() === true) {
+                await this.setPresence('online');
+                const userStatusRef = ref(firebaseService.getDatabaseInstance(), `sessions/${this.currentUser.uid}`);
+                // Set up disconnect hook
+                await onDisconnect(userStatusRef).set({
+                    sessionDatas: this._sessions.map(session => ({
+                        ...session,
+                        status: 'offline',
+                        lastSeen: new Date().toISOString()
+                    }))
+                });
+            }
+            else {
+                await this.setPresence('offline');
+            }
+        });
+        // Set up visibility change listener
+        if (browser) {
+            document.onvisibilitychange = async () => {
+                if (document.visibilityState === 'hidden') {
+                    await this.setPresence('away');
+                }
+                else {
+                    await this.setPresence('online');
+                }
+            };
+        }
+    }
+    setupVisibilityListener() {
+        if (browser) {
+            document.onvisibilitychange = async () => {
+                if (this.initialized) {
+                    if (document.visibilityState === 'hidden') {
+                        await this.setPresence('away');
+                    }
+                    else {
+                        await this.setPresence('online');
+                    }
+                }
+            };
+        }
+    }
+    getDeviceInfo() {
+        const userAgent = navigator.userAgent;
+        const platform = navigator.platform;
+        const browserInfo = userAgent.match(/(firefox|chrome|safari|opera|edge|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
+        const browser = browserInfo[1] || 'Unknown Browser';
+        return `${browser}-${platform}`.replace(/[^a-zA-Z0-9-]/g, '');
+    }
+    async requestLocationConsent() {
+        if (!this.config.geolocation?.enabled)
+            return false;
+        try {
+            if (this.config.geolocation.type === 'browser') {
+                const permission = await navigator.permissions.query({ name: 'geolocation' });
+                if (permission.state === 'granted') {
+                    this.locationConsent = true;
+                    return true;
+                }
+                const result = await new Promise((resolve) => {
+                    navigator.geolocation.getCurrentPosition(() => resolve(true), () => resolve(false), { timeout: 10000 });
+                });
+                this.locationConsent = result;
+                return result;
+            }
+            return true;
+        }
+        catch (error) {
+            console.error('Error requesting location consent:', error);
+            return false;
+        }
+    }
+    async getLocation() {
+        if (!this.config.geolocation?.enabled ||
+            (this.config.geolocation.requireConsent && !this.locationConsent)) {
+            return null;
+        }
+        try {
+            switch (this.config.geolocation.type) {
+                case 'browser':
+                    return new Promise((resolve) => {
+                        navigator.geolocation.getCurrentPosition((position) => {
+                            resolve({
+                                latitude: position.coords.latitude,
+                                longitude: position.coords.longitude,
+                                lastUpdated: new Date().toISOString()
+                            });
+                        }, () => resolve(null), { timeout: 10000 });
+                    });
+                case 'custom':
+                    if (this.config.geolocation.customGeolocationFn) {
+                        const result = await this.config.geolocation.customGeolocationFn();
+                        return {
+                            ...result,
+                            lastUpdated: new Date().toISOString()
+                        };
+                    }
+                    return null;
+                case 'ip':
+                    if (this.config.geolocation.ipServiceUrl) {
+                        const response = await fetch(this.config.geolocation.ipServiceUrl);
+                        const data = await response.json();
+                        return {
+                            latitude: data.latitude,
+                            longitude: data.longitude,
+                            lastUpdated: new Date().toISOString()
+                        };
+                    }
+                    return null;
+                default:
+                    return null;
+            }
+        }
+        catch (error) {
+            console.error('Error getting location:', error);
+            return null;
+        }
+    }
+    async initialize(user, config) {
+        try {
+            if (!browser) {
+                throw new Error('Presence service can only be initialized in browser environment');
+            }
+            if (this.initialized) {
+                console.warn('Presence service is already initialized');
+                return;
+            }
+            this._loading = true;
+            this.currentUser = user;
+            this.config = { ...this.config, ...config };
+            // If geolocation is enabled and requires consent, request it
+            if (this.config.geolocation?.enabled && this.config.geolocation.requireConsent) {
+                await this.requestLocationConsent();
+            }
+            await this.initializePresence();
+            this.initialized = true;
+            // Start location watcher if enabled and has consent
+            if (this.config.geolocation?.enabled &&
+                (!this.config.geolocation.requireConsent || this.locationConsent)) {
+                this.startLocationWatcher();
+            }
+            this.emitEvent({
+                type: 'init',
+                data: { userId: user.uid },
+                timestamp: Date.now()
+            });
+        }
+        catch (error) {
+            this._error = error;
+            this.emitEvent({
+                type: 'error',
+                error: error,
+                timestamp: Date.now()
+            });
+            throw error;
+        }
+        finally {
+            this._loading = false;
+        }
+    }
+    async setPresence(status) {
+        try {
+            if (!this.currentUser) {
+                throw new Error('No authenticated user found');
+            }
+            const db = firebaseService.getDatabaseInstance();
+            const userSessionsRef = ref(db, `sessions/${this.currentUser.uid}`);
+            const deviceId = this.getDeviceInfo();
+            const sessionId = `${this.currentUser.uid}_${deviceId}`;
+            // Get location if enabled
+            const location = await this.getLocation();
+            const userSessionsSnap = await get(userSessionsRef);
+            let sessionDatas = [];
+            if (userSessionsSnap.exists()) {
+                sessionDatas = userSessionsSnap.val().sessionDatas || [];
+                const sessionIndex = sessionDatas.findIndex((session) => session.uid === sessionId);
+                if (sessionIndex !== -1) {
+                    // Update existing session
+                    sessionDatas[sessionIndex] = {
+                        ...sessionDatas[sessionIndex],
+                        status,
+                        lastSeen: new Date().toISOString(),
+                        ...(location && { location })
+                    };
+                }
+                else {
+                    // Create new session
+                    sessionDatas.push({
+                        uid: sessionId,
+                        userId: this.currentUser.uid,
+                        deviceId,
+                        status,
+                        createdAt: new Date().toISOString(),
+                        lastSeen: new Date().toISOString(),
+                        ...(location && { location })
+                    });
+                }
+            }
+            else {
+                // First session for this user
+                sessionDatas = [{
+                        uid: sessionId,
+                        userId: this.currentUser.uid,
+                        deviceId,
+                        status,
+                        createdAt: new Date().toISOString(),
+                        lastSeen: new Date().toISOString(),
+                        ...(location && { location })
+                    }];
+            }
+            // Clean up stale sessions
+            if (this.config.sessionTTL) {
+                const cutoffTime = new Date(Date.now() - this.config.sessionTTL).toISOString();
+                sessionDatas = sessionDatas.filter(session => session.lastSeen >= cutoffTime);
+            }
+            await set(userSessionsRef, { sessionDatas });
+            this._sessions = sessionDatas;
+            this._currentSession = sessionDatas.find(session => session.uid === sessionId) || null;
+            this._status = status;
+            this.emitEvent({
+                type: 'status_change',
+                data: { status, sessionId, location },
+                timestamp: Date.now()
+            });
+        }
+        catch (error) {
+            this._error = error;
+            this.emitEvent({
+                type: 'error',
+                error: error,
+                timestamp: Date.now()
+            });
+            throw error;
+        }
+    }
+    startLocationWatcher() {
+        if (this.locationWatcher)
+            return;
+        const watchLocation = async () => {
+            const location = await this.getLocation();
+            if (location && this._currentSession) {
+                await this.setPresence(this._status);
+                this.emitEvent({
+                    type: 'location_update',
+                    data: { location },
+                    timestamp: Date.now()
+                });
+            }
+        };
+        // Update location periodically
+        this.locationWatcher = window.setInterval(watchLocation, this.config.updateInterval);
+    }
+    stopLocationWatcher() {
+        if (this.locationWatcher) {
+            clearInterval(this.locationWatcher);
+            this.locationWatcher = null;
+        }
+    }
+    addEventListener(callback) {
+        this.eventListeners.add(callback);
+        return () => this.eventListeners.delete(callback);
+    }
+    emitEvent(event) {
+        this.eventListeners.forEach(callback => callback(event));
+    }
+    dispose() {
+        this.stopLocationWatcher();
+        if (this.connectedListener) {
+            this.connectedListener();
+            this.connectedListener = null;
+        }
+        this.initialized = false;
+        this._currentSession = null;
+        this._sessions = [];
+        this._status = 'offline';
+        this._loading = false;
+        this._error = null;
+        this.emitEvent({
+            type: 'disconnect',
+            timestamp: Date.now()
+        });
+    }
+}
+export const presenceService = PresenceService.getInstance();

package/dist/firestore/doc.svelte.js

@@ -15,7 +15,9 @@ class FirekitDoc {
                     ? doc(firestore, ref)
                     : ref;
                 onSnapshot(this.docRef, (snapshot) => {
-                    this._data = snapshot.data() ?? null;
+                    // this._data = (snapshot.data() as T) ?? null;
+                    const data = snapshot.data();
+                    this._data = data ? { ...data, id: snapshot.id } : null;
                     this._loading = false;
                     this._error = null;
                 }, (error) => {

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

@@ -1,18 +1,27 @@
 import { type DocumentData, type WithFieldValue, type PartialWithFieldValue } from "firebase/firestore";
+interface MutationResponse<T> {
+    success: boolean;
+    data?: T;
+    id?: string;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface MutationOptions {
+    timestamps?: boolean;
+    merge?: boolean;
+    customId?: string;
+}
 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<string>;
-    update<T extends DocumentData>(path: string, data: PartialWithFieldValue<T>, options?: {
-        timestamps?: boolean;
-    }): Promise<void>;
-    delete(path: string): Promise<void>;
+    private getTimestampData;
+    private handleError;
+    add<T extends DocumentData>(collectionPath: string, data: WithFieldValue<T>, options?: MutationOptions): Promise<MutationResponse<T>>;
+    set<T extends DocumentData>(path: string, data: WithFieldValue<T>, options?: MutationOptions): Promise<MutationResponse<T>>;
+    update<T extends DocumentData>(path: string, data: PartialWithFieldValue<T>, options?: MutationOptions): Promise<MutationResponse<Partial<T>>>;
+    delete(path: string): Promise<MutationResponse<void>>;
     exists(path: string): Promise<boolean>;
+    getDoc<T extends DocumentData>(path: string): Promise<MutationResponse<T>>;
 }
 export declare const firekitDocMutations: FirekitDocumentMutations;
 export {};

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

@@ -2,62 +2,151 @@ import { addDoc, setDoc, updateDoc, deleteDoc, doc, getDoc, collection, serverTi
 import { firebaseService } from "../firebase.js";
 import { firekitUser } from "../auth/user.svelte.js";
 class FirekitDocumentMutations {
-    constructor() { }
-    async add(collectionPath, data, options = { timestamps: true }) {
-        const firestore = firebaseService.getDbInstance();
-        const colRef = collection(firestore, collectionPath);
-        const dataToAdd = {
-            ...data,
-            ...(options.timestamps && {
-                createdAt: serverTimestamp(),
-                createdBy: firekitUser.uid,
-                updatedAt: serverTimestamp(),
-                updatedBy: firekitUser.uid,
-            }),
+    getTimestampData(isNew = true) {
+        const timestamps = {
+            updatedAt: serverTimestamp(),
+            updatedBy: firekitUser.uid,
         };
-        return addDoc(colRef, dataToAdd);
-    }
-    async set(path, data, options = {
-        merge: false,
-        timestamps: true,
-    }) {
-        const firestore = firebaseService.getDbInstance();
-        const docRef = doc(collection(firestore, path));
-        const dataToSet = {
-            ...data,
-            ...(options.timestamps && {
-                createdAt: serverTimestamp(),
-                createdBy: firekitUser.uid,
-                updatedAt: serverTimestamp(),
-                updatedBy: firekitUser.uid,
-            }),
-            uid: docRef.id,
+        if (isNew) {
+            timestamps.createdAt = serverTimestamp();
+            timestamps.createdBy = firekitUser.uid;
+        }
+        return timestamps;
+    }
+    handleError(error) {
+        console.error('Firestore mutation error:', error);
+        return {
+            success: false,
+            error: {
+                code: error.code || 'unknown_error',
+                message: error.message || 'An unknown error occurred'
+            }
         };
-        await setDoc(docRef, dataToSet, { merge: options.merge });
-        return docRef.id;
+    }
+    async add(collectionPath, data, options = { timestamps: true }) {
+        try {
+            const firestore = firebaseService.getDbInstance();
+            const colRef = collection(firestore, collectionPath);
+            let dataToAdd = {
+                ...data,
+                ...(options.timestamps && this.getTimestampData()),
+            };
+            let docRef;
+            if (options.customId) {
+                docRef = doc(colRef, options.customId);
+                dataToAdd = { ...dataToAdd, id: docRef.id }; // Agregar el id al documento
+                await setDoc(docRef, dataToAdd);
+            }
+            else {
+                docRef = await addDoc(colRef, dataToAdd);
+                dataToAdd = { ...dataToAdd, id: docRef.id }; // Agregar el id al documento
+                await setDoc(docRef, dataToAdd);
+            }
+            return {
+                success: true,
+                id: docRef.id,
+                data: { ...dataToAdd, id: docRef.id }
+            };
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+    async set(path, data, options = { merge: false, timestamps: true }) {
+        try {
+            const firestore = firebaseService.getDbInstance();
+            let docRef;
+            if (path.includes('/')) {
+                docRef = doc(firestore, path);
+            }
+            else {
+                const [collectionPath, documentId] = path.split('/');
+                docRef = doc(collection(firestore, collectionPath), documentId);
+            }
+            const dataToSet = {
+                ...data,
+                ...(options.timestamps && this.getTimestampData()),
+                id: docRef.id,
+            };
+            await setDoc(docRef, dataToSet, { merge: options.merge });
+            return {
+                success: true,
+                id: docRef.id,
+                data: dataToSet
+            };
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
     }
     async update(path, data, options = { timestamps: true }) {
-        const firestore = firebaseService.getDbInstance();
-        const docRef = doc(firestore, path);
-        const dataToUpdate = {
-            ...data,
-            ...(options.timestamps && {
-                updatedAt: serverTimestamp(),
-                updatedBy: firekitUser.uid,
-            }),
-        };
-        return updateDoc(docRef, dataToUpdate);
+        try {
+            const firestore = firebaseService.getDbInstance();
+            const docRef = doc(firestore, path);
+            const dataToUpdate = {
+                ...data,
+                ...(options.timestamps && this.getTimestampData(false)),
+            };
+            await updateDoc(docRef, dataToUpdate);
+            return {
+                success: true,
+                id: docRef.id,
+                data: dataToUpdate
+            };
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
     }
     async delete(path) {
-        const firestore = firebaseService.getDbInstance();
-        const docRef = doc(firestore, path);
-        return deleteDoc(docRef);
+        try {
+            const firestore = firebaseService.getDbInstance();
+            const docRef = doc(firestore, path);
+            await deleteDoc(docRef);
+            return {
+                success: true,
+                id: docRef.id
+            };
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
     }
     async exists(path) {
-        const firestore = firebaseService.getDbInstance();
-        const docRef = doc(firestore, path);
-        const docSnap = await getDoc(docRef);
-        return docSnap.exists();
+        try {
+            const firestore = firebaseService.getDbInstance();
+            const docRef = doc(firestore, path);
+            const docSnap = await getDoc(docRef);
+            return docSnap.exists();
+        }
+        catch (error) {
+            console.error('Error checking document existence:', error);
+            return false;
+        }
+    }
+    async getDoc(path) {
+        try {
+            const firestore = firebaseService.getDbInstance();
+            const docRef = doc(firestore, path);
+            const docSnap = await getDoc(docRef);
+            if (!docSnap.exists()) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'not_found',
+                        message: 'Document does not exist'
+                    }
+                };
+            }
+            return {
+                success: true,
+                id: docSnap.id,
+                data: { id: docSnap.id, ...docSnap.data() }
+            };
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
     }
 }
 export const firekitDocMutations = new FirekitDocumentMutations();

package/dist/index.d.ts

@@ -2,10 +2,12 @@ export { firebaseConfig } from './config.js';
 export { firebaseService } from './firebase.js';
 export { firekitUser } from './auth/user.svelte.js';
 export { firekitAuth } from './auth/auth.js';
+export { presenceService } from './auth/presence.svelte';
 export { firekitAwaitableDoc } from './firestore/awaitable-doc.svelte.js';
 export { firekitDocMutations } from './firestore/document-mutations.svelte';
 export { firekitCollection } from './firestore/collection.svelte.js';
 export { firekitDoc } from './firestore/doc.svelte.js';
+export { firekitRealtimeDB } from './realtime/realtime.svelte.js';
 export { firekitDownloadUrl } from './storage/download-url.svelte.js';
 export { firekitStorageList } from './storage/storage-list.svelte.js';
 export { firekitUploadTask } from './storage/upload-task.svelte.js';

package/dist/index.js

@@ -4,11 +4,14 @@ export { firebaseService } from './firebase.js';
 // auth services
 export { firekitUser } from './auth/user.svelte.js';
 export { firekitAuth } from './auth/auth.js';
+export { presenceService } from './auth/presence.svelte';
 // firestore services
 export { firekitAwaitableDoc } from './firestore/awaitable-doc.svelte.js';
 export { firekitDocMutations } from './firestore/document-mutations.svelte';
 export { firekitCollection } from './firestore/collection.svelte.js';
 export { firekitDoc } from './firestore/doc.svelte.js';
+// realtime services
+export { firekitRealtimeDB } from './realtime/realtime.svelte.js';
 // Storage services
 export { firekitDownloadUrl } from './storage/download-url.svelte.js';
 export { firekitStorageList } from './storage/storage-list.svelte.js';

package/dist/realtime/realtime.svelte.js

@@ -0,0 +1,116 @@
+import { ref, onValue, push, set, update, remove } from "firebase/database";
+import { firebaseService } from "../firebase.js";
+import { browser } from "$app/environment";
+class FirekitRealtimeDB {
+    _data = $state(null);
+    _loading = $state(true);
+    _error = $state(null);
+    dbRef = null;
+    unsubscribe = null;
+    constructor(path, startWith) {
+        this._data = startWith ?? null;
+        if (browser) {
+            this.initializeRealtimeDB(path);
+        }
+    }
+    initializeRealtimeDB(path) {
+        try {
+            const database = firebaseService.getDatabaseInstance();
+            this.dbRef = ref(database, path);
+            this.unsubscribe = onValue(this.dbRef, (snapshot) => {
+                this._data = snapshot.val();
+                this._loading = false;
+                this._error = null;
+            }, (error) => {
+                this._error = error;
+                this._loading = false;
+            });
+        }
+        catch (error) {
+            this._error = error;
+            this._loading = false;
+        }
+    }
+    // Push new data to the list
+    async push(data) {
+        if (!this.dbRef)
+            return null;
+        const newRef = push(this.dbRef);
+        await set(newRef, data);
+        return newRef.key;
+    }
+    // Set data at the reference
+    async set(data) {
+        if (!this.dbRef)
+            return;
+        await set(this.dbRef, data);
+    }
+    // Update data at the reference
+    async update(data) {
+        if (!this.dbRef)
+            return;
+        await update(this.dbRef, data);
+    }
+    // Remove data at the reference
+    async remove() {
+        if (!this.dbRef)
+            return;
+        await remove(this.dbRef);
+    }
+    // Getters for reactive state
+    get data() {
+        return this._data;
+    }
+    get loading() {
+        return this._loading;
+    }
+    get error() {
+        return this._error;
+    }
+    get ref() {
+        if (!this.dbRef) {
+            throw new Error("Database reference is not available");
+        }
+        return this.dbRef;
+    }
+    // Cleanup subscription
+    dispose() {
+        if (this.unsubscribe) {
+            this.unsubscribe();
+        }
+    }
+}
+/**
+ * Creates a reactive Realtime Database reference
+ * @param path Database path
+ * @param startWith Optional initial data
+ * @returns FirekitRealtimeDB instance
+ */
+export function firekitRealtimeDB(path, startWith) {
+    return new FirekitRealtimeDB(path, startWith);
+}
+/**
+ * Creates a reactive Realtime Database list reference
+ * Automatically converts the data into an array format
+ * @param path Database path
+ * @param startWith Optional initial array data
+ * @returns FirekitRealtimeDB instance with array data
+ */
+export function firekitRealtimeList(path, startWith = []) {
+    // Convert initial array to Record format
+    const startWithRecord = startWith.reduce((acc, item, index) => {
+        acc[`key${index}`] = item;
+        return acc;
+    }, {});
+    return new class extends FirekitRealtimeDB {
+        _list = $derived(this.data
+            ? Object.entries(this.data).map(([key, value]) => ({
+                id: key,
+                ...value,
+            }))
+            : []);
+        get list() {
+            return this._list;
+        }
+    }(path, startWithRecord);
+}

package/package.json

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