svelte-firekit 0.0.1 → 0.0.2

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

@@ -0,0 +1,58 @@
+import { addDoc, setDoc, updateDoc, deleteDoc, doc, getDoc, collection, serverTimestamp } from "firebase/firestore";
+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.getDb();
+        const colRef = collection(firestore, collectionPath);
+        const dataToAdd = {
+            ...data,
+            ...(options.timestamps && {
+                createdAt: serverTimestamp(),
+                createdBy: firekitUser.uid,
+                updatedAt: serverTimestamp(),
+                updatedBy: firekitUser.uid
+            })
+        };
+        return addDoc(colRef, dataToAdd);
+    }
+    async set(path, data, options = { merge: false, timestamps: true }) {
+        const firestore = firebaseService.getDb();
+        const docRef = doc(firestore, path);
+        const dataToSet = {
+            ...data,
+            ...(options.timestamps && {
+                createdAt: serverTimestamp(),
+                createdBy: firekitUser.uid,
+                updatedAt: serverTimestamp(),
+                updatedBy: firekitUser.uid
+            })
+        };
+        return setDoc(docRef, dataToSet, { merge: options.merge });
+    }
+    async update(path, data, options = { timestamps: true }) {
+        const firestore = firebaseService.getDb();
+        const docRef = doc(firestore, path);
+        const dataToUpdate = {
+            ...data,
+            ...(options.timestamps && {
+                updatedAt: serverTimestamp(),
+                updatedBy: firekitUser.uid
+            })
+        };
+        return updateDoc(docRef, dataToUpdate);
+    }
+    async delete(path) {
+        const firestore = firebaseService.getDb();
+        const docRef = doc(firestore, path);
+        return deleteDoc(docRef);
+    }
+    async exists(path) {
+        const firestore = firebaseService.getDb();
+        const docRef = doc(firestore, path);
+        const docSnap = await getDoc(docRef);
+        return docSnap.exists();
+    }
+}
+export const firekitDocMutations = new FirekitDocumentMutations();

package/dist/firebase/storage/download-url.svelte.d.ts

@@ -0,0 +1,14 @@
+declare class FirekitDownloadUrl {
+    private _url;
+    private _loading;
+    private _error;
+    private storageRef;
+    constructor(path: string);
+    private initializeDownload;
+    get url(): string | null;
+    get loading(): boolean;
+    get error(): Error | null;
+    refresh(): void;
+}
+export declare function firekitDownloadUrl(path: string): FirekitDownloadUrl;
+export {};

package/dist/firebase/storage/download-url.svelte.js

@@ -0,0 +1,45 @@
+import { ref, getDownloadURL } from "firebase/storage";
+import { browser } from "$app/environment";
+import { firebaseService } from "../firebase.js";
+class FirekitDownloadUrl {
+    _url = $state(null);
+    _loading = $state(true);
+    _error = $state(null);
+    storageRef = null;
+    constructor(path) {
+        if (browser) {
+            this.initializeDownload(path);
+        }
+    }
+    async initializeDownload(path) {
+        try {
+            const storage = firebaseService.getStorageInstance();
+            this.storageRef = ref(storage, path);
+            this._url = await getDownloadURL(this.storageRef);
+            this._loading = false;
+        }
+        catch (error) {
+            this._error = error;
+            this._loading = false;
+        }
+    }
+    get url() {
+        return this._url;
+    }
+    get loading() {
+        return this._loading;
+    }
+    get error() {
+        return this._error;
+    }
+    refresh() {
+        if (this.storageRef) {
+            this._loading = true;
+            this._error = null;
+            this.initializeDownload(this.storageRef.fullPath);
+        }
+    }
+}
+export function firekitDownloadUrl(path) {
+    return new FirekitDownloadUrl(path);
+}

package/dist/firebase/storage/storage-list.svelte.d.ts

@@ -0,0 +1,17 @@
+import { type StorageReference } from "firebase/storage";
+declare class FirekitStorageList {
+    private _items;
+    private _prefixes;
+    private _loading;
+    private _error;
+    private storageRef;
+    constructor(path: string);
+    private initializeList;
+    get items(): StorageReference[];
+    get prefixes(): StorageReference[];
+    get loading(): boolean;
+    get error(): Error | null;
+    refresh(): void;
+}
+export declare function firekitStorageList(path: string): FirekitStorageList;
+export {};

package/dist/firebase/storage/storage-list.svelte.js

