boxwood 2.13.0 → 2.14.0

package/ui/prose/utilities/parseCustomTag.js

@@ -0,0 +1,218 @@
+/**
+ * Parse a custom component tag from markdown
+ * Supports both <Component attr="value"> and <Component attr={variable}>
+ * @param {string} line - The line to parse
+ * @param {Object} customComponents - Map of component names to functions
+ * @returns {Object|null} - Parsed tag info or null if not a custom tag
+ */
+function parseCustomTag(line, customComponents) {
+  if (!customComponents || typeof customComponents !== "object") {
+    return null
+  }
+
+  const trimmed = line.trim()
+
+  // Check for single-line tag: <tag>content</tag> or <tag attr="value">content</tag>
+  const singleLineMatch = trimmed.match(
+    /^<([A-Za-z][A-Za-z0-9-]*)(\s+[^>]*)?>(.+?)<\/\1>\s*$/,
+  )
+  if (singleLineMatch) {
+    const [, tagName, attributesStr, content] = singleLineMatch
+    const component = customComponents[tagName]
+    if (component) {
+      const attributes = parseAttributes(attributesStr || "")
+      return {
+        type: "custom-component-single-line",
+        tagName,
+        component,
+        attributes,
+        content,
+        selfClosing: false,
+      }
+    }
+  }
+
+  // Check for self-closing tag: <ComponentName ... /> (space before / is optional)
+  const selfClosingMatch = trimmed.match(
+    /^<([A-Za-z][A-Za-z0-9-]*)(\s+[^>]*)?\s*\/>\s*$/,
+  )
+  if (selfClosingMatch) {
+    const [, tagName, attributesStr] = selfClosingMatch
+    const component = customComponents[tagName]
+    if (component) {
+      const attributes = parseAttributes(attributesStr || "")
+      return {
+        type: "custom-component",
+        tagName,
+        component,
+        attributes,
+        selfClosing: true,
+      }
+    }
+  }
+
+  // Check for opening tag: <ComponentName ...>
+  const openTagMatch = trimmed.match(
+    /^<([A-Za-z][A-Za-z0-9-]*)(\s+[^>]*)?>\s*$/,
+  )
+  if (openTagMatch) {
+    const [, tagName, attributesStr] = openTagMatch
+    const component = customComponents[tagName]
+    if (component) {
+      const attributes = parseAttributes(attributesStr || "")
+      return {
+        type: "custom-component-open",
+        tagName,
+        component,
+        attributes,
+        selfClosing: false,
+      }
+    }
+  }
+
+  // Check for closing tag: </ComponentName>
+  const closeTagMatch = trimmed.match(/^<\/([A-Za-z][A-Za-z0-9-]*)>\s*$/)
+  if (closeTagMatch) {
+    const [, tagName] = closeTagMatch
+    const component = customComponents[tagName]
+    if (component) {
+      return {
+        type: "custom-component-close",
+        tagName,
+        component,
+      }
+    }
+  }
+
+  return null
+}
+
+/**
+ * Parse attributes from a tag string
+ * Supports: attr="value", attr='value', attr={variable}, attr
+ * @param {string} attributesStr - The attributes string
+ * @returns {Object} - Parsed attributes
+ */
+function parseAttributes(attributesStr) {
+  const attributes = {}
+  if (!attributesStr || !attributesStr.trim()) {
+    return attributes
+  }
+
+  const str = attributesStr.trim()
+  let i = 0
+
+  while (i < str.length) {
+    // Skip whitespace
+    while (i < str.length && /\s/.test(str[i])) {
+      i++
+    }
+
+    if (i >= str.length) break
+
+    // Parse attribute name
+    let nameStart = i
+    while (i < str.length && /[a-zA-Z0-9-_:]/.test(str[i])) {
+      i++
+    }
+
+    const name = str.substring(nameStart, i)
+    if (!name) break
+
+    // Skip whitespace after name
+    while (i < str.length && /\s/.test(str[i])) {
+      i++
+    }
+
+    // Check for =
+    if (i >= str.length || str[i] !== "=") {
+      // Boolean attribute
+      attributes[name] = true
+      continue
+    }
+
+    i++ // Skip =
+
+    // Skip whitespace after =
+    while (i < str.length && /\s/.test(str[i])) {
+      i++
+    }
+
+    if (i >= str.length) break
+
+    // Parse value
+    const quote = str[i]
+
+    if (quote === '"' || quote === "'") {
+      // Quoted string
+      i++ // Skip opening quote
+      let value = ""
+      while (i < str.length && str[i] !== quote) {
+        if (str[i] === "\\" && i + 1 < str.length) {
+          // Escaped character - add the next character literally
+          value += str[i + 1]
+          i += 2
+        } else {
+          value += str[i]
+          i++
+        }
+      }
+      attributes[name] = value
+      if (i < str.length) i++ // Skip closing quote
+    } else if (str[i] === "{") {
+      // Variable reference
+      i++ // Skip {
+      const valueStart = i
+      while (i < str.length && str[i] !== "}") {
+        i++
+      }
+      const variableName = str.substring(valueStart, i).trim()
+      attributes[name] = { __variable: variableName }
+      if (i < str.length) i++ // Skip }
+    } else {
+      // Unquoted value (until space or end)
+      const valueStart = i
+      while (i < str.length && !/\s/.test(str[i])) {
+        i++
+      }
+      const value = str.substring(valueStart, i)
+      attributes[name] = value
+    }
+  }
+
+  return attributes
+}
+
+/**
+ * Resolve attributes by replacing variable references with actual values
+ * @param {Object} attributes - Attributes with possible variable references
+ * @param {Object} data - Data object containing variable values
+ * @returns {Object} - Resolved attributes
+ */
+function resolveAttributes(attributes, data) {
+  if (!attributes || typeof attributes !== "object") {
+    return {}
+  }
+
+  const resolved = {}
+  for (const [key, value] of Object.entries(attributes)) {
+    if (value && typeof value === "object" && value.__variable) {
+      // Resolve variable
+      const variableName = value.__variable
+      resolved[key] =
+        data && data[variableName] !== undefined
+          ? data[variableName]
+          : undefined
+    } else {
+      resolved[key] = value
+    }
+  }
+
+  return resolved
+}
+
+module.exports = {
+  parseCustomTag,
+  parseAttributes,
+  resolveAttributes,
+}

