@lobehub/ui 2.16.1 → 2.16.3

package/es/hooks/useMarkdown/latex.js

@@ -1,5 +1,53 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { renderToString } from 'katex';
 
+// ============================================================================
+// Utility Classes
+// ============================================================================
+
+/**
+ * PlaceholderManager - Manages temporary replacement and restoration of protected content
+ * Used to protect code blocks and LaTeX expressions during preprocessing
+ */
+var PlaceholderManager = /*#__PURE__*/function () {
+  function PlaceholderManager() {
+    var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'PROTECTED';
+    _classCallCheck(this, PlaceholderManager);
+    _defineProperty(this, "placeholders", []);
+    _defineProperty(this, "prefix", void 0);
+    this.prefix = prefix;
+  }
+  _createClass(PlaceholderManager, [{
+    key: "add",
+    value: function add(content) {
+      var index = this.placeholders.length;
+      this.placeholders.push(content);
+      return "<<".concat(this.prefix, "_").concat(index, ">>");
+    }
+  }, {
+    key: "restore",
+    value: function restore(text) {
+      var _this = this;
+      return text.replaceAll(new RegExp("<<".concat(this.prefix, "_(\\d+)>>"), 'g'), function (_, index) {
+        return _this.placeholders[Number.parseInt(index)] || '';
+      });
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.placeholders = [];
+    }
+  }]);
+  return PlaceholderManager;
+}(); // ============================================================================
+// Helper Functions
+// ============================================================================
 // Helper: replace unescaped pipes with \vert within a LaTeX math fragment
 var replaceUnescapedPipes = function replaceUnescapedPipes(formula) {
   return (
@@ -52,13 +100,30 @@ export function escapeLatexPipes(text) {
   // remark-gfm table parsing won't treat them as column separators.
   // Leave code blocks/inline code untouched.
   // Also ignore escaped dollars (\$) which are currency symbols
-  var pattern = /(```[\S\s]*?```|`[^\n`]*`)|\$\$([\S\s]*?)\$\$|(?<!\\)(?<!\$)\$(?!\$)([\S\s]*?)(?<!\\)(?<!\$)\$(?!\$)/g;
-  return text.replaceAll(pattern, function (match, code, display, inline) {
-    if (code !== undefined) return code; // preserve code fences/inline code
-    if (display !== undefined) return "$$".concat(replaceUnescapedPipes(display), "$$");
-    if (inline !== undefined) return "$".concat(replaceUnescapedPipes(inline), "$");
-    return match;
+
+  // Process code blocks first to protect them
+  var codeBlocks = [];
+  var content = text.replaceAll(/(```[\S\s]*?```|`[^\n`]*`)/g, function (match) {
+    codeBlocks.push(match);
+    return "<<CODE_".concat(codeBlocks.length - 1, ">>");
+  });
+
+  // For display math, allow multiline
+  content = content.replaceAll(/\$\$([\S\s]*?)\$\$/g, function (match, display) {
+    return "$$".concat(replaceUnescapedPipes(display), "$$");
+  });
+
+  // For inline math, use non-greedy match that DOES NOT cross newlines
+  // This prevents issues in tables where $ might appear in different cells
+  content = content.replaceAll(/(?<!\\)\$(?!\$)([^\n$]*?)(?<!\\)\$(?!\$)/g, function (match, inline) {
+    return "$".concat(replaceUnescapedPipes(inline), "$");
   });
+
+  // Restore code blocks
+  content = content.replaceAll(/<<CODE_(\d+)>>/g, function (_, index) {
+    return codeBlocks[Number.parseInt(index)];
+  });
+  return content;
 }
 
 /**
@@ -94,7 +159,7 @@ export function escapeTextUnderscores(text) {
  */
 export function escapeCurrencyDollars(text) {
   // Protect code blocks and existing LaTeX expressions from processing
-  var protectedStrings = [];
+  var manager = new PlaceholderManager('PROTECTED');
   var content = text.replaceAll(
   // Match patterns to protect (in order):
   // 1. Code blocks: ```...```
@@ -104,77 +169,26 @@ export function escapeCurrencyDollars(text) {
   // 5. LaTeX bracket notation: \[...\]
   // 6. LaTeX parenthesis notation: \(...\)
   /(```[\S\s]*?```|`[^\n`]*`|\$\$[\S\s]*?\$\$|(?<!\\)\$(?!\$)(?=[\S\s]*?\\)[\S\s]*?(?<!\\)\$(?!\$)|\\\[[\S\s]*?\\]|\\\(.*?\\\))/g, function (match) {
-    protectedStrings.push(match);
-    return "<<PROTECTED_".concat(protectedStrings.length - 1, ">>");
+    return manager.add(match);
   });
 
   // Escape dollar signs that are clearly currency:
   // - $ followed by a digit
   // - Not preceded by another $ (to avoid breaking $$)
+  // - Not followed immediately by another $ (to avoid breaking $1$ LaTeX)
   // - Followed by number patterns with optional commas, decimals, ranges, or plus signs
   // Match patterns like: $20, $1,000, $19.99, $20-50, $300+, $1,000-2,000+
+  // But NOT: $1$, $2$ (these are LaTeX formulas)
   // In the replacement: \\ = backslash, $$ = literal $, $1 = capture group 1
-  content = content.replaceAll(/(?<!\$)\$(\d{1,3}(?:,\d{3})*(?:\.\d+)?(?:-\d{1,3}(?:,\d{3})*(?:\.\d+)?)?\+?)/g, '\\$$$1');
+  content = content.replaceAll(/(?<!\$)\$(\d{1,3}(?:,\d{3})*(?:\.\d+)?(?:-\d{1,3}(?:,\d{3})*(?:\.\d+)?)?\+?)(?!\$)/g, '\\$$$1');
 
   // Restore protected content
-  content = content.replaceAll(/<<PROTECTED_(\d+)>>/g, function (_, index) {
-    return protectedStrings[Number.parseInt(index)];
-  });
+  content = manager.restore(content);
   return content;
 }
 
-/**
- * Preprocesses LaTeX content by performing multiple operations:
- * 1. Protects code blocks from processing
- * 2. Protects existing LaTeX expressions
- * 3. Escapes dollar signs that likely represent currency
- * 4. Converts LaTeX delimiters
- * 5. Escapes mhchem commands and pipes
- *
- * @param content The input string containing LaTeX expressions
- * @returns The processed string with proper LaTeX formatting
- */
-export function preprocessLaTeX(str) {
-  // Step 1: Protect code blocks
-  // const codeBlocks: string[] = [];
-  // let content = str.replaceAll(/(```[\S\s]*?```|`[^\n`]+`)/g, (match, code) => {
-  //   codeBlocks.push(code);
-  //   return `<<CODE_BLOCK_${codeBlocks.length - 1}>>`;
-  // });
-
-  // // Step 2: Protect existing LaTeX expressions
-  // const latexExpressions: string[] = [];
-  // content = content.replaceAll(/(\$\$[\S\s]*?\$\$|\\\[[\S\s]*?\\]|\\\(.*?\\\))/g, (match) => {
-  //   latexExpressions.push(match);
-  //   return `<<LATEX_${latexExpressions.length - 1}>>`;
-  // });
-
-  // Step 3: Escape dollar signs that are likely currency indicators
-  // Deprecated, as it causes parsing errors for formulas starting with a number, such as `$1$`
-  // content = content.replaceAll(/\$(?=\d)/g, '\\$');
-
-  // Step 4: Restore LaTeX expressions
-  // content = content.replaceAll(
-  //   /<<LATEX_(\d+)>>/g,
-  //   (_, index) => latexExpressions[Number.parseInt(index)],
-  // );
-
-  // // Step 5: Restore code blocks
-  // content = content.replaceAll(
-  //   /<<CODE_BLOCK_(\d+)>>/g,
-  //   (_, index) => codeBlocks[Number.parseInt(index)],
-  // );
-  var content = str;
-
-  // Step 6: Apply additional escaping functions
-  // Escape currency dollar signs FIRST before other LaTeX processing
-  content = escapeCurrencyDollars(content);
-  content = convertLatexDelimiters(content);
-  content = escapeMhchemCommands(content);
-  content = escapeLatexPipes(content);
-  content = escapeTextUnderscores(content);
-  return content;
-}
+// Old simple preprocessLaTeX has been replaced by the comprehensive version below
+// The new preprocessLaTeX provides the same default behavior with optional advanced featuresgit
 
 /**
  * Extracts the LaTeX formula after the last $$ delimiter if there's an odd number of $$ delimiters.
@@ -220,4 +234,294 @@ export var isLastFormulaRenderable = function isLastFormulaRenderable(text) {
     console.log("LaTeX formula rendering error: ".concat(error));
     return false;
   }
-};
+};
+
+// ============================================================================
+// Advanced Preprocessing Functions
+// ============================================================================
+
+/**
+ * Fixes common LaTeX syntax errors automatically
+ * - Balances unmatched braces
+ * - Balances \left and \right delimiters
+ *
+ * @param text The input string containing LaTeX expressions
+ * @returns The string with fixed LaTeX expressions
+ */
+export function fixCommonLaTeXErrors(text) {
+  return text.replaceAll(/(\$\$[\S\s]*?\$\$|\$[\S\s]*?\$)/g, function (match) {
+    var fixed = match;
+
+    // Fix unbalanced braces
+    var openBraces = (fixed.match(/(?<!\\){/g) || []).length;
+    var closeBraces = (fixed.match(/(?<!\\)}/g) || []).length;
+    if (openBraces > closeBraces) {
+      var diff = openBraces - closeBraces;
+      var closingBraces = '}'.repeat(diff);
+      // Insert before the closing delimiter
+      fixed = fixed.replace(/(\$\$?)$/, closingBraces + '$1');
+    }
+
+    // Fix unbalanced \left and \right
+    var leftDelims = (fixed.match(/\\left[(.<[{|]/g) || []).length;
+    var rightDelims = (fixed.match(/\\right[).>\]|}]/g) || []).length;
+    if (leftDelims > rightDelims) {
+      var _diff = leftDelims - rightDelims;
+      var rightDots = '\\right.'.repeat(_diff);
+      fixed = fixed.replace(/(\$\$?)$/, rightDots + '$1');
+    }
+    return fixed;
+  });
+}
+
+/**
+ * Normalizes whitespace in LaTeX expressions
+ * - Removes extra spaces around $ delimiters
+ * - Normalizes multiple spaces to single space inside formulas
+ *
+ * @param text The input string containing LaTeX expressions
+ * @returns The string with normalized whitespace
+ */
+export function normalizeLatexSpacing(text) {
+  var result = text;
+
+  // Remove spaces inside $ delimiters (at the edges)
+  result = result.replaceAll(/\$\s+/g, '$');
+  result = result.replaceAll(/\s+\$/g, '$');
+  result = result.replaceAll(/\$\$\s+/g, '$$');
+  result = result.replaceAll(/\s+\$\$/g, '$$');
+
+  // Normalize multiple spaces inside formulas to single space
+  result = result.replaceAll(/(\$\$[\S\s]*?\$\$|\$[\S\s]*?\$)/g, function (match) {
+    return match.replaceAll(/\s{2,}/g, ' ');
+  });
+  return result;
+}
+
+/**
+ * Validates all LaTeX expressions in the text
+ * Returns detailed information about validation results
+ *
+ * @param text The input string containing LaTeX expressions
+ * @returns Validation results with errors if any
+ */
+export function validateLatexExpressions(text) {
+  var errors = [];
+  var totalExpressions = 0;
+  var pattern = /\$\$([\S\s]*?)\$\$|(?<!\\)\$(?!\$)([\S\s]*?)(?<!\\)\$(?!\$)/g;
+  var match;
+  while ((match = pattern.exec(text)) !== null) {
+    totalExpressions++;
+    var formula = match[1] || match[2];
+    var isDisplay = match[0].startsWith('$$');
+    try {
+      renderToString(formula, {
+        displayMode: isDisplay,
+        strict: 'warn',
+        throwOnError: true,
+        trust: false
+      });
+    } catch (error) {
+      errors.push({
+        formula: formula.slice(0, 50) + (formula.length > 50 ? '...' : ''),
+        message: error instanceof Error ? error.message : String(error),
+        position: match.index,
+        type: isDisplay ? 'display' : 'inline'
+      });
+    }
+  }
+  return {
+    errors: errors,
+    totalExpressions: totalExpressions,
+    valid: errors.length === 0
+  };
+}
+
+/**
+ * Handles CJK (Chinese, Japanese, Korean) characters mixed with LaTeX
+ * Optionally adds spaces between CJK characters and LaTeX expressions for better rendering
+ *
+ * @param text The input string
+ * @param addSpaces Whether to add spaces between CJK and LaTeX (default: false)
+ * @returns The processed string
+ */
+export function handleCJKWithLatex(text) {
+  var addSpaces = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (!addSpaces) return text;
+  var result = text;
+
+  // Add space between CJK character and opening $
+  result = result.replaceAll(/([\u3040-\u30FF\u4E00-\u9FA5])(\$)/g, '$1 $2');
+
+  // Add space between closing $ and CJK character
+  result = result.replaceAll(/(\$)([\u3040-\u30FF\u4E00-\u9FA5])/g, '$1 $2');
+  return result;
+}
+
+// ============================================================================
+// Advanced Preprocessing Options
+// ============================================================================
+
+/**
+ * Comprehensive LaTeX preprocessing with configurable options
+ *
+ * This is the main preprocessing function that handles:
+ * - Currency symbol escaping (e.g., $20 → \$20)
+ * - LaTeX delimiter conversion (\[...\] → $$...$$)
+ * - Special character escaping (pipes, underscores, mhchem)
+ * - Optional error fixing and validation
+ * - Optional CJK character handling
+ *
+ * @param text The input string containing LaTeX and Markdown
+ * @param options Configuration options for fine-grained control
+ * @returns The preprocessed string
+ *
+ * @example
+ * ```ts
+ * // Default behavior (same as old preprocessLaTeX)
+ * preprocessLaTeX('向量$90^\\circ$，非 $0^\\circ$ 和 $180^\\circ$')
+ *
+ * // With custom options
+ * preprocessLaTeX(text, {
+ *   fixErrors: true,
+ *   validate: true,
+ *   handleCJK: true
+ * })
+ * ```
+ */
+export function preprocessLaTeX(text) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var _options$addCJKSpaces = options.addCJKSpaces,
+    addCJKSpaces = _options$addCJKSpaces === void 0 ? false : _options$addCJKSpaces,
+    _options$convertBrack = options.convertBrackets,
+    convertBrackets = _options$convertBrack === void 0 ? true : _options$convertBrack,
+    _options$escapeCurren = options.escapeCurrency,
+    escapeCurrency = _options$escapeCurren === void 0 ? true : _options$escapeCurren,
+    _options$escapeMhchem = options.escapeMhchem,
+    escapeMhchem = _options$escapeMhchem === void 0 ? true : _options$escapeMhchem,
+    _options$escapePipes = options.escapePipes,
+    escapePipes = _options$escapePipes === void 0 ? true : _options$escapePipes,
+    _options$escapeUnders = options.escapeUnderscores,
+    escapeUnderscores = _options$escapeUnders === void 0 ? true : _options$escapeUnders,
+    _options$fixErrors = options.fixErrors,
+    fixErrors = _options$fixErrors === void 0 ? false : _options$fixErrors,
+    _options$handleCJK = options.handleCJK,
+    handleCJK = _options$handleCJK === void 0 ? false : _options$handleCJK,
+    _options$normalizeSpa = options.normalizeSpacing,
+    normalizeSpacing = _options$normalizeSpa === void 0 ? false : _options$normalizeSpa,
+    _options$throwOnValid = options.throwOnValidationError,
+    throwOnValidationError = _options$throwOnValid === void 0 ? false : _options$throwOnValid,
+    _options$validate = options.validate,
+    validate = _options$validate === void 0 ? false : _options$validate;
+  var content = text;
+
+  // Phase 1: Currency escaping (if enabled)
+  if (escapeCurrency) {
+    content = escapeCurrencyDollars(content);
+  }
+
+  // Phase 2: Bracket conversion (if enabled)
+  if (convertBrackets) {
+    content = convertLatexDelimiters(content);
+  }
+
+  // Phase 3: LaTeX-specific escaping
+  if (escapeMhchem) {
+    content = escapeMhchemCommands(content);
+  }
+  if (escapePipes) {
+    content = escapeLatexPipes(content);
+  }
+  if (escapeUnderscores) {
+    content = escapeTextUnderscores(content);
+  }
+
+  // Phase 4: Error fixing (if enabled)
+  if (fixErrors) {
+    content = fixCommonLaTeXErrors(content);
+  }
+
+  // Phase 5: Whitespace normalization (if enabled)
+  if (normalizeSpacing) {
+    content = normalizeLatexSpacing(content);
+  }
+
+  // Phase 6: CJK handling (if enabled)
+  if (handleCJK) {
+    content = handleCJKWithLatex(content, addCJKSpaces);
+  }
+
+  // Phase 7: Validation (if enabled)
+  if (validate) {
+    var validation = validateLatexExpressions(content);
+    if (!validation.valid) {
+      var errorMessage = "LaTeX validation failed (".concat(validation.errors.length, "/").concat(validation.totalExpressions, " expressions have errors):\n").concat(validation.errors.map(function (e) {
+        return "  - [".concat(e.type, "] at position ").concat(e.position, ": ").concat(e.message, "\n    Formula: ").concat(e.formula);
+      }).join('\n'));
+      if (throwOnValidationError) {
+        throw new Error(errorMessage);
+      } else {
+        console.warn(errorMessage);
+      }
+    }
+  }
+  return content;
+}
+
+/**
+ * Strict preprocessing mode - enables all safety features and validations
+ * Use this when you want maximum correctness and are willing to accept the performance cost
+ *
+ * @param text The input string
+ * @returns The preprocessed string with all features enabled
+ *
+ * @example
+ * ```ts
+ * const processed = preprocessLaTeXStrict(userInput)
+ * // Enables: error fixing, validation, CJK handling, space normalization
+ * ```
+ */
+export function preprocessLaTeXStrict(text) {
+  return preprocessLaTeX(text, {
+    addCJKSpaces: false,
+    // Usually don't want extra spaces
+    convertBrackets: true,
+    escapeCurrency: true,
+    escapeMhchem: true,
+    escapePipes: true,
+    escapeUnderscores: true,
+    fixErrors: true,
+    handleCJK: true,
+    normalizeSpacing: true,
+    throwOnValidationError: false,
+    // Warn but don't throw
+    validate: true
+  });
+}
+
+/**
+ * Minimal preprocessing mode - only essential operations
+ * Use this for better performance when you control the input
+ *
+ * @param text The input string
+ * @returns The preprocessed string with minimal processing
+ *
+ * @example
+ * ```ts
+ * const processed = preprocessLaTeXMinimal(trustedInput)
+ * // Only escapes currency and converts brackets
+ * ```
+ */
+export function preprocessLaTeXMinimal(text) {
+  return preprocessLaTeX(text, {
+    convertBrackets: true,
+    escapeCurrency: true,
+    escapeMhchem: false,
+    escapePipes: false,
+    escapeUnderscores: false,
+    fixErrors: false,
+    handleCJK: false,
+    normalizeSpacing: false,
+    validate: false
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/ui",
-  "version": "2.16.1",
+  "version": "2.16.3",
   "description": "Lobe UI is an open-source UI component library for building AIGC web apps",
   "keywords": [
     "lobehub",