tp-react-elements 1.0.0

package/dist/theme/index.d.ts

@@ -0,0 +1,9 @@
+import { ThemeOptions } from "@mui/material/styles";
+interface CustomThemeOptions extends ThemeOptions {
+    callColors?: {
+        selectedTheme?: string;
+        themeButtonColor?: string;
+    };
+}
+export declare const customTheme: CustomThemeOptions;
+export default customTheme;

package/dist/theme/index.esm.js

@@ -0,0 +1,61 @@
+import { createTheme } from '@mui/material/styles';
+
+const customTheme = createTheme({
+    breakpoints: {
+        values: {
+            xs: 0,
+            sm: 600,
+            md: 900,
+            lg: 1200,
+            xl: 1536,
+        },
+    },
+    typography: {
+        fontFamily: "Poppins, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, 'Noto Sans', sans-serif"
+    },
+    palette: {
+        error: { main: '#B3261E' },
+    },
+    components: {
+        MuiInputLabel: {
+            styleOverrides: {
+                root: {
+                    fontSize: "12px",
+                },
+            },
+        },
+        MuiInputBase: {
+            styleOverrides: {
+                root: {
+                    fontSize: "12px",
+                    input: {
+                        padding: "6.38px 14px",
+                    },
+                },
+            },
+        },
+        MuiRadio: {
+            styleOverrides: {
+                root: {
+                    padding: "4px 4px 0 8px",
+                },
+            },
+        },
+        MuiSelect: {
+            styleOverrides: {
+                select: {
+                    padding: "6.38px 32px 6.38px 14px",
+                },
+            },
+        },
+        MuiButton: {
+            styleOverrides: {
+                root: {
+                    textTransform: "none",
+                },
+            },
+        },
+    },
+});
+
+export { customTheme, customTheme as default };

package/dist/types/index.d.ts

@@ -0,0 +1,38 @@
+import { ReactNode } from 'react';
+import { FieldValues, Control, RegisterOptions, FieldPath } from 'react-hook-form';
+export interface BaseFieldProps<T extends FieldValues = FieldValues> {
+    name: FieldPath<T>;
+    control?: Control<T>;
+    label?: string;
+    placeholder?: string;
+    helpText?: string;
+    disabled?: boolean;
+    required?: boolean;
+    className?: string;
+    validation?: RegisterOptions<T>;
+}
+export interface FormFieldProps<T extends FieldValues = FieldValues> extends BaseFieldProps<T> {
+    children?: ReactNode;
+}
+export interface Option {
+    value: string | number;
+    label: string;
+    disabled?: boolean;
+}
+export interface SelectFieldProps<T extends FieldValues = FieldValues> extends BaseFieldProps<T> {
+    options: Option[];
+    multiple?: boolean;
+    searchable?: boolean;
+}
+export interface CheckboxFieldProps<T extends FieldValues = FieldValues> extends BaseFieldProps<T> {
+    options?: Option[];
+}
+export interface RadioFieldProps<T extends FieldValues = FieldValues> extends BaseFieldProps<T> {
+    options: Option[];
+    inline?: boolean;
+}
+export interface TextAreaFieldProps<T extends FieldValues = FieldValues> extends BaseFieldProps<T> {
+    rows?: number;
+    cols?: number;
+    resize?: 'none' | 'vertical' | 'horizontal' | 'both';
+}

package/dist/utils/Constants/FormConstants.d.ts

