expensify-common 2.0.42 → 2.0.44

package/dist/CONST.d.ts

@@ -325,12 +325,6 @@ declare const CONST: {
          * @type String
          */
         readonly MARKDOWN_EMAIL: "(?=((?=[\\w'#%+-]+(?:\\.[\\w'#%+-]+)*@)[\\w\\.'#%+-]{1,64}@(?:(?=[a-z\\d]+(?:-+[a-z\\d]+)*\\.)(?:[a-z\\d-]{1,63}\\.)+[a-z]{2,63})(?= |_|\\b))(?<end>.*))\\S{3,254}(?=\\k<end>$)";
-        /**
-         * Regex matching an text containing an Emoji
-         *
-         * @type RegExp
-         */
-        readonly EMOJIS: RegExp;
         /**
          * Regex matching an text containing an Emoji that can be a single emoji or made up by some different emojis
          *

package/dist/CONST.js

@@ -333,13 +333,6 @@ const CONST = {
          * @type String
          */
         MARKDOWN_EMAIL: EMAIL_BASE_REGEX,
-        /**
-         * Regex matching an text containing an Emoji
-         *
-         * @type RegExp
-         */
-        // eslint-disable-next-line no-misleading-character-class
-        EMOJIS: /[\p{Extended_Pictographic}\u200d\u{1f1e6}-\u{1f1ff}\u{1f3fb}-\u{1f3ff}\u{e0020}-\u{e007f}\u20E3\uFE0F]|[#*0-9]\uFE0F?\u20E3/gu,
         /**
          * Regex matching an text containing an Emoji that can be a single emoji or made up by some different emojis
          *

package/dist/ExpensiMark.d.ts

@@ -29,6 +29,12 @@ type ReplaceOptions = {
     shouldEscapeText?: boolean;
     shouldKeepRawInput?: boolean;
 };
+type TruncateOptions = {
+    ellipsis?: string;
+    truncateLastWord?: boolean;
+    slop?: number;
+    removeImageTag?: boolean;
+};
 export default class ExpensiMark {
     static Log: Logger;
     /**
@@ -138,6 +144,27 @@ export default class ExpensiMark {
      * @returns original MD content escaped for use in HTML attribute value
      */
     escapeAttributeContent(content: string): string;
+    /**
+     * Determines the end position to truncate the HTML content while considering word boundaries.
+     *
+     * @param {string} content - The HTML content to be truncated.
+     * @param {number} tailPosition - The position up to which the content should be considered.
+     * @param {number} maxLength - The maximum length of the truncated content.
+     * @param {number} totalLength - The length of the content processed so far.
+     * @param {Object} opts - Options to customize the truncation.
+     * @returns {number} The calculated position to truncate the content.
+     */
+    getEndPosition(content: string, tailPosition: number | undefined, maxLength: number, totalLength: number, opts: TruncateOptions): number;
+    /**
+     * Truncate HTML string and keep tag safe.
+     * pulled from https://github.com/huang47/nodejs-html-truncate/blob/master/lib/truncate.js
+     *
+     * @param {string} html - The string that needs to be truncated
+     * @param {number} maxLength - Length of truncated string
+     * @param {Object} [options] - Optional configuration options
+     * @returns {string} The truncated string
+     */
+    truncateHTML(html: string, maxLength: number, options?: TruncateOptions): string;
     /**
      * Replaces text with a replacement based on a regex
      * @param text - The text to replace

package/dist/ExpensiMark.js

@@ -107,7 +107,7 @@ class ExpensiMark {
                     return this.modifyTextForEmailLinks(regex, textToProcess, replacement, shouldKeepRawInput);
                 },
                 replacement: (_extras, match, g1, g2) => {
-                    if (g1.match(Constants.CONST.REG_EXP.EMOJIS) || !g1.trim()) {
+                    if (!g1.trim()) {
                         return match;
                     }
                     const label = g1.trim();
@@ -116,7 +116,7 @@ class ExpensiMark {
                     return `<a href="${href}">${formattedLabel}</a>`;
                 },
                 rawInputReplacement: (_extras, match, g1, g2, g3) => {
-                    if (g1.match(Constants.CONST.REG_EXP.EMOJIS) || !g1.trim()) {
+                    if (!g1.trim()) {
                         return match;
                     }
                     const dataRawHref = g2 ? g2 + g3 : g3;
@@ -177,13 +177,13 @@ class ExpensiMark {
                 name: 'link',
                 process: (textToProcess, replacement) => this.modifyTextForUrlLinks(MARKDOWN_LINK_REGEX, textToProcess, replacement),
                 replacement: (_extras, match, g1, g2) => {
-                    if (g1.match(Constants.CONST.REG_EXP.EMOJIS) || !g1.trim()) {
+                    if (!g1.trim()) {
                         return match;
                     }
                     return `<a href="${str_1.default.sanitizeURL(g2)}" target="_blank" rel="noreferrer noopener">${g1.trim()}</a>`;
                 },
                 rawInputReplacement: (_extras, match, g1, g2) => {
-                    if (g1.match(Constants.CONST.REG_EXP.EMOJIS) || !g1.trim()) {
+                    if (!g1.trim()) {
                         return match;
                     }
                     return `<a href="${str_1.default.sanitizeURL(g2)}" data-raw-href="${g2}" data-link-variant="labeled" target="_blank" rel="noreferrer noopener">${g1.trim()}</a>`;
@@ -1093,6 +1093,172 @@ class ExpensiMark {
         originalContent = str_1.default.replaceAll(originalContent, '\n', '');
         return Utils.escape(originalContent);
     }
+    /**
+     * Determines the end position to truncate the HTML content while considering word boundaries.
+     *
+     * @param {string} content - The HTML content to be truncated.
+     * @param {number} tailPosition - The position up to which the content should be considered.
+     * @param {number} maxLength - The maximum length of the truncated content.
+     * @param {number} totalLength - The length of the content processed so far.
+     * @param {Object} opts - Options to customize the truncation.
+     * @returns {number} The calculated position to truncate the content.
+     */
+    getEndPosition(content, tailPosition, maxLength, totalLength, opts) {
+        const WORD_BREAK_REGEX = /\W+/g;
+        // Calculate the default position to truncate based on the maximum length and the length of the content processed so far
+        const defaultPosition = maxLength - totalLength;
+        // Define the slop value, which determines the tolerance for cutting off content near the maximum length
+        const slop = opts.slop;
+        if (!slop)
+            return defaultPosition;
+        // Initialize the position to the default position
+        let position = defaultPosition;
+        // Determine if the default position is considered "short" based on the slop value
+        const isShort = defaultPosition < slop;
+        // Calculate the position within the slop range
+        const slopPos = isShort ? defaultPosition : slop - 1;
+        // Extract the substring to analyze for word boundaries, considering the slop and tail position
+        const substr = content.slice(isShort ? 0 : defaultPosition - slop, tailPosition !== undefined ? tailPosition : defaultPosition + slop);
+        // Find the first word boundary within the substring
+        const wordBreakMatch = WORD_BREAK_REGEX.exec(substr);
+        // Adjust the position to avoid truncating in the middle of a word if the option is enabled
+        if (!opts.truncateLastWord) {
+            if (tailPosition && substr.length <= tailPosition) {
+                // If tail position is defined and the substring length is within the tail position, set position to the substring length
+                position = substr.length;
+            }
+            else {
+                // Iterate through word boundary matches to adjust the position
+                while (wordBreakMatch !== null) {
+                    if (wordBreakMatch.index < slopPos) {
+                        // If the word boundary is before the slop position, adjust position backward
+                        position = defaultPosition - (slopPos - wordBreakMatch.index);
+                        if (wordBreakMatch.index === 0 && defaultPosition <= 1) {
+                            break;
+                        }
+                    }
+                    else if (wordBreakMatch.index === slopPos) {
+                        // If the word boundary is at the slop position, set position to the default position
+                        position = defaultPosition;
+                        break;
+                    }
+                    else {
+                        // If the word boundary is after the slop position, adjust position forward
+                        position = defaultPosition + (wordBreakMatch.index - slopPos);
+                        break;
+                    }
+                }
+            }
+            // If the character at the determined position is a whitespace, adjust position backward
+            if (content.charAt(position - 1).match(/\s$/)) {
+                position--;
+            }
+        }
+        // Return the calculated position to truncate the content
+        return position;
+    }
+    /**
+     * Truncate HTML string and keep tag safe.
+     * pulled from https://github.com/huang47/nodejs-html-truncate/blob/master/lib/truncate.js
+     *
+     * @param {string} html - The string that needs to be truncated
+     * @param {number} maxLength - Length of truncated string
+     * @param {Object} [options] - Optional configuration options
+     * @returns {string} The truncated string
+     */
+    truncateHTML(html, maxLength, options) {
+        const EMPTY_STRING = '';
+        const DEFAULT_TRUNCATE_SYMBOL = '...';
+        const DEFAULT_SLOP = Math.min(10, maxLength);
+        const tagsStack = [];
+        const KEY_VALUE_REGEX = '((?:\\s+(?:\\w+|-)+(?:\\s*=\\s*(?:"(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\'|[^\'">\\s]+))?)*)';
+        const IS_CLOSE_REGEX = '\\s*\\/?\\s*';
+        const CLOSE_REGEX = '\\s*\\/\\s*';
+        const SELF_CLOSE_REGEX = new RegExp(`<\\/?(\\w+)${KEY_VALUE_REGEX}${CLOSE_REGEX}>`);
+        const HTML_TAG_REGEX = new RegExp(`<\\/?(\\w+)${KEY_VALUE_REGEX}${IS_CLOSE_REGEX}>`);
+        const URL_REGEX = /(((ftp|https?):\/\/)[\\-\w@:%_\\+.~#?,&\\/\\/=]+)|((mailto:)?[_.\w\\-]+@([\w][\w\\-]+\.)+[a-zA-Z]{2,3})/g;
+        const IMAGE_TAG_REGEX = new RegExp(`<img\\s*${KEY_VALUE_REGEX}${CLOSE_REGEX}>`);
+        let truncatedContent = EMPTY_STRING;
+        let totalLength = 0;
+        let matches = HTML_TAG_REGEX.exec(html);
+        let endResult;
+        let index;
+        let tag;
+        let selfClose = null;
+        let htmlString = html;
+        const opts = Object.assign({ ellipsis: DEFAULT_TRUNCATE_SYMBOL, truncateLastWord: true, slop: DEFAULT_SLOP }, options);
+        function removeImageTag(content) {
+            const match = IMAGE_TAG_REGEX.exec(content);
+            if (!match) {
+                return content;
+            }
+            const matchIndex = match.index;
+            const matchLength = match[0].length;
+            return content.substring(0, matchIndex) + content.substring(matchIndex + matchLength);
+        }
+        function closeTags(tags) {
+            return tags
+                .reverse()
+                .map((mappedTag) => {
+                return `</${mappedTag}>`;
+            })
+                .join('');
+        }
+        while (matches) {
+            matches = HTML_TAG_REGEX.exec(htmlString);
+            if (!matches) {
+                if (totalLength >= maxLength) {
+                    break;
+                }
+                matches = URL_REGEX.exec(htmlString);
+                if (!matches || matches.index >= maxLength) {
+                    truncatedContent += htmlString.substring(0, this.getEndPosition(htmlString, undefined, maxLength, totalLength, opts));
+                    break;
+                }
+                while (matches) {
+                    endResult = matches[0];
+                    if (endResult !== null) {
+                        index = matches.index;
+                        truncatedContent += htmlString.substring(0, index + endResult.length - totalLength);
+                        htmlString = htmlString.substring(index + endResult.length);
+                        matches = URL_REGEX.exec(htmlString);
+                    }
+                }
+                break;
+            }
+            endResult = matches[0];
+            index = matches.index;
+            if (totalLength + index > maxLength) {
+                truncatedContent += htmlString.substring(0, this.getEndPosition(htmlString, index, maxLength, totalLength, opts));
+                break;
+            }
+            else {
+                totalLength += index;
+                truncatedContent += htmlString.substring(0, index);
+            }
+            if (endResult[1] === '/') {
+                tagsStack.pop();
+                selfClose = null;
+            }
+            else {
+                selfClose = SELF_CLOSE_REGEX.exec(endResult);
+                if (!selfClose) {
+                    tag = matches[1];
+                    tagsStack.push(tag);
+                }
+            }
+            truncatedContent += selfClose ? selfClose[0] : endResult;
+            htmlString = htmlString.substring(index + endResult.length); // Update htmlString
+        }
+        if (htmlString.length > maxLength - totalLength && opts.ellipsis) {
+            truncatedContent += opts.ellipsis ? '...' : '';
+        }
+        truncatedContent += closeTags(tagsStack);
+        if (opts.removeImageTag) {
+            truncatedContent = removeImageTag(truncatedContent);
+        }
+        return truncatedContent;
+    }
     /**
      * Replaces text with a replacement based on a regex
      * @param text - The text to replace

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expensify-common",
-  "version": "2.0.42",
+  "version": "2.0.44",
   "author": "Expensify, Inc.",
   "description": "Expensify libraries and components shared across different repos",
   "homepage": "https://expensify.com",