indas-ui 0.0.1 → 0.1.1

package/dist/contexts/CurrencyContext.js

@@ -0,0 +1,331 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useEffect, useCallback } from 'react';
+// Resolve symbol from Intl API — no hardcoding
+export function getSymbolForCode(code) {
+    try {
+        const parts = new Intl.NumberFormat('en', { style: 'currency', currency: code, currencyDisplay: 'narrowSymbol' }).formatToParts(0);
+        return parts.find(p => p.type === 'currency')?.value || code;
+    }
+    catch {
+        return code;
+    }
+}
+// Build CurrencyInfo from API code + name — everything derived, nothing hardcoded
+function buildCurrencyInfo(code, name) {
+    const zeroDecimals = new Set(['JPY', 'KRW', 'HUF', 'ISK', 'IDR']);
+    return {
+        code,
+        name,
+        symbol: getSymbolForCode(code),
+        flag: '',
+        decimal: zeroDecimals.has(code) ? 0 : 2,
+    };
+}
+const CurrencyContext = createContext(undefined);
+// Reliable exchange rate service with multiple APIs
+class ExchangeRateService {
+    constructor() {
+        this.cache = null;
+        this.CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
+    }
+    static getInstance() {
+        if (!ExchangeRateService.instance) {
+            ExchangeRateService.instance = new ExchangeRateService();
+        }
+        return ExchangeRateService.instance;
+    }
+    async fetchFromAPI(base) {
+        try {
+            const response = await fetch(`https://api.frankfurter.dev/v1/latest?base=${base}`, {
+                method: 'GET',
+                headers: {
+                    'Accept': 'application/json',
+                }
+            });
+            if (!response.ok) {
+                return null;
+            }
+            const data = await response.json();
+            const rates = data.rates;
+            if (rates && typeof rates === 'object') {
+                const normalizedRates = { [base]: 1 };
+                for (const [key, value] of Object.entries(rates)) {
+                    normalizedRates[key.toUpperCase()] = value;
+                }
+                return normalizedRates;
+            }
+        }
+        catch (error) {
+            // Silent fail - currency conversion is optional
+        }
+        return null;
+    }
+    async getRates(base) {
+        // Check cache (invalidate if base changed)
+        if (this.cache && Date.now() - this.cache.timestamp < this.CACHE_DURATION && this.cache.rates[base] === 1) {
+            return this.cache.rates;
+        }
+        try {
+            const apiRates = await this.fetchFromAPI(base);
+            if (apiRates) {
+                this.cache = {
+                    rates: apiRates,
+                    timestamp: Date.now()
+                };
+                return apiRates;
+            }
+        }
+        catch (error) {
+            // Exchange rate API unavailable - fallback to base only
+        }
+        const baseRates = { [base]: 1 };
+        this.cache = {
+            rates: baseRates,
+            timestamp: Date.now()
+        };
+        return baseRates;
+    }
+}
+export function CurrencyProvider({ children, baseCurrencyCode }) {
+    const resolvedBase = baseCurrencyCode || 'INR';
+    const [selectedCurrency, setSelectedCurrency] = useState(resolvedBase);
+    const [baseCurrency, setBaseCurrency] = useState(resolvedBase);
+    const [exchangeRates, setExchangeRates] = useState({});
+    const [availableCurrencies, setAvailableCurrencies] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [lastUpdated, setLastUpdated] = useState(null);
+    const [error, setError] = useState(null);
+    const [manualRates, setManualRates] = useState(new Map());
+    const exchangeService = ExchangeRateService.getInstance();
+    const refreshRates = useCallback(async () => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const rates = await exchangeService.getRates(baseCurrency);
+            setExchangeRates(rates);
+            setLastUpdated(new Date());
+        }
+        catch (err) {
+            setError('Failed to fetch exchange rates');
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [exchangeService, baseCurrency]);
+    // Fetch full currency list from API on mount
+    useEffect(() => {
+        let cancelled = false;
+        async function fetchCurrencies() {
+            try {
+                const res = await fetch('https://api.frankfurter.dev/v1/currencies');
+                if (!res.ok)
+                    return;
+                const data = await res.json();
+                if (cancelled)
+                    return;
+                const list = Object.entries(data).map(([code, name]) => buildCurrencyInfo(code, name));
+                // Ensure base currency is always in the list even if API doesn't return it
+                if (!list.some(c => c.code === resolvedBase)) {
+                    list.unshift(buildCurrencyInfo(resolvedBase, resolvedBase));
+                }
+                setAvailableCurrencies(list);
+            }
+            catch {
+                // API down — create a minimal entry from the DB base currency so dropdown isn't empty
+                setAvailableCurrencies([buildCurrencyInfo(resolvedBase, resolvedBase)]);
+            }
+        }
+        fetchCurrencies();
+        return () => { cancelled = true; };
+    }, [resolvedBase]);
+    // Update base currency when session loads
+    useEffect(() => {
+        if (baseCurrencyCode && baseCurrencyCode !== baseCurrency) {
+            setBaseCurrency(baseCurrencyCode);
+            // Also update selected if it was still the old default
+            setSelectedCurrency(prev => {
+                const saved = localStorage.getItem('selectedCurrency');
+                return saved || baseCurrencyCode;
+            });
+        }
+    }, [baseCurrencyCode]);
+    // Auto-refresh exchange rates
+    useEffect(() => {
+        refreshRates();
+        const interval = setInterval(refreshRates, 5 * 60 * 1000); // 5 minutes
+        return () => clearInterval(interval);
+    }, [refreshRates]);
+    const setCurrency = useCallback((currency) => {
+        setSelectedCurrency(currency);
+        // Store in localStorage for persistence
+        localStorage.setItem('selectedCurrency', currency);
+    }, []);
+    // Load saved currency on mount (after currencies are loaded)
+    useEffect(() => {
+        if (availableCurrencies.length > 0) {
+            const saved = localStorage.getItem('selectedCurrency');
+            const currencyExists = availableCurrencies.some(c => c.code === saved);
+            if (saved && currencyExists) {
+                setSelectedCurrency(saved);
+            }
+        }
+    }, [availableCurrencies]);
+    const convertAmount = useCallback((amount, from = baseCurrency, to = selectedCurrency) => {
+        if (from === to)
+            return amount;
+        if (!amount || amount === 0)
+            return 0;
+        const manualRateKey = `${from}-${to}`;
+        const manualRate = manualRates.get(manualRateKey);
+        if (manualRate) {
+            return amount * manualRate;
+        }
+        // Use exchange rates
+        if (from === baseCurrency) {
+            const rate = exchangeRates[to];
+            return rate ? amount * rate : amount;
+        }
+        if (to === baseCurrency) {
+            const rate = exchangeRates[from];
+            return rate ? amount / rate : amount;
+        }
+        // Cross currency conversion via base currency
+        const fromRate = exchangeRates[from];
+        const toRate = exchangeRates[to];
+        if (fromRate && toRate) {
+            const inBaseCurrency = amount / fromRate;
+            return inBaseCurrency * toRate;
+        }
+        return amount;
+    }, [baseCurrency, selectedCurrency, exchangeRates, manualRates]);
+    const formatCurrency = useCallback((amount, currency = selectedCurrency, options) => {
+        const currencyInfo = availableCurrencies.find(c => c.code === currency);
+        if (!currencyInfo)
+            return amount.toString();
+        const { showSymbol = true, locale = 'en-IN', compact = false, precision = currencyInfo.decimal } = options || {};
+        // Handle zero and negative amounts
+        if (amount === 0) {
+            return showSymbol ? `${currencyInfo.symbol}0${precision > 0 ? '.' + '0'.repeat(precision) : ''}` : '0';
+        }
+        try {
+            if (compact && Math.abs(amount) >= 1000) {
+                // Compact formatting for large numbers
+                const formatValue = (num, suffix) => {
+                    const formatted = new Intl.NumberFormat(locale, {
+                        style: 'decimal',
+                        minimumFractionDigits: 1,
+                        maximumFractionDigits: 1
+                    }).format(num);
+                    return showSymbol ? `${currencyInfo.symbol}${formatted}${suffix}` : `${formatted}${suffix}`;
+                };
+                if (Math.abs(amount) >= 10000000) { // 1 crore
+                    return formatValue(amount / 10000000, 'Cr');
+                }
+                else if (Math.abs(amount) >= 100000) { // 1 lakh
+                    return formatValue(amount / 100000, 'L');
+                }
+                else if (Math.abs(amount) >= 1000) { // 1 thousand
+                    return formatValue(amount / 1000, 'K');
+                }
+            }
+            // Standard formatting - use decimal style + manual symbol to avoid
+            // Intl rendering full currency name (e.g. "IndianRupee" instead of "₹")
+            const formatted = new Intl.NumberFormat(locale, {
+                style: 'decimal',
+                minimumFractionDigits: precision,
+                maximumFractionDigits: precision
+            }).format(amount);
+            return showSymbol ? `${currencyInfo.symbol}${formatted}` : formatted;
+        }
+        catch {
+            // Fallback formatting
+            const formattedAmount = amount.toLocaleString(locale, {
+                minimumFractionDigits: precision,
+                maximumFractionDigits: precision
+            });
+            return showSymbol ? `${currencyInfo.symbol}${formattedAmount}` : formattedAmount;
+        }
+    }, [selectedCurrency, availableCurrencies]);
+    const parseCurrencyInput = useCallback((input, currency = selectedCurrency) => {
+        if (!input || input.trim() === '')
+            return null;
+        const currencyInfo = availableCurrencies.find(c => c.code === currency);
+        if (!currencyInfo)
+            return null;
+        // Remove currency symbols and common formatting
+        let cleaned = input
+            .replace(new RegExp(currencyInfo.symbol, 'g'), '')
+            .replace(/[,\s]/g, '') // Remove commas and spaces
+            .replace(/[₹$€£¥]/g, '') // Remove common currency symbols
+            .trim();
+        // Handle Indian notation (L for lakh, Cr for crore, K for thousand)
+        if (cleaned.toLowerCase().includes('cr')) {
+            const number = parseFloat(cleaned.replace(/cr/i, ''));
+            if (!isNaN(number))
+                return number * 10000000; // 1 crore = 10 million
+        }
+        if (cleaned.toLowerCase().includes('l')) {
+            const number = parseFloat(cleaned.replace(/l/i, ''));
+            if (!isNaN(number))
+                return number * 100000; // 1 lakh = 100,000
+        }
+        if (cleaned.toLowerCase().includes('k')) {
+            const number = parseFloat(cleaned.replace(/k/i, ''));
+            if (!isNaN(number))
+                return number * 1000; // 1K = 1,000
+        }
+        // Parse as regular number
+        const parsed = parseFloat(cleaned);
+        return isNaN(parsed) ? null : parsed;
+    }, [selectedCurrency, availableCurrencies]);
+    const getCurrencyInfo = useCallback((currency) => {
+        return availableCurrencies.find(c => c.code === currency) || null;
+    }, [availableCurrencies]);
+    const getAllCurrencies = useCallback(() => {
+        return availableCurrencies;
+    }, [availableCurrencies]);
+    const setManualRate = useCallback((from, to, rate) => {
+        const key = `${from}-${to}`;
+        setManualRates(prev => new Map(prev.set(key, rate)));
+    }, []);
+    const removeManualRate = useCallback((from, to) => {
+        const key = `${from}-${to}`;
+        setManualRates(prev => {
+            const newMap = new Map(prev);
+            newMap.delete(key);
+            return newMap;
+        });
+    }, []);
+    const isManualRate = useCallback((from, to) => {
+        const key = `${from}-${to}`;
+        return manualRates.has(key);
+    }, [manualRates]);
+    const value = {
+        selectedCurrency,
+        baseCurrency,
+        exchangeRates,
+        availableCurrencies,
+        isLoading,
+        lastUpdated,
+        error,
+        setCurrency,
+        refreshRates,
+        convertAmount,
+        formatCurrency,
+        parseCurrencyInput,
+        getCurrencyInfo,
+        getAllCurrencies,
+        setManualRate,
+        removeManualRate,
+        isManualRate
+    };
+    return (_jsx(CurrencyContext.Provider, { value: value, children: children }));
+}
+export function useCurrency() {
+    const context = useContext(CurrencyContext);
+    if (context === undefined) {
+        throw new Error('useCurrency must be used within a CurrencyProvider');
+    }
+    return context;
+}

