@chat-js/cli 0.6.1 → 0.6.3

package/templates/chat-app/components/ai-elements/parseIncompleteMarkdown.tsx

@@ -4,141 +4,141 @@
  * of links, images, bold, and italic formatting during streaming.
  */
 export function parseIncompleteMarkdown(text: string): string {
-  if (!text || typeof text !== "string") {
-    return text;
-  }
+	if (!text || typeof text !== "string") {
+		return text;
+	}
 
-  let result = text;
+	let result = text;
 
-  // Handle incomplete links and images
-  // Pattern: [...] or ![...] where the closing ] is missing
-  const linkImagePattern = /(!?\[)([^\]]*?)$/;
-  const linkMatch = result.match(linkImagePattern);
-  if (linkMatch) {
-    // If we have an unterminated [ or ![, remove it and everything after
-    const startIndex = result.lastIndexOf(linkMatch[1]);
-    result = result.substring(0, startIndex);
-  }
+	// Handle incomplete links and images
+	// Pattern: [...] or ![...] where the closing ] is missing
+	const linkImagePattern = /(!?\[)([^\]]*?)$/;
+	const linkMatch = result.match(linkImagePattern);
+	if (linkMatch) {
+		// If we have an unterminated [ or ![, remove it and everything after
+		const startIndex = result.lastIndexOf(linkMatch[1]);
+		result = result.substring(0, startIndex);
+	}
 
-  // Handle incomplete bold formatting (**)
-  const boldPattern = /(\*\*)([^*]*?)$/;
-  const boldMatch = result.match(boldPattern);
-  if (boldMatch) {
-    // Count the number of ** in the entire string
-    const asteriskPairs = (result.match(/\*\*/g) || []).length;
-    // If odd number of **, we have an incomplete bold - complete it
-    if (asteriskPairs % 2 === 1) {
-      result = `${result}**`;
-    }
-  }
+	// Handle incomplete bold formatting (**)
+	const boldPattern = /(\*\*)([^*]*?)$/;
+	const boldMatch = result.match(boldPattern);
+	if (boldMatch) {
+		// Count the number of ** in the entire string
+		const asteriskPairs = (result.match(/\*\*/g) || []).length;
+		// If odd number of **, we have an incomplete bold - complete it
+		if (asteriskPairs % 2 === 1) {
+			result = `${result}**`;
+		}
+	}
 
-  // Handle incomplete italic formatting (__)
-  const italicPattern = /(__)([^_]*?)$/;
-  const italicMatch = result.match(italicPattern);
-  if (italicMatch) {
-    // Count the number of __ in the entire string
-    const underscorePairs = (result.match(/__/g) || []).length;
-    // If odd number of __, we have an incomplete italic - complete it
-    if (underscorePairs % 2 === 1) {
-      result = `${result}__`;
-    }
-  }
+	// Handle incomplete italic formatting (__)
+	const italicPattern = /(__)([^_]*?)$/;
+	const italicMatch = result.match(italicPattern);
+	if (italicMatch) {
+		// Count the number of __ in the entire string
+		const underscorePairs = (result.match(/__/g) || []).length;
+		// If odd number of __, we have an incomplete italic - complete it
+		if (underscorePairs % 2 === 1) {
+			result = `${result}__`;
+		}
+	}
 
-  // Handle incomplete single asterisk italic (*)
-  const singleAsteriskPattern = /(\*)([^*]*?)$/;
-  const singleAsteriskMatch = result.match(singleAsteriskPattern);
-  if (singleAsteriskMatch) {
-    // Count single asterisks that aren't part of **
-    const singleAsterisks = result.split("").reduce((acc, char, index) => {
-      if (char === "*") {
-        // Check if it's part of a ** pair
-        const prevChar = result[index - 1];
-        const nextChar = result[index + 1];
-        if (prevChar !== "*" && nextChar !== "*") {
-          return acc + 1;
-        }
-      }
-      return acc;
-    }, 0);
+	// Handle incomplete single asterisk italic (*)
+	const singleAsteriskPattern = /(\*)([^*]*?)$/;
+	const singleAsteriskMatch = result.match(singleAsteriskPattern);
+	if (singleAsteriskMatch) {
+		// Count single asterisks that aren't part of **
+		const singleAsterisks = result.split("").reduce((acc, char, index) => {
+			if (char === "*") {
+				// Check if it's part of a ** pair
+				const prevChar = result[index - 1];
+				const nextChar = result[index + 1];
+				if (prevChar !== "*" && nextChar !== "*") {
+					return acc + 1;
+				}
+			}
+			return acc;
+		}, 0);
 
-    // If odd number of single *, we have an incomplete italic - complete it
-    if (singleAsterisks % 2 === 1) {
-      result = `${result}*`;
-    }
-  }
+		// If odd number of single *, we have an incomplete italic - complete it
+		if (singleAsterisks % 2 === 1) {
+			result = `${result}*`;
+		}
+	}
 
-  // Handle incomplete single underscore italic (_)
-  const singleUnderscorePattern = /(_)([^_]*?)$/;
-  const singleUnderscoreMatch = result.match(singleUnderscorePattern);
-  if (singleUnderscoreMatch) {
-    // Count single underscores that aren't part of __
-    const singleUnderscores = result.split("").reduce((acc, char, index) => {
-      if (char === "_") {
-        // Check if it's part of a __ pair
-        const prevChar = result[index - 1];
-        const nextChar = result[index + 1];
-        if (prevChar !== "_" && nextChar !== "_") {
-          return acc + 1;
-        }
-      }
-      return acc;
-    }, 0);
+	// Handle incomplete single underscore italic (_)
+	const singleUnderscorePattern = /(_)([^_]*?)$/;
+	const singleUnderscoreMatch = result.match(singleUnderscorePattern);
+	if (singleUnderscoreMatch) {
+		// Count single underscores that aren't part of __
+		const singleUnderscores = result.split("").reduce((acc, char, index) => {
+			if (char === "_") {
+				// Check if it's part of a __ pair
+				const prevChar = result[index - 1];
+				const nextChar = result[index + 1];
+				if (prevChar !== "_" && nextChar !== "_") {
+					return acc + 1;
+				}
+			}
+			return acc;
+		}, 0);
 
-    // If odd number of single _, we have an incomplete italic - complete it
-    if (singleUnderscores % 2 === 1) {
-      result = `${result}_`;
-    }
-  }
+		// If odd number of single _, we have an incomplete italic - complete it
+		if (singleUnderscores % 2 === 1) {
+			result = `${result}_`;
+		}
+	}
 
-  // Handle incomplete inline code blocks (`) - but avoid code blocks (```)
-  const inlineCodePattern = /(`)([^`]*?)$/;
-  const inlineCodeMatch = result.match(inlineCodePattern);
-  if (inlineCodeMatch) {
-    // Check if we're dealing with a code block (triple backticks)
-    const _hasCodeBlockStart = result.includes("```");
-    const codeBlockPattern = /```[\s\S]*?```/g;
-    const _completeCodeBlocks = (result.match(codeBlockPattern) || []).length;
-    const allTripleBackticks = (result.match(/```/g) || []).length;
+	// Handle incomplete inline code blocks (`) - but avoid code blocks (```)
+	const inlineCodePattern = /(`)([^`]*?)$/;
+	const inlineCodeMatch = result.match(inlineCodePattern);
+	if (inlineCodeMatch) {
+		// Check if we're dealing with a code block (triple backticks)
+		const _hasCodeBlockStart = result.includes("```");
+		const codeBlockPattern = /```[\s\S]*?```/g;
+		const _completeCodeBlocks = (result.match(codeBlockPattern) || []).length;
+		const allTripleBackticks = (result.match(/```/g) || []).length;
 
-    // If we have an odd number of ``` sequences, we're inside an incomplete code block
-    // In this case, don't complete inline code
-    const insideIncompleteCodeBlock = allTripleBackticks % 2 === 1;
+		// If we have an odd number of ``` sequences, we're inside an incomplete code block
+		// In this case, don't complete inline code
+		const insideIncompleteCodeBlock = allTripleBackticks % 2 === 1;
 
-    if (!insideIncompleteCodeBlock) {
-      // Count the number of single backticks that are NOT part of triple backticks
-      let singleBacktickCount = 0;
-      for (let i = 0; i < result.length; i++) {
-        if (result[i] === "`") {
-          // Check if this backtick is part of a triple backtick sequence
-          const isTripleStart = result.substring(i, i + 3) === "```";
-          const isTripleMiddle =
-            i > 0 && result.substring(i - 1, i + 2) === "```";
-          const isTripleEnd = i > 1 && result.substring(i - 2, i + 1) === "```";
+		if (!insideIncompleteCodeBlock) {
+			// Count the number of single backticks that are NOT part of triple backticks
+			let singleBacktickCount = 0;
+			for (let i = 0; i < result.length; i++) {
+				if (result[i] === "`") {
+					// Check if this backtick is part of a triple backtick sequence
+					const isTripleStart = result.substring(i, i + 3) === "```";
+					const isTripleMiddle =
+						i > 0 && result.substring(i - 1, i + 2) === "```";
+					const isTripleEnd = i > 1 && result.substring(i - 2, i + 1) === "```";
 
-          if (!(isTripleStart || isTripleMiddle || isTripleEnd)) {
-            singleBacktickCount++;
-          }
-        }
-      }
+					if (!(isTripleStart || isTripleMiddle || isTripleEnd)) {
+						singleBacktickCount++;
+					}
+				}
+			}
 
-      // If odd number of single backticks, we have an incomplete inline code - complete it
-      if (singleBacktickCount % 2 === 1) {
-        result = `${result}\``;
-      }
-    }
-  }
+			// If odd number of single backticks, we have an incomplete inline code - complete it
+			if (singleBacktickCount % 2 === 1) {
+				result = `${result}\``;
+			}
+		}
+	}
 
-  // Handle incomplete strikethrough formatting (~~)
-  const strikethroughPattern = /(~~)([^~]*?)$/;
-  const strikethroughMatch = result.match(strikethroughPattern);
-  if (strikethroughMatch) {
-    // Count the number of ~~ in the entire string
-    const tildePairs = (result.match(/~~/g) || []).length;
-    // If odd number of ~~, we have an incomplete strikethrough - complete it
-    if (tildePairs % 2 === 1) {
-      result = `${result}~~`;
-    }
-  }
+	// Handle incomplete strikethrough formatting (~~)
+	const strikethroughPattern = /(~~)([^~]*?)$/;
+	const strikethroughMatch = result.match(strikethroughPattern);
+	if (strikethroughMatch) {
+		// Count the number of ~~ in the entire string
+		const tildePairs = (result.match(/~~/g) || []).length;
+		// If odd number of ~~, we have an incomplete strikethrough - complete it
+		if (tildePairs % 2 === 1) {
+			result = `${result}~~`;
+		}
+	}
 
-  return result;
+	return result;
 }