coer-elements 2.0.17 → 2.0.19

package/fesm2022/coer-elements-tools.mjs

@@ -81,12 +81,6 @@ const Tools = {
             default: return '';
         }
     },
-    /** */
-    RemoveAccents: (value) => {
-        if (Tools.IsOnlyWhiteSpace(value))
-            return '';
-        return value.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
-    },
     /** Break reference of a object or array */
     BreakReference: (object) => {
         if (object === null)
@@ -102,14 +96,6 @@ const Tools = {
         const OBJECT = JSON.parse(JSON.stringify(object));
         return (Array.isArray(OBJECT) ? [...OBJECT] : { ...OBJECT });
     },
-    /** Clean extra whitespaces */
-    CleanUpBlanks: (text) => {
-        if (Tools.IsOnlyWhiteSpace(text))
-            return '';
-        let words = String(text).split(' ');
-        words = words.filter(x => x.length > 0);
-        return words.join(' ');
-    },
     /** Get properties of an object */
     GetPropertyList: (object) => {
         const properties = [];
@@ -137,32 +123,6 @@ const Tools = {
         }
         return Tools.BreakReference(array).map(item => Object.assign({ index: index++ }, item));
     },
-    /** Set First Char To Lower */
-    FirstCharToLower: (text) => {
-        if (Tools.IsOnlyWhiteSpace(text))
-            return '';
-        const textArray = [];
-        for (let i = 0; i < text.length; i++) {
-            if (i === 0)
-                textArray.push(text[i].toLowerCase());
-            else
-                textArray.push(text[i]);
-        }
-        return textArray.join('');
-    },
-    /** Set First Char To Upper */
-    FirstCharToUpper: (text) => {
-        if (Tools.IsOnlyWhiteSpace(text))
-            return '';
-        const textArray = [];
-        for (let i = 0; i < text.length; i++) {
-            if (i === 0)
-                textArray.push(text[i].toUpperCase());
-            else
-                textArray.push(text[i]);
-        }
-        return textArray.join('');
-    },
     /** Sort an array in ascending order by property */
     SortBy: (array, property, propertyType = 'string') => {
         switch (propertyType) {
@@ -291,12 +251,6 @@ const Tools = {
             new CoerAlert().Warning('Unable to copy to clipboard', 'Quick Implement', 'bi bi-clipboard-fill');
         }
     },
-    /** */
-    RemoveLastChar: (text) => {
-        return Tools.IsNotOnlyWhiteSpace(text)
-            ? text.trimEnd().substring(0, text.length - 1).trimEnd()
-            : '';
-    }
 };
 
 class Colors {
@@ -800,23 +754,23 @@ class DateTime {
     }
 }
 
-const ElementsHTML = {
+class ElementsHTML {
     /** */
-    GetElement: (selector) => {
+    static { this.GetElement = (selector) => {
         return document.querySelector(selector);
-    },
+    }; }
     /** */
-    GetCssValueBy: (selector, style) => {
+    static { this.GetCssValueBy = (selector, style) => {
         return ElementsHTML.GetCssValue(document.querySelector(selector), style);
-    },
+    }; }
     /** */
-    GetCssValue: (element, style) => {
+    static { this.GetCssValue = (element, style) => {
         return Tools.IsNotNull(element)
             ? window.getComputedStyle(element).getPropertyValue(style)
             : '';
-    },
+    }; }
     /** Get width in px */
-    GetElementWidth: (element, ...args) => {
+    static { this.GetElementWidth = (element, ...args) => {
         let width = 0;
         if (Tools.IsNotNull(element) && Tools.IsNotOnlyWhiteSpace(element?.offsetWidth)) {
             width += element.offsetWidth;
@@ -829,9 +783,9 @@ const ElementsHTML = {
             }
         }
         return `${width}px`;
-    },
+    }; }
     /** Get height in px */
-    GetElementHeight: (element, ...args) => {
+    static { this.GetElementHeight = (element, ...args) => {
         let height = 0;
         if (Tools.IsNotNull(element) && Tools.IsNotOnlyWhiteSpace(element?.offsetHeight)) {
             height += element.offsetHeight;
@@ -844,9 +798,9 @@ const ElementsHTML = {
             }
         }
         return `${height}px`;
-    },
+    }; }
     /** */
-    IsInvalidElement: (element) => {
+    static { this.IsInvalidElement = (element) => {
         let isInvalid = true;
         if (Tools.IsNotNull(element)) {
             if (typeof element == 'object') {
@@ -857,9 +811,9 @@ const ElementsHTML = {
             }
         }
         return isInvalid;
-    },
+    }; }
     /** Get color in hexadecimal format */
-    GetElementColor: (element) => {
+    static { this.GetElementColor = (element) => {
         if (Tools.IsNotNull(element)) {
             let rgb = window.getComputedStyle(element).getPropertyValue('color');
             rgb = rgb.replace('rgb(', '').replace(')', '');
@@ -871,8 +825,105 @@ const ElementsHTML = {
             return Colors.ToHexadecimal(red, green, blue, alpha);
         }
         return '';
+    }; }
+}
+;
+
+class StringTools {
+    /** Sets the first character to lowercase */
+    static FirstCharToLower(value) {
+        if (Tools.IsOnlyWhiteSpace(value))
+            return '';
+        const array = [];
+        for (let i = 0; i < String(value).length; i++) {
+            if (i === 0)
+                array.push(String(value)[i].toLowerCase());
+            else
+                array.push(String(value)[i]);
+        }
+        return array.join('');
     }
-};
+    /** Sets the first character to uppercase */
+    static FirstCharToUpper(value) {
+        if (Tools.IsOnlyWhiteSpace(value))
+            return '';
+        const array = [];
+        for (let i = 0; i < String(value).length; i++) {
+            if (i === 0)
+                array.push(String(value)[i].toUpperCase());
+            else
+                array.push(String(value)[i]);
+        }
+        return array.join('');
+    }
+    /** Clean extra whitespaces */
+    static CleanUpBlanks(value) {
+        return (Tools.IsNotOnlyWhiteSpace(value))
+            ? String(value).split(' ').filter(x => x.length > 0).join(' ')
+            : '';
+    }
+    /** Apply title formatting */
+    static ToTitle(value) {
+        return (Tools.IsNotOnlyWhiteSpace(value))
+            ? String(value).split(' ').filter(x => x.length > 0).map(x => StringTools.FirstCharToUpper(x.toLowerCase())).join(' ')
+            : '';
+    }
+    /** Removes the last character */
+    static RemoveLastChar(value) {
+        return Tools.IsNotOnlyWhiteSpace(value)
+            ? String(value).trimEnd().substring(0, String(value).length - 1).trimEnd()
+            : '';
+    }
+    /** Removes accents */
+    static RemoveAccents(value, except = []) {
+        if (Tools.IsOnlyWhiteSpace(value))
+            return '';
+        if (except.length > 0) {
+            let index = 0;
+            const mapValue = new Map();
+            for (const char of String(value)) {
+                mapValue.set(index++, char);
+            }
+            index = 0;
+            const mapNormalize = new Map();
+            for (const char of String(value).normalize('NFD').replace(/[\u0300-\u036f]/g, '')) {
+                mapNormalize.set(index++, char);
+            }
+            for (const char of except) {
+                for (const [index, value] of mapValue.entries()) {
+                    if (value === char) {
+                        mapNormalize.set(index, char);
+                    }
+                }
+            }
+            return Array.from(mapNormalize.values()).join('');
+        }
+        else {
+            return String(value).normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+        }
+    }
+    /** Removes special characters */
+    static OnlyAlphaNumeric(value) {
+        return (Tools.IsNotOnlyWhiteSpace(value))
+            ? String(value).replace(/[^a-zA-Z0-9áéíóúÁÉÍÓÚüÜñÑ\s]/g, '') : '';
+    }
+    /** Validates if both strings are equal */
+    static Equals(value, value2, sensitive = false) {
+        if (typeof value === null && typeof value2 === null)
+            return true;
+        if (typeof value === 'undefined' && typeof value2 === 'undefined')
+            return true;
+        if (typeof value === 'string' && typeof value2 === 'string') {
+            if (!sensitive) {
+                value = value.toUpperCase();
+                value2 = value2.toUpperCase();
+            }
+            return value.length === value2.length
+                && value === value2;
+        }
+        return false;
+    }
+}
 
 class Files {
     static { this.EXCEL_EXTENSIONS = ['xls', 'xlsx', 'csv']; }
@@ -914,7 +965,7 @@ class Files {
                     });
                     //Get Headers
                     for (const column in dataSheet[0]) {
-                        columns.push(Tools.FirstCharToLower(String(dataSheet[0][column]).replaceAll(' ', '')));
+                        columns.push(StringTools.FirstCharToLower(String(dataSheet[0][column]).replaceAll(' ', '')));
                     }
                     //Get Rows
                     rows = XLSX.utils.sheet_to_json(sheet, { header: columns });
@@ -932,8 +983,8 @@ class Files {
     }
     /** Export to excel file */
     static ExportExcel(data, fileName = 'coer_report', sheetName = 'Sheet1') {
-        sheetName = Tools.CleanUpBlanks(sheetName);
-        fileName = Tools.CleanUpBlanks(fileName);
+        sheetName = StringTools.CleanUpBlanks(sheetName);
+        fileName = StringTools.CleanUpBlanks(fileName);
         if (fileName.endsWith('.xls') || fileName.endsWith('.xlsx') || fileName.endsWith('.csv')) {
             if (fileName.endsWith('.xls')) {
                 fileName = fileName.replaceAll('.xls', '.xlsx');
@@ -2093,5 +2144,5 @@ class Service {
  * Generated bundle index. Do not edit.
  */
 
-export { Breadcrumbs, CONTROL_VALUE, CoerAlert, Colors, ControlValue, DateTime, ElementsHTML, Files, Filters, GridTemplates, Menu, Page, Screen, Section, Service, Source, Tools, User };
+export { Breadcrumbs, CONTROL_VALUE, CoerAlert, Colors, ControlValue, DateTime, ElementsHTML, Files, Filters, GridTemplates, Menu, Page, Screen, Section, Service, Source, StringTools, Tools, User };
 //# sourceMappingURL=coer-elements-tools.mjs.map