package/dist/contexts/DeviceContext.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+interface DeviceContextValue {
+    deviceType: 'desktop' | 'mobile' | 'tablet';
+    isMobile: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+}
+export declare function DeviceProvider({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+export declare function useDevice(): DeviceContextValue;
+export {};

package/dist/contexts/DeviceContext.js

@@ -0,0 +1,69 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+const DeviceContext = React.createContext({
+    deviceType: 'desktop',
+    isMobile: false,
+    isTablet: false,
+    isDesktop: true,
+});
+export function DeviceProvider({ children }) {
+    const [deviceType, setDeviceType] = React.useState('desktop');
+    React.useEffect(() => {
+        const update = () => {
+            const width = window.innerWidth;
+            // Use viewport width only — UA-based detection breaks DevTools responsive mode
+            if (width <= 768) {
+                setDeviceType('mobile');
+            }
+            else if (width <= 1024) {
+                setDeviceType('tablet');
+            }
+            else {
+                setDeviceType('desktop');
+            }
+        };
+        update();
+        const mql = window.matchMedia('(max-width: 768px)');
+        const tabletMql = window.matchMedia('(max-width: 1024px)');
+        const handler = () => update();
+        mql.addEventListener('change', handler);
+        tabletMql.addEventListener('change', handler);
+        return () => {
+            mql.removeEventListener('change', handler);
+            tabletMql.removeEventListener('change', handler);
+        };
+    }, []);
+    // Sync <meta name="theme-color"> from --color-primary CSS variable
+    React.useEffect(() => {
+        const syncThemeColor = () => {
+            const rgb = getComputedStyle(document.documentElement).getPropertyValue('--color-primary').trim();
+            if (!rgb)
+                return;
+            const [r, g, b] = rgb.split(/\s+/).map(Number);
+            const hex = `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)}`;
+            let meta = document.querySelector('meta[name="theme-color"]');
+            if (!meta) {
+                meta = document.createElement('meta');
+                meta.name = 'theme-color';
+                document.head.appendChild(meta);
+            }
+            meta.content = hex;
+        };
+        syncThemeColor();
+        // Re-sync when theme class changes on <html>
+        const observer = new MutationObserver(syncThemeColor);
+        observer.observe(document.documentElement, { attributes: true, attributeFilter: ['class'] });
+        return () => observer.disconnect();
+    }, []);
+    const value = React.useMemo(() => ({
+        deviceType,
+        isMobile: deviceType === 'mobile',
+        isTablet: deviceType === 'tablet',
+        isDesktop: deviceType === 'desktop',
+    }), [deviceType]);
+    return (_jsx(DeviceContext.Provider, { value: value, children: children }));
+}
+export function useDevice() {
+    return React.useContext(DeviceContext);
+}

package/dist/contexts/EmailContext.d.ts

@@ -0,0 +1,112 @@
+import React from 'react';
+import { type EmailAPI } from '../lib/api/activity/email/index.js';
+import type { Email, EmailThread, EmailFolder, EmailCategory, EmailTemplate, EmailSearchFilters, EmailDraft, EmailContact, EmailSendRequest } from '../lib/api/activity/email/index.js';
+interface FolderCacheEntry {
+    emails: Email[];
+    totalCount: number;
+    hasMore: boolean;
+    fetchedAt: number;
+}
+interface EmailState {
+    emails: Email[];
+    threads: EmailThread[];
+    folders: EmailFolder[];
+    categories: EmailCategory[];
+    templates: EmailTemplate[];
+    drafts: EmailDraft[];
+    contacts: EmailContact[];
+    folderCache: Record<string, FolderCacheEntry>;
+    folderCounts: Record<string, number>;
+    selectedEmailId: string | null;
+    selectedThreadId: string | null;
+    selectedFolderId: string | null;
+    selectedCategory: EmailCategory['type'] | null;
+    currentView: 'inbox' | 'sent' | 'drafts' | 'starred' | 'archive' | 'spam' | 'trash' | 'search';
+    loading: boolean;
+    loadingMore: boolean;
+    sendingEmail: boolean;
+    savingDraft: boolean;
+    currentPage: number;
+    hasMore: boolean;
+    totalCount: number;
+    unreadCount: number;
+    searchQuery: string;
+    searchFilters: EmailSearchFilters;
+    composeOpen: boolean;
+    replyToEmail: Email | null;
+    initialDraftData: Partial<EmailDraft> | null;
+    error: string | null;
+    isConnected: boolean;
+    lastSyncTime: Date | null;
+}
+interface EmailContextValue {
+    state: EmailState;
+    api: EmailAPI;
+    actions: {
+        fetchAllFolders: () => Promise<void>;
+        fetchEmails: (filters?: EmailSearchFilters, page?: number) => Promise<void>;
+        fetchPage: (page: number) => Promise<void>;
+        fetchMoreEmails: () => Promise<void>;
+        fetchEmailById: (emailId: string) => Promise<Email | null>;
+        fetchThread: (threadId: string) => Promise<EmailThread | null>;
+        fetchFolders: () => Promise<void>;
+        fetchCategories: () => Promise<void>;
+        fetchTemplates: () => Promise<void>;
+        fetchDrafts: () => Promise<void>;
+        fetchContacts: (search?: string) => Promise<void>;
+        fetchUnreadCount: () => Promise<void>;
+        sendEmail: (emailData: EmailSendRequest) => Promise<void>;
+        saveDraft: (draft: EmailDraft) => Promise<void>;
+        updateEmailStatus: (emailId: string, updates: Partial<Email>) => Promise<void>;
+        deleteEmail: (emailId: string) => Promise<void>;
+        openCompose: (replyToEmail?: Email, initialData?: Partial<EmailDraft>) => void;
+        closeCompose: () => void;
+        selectEmail: (emailId: string) => void;
+        selectFolder: (folderId: string) => void;
+        selectCategory: (category: EmailCategory['type']) => void;
+        setCurrentView: (view: EmailState['currentView']) => void;
+        setSearchQuery: (query: string) => void;
+        setSearchFilters: (filters: EmailSearchFilters) => void;
+        performSearch: (query: string, filters?: EmailSearchFilters) => Promise<void>;
+        refreshEmails: () => Promise<void>;
+        clearError: () => void;
+        resetState: () => void;
+    };
+}
+export declare function EmailProvider({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+export declare function useEmail(): EmailContextValue;
+export declare function useEmailState(): EmailState;
+export declare function useEmailActions(): {
+    fetchAllFolders: () => Promise<void>;
+    fetchEmails: (filters?: EmailSearchFilters, page?: number) => Promise<void>;
+    fetchPage: (page: number) => Promise<void>;
+    fetchMoreEmails: () => Promise<void>;
+    fetchEmailById: (emailId: string) => Promise<Email | null>;
+    fetchThread: (threadId: string) => Promise<EmailThread | null>;
+    fetchFolders: () => Promise<void>;
+    fetchCategories: () => Promise<void>;
+    fetchTemplates: () => Promise<void>;
+    fetchDrafts: () => Promise<void>;
+    fetchContacts: (search?: string) => Promise<void>;
+    fetchUnreadCount: () => Promise<void>;
+    sendEmail: (emailData: EmailSendRequest) => Promise<void>;
+    saveDraft: (draft: EmailDraft) => Promise<void>;
+    updateEmailStatus: (emailId: string, updates: Partial<Email>) => Promise<void>;
+    deleteEmail: (emailId: string) => Promise<void>;
+    openCompose: (replyToEmail?: Email, initialData?: Partial<EmailDraft>) => void;
+    closeCompose: () => void;
+    selectEmail: (emailId: string) => void;
+    selectFolder: (folderId: string) => void;
+    selectCategory: (category: EmailCategory["type"]) => void;
+    setCurrentView: (view: EmailState["currentView"]) => void;
+    setSearchQuery: (query: string) => void;
+    setSearchFilters: (filters: EmailSearchFilters) => void;
+    performSearch: (query: string, filters?: EmailSearchFilters) => Promise<void>;
+    refreshEmails: () => Promise<void>;
+    clearError: () => void;
+    resetState: () => void;
+};
+export declare function useEmailAPI(): EmailAPI;
+export {};