package/ui/prose/utilities/processConditionals.js

@@ -0,0 +1,264 @@
+const { resolvePath } = require("./replaceVariables")
+
+/**
+ * Check if a value is truthy for conditional rendering
+ * @param {*} value - The value to check
+ * @returns {boolean} - Whether the value is truthy
+ */
+function isTruthy(value) {
+  // null and undefined are falsy
+  if (value === null || value === undefined) {
+    return false
+  }
+  // Empty string is falsy
+  if (value === "") {
+    return false
+  }
+  // 0 is falsy
+  if (value === 0) {
+    return false
+  }
+  // false is falsy
+  if (value === false) {
+    return false
+  }
+  // Empty array is falsy
+  if (Array.isArray(value) && value.length === 0) {
+    return false
+  }
+  // Everything else is truthy
+  return true
+}
+
+/**
+ * Evaluate a condition expression
+ * Supports: variable, variable > value, variable < value, etc.
+ * Also supports negation with ! prefix
+ * @param {string} condition - The condition to evaluate
+ * @param {Object} data - Data object with variable values
+ * @returns {boolean} - Whether the condition is true
+ */
+function evaluateCondition(condition, data) {
+  // Check for negation operator at the start
+  let negated = false
+  let conditionToEvaluate = condition.trim()
+
+  if (conditionToEvaluate.startsWith("!")) {
+    negated = true
+    conditionToEvaluate = conditionToEvaluate.substring(1).trim()
+  }
+
+  let result
+
+  // Check for comparison operators
+  const comparisonMatch = conditionToEvaluate.match(
+    /^(.+?)\s*(>=|<=|>|<|==|!=)\s*(.+)$/,
+  )
+
+  if (comparisonMatch) {
+    const [, leftExpr, operator, rightExpr] = comparisonMatch
+
+    // Resolve left side (variable or path)
+    const leftValue = resolvePath(data, leftExpr.trim())
+
+    // Resolve right side (could be a number, string, or variable)
+    let rightValue = rightExpr.trim()
+
+    // Try to parse as number
+    if (/^-?\d+(\.\d+)?$/.test(rightValue)) {
+      rightValue = parseFloat(rightValue)
+    }
+    // Try to parse as boolean
+    else if (rightValue === "true") {
+      rightValue = true
+    } else if (rightValue === "false") {
+      rightValue = false
+    }
+    // Try to parse as string literal (quoted)
+    else if (
+      (rightValue.startsWith('"') && rightValue.endsWith('"')) ||
+      (rightValue.startsWith("'") && rightValue.endsWith("'"))
+    ) {
+      rightValue = rightValue.slice(1, -1)
+    }
+    // Otherwise treat as a variable path
+    else {
+      rightValue = resolvePath(data, rightValue)
+    }
+
+    // Perform comparison
+    switch (operator) {
+      case ">":
+        result = leftValue > rightValue
+        break
+      case "<":
+        result = leftValue < rightValue
+        break
+      case ">=":
+        result = leftValue >= rightValue
+        break
+      case "<=":
+        result = leftValue <= rightValue
+        break
+      case "==":
+        result = leftValue == rightValue
+        break
+      case "!=":
+        result = leftValue != rightValue
+        break
+      default:
+        result = false
+    }
+  } else {
+    // No comparison operator, just evaluate truthiness
+    const value = resolvePath(data, conditionToEvaluate)
+    result = isTruthy(value)
+  }
+
+  // Apply negation if present
+  return negated ? !result : result
+}
+
+/**
+ * Process {#if condition}...{/if} blocks in text
+ * Supports {#elseif condition} and {#else} blocks
+ * Removes blocks where the condition is falsy
+ * @param {string} text - Text containing conditional blocks
+ * @param {Object} data - Data object with variable values
+ * @returns {string} - Text with conditionals processed
+ */
+function processConditionals(text, data) {
+  if (!text || typeof text !== "string") {
+    return text
+  }
+
+  // If no data, treat all conditions as falsy
+  if (!data || typeof data !== "object") {
+    // Remove all {#if}...{/if} blocks, but keep final {#else} content
+    let result = text
+    // Handle {#if}...{#elseif}...{#else}...{/if}
+    result = result.replace(
+      /\{#if\s+[^}]+\}[\s\S]*?(?:\{#elseif\s+[^}]+\}[\s\S]*?)*\{#else\}([\s\S]*?)\{\/if\}/g,
+      "$1",
+    )
+    // Handle blocks without {#else}
+    result = result.replace(/\{#if\s+[^}]+\}[\s\S]*?\{\/if\}/g, "")
+    return result
+  }
+
+  let result = text
+  let maxIterations = 100 // Prevent infinite loops
+  let iterations = 0
+
+  // Process all {#if} blocks (handles nested blocks by processing innermost first)
+  while (/{#if\s+[^}]+\}/.test(result) && iterations < maxIterations) {
+    iterations++
+
+    // Find the next {#if} block
+    const ifMatch = result.match(/\{#if\s+([^}]+)\}/)
+    if (!ifMatch) break
+
+    const fullIfTag = ifMatch[0]
+    const firstCondition = ifMatch[1].trim()
+    const ifStart = result.indexOf(fullIfTag)
+    const contentStart = ifStart + fullIfTag.length
+
+    // Find the matching {/if} and collect all {#elseif} and {#else} blocks
+    let depth = 1
+    let i = contentStart
+    let endIfStart = -1
+    const branches = []
+    let currentBranchStart = contentStart
+    let currentBranchCondition = firstCondition
+    let currentBranchType = "if"
+
+    while (i < result.length && depth > 0) {
+      if (result.substring(i, i + 4) === "{#if") {
+        depth++
+        i += 4
+      } else if (result.substring(i, i + 5) === "{/if}") {
+        depth--
+        if (depth === 0) {
+          // Save the last branch content
+          branches.push({
+            type: currentBranchType,
+            condition: currentBranchCondition,
+            content: result.substring(currentBranchStart, i),
+          })
+          endIfStart = i
+          break
+        }
+        i += 5
+      } else if (result.substring(i, i + 9) === "{#elseif " && depth === 1) {
+        // Found {#elseif} at the same depth level
+        // Save the current branch
+        branches.push({
+          type: currentBranchType,
+          condition: currentBranchCondition,
+          content: result.substring(currentBranchStart, i),
+        })
+
+        // Parse the new condition
+        const elseifMatch = result.substring(i).match(/^\{#elseif\s+([^}]+)\}/)
+        if (elseifMatch) {
+          const elseifTag = elseifMatch[0]
+          currentBranchCondition = elseifMatch[1].trim()
+          currentBranchType = "elseif"
+          currentBranchStart = i + elseifTag.length
+          i += elseifTag.length
+        } else {
+          i++
+        }
+      } else if (result.substring(i, i + 7) === "{#else}" && depth === 1) {
+        // Found {#else} at the same depth level
+        // Save the current branch
+        branches.push({
+          type: currentBranchType,
+          condition: currentBranchCondition,
+          content: result.substring(currentBranchStart, i),
+        })
+
+        // Start else branch
+        currentBranchType = "else"
+        currentBranchCondition = null
+        currentBranchStart = i + 7 // +7 for "{#else}"
+        i += 7
+      } else {
+        i++
+      }
+    }
+
+    // If no matching {/if} found, break to avoid issues
+    if (endIfStart === -1) {
+      break
+    }
+
+    const endIfEnd = endIfStart + 5 // length of "{/if}"
+
+    // Evaluate branches in order and pick the first one that matches
+    let selectedContent = ""
+    for (const branch of branches) {
+      if (branch.type === "else") {
+        // Else branch always matches if we get here
+        selectedContent = branch.content
+        break
+      } else if (branch.type === "if" || branch.type === "elseif") {
+        // Evaluate the condition
+        if (evaluateCondition(branch.condition, data)) {
+          selectedContent = branch.content
+          break
+        }
+      }
+    }
+
+    // Replace the entire {#if}...{/if} block with the selected content
+    result =
+      result.substring(0, ifStart) +
+      selectedContent +
+      result.substring(endIfEnd)
+  }
+
+  return result
+}
+
+module.exports = { processConditionals, isTruthy, evaluateCondition }

package/ui/prose/utilities/processLoops.js

@@ -0,0 +1,171 @@
+const { resolvePath } = require("./replaceVariables")
+const { processConditionals } = require("./processConditionals")
+
+/**
+ * Process {#each items}...{/each} blocks in text
+ * Repeats content for each item in an array
+ * Supports:
+ * - {#each items} - basic iteration, access current item with {item}
+ * - {#each items as item} - custom item variable name
+ * - {#each items as item, index} - access item and index
+ * @param {string} text - Text containing loop blocks
+ * @param {Object} data - Data object with variable values
+ * @returns {string} - Text with loops expanded
+ */
+function processLoops(text, data) {
+  if (!text || typeof text !== "string") {
+    return text
+  }
+
+  // If no data, remove all {#each}...{/each} blocks
+  if (!data || typeof data !== "object") {
+    return text.replace(/\{#each\s+[^}]+\}[\s\S]*?\{\/each\}/g, "")
+  }
+
+  let result = text
+  let maxIterations = 100 // Prevent infinite loops
+  let iterations = 0
+
+  // Process all {#each} blocks (handles nested blocks by processing innermost first)
+  while (/{#each\s+[^}]+\}/.test(result) && iterations < maxIterations) {
+    iterations++
+
+    // Find the next {#each} block
+    // Matches: {#each items}, {#each items as item}, {#each items as item, index}
+    const eachMatch = result.match(
+      /\{#each\s+([a-zA-Z0-9_.[\]]+)(?:\s+as\s+([a-zA-Z0-9_]+)(?:\s*,\s*([a-zA-Z0-9_]+))?)?\}/,
+    )
+    if (!eachMatch) break
+
+    const fullEachTag = eachMatch[0]
+    const arrayPath = eachMatch[1].trim()
+    const itemName = eachMatch[2] ? eachMatch[2].trim() : "item"
+    const indexName = eachMatch[3] ? eachMatch[3].trim() : null
+
+    const eachStart = result.indexOf(fullEachTag)
+    const contentStart = eachStart + fullEachTag.length
+
+    // Find the matching {/each}
+    let depth = 1
+    let i = contentStart
+    let endEachStart = -1
+
+    while (i < result.length && depth > 0) {
+      if (result.substring(i, i + 6) === "{#each") {
+        depth++
+        i += 6
+      } else if (result.substring(i, i + 7) === "{/each}") {
+        depth--
+        if (depth === 0) {
+          endEachStart = i
+          break
+        }
+        i += 7
+      } else {
+        i++
+      }
+    }
+
+    // If no matching {/each} found, break to avoid issues
+    if (endEachStart === -1) {
+      break
+    }
+
+    const blockContent = result.substring(contentStart, endEachStart)
+    const endEachEnd = endEachStart + 7 // length of "{/each}"
+
+    // Resolve the array
+    const array = resolvePath(data, arrayPath)
+
+    // Generate repeated content
+    let expandedContent = ""
+
+    if (Array.isArray(array) && array.length > 0) {
+      for (let idx = 0; idx < array.length; idx++) {
+        const item = array[idx]
+
+        // Create a new data context with the item and index
+        const loopData = { ...data }
+        loopData[itemName] = item
+
+        if (indexName) {
+          loopData[indexName] = idx
+        }
+
+        // First, process any conditionals within the loop content using the loop data
+        let itemContent = processConditionals(blockContent, loopData)
+
+        // Then replace variables in the block content
+        itemContent = replaceLoopVariables(itemContent, loopData)
+
+        expandedContent += itemContent
+      }
+    }
+    // If array is empty or not an array, remove the block
+
+    // Replace the entire {#each}...{/each} block
+    result =
+      result.substring(0, eachStart) +
+      expandedContent +
+      result.substring(endEachEnd)
+  }
+
+  return result
+}
+
+/**
+ * Replace variables in text with values from loop data
+ * @param {string} text - Text containing variable placeholders
+ * @param {Object} loopData - Data object with loop variables
+ * @returns {string} - Text with variables replaced
+ */
+function replaceLoopVariables(text, loopData) {
+  if (!text || typeof text !== "string") {
+    return text
+  }
+
+  let result = text
+  const regex = /\{([a-zA-Z0-9_.[\]]+)\}/g
+  let match
+
+  // Collect all variable matches first to avoid issues with overlapping replacements
+  const matches = []
+  while ((match = regex.exec(text)) !== null) {
+    matches.push({
+      fullMatch: match[0],
+      path: match[1],
+      index: match.index,
+    })
+  }
+
+  // Process matches in reverse order to maintain correct indices
+  for (let i = matches.length - 1; i >= 0; i--) {
+    const { fullMatch, path, index } = matches[i]
+
+    // Skip if it's a control structure tag
+    if (
+      path.startsWith("#") ||
+      path.startsWith("/") ||
+      fullMatch === "{#each}" ||
+      fullMatch === "{/each}" ||
+      fullMatch === "{#if}" ||
+      fullMatch === "{/if}"
+    ) {
+      continue
+    }
+
+    // Resolve the variable value
+    const value = resolvePath(loopData, path)
+
+    if (value !== undefined && value !== null) {
+      result =
+        result.substring(0, index) +
+        String(value) +
+        result.substring(index + fullMatch.length)
+    }
+  }
+
+  return result
+}
+
+module.exports = { processLoops }