@cloudparker/moldex.js 4.1.15 → 4.1.17

package/dist/services/date/date-service.d.ts

@@ -14,10 +14,6 @@ export declare class PeriodEnum {
     static NEXT_YEAR: number;
     static DATE: number;
 }
-export type FirestoreTimestamp = {
-    seconds: number;
-    nanoseconds: number;
-};
 export declare function getDateWith(yearChange: number): Date;
 export declare function getDateTime(date: string | Date | any): number;
 export declare function momentDiff({ startDate, endDate, unit }: {
@@ -37,9 +33,6 @@ export declare function getPeriodDates(period: PeriodEnum, currentDate?: Date):
 export declare function padTo2Digits(num: number): string;
 export declare function millisToTimeString(milliseconds: number): string;
 export declare function timestampToMillis(timestamp: any): number;
-export declare function timestampToDate(timestamp: FirestoreTimestamp): Date;
-export declare function timestampToDateString(timestamp: FirestoreTimestamp): string;
-export declare function timestampToAgo(timestamp: FirestoreTimestamp): string;
 export declare function dateToTimestamp(date: Date): {
     seconds: number;
     nanoseconds: number;
@@ -50,3 +43,9 @@ export declare function millisToDate(millis: number): Date;
 export declare function dateFormat(date: Date, format?: 'MM-DD-YYYY hh:mm a' | 'MM-DD-YYYY' | 'YYYY-MM-DD' | 'YYYY-MM-DDTHH:MM' | string): string;
 export declare function isDateBetween(date: Date, startDate: Date, endDate: Date): boolean;
 export declare function toDate(value: any): Date;
+/**
+ * Formats a duration in seconds to mm:ss or hh:mm:ss format
+ * @param seconds - The duration in seconds
+ * @returns Formatted duration string (mm:ss if less than an hour, hh:mm:ss if an hour or more)
+ */
+export declare function formatDuration(seconds: number): string;

package/dist/services/date/date-service.js

@@ -141,21 +141,6 @@ export function timestampToMillis(timestamp) {
         return (timestamp.seconds * 1000) + (timestamp.nanoseconds / 1000000);
     }
 }
-export function timestampToDate(timestamp) {
-    if (timestamp && timestamp.seconds) {
-        return new Date((timestamp.seconds * 1000) + (timestamp.nanoseconds / 1000000));
-    }
-}
-export function timestampToDateString(timestamp) {
-    if (timestamp && timestamp.seconds) {
-        return moment(new Date(timestamp.seconds * 1000)).format('MM-DD-YYYY hh:mm a');
-    }
-}
-export function timestampToAgo(timestamp) {
-    if (timestamp && timestamp.seconds) {
-        return moment(new Date(timestamp.seconds * 1000)).fromNow();
-    }
-}
 export function dateToTimestamp(date) {
     return { seconds: date.getTime() / 1000, nanoseconds: 0 };
 }
@@ -198,9 +183,26 @@ export function toDate(value) {
         else if (typeof value == 'string') {
             result = moment(value).toDate();
         }
-        else if (value.seconds) {
-            result = timestampToDate(value);
-        }
     }
     return result;
 }
+/**
+ * Formats a duration in seconds to mm:ss or hh:mm:ss format
+ * @param seconds - The duration in seconds
+ * @returns Formatted duration string (mm:ss if less than an hour, hh:mm:ss if an hour or more)
+ */
+export function formatDuration(seconds) {
+    if (seconds < 0) {
+        seconds = 0;
+    }
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = Math.floor(seconds % 60);
+    const mm = minutes.toString().padStart(2, '0');
+    const ss = secs.toString().padStart(2, '0');
+    if (hours > 0) {
+        const hh = hours.toString().padStart(2, '0');
+        return `${hh}:${mm}:${ss}`;
+    }
+    return `${mm}:${ss}`;
+}

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/package.json

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