svelte-firekit 0.0.1

package/dist/firebase.js

@@ -0,0 +1,110 @@
+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';
+// Declare Firebase instances as nullable, allowing lazy initialization
+let firebaseApp = null;
+let db = null;
+let auth = null;
+let functions = null;
+let database = null;
+let storage = null;
+// Detect if the code is running in a browser environment
+const isBrowser = typeof window !== 'undefined';
+/**
+ * Initializes and returns the Firebase app instance.
+ * Ensures only one app instance is created and reused across invocations.
+ * @returns {FirebaseApp} The initialized Firebase application.
+ */
+export function getFirebaseApp() {
+    if (firebaseApp)
+        return firebaseApp;
+    const existingApps = getApps();
+    if (existingApps.length) {
+        firebaseApp = existingApps[0];
+    }
+    else {
+        firebaseApp = initializeApp(firebaseConfig);
+        console.log(`${firebaseConfig.projectId} initialized on ${isBrowser ? 'client' : 'server'}`);
+    }
+    initializeFirestoreInstance(); // Ensure Firestore is also initialized
+    return firebaseApp;
+}
+/**
+ * Initializes the Firestore instance with a persistent cache if in the browser.
+ * Configures the Firestore cache to be unlimited and manages multi-tab synchronization.
+ */
+function initializeFirestoreInstance() {
+    if (db || !isBrowser)
+        return;
+    db = initializeFirestore(firebaseApp, {
+        localCache: persistentLocalCache({
+            cacheSizeBytes: CACHE_SIZE_UNLIMITED,
+            tabManager: persistentMultipleTabManager()
+        }),
+    });
+    const indexManager = getPersistentCacheIndexManager(db);
+    if (indexManager) {
+        enablePersistentCacheIndexAutoCreation(indexManager);
+        console.log('Firestore persistent cache indexing is enabled');
+    }
+    else {
+        console.warn('Failed to initialize the Firestore cache index manager');
+    }
+}
+/**
+ * Retrieves the Firestore database instance.
+ * Calls `getFirebaseApp` to ensure the app and Firestore are initialized.
+ * @returns {Firestore} The Firestore instance.
+ */
+export function getDb() {
+    if (!db)
+        getFirebaseApp();
+    return db;
+}
+/**
+ * Retrieves the Auth instance, initializing it if needed.
+ * @returns {Auth} The Auth instance.
+ */
+export function getAuthInstance() {
+    if (!auth)
+        auth = getAuth(getFirebaseApp());
+    return auth;
+}
+/**
+ * Retrieves the Functions instance, initializing it if needed.
+ * @returns {Functions} The Functions instance.
+ */
+export function getFunctionsInstance() {
+    if (!functions)
+        functions = getFunctions(getFirebaseApp());
+    return functions;
+}
+/**
+ * Retrieves the Database instance, initializing it if needed.
+ * @returns {Database} The Database instance.
+ */
+export function getDatabaseInstance() {
+    if (!database)
+        database = getDatabase(getFirebaseApp());
+    return database;
+}
+/**
+ * Retrieves the Storage instance, initializing it if needed.
+ * @returns {FirebaseStorage} The Storage instance.
+ */
+export function getStorageInstance() {
+    if (!storage)
+        storage = getStorage(getFirebaseApp());
+    return storage;
+}
+/**
+ * Creates a new Firestore batch instance for performing atomic writes.
+ * @returns {WriteBatch} A new write batch instance.
+ */
+export function getBatch() {
+    return writeBatch(getDb());
+}

package/dist/firestore/Collection.svelte