@@ -0,0 +1,51 @@
+import { ref, listAll } from "firebase/storage";
+import { browser } from "$app/environment";
+import { firebaseService } from "../firebase.js";
+class FirekitStorageList {
+    _items = $state([]);
+    _prefixes = $state([]);
+    _loading = $state(true);
+    _error = $state(null);
+    storageRef = null;
+    constructor(path) {
+        if (browser) {
+            this.initializeList(path);
+        }
+    }
+    async initializeList(path) {
+        try {
+            const storage = firebaseService.getStorageInstance();
+            this.storageRef = ref(storage, path);
+            const result = await listAll(this.storageRef);
+            this._items = result.items;
+            this._prefixes = result.prefixes;
+            this._loading = false;
+        }
+        catch (error) {
+            this._error = error;
+            this._loading = false;
+        }
+    }
+    get items() {
+        return this._items;
+    }
+    get prefixes() {
+        return this._prefixes;
+    }
+    get loading() {
+        return this._loading;
+    }
+    get error() {
+        return this._error;
+    }
+    refresh() {
+        if (this.storageRef) {
+            this._loading = true;
+            this._error = null;
+            this.initializeList(this.storageRef.fullPath);
+        }
+    }
+}
+export function firekitStorageList(path) {
+    return new FirekitStorageList(path);
+}

package/dist/firebase/storage/upload-task.svelte.d.ts

@@ -0,0 +1,22 @@
+import { type UploadTaskSnapshot } from "firebase/storage";
+declare class FirekitUploadTask {
+    private _progress;
+    private _error;
+    private _snapshot;
+    private _downloadURL;
+    private _completed;
+    private uploadTask;
+    private storageRef;
+    constructor(path: string, file: File);
+    private initializeUpload;
+    pause(): void;
+    resume(): void;
+    cancel(): void;
+    get progress(): number;
+    get error(): Error | null;
+    get snapshot(): UploadTaskSnapshot | null;
+    get downloadURL(): string | null;
+    get completed(): boolean;
+}
+export declare function firekitUploadTask(path: string, file: File): FirekitUploadTask;
+export {};

package/dist/firebase/storage/upload-task.svelte.js

@@ -0,0 +1,65 @@
+import { ref, uploadBytesResumable, getDownloadURL } from "firebase/storage";
+import { browser } from "$app/environment";
+import { firebaseService } from "../firebase.js";
+class FirekitUploadTask {
+    _progress = $state(0);
+    _error = $state(null);
+    _snapshot = $state(null);
+    _downloadURL = $state(null);
+    _completed = $state(false);
+    uploadTask = null;
+    storageRef = null;
+    constructor(path, file) {
+        if (browser) {
+            this.initializeUpload(path, file);
+        }
+    }
+    initializeUpload(path, file) {
+        try {
+            const storage = firebaseService.getStorageInstance();
+            this.storageRef = ref(storage, path);
+            this.uploadTask = uploadBytesResumable(this.storageRef, file);
+            this.uploadTask.on('state_changed', (snapshot) => {
+                this._snapshot = snapshot;
+                this._progress = (snapshot.bytesTransferred / snapshot.totalBytes) * 100;
+            }, (error) => {
+                this._error = error;
+            }, async () => {
+                if (this.storageRef) {
+                    this._downloadURL = await getDownloadURL(this.storageRef);
+                    this._completed = true;
+                }
+            });
+        }
+        catch (error) {
+            this._error = error;
+        }
+    }
+    pause() {
+        this.uploadTask?.pause();
+    }
+    resume() {
+        this.uploadTask?.resume();
+    }
+    cancel() {
+        this.uploadTask?.cancel();
+    }
+    get progress() {
+        return this._progress;
+    }
+    get error() {
+        return this._error;
+    }
+    get snapshot() {
+        return this._snapshot;
+    }
+    get downloadURL() {
+        return this._downloadURL;
+    }
+    get completed() {
+        return this._completed;
+    }
+}
+export function firekitUploadTask(path, file) {
+    return new FirekitUploadTask(path, file);
+}

package/dist/hooks/is-mobile.svelte.d.ts

@@ -0,0 +1,5 @@
+export declare class IsMobile {
+    #private;
+    constructor();
+    get current(): boolean;
+}

package/dist/hooks/is-mobile.svelte.js

