ExpensiMark: Add New Markdown Truncation Utility

lib/ExpensiMark.js

@@ -9,6 +9,42 @@
 
 const SLACK_SPAN_NEW_LINE_TAG = '<span class="c-mrkdwn__br" data-stringify-type="paragraph-break" style="box-sizing: inherit; display: block; height: unset;"></span>';
 
+const ASTERISK_ITALIC = '*';
+const UNDERSCORE_ITALIC = '_';
+const ASTERISK_BOLD = '**';
+const UNDERSCORE_BOLD = '__';
+const ESCAPED_UNDERSCORE = '\\_';
+const ESCAPED_ASTERISK = '\\*';
+const ASTERISK_PLACEHOLDER_REGEXP = /ASTERISKPLACEHOLDER/gm;
+const UNDERSCORE_PLACEHOLDER_REGEXP = /UNDERSCOREPLACEHOLDER/gm;
+const UNDERSCORE_BOLD_PLACEHOLDER_REGEXP = /UNDERSCOREBOLDPLACEHOLDER/gm;
+const ASTERISK_BOLD_PLACEHOLDER_REGEXP = /ASTERISKBOLDPLACEHOLDER/gm;
+const UNDERSCORE_ITALIC_PLACEHOLDER_REGEXP = /UNDERSCOREITALICPLACEHOLDER/gm;
+const ASTERISK_ITALIC_PLACEHOLDER_REGEXP = /ASTERISKITALICPLACEHOLDER/gm;
+
+
+const ESCAPED_ASTERISK_REGEXP = /\\\*/g;
+
+const ESCAPED_UNDERSCORE_REGEXP = /\\_/g;
+const UNDERSCORE_BOLD_REGEXP = /(__)(.*?)(__)/g;
+const ASTERISK_BOLD_REGEXP = /(\*\*)(.*?)(\*\*)/g;
+const UNDERSCORE_ITALIC_REGEXP = /(_)(.*?)(_)/g;
+const ASTERISK_ITALIC_REGEXP = /(\*)(.*?)(\*)/g;
+
+const HYPERLINK = /^\[([^[]+)\]\(([^)]+)\)/;
+
+const formatMarkers = [
+    ASTERISK_BOLD_PLACEHOLDER_REGEXP.source,
+    UNDERSCORE_BOLD_PLACEHOLDER_REGEXP.source,
+    ASTERISK_ITALIC_PLACEHOLDER_REGEXP.source,
+    UNDERSCORE_ITALIC_PLACEHOLDER_REGEXP.source,
+];
+
+const formatPlaceholdersMap = {
+    [UNDERSCORE_PLACEHOLDER_REGEXP.source]: ESCAPED_UNDERSCORE.length,
+    [ASTERISK_PLACEHOLDER_REGEXP.source]: ESCAPED_ASTERISK.length,
+};
+
 export default class ExpensiMark {
     constructor() {
         /**
@@ -160,7 +196,7 @@
              */
             {
                 name: 'hereMentions',
                 regex: /([a-zA-Z0-9.!$%&+/=?^`{|}_-]?)(@here)([.!$%&+/=?^`{|}_-]?)(?=\b)(?!([\w'#%+-]*@(?:[a-z\d-]+\.)+[a-z]{2,}(?:\s|$|@here))|((?:(?!<a).)+)?<\/a>|[^<]*(<\/pre>|<\/code>))/gm,
                 replacement: (match, g1, g2, g3) => {
                     if (!Str.isValidMention(match)) {
                         return match;
@@ -976,4 +1012,170 @@
 
         return text.replace(pattern, char => entities[char] || char);
     }
+
+    /**
+     * Find the format placeholder at the start of the given text, if any.
+     *
+     * @param {String} text
+     * @returns {String|null}
+     */
+    findFormatPlaceholderAhead(text) {
+        const formatPlaceholders = Object.keys(formatPlaceholdersMap);
+
+        for (let i = 0, l = formatPlaceholders.length; i < l; i++) {
+            if (text.startsWith(formatPlaceholders[i])) {
+                return formatPlaceholders[i];
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Find the format marker at the start of the given text, if any, and update the format stack accordingly.
+     *
+     * @param {String} text 
+     * @param {Array} formatStack
+     * @returns {String|null}
+     */
+    findFormatMarkerAhead(text, formatStack) {
+        for (let i = 0, l = formatMarkers.length; i < l; i++) {
+            if (text.startsWith(formatMarkers[i])) {
+                if (formatStack[formatStack.length - 1] === formatMarkers[i]) {
+                    formatStack.pop();
+                } else {
+                    formatStack.push(formatMarkers[i]);
+                }
+                return formatMarkers[i];
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Find the format marker at the start of the given text, if any, and update the format stack accordingly.
+     *
+     * @param {String} text 
+     * @param {Array} formatStack
+     * @returns {String|null}
+     */
+    replaceFormatMarkersWithPlaceholders(text) {
+        return text
+            .replace(
+                ESCAPED_UNDERSCORE_REGEXP,
+                UNDERSCORE_PLACEHOLDER_REGEXP.source
+            )
+            .replace(
+                ESCAPED_ASTERISK_REGEXP,
+                ASTERISK_PLACEHOLDER_REGEXP.source
+            )
+            .replace(
+                UNDERSCORE_BOLD_REGEXP,
+                `${UNDERSCORE_BOLD_PLACEHOLDER_REGEXP.source}$2${UNDERSCORE_BOLD_PLACEHOLDER_REGEXP.source}`
+            )
+            .replace(
+                ASTERISK_BOLD_REGEXP,
+                `${ASTERISK_BOLD_PLACEHOLDER_REGEXP.source}$2${ASTERISK_BOLD_PLACEHOLDER_REGEXP.source}`
+            )
+            .replace(
+                UNDERSCORE_ITALIC_REGEXP,
+                `${UNDERSCORE_ITALIC_PLACEHOLDER_REGEXP.source}$2${UNDERSCORE_ITALIC_PLACEHOLDER_REGEXP.source}`
+            )
+            .replace(
+                ASTERISK_ITALIC_REGEXP,
+                `${ASTERISK_ITALIC_PLACEHOLDER_REGEXP.source}$2${ASTERISK_ITALIC_PLACEHOLDER_REGEXP.source}`
+            );
+    }
+
+    /**
+     * Find the format marker at the start of the given text, if any, and update the format stack accordingly.
+     *
+     * @param {String} text 
+     * @param {Array} formatStack
+     * @returns {String|null}
+     */
+    replaceFormatPlaceholdersWithMarkers(text) {
+        return text
+            .replace(UNDERSCORE_PLACEHOLDER_REGEXP, ESCAPED_UNDERSCORE)
+            .replace(ASTERISK_PLACEHOLDER_REGEXP, ESCAPED_ASTERISK)
+            .replace(UNDERSCORE_BOLD_PLACEHOLDER_REGEXP, UNDERSCORE_BOLD)
+            .replace(ASTERISK_BOLD_PLACEHOLDER_REGEXP, ASTERISK_BOLD)
+            .replace(UNDERSCORE_ITALIC_PLACEHOLDER_REGEXP, UNDERSCORE_ITALIC)
+            .replace(ASTERISK_ITALIC_PLACEHOLDER_REGEXP, ASTERISK_ITALIC);
+    }
+
+    /**
+     * Truncate the given Markdown text to the specified character limit.
+     *
+     * @param {String} text
+     * @param {Number} limit
+     * @param {Boolean} ellipsis - Whether to add an ellipsis if the text is truncated
+     * @returns {String}
+     */
+    truncateMarkdown(text, limit, ellipsis) {
+        let count = 0;
+
+        const truncateString = (tempText) => {
+            const formatStack = [];
+            let shouldSkipCountIncrement = false;
+            let outputText = '';
+
+            for (let index = 0; count < limit && index < tempText.length; index++) {
+                const substring = tempText.substring(index);
+
+                const formatMarker = this.findFormatMarkerAhead(substring, formatStack);
+                if (formatMarker) {
+                    outputText += formatMarker;
+                    index += formatMarker.length - 1;
+                    shouldSkipCountIncrement = true;
+                    continue;
+                }
+
+                const formatPlaceholder = findFormatPlaceholderAhead(substring);
+                if (formatPlaceholder) {
+                    outputText += formatPlaceholder;
+                    index += formatPlaceholder.length - 1;
+                    shouldSkipCountIncrement = true;
+                    count += formatPlaceholdersMap[formatPlaceholder];
+                    continue;
+                }
+
+                const hyperlinkAheadRegexp = new RegExp(HYPERLINK);
+                const hyperlinkMatch = hyperlinkAheadRegexp.exec(substring);
+                if (hyperlinkMatch) {
+                    const hyperlinkText = hyperlinkMatch[1];
+                    const hyperlinkUrl = hyperlinkMatch[2];
+                    outputText += `[${truncateString(hyperlinkText)}](${hyperlinkUrl})`;
+                    index += hyperlinkMatch[0].length - 1;
+                    shouldSkipCountIncrement = true;
+                    continue;
+                }
+
+                outputText += tempText[index];
+
+                if (!shouldSkipCountIncrement) {
+                    count++;
+                }
+
+                shouldSkipCountIncrement = false;
+            }
+
+            outputText = outputText.trimEnd();
+
+            formatStack.forEach((marker) => {
+                outputText += marker;
+            });
+
+            return outputText;
+        };
+
+        let outputText = truncateString(text);
+
+        if (ellipsis && outputText.length < text.length) {
+            outputText += "...";
+        }
+
+        return outputText;
+    }
 }