@cloudparker/moldex.js 4.1.13 → 4.1.16

package/dist/services/utils/currency-service.d.ts

@@ -43,6 +43,28 @@ export declare enum CurrencySymbols {
     VND = "\u20AB",
     ZAR = "R"
 }
+export interface CurrencyRates {
+    [currencyCode: string]: number;
+}
+export interface CurrencyApiResponse {
+    result: string;
+    provider: string;
+    documentation: string;
+    terms_of_use: string;
+    time_last_update_unix: number;
+    time_last_update_utc: string;
+    time_next_update_unix: number;
+    time_next_update_utc: string;
+    time_eol_unix: number;
+    base_code: string;
+    rates: CurrencyRates;
+}
+export interface CurrencyData {
+    baseCode: string;
+    rates: CurrencyRates;
+    lastUpdate: string;
+    nextUpdate: string;
+}
 /**
  * Converts a number into words based on the Indian numbering system.
  * Supports up to Crore level and works for numbers up to 99 Crore.
@@ -89,3 +111,45 @@ export declare function toCurrency(value?: number, symbol?: string): string;
  * @returns A string formatted with commas as per the Indian numbering system.
  */
 export declare function formatIndianCurrency(amount: number | string): string;
+/**
+ * Fetches currency exchange rates for a given base currency
+ * @param baseCurrency - The base currency code (e.g., 'USD', 'EUR', 'INR')
+ * @param forceRefresh - Force a refresh even if cached data exists (default: false)
+ * @returns Currency data with exchange rates
+ * @throws Error if the API request fails
+ */
+export declare function getCurrencyRates(baseCurrency?: string, forceRefresh?: boolean): Promise<CurrencyData>;
+/**
+ * Converts an amount from one currency to another
+ * @param amount - The amount to convert
+ * @param fromCurrency - The source currency code
+ * @param toCurrency - The target currency code
+ * @returns The converted amount
+ */
+export declare function convertCurrency(amount: number, fromCurrency: string, toCurrency: string): Promise<number>;
+/**
+ * Gets a specific exchange rate between two currencies
+ * @param fromCurrency - The source currency code
+ * @param toCurrency - The target currency code
+ * @returns The exchange rate
+ */
+export declare function getExchangeRate(fromCurrency: string, toCurrency: string): Promise<number>;
+/**
+ * Clears the currency cache for a specific currency or all currencies
+ * @param baseCurrency - Optional base currency to clear, if not provided clears all
+ */
+export declare function clearCurrencyCache(baseCurrency?: string): void;
+/**
+ * Gets the cached currency data without fetching
+ * @param baseCurrency - The base currency code
+ * @returns Cached currency data or null if not cached
+ */
+export declare function getCachedCurrencyRates(baseCurrency: string): CurrencyData | null;
+/**
+ * Formats a currency amount with the appropriate symbol and formatting
+ * @param amount - The amount to format
+ * @param currencyCode - The currency code (e.g., 'USD', 'EUR', 'INR')
+ * @param locale - The locale for formatting (defaults to 'en-US')
+ * @returns Formatted currency string
+ */
+export declare function formatCurrency(amount: number, currencyCode: string, locale?: string): string;

package/dist/services/utils/currency-service.js

@@ -47,6 +47,8 @@ export var CurrencySymbols;
     CurrencySymbols["VND"] = "\u20AB";
     CurrencySymbols["ZAR"] = "R";
 })(CurrencySymbols || (CurrencySymbols = {}));