@@ -0,0 +1,23 @@
+import { untrack } from "svelte";
+const MOBILE_BREAKPOINT = 768;
+export class IsMobile {
+    #current = $state(false);
+    constructor() {
+        $effect(() => {
+            return untrack(() => {
+                const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
+                const onChange = () => {
+                    this.#current = window.innerWidth < MOBILE_BREAKPOINT;
+                };
+                mql.addEventListener("change", onChange);
+                onChange();
+                return () => {
+                    mql.removeEventListener("change", onChange);
+                };
+            });
+        });
+    }
+    get current() {
+        return this.#current;
+    }
+}

package/dist/index.d.ts

@@ -1,2 +1,22 @@
-export { default as SignIn } from './auth/sign-in.svelte';
-export { default as UserButton } from './auth/user-button.svelte';
+export { firebaseConfig } from './firebase/config.js';
+export { firebaseService } from './firebase/firebase.js';
+export { firekitUser } from './firebase/auth/user.svelte.js';
+export { firekitAuth } from './firebase/auth/auth.js';
+export { firekitAuthGuard } from './firebase/auth/auth-guard.svelte.js';
+export { firekitAwaitableDoc } from './firebase/firestore/awaitable-doc.svelte.js';
+export { firekitDocMutations } from './firebase/firestore/document-mutations.svelte';
+export { firekitCollection } from './firebase/firestore/collection.svelte.js';
+export { firekitDoc } from './firebase/firestore/doc.svelte.js';
+export { firekitDownloadUrl } from './firebase/storage/download-url.svelte.js';
+export { firekitStorageList } from './firebase/storage/storage-list.svelte.js';
+export { firekitUploadTask } from './firebase/storage/upload-task.svelte.js';
+export { default as SignInPage } from './auth/sign-in.svelte';
+export { default as SignUpPage } from './auth/sign-up.svelte';
+export { default as ResetPassWordPage } from './auth/reset-password.svelte';
+export { default as ResetPassWordForm } from './components/auth/reset-password-form.svelte';
+export { default as SignInForm } from './components/auth/sign-in-form.svelte';
+export { default as SignUpForm } from './components/auth/sign-up-form.svelte';
+export { default as UserButton } from './components/auth/user-button.svelte';
+export { default as Collection } from './components/firestore/collection.svelte';
+export { default as Doc } from './components/firestore/doc.svelte';
+export { default as Upload } from './components/storage/upload.svelte';

package/dist/index.js

@@ -1,3 +1,29 @@
-// Reexport your entry components here
-export { default as SignIn } from './auth/sign-in.svelte';
-export { default as UserButton } from './auth/user-button.svelte';
+// Firebase config
+export { firebaseConfig } from './firebase/config.js';
+export { firebaseService } from './firebase/firebase.js';
+// auth services
+export { firekitUser } from './firebase/auth/user.svelte.js';
+export { firekitAuth } from './firebase/auth/auth.js';
+export { firekitAuthGuard } from './firebase/auth/auth-guard.svelte.js';
+// firestore services
+export { firekitAwaitableDoc } from './firebase/firestore/awaitable-doc.svelte.js';
+export { firekitDocMutations } from './firebase/firestore/document-mutations.svelte';
+export { firekitCollection } from './firebase/firestore/collection.svelte.js';
+export { firekitDoc } from './firebase/firestore/doc.svelte.js';
+// Storage services
+export { firekitDownloadUrl } from './firebase/storage/download-url.svelte.js';
+export { firekitStorageList } from './firebase/storage/storage-list.svelte.js';
+export { firekitUploadTask } from './firebase/storage/upload-task.svelte.js';
+// auth components
+export { default as SignInPage } from './auth/sign-in.svelte';
+export { default as SignUpPage } from './auth/sign-up.svelte';
+export { default as ResetPassWordPage } from './auth/reset-password.svelte';
+export { default as ResetPassWordForm } from './components/auth/reset-password-form.svelte';
+export { default as SignInForm } from './components/auth/sign-in-form.svelte';
+export { default as SignUpForm } from './components/auth/sign-up-form.svelte';
+export { default as UserButton } from './components/auth/user-button.svelte';
+// firestore components
+export { default as Collection } from './components/firestore/collection.svelte';
+export { default as Doc } from './components/firestore/doc.svelte';
+// storage 
+export { default as Upload } from './components/storage/upload.svelte';

package/dist/types/docs.d.ts

