react-js-plugins 3.14.4 → 3.14.5

package/dist/chunkautils/chunk83453.js

@@ -1,97 +1,24 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import moment from "moment";
 import { _deepClone, isWindowReady } from "./chunk65431";
-import { chunk } from "./chunk75342";
-export var _scrollToTop = function () {
+export const _scrollToTop = () => {
     if (!isWindowReady()) {
         return;
     }
     window.scrollTo({ top: 0, behavior: "smooth" });
 };
-export var _batchProcess = function (data, batchSize, processFn) { return __awaiter(void 0, void 0, void 0, function () {
-    var i, batch;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                i = 0;
-                _a.label = 1;
-            case 1:
-                if (!(i < data.length)) return [3 /*break*/, 4];
-                batch = data.slice(i, i + batchSize);
-                return [4 /*yield*/, Promise.all(batch.map(processFn))];
-            case 2:
-                _a.sent();
-                _a.label = 3;
-            case 3:
-                i += batchSize;
-                return [3 /*break*/, 1];
-            case 4: return [2 /*return*/];
-        }
-    });
-}); };
-export var _flattenObject = function (obj, prefix) {
-    if (prefix === void 0) { prefix = ''; }
-    var result = {};
-    for (var key in obj) {
+export const _batchProcess = async (data, batchSize, processFn) => {
+    for (let i = 0; i < data.length; i += batchSize) {
+        const batch = data.slice(i, i + batchSize);
+        await Promise.all(batch.map(processFn));
+    }
+};
+export const _flattenObject = (obj, prefix = '') => {
+    let result = {};
+    for (let key in obj) {
         if (obj.hasOwnProperty(key)) {
-            var newKey = prefix ? "".concat(prefix, ".").concat(key) : key;
+            const newKey = prefix ? `${prefix}.${key}` : key;
             if (typeof obj[key] === 'object' && obj[key] !== null) {
-                result = __assign(__assign({}, result), _flattenObject(obj[key], newKey));
+                result = Object.assign(Object.assign({}, result), _flattenObject(obj[key], newKey));
             }
             else {
                 result[newKey] = obj[key];
@@ -100,8 +27,8 @@ export var _flattenObject = function (obj, prefix) {
     }
     return result;
 };
-export var _deepMerge = function (target, source) {
-    for (var key in source) {
+export const _deepMerge = (target, source) => {
+    for (let key in source) {
         if (source.hasOwnProperty(key)) {
             if (typeof source[key] === 'object' && source[key] !== null && target[key]) {
                 target[key] = _deepMerge(target[key], source[key]);
@@ -113,14 +40,14 @@ export var _deepMerge = function (target, source) {
     }
     return target;
 };
-export var _chunk = function (arr, size) {
-    var result = [];
-    for (var i = 0; i < arr.length; i += size) {
+export const _chunk = (arr, size) => {
+    const result = [];
+    for (let i = 0; i < arr.length; i += size) {
         result.push(arr.slice(i, i + size));
     }
     return result;
 };
-var toVal = function (mix) {
+const toVal = (mix) => {
     if (typeof mix === "string" || typeof mix === "number") {
         return String(mix);
     }
@@ -132,66 +59,40 @@ var toVal = function (mix) {
     }
     if (mix && typeof mix === "object") {
         return Object.entries(mix)
-            .filter(function (_a) {
-            var _ = _a[0], value = _a[1];
-            return Boolean(value);
-        })
-            .map(function (_a) {
-            var key = _a[0];
-            return key;
-        })
+            .filter(([_, value]) => Boolean(value))
+            .map(([key]) => key)
             .join(" ");
     }
     return "";
 };
-export var _combineClasses = function () {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    if (!chunk()) {
-        throw new Error("Postcss: <css input>:X:X: Unknown word");
-    }
+export const _combineClasses = (...args) => {
     return args
         .map(toVal)
         .filter(Boolean)
         .join(" ");
 };
-export var _asyncDebounce = function (fn, delay) {
-    var timeout;
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        return __awaiter(void 0, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                clearTimeout(timeout);
-                timeout = setTimeout(function () { return fn.apply(void 0, args); }, delay);
-                return [2 /*return*/];
-            });
-        });
+export const _asyncDebounce = (fn, delay) => {
+    let timeout;
+    return async (...args) => {
+        clearTimeout(timeout);
+        timeout = setTimeout(() => fn(...args), delay);
     };
 };
 export function _throttle(func, limit) {
-    var inThrottle;
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
+    let inThrottle;
+    return (...args) => {
         if (!inThrottle) {
-            func.apply(void 0, args);
+            func(...args);
             inThrottle = true;
-            setTimeout(function () { return (inThrottle = false); }, limit);
+            setTimeout(() => (inThrottle = false), limit);
         }
     };
 }
-export var _deepCloneArray = function (arr) {
-    return arr.map(function (item) { return (typeof item === 'object' ? _deepClone(item) : item); });
+export const _deepCloneArray = (arr) => {
+    return arr.map(item => (typeof item === 'object' ? _deepClone(item) : item));
 };
-export var _getMaxMinValue = function (arr) {
-    return arr.reduce(function (acc, curr) {
+export const _getMaxMinValue = (arr) => {
+    return arr.reduce((acc, curr) => {
         if (curr > acc.max)
             acc.max = curr;
         if (curr < acc.min)
@@ -199,64 +100,34 @@ export var _getMaxMinValue = function (arr) {
         return acc;
     }, { max: -Infinity, min: Infinity });
 };
-export var _asyncMap = function (arr, asyncFn) { return __awaiter(void 0, void 0, void 0, function () {
-    var results, i, _a, _b;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
-            case 0:
-                results = [];
-                i = 0;
-                _c.label = 1;
-            case 1:
-                if (!(i < arr.length)) return [3 /*break*/, 4];
-                _b = (_a = results).push;
-                return [4 /*yield*/, asyncFn(arr[i])];
-            case 2:
-                _b.apply(_a, [_c.sent()]);
-                _c.label = 3;
-            case 3:
-                i++;
-                return [3 /*break*/, 1];
-            case 4: return [2 /*return*/, results];
-        }
-    });
-}); };
-export var _transformAsyncData = function (arr, transformer) { return __awaiter(void 0, void 0, void 0, function () {
-    var result, i, transformedItem;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                result = [];
-                i = 0;
-                _a.label = 1;
-            case 1:
-                if (!(i < arr.length)) return [3 /*break*/, 4];
-                return [4 /*yield*/, transformer(arr[i])];
-            case 2:
-                transformedItem = _a.sent();
-                result.push(transformedItem);
-                _a.label = 3;
-            case 3:
-                i++;
-                return [3 /*break*/, 1];
-            case 4: return [2 /*return*/, result];
-        }
-    });
-}); };
-export var _getNestedProperty = function (obj, path) {
-    return path.split('.').reduce(function (acc, key) { return acc && acc[key]; }, obj);
+export const _asyncMap = async (arr, asyncFn) => {
+    const results = [];
+    for (let i = 0; i < arr.length; i++) {
+        results.push(await asyncFn(arr[i]));
+    }
+    return results;
+};
+export const _transformAsyncData = async (arr, transformer) => {
+    const result = [];
+    for (let i = 0; i < arr.length; i++) {
+        const transformedItem = await transformer(arr[i]);
+        result.push(transformedItem);
+    }
+    return result;
+};
+export const _getNestedProperty = (obj, path) => {
+    return path.split('.').reduce((acc, key) => acc && acc[key], obj);
 };
-export var _deepEqual = function (obj1, obj2) {
+export const _deepEqual = (obj1, obj2) => {
     if (obj1 === obj2)
         return true;
     if (typeof obj1 !== 'object' || obj1 === null || typeof obj2 !== 'object' || obj2 === null)
         return false;
-    var keys1 = Object.keys(obj1);
-    var keys2 = Object.keys(obj2);
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
     if (keys1.length !== keys2.length)
         return false;
-    for (var _i = 0, keys1_1 = keys1; _i < keys1_1.length; _i++) {
-        var key = keys1_1[_i];
+    for (let key of keys1) {
         if (!keys2.includes(key))
             return false;
         if (!_deepEqual(obj1[key], obj2[key]))
@@ -264,63 +135,50 @@ export var _deepEqual = function (obj1, obj2) {
     }
     return true;
 };
-export var _mergeArrays = function (arr1, arr2) {
-    return Array.from(new Set(__spreadArray(__spreadArray([], arr1, true), arr2, true)));
+export const _mergeArrays = (arr1, arr2) => {
+    return Array.from(new Set([...arr1, ...arr2]));
 };
-export var _filterDuplicates = function (arr, uniqueKey) {
-    var seen = new Set();
-    return arr.filter(function (item) {
-        var key = item[uniqueKey];
+export const _filterDuplicates = (arr, uniqueKey) => {
+    const seen = new Set();
+    return arr.filter((item) => {
+        const key = item[uniqueKey];
         if (seen.has(key))
             return false;
         seen.add(key);
         return true;
     });
 };
-export var _sortByKey = function (arr, key, order) {
-    if (order === void 0) { order = "asc"; }
-    return __spreadArray([], arr, true).sort(function (a, b) {
-        return order === "asc" ? a[key] - b[key] : b[key] - a[key];
-    });
-};
-export var _extractUniqueValues = function (array, key) {
+export const _sortByKey = (arr, key, order = "asc") => [...arr].sort((a, b) => order === "asc" ? a[key] - b[key] : b[key] - a[key]);
+export const _extractUniqueValues = (array, key) => {
     if (!Array.isArray(array))
         return [];
-    return Array.from(new Set(array.map(function (item) { return item[key]; }).filter(function (val) { return val !== undefined; })));
+    return Array.from(new Set(array.map(item => item[key]).filter(val => val !== undefined)));
 };
-export var _extractKeyValues = function (array, key) {
+export const _extractKeyValues = (array, key) => {
     if (!Array.isArray(array))
         return [];
-    return array.map(function (item) { return item[key]; }).filter(function (val) { return val !== undefined; });
+    return array.map(item => item[key]).filter(val => val !== undefined);
 };
-export var _extractNestedKeyValues = function (array, keyPath) {
+export const _extractNestedKeyValues = (array, keyPath) => {
     if (!Array.isArray(array))
         return [];
-    var keys = keyPath.split('.');
-    return array.map(function (item) {
-        var value = item;
-        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
-            var k = keys_1[_i];
+    const keys = keyPath.split('.');
+    return array.map(item => {
+        let value = item;
+        for (const k of keys) {
             if (value === undefined)
                 break;
             value = value[k];
         }
         return value;
-    }).filter(function (val) { return val !== undefined; });
-};
-export var _mapAsync = function (arr, asyncFn) { return __awaiter(void 0, void 0, void 0, function () {
-    var result;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, Promise.all(arr.map(asyncFn))];
-            case 1:
-                result = _a.sent();
-                return [2 /*return*/, result];
-        }
-    });
-}); };
-export var _formatDate = function (date, format) {
-    var options = {};
+    }).filter(val => val !== undefined);
+};
+export const _mapAsync = async (arr, asyncFn) => {
+    const result = await Promise.all(arr.map(asyncFn));
+    return result;
+};
+export const _formatDate = (date, format) => {
+    const options = {};
     if (format.includes('Y'))
         options.year = 'numeric';
     if (format.includes('M'))
@@ -329,40 +187,39 @@ export var _formatDate = function (date, format) {
         options.day = 'numeric';
     return new Intl.DateTimeFormat('en-US', options).format(date);
 };
-export function _localeDateFormat(date, locale, options) {
-    if (locale === void 0) { locale = 'en-IN'; }
-    return new Intl.DateTimeFormat(locale, __assign({ year: 'numeric', month: 'short', day: 'numeric' }, options)).format(new Date(date));
+export function _localeDateFormat(date, locale = 'en-IN', options) {
+    return new Intl.DateTimeFormat(locale, Object.assign({ year: 'numeric', month: 'short', day: 'numeric' }, options)).format(new Date(date));
 }
-export var _calPercentage = function (value, total) {
+export const _calPercentage = (value, total) => {
     if (total === 0)
         return 0;
     return (value / total) * 100;
 };
-export var _sum = function (numbers) {
-    return numbers.reduce(function (acc, num) { return acc + num; }, 0);
+export const _sum = (numbers) => {
+    return numbers.reduce((acc, num) => acc + num, 0);
 };
-export var _average = function (numbers) {
-    var total = _sum(numbers);
+export const _average = (numbers) => {
+    const total = _sum(numbers);
     return total / numbers.length;
 };
-export var _getPriceAfterTax = function (price, taxRate) {
+export const _getPriceAfterTax = (price, taxRate) => {
     return price * (1 + taxRate / 100);
 };
-export var _calculateTimeDifference = function (startDate, endDate) {
-    var diffInMilliseconds = endDate.getTime() - startDate.getTime();
-    var days = Math.floor(diffInMilliseconds / (1000 * 3600 * 24));
-    var hours = Math.floor((diffInMilliseconds % (1000 * 3600 * 24)) / (1000 * 3600));
-    var minutes = Math.floor((diffInMilliseconds % (1000 * 3600)) / (1000 * 60));
-    var seconds = Math.floor((diffInMilliseconds % (1000 * 60)) / 1000);
-    return "".concat(days, "d ").concat(hours, "h ").concat(minutes, "m ").concat(seconds, "s");
+export const _calculateTimeDifference = (startDate, endDate) => {
+    const diffInMilliseconds = endDate.getTime() - startDate.getTime();
+    const days = Math.floor(diffInMilliseconds / (1000 * 3600 * 24));
+    const hours = Math.floor((diffInMilliseconds % (1000 * 3600 * 24)) / (1000 * 3600));
+    const minutes = Math.floor((diffInMilliseconds % (1000 * 3600)) / (1000 * 60));
+    const seconds = Math.floor((diffInMilliseconds % (1000 * 60)) / 1000);
+    return `${days}d ${hours}h ${minutes}m ${seconds}s`;
 };
-export var _arrayIncludesObject = function (arr, obj) {
-    return arr.some(function (item) { return JSON.stringify(item) === JSON.stringify(obj); });
+export const _arrayIncludesObject = (arr, obj) => {
+    return arr.some(item => JSON.stringify(item) === JSON.stringify(obj));
 };
-export var _toCamelCase = function (str) {
-    return str.replace(/([-_][a-z])/g, function (group) { return group.toUpperCase().replace('-', '').replace('_', ''); });
+export const _toCamelCase = (str) => {
+    return str.replace(/([-_][a-z])/g, group => group.toUpperCase().replace('-', '').replace('_', ''));
 };
-export var _freeze = function (obj) {
+export const _freeze = (obj) => {
     if (typeof obj !== "object" || obj === null) {
         console.error("Error: Provided value is not a valid object.");
         return null;
@@ -373,14 +230,14 @@ export var _freeze = function (obj) {
     }
     return Object.freeze(obj);
 };
-export var _isFreeze = function (obj) {
+export const _isFreeze = (obj) => {
     if (typeof obj !== "object" || obj === null) {
         console.error("Error: Provided value is not a valid object.");
         return false;
     }
     return Object.isFrozen(obj);
 };
-export var _seal = function (obj) {
+export const _seal = (obj) => {
     if (typeof obj !== "object" || obj === null) {
         console.error("Error: Provided value is not a valid plain object.");
         return null;
@@ -391,22 +248,21 @@ export var _seal = function (obj) {
     }
     return Object.seal(obj);
 };
-export var _isSeal = function (obj) {
+export const _isSeal = (obj) => {
     if (typeof obj !== "object" || obj === null) {
         console.error("Error: Provided value is not a valid object.");
         return false;
     }
     return Object.isSealed(obj);
 };
-export var _arrayToObject = function (arr) {
-    var obj = {};
-    for (var _i = 0, arr_1 = arr; _i < arr_1.length; _i++) {
-        var _a = arr_1[_i], key = _a[0], value = _a[1];
+export const _arrayToObject = (arr) => {
+    const obj = {};
+    for (const [key, value] of arr) {
         obj[key] = value;
     }
     return obj;
 };
-export var _objectToArray = function (obj) {
+export const _objectToArray = (obj) => {
     var result = [];
     for (var key in obj) {
         if (obj.hasOwnProperty(key)) {
@@ -415,26 +271,23 @@ export var _objectToArray = function (obj) {
     }
     return result;
 };
-export var _arrayToObjectByKey = function (arr, key) {
-    return arr.reduce(function (acc, curr) {
+export const _arrayToObjectByKey = (arr, key) => {
+    return arr.reduce((acc, curr) => {
         acc[curr[key]] = curr;
         return acc;
     }, {});
 };
-export var _isInArray = function (arr, value) { return arr.includes(value); };
-export var _getObjectValues = function (obj) { return Object.values(obj); };
-export var _swapArrayElements = function (arr, index1, index2) {
-    var temp = arr[index1];
+export const _isInArray = (arr, value) => arr.includes(value);
+export const _getObjectValues = (obj) => Object.values(obj);
+export const _swapArrayElements = (arr, index1, index2) => {
+    const temp = arr[index1];
     arr[index1] = arr[index2];
     arr[index2] = temp;
 };
-export var _filterObjectByKey = function (obj, keys) {
-    return Object.fromEntries(Object.entries(obj).filter(function (_a) {
-        var key = _a[0];
-        return keys.includes(key);
-    }));
+export const _filterObjectByKey = (obj, keys) => {
+    return Object.fromEntries(Object.entries(obj).filter(([key]) => keys.includes(key)));
 };
-export var _getScrollPosition = function () {
+export const _getScrollPosition = () => {
     if (!isWindowReady()) {
         return { scrollX: 0, scrollY: 0 };
     }
@@ -443,30 +296,29 @@ export var _getScrollPosition = function () {
         scrollY: window.scrollY,
     };
 };
-export var _arrayIntersection = function (arr1, arr2) {
+export const _arrayIntersection = (arr1, arr2) => {
     if (!Array.isArray(arr1) || !Array.isArray(arr2)) {
         console.error("Both parameters must be arrays.");
         return [];
     }
-    return arr1.filter(function (item) { return arr2.includes(item); });
+    return arr1.filter(item => arr2.includes(item));
 };
-export var _getArrayOfObjectsByProperty = function (arr, key, value) {
-    return arr.filter(function (item) { return item[key] === value; });
+export const _getArrayOfObjectsByProperty = (arr, key, value) => {
+    return arr.filter(item => item[key] === value);
 };
-export var _downloadBlob = function (blob, filename) {
-    var url = URL.createObjectURL(blob);
-    var a = document.createElement('a');
+export const _downloadBlob = (blob, filename) => {
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
     a.href = url;
     a.download = filename;
     document.body.appendChild(a);
     a.click();
     document.body.removeChild(a);
 };
-export var _downloadFile = function (response, defaultName) {
-    if (defaultName === void 0) { defaultName = 'downloadedFile'; }
+export const _downloadFile = (response, defaultName = 'downloadedFile') => {
     try {
-        var contentType = response.headers['content-type'];
-        var fileName = defaultName;
+        const contentType = response.headers['content-type'];
+        let fileName = defaultName;
         if (contentType === 'application/pdf')
             fileName += '.pdf';
         else if (contentType === 'image/png')
@@ -481,16 +333,16 @@ export var _downloadFile = function (response, defaultName) {
             fileName += '.xlsx';
         else if (contentType === 'application/zip')
             fileName += '.zip';
-        var blob = new Blob([response.data], { type: contentType });
-        var url_1 = window.URL.createObjectURL(blob);
-        var link_1 = document.createElement('a');
-        link_1.href = url_1;
-        link_1.download = fileName;
-        document.body.appendChild(link_1);
-        link_1.click();
-        setTimeout(function () {
-            window.URL.revokeObjectURL(url_1);
-            document.body.removeChild(link_1);
+        const blob = new Blob([response.data], { type: contentType });
+        const url = window.URL.createObjectURL(blob);
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = fileName;
+        document.body.appendChild(link);
+        link.click();
+        setTimeout(() => {
+            window.URL.revokeObjectURL(url);
+            document.body.removeChild(link);
         }, 100);
     }
     catch (err) {
@@ -498,40 +350,38 @@ export var _downloadFile = function (response, defaultName) {
         throw err;
     }
 };
-export var _fileToBase64 = function (file) {
-    return new Promise(function (resolve, reject) {
-        if (!file || !(file instanceof File)) {
-            reject(new Error('No valid file provided'));
-            return;
-        }
-        var reader = new FileReader();
-        reader.onload = function () {
-            if (typeof reader.result === 'string') {
-                var base64String = reader.result.split(",")[1];
-                if (base64String) {
-                    resolve(base64String);
-                }
-                else {
-                    reject(new Error("Failed to extract base64 data"));
-                }
+export const _fileToBase64 = (file) => new Promise((resolve, reject) => {
+    if (!file || !(file instanceof File)) {
+        reject(new Error('No valid file provided'));
+        return;
+    }
+    const reader = new FileReader();
+    reader.onload = () => {
+        if (typeof reader.result === 'string') {
+            const base64String = reader.result.split(",")[1];
+            if (base64String) {
+                resolve(base64String);
             }
             else {
-                reject(new Error("Invalid file format"));
+                reject(new Error("Failed to extract base64 data"));
             }
-        };
-        reader.onerror = function () { return reject(new Error("Failed to read file")); };
-        reader.readAsDataURL(file);
-    });
-};
-export var _base64ToBlob = function (base64) {
-    var binaryString = atob(base64.split(',')[1]);
-    var array = [];
-    for (var i = 0; i < binaryString.length; i++) {
+        }
+        else {
+            reject(new Error("Invalid file format"));
+        }
+    };
+    reader.onerror = () => reject(new Error("Failed to read file"));
+    reader.readAsDataURL(file);
+});
+export const _base64ToBlob = (base64) => {
+    const binaryString = atob(base64.split(',')[1]);
+    const array = [];
+    for (let i = 0; i < binaryString.length; i++) {
         array.push(binaryString.charCodeAt(i));
     }
     return new Blob([new Uint8Array(array)], { type: 'application/octet-stream' });
 };
-export var _downloadBase64File = function (base64Data, fileName) {
+export const _downloadBase64File = (base64Data, fileName) => {
     var _a, _b;
     try {
         if (!base64Data || typeof base64Data !== 'string') {
@@ -540,10 +390,10 @@ export var _downloadBase64File = function (base64Data, fileName) {
         if (!fileName || typeof fileName !== 'string') {
             throw new Error('A valid file name is required.');
         }
-        var hasPrefix = base64Data.startsWith('data:');
+        const hasPrefix = base64Data.startsWith('data:');
         if (!hasPrefix) {
-            var extension = (_b = (_a = fileName.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : '';
-            var mimeTypes = {
+            const extension = (_b = (_a = fileName.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : '';
+            const mimeTypes = {
                 jpg: 'image/jpeg',
                 jpeg: 'image/jpeg',
                 png: 'image/png',
@@ -553,13 +403,13 @@ export var _downloadBase64File = function (base64Data, fileName) {
                 xls: 'application/vnd.ms-excel',
                 xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
             };
-            var mimeType = mimeTypes[extension] || 'application/octet-stream';
-            base64Data = "data:".concat(mimeType, ";base64,").concat(base64Data);
+            const mimeType = mimeTypes[extension] || 'application/octet-stream';
+            base64Data = `data:${mimeType};base64,${base64Data}`;
         }
         if (!base64Data.includes('base64,')) {
             throw new Error('Base64 string is missing proper format.');
         }
-        var link = document.createElement('a');
+        const link = document.createElement('a');
         link.href = base64Data;
         link.download = fileName;
         document.body.appendChild(link);
@@ -570,8 +420,7 @@ export var _downloadBase64File = function (base64Data, fileName) {
         console.error('Download failed:', error.message);
     }
 };
-export var _uint8ArrayToBlob = function (uint8Array, mimeType) {
-    if (mimeType === void 0) { mimeType = 'application/octet-stream'; }
+export const _uint8ArrayToBlob = (uint8Array, mimeType = 'application/octet-stream') => {
     try {
         if (!(uint8Array instanceof Uint8Array)) {
             throw new Error('Invalid input: expected Uint8Array.');
@@ -583,10 +432,9 @@ export var _uint8ArrayToBlob = function (uint8Array, mimeType) {
         return new Blob([], { type: mimeType });
     }
 };
-export var _octetToBlob = function (data, mimeType) {
-    if (mimeType === void 0) { mimeType = 'application/octet-stream'; }
+export const _octetToBlob = (data, mimeType = 'application/octet-stream') => {
     try {
-        var buffer = void 0;
+        let buffer;
         if (data instanceof Uint8Array) {
             buffer = data;
         }
@@ -606,15 +454,15 @@ export var _octetToBlob = function (data, mimeType) {
         return new Blob([], { type: mimeType });
     }
 };
-export var _initializeFormValues = function (fields) {
-    return fields.reduce(function (acc, field) {
+export const _initializeFormValues = (fields) => {
+    return fields.reduce((acc, field) => {
         acc[field] = ''; // default value
         return acc;
     }, {});
 };
-export var _setNestedProperty = function (obj, path, value) {
-    var keys = path.split('.');
-    keys.reduce(function (acc, key, idx) {
+export const _setNestedProperty = (obj, path, value) => {
+    const keys = path.split('.');
+    keys.reduce((acc, key, idx) => {
         if (idx === keys.length - 1) {
             acc[key] = value;
         }
@@ -624,21 +472,21 @@ export var _setNestedProperty = function (obj, path, value) {
         return acc[key];
     }, obj);
 };
-export var _transformArray = function (arr, transformFn) {
+export const _transformArray = (arr, transformFn) => {
     return arr.map(transformFn);
 };
-export var _findObjectById = function (arr, id) {
-    return arr.find(function (item) { return item.id === id; });
+export const _findObjectById = (arr, id) => {
+    return arr.find((item) => item.id === id);
 };
-export var _getUniqueValues = function (arr) {
+export const _getUniqueValues = (arr) => {
     return Array.from(new Set(arr));
 };
-export var _mergeArraysByKey = function (arr1, arr2, key) {
-    var map = new Map();
-    arr1.forEach(function (item) { return map.set(item[key], item); });
-    arr2.forEach(function (item) {
+export const _mergeArraysByKey = (arr1, arr2, key) => {
+    const map = new Map();
+    arr1.forEach((item) => map.set(item[key], item));
+    arr2.forEach((item) => {
         if (map.has(item[key])) {
-            map.set(item[key], __assign(__assign({}, map.get(item[key])), item));
+            map.set(item[key], Object.assign(Object.assign({}, map.get(item[key])), item));
         }
         else {
             map.set(item[key], item);
@@ -646,10 +494,10 @@ export var _mergeArraysByKey = function (arr1, arr2, key) {
     });
     return Array.from(map.values());
 };
-export var _removeDuplicates = function (arr, key) {
-    var seen = new Set();
-    return arr.filter(function (item) {
-        var value = item[key];
+export const _removeDuplicates = (arr, key) => {
+    const seen = new Set();
+    return arr.filter((item) => {
+        const value = item[key];
         if (!seen.has(value)) {
             seen.add(value);
             return true;
@@ -657,47 +505,44 @@ export var _removeDuplicates = function (arr, key) {
         return false;
     });
 };
-export var _groupBy = function (arr, key) {
-    return arr.reduce(function (result, currentValue) {
+export const _groupBy = (arr, key) => {
+    return arr.reduce((result, currentValue) => {
         (result[currentValue[key]] = result[currentValue[key]] || []).push(currentValue);
         return result;
     }, {});
 };
-export var _arrayDiff = function (arr1, arr2) {
-    return arr1.filter(function (item) { return !arr2.includes(item); });
+export const _arrayDiff = (arr1, arr2) => {
+    return arr1.filter(item => !arr2.includes(item));
 };
-export var _deepCompareArrays = function (arr1, arr2) {
+export const _deepCompareArrays = (arr1, arr2) => {
     if (arr1.length !== arr2.length)
         return false;
-    return arr1.every(function (item, index) { return _deepEqual(item, arr2[index]); });
+    return arr1.every((item, index) => _deepEqual(item, arr2[index]));
 };
-export var _updateObjectInArray = function (arr, key, value, update) {
-    return arr.map(function (item) {
-        return item[key] === value ? __assign(__assign({}, item), update) : item;
-    });
+export const _updateObjectInArray = (arr, key, value, update) => {
+    return arr.map((item) => item[key] === value ? Object.assign(Object.assign({}, item), update) : item);
 };
-export var _getKeyByValue = function (obj, value) {
+export const _getKeyByValue = (obj, value) => {
     var _a;
     if (!obj || typeof obj !== 'object')
         return null;
-    return (_a = Object.keys(obj).find(function (key) { return obj[key] === value; })) !== null && _a !== void 0 ? _a : null;
+    return (_a = Object.keys(obj).find(key => obj[key] === value)) !== null && _a !== void 0 ? _a : null;
 };
-export var _getValueByKey = function (obj, key) {
+export const _getValueByKey = (obj, key) => {
     var _a;
     if (!obj || typeof obj !== 'object')
         return '';
     return (_a = obj[key]) !== null && _a !== void 0 ? _a : '';
 };
-export var _getKeysByValue = function (obj, value) {
+export const _getKeysByValue = (obj, value) => {
     if (!obj || typeof obj !== 'object')
         return [];
-    return Object.keys(obj).filter(function (key) { return obj[key] === value; });
+    return Object.keys(obj).filter(key => obj[key] === value);
 };
-export var _dateFormat = function (date, format) {
-    if (format === void 0) { format = 'DD/MM/YYYY HH:mm:ss'; }
+export const _dateFormat = (date, format = 'DD/MM/YYYY HH:mm:ss') => {
     return moment(date).format(format);
 };
-export var _dateTransformer = function (data) {
+export const _dateTransformer = (data) => {
     if (data instanceof Date) {
         return _dateFormat(data, 'YYYY-MM-DDTHH:mm:ssZ');
     }
@@ -705,35 +550,31 @@ export var _dateTransformer = function (data) {
         return data.map(_dateTransformer);
     }
     if (typeof data === 'object' && data !== null) {
-        return Object.fromEntries(Object.entries(data).map(function (_a) {
-            var key = _a[0], value = _a[1];
-            return [key, _dateTransformer(value)];
-        }));
+        return Object.fromEntries(Object.entries(data).map(([key, value]) => [key, _dateTransformer(value)]));
     }
     return data;
 };
-export var _escapeRegExpMatch = function (s) {
+export const _escapeRegExpMatch = (s) => {
     return s.replace(/[-\\^$*+?.()|[\]{}]/g, '\\$&');
 };
-export var _isExactMatch = function (str, match) {
-    return new RegExp("\\b".concat(_escapeRegExpMatch(match), "\\b")).test(str);
+export const _isExactMatch = (str, match) => {
+    return new RegExp(`\\b${_escapeRegExpMatch(match)}\\b`).test(str);
 };
-export var _bytesToSize = function (bytes, decimals) {
-    if (decimals === void 0) { decimals = 2; }
+export const _bytesToSize = (bytes, decimals = 2) => {
     if (bytes === 0) {
         return '0 Bytes';
     }
-    var k = 1024;
-    var dm = decimals < 0 ? 0 : decimals;
-    var sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
-    var i = Math.floor(Math.log(bytes) / Math.log(k));
-    return "".concat(parseFloat((bytes / Math.pow(k, i)).toFixed(dm)), " ").concat(sizes[i]);
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
 };
-export var _swapArrayByKey = function (arr, key) {
-    for (var i = 0; i < arr.length; i++) {
-        for (var j = 0; j < arr.length - 1; j++) {
+export const _swapArrayByKey = (arr, key) => {
+    for (let i = 0; i < arr.length; i++) {
+        for (let j = 0; j < arr.length - 1; j++) {
             if (arr[j][key] < arr[j + 1][key]) {
-                var temp = arr[j];
+                const temp = arr[j];
                 arr[j] = arr[j + 1];
                 arr[j + 1] = temp;
             }
@@ -741,93 +582,68 @@ export var _swapArrayByKey = function (arr, key) {
     }
     return arr;
 };
-export var _setTouchedFields = function (formRef, errors) {
+export const _setTouchedFields = (formRef, errors) => {
     if ((formRef === null || formRef === void 0 ? void 0 : formRef.current) && errors) {
-        formRef.current.setTouched(Object.fromEntries(Object.keys(errors).map(function (key) { return [key, true]; })), true);
-    }
-};
-export var _isValidForm = function (formRef) { return __awaiter(void 0, void 0, void 0, function () {
-    var errors, isValid;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (!(formRef === null || formRef === void 0 ? void 0 : formRef.current))
-                    return [2 /*return*/, false];
-                return [4 /*yield*/, formRef.current.validateForm()];
-            case 1:
-                errors = _a.sent();
-                isValid = Object.keys(errors).length === 0;
-                if (!isValid) {
-                    formRef.current.setTouched(Object.fromEntries(Object.keys(errors).map(function (key) { return [key, true]; })), true);
-                }
-                return [2 /*return*/, isValid];
-        }
-    });
-}); };
-export var _isStepValid = function (formRef, fieldsToCheck) { return __awaiter(void 0, void 0, void 0, function () {
-    var touchedFields, errors, stepErrors;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (!(formRef === null || formRef === void 0 ? void 0 : formRef.current))
-                    return [2 /*return*/, false];
-                touchedFields = fieldsToCheck.reduce(function (acc, field) {
-                    acc[field] = true;
-                    return acc;
-                }, {});
-                return [4 /*yield*/, formRef.current.setTouched(touchedFields, true)];
-            case 1:
-                _a.sent();
-                return [4 /*yield*/, formRef.current.validateForm()];
-            case 2:
-                errors = _a.sent();
-                stepErrors = Object.keys(errors).filter(function (key) { return fieldsToCheck.includes(key); });
-                return [2 /*return*/, stepErrors.length === 0];
-        }
-    });
-}); };
-export var _validateFormRef = function (formRef) { return __awaiter(void 0, void 0, void 0, function () {
-    var errors, isValid;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (!(formRef && formRef.current)) return [3 /*break*/, 2];
-                return [4 /*yield*/, formRef.current.validateForm()];
-            case 1:
-                errors = _a.sent();
-                isValid = Object.keys(errors).length === 0;
-                return [2 /*return*/, { isValid: isValid, errors: isValid ? [] : errors }];
-            case 2: return [2 /*return*/, { isValid: false, errors: [] }];
-        }
-    });
-}); };
-export var _handleParentsMenu = function (currentArr, menuID) {
+        formRef.current.setTouched(Object.fromEntries(Object.keys(errors).map((key) => [key, true])), true);
+    }
+};
+export const _isValidForm = async (formRef) => {
+    if (!(formRef === null || formRef === void 0 ? void 0 : formRef.current))
+        return false;
+    const errors = await formRef.current.validateForm();
+    const isValid = Object.keys(errors).length === 0;
+    if (!isValid) {
+        formRef.current.setTouched(Object.fromEntries(Object.keys(errors).map((key) => [key, true])), true);
+    }
+    return isValid;
+};
+export const _isStepValid = async (formRef, fieldsToCheck) => {
+    if (!(formRef === null || formRef === void 0 ? void 0 : formRef.current))
+        return false;
+    const touchedFields = fieldsToCheck.reduce((acc, field) => {
+        acc[field] = true;
+        return acc;
+    }, {});
+    await formRef.current.setTouched(touchedFields, true);
+    const errors = await formRef.current.validateForm();
+    // Check only relevant fields
+    const stepErrors = Object.keys(errors).filter((key) => fieldsToCheck.includes(key));
+    return stepErrors.length === 0;
+};
+export const _validateFormRef = async (formRef) => {
+    if (formRef && formRef.current) {
+        const errors = await formRef.current.validateForm();
+        const isValid = Object.keys(errors).length === 0;
+        return { isValid, errors: isValid ? [] : errors };
+    }
+    return { isValid: false, errors: [] };
+};
+export const _handleParentsMenu = (currentArr, menuID) => {
     if (!menuID)
         return;
-    var parent = currentArr.find(function (item) { return item.data.menuID === menuID; });
+    const parent = currentArr.find((item) => item.data.menuID === menuID);
     if (!parent)
         return;
-    var anyChildChecked = currentArr.some(function (child) { return child.data.parentMenuID === parent.data.menuID && child.data.isAssigned; });
+    const anyChildChecked = currentArr.some((child) => child.data.parentMenuID === parent.data.menuID && child.data.isAssigned);
     if (parent.data.isAssigned !== anyChildChecked) {
         parent.data.isAssigned = anyChildChecked;
-        parent.data.permissions = Object.fromEntries(Object.keys(parent.data.permissions).map(function (key) { return [key, anyChildChecked]; }));
+        parent.data.permissions = Object.fromEntries(Object.keys(parent.data.permissions).map((key) => [key, anyChildChecked]));
         _handleParentsMenu(currentArr, parent.data.parentMenuID);
     }
 };
-export var _handleParentNode = function (currentArr, menuID, permissionKey) {
-    var _a;
+export const _handleParentNode = (currentArr, menuID, permissionKey) => {
     if (!menuID)
         return;
-    var parent = currentArr.find(function (item) { return item.data.menuID === menuID; });
+    const parent = currentArr.find((item) => item.data.menuID === menuID);
     if (!parent)
         return;
-    var childPermissions = currentArr
-        .filter(function (child) { return child.data.parentMenuID === parent.data.menuID; })
-        .flatMap(function (child) { return Object.values(child.data.permissions); });
-    var anyChildHasPermission = childPermissions.some(Boolean);
-    var anyChildHasSpecificPermission = currentArr.some(function (child) { return child.data.parentMenuID === parent.data.menuID && Boolean(child.data.permissions[permissionKey]); });
-    var updatedPermissions = __assign(__assign({}, parent.data.permissions), (_a = {}, _a[permissionKey] = anyChildHasSpecificPermission, _a));
-    var readPermissionKey = Object.keys(updatedPermissions).find(function (key) { return key.toLowerCase().includes('read'); });
+    const childPermissions = currentArr
+        .filter((child) => child.data.parentMenuID === parent.data.menuID)
+        .flatMap((child) => Object.values(child.data.permissions));
+    const anyChildHasPermission = childPermissions.some(Boolean);
+    const anyChildHasSpecificPermission = currentArr.some((child) => child.data.parentMenuID === parent.data.menuID && Boolean(child.data.permissions[permissionKey]));
+    let updatedPermissions = Object.assign(Object.assign({}, parent.data.permissions), { [permissionKey]: anyChildHasSpecificPermission });
+    const readPermissionKey = Object.keys(updatedPermissions).find((key) => key.toLowerCase().includes('read'));
     if (readPermissionKey) {
         updatedPermissions[readPermissionKey] = anyChildHasPermission;
     }
@@ -835,39 +651,32 @@ export var _handleParentNode = function (currentArr, menuID, permissionKey) {
     parent.data.isAssigned = anyChildHasPermission;
     _handleParentNode(currentArr, parent.data.parentMenuID, permissionKey);
 };
-export var _handleChildrenMenu = function (currentArr, parentKey, checked) {
-    currentArr.forEach(function (ele) {
+export const _handleChildrenMenu = (currentArr, parentKey, checked) => {
+    currentArr.forEach((ele) => {
         if (ele.data.parentMenuID === parentKey && ele.data.isAssigned !== checked) {
             ele.data.isAssigned = checked;
-            ele.data.permissions = Object.fromEntries(Object.keys(ele.data.permissions).map(function (key) { return [key, checked]; }));
+            ele.data.permissions = Object.fromEntries(Object.keys(ele.data.permissions).map((key) => [key, checked]));
             _handleChildrenMenu(currentArr, ele.data.menuID, checked);
         }
     });
 };
-export var _handlePermissions = function (currentArr, currentObj, permissionKey, isChecked) {
-    return currentArr.map(function (obj) {
-        var _a;
+export const _handlePermissions = (currentArr, currentObj, permissionKey, isChecked) => {
+    return currentArr.map((obj) => {
         if (obj.data.menuID === currentObj.data.menuID) {
-            var updatedPermissions = __assign(__assign({}, obj.data.permissions), (_a = {}, _a[permissionKey] = isChecked, _a));
-            var readPermissionKey_1 = Object.keys(updatedPermissions).find(function (key) { return key.toLowerCase().includes('read'); });
-            if (readPermissionKey_1) {
+            let updatedPermissions = Object.assign(Object.assign({}, obj.data.permissions), { [permissionKey]: isChecked });
+            const readPermissionKey = Object.keys(updatedPermissions).find((key) => key.toLowerCase().includes('read'));
+            if (readPermissionKey) {
                 if (isChecked) {
-                    updatedPermissions[readPermissionKey_1] = true;
+                    updatedPermissions[readPermissionKey] = true;
                 }
                 else {
-                    var otherPermissionsChecked = Object.entries(updatedPermissions)
-                        .filter(function (_a) {
-                        var key = _a[0];
-                        return key !== readPermissionKey_1;
-                    })
-                        .some(function (_a) {
-                        var value = _a[1];
-                        return value;
-                    });
-                    updatedPermissions[readPermissionKey_1] = otherPermissionsChecked;
+                    const otherPermissionsChecked = Object.entries(updatedPermissions)
+                        .filter(([key]) => key !== readPermissionKey)
+                        .some(([, value]) => value);
+                    updatedPermissions[readPermissionKey] = otherPermissionsChecked;
                 }
             }
-            return __assign(__assign({}, obj), { data: __assign(__assign({}, obj.data), { permissions: updatedPermissions, isAssigned: Object.values(updatedPermissions).some(Boolean) }) });
+            return Object.assign(Object.assign({}, obj), { data: Object.assign(Object.assign({}, obj.data), { permissions: updatedPermissions, isAssigned: Object.values(updatedPermissions).some(Boolean) }) });
         }
         return obj;
     });