@@ -0,0 +1,148 @@
+<script lang="ts">
+  import { onDestroy, onMount, createEventDispatcher, type Snippet } from "svelte";
+  import type { Unsubscriber } from "svelte/store";
+  import type {
+    CollectionReference,
+    QueryConstraint,
+  } from "firebase/firestore";
+  import { collectionStore } from "./collection.svelte.js";
+  
+  type T = $$Generic;
+
+  // export let path: CollectionReference<T> | string;
+  // export let queryConstraints: QueryConstraint[] = []; // usage example: [where('role', '==', 'contributor'), orderBy("name")];
+  // export let traceId = "";
+  // export let log = false;
+  // export let startWith: T[] = undefined
+  // export let maxWait = 10000;
+  // export let once = false;
+  // export let refField: string = undefined;
+
+  let {
+    path,
+    queryConstraints = [] as QueryConstraint[],
+    traceId = "",
+    log = false,
+    startWith = undefined,
+    maxWait = 10000,
+    once = false,
+    refField = undefined,
+  } = $props() as {
+    path: CollectionReference<T> | string;
+    queryConstraints: QueryConstraint[];
+    traceId: string;
+    log: boolean;
+    startWith: T[];
+    maxWait: number;
+    once: boolean;
+    refField: string;
+  };
+
+    const opts = {
+    startWith,
+    traceId,
+    log,
+    maxWait,
+    once,
+    refField,
+  };
+
+
+  // let store = collectionStore<T>(path, queryConstraints, opts);
+
+  let store: any = $state(collectionStore<T>(path, queryConstraints, opts || {}));
+
+
+
+  const dispatch = createEventDispatcher<{
+    ref: { ref: CollectionReference<T> };
+    data: { data: T[] };
+  }>();
+
+  let unsub: Unsubscriber;
+
+
+  // Props changed
+  // $: {
+  //   if (typeof window !== 'undefined') {
+  //     if (unsub) {
+  //       unsub();
+  //       const updatedOpts = { ...opts, traceId, log, maxWait, once, refField };
+  //       store = collectionStore(path, queryConstraints, updatedOpts);
+  //       dispatch('ref', { ref: store.ref });
+  //     }
+
+  //     unsub = store.subscribe((data) => {
+  //       dispatch('data', {
+  //         data,
+  //       });
+  //     });
+  //   }
+  // }
+
+
+
+  $effect(() => {
+    console.log("effect");
+    if (typeof window !== "undefined") {
+
+      if (unsub && typeof unsub === "function") {
+        unsub();
+        
+        // Initialize opts with a fallback to an empty object
+        const updatedOpts = { ...opts || {}, traceId, log, maxWait, once, refField };
+        
+        store = collectionStore(path, queryConstraints, updatedOpts);
+        dispatch("ref", { ref: store.ref });
+      }
+
+      store.subscribe((data) => {
+        dispatch("data", { data: data });
+      });
+    }
+  });
+
+
+  onMount(() => dispatch("ref", { ref: store.ref }));
+  onDestroy(() => unsub && unsub());
+</script>
+
+
+{#snippet before(message)}
+  <h3>{message}</h3>
+{/snippet}
+
+{#snippet done(response)}
+<h3 class="text-blue-500 text-xl ">Proyects: {response.data?.length || 0}</h3>
+<div class="bg-slate-200 max-h-[300px] overflow-y-auto text-black w-[800px] my-4">
+  <pre>{JSON.stringify(response.data, null, 2)}</pre>
+</div>
+{/snippet}
+{#snippet loading(message)}
+  <h3>{message}</h3>
+{/snippet}
+
+{#snippet empty(message)}
+  <h3>{message}</h3>
+{/snippet}
+{#snippet after(message)}
+  <h3>{message}</h3>
+{/snippet}
+
+
+{@render before("Ready to Start")}
+{#if store}
+  {@render done({data: $store,
+    ref: store.ref,
+    error: store.error,
+    first: store.meta.first,
+    last: store.meta.last})}
+
+{:else if $store.loading}
+  {@render loading("Loading Data")}
+{:else}
+  {@render empty("No found result")}
+{/if}
+  
+{@render after("Finish")}
+  

package/dist/firestore/Collection.svelte.d.ts

@@ -0,0 +1,27 @@
+import type { CollectionReference } from "firebase/firestore";
+declare class __sveltets_Render<T> {
+    props(): Record<string, never>;
+    events(): {
+        ref: CustomEvent<{
+            ref: CollectionReference<T, import("@firebase/firestore").DocumentData>;
+        }>;
+        data: CustomEvent<{
+            data: T[];
+        }>;
+    };
+    slots(): {};
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T>(internal: unknown, props: {
+        $$events?: ReturnType<__sveltets_Render<T>['events']>;
+    }): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Collection: $$IsomorphicComponent;
+type Collection<T> = InstanceType<typeof Collection<T>>;
+export default Collection;

package/dist/firestore/collection.svelte.js

@@ -0,0 +1,207 @@
+import { writable } from "svelte/store";
+import { onSnapshot, query } from "firebase/firestore";
+import { startTrace, stopTrace } from "./perf.js";
+import { colRef } from "./firestore.js";
+export function collectionStore(path, queryConstraints = [], options = {}) {
+    const { startWith, log, traceId, maxWait = 10000, once, idField = "id", refField, } = options;
+    if (typeof window === "undefined") {
+        const store = writable(startWith);
+        const { subscribe } = store;
+        return {
+            subscribe,
+            ref: undefined,
+            get loading() {
+                return false;
+            },
+            get error() {
+                return false;
+            },
+            get meta() {
+                return { first: null, last: null };
+            },
+        };
+    }
+    const { subscribe, set } = writable(startWith, start);
+    const ref = typeof path === "string" ? colRef(path) : path;
+    const q = query(ref, ...queryConstraints);
+    const trace = traceId && startTrace(traceId);
+    let _loading = typeof startWith !== undefined;
+    let _error = null;
+    let _meta = { first: null, last: null };
+    let _waitForIt;
+    // Metadata for result
+    const calcMeta = (val) => {
+        return val && val.length
+            ? { first: val[0], last: val[val.length - 1] }
+            : { first: null, last: null };
+    };
+    const next = (val, err) => {
+        _loading = false;
+        _waitForIt && clearTimeout(_waitForIt);
+        _error = err || null;
+        _meta = calcMeta(val);
+        set(val);
+        trace && stopTrace(trace);
+    };
+    function start() {
+        _waitForIt =
+            maxWait &&
+                setTimeout(() => _loading && next(null, new Error(`Timeout at ${maxWait}.`)), maxWait);
+        const teardown = onSnapshot(q, (snapshot) => {
+            // Will always return an array
+            const data = snapshot.docs.map((docSnap) => ({
+                ...docSnap.data(),
+                // Allow end user override fields mapped for ID and Ref
+                ...(idField ? { [idField]: docSnap.id } : null),
+                ...(refField ? { [refField]: docSnap.ref } : null),
+            }));
+            if (log) {
+                const type = _loading ? "New Query" : "Updated Query";
+                console.groupCollapsed(`${type} ${ref.id} | ${data.length} hits`);
+                console.log(`Path: ${ref.path}`);
+                console.table(data);
+                console.groupEnd();
+            }
+            next(data);
+            once && teardown();
+        }, (error) => {
+            console.error(error);
+            next(null, error);
+        });
+        return () => teardown();
+    }
+    return {
+        subscribe,
+        ref,
+        get loading() {
+            return _loading;
+        },
+        get error() {
+            return _error;
+        },
+        get meta() {
+            return _meta;
+        },
+    };
+}
+/*import { writable } from 'svelte/store';
+import {
+    onSnapshot,
+    query,
+    type QueryConstraint,
+} from 'firebase/firestore';
+
+import { colRef, type CollectionPredicate } from '../firestore';
+import { startTrace, stopTrace } from '../perf';
+
+export function collectionStore<T>(
+    path: CollectionPredicate<T>,
+    queryConstraints: QueryConstraint[] = [],
+    options: {
+        log?: boolean;
+        traceId?: string;
+        startWith?: T[];
+        maxWait?: number;
+        once?: boolean;
+        idField?: string;
+        refField?: string;
+    } = {}) {
+    const { startWith, log, traceId, maxWait = 10000, once, idField = 'id', refField } = options;
+
+    if (typeof window === 'undefined') {
+        const store = writable(startWith);
+        const { subscribe } = store;
+        return {
+            subscribe,
+            ref: undefined,
+            get loading() {
+                return false;
+            },
+            get error() {
+                return false;
+            },
+            get meta() {
+                return { first: null, last: null };
+            },
+        };
+    }
+
+    const { subscribe, set } = writable(startWith, start);
+
+    const ref = typeof path === 'string' ? colRef<T>(path) : path;
+    const q = query(ref, ...queryConstraints);
+    const trace = traceId && startTrace(traceId);
+
+    let _loading = typeof startWith !== undefined;
+    let _error = null;
+    let _meta = { first: null, last: null };
+    let _waitForIt;
+
+    // Metadata for result
+    const calcMeta = (val) => {
+        return val && val.length
+            ? { first: val[0], last: val[val.length - 1] }
+            : { first: null, last: null };
+    };
+
+    const next = (val: T[], err?: Error) => {
+        _loading = false;
+        _waitForIt && clearTimeout(_waitForIt);
+        _error = err || null;
+        _meta = calcMeta(val);
+        set(val);
+        trace && stopTrace(trace);
+    };
+
+    function start() {
+        _waitForIt =
+            maxWait &&
+            setTimeout(
+                () => _loading && next(null, new Error(`Timeout at ${maxWait}.`)),
+                maxWait
+            );
+
+        const teardown = onSnapshot(
+            q,
+            (snapshot) => {
+                // Will always return an array
+                const data = snapshot.docs.map((docSnap) => ({
+                    ...docSnap.data(),
+                    // Allow end user override fields mapped for ID and Ref
+                    ...(idField ? { [idField]: docSnap.id } : null),
+                    ...(refField ? { [refField]: docSnap.ref } : null),
+                }));
+
+                if (log) {
+                    const type = _loading ? 'New Query' : 'Updated Query';
+                    console.groupCollapsed(`${type} ${ref.id} | ${data.length} hits`);
+                    console.log(`Path: ${ref.path}`);
+                    console.table(data);
+                    console.groupEnd();
+                }
+                next(data);
+                once && teardown();
+            },
+            (error) => {
+                console.error(error);
+                next(null, error);
+            }
+        );
+
+        return () => teardown();
+    };
+
+    return {
+        subscribe,
+        ref,
+        get loading() {
+            return _loading;
+        },
+        get error() {
+            return _error;
+        },
+        get meta() {
+            return _meta;
+        },
+    };
+}*/

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

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

package/dist/firestore/doc.svelte.js

@@ -0,0 +1 @@
+"use strict";

package/dist/firestore/firestore.d.ts

@@ -0,0 +1,31 @@
+import { type CollectionReference, type DocumentReference, type QueryConstraint, type WithFieldValue, type PartialWithFieldValue, type FirestoreError } from "firebase/firestore";
+export type CollectionPredicate<T> = string | CollectionReference<T>;
+export type DocPredicate<T> = string | DocumentReference<T>;
+export declare function colRef<T>(ref: CollectionPredicate<T>): CollectionReference<T>;
+export declare function docRef<T>(ref: DocPredicate<T>): DocumentReference<T>;
+export declare function getCollection<T>(path: CollectionPredicate<T>, queryConstraints?: QueryConstraint[]): Promise<T[]>;
+export declare function getCollectionOrError<T>(path: CollectionPredicate<T>, queryConstraints?: QueryConstraint[], { fromCache }?: {
+    fromCache: boolean;
+}): Promise<{
+    data?: T[];
+    ref?: CollectionReference<T>;
+    error?: FirestoreError;
+}>;
+export declare function getDocument<T>(ref: DocPredicate<T>): Promise<T>;
+export declare function getDocumentOrError<T>(ref: DocPredicate<T>): Promise<{
+    data?: T;
+    ref?: DocumentReference<T>;
+    error?: FirestoreError;
+}>;
+export declare function add<T>(ref: CollectionPredicate<T>, data: WithFieldValue<T>, opts?: {
+    abbreviate?: boolean;
+}): Promise<DocumentReference<T>>;
+export declare function set<T>(ref: DocPredicate<T>, data: PartialWithFieldValue<T>, opts?: {
+    abbreviate?: boolean;
+    merge?: boolean;
+}): Promise<void>;
+export declare function update<T>(ref: DocPredicate<T>, data: PartialWithFieldValue<T>, opts?: {
+    abbreviate?: boolean;
+}): Promise<void>;
+export declare function deleteDocument<T>(ref: DocPredicate<T>): Promise<void>;
+export declare function docExists<T>(ref: DocPredicate<T>): Promise<boolean>;

package/dist/firestore/firestore.js

@@ -0,0 +1,100 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// Inspired by https://fireship.io/lessons/firestore-advanced-usage-angularfire/
+import { authUser } from "../auth/user.svelte.js";
+import { getDb } from "../firebase.js";
+import { collection, doc, getDocs, getDocsFromCache, 
+// getDocsFromServer,
+getDoc, query, addDoc, setDoc, deleteDoc, updateDoc, serverTimestamp, } from "firebase/firestore";
+export function colRef(ref) {
+    const db = getDb();
+    return typeof ref === "string"
+        ? collection(db, ref)
+        : ref;
+}
+export function docRef(ref) {
+    if (typeof ref === "string") {
+        const pathParts = ref.split("/");
+        const documentId = pathParts.pop();
+        const collectionString = pathParts.join("/");
+        return doc(colRef(collectionString), documentId);
+    }
+    else {
+        return ref;
+    }
+}
+export async function getCollection(path, queryConstraints = []) {
+    const ref = typeof path === "string" ? colRef(path) : path;
+    const q = query(ref, ...queryConstraints);
+    const collectionSnap = await getDocs(q);
+    return collectionSnap.docs.map((docSnap) => ({
+        ...docSnap.data(),
+        id: docSnap.id,
+    }));
+}
+export async function getCollectionOrError(path, queryConstraints = [], { fromCache } = { fromCache: false }) {
+    try {
+        const _ref = typeof path === "string" ? colRef(path) : path;
+        const q = query(_ref, ...queryConstraints);
+        const collectionSnap = fromCache
+            ? await getDocsFromCache(q)
+            : await getDocs(q);
+        return {
+            data: collectionSnap.docs.map((docSnap) => ({
+                ...docSnap.data(),
+                id: docSnap.id,
+            })),
+            ref: _ref,
+        };
+    }
+    catch (error) {
+        return { error };
+    }
+}
+export async function getDocument(ref) {
+    const docSnap = await getDoc(docRef(ref));
+    return docSnap.exists() ? { ...docSnap.data(), id: docSnap.id } : null;
+}
+export async function getDocumentOrError(ref) {
+    try {
+        const _ref = docRef(ref);
+        const docSnap = await getDoc(_ref);
+        return {
+            data: docSnap.exists()
+                ? { ...docSnap.data(), id: docSnap.id }
+                : null,
+            ref: _ref,
+        };
+    }
+    catch (error) {
+        return { error };
+    }
+}
+export function add(ref, data, opts = {}) {
+    data[opts.abbreviate ? "ca" : "createdAt"] = serverTimestamp();
+    data[opts.abbreviate ? "cb" : "createdBy"] = authUser.userId;
+    data[opts.abbreviate ? "ua" : "updatedAt"] = serverTimestamp();
+    data[opts.abbreviate ? "ub" : "updatedBy"] = authUser.userId;
+    return addDoc(colRef(ref), data);
+}
+export async function set(ref, data, opts = {}) {
+    const snap = await getDocument(ref);
+    if (snap) {
+        return await update(ref, data);
+    }
+    data[opts.abbreviate ? "ca" : "createdAt"] = serverTimestamp();
+    data[opts.abbreviate ? "cb" : "createdBy"] = authUser.userId;
+    data[opts.abbreviate ? "ua" : "updatedAt"] = serverTimestamp();
+    data[opts.abbreviate ? "ub" : "updatedBy"] = authUser.userId;
+    return await setDoc(docRef(ref), data, { merge: opts.merge });
+} // could split apart into set and upsert if desired, https://stackoverflow.com/questions/46597327/difference-between-set-with-merge-true-and-update
+export async function update(ref, data, opts = {}) {
+    data[opts.abbreviate ? "ua" : "updatedAt"] = serverTimestamp();
+    data[opts.abbreviate ? "ub" : "updatedBy"] = authUser.userId;
+    return updateDoc(docRef(ref), data);
+}
+export function deleteDocument(ref) {
+    return deleteDoc(docRef(ref));
+}
+export async function docExists(ref) {
+    return (await getDoc(docRef(ref))).exists();
+}

package/dist/firestore/perf.d.ts

@@ -0,0 +1,3 @@
+import { type PerformanceTrace } from "firebase/performance";
+export declare function startTrace(name: string): PerformanceTrace;
+export declare function stopTrace(t: PerformanceTrace): null;

package/dist/firestore/perf.js

@@ -0,0 +1,12 @@
+import { getFirebaseApp } from "../firebase.js";
+import { getPerformance, trace, } from "firebase/performance";
+export function startTrace(name) {
+    const perf = getPerformance(getFirebaseApp());
+    const t = trace(perf, name);
+    t.start();
+    return t;
+}
+export function stopTrace(t) {
+    t.stop();
+    return null;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SignIn } from './auth/sign-in.svelte';
+export { default as UserButton } from './auth/user-button.svelte';

package/dist/index.js

@@ -0,0 +1,3 @@
+// Reexport your entry components here
+export { default as SignIn } from './auth/sign-in.svelte';
+export { default as UserButton } from './auth/user-button.svelte';

package/dist/schemas/reset-password.d.ts

@@ -0,0 +1,4 @@
+import * as v from 'valibot';
+export declare const resetPasswordSchema: v.ObjectSchema<{
+    readonly email: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, "Please enter your email.">, v.EmailAction<string, "The email address is badly formatted.">]>;
+}, undefined>;

package/dist/schemas/reset-password.js

@@ -0,0 +1,4 @@
+import * as v from 'valibot';
+export const resetPasswordSchema = v.object({
+    email: v.pipe(v.string(), v.nonEmpty('Please enter your email.'), v.email('The email address is badly formatted.')),
+});

package/dist/schemas/sign-in.d.ts

@@ -0,0 +1,5 @@
+import * as v from 'valibot';
+export declare const signInSchema: v.ObjectSchema<{
+    readonly email: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, "Please enter your email.">, v.EmailAction<string, "The email address is badly formatted.">]>;
+    readonly password: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, "Please enter your password.">, v.MinLengthAction<string, 8, "Your password must have 8 characters or more.">]>;
+}, undefined>;

package/dist/schemas/sign-in.js

@@ -0,0 +1,5 @@
+import * as v from 'valibot';
+export const signInSchema = v.object({
+    email: v.pipe(v.string(), v.nonEmpty('Please enter your email.'), v.email('The email address is badly formatted.')),
+    password: v.pipe(v.string(), v.nonEmpty('Please enter your password.'), v.minLength(8, 'Your password must have 8 characters or more.')),
+});