indas-ui 0.0.1 → 0.1.0

package/dist/cjs/components/ui/select.js

@@ -0,0 +1,72 @@
+'use client';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectScrollDownButton = exports.SelectScrollUpButton = exports.SelectSeparator = exports.SelectItem = exports.SelectLabel = exports.SelectContent = exports.SelectTrigger = exports.SelectValue = exports.SelectGroup = exports.Select = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const React = __importStar(require("react"));
+const SelectPrimitive = __importStar(require("@radix-ui/react-select"));
+const utils_1 = require("../../lib/utils.js");
+const react_icons_1 = require("@radix-ui/react-icons");
+const Select = SelectPrimitive.Root;
+exports.Select = Select;
+const SelectGroup = SelectPrimitive.Group;
+exports.SelectGroup = SelectGroup;
+const SelectValue = SelectPrimitive.Value;
+exports.SelectValue = SelectValue;
+const SelectTrigger = React.forwardRef(({ className, children, ...props }, ref) => ((0, jsx_runtime_1.jsxs)(SelectPrimitive.Trigger, { ref: ref, className: (0, utils_1.cn)("flex h-9 w-full items-center justify-between whitespace-nowrap rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm ring-offset-background data-[placeholder]:text-muted-foreground focus:outline-none focus:ring-1 focus:ring-ring disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1", className), ...props, children: [children, (0, jsx_runtime_1.jsx)(SelectPrimitive.Icon, { asChild: true, children: (0, jsx_runtime_1.jsx)(react_icons_1.ChevronDownIcon, { className: "h-4 w-4 opacity-50" }) })] })));
+exports.SelectTrigger = SelectTrigger;
+SelectTrigger.displayName = SelectPrimitive.Trigger.displayName;
+const SelectScrollUpButton = React.forwardRef(({ className, ...props }, ref) => ((0, jsx_runtime_1.jsx)(SelectPrimitive.ScrollUpButton, { ref: ref, className: (0, utils_1.cn)("flex cursor-default items-center justify-center py-1", className), ...props, children: (0, jsx_runtime_1.jsx)(react_icons_1.ChevronUpIcon, { className: "h-4 w-4" }) })));
+exports.SelectScrollUpButton = SelectScrollUpButton;
+SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName;
+const SelectScrollDownButton = React.forwardRef(({ className, ...props }, ref) => ((0, jsx_runtime_1.jsx)(SelectPrimitive.ScrollDownButton, { ref: ref, className: (0, utils_1.cn)("flex cursor-default items-center justify-center py-1", className), ...props, children: (0, jsx_runtime_1.jsx)(react_icons_1.ChevronDownIcon, { className: "h-4 w-4" }) })));
+exports.SelectScrollDownButton = SelectScrollDownButton;
+SelectScrollDownButton.displayName =
+    SelectPrimitive.ScrollDownButton.displayName;
+const SelectContent = React.forwardRef(({ className, children, position = "popper", ...props }, ref) => ((0, jsx_runtime_1.jsx)(SelectPrimitive.Portal, { children: (0, jsx_runtime_1.jsxs)(SelectPrimitive.Content, { ref: ref, className: (0, utils_1.cn)("relative z-50 max-h-[--radix-select-content-available-height] min-w-[8rem] overflow-y-auto overflow-x-hidden rounded-md border bg-popover text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 origin-[--radix-select-content-transform-origin]", position === "popper" &&
+            "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1", className), position: position, ...props, children: [(0, jsx_runtime_1.jsx)(SelectScrollUpButton, {}), (0, jsx_runtime_1.jsx)(SelectPrimitive.Viewport, { className: (0, utils_1.cn)("p-1", position === "popper" &&
+                    "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]"), children: children }), (0, jsx_runtime_1.jsx)(SelectScrollDownButton, {})] }) })));
+exports.SelectContent = SelectContent;
+SelectContent.displayName = SelectPrimitive.Content.displayName;
+const SelectLabel = React.forwardRef(({ className, ...props }, ref) => ((0, jsx_runtime_1.jsx)(SelectPrimitive.Label, { ref: ref, className: (0, utils_1.cn)("px-2 py-1.5 text-sm font-semibold", className), ...props })));
+exports.SelectLabel = SelectLabel;
+SelectLabel.displayName = SelectPrimitive.Label.displayName;
+const SelectItem = React.forwardRef(({ className, children, ...props }, ref) => ((0, jsx_runtime_1.jsxs)(SelectPrimitive.Item, { ref: ref, className: (0, utils_1.cn)("relative flex w-full cursor-default select-none items-center rounded-sm py-1.5 pl-2 pr-8 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50", className), ...props, children: [(0, jsx_runtime_1.jsx)("span", { className: "absolute right-2 flex h-3.5 w-3.5 items-center justify-center", children: (0, jsx_runtime_1.jsx)(SelectPrimitive.ItemIndicator, { children: (0, jsx_runtime_1.jsx)(react_icons_1.CheckIcon, { className: "h-4 w-4" }) }) }), (0, jsx_runtime_1.jsx)(SelectPrimitive.ItemText, { children: children })] })));
+exports.SelectItem = SelectItem;
+SelectItem.displayName = SelectPrimitive.Item.displayName;
+const SelectSeparator = React.forwardRef(({ className, ...props }, ref) => ((0, jsx_runtime_1.jsx)(SelectPrimitive.Separator, { ref: ref, className: (0, utils_1.cn)("-mx-1 my-1 h-px bg-muted", className), ...props })));
+exports.SelectSeparator = SelectSeparator;
+SelectSeparator.displayName = SelectPrimitive.Separator.displayName;