@@ -0,0 +1,50 @@
+export type Metadata = {
+    title: string;
+    description: string;
+    openGraph: {
+        title: string;
+        description: string;
+        type: 'article';
+        url: string;
+        images: [
+            {
+                url: string;
+                width: number;
+                height: number;
+                alt: string;
+            }
+        ];
+    };
+    twitter: {
+        card: 'summary_large_image';
+        title: string;
+        description: string;
+        images: string[];
+        creator: string;
+    };
+};
+export type FrontMatter = {
+    title: string;
+    description: string;
+    slug: string;
+    component: boolean;
+    source: string;
+    external?: {
+        project: string;
+        url: string;
+    };
+    bits?: string;
+};
+export type DocFile = {
+    default: import('svelte').Component;
+    metadata: FrontMatter;
+};
+export type DocResolver = () => Promise<DocFile>;
+export type TableOfContentsItem = {
+    title: string;
+    url: string;
+    items?: TableOfContentsItem[];
+};
+export type TableOfContents = {
+    items: TableOfContentsItem[];
+};

package/dist/utils.d.ts

@@ -1,3 +1,29 @@
 import { type ClassValue } from "clsx";
 export declare function cn(...inputs: ClassValue[]): string;
-export declare function getInitials(name: string | null | undefined): string;
+/**
+ * Options for initial generation
+ */
+type InitialsOptions = {
+    maxLength?: number;
+    fallback?: string;
+};
+/**
+ * Extracts initials from a given name string
+ * @param name - Full name to extract initials from
+ * @param options - Optional configuration for initial generation
+ * @returns Generated initials or fallback value
+ * @example
+ * getInitials("John Doe") // returns "JD"
+ * getInitials("Jane") // returns "J"
+ * getInitials("") // returns ""
+ * getInitials(null, { fallback: "NA" }) // returns "NA"
+ */
+export declare function getInitials(name: string | null | undefined, options?: InitialsOptions): string;
+export declare function slugFromPath(path: string): string;
+export declare function getDoc(slug: string): Promise<{
+    component: import("svelte").Component<{}, {}, string>;
+    metadata: import("./types/docs.js").FrontMatter;
+    title: string;
+}>;
+export declare function slugFromPathname(pathname: string): string;
+export {};

package/dist/utils.js

@@ -1,16 +1,92 @@
 import { clsx } from "clsx";
 import { twMerge } from "tailwind-merge";
+import { error } from '@sveltejs/kit';
 export function cn(...inputs) {
     return twMerge(clsx(inputs));
 }
