@cloudparker/moldex.js 4.1.7 → 4.1.9

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

@@ -0,0 +1,73 @@
+/**
+ * Validates whether a given string is a valid hexadecimal color code.
+ *
+ * This function checks if a given string matches the pattern for a valid hex color code,
+ * which can be either 3 or 6 characters long, prefixed with '#'.
+ *
+ * @param hex - The string to validate as a hex color code.
+ * @returns A boolean indicating whether the string is a valid hex color code.
+ *
+ * @example
+ * console.log(isValidHexColor('#FFF'));   // Output: true
+ * console.log(isValidHexColor('#123ABC')); // Output: true
+ * console.log(isValidHexColor('#1234'));   // Output: false
+ */
+export function isValidHexColor(hex) {
+    const hexRegex = /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/;
+    return hexRegex.test(hex);
+}
+/**
+ * Converts a named or RGB color string to its hexadecimal representation.
+ *
+ * This function creates a temporary DOM element, sets its color property to the provided color string,
+ * and retrieves the computed color value. It then converts the RGB color to a hexadecimal format.
+ *
+ * @param color - A color string, such as a named color ('red'), RGB color ('rgb(255, 0, 0)'), or hex color ('#FF0000').
+ * @returns The hexadecimal representation of the color.
+ *
+ * @throws An error if the color cannot be parsed.
+ *
+ * @example
+ * console.log(colorToHex('red'));        // Output: #FF0000
+ * console.log(colorToHex('rgb(0, 255, 0)')); // Output: #00FF00
+ */
+export function colorToHex(color) {
+    // Create a temporary div element to use its computed style
+    const tempDiv = document.createElement("div");
+    tempDiv.style.color = color;
+    document.body.appendChild(tempDiv);
+    // Get the computed color from the div element
+    const computedColor = window.getComputedStyle(tempDiv).color;
+    document.body.removeChild(tempDiv);
+    // Extract the RGB values from the computed color
+    const rgb = computedColor.match(/\d+/g)?.map(Number);
+    if (!rgb || rgb.length !== 3) {
+        throw new Error(`Unable to parse color: ${color}`);
+    }
+    // Convert RGB values to a hex color and return
+    return rgbToHex(rgb[0], rgb[1], rgb[2]);
+}
+/**
+ * Converts RGB values to a hexadecimal color code.
+ *
+ * This function takes the red, green, and blue components and converts them to a hexadecimal string.
+ * The resulting hex code is formatted as '#RRGGBB'.
+ *
+ * @param r - The red component (0-255).
+ * @param g - The green component (0-255).
+ * @param b - The blue component (0-255).
+ * @returns The hexadecimal color code in the format '#RRGGBB'.
+ *
+ * @example
+ * console.log(rgbToHex(255, 0, 0)); // Output: #FF0000
+ */
+export function rgbToHex(r, g, b) {
+    if (![r, g, b].every((value) => typeof value === 'number' && value >= 0 && value <= 255)) {
+        throw new Error('RGB values must be numbers between 0 and 255.');
+    }
+    return ("#" +
+        [r, g, b]
+            .map((x) => x.toString(16).padStart(2, "0")) // Convert to hex and ensure two characters
+            .join("")
+            .toUpperCase());
+}

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