package/dist/cjs/config/api.js

@@ -0,0 +1,65 @@
+'use client';
+"use strict";
+/**
+ * Centralized API Domain Configuration
+ *
+ * Change the DOMAIN here to update across the entire application.
+ * Endpoints are hardcoded in each API call as they should be.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_HEADERS = void 0;
+exports.setApiDomain = setApiDomain;
+exports.getApiDomain = getApiDomain;
+exports.buildApiUrl = buildApiUrl;
+exports.createApiHeaders = createApiHeaders;
+// Centralized domain - read from environment variables (no fallback)
+const API_DOMAIN_RAW = process.env.NEXT_PUBLIC_API_BASE_URL;
+let API_DOMAIN = API_DOMAIN_RAW?.replace(/\/$/, '') || '';
+// Validation - only API_DOMAIN is required
+if (!API_DOMAIN) {
+    throw new Error('Missing required API configuration: NEXT_PUBLIC_API_BASE_URL must be set in .env.local');
+}
+/**
+ * Set API domain dynamically
+ */
+function setApiDomain(domain) {
+    // Remove trailing slash if present
+    API_DOMAIN = domain.replace(/\/$/, '');
+}
+/**
+ * Get current API domain
+ */
+function getApiDomain() {
+    return API_DOMAIN;
+}
+/**
+ * Build complete API URL with hardcoded endpoint
+ */
+function buildApiUrl(endpoint) {
+    // Ensure endpoint starts with /
+    const cleanEndpoint = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
+    return `${API_DOMAIN}${cleanEndpoint}`;
+}
+/**
+ * Default headers for API requests
+ */
+exports.DEFAULT_HEADERS = {
+    'Content-Type': 'application/json',
+};
+/**
+ * Create headers with company and user ID
+ * Note: Use APIClient from @/lib/api/core/client for proper multi-tenant authentication
+ * This function is deprecated and kept only for backward compatibility
+ */
+function createApiHeaders(companyId, userId) {
+    const headers = {
+        ...exports.DEFAULT_HEADERS
+    };
+    if (companyId !== undefined) {
+        headers['CompanyID'] = companyId.toString();
+    }
+    if (userId !== undefined) {
+        headers['UserID'] = userId.toString();
+    }
+    return headers;
+}

package/dist/cjs/contexts/AppConfigContext.js