@@ -0,0 +1,40 @@
+import dayjs, { Dayjs } from 'dayjs';
+import { VariantProps, FormRenderProps } from '../Interface/FormInterface';
+/**
+ * Renders a form input label with an optional required asterisk.
+ *
+ * @param {VariantProps} variant - The variant type of the form input.
+ * @param {FormRenderProps} props - The properties for rendering the form input.
+ * @param {boolean} [showLabel=false] - Whether to always show the label.
+ * @returns {JSX.Element | false} The rendered label element or false if not shown.
+ */
+export declare const renderLabel: (variant: VariantProps, props: FormRenderProps, showLabel?: boolean) => false | import("react/jsx-runtime").JSX.Element;
+/**
+ * Formats a date string in "M/YYYY" or "MM/YYYY" format to "MM/01/YYYY".
+ *
+ * @param {string} date - The date string to format.
+ * @returns {string} The formatted date string with day set to '01'.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function formatDateMonthAndYear(date: any): string;
+/**
+ * Parses a custom time string in "HH:mm:ss.SSS" format into a Dayjs object.
+ *
+ * @param {string} timeString - The custom time string to parse.
+ * @returns {Dayjs | null} The parsed Dayjs object, or null if input is empty.
+ */
+export declare function parseCustomTime(timeString: string): dayjs.Dayjs | null;
+/**
+ * Formats a Dayjs object into a custom time string "HH:mm:ss.SSSSSSS".
+ *
+ * @param {Dayjs | null | undefined} date - The Dayjs object to format.
+ * @returns {string} The formatted time string, or an empty string if invalid.
+ */
+export declare function formatDayjsToCustomTime(date: Dayjs | null | undefined): string;
+/**
+ * Extracts and formats a date string into "DD/MM/YYYY".
+ *
+ * @param {string | any} inputDateString - The input date string or value.
+ * @returns {string} The formatted date string, or an empty string if input is falsy.
+ */
+export declare const extractDate: (inputDateString: string | any) => string;

package/dist/utils/Constants/FormConstants.esm.js

@@ -0,0 +1,78 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import dayjs from 'dayjs';
+
+/**
+ * Renders a form input label with an optional required asterisk.
+ *
+ * @param {VariantProps} variant - The variant type of the form input.
+ * @param {FormRenderProps} props - The properties for rendering the form input.
+ * @param {boolean} [showLabel=false] - Whether to always show the label.
+ * @returns {JSX.Element | false} The rendered label element or false if not shown.
+ */
+const renderLabel = (variant, props, showLabel = false) => (variant === 'standard' || showLabel) && (jsxs("span", { id: `${props.item.name}-label`, className: "formInputlabel", style: { fontSize: '12px' }, children: [props.item.label, ' ', props.item.required && (jsx("span", { "aria-hidden": "true", style: { color: 'var(--mui-palette-error-main, #B3261E)' }, children: "*" }))] }));
+/**
+ * Formats a date string in "M/YYYY" or "MM/YYYY" format to "MM/01/YYYY".
+ *
+ * @param {string} date - The date string to format.
+ * @returns {string} The formatted date string with day set to '01'.
+ * @throws {TypeError} If the input is not a string.
+ */
+function formatDateMonthAndYear(date) {
+    // Check if date is a string
+    if (typeof date !== 'string') {
+        throw new TypeError('Expected a string');
+    }
+    // Split the date string into month and year
+    const [month, year] = date.split('/');
+    // If the month has only one digit, prepend '0' to it
+    const formattedMonth = month.length === 1 ? '0' + month : month;
+    // Return the formatted date with day set to '01'
+    return `${formattedMonth}/01/${year}`;
+}
+/**
+ * Parses a custom time string in "HH:mm:ss.SSS" format into a Dayjs object.
+ *
+ * @param {string} timeString - The custom time string to parse.
+ * @returns {Dayjs | null} The parsed Dayjs object, or null if input is empty.
+ */
+function parseCustomTime(timeString) {
+    if (!timeString)
+        return null; // Return null if empty
+    const [timePart, msPart] = timeString.split('.');
+    const [hours, minutes, seconds] = timePart.split(':').map(Number);
+    const milliseconds = msPart ? Number(parseFloat(`0.${msPart}`).toFixed(3)) * 1000 : 0;
+    return dayjs().hour(hours).minute(minutes).second(seconds).millisecond(milliseconds);
+}
+/**
+ * Formats a Dayjs object into a custom time string "HH:mm:ss.SSSSSSS".
+ *
+ * @param {Dayjs | null | undefined} date - The Dayjs object to format.
+ * @returns {string} The formatted time string, or an empty string if invalid.
+ */
+function formatDayjsToCustomTime(date) {
+    if (!date || !date.isValid())
+        return '';
+    const milliseconds = date.millisecond().toString().padEnd(7, '0');
+    return `${date.format('HH:mm:ss')}.${milliseconds}`;
+}
+/**
+ * Extracts and formats a date string into "DD/MM/YYYY".
+ *
+ * @param {string | any} inputDateString - The input date string or value.
+ * @returns {string} The formatted date string, or an empty string if input is falsy.
+ */
+const extractDate = (inputDateString) => {
+    const inputDate = new Date(inputDateString);
+    if (!inputDateString) {
+        return '';
+    }
+    // Extract day, month, and year components
+    const day = inputDate.getDate();
+    const month = inputDate.getMonth() + 1; // Months are zero-based
+    const year = inputDate.getFullYear();
+    // Format the components as DD/MM/YYYY
+    const formattedDate = `${day}/${month}/${year}`;
+    return formattedDate;
+};
+
+export { extractDate, formatDateMonthAndYear, formatDayjsToCustomTime, parseCustomTime, renderLabel };