@@ -0,0 +1,91 @@
+export declare enum CurrencySymbols {
+    AED = "\u062F.\u0625",
+    AUD = "$",
+    BDT = "\u09F3",
+    BHD = ".\u062F.\u0628",
+    BRL = "R$",
+    CAD = "$",
+    CHF = "CHF",
+    CNY = "\u00A5",
+    CZK = "K\u010D",
+    DKK = "kr",
+    EGP = "\u00A3",
+    EUR = "\u20AC",
+    GBP = "\u00A3",
+    HKD = "$",
+    HUF = "Ft",
+    IDR = "Rp",
+    ILS = "\u20AA",
+    INR = "\u20B9",
+    JOD = "\u062F.\u0627",
+    JPY = "\u00A5",
+    KRW = "\u20A9",
+    KWD = "\u062F.\u0643",
+    LKR = "Rs",
+    MXN = "$",
+    MYR = "RM",
+    NGN = "\u20A6",
+    NOK = "kr",
+    NPR = "\u20A8",
+    NZD = "$",
+    OMR = "\u0631.\u0639.",
+    PHP = "\u20B1",
+    PKR = "\u20A8",
+    PLN = "z\u0142",
+    QAR = "\u0631.\u0642",
+    RUB = "\u20BD",
+    SAR = "\uFDFC",
+    SEK = "kr",
+    SGD = "$",
+    THB = "\u0E3F",
+    TRY = "\u20BA",
+    USD = "$",
+    VND = "\u20AB",
+    ZAR = "R"
+}
+/**
+ * Converts a number into words based on the Indian numbering system.
+ * Supports up to Crore level and works for numbers up to 99 Crore.
+ *
+ * @param num - The number to convert to words.
+ * @returns A string representing the number in words.
+ *
+ * @example
+ * numberToWords(190005000) // Output: "Nineteen Crore, Fifty Thousand"
+ * numberToWords(123456789) // Output: "Twelve Crore, Thirty-Four Lakh, Fifty-Six Thousand, Seven Hundred and Eighty-Nine"
+ */
+export declare function numberToWords(num: number): string;
+/**
+ * Converts a two-digit number into words.
+ *
+ * @param num - The number to convert.
+ * @returns The number in words.
+ */
+export declare function convertTwoDigits(num: number): string;
+/**
+ * Converts a number to a currency-formatted string.
+ *
+ * This function formats a given number as a currency string, using a specified currency symbol
+ * (default is '$'). It handles negative values by adding a '-' sign in front of the formatted value.
+ *
+ * @param value - The numeric value to format as currency.
+ * @param symbol - The currency symbol to use. Default is '$'.
+ * @returns A formatted string representing the currency value.
+ *
+ * @example
+ * const formattedValue = toCurrency(1234.56, '$');
+ * console.log(formattedValue); // Output: "$ 1234.56"
+ *
+ * @example
+ * const formattedNegative = toCurrency(-1234.56, '€');
+ * console.log(formattedNegative); // Output: "- € 1234.56"
+ */
+export declare function toCurrency(value?: number, symbol?: string): string;
+/**
+ * Formats a number into Indian currency format with commas
+ * Example: 1234567890.50 -> "1,23,45,67,890.50"
+ *
+ * @param amount - The number to format (can include decimals).
+ * @returns A string formatted with commas as per the Indian numbering system.
+ */
+export declare function formatIndianCurrency(amount: number | string): string;

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

