svelte-firekit 0.1.9 → 0.2.1

package/dist/services/ai.svelte.js

@@ -0,0 +1,302 @@
+import { getAI, getGenerativeModel, GoogleAIBackend, VertexAIBackend } from 'firebase/ai';
+import { firebaseService } from '../firebase.js';
+function getAIInstance(backend = 'googleai') {
+    const app = firebaseService.getFirebaseApp();
+    if (!app)
+        throw new Error('Firebase app is not initialized.');
+    const backendInstance = backend === 'vertexai' ? new VertexAIBackend() : new GoogleAIBackend();
+    return getAI(app, { backend: backendInstance });
+}
+// ── Content helpers ───────────────────────────────────────────────────────────
+/** Builds a text Part. */
+export function textPart(text) {
+    return { text };
+}
+/** Builds an inline image Part from a base64 data URL or raw base64 string. */
+export function imagePart(base64, mimeType = 'image/jpeg') {
+    const data = base64.startsWith('data:')
+        ? base64.split(',')[1]
+        : base64;
+    return { inlineData: { data, mimeType } };
+}
+/** Builds an image Part from a publicly accessible URL. */
+export function imageUrlPart(url, mimeType = 'image/jpeg') {
+    return { fileData: { fileUri: url, mimeType } };
+}
+// ── One-shot generation ───────────────────────────────────────────────────────
+/**
+ * Reactive one-shot AI generation.
+ *
+ * Calls `generateContent` and exposes reactive state. Re-call `generate()`
+ * to produce new results.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { firekitGenerate } from 'svelte-firekit';
+ *   const gen = firekitGenerate({ model: 'gemini-2.0-flash' });
+ *   gen.generate('Summarize the following: ...');
+ * </script>
+ * {#if gen.loading}<p>Thinking…</p>{/if}
+ * {#if gen.text}<p>{gen.text}</p>{/if}
+ * ```
+ */
+export class FirekitGenerate {
+    _text = $state(null);
+    _loading = $state(false);
+    _error = $state(null);
+    hasResult = $derived(this._text !== null && !this._loading);
+    _model;
+    constructor(options = {}) {
+        const { backend = 'googleai', model = 'gemini-2.0-flash', generationConfig, safetySettings, systemInstruction } = options;
+        const ai = getAIInstance(backend);
+        const params = { model };
+        if (generationConfig)
+            params.generationConfig = generationConfig;
+        if (safetySettings)
+            params.safetySettings = safetySettings;
+        if (systemInstruction)
+            params.systemInstruction = systemInstruction;
+        this._model = getGenerativeModel(ai, params);
+    }
+    get text() { return this._text; }
+    get loading() { return this._loading; }
+    get error() { return this._error; }
+    /**
+     * Generates a response for the given prompt (text or multi-part content).
+     * Returns the generated text, or null on error.
+     */
+    async generate(prompt) {
+        this._loading = true;
+        this._error = null;
+        try {
+            const result = await this._model.generateContent(prompt);
+            const text = result.response.text();
+            this._text = text;
+            return text;
+        }
+        catch (err) {
+            this._error = err instanceof Error ? err : new Error(String(err));
+            return null;
+        }
+        finally {
+            this._loading = false;
+        }
+    }
+    /** Resets result and error state. */
+    reset() {
+        this._text = null;
+        this._error = null;
+    }
+}
+// ── Streaming generation ──────────────────────────────────────────────────────
+/**
+ * Reactive streaming AI generation.
+ *
+ * Streams tokens into `text` as they arrive from the model.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { firekitStream } from 'svelte-firekit';
+ *   const gen = firekitStream({ model: 'gemini-2.0-flash' });
+ *   gen.generate('Write a poem about Svelte.');
+ * </script>
+ * {#if gen.streaming}<span class="cursor">▍</span>{/if}
+ * <p>{gen.text}</p>
+ * ```
+ */
+export class FirekitStream {
+    _text = $state('');
+    _streaming = $state(false);
+    _loading = $state(false);
+    _error = $state(null);
+    done = $derived(!this._loading && !this._streaming);
+    _model;
+    constructor(options = {}) {
+        const { backend = 'googleai', model = 'gemini-2.0-flash', generationConfig, safetySettings, systemInstruction } = options;
+        const ai = getAIInstance(backend);
+        const params = { model };
+        if (generationConfig)
+            params.generationConfig = generationConfig;
+        if (safetySettings)
+            params.safetySettings = safetySettings;
+        if (systemInstruction)
+            params.systemInstruction = systemInstruction;
+        this._model = getGenerativeModel(ai, params);
+    }
+    get text() { return this._text; }
+    get streaming() { return this._streaming; }
+    get loading() { return this._loading; }
+    get error() { return this._error; }
+    /**
+     * Streams a response for the given prompt.
+     * Resolves with the full text once streaming completes.
+     */
+    async generate(prompt) {
+        this._text = '';
+        this._loading = true;
+        this._streaming = false;
+        this._error = null;
+        try {
+            const stream = await this._model.generateContentStream(prompt);
+            this._loading = false;
+            this._streaming = true;
+            for await (const chunk of stream.stream) {
+                const chunkText = chunk.text();
+                this._text += chunkText;
+            }
+            // Final aggregated response
+            const final = await stream.response;
+            this._text = final.text();
+            return this._text;
+        }
+        catch (err) {
+            this._error = err instanceof Error ? err : new Error(String(err));
+            return '';
+        }
+        finally {
+            this._streaming = false;
+            this._loading = false;
+        }
+    }
+    /** Resets accumulated text and error. */
+    reset() {
+        this._text = '';
+        this._error = null;
+    }
+}
+// ── Chat session ──────────────────────────────────────────────────────────────
+/**
+ * Reactive multi-turn chat session.
+ *
+ * Maintains conversation history and exposes reactive state for each
+ * assistant turn (supports both streaming and non-streaming).
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { firekitChat } from 'svelte-firekit';
+ *   const chat = firekitChat({ model: 'gemini-2.0-flash' });
+ *   await chat.send('Hello!');
+ * </script>
+ * {#each chat.history as msg}
+ *   <div class={msg.role}>{msg.text}</div>
+ * {/each}
+ * {#if chat.streaming}<span>▍</span>{/if}
+ * ```
+ */
+export class FirekitChat {
+    _history = $state([]);
+    _pendingText = $state('');
+    _loading = $state(false);
+    _streaming = $state(false);
+    _error = $state(null);
+    lastMessage = $derived(this._history.length > 0 ? this._history[this._history.length - 1] : null);
+    isEmpty = $derived(this._history.length === 0);
+    _session;
+    constructor(options = {}, initialHistory = []) {
+        const { backend = 'googleai', model = 'gemini-2.0-flash', generationConfig, safetySettings, systemInstruction } = options;
+        const ai = getAIInstance(backend);
+        const params = { model };
+        if (generationConfig)
+            params.generationConfig = generationConfig;
+        if (safetySettings)
+            params.safetySettings = safetySettings;
+        if (systemInstruction)
+            params.systemInstruction = systemInstruction;
+        const genModel = getGenerativeModel(ai, params);
+        this._session = genModel.startChat({ history: initialHistory });
+        // Seed history from initialHistory
+        for (const turn of initialHistory) {
+            const text = turn.parts
+                .map((p) => ('text' in p ? p.text : ''))
+                .filter(Boolean)
+                .join('');
+            this._history.push({
+                role: turn.role,
+                parts: turn.parts,
+                text
+            });
+        }
+    }
+    get history() { return this._history; }
+    get pendingText() { return this._pendingText; }
+    get loading() { return this._loading; }
+    get streaming() { return this._streaming; }
+    get error() { return this._error; }
+    /**
+     * Sends a message and returns the model's response text.
+     * Uses streaming by default for a responsive UI.
+     */
+    async send(message, { stream = true } = {}) {
+        const parts = typeof message === 'string' ? [{ text: message }] : message;
+        const userText = parts.map((p) => ('text' in p ? p.text : '')).join('');
+        this._history.push({ role: 'user', parts, text: userText });
+        this._pendingText = '';
+        this._loading = true;
+        this._error = null;
+        try {
+            let responseText = '';
+            if (stream) {
+                const result = await this._session.sendMessageStream(parts);
+                this._loading = false;
+                this._streaming = true;
+                for await (const chunk of result.stream) {
+                    const chunkText = chunk.text();
+                    this._pendingText += chunkText;
+                }
+                const final = await result.response;
+                responseText = final.text();
+            }
+            else {
+                const result = await this._session.sendMessage(parts);
+                this._loading = false;
+                responseText = result.response.text();
+            }
+            this._history.push({
+                role: 'model',
+                parts: [{ text: responseText }],
+                text: responseText
+            });
+            this._pendingText = '';
+            return responseText;
+        }
+        catch (err) {
+            this._error = err instanceof Error ? err : new Error(String(err));
+            this._pendingText = '';
+            return '';
+        }
+        finally {
+            this._loading = false;
+            this._streaming = false;
+        }
+    }
+    /** Clears the conversation history and starts a fresh session. */
+    clear() {
+        this._history = [];
+        this._pendingText = '';
+        this._error = null;
+    }
+}
+// ── Factory functions ─────────────────────────────────────────────────────────
+/**
+ * Creates a reactive one-shot AI text generator.
+ */
+export function firekitGenerate(options) {
+    return new FirekitGenerate(options);
+}
+/**
+ * Creates a reactive streaming AI text generator.
+ */
+export function firekitStream(options) {
+    return new FirekitStream(options);
+}
+/**
+ * Creates a reactive multi-turn AI chat session.
+ */
+export function firekitChat(options, initialHistory) {
+    return new FirekitChat(options, initialHistory);
+}
+// Re-export useful Firebase AI types consumers may need
+export { GoogleAIBackend, VertexAIBackend };