package/dist/utils/Constants/FunctionConstants.d.ts

@@ -0,0 +1,61 @@
+export declare const handleDownloadReactTableDataExcel: (fileName: string, rowData: any[], columns?: any[], customColumns?: any[], HeaderBackGround?: string, HeaderColor?: string) => Promise<void>;
+export declare function getUsernameFromEmail(email: string): string;
+export declare function getInitials(name: string): string;
+export declare function findMenuHierarchy(menuData: any[], currentUrl: string, URLProjectNameWithSlash: string): any;
+/**
+ * Calculates a date by adding/subtracting days from today or a base date
+ * @param dayOffset - Days to add (positive) or subtract (negative) (default: 0)
+ * @param baseDate - Base date in DD/MM/YYYY format (default: today)
+ * @returns Formatted date string in DD/MM/YYYY format
+ */
+export declare const getDesiredDate: (dayOffset?: number, baseDate?: string | null) => string;
+/**
+ * Calculates sum of numeric values for a specific property across array objects
+ * @param array - Array of objects to sum
+ * @param key - Property name to sum
+ * @returns Total sum of numeric values
+ */
+export declare function calculateTotalArrayValueTotal<T extends Record<string, any>>(array: T[], key: keyof T): number;
+/**
+ * Checks if first date comes before second date
+ * @param dateStr1 - First date in DD/MM/YYYY format
+ * @param dateStr2 - Second date in DD/MM/YYYY format
+ * @returns True if dateStr1 is before dateStr2
+ */
+export declare function checkIsDateIsBefore(dateStr1: string, dateStr2: string): boolean;
+/**
+ * Lightens a hex color by a specified percentage
+ * @param color - Hex color string (with or without #)
+ * @param percent - Percentage to lighten (0-100)
+ * @returns Lightened hex color string
+ */
+export declare function lightenColor(color: string, percent: number): string;
+/**
+ * Gets formatted date with optional day offset
+ * @param dayOffset - Days to add (positive) or subtract (negative) from today (default: 0)
+ * @returns Date string in DD/MM/YYYY format
+ */
+export declare function getFormattedDate(dayOffset?: number): string;
+/**
+ * Encrypts text or objects using AES encryption and Base64 encoding
+ * @param text - String to encrypt (objects will be JSON.stringify'd)
+ * @param SECRET_KEY - Secret key for encryption
+ * @returns Base64 encoded encrypted string
+ * @example
+ * ```typescript
+ * const encrypted = await encryptText("Hello World", "myKey");
+ * const encryptedObj = await encryptText({name: "John"}, "myKey");
+ * ```
+ */
+export declare const encryptText: (text: string, SECRET_KEY: string) => Promise<string>;
+/**
+ * Decrypts Base64 encoded AES encrypted text back to original string
+ * @param ciphertext - Base64 encoded encrypted string from encryptText
+ * @param SECRET_KEY - Same secret key used for encryption
+ * @returns Original decrypted text
+ * @example
+ * ```typescript
+ * const decrypted = await decryptText(encryptedString, "myKey");
+ * ```
+ */
+export declare const decryptText: (ciphertext: string, SECRET_KEY: string) => Promise<string>;