@@ -0,0 +1,140 @@
+const belowTwenty = ["", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"];
+const tens = ["", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"];
+const scales = ["", "Thousand", "Lakh", "Crore"];
+export var CurrencySymbols;
+(function (CurrencySymbols) {
+    CurrencySymbols["AED"] = "\u062F.\u0625";
+    CurrencySymbols["AUD"] = "$";
+    CurrencySymbols["BDT"] = "\u09F3";
+    CurrencySymbols["BHD"] = ".\u062F.\u0628";
+    CurrencySymbols["BRL"] = "R$";
+    CurrencySymbols["CAD"] = "$";
+    CurrencySymbols["CHF"] = "CHF";
+    CurrencySymbols["CNY"] = "\u00A5";
+    CurrencySymbols["CZK"] = "K\u010D";
+    CurrencySymbols["DKK"] = "kr";
+    CurrencySymbols["EGP"] = "\u00A3";
+    CurrencySymbols["EUR"] = "\u20AC";
+    CurrencySymbols["GBP"] = "\u00A3";
+    CurrencySymbols["HKD"] = "$";
+    CurrencySymbols["HUF"] = "Ft";
+    CurrencySymbols["IDR"] = "Rp";
+    CurrencySymbols["ILS"] = "\u20AA";
+    CurrencySymbols["INR"] = "\u20B9";
+    CurrencySymbols["JOD"] = "\u062F.\u0627";
+    CurrencySymbols["JPY"] = "\u00A5";
+    CurrencySymbols["KRW"] = "\u20A9";
+    CurrencySymbols["KWD"] = "\u062F.\u0643";
+    CurrencySymbols["LKR"] = "Rs";
+    CurrencySymbols["MXN"] = "$";
+    CurrencySymbols["MYR"] = "RM";
+    CurrencySymbols["NGN"] = "\u20A6";
+    CurrencySymbols["NOK"] = "kr";
+    CurrencySymbols["NPR"] = "\u20A8";
+    CurrencySymbols["NZD"] = "$";
+    CurrencySymbols["OMR"] = "\u0631.\u0639.";
+    CurrencySymbols["PHP"] = "\u20B1";
+    CurrencySymbols["PKR"] = "\u20A8";
+    CurrencySymbols["PLN"] = "z\u0142";
+    CurrencySymbols["QAR"] = "\u0631.\u0642";
+    CurrencySymbols["RUB"] = "\u20BD";
+    CurrencySymbols["SAR"] = "\uFDFC";
+    CurrencySymbols["SEK"] = "kr";
+    CurrencySymbols["SGD"] = "$";
+    CurrencySymbols["THB"] = "\u0E3F";
+    CurrencySymbols["TRY"] = "\u20BA";
+    CurrencySymbols["USD"] = "$";
+    CurrencySymbols["VND"] = "\u20AB";
+    CurrencySymbols["ZAR"] = "R";
+})(CurrencySymbols || (CurrencySymbols = {}));
+/**
+ * Converts a number into words based on the Indian numbering system.
+ * Supports up to Crore level and works for numbers up to 99 Crore.
+ *
+ * @param num - The number to convert to words.
+ * @returns A string representing the number in words.
+ *
+ * @example
+ * numberToWords(190005000) // Output: "Nineteen Crore, Fifty Thousand"
+ * numberToWords(123456789) // Output: "Twelve Crore, Thirty-Four Lakh, Fifty-Six Thousand, Seven Hundred and Eighty-Nine"
+ */
+export function numberToWords(num) {
+    if (num === 0)
+        return "Zero";
+    const crore = Math.floor(num / 10000000);
+    const lakh = Math.floor((num % 10000000) / 100000);
+    const thousand = Math.floor((num % 100000) / 1000);
+    const hundred = Math.floor((num % 1000) / 100);
+    const remainder = num % 100;
+    let result = '';
+    if (crore > 0) {
+        result += `${convertTwoDigits(crore)} Crore`;
+    }
+    if (lakh > 0) {
+        result += result ? `, ${convertTwoDigits(lakh)} Lakh` : `${convertTwoDigits(lakh)} Lakh`;
+    }
+    if (thousand > 0) {
+        result += result ? `, ${convertTwoDigits(thousand)} Thousand` : `${convertTwoDigits(thousand)} Thousand`;
+    }
+    if (hundred > 0) {
+        result += result ? `, ${convertTwoDigits(hundred)} Hundred` : `${convertTwoDigits(hundred)} Hundred`;
+    }
+    if (remainder > 0) {
+        result += result ? ` and ${convertTwoDigits(remainder)}` : `${convertTwoDigits(remainder)}`;
+    }
+    return result.trim();
+}
+/**
+ * Converts a two-digit number into words.
+ *
+ * @param num - The number to convert.
+ * @returns The number in words.
+ */
+export function convertTwoDigits(num) {
+    if (num < 20) {
+        return belowTwenty[num];
+    }
+    const ten = Math.floor(num / 10);
+    const unit = num % 10;
+    return `${tens[ten]}${unit ? " " + belowTwenty[unit] : ""}`;
+}
+/**
+ * Converts a number to a currency-formatted string.
+ *
+ * This function formats a given number as a currency string, using a specified currency symbol
+ * (default is '$'). It handles negative values by adding a '-' sign in front of the formatted value.
+ *
+ * @param value - The numeric value to format as currency.
+ * @param symbol - The currency symbol to use. Default is '$'.
+ * @returns A formatted string representing the currency value.
+ *
+ * @example
+ * const formattedValue = toCurrency(1234.56, '$');
+ * console.log(formattedValue); // Output: "$ 1234.56"
+ *
+ * @example
+ * const formattedNegative = toCurrency(-1234.56, '€');
+ * console.log(formattedNegative); // Output: "- € 1234.56"
+ */
+export function toCurrency(value = 0, symbol = '$') {
+    const isNegative = value < 0;
+    const currencyValue = Math.abs(value).toFixed(2);
+    return `${isNegative ? '- ' : ''}${symbol} ${currencyValue}`;
+}
+/**
+ * Formats a number into Indian currency format with commas
+ * Example: 1234567890.50 -> "1,23,45,67,890.50"
+ *
+ * @param amount - The number to format (can include decimals).
+ * @returns A string formatted with commas as per the Indian numbering system.
+ */
+export function formatIndianCurrency(amount) {
+    let amountStr = typeof amount === 'number' ? amount.toFixed(2) : parseFloat(amount).toFixed(2);
+    let [integerPart, decimalPart] = amountStr.split(".");
+    let lastThreeDigits = integerPart.slice(-3);
+    let otherDigits = integerPart.slice(0, -3);
+    if (otherDigits !== "") {
+        otherDigits = otherDigits.replace(/\B(?=(\d{2})+(?!\d))/g, ",");
+    }
+    return otherDigits + (otherDigits ? "," : "") + lastThreeDigits + "." + decimalPart;
+}

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

@@ -0,0 +1,91 @@
+/**
+ * Downloads a file from various data sources (string, URL, Data URL, or File object).
+ *
+ * This function handles downloading files from a variety of sources, including:
+ * - String data (text, JSON, etc.)
+ * - URLs (file URLs or remote URLs)
+ * - Data URLs (Base64 encoded strings)
+ * - File or Blob objects
+ *
+ * @param data - The data to download. It can be a string, URL, Data URL, or a File/Blob object.
+ * @param filename - The name for the downloaded file.
+ * @param mimeType - Optional. The MIME type of the file. Default is 'application/octet-stream'.
+ *
+ * @example
+ * // Download a string as a text file
+ * downloadFile('Hello, world!', 'example.txt', 'text/plain');
+ *
+ * @example
+ * // Download a file from a URL
+ * downloadFile('https://example.com/file.pdf', 'downloaded-file.pdf');
+ *
+ * @example
+ * // Download a file from a Data URL
+ * const dataUrl = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...';
+ * downloadFile(dataUrl, 'image.png');
+ *
+ * @example
+ * // Download a File object
+ * const myFile = new File(['Hello, world!'], 'example.txt', { type: 'text/plain' });
+ * downloadFile(myFile);
+ */
+export declare function downloadFile(data: string | URL | File | Blob, filename?: string, mimeType?: string): void;
+/**
+ * Downloads plain string data as a file.
+ *
+ * @param data - The string data to download.
+ * @param filename - The name for the downloaded file.
+ * @param mimeType - The MIME type of the file.
+ */
+export declare function downloadStringData(data: string, filename: string, mimeType: string): void;
+/**
+ * Downloads a file from a given URL.
+ *
+ * @param url - The URL to download the file from.
+ * @param filename - The name for the downloaded file.
+ */
+export declare function downloadFromUrl(url: string, filename: string): void;
+/**
+ * Downloads a file from a Data URL (Base64 encoded string).
+ *
+ * @param dataUrl - The Data URL to download.
+ * @param filename - The name for the downloaded file.
+ * @param mimeType - Optional. The MIME type of the file.
+ */
+export declare function downloadDataUrl(dataUrl: string, filename: string, mimeType?: string): void;
+/**
+ * Downloads a File or Blob object.
+ *
+ * @param file - The File or Blob object to download.
+ * @param filename - The name for the downloaded file.
+ */
+export declare function downloadBlob(file: Blob, filename: string): void;
+/**
+ * Converts a Data URL to a Blob object.
+ *
+ * @param dataUrl - The Data URL to convert.
+ * @param mimeType - Optional. The MIME type of the resulting Blob.
+ * @returns A Blob object representing the data.
+ */
+export declare function dataUrlToBlob(dataUrl: string, mimeType?: string): Blob;
+/**
+ * Determines if a given string is a valid Data URL.
+ *
+ * @param str - The string to validate.
+ * @returns A boolean indicating whether the string is a valid Data URL.
+ */
+export declare function isDataUrl(str: string): boolean;
+/**
+ * Determines if a given string is a valid URL.
+ *
+ * @param str - The string to validate.
+ * @returns A boolean indicating whether the string is a valid URL.
+ */
+export declare function isUrl(str: string): boolean;
+/**
+ * Extracts the filename from a URL.
+ *
+ * @param url - The URL string.
+ * @returns The extracted filename, or 'download' if the URL does not contain a filename.
+ */
+export declare function getFilenameFromUrl(url: string): string;

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

@@ -0,0 +1,159 @@
+/**
+ * Downloads a file from various data sources (string, URL, Data URL, or File object).
+ *
+ * This function handles downloading files from a variety of sources, including:
+ * - String data (text, JSON, etc.)
+ * - URLs (file URLs or remote URLs)
+ * - Data URLs (Base64 encoded strings)
+ * - File or Blob objects
+ *
+ * @param data - The data to download. It can be a string, URL, Data URL, or a File/Blob object.
+ * @param filename - The name for the downloaded file.
+ * @param mimeType - Optional. The MIME type of the file. Default is 'application/octet-stream'.
+ *
+ * @example
+ * // Download a string as a text file
+ * downloadFile('Hello, world!', 'example.txt', 'text/plain');
+ *
+ * @example
+ * // Download a file from a URL
+ * downloadFile('https://example.com/file.pdf', 'downloaded-file.pdf');
+ *
+ * @example
+ * // Download a file from a Data URL
+ * const dataUrl = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...';
+ * downloadFile(dataUrl, 'image.png');
+ *
+ * @example
+ * // Download a File object
+ * const myFile = new File(['Hello, world!'], 'example.txt', { type: 'text/plain' });
+ * downloadFile(myFile);
+ */
+export function downloadFile(data, filename, mimeType) {
+    // Determine the type of the data and handle accordingly
+    if (typeof data === 'string') {
+        if (isDataUrl(data)) {
+            // Handle Data URL
+            downloadDataUrl(data, filename || 'download', mimeType);
+        }
+        else if (isUrl(data)) {
+            // Handle URL download
+            downloadFromUrl(data, filename || getFilenameFromUrl(data));
+        }
+        else {
+            // Handle plain string data
+            downloadStringData(data, filename || 'download.txt', mimeType || 'application/octet-stream');
+        }
+    }
+    else if (data instanceof File || data instanceof Blob) {
+        // Handle File or Blob object
+        downloadBlob(data, filename || data.name || 'download');
+    }
+    else {
+        console.error('Unsupported data type for download.');
+    }
+}
+/**
+ * Downloads plain string data as a file.
+ *
+ * @param data - The string data to download.
+ * @param filename - The name for the downloaded file.
+ * @param mimeType - The MIME type of the file.
+ */
+export function downloadStringData(data, filename, mimeType) {
+    const blob = new Blob([data], { type: mimeType });
+    downloadBlob(blob, filename);
+}
+/**
+ * Downloads a file from a given URL.
+ *
+ * @param url - The URL to download the file from.
+ * @param filename - The name for the downloaded file.
+ */
+export function downloadFromUrl(url, filename) {
+    const link = document.createElement('a');
+    link.href = url;
+    link.download = filename;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+}
+/**
+ * Downloads a file from a Data URL (Base64 encoded string).
+ *
+ * @param dataUrl - The Data URL to download.
+ * @param filename - The name for the downloaded file.
+ * @param mimeType - Optional. The MIME type of the file.
+ */
+export function downloadDataUrl(dataUrl, filename, mimeType) {
+    const blob = dataUrlToBlob(dataUrl, mimeType);
+    downloadBlob(blob, filename);
+}
+/**
+ * Downloads a File or Blob object.
+ *
+ * @param file - The File or Blob object to download.
+ * @param filename - The name for the downloaded file.
+ */
+export function downloadBlob(file, filename) {
+    const link = document.createElement('a');
+    link.href = URL.createObjectURL(file);
+    link.download = filename;
+    document.body.appendChild(link);
+    link.click();
+    // Clean up the URL object to free up memory
+    URL.revokeObjectURL(link.href);
+    document.body.removeChild(link);
+}
+/**
+ * Converts a Data URL to a Blob object.
+ *
+ * @param dataUrl - The Data URL to convert.
+ * @param mimeType - Optional. The MIME type of the resulting Blob.
+ * @returns A Blob object representing the data.
+ */
+export function dataUrlToBlob(dataUrl, mimeType) {
+    const byteString = atob(dataUrl.split(',')[1]);
+    const ab = new ArrayBuffer(byteString.length);
+    const ia = new Uint8Array(ab);
+    for (let i = 0; i < byteString.length; i++) {
+        ia[i] = byteString.charCodeAt(i);
+    }
+    return new Blob([ab], { type: mimeType || 'application/octet-stream' });
+}
+/**
+ * Determines if a given string is a valid Data URL.
+ *
+ * @param str - The string to validate.
+ * @returns A boolean indicating whether the string is a valid Data URL.
+ */
+export function isDataUrl(str) {
+    const pattern = /^data:([a-zA-Z0-9/+.-]+);base64,/;
+    return pattern.test(str);
+}
+/**
+ * Determines if a given string is a valid URL.
+ *
+ * @param str - The string to validate.
+ * @returns A boolean indicating whether the string is a valid URL.
+ */
+export function isUrl(str) {
+    try {
+        new URL(str);
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+}
+/**
+ * Extracts the filename from a URL.
+ *
+ * @param url - The URL string.
+ * @returns The extracted filename, or 'download' if the URL does not contain a filename.
+ */
+export function getFilenameFromUrl(url) {
+    const segments = url.split('/');
+    const filename = segments.pop();
+    return filename && filename.includes('.') ? filename : 'download';
+}