package/dist/services/analytics.d.ts

@@ -1,272 +1,80 @@
+import { type ConsentSettings } from 'firebase/analytics';
 /**
- * @fileoverview FirekitAnalytics - Google Analytics Service for SvelteKit with Firebase Analytics
- * @module FirekitAnalytics
- * @version 1.0.0
- */
-import { type Analytics } from 'firebase/analytics';
-import type { AnalyticsEvent, EcommerceItem, PurchaseEvent, FormSubmissionEvent, SearchEvent, PageViewEvent, EngagementEvent } from '../types/analytics.js';
-/**
- * Comprehensive Firebase Analytics service for SvelteKit applications.
- * Provides a complete analytics solution with automatic user tracking,
- * e-commerce tracking, and SvelteKit-specific features.
+ * Firebase Analytics wrapper.
+ *
+ * Lazily initializes Analytics (checks `isSupported()` first) and
+ * provides a clean, typed API for event logging and user properties.
  *
- * @class FirekitAnalytics
  * @example
- * ```typescript
+ * ```ts
  * import { firekitAnalytics } from 'svelte-firekit';
  *
- * // Track a custom event
- * firekitAnalytics.trackEvent('button_click', { button_name: 'signup' });
- *
- * // Track a purchase
- * firekitAnalytics.trackPurchase({
- *   transaction_id: 'T12345',
- *   value: 29.99,
- *   currency: 'USD',
- *   items: [{ item_id: 'prod_123', item_name: 'Premium Plan' }]
- * });
+ * firekitAnalytics.logEvent('purchase', { value: 9.99, currency: 'USD' });
+ * firekitAnalytics.setUserId(user.uid);
  * ```
  */
 declare class FirekitAnalytics {
     private static instance;
-    private analytics;
-    private _initialized;
-    private customParameters;
-    private debugMode;
+    private _analytics;
+    private _initPromise;
     private constructor();
-    /**
-     * Gets singleton instance of FirekitAnalytics
-     * @returns {FirekitAnalytics} The FirekitAnalytics instance
-     */
     static getInstance(): FirekitAnalytics;
+    private _init;
+    private _get;
     /**
-     * Initializes the analytics service
-     */
-    private initialize;
-    /**
-     * Checks if analytics is available
-     * @private
-     */
-    private isAnalyticsAvailable;
-    /**
-     * Gets the analytics instance
-     * @returns {Analytics | null} Firebase Analytics instance
-     */
-    getAnalyticsInstance(): Analytics | null;
-    /**
-     * Checks if analytics is initialized
-     * @returns {boolean} True if analytics is initialized
-     */
-    isInitialized(): boolean;
-    /**
-     * Logs a custom analytics event
-     * @param {string} eventName Name of the event
-     * @param {Record<string, any>} parameters Event parameters
+     * Logs a custom or standard analytics event.
      *
      * @example
-     * ```typescript
-     * firekitAnalytics.trackEvent('button_click', {
-     *   button_name: 'signup',
-     *   page_location: '/home'
-     * });
+     * ```ts
+     * firekitAnalytics.logEvent('sign_up', { method: 'google' });
+     * firekitAnalytics.logEvent('page_view', { page_title: 'Home' });
      * ```
      */
-    trackEvent(eventName: string, parameters?: Record<string, any>): void;
+    logEvent(eventName: string, eventParams?: Record<string, unknown>): Promise<void>;
     /**
-     * Tracks page view events
-     * @param {PageViewEvent} pageView Page view data
-     *
-     * @example
-     * ```typescript
-     * firekitAnalytics.trackPageView({
-     *   page_path: '/products',
-     *   page_title: 'Products Page'
-     * });
-     * ```
-     */
-    trackPageView(pageView: PageViewEvent): void;
-    /**
-     * Sets user ID for analytics
-     * @param {string | null} userId User ID or null to clear
+     * Sets the Analytics user ID.
+     * Pass `null` to clear the user ID (e.g. on sign-out).
      */
-    setUserId(userId: string | null): void;
+    setUserId(id: string | null): Promise<void>;
     /**
-     * Sets user properties for analytics
-     * @param {Record<string, any>} properties User properties
+     * Sets Analytics user properties.
      *
      * @example
-     * ```typescript
-     * firekitAnalytics.setUserProperties({
-     *   user_type: 'premium',
-     *   subscription_plan: 'pro'
-     * });
+     * ```ts
+     * firekitAnalytics.setUserProperties({ plan: 'pro', locale: 'en-US' });
      * ```
      */
-    setUserProperties(properties: Record<string, any>): void;
+    setUserProperties(properties: Record<string, string | null>): Promise<void>;
     /**
-     * Tracks purchase events
-     * @param {PurchaseEvent} purchase Purchase data
+     * Logs a screen_view event.
      *
      * @example
-     * ```typescript
-     * firekitAnalytics.trackPurchase({
-     *   transaction_id: 'T12345',
-     *   value: 29.99,
-     *   currency: 'USD',
-     *   items: [{
-     *     item_id: 'prod_123',
-     *     item_name: 'Premium Plan',
-     *     price: 29.99
-     *   }]
-     * });
+     * ```ts
+     * firekitAnalytics.setCurrentScreen('ProductDetail');
      * ```
      */
-    trackPurchase(purchase: PurchaseEvent): void;
+    setCurrentScreen(screenName: string): Promise<void>;
     /**
-     * Tracks add to cart events
-     * @param {EcommerceItem} item Item being added to cart
-     * @param {number} value Total value of the cart
-     * @param {string} currency Currency code
-     *
-     * @example
-     * ```typescript
-     * firekitAnalytics.trackAddToCart({
-     *   item_id: 'prod_123',
-     *   item_name: 'Premium Plan',
-     *   price: 29.99
-     * }, 29.99, 'USD');
-     * ```
+     * Sets default parameters that will be included with every logged event.
      */
-    trackAddToCart(item: EcommerceItem, value: number, currency?: string): void;
+    setDefaultEventParameters(params: Record<string, unknown> | null): Promise<void>;
     /**
-     * Tracks remove from cart events
-     * @param {EcommerceItem} item Item being removed from cart
-     * @param {number} value Total value of the cart
-     * @param {string} currency Currency code
-     */
-    trackRemoveFromCart(item: EcommerceItem, value: number, currency?: string): void;
-    /**
-     * Tracks view item events
-     * @param {EcommerceItem} item Item being viewed
-     */
-    trackViewItem(item: EcommerceItem): void;
-    /**
-     * Tracks begin checkout events
-     * @param {EcommerceItem[]} items Items in cart
-     * @param {number} value Total value
-     * @param {string} currency Currency code
-     */
-    trackBeginCheckout(items: EcommerceItem[], value: number, currency?: string): void;
-    /**
-     * Tracks form submission events
-     * @param {FormSubmissionEvent} formSubmission Form submission data
-     *
-     * @example
-     * ```typescript
-     * firekitAnalytics.trackFormSubmission({
-     *   form_name: 'contact_form',
-     *   success: true
-     * });
-     * ```
+     * Enables or disables Analytics data collection.
+     * Useful for respecting user consent.
      */
-    trackFormSubmission(formSubmission: FormSubmissionEvent): void;
+    setCollectionEnabled(enabled: boolean): Promise<void>;
     /**
-     * Tracks search events
-     * @param {SearchEvent} search Search data
+     * Updates consent settings (GDPR, CCPA, etc.).
      *
      * @example
-     * ```typescript
-     * firekitAnalytics.trackSearch({
-     *   search_term: 'premium features',
-     *   results_count: 15
+     * ```ts
+     * firekitAnalytics.setConsent({
+     *   analytics_storage: 'granted',
+     *   ad_storage: 'denied'
      * });
      * ```
      */
-    trackSearch(search: SearchEvent): void;
-    /**
-     * Tracks custom conversion events
-     * @param {string} conversionName Name of the conversion
-     * @param {number} value Conversion value
-     * @param {string} currency Currency code
-     */
-    trackConversion(conversionName: string, value?: number, currency?: string): void;
-    /**
-     * Tracks user engagement events
-     * @param {EngagementEvent} engagement Engagement data
-     */
-    trackEngagement(engagement: EngagementEvent): void;
-    /**
-     * Initializes automatic page tracking for SvelteKit
-     * @param {boolean} trackInitialPage Whether to track the initial page load
-     *
-     * @example
-     * ```typescript
-     * // In your app.html or layout
-     * firekitAnalytics.initPageTracking();
-     * ```
-     */
-    initPageTracking(trackInitialPage?: boolean): void;
-    /**
-     * Tracks route changes manually (useful for custom routing)
-     * @param {string} route Route path
-     * @param {string} title Page title
-     */
-    trackRouteChange(route: string, title?: string): void;
-    /**
-     * Sets custom parameters that will be included in all subsequent events
-     * @param {Record<string, any>} parameters Custom parameters
-     */
-    setCustomParameters(parameters: Record<string, any>): void;
-    /**
-     * Clears custom parameters
-     */
-    clearCustomParameters(): void;
-    /**
-     * Tracks multiple events in batch
-     * @param {AnalyticsEvent[]} events Array of events to track
-     */
-    trackEvents(events: AnalyticsEvent[]): void;
-    /**
-     * Enables or disables analytics collection
-     * @param {boolean} enabled Whether to enable analytics collection
-     */
-    setAnalyticsEnabled(enabled: boolean): void;
-    /**
-     * Sets debug mode for analytics
-     * @param {boolean} enabled Whether to enable debug mode
-     */
-    setDebugMode(enabled: boolean): void;
-    /**
-     * Gets current debug mode status
-     * @returns {boolean} Current debug mode status
-     */
-    getDebugMode(): boolean;
-    /**
-     * Cleans up analytics resources
-     */
-    cleanup(): void;
+    setConsent(settings: ConsentSettings): Promise<void>;
 }
-/**
- * Pre-initialized singleton instance of FirekitAnalytics.
- * This is the main export that should be used throughout your application.
- *
- * @example
- * ```typescript
- * import { firekitAnalytics } from 'svelte-firekit';
- *
- * // Track a custom event
- * firekitAnalytics.trackEvent('button_click', { button_name: 'signup' });
- *
- * // Initialize page tracking
- * firekitAnalytics.initPageTracking();
- *
- * // Track a purchase
- * firekitAnalytics.trackPurchase({
- *   transaction_id: 'T12345',
- *   value: 29.99,
- *   currency: 'USD'
- * });
- * ```
- */
 export declare const firekitAnalytics: FirekitAnalytics;
 export {};