package/dist/utils/Constants/FunctionConstants.esm.js

@@ -0,0 +1,236 @@
+import dayjs from 'dayjs';
+import { saveAs } from './file-saver.esm.js';
+import { utils, write } from './xlsx-js-style.esm.js';
+
+const toTitleCase = (str) => {
+    return str
+        .replace(/([A-Z])/g, ' $1') // Insert space before capital letters
+        .replace(/^./, (match) => match.toUpperCase()) // Capitalize the first letter
+        .trim(); // Remove any leading or trailing spaces
+};
+const getMaxLength = (data, key) => {
+    const keyLength = key.length;
+    // Length of the key (column header)
+    const dataMaxLength = Math.max(...data.map((item) => (item[key] ? item[key].toString().length : 0)));
+    return Math.max(keyLength, dataMaxLength);
+}; // Return the maximum of key length or data length };
+const handleDownloadReactTableDataExcel = async (fileName, rowData, columns = [], customColumns = [], HeaderBackGround = 'FFF4694B', HeaderColor = '000000') => {
+    const EXCEL_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8';
+    const EXCEL_EXTENSION = '.xlsx';
+    // Exclude 'actions' column and columns with hideOnExcel: true
+    const visibleColumns1 = columns.filter((col) => col?.accessorKey !== 'actions');
+    const visibleColumns = visibleColumns1.filter((col) => !col?.hideOnExcel || col?.hideOnExcel !== true);
+    const data = rowData;
+    // Map column headers and accessorKeys
+    const columnHeaders = visibleColumns.length > 0 ? visibleColumns.map((col) => col.header) : Object.keys(data[0]); // Use data keys as headers if columns are not provided
+    const accessorKeys = visibleColumns.length > 0 ? visibleColumns.map((col) => col.accessorKey) : Object.keys(data[0]); // Use data keys as accessor keys if columns are not provided
+    // Reformat data to include only visible columns
+    const formattedData = data.map((row) => {
+        const formattedRow = {};
+        accessorKeys.forEach((key) => {
+            formattedRow[key] = row[key] || '';
+        });
+        return formattedRow;
+    });
+    // Create worksheet
+    const ws = await utils.json_to_sheet(formattedData, { header: accessorKeys });
+    // Apply column headers styling dynamically
+    for (let index = 0; index < accessorKeys.length; index++) {
+        const key = accessorKeys[index];
+        const colLetter = await utils.encode_col(index); // Excel column letter
+        const cellAddress = `${colLetter}1`; // Header row cell
+        const headerText = toTitleCase(columnHeaders[index]);
+        ws[cellAddress] = {
+            t: 's',
+            v: headerText,
+            s: {
+                fill: { patternType: 'solid', fgColor: { rgb: HeaderBackGround } },
+                font: { bold: true, color: { rgb: HeaderColor }, sz: 12 },
+                alignment: { horizontal: 'center' },
+            },
+        };
+        // Apply custom color to entire column based on excelColumnColor in the column definition
+        const col = visibleColumns.length > 0
+            ? visibleColumns[index]
+            : customColumns.length > 0 && customColumns.find((item) => item.accessorKey === key);
+        if (col && col.excelColumnColor) {
+            const columnColor = col.excelColumnColor;
+            const textColor = col.excelTextColor;
+            // Apply color to all rows in that column (from row 2 onward)
+            for (let rowIndex = 2; rowIndex <= formattedData.length + 1; rowIndex++) {
+                const cell = `${colLetter}${rowIndex}`;
+                ws[cell] = ws[cell] || {}; // Ensure cell exists
+                ws[cell].s = ws[cell].s || {}; // Ensure style exists
+                ws[cell].s.fill = {
+                    patternType: 'solid',
+                    fgColor: { rgb: columnColor },
+                    font: { color: { rgb: textColor } },
+                };
+                ws[cell].s.border = {
+                    top: { style: 'thin', color: { rgb: '000000' } }, // Black thin border
+                    bottom: { style: 'thin', color: { rgb: '000000' } },
+                    left: { style: 'thin', color: { rgb: '000000' } },
+                    right: { style: 'thin', color: { rgb: '000000' } },
+                };
+            }
+        }
+    }
+    // Set column widths dynamically or with defaults
+    const colWidths = visibleColumns.length > 0
+        ? accessorKeys.map((accessorKey) => {
+            // Find the corresponding column by accessorKey
+            const column = visibleColumns.find((col) => col.accessorKey === accessorKey);
+            // Check if `excelColumnSize` is defined for this column
+            if (column && column.excelColumnSize) {
+                return {
+                    wch: parseInt(column.excelColumnSize.replace('px', '')) / 7,
+                };
+            }
+            else {
+                return { wch: getMaxLength(data, accessorKey) + 5 }; // Default column width
+            }
+        })
+        : customColumns.length > 0
+            ? accessorKeys.map((accessorKey) => {
+                // Find the corresponding column by accessorKey
+                const column = customColumns.find((col) => col.accessorKey === accessorKey);
+                // Check if `excelColumnSize` is defined for this column
+                if (column && column.excelColumnSize) {
+                    return {
+                        wch: parseInt(column.excelColumnSize.replace('px', '')) / 7,
+                    };
+                }
+                else {
+                    return { wch: getMaxLength(data, accessorKey) + 5 }; // Default column width
+                }
+            })
+            : accessorKeys.map((accessorKey) => {
+                // Find the corresponding column by accessorKey
+                const column = customColumns.find((col) => col.accessorKey === accessorKey);
+                // Check if `excelColumnSize` is defined for this column
+                if (column && column.excelColumnSize) {
+                    return {
+                        wch: parseInt(column.excelColumnSize.replace('px', '')) / 7,
+                    };
+                }
+                else {
+                    return { wch: getMaxLength(data, accessorKey) + 5 }; // Default column width
+                }
+            });
+    ws['!cols'] = colWidths;
+    // Create workbook and save it
+    const wb = await utils.book_new();
+    await utils.book_append_sheet(wb, ws, 'Sheet1');
+    const eb = await write(wb, { bookType: 'xlsx', type: 'array' });
+    const blob = new Blob([eb], { type: EXCEL_TYPE });
+    await saveAs(blob, fileName + EXCEL_EXTENSION);
+};
+function getUsernameFromEmail(email) {
+    return email.split('@')[0];
+}
+function getInitials(name) {
+    if (!name)
+        return '';
+    const words = name.trim().split(/\s+/); // split by any spaces
+    let initials = '';
+    for (let i = 0; i < words.length && initials.length < 2; i++) {
+        initials += words[i][0].toUpperCase();
+    }
+    return initials;
+}
+function findMenuHierarchy(menuData, currentUrl, URLProjectNameWithSlash) {
+    const url = currentUrl;
+    const pathname = url.pathname.replace(URLProjectNameWithSlash, '').toLowerCase() + url.search.toLowerCase();
+    let result = [];
+    function traverse(menus, path = []) {
+        for (const menu of menus) {
+            const currentPath = [...path, menu];
+            const subMenusRaw = [].concat(menu.SubMenu || [], menu.SubMenus || []).filter(Boolean);
+            // Match found
+            if (menu.Path && menu.Path.toLowerCase() === pathname) {
+                result = currentPath;
+                return true;
+            }
+            if (subMenusRaw.length > 0) {
+                if (traverse(subMenusRaw, currentPath)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    traverse(menuData);
+    return result;
+}
+/**
+ * Calculates a date by adding/subtracting days from today or a base date
+ * @param dayOffset - Days to add (positive) or subtract (negative) (default: 0)
+ * @param baseDate - Base date in DD/MM/YYYY format (default: today)
+ * @returns Formatted date string in DD/MM/YYYY format
+ */
+const getDesiredDate = (dayOffset = 0, baseDate = null) => {
+    const startDate = baseDate ? dayjs(baseDate, 'DD/MM/YYYY') : dayjs();
+    if (!startDate.isValid()) {
+        throw new Error('Invalid date format. Please use DD/MM/YYYY.');
+    }
+    return startDate.add(dayOffset, 'day').format('DD/MM/YYYY');
+};
+/**
+ * Calculates sum of numeric values for a specific property across array objects
+ * @param array - Array of objects to sum
+ * @param key - Property name to sum
+ * @returns Total sum of numeric values
+ */
+function calculateTotalArrayValueTotal(array, key) {
+    if (!Array.isArray(array)) {
+        return 0;
+    }
+    return array.reduce((sum, item) => {
+        const value = Number(item[key]) || 0;
+        return sum + value;
+    }, 0);
+}
+/**
+ * Checks if first date comes before second date
+ * @param dateStr1 - First date in DD/MM/YYYY format
+ * @param dateStr2 - Second date in DD/MM/YYYY format
+ * @returns True if dateStr1 is before dateStr2
+ */
+function checkIsDateIsBefore(dateStr1, dateStr2) {
+    const date1 = dayjs(dateStr1.trim(), 'DD/MM/YYYY');
+    const date2 = dayjs(dateStr2.trim(), 'DD/MM/YYYY');
+    if (!date1.isValid() || !date2.isValid()) {
+        throw new Error('Invalid date format. Please use DD/MM/YYYY.');
+    }
+    return date1.isBefore(date2);
+}
+/**
+ * Lightens a hex color by a specified percentage
+ * @param color - Hex color string (with or without #)
+ * @param percent - Percentage to lighten (0-100)
+ * @returns Lightened hex color string
+ */
+function lightenColor(color, percent) {
+    const num = parseInt(color.replace('#', ''), 16);
+    const amt = Math.round(2.55 * percent);
+    const R = (num >> 16) + amt;
+    const G = ((num >> 8) & 0x00ff) + amt;
+    const B = (num & 0x0000ff) + amt;
+    return ('#' +
+        (0x1000000 +
+            (R < 255 ? (R < 1 ? 0 : R) : 255) * 0x10000 +
+            (G < 255 ? (G < 1 ? 0 : G) : 255) * 0x100 +
+            (B < 255 ? (B < 1 ? 0 : B) : 255))
+            .toString(16)
+            .slice(1));
+}
+/**
+ * Gets formatted date with optional day offset
+ * @param dayOffset - Days to add (positive) or subtract (negative) from today (default: 0)
+ * @returns Date string in DD/MM/YYYY format
+ */
+function getFormattedDate(dayOffset = 0) {
+    return dayjs().add(dayOffset, 'day').format('DD/MM/YYYY');
+}
+
+export { calculateTotalArrayValueTotal, checkIsDateIsBefore, findMenuHierarchy, getDesiredDate, getFormattedDate, getInitials, getUsernameFromEmail, handleDownloadReactTableDataExcel, lightenColor };

package/dist/utils/Constants/FunctionConstants.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/Constants/crypto-js.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Lazy-loaded crypto-js module
+ * This module provides dynamic imports for crypto-js to reduce initial bundle size
+ */
+/**
+ * Get the CryptoJS module
+ * @returns Promise that resolves to the CryptoJS module
+ */
+export declare const getCryptoJS: () => Promise<any>;
+/**
+ * AES encryption namespace with lazy-loaded methods
+ */
+export declare const AES: {
+    encrypt: (text: string, key: string) => Promise<any>;
+    decrypt: (ciphertext: string, key: string) => Promise<any>;
+};
+/**
+ * Encoding namespaces with lazy-loaded methods
+ */
+export declare const enc: {
+    Base64: {
+        stringify: (wordArray: any) => Promise<any>;
+        parse: (base64Str: string) => Promise<any>;
+    };
+    Utf8: {
+        parse: (utf8Str: string) => Promise<any>;
+        stringify: (wordArray: any) => Promise<any>;
+    };
+};

package/dist/utils/Constants/date-pickers.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Lazy-loading wrapper for @mui/x-date-pickers components
+ * This module provides dynamic imports for date/time picker components
+ * to reduce initial bundle size
+ */
+/**
+ * Get DatePicker component
+ * @returns DatePicker component
+ */
+export declare const getDatePicker: () => Promise<any>;
+/**
+ * Get LocalizationProvider component
+ * @returns LocalizationProvider component
+ */
+export declare const getLocalizationProvider: () => Promise<any>;
+/**
+ * Get AdapterDayjs adapter
+ * @returns AdapterDayjs adapter
+ */
+export declare const getAdapterDayjs: () => Promise<any>;
+/**
+ * Get TimePicker component
+ * @returns TimePicker component
+ */
+export declare const getTimePicker: () => Promise<any>;
+export declare const DatePicker: () => null;
+export declare const LocalizationProvider: () => null;
+export declare const AdapterDayjs: () => any;
+export declare const TimePicker: () => null;

package/dist/utils/Constants/date-pickers.esm.js

@@ -0,0 +1,33 @@
+/**
+ * Lazy-loading wrapper for @mui/x-date-pickers components
+ * This module provides dynamic imports for date/time picker components
+ * to reduce initial bundle size
+ */
+// Dynamic import for DatePicker components
+let DatePickerCache = null;
+/**
+ * Get DatePicker component
+ * @returns DatePicker component
+ */
+const getDatePicker = async () => {
+    if (!DatePickerCache) {
+        const module = await import('@mui/x-date-pickers/DatePicker');
+        DatePickerCache = module.DatePicker || module.default;
+    }
+    return DatePickerCache;
+};
+// Dynamic import for TimePicker component
+let TimePickerCache = null;
+/**
+ * Get TimePicker component
+ * @returns TimePicker component
+ */
+const getTimePicker = async () => {
+    if (!TimePickerCache) {
+        const module = await import('@mui/x-date-pickers/TimePicker');
+        TimePickerCache = module.TimePicker || module.default;
+    }
+    return TimePickerCache;
+};
+
+export { getDatePicker, getTimePicker };

package/dist/utils/Constants/file-saver.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Lazy-loaded file-saver module
+ * This module provides dynamic imports for file-saver to reduce initial bundle size
+ */
+/**
+ * Get the saveAs function from file-saver
+ * @returns Promise that resolves to the saveAs function
+ */
+export declare const getSaveAs: () => Promise<typeof import("file-saver")>;
+/**
+ * Placeholder for the saveAs function that will be dynamically imported
+ * This allows TypeScript to recognize the function signature
+ */
+export declare const saveAs: (blob: Blob, filename: string) => Promise<void>;

package/dist/utils/Constants/file-saver.esm.js

@@ -0,0 +1,22 @@
+/**
+ * Lazy-loaded file-saver module
+ * This module provides dynamic imports for file-saver to reduce initial bundle size
+ */
+/**
+ * Get the saveAs function from file-saver
+ * @returns Promise that resolves to the saveAs function
+ */
+const getSaveAs = async () => {
+    const module = await import('file-saver');
+    return module.saveAs;
+};
+/**
+ * Placeholder for the saveAs function that will be dynamically imported
+ * This allows TypeScript to recognize the function signature
+ */
+const saveAs = async (blob, filename) => {
+    const realSaveAs = await getSaveAs();
+    return realSaveAs(blob, filename);
+};
+
+export { getSaveAs, saveAs };

package/dist/utils/Constants/index.d.ts

@@ -0,0 +1,5 @@
+export * from './FunctionConstants';
+export * from './FormConstants';
+export * from './date-pickers';
+export * from './file-saver';
+export * from './xlsx-js-style';