@@ -0,0 +1,37 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppConfigProvider = AppConfigProvider;
+exports.useAppConfig = useAppConfig;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const AppConfigContext = (0, react_1.createContext)(undefined);
+function AppConfigProvider({ children }) {
+    const [selectedFinancialYear, setSelectedFinancialYear] = (0, react_1.useState)('2025-2026');
+    const [selectedProductionUnit, setSelectedProductionUnit] = (0, react_1.useState)('');
+    // Helper to convert "2025-2026" to "_25_26"
+    const getFinancialYearSuffix = () => {
+        if (!selectedFinancialYear)
+            return '';
+        const parts = selectedFinancialYear.split('-');
+        if (parts.length !== 2)
+            return '';
+        const startYear = parts[0].slice(-2); // Last 2 digits of start year
+        const endYear = parts[1].slice(-2); // Last 2 digits of end year
+        return `_${startYear}_${endYear}`;
+    };
+    return ((0, jsx_runtime_1.jsx)(AppConfigContext.Provider, { value: {
+            selectedFinancialYear,
+            setSelectedFinancialYear,
+            selectedProductionUnit,
+            setSelectedProductionUnit,
+            getFinancialYearSuffix
+        }, children: children }));
+}
+function useAppConfig() {
+    const context = (0, react_1.useContext)(AppConfigContext);
+    if (context === undefined) {
+        throw new Error('useAppConfig must be used within an AppConfigProvider');
+    }
+    return context;
+}

package/dist/cjs/contexts/CurrencyContext.js

@@ -0,0 +1,336 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSymbolForCode = getSymbolForCode;
+exports.CurrencyProvider = CurrencyProvider;
+exports.useCurrency = useCurrency;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+// Resolve symbol from Intl API — no hardcoding
+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 = (0, react_1.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;
+    }
+}
+function CurrencyProvider({ children, baseCurrencyCode }) {
+    const resolvedBase = baseCurrencyCode || 'INR';
+    const [selectedCurrency, setSelectedCurrency] = (0, react_1.useState)(resolvedBase);
+    const [baseCurrency, setBaseCurrency] = (0, react_1.useState)(resolvedBase);
+    const [exchangeRates, setExchangeRates] = (0, react_1.useState)({});
+    const [availableCurrencies, setAvailableCurrencies] = (0, react_1.useState)([]);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const [lastUpdated, setLastUpdated] = (0, react_1.useState)(null);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [manualRates, setManualRates] = (0, react_1.useState)(new Map());
+    const exchangeService = ExchangeRateService.getInstance();
+    const refreshRates = (0, react_1.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
+    (0, react_1.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
+    (0, react_1.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
+    (0, react_1.useEffect)(() => {
+        refreshRates();
+        const interval = setInterval(refreshRates, 5 * 60 * 1000); // 5 minutes
+        return () => clearInterval(interval);
+    }, [refreshRates]);
+    const setCurrency = (0, react_1.useCallback)((currency) => {
+        setSelectedCurrency(currency);
+        // Store in localStorage for persistence
+        localStorage.setItem('selectedCurrency', currency);
+    }, []);
+    // Load saved currency on mount (after currencies are loaded)
+    (0, react_1.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 = (0, react_1.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 = (0, react_1.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 = (0, react_1.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 = (0, react_1.useCallback)((currency) => {
+        return availableCurrencies.find(c => c.code === currency) || null;
+    }, [availableCurrencies]);
+    const getAllCurrencies = (0, react_1.useCallback)(() => {
+        return availableCurrencies;
+    }, [availableCurrencies]);
+    const setManualRate = (0, react_1.useCallback)((from, to, rate) => {
+        const key = `${from}-${to}`;
+        setManualRates(prev => new Map(prev.set(key, rate)));
+    }, []);
+    const removeManualRate = (0, react_1.useCallback)((from, to) => {
+        const key = `${from}-${to}`;
+        setManualRates(prev => {
+            const newMap = new Map(prev);
+            newMap.delete(key);
+            return newMap;
+        });
+    }, []);
+    const isManualRate = (0, react_1.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 ((0, jsx_runtime_1.jsx)(CurrencyContext.Provider, { value: value, children: children }));
+}
+function useCurrency() {
+    const context = (0, react_1.useContext)(CurrencyContext);
+    if (context === undefined) {
+        throw new Error('useCurrency must be used within a CurrencyProvider');
+    }
+    return context;
+}

package/dist/cjs/contexts/DeviceContext.js

@@ -0,0 +1,106 @@
+'use client';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceProvider = DeviceProvider;
+exports.useDevice = useDevice;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const React = __importStar(require("react"));
+const DeviceContext = React.createContext({
+    deviceType: 'desktop',
+    isMobile: false,
+    isTablet: false,
+    isDesktop: true,
+});
+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 ((0, jsx_runtime_1.jsx)(DeviceContext.Provider, { value: value, children: children }));
+}
+function useDevice() {
+    return React.useContext(DeviceContext);
+}