fix(auto-close): improve performance & partial issues

Author: farnabaz

src/utils/auto-close.ts

@@ -3,6 +3,19 @@
  * Useful for streaming/incremental parsing where content may be partial
  */
 
+// Pre-compiled regex patterns for better performance
+const PATTERNS = {
+  trailingWhitespace: /\s+$/,
+  trailingAsterisks: /\*+$/,
+  asteriskGlobal: /\*/g,
+  doubleQuoteGlobal: /"/g,
+  singleQuoteGlobal: /'/g,
+  tildeGlobal: /~~/g,
+} as const
+
+// Pre-generated colon closers for common nesting depths (avoids repeat() calls)
+const COLON_CLOSERS = ['', ':', '::', ':::', '::::', ':::::', '::::::', ':::::::'] as const
+
 /**
  * Detects and auto-closes unclosed markdown inline syntax and MDC components
  *
@@ -21,13 +34,19 @@ export function autoCloseMarkdown(markdown: string): string {
     return markdown
   }
 
-  let result = markdown
+  // Split once and share between functions to avoid redundant splitting
+  const lines = markdown.split('\n')
+  const lastLine = lines[lines.length - 1]
 
   // Step 1: Auto-close inline markdown syntax
-  result = autoCloseInlineSyntax(result)
+  let result = autoCloseInlineSyntax(markdown, lastLine)
 
-  // Step 2: Auto-close MDC block components
-  result = autoCloseMDCComponents(result)
+  // Step 2: Auto-close MDC block components (only if content changed or has components)
+  if (result.includes('::')) {
+    // Re-split only if markdown was modified by inline closing
+    const updatedLines = result === markdown ? lines : result.split('\n')
+    result = autoCloseMDCComponents(result, updatedLines)
+  }
 
   return result
 }
@@ -36,13 +55,10 @@ export function autoCloseMarkdown(markdown: string): string {
  * Auto-closes unclosed inline markdown syntax (bold, italic, code, strikethrough)
  * Only closes markers that appear to be incomplete at the end of content
  */