+const CURRENCY_API_BASE = 'https://open.er-api.com/v6/latest';
+const currencyCache = new Map();
 /**
  * Converts a number into words based on the Indian numbering system.
  * Supports up to Crore level and works for numbers up to 99 Crore.
@@ -138,3 +140,156 @@ export function formatIndianCurrency(amount) {
     }
     return otherDigits + (otherDigits ? "," : "") + lastThreeDigits + "." + decimalPart;
 }
+/**
+ * Checks if cached currency data is still valid
+ * @param cachedData - The cached currency data
+ * @returns true if cache is valid, false otherwise
+ */
+function isCacheValid(cachedData) {
+    const nowUnix = Math.floor(Date.now() / 1000);
+    return cachedData.nextUpdateUnix > nowUnix;
+}
+/**
+ * Fetches currency exchange rates for a given base currency
+ * @param baseCurrency - The base currency code (e.g., 'USD', 'EUR', 'INR')
+ * @param forceRefresh - Force a refresh even if cached data exists (default: false)
+ * @returns Currency data with exchange rates
+ * @throws Error if the API request fails
+ */
+export async function getCurrencyRates(baseCurrency = 'USD', forceRefresh = false) {
+    const cacheKey = baseCurrency.toUpperCase();
+    // Check cache first
+    if (!forceRefresh) {
+        const cached = currencyCache.get(cacheKey);
+        if (cached && isCacheValid(cached)) {
+            console.log(`[currency.service] Using cached rates for ${cacheKey}`);
+            return {
+                baseCode: cached.baseCode,
+                rates: cached.rates,
+                lastUpdate: cached.lastUpdate,
+                nextUpdate: cached.nextUpdate
+            };
+        }
+    }
+    try {
+        console.log(`[currency.service] Fetching fresh rates for ${cacheKey}`);
+        const response = await fetch(`${CURRENCY_API_BASE}/${cacheKey}`);
+        if (!response.ok) {
+            throw new Error(`Currency API request failed: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        if (data.result !== 'success') {
+            throw new Error('Currency API returned unsuccessful result');
+        }
+        const currencyData = {
+            baseCode: data.base_code,
+            rates: data.rates,
+            lastUpdate: data.time_last_update_utc,
+            nextUpdate: data.time_next_update_utc,
+            nextUpdateUnix: data.time_next_update_unix
+        };
+        // Store in cache
+        currencyCache.set(cacheKey, currencyData);
+        return {
+            baseCode: currencyData.baseCode,
+            rates: currencyData.rates,
+            lastUpdate: currencyData.lastUpdate,
+            nextUpdate: currencyData.nextUpdate
+        };
+    }
+    catch (error) {
+        console.error('[currency.service] Failed to fetch currency rates:', error);
+        // If fetch fails, try to return stale cache as fallback
+        const cached = currencyCache.get(cacheKey);
+        if (cached) {
+            console.warn('[currency.service] Returning stale cached data due to fetch error');
+            return {
+                baseCode: cached.baseCode,
+                rates: cached.rates,
+                lastUpdate: cached.lastUpdate,
+                nextUpdate: cached.nextUpdate
+            };
+        }
+        throw error;
+    }
+}
+/**
+ * Converts an amount from one currency to another
+ * @param amount - The amount to convert
+ * @param fromCurrency - The source currency code
+ * @param toCurrency - The target currency code
+ * @returns The converted amount
+ */
+export async function convertCurrency(amount, fromCurrency, toCurrency) {
+    const data = await getCurrencyRates(fromCurrency);
+    const rate = data.rates[toCurrency.toUpperCase()];
+    if (!rate) {
+        throw new Error(`Exchange rate not found for ${toCurrency}`);
+    }
+    return amount * rate;
+}
+/**
+ * Gets a specific exchange rate between two currencies
+ * @param fromCurrency - The source currency code
+ * @param toCurrency - The target currency code
+ * @returns The exchange rate
+ */
+export async function getExchangeRate(fromCurrency, toCurrency) {
+    const data = await getCurrencyRates(fromCurrency);
+    const rate = data.rates[toCurrency.toUpperCase()];
+    if (!rate) {
+        throw new Error(`Exchange rate not found for ${toCurrency}`);
+    }
+    return rate;
+}
+/**
+ * Clears the currency cache for a specific currency or all currencies
+ * @param baseCurrency - Optional base currency to clear, if not provided clears all
+ */
+export function clearCurrencyCache(baseCurrency) {
+    if (baseCurrency) {
+        currencyCache.delete(baseCurrency.toUpperCase());
+        console.log(`[currency.service] Cleared cache for ${baseCurrency.toUpperCase()}`);
+    }
+    else {
+        currencyCache.clear();
+        console.log('[currency.service] Cleared all currency cache');
+    }
+}
+/**
+ * Gets the cached currency data without fetching
+ * @param baseCurrency - The base currency code
+ * @returns Cached currency data or null if not cached
+ */
+export function getCachedCurrencyRates(baseCurrency) {
+    const cached = currencyCache.get(baseCurrency.toUpperCase());
+    if (!cached)
+        return null;
+    return {
+        baseCode: cached.baseCode,
+        rates: cached.rates,
+        lastUpdate: cached.lastUpdate,
+        nextUpdate: cached.nextUpdate
+    };
+}
+/**
+ * Formats a currency amount with the appropriate symbol and formatting
+ * @param amount - The amount to format
+ * @param currencyCode - The currency code (e.g., 'USD', 'EUR', 'INR')
+ * @param locale - The locale for formatting (defaults to 'en-US')
+ * @returns Formatted currency string
+ */
+export function formatCurrency(amount, currencyCode, locale = 'en-US') {
+    try {
+        return new Intl.NumberFormat(locale, {
+            style: 'currency',
+            currency: currencyCode.toUpperCase(),
+            minimumFractionDigits: 2,
+            maximumFractionDigits: 2
+        }).format(amount);
+    }
+    catch (error) {
+        console.error('[currency.service] Failed to format currency:', error);
+        return `${currencyCode.toUpperCase()} ${amount.toFixed(2)}`;
+    }
+}

package/dist/views/extra/loaders/country-loader.svelte

@@ -1,4 +1,3 @@
- 
 <script lang="ts">
 	import EasyScriptLoader from '@cloudparker/easy-script-loader-svelte';
 	import type { Snippet } from 'svelte';
@@ -14,6 +13,21 @@
 
 	let EasyCountryData: any;
 
+	export async function getCountry({
+		isoCode,
+		dialCode,
+		name
+	}: {
+		isoCode?: string;
+		dialCode?: string;
+		name?: string;
+	}) {
+		if (EasyCountryData) {
+			return EasyCountryData.getCountry({ isoCode, dialCode, name });
+		}
+		return null;
+	}
+
 	export async function loadCountries() {
 		if (EasyCountryData) {
 			countries = EasyCountryData.getCountries();

package/dist/views/extra/loaders/country-loader.svelte.d.ts

@@ -6,6 +6,11 @@ type Props = {
     children?: Snippet;
 };
 declare const CountryLoader: import("svelte").Component<Props, {
+    getCountry: ({ isoCode, dialCode, name }: {
+        isoCode?: string;
+        dialCode?: string;
+        name?: string;
+    }) => Promise<any>;
     loadCountries: () => Promise<void>;
 }, "countries">;
 type CountryLoader = ReturnType<typeof CountryLoader>;

package/dist/views/extra/loaders/state-loader.svelte

@@ -19,6 +19,13 @@
 
 	let EasyCountryStateData: any;
 
+    export async function getState(id:string){
+        if(EasyCountryStateData){
+            return EasyCountryStateData.getState(id);
+        }
+        return null;
+    }
+
 	export async function loadStates(countryCode?: string) {
 		if (EasyCountryStateData) {
 			states = EasyCountryStateData.getStates(countryCode || null);

package/dist/views/extra/loaders/state-loader.svelte.d.ts

@@ -11,6 +11,7 @@ type Props = {
     children?: Snippet;
 };
 declare const StateLoader: import("svelte").Component<Props, {
+    getState: (id: string) => Promise<any>;
     loadStates: (countryCode?: string) => Promise<void>;
 }, "states">;
 type StateLoader = ReturnType<typeof StateLoader>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cloudparker/moldex.js",
-    "version": "4.1.13",
+    "version": "4.1.16",
     "keywords": [
         "svelte"
     ],