@arsedizioni/ars-utils 20.0.34 → 20.0.36

package/core/index.d.ts

@@ -174,20 +174,20 @@ declare class SystemUtils {
      * @param b   : string b
      * @returns   : 0 if equals, 1 if bigger, -1 if lower
      */
-    static compareString(a: string, b: string): number;
+    static compareString(a?: string, b?: string): number;
     /**
      * Capitalize a string
      * @param s   : the string to capitalize
      * @returns   : the capitalized string
      */
-    static capitalize(s: string): string | undefined;
+    static capitalize(s?: string): string | undefined;
     /**
      * Truncate a string
      * @param s     : the string to truncate
      * @param max   : the max number of chars
      * @returns     : the truncated string
      */
-    static truncate(s: string, max?: number): string | undefined;
+    static truncate(s?: string, max?: number): string | undefined;
     /**
      * Join a list of strings
      * @param items     : the list of strings
@@ -195,26 +195,58 @@ declare class SystemUtils {
      * @param max       : the maximum resulting string
      * @returns         : the joined string
      */
-    static join(items: string[], sep?: string, max?: number): string | undefined;
+    static join(items?: string[], sep?: string, max?: number): string | undefined;
     /**
      * Replace stuff in text html
      * @param s   : the string to process
      * @returns   : the replaced string
      */
-    static replaceAsHtml(s: string): string;
+    static replaceAsHtml(s?: string): string;
     /**
-     * Convert a markdown string to html
-     * @param markdown : the markdown string
-     * @returns
+     * Convert markdown to html
+     * @param markdown : the markdown data
+     * @returns the html
      */
     static markdownToHtml(markdown: string): string;
+    /**
+     * Convert markdown table to html
+     * @param markdown: the markdown string
+     * @returns : the html
+     */
+    private static markdownConvertTables;
+    /**
+     * Convert a markdown table row to html
+     * @param row : the markdown row
+     * @param isHeader : true if is header
+     * @returns the html
+     */
+    private static markdownConvertTableRow;
+    /**
+     * Convert a markdown list to html
+     * @param markdown : the markdown list
+     * @returns the html
+     */
+    private static markdownConvertLists;
+    /**
+     * Wrap a list
+     * @param type: the list type
+     * @param items : the item list
+     * @returns the html
+     */
+    private static markdownWrapList;
+    /**
+     * Convert markdown paragraphs to html
+     * @param markdown : the markdown paragraphs
+     * @returns the html
+     */
+    private static markdownConvertParagraphs;
     /**
      * Compare two names
      * @param a   : name a
      * @param b   : name b
      * @returns   : true if a equals b
      */
-    static compareNames(a: string, b: string): boolean;
+    static compareNames(a?: string, b?: string): boolean;
     /**
      * Cipher a text
      * @param text    : the text
@@ -222,7 +254,7 @@ declare class SystemUtils {
      * @param reverse : true to decode, false to encode
      * @returns       :the ciphered text
      */
-    static cipher(text: string, key: string, reverse?: boolean): string;
+    static cipher(text: string, key: string, reverse?: boolean): string | undefined;
     /**
      * Clone an object using JSON
      * @param obj : the oblect to clone
@@ -240,13 +272,13 @@ declare class SystemUtils {
      * @param value   : the value to parse
      * @returns       : true if is a valid UUID
      */
-    static parseUUID(value: string): boolean;
+    static parseUUID(value?: string): boolean;
     /**
      * Parse and ensure that UUID is not empty
      * @param value   : the value to parse
      * @returns       : true if valid and not empty
      */
-    static parseUUIDNotEmpty(value: string): boolean;
+    static parseUUIDNotEmpty(value?: string): boolean;
     /**
      * Return an empty UUID
      * @returns : the empty UUID
@@ -262,26 +294,26 @@ declare class SystemUtils {
      * @param value : email
      * @returns     : true if the email is valid or empty
      */
-    static parseEmail(value: string): boolean;
+    static parseEmail(value?: string): boolean;
     /**
      * Parse a text and return true if is a valid url or null
      * @param value : the url to parse
      * @returns     : true if the url is valid or empty
      */
-    static parseUrl(value: string): boolean;
+    static parseUrl(value?: string): boolean;
     /**
      * Get date parts from a string value
      * @param value   : the string to parse
      * @returns       : an array of numbers with year, month, day
      */
-    static getDateParts(value: string): number[] | undefined;
+    static getDateParts(value?: string): number[] | undefined;
     /**
      * Parse a date
      * @param value   : the value to check
      * @param locale  : the locale to use
      * @returns       : a valid Date object or null
      */
-    static parseDate(value: string | Date, locale?: any): Date | undefined;
+    static parseDate(value?: string | Date, locale?: any): Date | undefined;
     /**
      * Format a date
      * @param value     : the date or string to format
@@ -289,13 +321,13 @@ declare class SystemUtils {
      * @param locale    : the locale to use (default is IT)
      * @returns         : the formatted string
      */
-    static formatDate(value: Date | string, fmt?: DateFormat | string, locale?: any): string;
+    static formatDate(value?: Date | string, fmt?: DateFormat | string, locale?: any): string;
     /**
      * Return an italian local date
      * @param value  : the date
      * @returns     : the new date
      */
-    static toLocalDate(value: Date | string): Date;
+    static toLocalDate(value?: Date | string): Date;
     /**
      * Update a DateInterval object according to a string
      * @param value       : string value
@@ -309,13 +341,13 @@ declare class SystemUtils {
      * @param value : the value to encode
      * @returns     : the url encoded string
      */
-    static urlEncode(value: string): string;
+    static urlEncode(value: string): string | undefined;
     /**
      * Decode url
      * @param value : the url to decode
      * @returns     : the decode url string
      */
-    static urlDecode(value: string): string;
+    static urlDecode(value?: string): string | undefined;
     /**
      * Get a querystring parameter value
      * @param name  : the parameter name
@@ -332,7 +364,7 @@ declare class SystemUtils {
      * @param password: the password to evaluate
      * @returns the password strength info
      */
-    static calculatePasswordStrength(password: string): PasswordStrength;
+    static calculatePasswordStrength(password?: string): PasswordStrength;
     /**
      * Check if current browser supports touch
      * @returns : true if the display is touchable

package/fesm2022/arsedizioni-ars-utils-core.mjs

@@ -307,6 +307,8 @@ class SystemUtils {
      * @returns   : the replaced string
      */
     static replaceAsHtml(s) {
+        if (!s)
+            return undefined;
         const regex = /https?:\/\/.*[^\s]/ig;
         const m = regex.exec(s);
         if (m && m.length > 0) {
@@ -319,87 +321,203 @@ class SystemUtils {
         return s;
     }
     /**
-     * Convert a markdown string to html
-     * @param markdown : the markdown string
-     * @returns
+     * Convert markdown to html
+     * @param markdown : the markdown data
+     * @returns the html
      */
     static markdownToHtml(markdown) {
         let html = markdown;
-        // Headers
+        //1. Escape HTML entities 
+        html = html.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+        // 2. Code blocks 
+        html = html.replace(/```(\w+)?\n([\s\S]*?)```/g, (_match, lang, code) => {
+            const langClass = lang ? ` class="language-${lang}"` : '';
+            return `<pre><code${langClass}>${code.trim()}</code></pre>`;
+        });
+        // 3. Inline code
+        html = html.replace(/`([^`]+)`/g, '<code>$1</code>');
+        // 4. Headers 
+        html = html.replace(/^##### (.*$)/gim, '<h5>$1</h5>');
+        html = html.replace(/^#### (.*$)/gim, '<h4>$1</h4>');
         html = html.replace(/^### (.*$)/gim, '<h3>$1</h3>');
         html = html.replace(/^## (.*$)/gim, '<h2>$1</h2>');
         html = html.replace(/^# (.*$)/gim, '<h1>$1</h1>');
-        // Bold
-        html = html.replace(/\*\*(.*)\*\*/gim, '<strong>$1</strong>');
-        html = html.replace(/__(.*?)__/gim, '<strong>$1</strong>');
-        // Italic
-        html = html.replace(/\*(.*?)\*/gim, '<em>$1</em>');
-        html = html.replace(/_(.*?)_/gim, '<em>$1</em>');
-        // Code blocks
-        html = html.replace(/```([\s\S]*?)```/gim, '<pre><code>$1</code></pre>');
-        // Inline code
-        html = html.replace(/`(.*?)`/gim, '<code>$1</code>');
-        // Links
-        html = html.replace(/\[([^\]]*)\]\(([^)]*)\)/gim, '<a href="$2">$1</a>');
-        // Images
-        html = html.replace(/!\[([^\]]*)\]\(([^)]*)\)/gim, '<img alt="$1" src="$2" />');
-        // Blockquotes
-        html = html.replace(/^\> (.*$)/gim, '<blockquote>$1</blockquote>');
-        // Unordered lists
-        html = html.replace(/^\* (.*$)/gim, '<li>$1</li>');
-        html = html.replace(/^- (.*$)/gim, '<li>$1</li>');
-        // Ordered lists
-        html = html.replace(/^\d+\. (.*$)/gim, '<li>$1</li>');
-        // Wrap list items in ul/ol tags
-        html = html.replace(/(<li>.*<\/li>)/gims, function (match) {
-            return '<ul>' + match + '</ul>';
-        });
-        // Tables
-        html = html.replace(/\|(.+)\|/g, function (_match, content) {
-            const cells = content.split('|').map((cell) => cell.trim());
-            return '<tr>' + cells.map((cell) => {
-                // Check if this is a header separator row
-                if (cell.match(/^[\s\-\:]+$/)) {
-                    return null;
+        // 5. Horizontal rules
+        html = html.replace(/^---+$/gim, '<hr>');
+        html = html.replace(/^\*\*\*+$/gim, '<hr>');
+        // 6. Links 
+        html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+        // 7. Images
+        html = html.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<img src="$2" alt="$1">');
+        // 8. Bold e Italic 
+        html = html.replace(/\*\*\*([^*]+)\*\*\*/gim, '<strong><em>$1</em></strong>');
+        html = html.replace(/___([^_]+)___/gim, '<strong><em>$1</em></strong>');
+        html = html.replace(/\*\*([^*]+)\*\*/gim, '<strong>$1</strong>');
+        html = html.replace(/__([^_]+)__/gim, '<strong>$1</strong>');
+        html = html.replace(/\*([^*]+)\*/gim, '<em>$1</em>');
+        html = html.replace(/_([^_]+)_/gim, '<em>$1</em>');
+        // 9. Strikethrough
+        html = html.replace(/~~([^~]+)~~/gim, '<del>$1</del>');
+        // 10. Blockquotes
+        html = html.replace(/^> (.*$)/gim, '<blockquote>$1</blockquote>');
+        // 11. Tables
+        html = this.markdownConvertTables(html);
+        // 12. Lists 
+        html = this.markdownConvertLists(html);
+        // 13. Line breaks
+        html = html.replace(/  $/gm, '<br>');
+        // 14. Paragrafi (ultimo step per non interferire con altri elementi)
+        html = this.markdownConvertParagraphs(html);
+        // 15. Clean up extra newlines
+        html = html.replace(/\n{3,}/g, '\n\n');
+        return html.trim();
+    }
+    /**
+     * Convert markdown table to html
+     * @param markdown: the markdown string
+     * @returns : the html
+     */
+    static markdownConvertTables(markdown) {
+        const lines = markdown.split('\n');
+        const result = [];
+        let inTable = false;
+        let tableRows = [];
+        let headerProcessed = false;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (line.includes('|') && line.length > 1) {
+                const nextLine = i + 1 < lines.length ? lines[i + 1].trim() : '';
+                const isHeaderSeparator = /^\|?[\s\-:|]+\|?$/.test(nextLine);
+                if (!inTable) {
+                    inTable = true;
+                    headerProcessed = false;
+                    tableRows = [];
+                }
+                if (isHeaderSeparator && !headerProcessed) {
+                    tableRows.push(this.markdownConvertTableRow(line, true));
+                    headerProcessed = true;
+                    i++;
+                }
+                else if (!isHeaderSeparator) {
+                    tableRows.push(this.markdownConvertTableRow(line, false));
                 }
-                return '<td>' + cell + '</td>';
-            }).filter((cell) => cell !== null).join('') + '</tr>';
-        });
-        // Convert table rows to proper table structure
-        html = html.replace(/(<tr>.*?<\/tr>)\s*\n*(<tr>.*?<\/tr>)/gs, function (match, firstRow, rest) {
-            // Check if the second row is a separator (contains only dashes, colons, spaces)
-            const secondRowContent = rest.replace(/<\/?t[rd]>/g, '');
-            if (secondRowContent.match(/^[\s\-\:\|]+$/)) {
-                // This is a header separator, make first row a header
-                const headerRow = firstRow.replace(/<td>/g, '<th>').replace(/<\/td>/g, '</th>');
-                return headerRow;
             }
-            return match;
-        });
-        // Wrap table rows in table tags
-        html = html.replace(/(<tr>.*?<\/tr>(?:\s*<tr>.*?<\/tr>)*)/gs, '<table>$1</table>');
-        // Horizontal rules
-        html = html.replace(/^\-\-\-$/gim, '<hr>');
-        html = html.replace(/^\*\*\*$/gim, '<hr>');
-        // Line breaks
-        html = html.replace(/\n\n/gim, '</p><p>');
-        html = html.replace(/\n/gim, '<br>');
-        // Wrap in paragraphs
-        html = '<p>' + html + '</p>';
-        // Clean up empty paragraphs
-        html = html.replace(/<p><\/p>/gim, '');
-        html = html.replace(/<p>(<h[1-6]>)/gim, '$1');
-        html = html.replace(/(<\/h[1-6]>)<\/p>/gim, '$1');
-        html = html.replace(/<p>(<ul>)/gim, '$1');
-        html = html.replace(/(<\/ul>)<\/p>/gim, '$1');
-        html = html.replace(/<p>(<blockquote>)/gim, '$1');
-        html = html.replace(/(<\/blockquote>)<\/p>/gim, '$1');
-        html = html.replace(/<p>(<pre>)/gim, '$1');
-        html = html.replace(/(<\/pre>)<\/p>/gim, '$1');
-        html = html.replace(/<p>(<table>)/gim, '$1');
-        html = html.replace(/(<\/table>)<\/p>/gim, '$1');
-        html = html.replace(/<p>(<hr>)<\/p>/gim, '$1');
-        return html;
+            else {
+                if (inTable && tableRows.length > 0) {
+                    result.push('<table>');
+                    result.push(...tableRows);
+                    result.push('</table>');
+                    tableRows = [];
+                    inTable = false;
+                }
+                result.push(line);
+            }
+        }
+        if (inTable && tableRows.length > 0) {
+            result.push('<table>');
+            result.push(...tableRows);
+            result.push('</table>');
+        }
+        return result.join('\n');
+    }
+    /**
+     * Convert a markdown table row to html
+     * @param row : the markdown row
+     * @param isHeader : true if is header
+     * @returns the html
+     */
+    static markdownConvertTableRow(row, isHeader) {
+        const cells = row.split('|').map(cell => cell.trim()).filter(cell => cell !== '');
+        const tag = isHeader ? 'th' : 'td';
+        const cellsHtml = cells.map(cell => `    <${tag}>${cell}</${tag}>`).join('\n');
+        return `  <tr>\n${cellsHtml}\n  </tr>`;
+    }
+    /**
+     * Convert a markdown list to html
+     * @param markdown : the markdown list
+     * @returns the html
+     */
+    static markdownConvertLists(markdown) {
+        markdown = markdown.replace(/^\* (.*$)/gim, '<li data-type="ul">$1</li>');
+        markdown = markdown.replace(/^- (.*$)/gim, '<li data-type="ul">$1</li>');
+        markdown = markdown.replace(/^\+ (.*$)/gim, '<li data-type="ul">$1</li>');
+        markdown = markdown.replace(/^\d+\. (.*$)/gim, '<li data-type="ol">$1</li>');
+        const lines = markdown.split('\n');
+        const result = [];
+        let currentList = { type: null, items: [] };
+        for (const line of lines) {
+            const ulMatch = line.match(/^<li data-type="ul">(.*)<\/li>$/);
+            const olMatch = line.match(/^<li data-type="ol">(.*)<\/li>$/);
+            if (ulMatch) {
+                if (currentList.type !== 'ul') {
+                    if (currentList.type && currentList.items.length > 0) {
+                        result.push(this.markdownWrapList(currentList.type, currentList.items));
+                    }
+                    currentList = { type: 'ul', items: [ulMatch[1]] };
+                }
+                else {
+                    currentList.items.push(ulMatch[1]);
+                }
+            }
+            else if (olMatch) {
+                if (currentList.type !== 'ol') {
+                    if (currentList.type && currentList.items.length > 0) {
+                        result.push(this.markdownWrapList(currentList.type, currentList.items));
+                    }
+                    currentList = { type: 'ol', items: [olMatch[1]] };
+                }
+                else {
+                    currentList.items.push(olMatch[1]);
+                }
+            }
+            else {
+                if (currentList.type && currentList.items.length > 0) {
+                    result.push(this.markdownWrapList(currentList.type, currentList.items));
+                    currentList = { type: null, items: [] };
+                }
+                result.push(line);
+            }
+        }
+        if (currentList.type && currentList.items.length > 0) {
+            result.push(this.markdownWrapList(currentList.type, currentList.items));
+        }
+        return result.join('\n');
+    }
+    /**
+     * Wrap a list
+     * @param type: the list type
+     * @param items : the item list
+     * @returns the html
+     */
+    static markdownWrapList(type, items) {
+        const listItems = items.map(item => `  <li>${item}</li>`).join('\n');
+        return `<${type}>\n${listItems}\n</${type}>`;
+    }
+    /**
+     * Convert markdown paragraphs to html
+     * @param markdown : the markdown paragraphs
+     * @returns the html
+     */
+    static markdownConvertParagraphs(markdown) {
+        const lines = markdown.split('\n');
+        const result = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                result.push('');
+                continue;
+            }
+            if (trimmed.startsWith('<') && trimmed.endsWith('>')) {
+                result.push(line);
+                continue;
+            }
+            if (trimmed.startsWith('<') || trimmed.endsWith('>')) {
+                result.push(line);
+                continue;
+            }
+            result.push(`<p>${trimmed}</p>`);
+        }
+        return result.join('\n');
     }
     /**
      * Compare two names
@@ -490,7 +608,7 @@ class SystemUtils {
      */
     static parseUUID(value) {
         const regex = /^({|()?[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}(}|))?$/;
-        return regex.test(value);
+        return value?.length > 0 && regex.test(value);
     }
     /**
      * Parse and ensure that UUID is not empty
@@ -699,7 +817,9 @@ class SystemUtils {
      * @returns     : the url encoded string
      */
     static urlEncode(value) {
-        return encodeURIComponent(value);
+        return value?.length > 0
+            ? encodeURIComponent(value)
+            : undefined;
     }
     /**
      * Decode url
@@ -708,7 +828,9 @@ class SystemUtils {
      */
     static urlDecode(value) {
         const regex = /\+/g;
-        return decodeURIComponent((value + "").replace(regex, "%20"));
+        return value?.length > 0
+            ? decodeURIComponent((value + "").replace(regex, "%20"))
+            : undefined;
     }
     /**
      * Get a querystring parameter value