-function autoCloseInlineSyntax(markdown: string): string {
+function autoCloseInlineSyntax(markdown: string, lastLine: string): string {
   // Track what needs closing by scanning from the end
   // This prevents closing markers that are intentionally left open in the middle
 
-  const lines = markdown.split('\n')
-  const lastLine = lines[lines.length - 1]
-
   // Define markers in order (bold+italic, then bold, then italic to avoid conflicts)
   const markers = [
     { marker: '***', pattern: /\*\*\*(?:[^*]|\*(?!\*\*)|\*\*(?!\*))*$/ }, // bold+italic (strong emphasis)
@@ -55,23 +71,82 @@ function autoCloseInlineSyntax(markdown: string): string {
   let closingSuffix = ''
   let trimTrailing = false
 
+  // Pre-compute values used multiple times
+  const hasTrailingWhitespace = PATTERNS.trailingWhitespace.test(lastLine)
+  const trimmedLastLine = hasTrailingWhitespace ? lastLine.trimEnd() : lastLine
+
   // Check each marker
   for (const { marker, pattern } of markers) {
     if (pattern.test(lastLine)) {
-      // Count occurrences in the last line
-      const escapedMarker = escapeRegex(marker)
-      const markerRegex = new RegExp(escapedMarker, 'g')
-      const count = (lastLine.match(markerRegex) || []).length
-
-      // If odd number of markers, we have an unclosed one
-      if (count % 2 === 1) {
-        // Check if content ends with whitespace before we close
-        // But preserve whitespace for inline code (spaces are significant in code)
-        if (marker !== '`' && /\s+$/.test(lastLine)) {
-          trimTrailing = true
+      const markerLen = marker.length
+      const markerChar = marker[0]
+
+      // For asterisk-based markers (*, **, ***), handle partial closings
+      if (markerChar === '*') {
+        // Check if line ends with asterisks (indicates partial closing)
+        const endsWithAsterisks = PATTERNS.trailingAsterisks.test(trimmedLastLine)
+
+        // Count total asterisks in the line (use pre-compiled regex)
+        const asteriskCount = (lastLine.match(PATTERNS.asteriskGlobal) || []).length
+
+        // Calculate remainder when dividing by (markerLen * 2)
+        // markerLen * 2 represents one complete open + close pair
+        const remainder = asteriskCount % (markerLen * 2)
+
+        // If remainder is 0, this marker is properly closed, skip it
+        if (remainder === 0) {
+          continue
+        }
+
+        // If remainder equals markerLen, we have exactly one opening marker
+        if (remainder === markerLen) {
+          // Check if line starts with more asterisks than this marker (e.g., *** when checking **)
+          // This prevents "***text***" from being seen as unclosed **
+          const startsWithMoreAsterisks = new RegExp('^\\*{' + (markerLen + 1) + ',}').test(lastLine)
+          if (startsWithMoreAsterisks) {
+            continue // This line uses a different (longer) marker
+          }
+
+          // Additional check: ensure line doesn't already have complete pairs and end with non-asterisk
+          // This prevents false positives like "**bold** and *italic*" being seen as unclosed **
+          const completePairPattern = new RegExp(escapeRegex(marker) + '[^*]+' + escapeRegex(marker))
+          const hasCompletePair = completePairPattern.test(lastLine)
+
+          if (hasCompletePair && !endsWithAsterisks) {
+            continue // Skip, this is a false match
+          }
+
+          if (hasTrailingWhitespace) {
+            trimTrailing = true
+          }
+          closingSuffix = marker
+          break
+        }
+        // If line ends with asterisks AND remainder shows partial closing
+        else if (endsWithAsterisks && remainder > markerLen && remainder < markerLen * 2) {
+          const needed = (markerLen * 2) - remainder
+          if (hasTrailingWhitespace) {
+            trimTrailing = true
+          }
+          closingSuffix = '*'.repeat(needed)
+          break
+        }
+      }
+      // For non-asterisk markers, use the original logic
+      else {
+        // Use pre-compiled regex for strikethrough
+        const count = marker === '~~'
+          ? (lastLine.match(PATTERNS.tildeGlobal) || []).length
+          : (lastLine.match(new RegExp(escapeRegex(marker), 'g')) || []).length
+
+        if (count % 2 === 1) {
+          // Preserve whitespace for inline code (spaces are significant in code)
+          if (marker !== '`' && hasTrailingWhitespace) {
+            trimTrailing = true
+          }
+          closingSuffix = marker
+          break
         }
-        closingSuffix += marker
-        break // Only close the first unclosed marker
       }
     }
   }
@@ -89,9 +164,8 @@ function autoCloseInlineSyntax(markdown: string): string {
  * Handles nested components by tracking the marker depth (::, :::, ::::, etc.)
  * Also closes incomplete props {...}
  */
-function autoCloseMDCComponents(markdown: string): string {
+function autoCloseMDCComponents(markdown: string, lines: string[]): string {
   let result = markdown
-  const lines = result.split('\n')
 
   // Check for incomplete props on the last line
   const lastLine = lines[lines.length - 1]
@@ -101,9 +175,9 @@ function autoCloseMDCComponents(markdown: string): string {
     if (openBraceMatch) {
       const propsContent = openBraceMatch[0].substring(1) // Remove the opening {
 
-      // Check if there's an unclosed quote within the props
-      const doubleQuotes = (propsContent.match(/"/g) || []).length
-      const singleQuotes = (propsContent.match(/'/g) || []).length
+      // Single-pass quote counting using pre-compiled patterns
+      const doubleQuotes = (propsContent.match(PATTERNS.doubleQuoteGlobal) || []).length
+      const singleQuotes = (propsContent.match(PATTERNS.singleQuoteGlobal) || []).length
 
       let closing = ''
 
@@ -170,14 +244,18 @@ function autoCloseMDCComponents(markdown: string): string {
   }
 
   // Add closing markers for any unclosed components (in reverse order)
-  let closingSuffix = ''
+  // Use array join pattern for better performance with multiple closers
+  const closers: string[] = []
   while (unclosedStack.length > 0) {
     const component = unclosedStack.pop()!
-    const closer = ':'.repeat(component.markerCount)
-    closingSuffix += `\n${closer}`
+    // Use pre-generated closers for common depths, fallback to repeat() for deep nesting
+    const closer = component.markerCount < COLON_CLOSERS.length
+      ? COLON_CLOSERS[component.markerCount]
+      : ':'.repeat(component.markerCount)
+    closers.push(closer)
   }
 
-  return result + closingSuffix
+  return closers.length > 0 ? result + '\n' + closers.join('\n') : result
 }
 
 /**

test/auto-close.test.ts

@@ -127,21 +127,48 @@ describe('autoCloseMarkdown - MDC Components', () => {
     const expected = '*italic*'
     expect(autoCloseMarkdown(input)).toBe(expected)
   })
+
   it('should ignore trailing space in bold', () => {
     const input = '**bold '
     const expected = '**bold**'
     expect(autoCloseMarkdown(input)).toBe(expected)
   })
+
   it('should ignore trailing space in strikethrough', () => {
     const input = '~~strikethrough '
     const expected = '~~strikethrough~~'
     expect(autoCloseMarkdown(input)).toBe(expected)
   })
+
   it('should ignore trailing space in code', () => {
     const input = '`code '
     const expected = '`code `'
     expect(autoCloseMarkdown(input)).toBe(expected)
   })
+
+  it('***italic and bold', () => {
+    const input = '***italic and bold'
+    const expected = '***italic and bold***'
+    expect(autoCloseMarkdown(input)).toBe(expected)
+  })
+
+  it('***italic and bold partial', () => {
+    const input = '***italic and bold*'
+    const expected = '***italic and bold***'
+    expect(autoCloseMarkdown(input)).toBe(expected)
+  })
+
+  it('***italic and bold partial 2', () => {
+    const input = '***italic and bold**'
+    const expected = '***italic and bold***'
+    expect(autoCloseMarkdown(input)).toBe(expected)
+  })
+
+  it('**bold partial', () => {
+    const input = '**bold*'
+    const expected = '**bold**'
+    expect(autoCloseMarkdown(input)).toBe(expected)
+  })
 })
 
 describe('autoCloseMarkdown - Combined Scenarios', () => {