-export function getInitials(name) {
-    if (!name)
-        return '';
-    const nameParts = name.trim().split(' ');
-    if (nameParts.length === 1) {
-        return nameParts[0].charAt(0).toUpperCase();
+/**
+ * Extracts initials from a given name string
+ * @param name - Full name to extract initials from
+ * @param options - Optional configuration for initial generation
+ * @returns Generated initials or fallback value
+ * @example
+ * getInitials("John Doe") // returns "JD"
+ * getInitials("Jane") // returns "J"
+ * getInitials("") // returns ""
+ * getInitials(null, { fallback: "NA" }) // returns "NA"
+ */
+export function getInitials(name, options = {}) {
+    const { maxLength = 2, fallback = '' } = options;
+    try {
+        // Handle empty/invalid input
+        if (!name?.trim()) {
+            return fallback;
+        }
+        // Split and filter out empty parts
+        const nameParts = name
+            .trim()
+            .split(' ')
+            .filter(part => part.length > 0);
+        // Handle empty array after filtering
+        if (nameParts.length === 0) {
+            return fallback;
+        }
+        // Handle single word
+        if (nameParts.length === 1) {
+            const initial = nameParts[0].charAt(0).toUpperCase();
+            return initial || fallback;
+        }
+        // Get first and last initials
+        const firstInitial = nameParts[0].charAt(0).toUpperCase();
+        const lastInitial = nameParts[nameParts.length - 1].charAt(0).toUpperCase();
+        // Combine initials and ensure max length
+        const initials = (firstInitial + lastInitial).slice(0, maxLength);
+        return initials || fallback;
     }
-    const firstInitial = nameParts[0].charAt(0).toUpperCase();
-    const lastInitial = nameParts[nameParts.length - 1].charAt(0).toUpperCase();
-    return firstInitial + lastInitial;
+    catch (error) {
+        console.error('Error generating initials:', error);
+        return fallback;
+    }
+}
+export function slugFromPath(path) {
+    return path.replace('/src/content/', '').replace('.md', '');
+}
+export async function getDoc(slug) {
+    const modules = import.meta.glob(`/src/content/**/*.md`);
+    const match = findMatch(slug, modules);
+    const doc = await match?.resolver?.();
+    if (!doc || !doc.metadata) {
+        error(404);
+    }
+    return {
+        component: doc.default,
+        metadata: doc.metadata,
+        title: doc.metadata.title
+    };
+}
+function findMatch(slug, modules) {
+    let match = {};
+    for (const [path, resolver] of Object.entries(modules)) {
+        if (slugFromPath(path) === slug) {
+            match = { path, resolver: resolver };
+            break;
+        }
+    }
+    if (!match.path) {
+        match = getIndexDocIfExists(slug, modules);
+    }
+    return match;
+}
+export function slugFromPathname(pathname) {
+    return pathname.split('/').pop() ?? '';
+}
+function getIndexDocIfExists(slug, modules) {
+    let match = {};
+    for (const [path, resolver] of Object.entries(modules)) {
+        if (path.includes(`/${slug}/index.md`)) {
+            match = { path, resolver: resolver };
+            break;
+        }
+    }
+    return match;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "svelte-firekit",
-	"version": "0.0.1",
+	"version": "0.0.2",
 	"license": "MIT",
 	"scripts": {
 		"dev": "vite dev",
@@ -29,18 +29,21 @@
 		}
 	},
 	"peerDependencies": {
-		"svelte": "^5.0.0",
-		"@sveltejs/kit": "^2.0.0"
+		"@sveltejs/kit": "^2.0.0",
+		"firebase": "^11.0.1",
+		"svelte": "^5.0.0"
 	},
 	"devDependencies": {
 		"@sveltejs/adapter-auto": "^3.0.0",
 		"@sveltejs/kit": "^2.0.0",
 		"@sveltejs/package": "^2.0.0",
 		"@sveltejs/vite-plugin-svelte": "^4.0.0",
+		"@tailwindcss/typography": "^0.5.15",
 		"autoprefixer": "^10.4.20",
-		"bits-ui": "^1.0.0-next.34",
+		"bits-ui": "^1.0.0-next.52",
 		"clsx": "^2.1.1",
 		"formsnap": "^2.0.0-next.1",
+		"lucide-svelte": "^0.456.0",
 		"mode-watcher": "^0.4.1",
 		"publint": "^0.2.0",
 		"svelte": "^5.0.0",
@@ -53,12 +56,11 @@
 		"tailwindcss": "^3.4.9",
 		"tailwindcss-animate": "^1.0.7",
 		"typescript": "^5.0.0",
-		"vite": "^5.0.11",
-		"zod": "^3.23.8"
+		"vite": "^5.0.11"
 	},
 	"dependencies": {
 		"firebase": "^11.0.1",
 		"lucide": "^0.454.0",
-		"lucide-svelte": "^0.454.0"
+		"mdsvex": "^0.12.3"
 	}
 }

package/dist/auth/uid.js

@@ -1,7 +0,0 @@
-"use strict";
-// import { get } from "svelte/store";
-// import { authState } from "./user";
-// export const getUid = () => {
-//   const u = get(authState);
-//   return (u && u.uid) || "anonymous"; // 'anonymous' allows support messages to be saved by non-logged-in users
-// };

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

@@ -1,10 +0,0 @@
-import { type User } from "firebase/auth";
-export declare class FirebaseAuthUser {
-    #private;
-    constructor();
-    get isAuthenticated(): boolean;
-    get isAnonymousUser(): boolean | undefined;
-    get userId(): string | undefined;
-    get currentUser(): User | null | undefined;
-}
-export declare const authUser: FirebaseAuthUser;

package/dist/auth/user.svelte.js

@@ -1,21 +0,0 @@
-import { getAuthInstance } from "../firebase.js";
-import { onAuthStateChanged } from "firebase/auth";
-export class FirebaseAuthUser {
-    #currentUser = $state();
-    constructor() {
-        onAuthStateChanged(getAuthInstance(), (user) => (this.#currentUser = user));
-    }
-    get isAuthenticated() {
-        return this.currentUser !== null;
-    }
-    get isAnonymousUser() {
-        return this.currentUser?.isAnonymous;
-    }
-    get userId() {
-        return this.currentUser?.uid;
-    }
-    get currentUser() {
-        return this.#currentUser;
-    }
-}
-export const authUser = new FirebaseAuthUser();