svelte-firekit 0.1.9 → 0.2.1

package/dist/components/SignedOut.svelte

@@ -0,0 +1,32 @@
+<script lang="ts">
+	import type { Snippet } from 'svelte';
+	import { firekitUser } from '../services/user.svelte.js';
+
+	/**
+	 * Renders `children` only when no authenticated user exists (including during loading).
+	 * Passes a sign-in trigger function to children — wire it up to your auth method of choice.
+	 *
+	 * @example
+	 * <SignedOut>
+	 *   {#snippet children(signIn)}
+	 *     <button onclick={signIn}>Sign in with Google</button>
+	 *   {/snippet}
+	 * </SignedOut>
+	 */
+	let {
+		children,
+		onSignIn
+	}: {
+		children: Snippet<[() => void]>;
+		/** Optional callback invoked when the user triggers sign-in from the snippet. */
+		onSignIn?: () => void;
+	} = $props();
+
+	function triggerSignIn() {
+		onSignIn?.();
+	}
+</script>
+
+{#if !firekitUser.isAuthenticated && !firekitUser.loading}
+	{@render children(triggerSignIn)}
+{/if}

package/dist/components/{firekit/signed-out.svelte.d.ts → SignedOut.svelte.d.ts}

@@ -1,10 +1,8 @@
-import type { Auth } from 'firebase/auth';
 import type { Snippet } from 'svelte';
 type $$ComponentProps = {
-    /**
-     * Children content to render when user is signed out
-     */
-    children: Snippet<[Auth]>;
+    children: Snippet<[() => void]>;
+    /** Optional callback invoked when the user triggers sign-in from the snippet. */
+    onSignIn?: () => void;
 };
 declare const SignedOut: import("svelte").Component<$$ComponentProps, {}, "">;
 type SignedOut = ReturnType<typeof SignedOut>;

package/dist/components/UploadTask.svelte

@@ -0,0 +1,75 @@
+<script lang="ts">
+	import type { Snippet } from 'svelte';
+	import type { UploadMetadata } from 'firebase/storage';
+	import { FirekitUploadTask, type UploadState } from '../services/storage.svelte.js';
+
+	/**
+	 * Manages a Firebase Storage upload with reactive progress.
+	 *
+	 * Exposes upload controls (pause, resume, cancel) and progress state
+	 * to the `uploading` snippet.
+	 *
+	 * @example
+	 * ```svelte
+	 * <UploadTask path="uploads/{file.name}" {file}>
+	 *   {#snippet uploading(task)}
+	 *     <progress value={task.progress} max={100} />
+	 *     <button onclick={task.pause}>Pause</button>
+	 *   {/snippet}
+	 *   {#snippet complete(url)}
+	 *     <img src={url} alt="uploaded" />
+	 *   {/snippet}
+	 * </UploadTask>
+	 * ```
+	 */
+	let {
+		path,
+		file,
+		metadata,
+		uploading: uploadingSnippet,
+		complete: completeSnippet,
+		error: errorSnippet
+	}: {
+		/** Storage destination path. */
+		path: string;
+		/** File or raw bytes to upload. */
+		file: Blob | Uint8Array | ArrayBuffer;
+		/** Optional upload metadata (content type, custom metadata, etc.). */
+		metadata?: UploadMetadata;
+		/**
+		 * Rendered while the upload is active.
+		 * Receives an object with `{ progress, state, bytesTransferred, totalBytes, pause, resume, cancel }`.
+		 */
+		uploading?: Snippet<[{
+			progress: number;
+			state: UploadState;
+			bytesTransferred: number;
+			totalBytes: number;
+			pause: () => void;
+			resume: () => void;
+			cancel: () => void;
+		}]>;
+		/** Rendered after a successful upload. Receives the download URL. */
+		complete?: Snippet<[string]>;
+		/** Rendered on error. */
+		error?: Snippet<[Error]>;
+	} = $props();
+
+	const task = new FirekitUploadTask(path, file, metadata);
+</script>
+
+{#if task.error && errorSnippet}
+	{@render errorSnippet(task.error)}
+{:else if task.completed && completeSnippet && task.downloadURL}
+	{@render completeSnippet(task.downloadURL)}
+{:else if task.active && uploadingSnippet}
+	{@render uploadingSnippet({
+		progress: task.progress,
+		state: task.state,
+		bytesTransferred: task.bytesTransferred,
+		totalBytes: task.totalBytes,
+		pause: () => task.pause(),
+		resume: () => task.resume(),
+		cancel: () => task.cancel()
+	})}
+{/if}

package/dist/components/UploadTask.svelte.d.ts

@@ -0,0 +1,33 @@
+import type { Snippet } from 'svelte';
+import type { UploadMetadata } from 'firebase/storage';
+import { type UploadState } from '../services/storage.svelte.js';
+type $$ComponentProps = {
+    /** Storage destination path. */
+    path: string;
+    /** File or raw bytes to upload. */
+    file: Blob | Uint8Array | ArrayBuffer;
+    /** Optional upload metadata (content type, custom metadata, etc.). */
+    metadata?: UploadMetadata;
+    /**
+     * Rendered while the upload is active.
+     * Receives an object with `{ progress, state, bytesTransferred, totalBytes, pause, resume, cancel }`.
+     */
+    uploading?: Snippet<[
+        {
+            progress: number;
+            state: UploadState;
+            bytesTransferred: number;
+            totalBytes: number;
+            pause: () => void;
+            resume: () => void;
+            cancel: () => void;
+        }
+    ]>;
+    /** Rendered after a successful upload. Receives the download URL. */
+    complete?: Snippet<[string]>;
+    /** Rendered on error. */
+    error?: Snippet<[Error]>;
+};
+declare const UploadTask: import("svelte").Component<$$ComponentProps, {}, "">;
+type UploadTask = ReturnType<typeof UploadTask>;
+export default UploadTask;

package/dist/config.d.ts

@@ -1,12 +1,35 @@
 import type { FirebaseOptions } from 'firebase/app';
 /**
- * Pre-initialized Firebase configuration instance.
- * Use this to get Firebase configuration options directly.
+ * Initialize Firekit with your Firebase project configuration.
+ * Must be called once before using any Firekit services.
+ *
+ * Works in any Svelte 5 project — no SvelteKit dependency required.
+ *
+ * @example
+ * // Plain Svelte 5
+ * import { initFirekit } from 'svelte-firekit';
+ * initFirekit({ apiKey: '...', authDomain: '...', projectId: '...', ... });
  *
  * @example
- * import { firebaseConfig } from './firebase-config';
- * import { initializeApp } from 'firebase/app';
+ * // SvelteKit — call in +layout.ts or a dedicated firebase.ts module
+ * import { initFirekit } from 'svelte-firekit';
+ * import { PUBLIC_FIREBASE_API_KEY, PUBLIC_FIREBASE_PROJECT_ID } from '$env/static/public';
  *
- * const app = initializeApp(firebaseConfig);
+ * initFirekit({
+ *   apiKey: PUBLIC_FIREBASE_API_KEY,
+ *   authDomain: `${PUBLIC_FIREBASE_PROJECT_ID}.firebaseapp.com`,
+ *   projectId: PUBLIC_FIREBASE_PROJECT_ID,
+ *   storageBucket: `${PUBLIC_FIREBASE_PROJECT_ID}.firebasestorage.app`,
+ *   messagingSenderId: PUBLIC_FIREBASE_MESSAGING_SENDER_ID,
+ *   appId: PUBLIC_FIREBASE_APP_ID,
+ *   measurementId: PUBLIC_FIREBASE_MEASUREMENT_ID, // optional, needed only for Analytics
+ * });
+ */
+export declare function initFirekit(config: FirebaseOptions): void;
+/**
+ * Returns the stored Firebase config. Throws if initFirekit() has not been called.
+ * @internal Used by FirebaseService — consumers should use initFirekit() instead.
  */
-export declare const firebaseConfig: FirebaseOptions;
+export declare function getFirekitConfig(): FirebaseOptions;
+/** Returns true if initFirekit() has been called. */
+export declare function isFirekitConfigured(): boolean;

package/dist/config.js

@@ -1,85 +1,48 @@
-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';
 import { isValidFirebaseConfig } from './types/firebase.js';
+let _config = null;
 /**
- * @module FirebaseConfig
- */
-/**
- * Singleton class that manages Firebase configuration.
- * Implements the Singleton pattern to ensure only one Firebase config instance exists.
+ * Initialize Firekit with your Firebase project configuration.
+ * Must be called once before using any Firekit services.
+ *
+ * Works in any Svelte 5 project — no SvelteKit dependency required.
  *
  * @example
- * // Get Firebase configuration
- * const config = FirebaseConfig.getInstance().getConfig();
+ * // Plain Svelte 5
+ * import { initFirekit } from 'svelte-firekit';
+ * initFirekit({ apiKey: '...', authDomain: '...', projectId: '...', ... });
  *
- * // Initialize Firebase app
- * const app = initializeApp(config);
+ * @example
+ * // SvelteKit — call in +layout.ts or a dedicated firebase.ts module
+ * import { initFirekit } from 'svelte-firekit';
+ * import { PUBLIC_FIREBASE_API_KEY, PUBLIC_FIREBASE_PROJECT_ID } from '$env/static/public';
  *
- * @throws {Error} If any required Firebase configuration variables are missing or invalid
+ * initFirekit({
+ *   apiKey: PUBLIC_FIREBASE_API_KEY,
+ *   authDomain: `${PUBLIC_FIREBASE_PROJECT_ID}.firebaseapp.com`,
+ *   projectId: PUBLIC_FIREBASE_PROJECT_ID,
+ *   storageBucket: `${PUBLIC_FIREBASE_PROJECT_ID}.firebasestorage.app`,
+ *   messagingSenderId: PUBLIC_FIREBASE_MESSAGING_SENDER_ID,
+ *   appId: PUBLIC_FIREBASE_APP_ID,
+ *   measurementId: PUBLIC_FIREBASE_MEASUREMENT_ID, // optional, needed only for Analytics
+ * });
  */
-class FirebaseConfig {
-    static instance;
-    config;
-    /**
-     * Private constructor to prevent direct instantiation.
-     * Validates all required environment variables are present and creates config.
-     *
-     * @private
-     * @throws {Error} If any required Firebase configuration variables are missing or invalid
-     */
-    constructor() {
-        const config = this.getFirebaseConfig();
-        if (!isValidFirebaseConfig(config)) {
-            throw new Error('Invalid Firebase configuration. Please check your environment variables.');
-        }
-        this.config = config;
-    }
-    /**
-     * Gets the Firebase configuration from environment variables.
-     *
-     * @private
-     * @returns {Partial<FirebaseEnvVars>} The Firebase configuration
-     */
-    getFirebaseConfig() {
-        return {
-            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
-        };
-    }
-    /**
-     * Gets the singleton instance of FirebaseConfig.
-     * Creates a new instance if one doesn't exist.
-     *
-     * @returns {FirebaseConfig} The singleton FirebaseConfig instance
-     * @throws {Error} If any required Firebase configuration variables are missing or invalid
-     */
-    static getInstance() {
-        if (!FirebaseConfig.instance) {
-            FirebaseConfig.instance = new FirebaseConfig();
-        }
-        return FirebaseConfig.instance;
-    }
-    /**
-     * Gets the Firebase configuration options.
-     *
-     * @returns {FirebaseOptions} The Firebase configuration options
-     */
-    getConfig() {
-        return this.config;
+export function initFirekit(config) {
+    if (!isValidFirebaseConfig(config)) {
+        throw new Error('Invalid Firebase configuration. Required: apiKey, authDomain, projectId, storageBucket, messagingSenderId, appId.');
     }
+    _config = config;
 }
 /**
- * Pre-initialized Firebase configuration instance.
- * Use this to get Firebase configuration options directly.
- *
- * @example
- * import { firebaseConfig } from './firebase-config';
- * import { initializeApp } from 'firebase/app';
- *
- * const app = initializeApp(firebaseConfig);
+ * Returns the stored Firebase config. Throws if initFirekit() has not been called.
+ * @internal Used by FirebaseService — consumers should use initFirekit() instead.
  */
-export const firebaseConfig = FirebaseConfig.getInstance().getConfig();
+export function getFirekitConfig() {
+    if (!_config) {
+        throw new Error('Firekit is not configured. Call initFirekit(config) before using any Firekit services.');
+    }
+    return _config;
+}
+/** Returns true if initFirekit() has been called. */
+export function isFirekitConfigured() {
+    return _config !== null;
+}

package/dist/context.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Typed Svelte context getters for Firebase service instances.
+ *
+ * These must be called during component initialisation (inside `<script>` or a
+ * function called synchronously at component init time), after a `<FirebaseApp>`
+ * ancestor has set them via `setContext`.
+ *
+ * For the reactive singleton services (`firekitUser`, `firekitAuth`, etc.) you
+ * can also just import them directly — no context needed.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { getFirestoreContext, getAuthContext } from 'svelte-firekit';
+ *   const db = getFirestoreContext();   // Firestore instance
+ *   const auth = getAuthContext();      // Auth instance
+ * </script>
+ * ```
+ */
+import type { FirebaseApp } from 'firebase/app';
+import type { Auth } from 'firebase/auth';
+import type { Firestore } from 'firebase/firestore';
+import type { FirebaseStorage } from 'firebase/storage';
+import type { Database } from 'firebase/database';
+import type { Functions } from 'firebase/functions';
+import type { AppCheck } from 'firebase/app-check';
+import type { firekitAnalytics } from './services/analytics.js';
+import type { firekitMessaging } from './services/messaging.svelte.js';
+/** Returns the `FirebaseApp` instance set by `<FirebaseApp>`. */
+export declare function getFirebaseAppContext(): FirebaseApp | undefined;
+/** Returns the Firebase `Auth` instance set by `<FirebaseApp>`. */
+export declare function getAuthContext(): Auth | undefined;
+/** Returns the `Firestore` instance set by `<FirebaseApp>`. */
+export declare function getFirestoreContext(): Firestore | undefined;
+/** Returns the `FirebaseStorage` instance set by `<FirebaseApp>`. */
+export declare function getStorageContext(): FirebaseStorage | undefined;
+/** Returns the Realtime Database `Database` instance set by `<FirebaseApp>`. */
+export declare function getRTDBContext(): Database | undefined;
+/** Returns the Cloud Functions `Functions` instance set by `<FirebaseApp>`. */
+export declare function getFunctionsContext(): Functions | undefined;
+/** Returns the `AppCheck` instance set by `<FirebaseApp>`, or null if App Check is not enabled. */
+export declare function getAppCheckContext(): AppCheck | null | undefined;
+/** Returns the `firekitAnalytics` singleton set by `<FirebaseApp>`. */
+export declare function getAnalyticsContext(): typeof firekitAnalytics | undefined;
+/** Returns the `firekitMessaging` singleton set by `<FirebaseApp>`. */
+export declare function getMessagingContext(): typeof firekitMessaging | undefined;

package/dist/context.js

@@ -0,0 +1,56 @@
+/**
+ * Typed Svelte context getters for Firebase service instances.
+ *
+ * These must be called during component initialisation (inside `<script>` or a
+ * function called synchronously at component init time), after a `<FirebaseApp>`
+ * ancestor has set them via `setContext`.
+ *
+ * For the reactive singleton services (`firekitUser`, `firekitAuth`, etc.) you
+ * can also just import them directly — no context needed.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { getFirestoreContext, getAuthContext } from 'svelte-firekit';
+ *   const db = getFirestoreContext();   // Firestore instance
+ *   const auth = getAuthContext();      // Auth instance
+ * </script>
+ * ```
+ */
+import { getContext } from 'svelte';
+/** Returns the `FirebaseApp` instance set by `<FirebaseApp>`. */
+export function getFirebaseAppContext() {
+    return getContext('firebase/app');
+}
+/** Returns the Firebase `Auth` instance set by `<FirebaseApp>`. */
+export function getAuthContext() {
+    return getContext('firebase/auth');
+}
+/** Returns the `Firestore` instance set by `<FirebaseApp>`. */
+export function getFirestoreContext() {
+    return getContext('firebase/firestore');
+}
+/** Returns the `FirebaseStorage` instance set by `<FirebaseApp>`. */
+export function getStorageContext() {
+    return getContext('firebase/storage');
+}
+/** Returns the Realtime Database `Database` instance set by `<FirebaseApp>`. */
+export function getRTDBContext() {
+    return getContext('firebase/rtdb');
+}
+/** Returns the Cloud Functions `Functions` instance set by `<FirebaseApp>`. */
+export function getFunctionsContext() {
+    return getContext('firebase/functions');
+}
+/** Returns the `AppCheck` instance set by `<FirebaseApp>`, or null if App Check is not enabled. */
+export function getAppCheckContext() {
+    return getContext('firebase/app-check');
+}
+/** Returns the `firekitAnalytics` singleton set by `<FirebaseApp>`. */
+export function getAnalyticsContext() {
+    return getContext('firebase/analytics');
+}
+/** Returns the `firekitMessaging` singleton set by `<FirebaseApp>`. */
+export function getMessagingContext() {
+    return getContext('firebase/messaging');
+}

package/dist/firebase.d.ts

@@ -1,14 +1,13 @@
 import { FirebaseServiceStatus, type FirebaseServiceInstance } from './types/firebase.js';
+import type { AppCheck } from 'firebase/app-check';
+import type { RemoteConfig } from 'firebase/remote-config';
 /**
- * Singleton service class that manages Firebase service instances.
- * Handles initialization and access to Firebase app and its various services.
+ * Singleton service that manages all Firebase service instances.
+ * Services are initialized lazily — they spin up only when first accessed.
  *
- * @example
- * // Get Firestore instance
- * const db = firebaseService.getDbInstance();
- *
- * // Get Auth instance
- * const auth = firebaseService.getAuthInstance();
+ * Core services (Firestore, Auth, Functions, RTDB, Storage) are always available.
+ * Browser-only services (Analytics, Performance, Messaging) check the environment.
+ * Security services (AppCheck, RemoteConfig) are initialized by their dedicated service files.
  */
 declare class FirebaseService implements FirebaseServiceInstance {
     private static instance;
@@ -19,108 +18,50 @@ declare class FirebaseService implements FirebaseServiceInstance {
     database: FirebaseServiceInstance['database'];
     storage: FirebaseServiceInstance['storage'];
     analytics: FirebaseServiceInstance['analytics'];
+    appCheck: AppCheck | null;
+    remoteConfig: RemoteConfig | null;
+    performance: FirebaseServiceInstance['performance'];
+    messaging: FirebaseServiceInstance['messaging'];
     status: FirebaseServiceStatus;
     initializationError: Error | null;
     readonly isBrowser: boolean;
-    /** @private */
     private constructor();
-    /**
-     * Gets the singleton instance of FirebaseService.
-     * Creates a new instance if one doesn't exist.
-     *
-     * @returns {FirebaseService} The singleton FirebaseService instance
-     */
     static getInstance(): FirebaseService;
-    /**
-     * Gets the current status of the Firebase service
-     *
-     * @returns {FirebaseServiceStatus} The current service status
-     */
     getStatus(): FirebaseServiceStatus;
-    /**
-     * Gets the initialization error if any occurred
-     *
-     * @returns {Error | null} The initialization error or null if none occurred
-     */
     getInitializationError(): Error | null;
-    /**
-     * Initializes or retrieves the Firebase app instance.
-     * Also initializes Firestore if running in browser environment.
-     *
-     * @returns {FirebaseApp} The Firebase app instance
-     * @throws {FirebaseServiceError} If initialization fails
-     */
     getFirebaseApp(): FirebaseServiceInstance['firebaseApp'];
-    /**
-     * Initializes Firestore with persistent cache and multi-tab support.
-     * Only runs in browser environment.
-     *
-     * @private
-     * @throws {FirebaseServiceError} If Firestore initialization fails
-     */
     private initializeFirestoreInstance;
-    /**
-     * Gets the Firestore instance, initializing it if necessary.
-     *
-     * @returns {Firestore} The Firestore instance
-     * @throws {FirebaseServiceError} If Firestore is not available
-     */
     getDbInstance(): FirebaseServiceInstance['db'];
-    /**
-     * Gets the Authentication instance, initializing it if necessary.
-     *
-     * @returns {Auth} The Authentication instance
-     * @throws {FirebaseServiceError} If Auth initialization fails
-     */
     getAuthInstance(): FirebaseServiceInstance['auth'];
-    /**
-     * Gets the Cloud Functions instance, initializing it if necessary.
-     *
-     * @returns {Functions} The Cloud Functions instance
-     * @throws {FirebaseServiceError} If Functions initialization fails
-     */
     getFunctionsInstance(): FirebaseServiceInstance['functions'];
+    getDatabaseInstance(): FirebaseServiceInstance['database'];
+    getStorageInstance(): FirebaseServiceInstance['storage'];
     /**
-     * Gets the Realtime Database instance, initializing it if necessary.
-     *
-     * @returns {Database} The Realtime Database instance
-     * @throws {FirebaseServiceError} If Database initialization fails
+     * Gets the Analytics instance. Returns null if analytics is not supported
+     * (e.g. no measurementId in config, ad-blockers, SSR).
      */
-    getDatabaseInstance(): FirebaseServiceInstance['database'];
+    getAnalyticsInstance(): Promise<FirebaseServiceInstance['analytics']>;
     /**
-     * Gets the Storage instance, initializing it if necessary.
-     *
-     * @returns {FirebaseStorage} The Storage instance
-     * @throws {FirebaseServiceError} If Storage initialization fails
+     * Gets the Performance Monitoring instance. Browser-only.
      */
-    getStorageInstance(): FirebaseServiceInstance['storage'];
+    getPerformanceInstance(): FirebaseServiceInstance['performance'];
     /**
-     * Gets the Analytics instance, initializing it if necessary.
-     * Only available in browser environment.
-     *
-     * @returns {Analytics} The Analytics instance
-     * @throws {FirebaseServiceError} If Analytics initialization fails
+     * Gets the Cloud Messaging instance. Returns null if not supported
+     * (requires HTTPS, service workers, and browser support).
      */
-    getAnalyticsInstance(): FirebaseServiceInstance['analytics'];
+    getMessagingInstance(): Promise<FirebaseServiceInstance['messaging']>;
     /**
-     * Resets the Firebase service to its initial state.
-     * Useful for testing or when you need to reinitialize the services.
-     *
-     * @returns {Promise<void>}
+     * Resets all service instances. Primarily useful for testing.
      */
     reset(): Promise<void>;
 }
 /**
- * Pre-initialized Firebase service instance.
- * Use this to access Firebase services directly.
+ * The global Firebase service singleton.
+ * Access Firebase service instances through this object.
  *
  * @example
- * import { firebaseService } from './firebase-service';
- *
- * // Get Firestore
+ * import { firebaseService } from 'svelte-firekit';
  * const db = firebaseService.getDbInstance();
- *
- * // Get Auth
  * const auth = firebaseService.getAuthInstance();
  */
 export declare const firebaseService: FirebaseService;