boxwood 2.16.0 → 2.18.0

package/ui/markdown/utilities/replaceVariables.js

@@ -1,115 +0,0 @@
-/**
- * Resolve a path like "images[0].src" or "user.name" from a data object
- * @param {Object} data - The data object to resolve the path from
- * @param {string} path - The path to resolve (e.g., "images[0].src", "user.name")
- * @returns {*} - The resolved value or undefined
- */
-function resolvePath(data, path) {
-  // Handle simple variable names (backwards compatibility)
-  if (!/[.\[]/.test(path)) {
-    return data[path]
-  }
-
-  // Split the path into parts, handling both dot notation and bracket notation
-  // e.g., "images[0].src" -> ["images", "0", "src"]
-  const parts = path
-    .replace(/\[(\d+)\]/g, ".$1") // Convert [0] to .0
-    .split(".")
-    .filter(Boolean)
-
-  let current = data
-  for (const part of parts) {
-    if (current === null || current === undefined) {
-      return undefined
-    }
-    current = current[part]
-  }
-
-  return current
-}
-
-/**
- * Replace {variableName} placeholders in text with actual values from data
- * Supports:
- * - Simple variables: {name}
- * - Array indexing: {images[0]}
- * - Property access: {user.name}
- * - Combined: {images[0].src}
- * @param {string} text - Text containing variable placeholders
- * @param {Object} data - Data object with variable values
- * @returns {string|Array} - Text with variables replaced, or array if mixed content
- */
-function replaceVariables(text, data) {
-  if (!text || typeof text !== "string") {
-    return text
-  }
-
-  if (!data || typeof data !== "object") {
-    return text
-  }
-
-  // Check if text contains any variables
-  if (!text.includes("{") || !text.includes("}")) {
-    return text
-  }
-
-  const result = []
-  let i = 0
-  let lastIndex = 0
-
-  while (i < text.length) {
-    if (text[i] === "\\" && text[i + 1] === "{") {
-      // Escaped opening brace
-      result.push(text.substring(lastIndex, i))
-      result.push("{")
-      i += 2
-      lastIndex = i
-      continue
-    }
-
-    if (text[i] === "{") {
-      const closeIndex = text.indexOf("}", i + 1)
-
-      if (closeIndex !== -1) {
-        // Found a variable placeholder
-        const variablePath = text.substring(i + 1, closeIndex).trim()
-
-        if (variablePath) {
-          // Add text before the variable
-          if (i > lastIndex) {
-            result.push(text.substring(lastIndex, i))
-          }
-
-          // Resolve the variable value (supports paths like "images[0].src")
-          const value = resolvePath(data, variablePath)
-          if (value !== undefined && value !== null) {
-            result.push(String(value))
-          } else {
-            // Variable not found, keep the placeholder
-            result.push(text.substring(i, closeIndex + 1))
-          }
-
-          i = closeIndex + 1
-          lastIndex = i
-          continue
-        }
-      }
-    }
-
-    i++
-  }
-
-  // Add remaining text
-  if (lastIndex < text.length) {
-    result.push(text.substring(lastIndex))
-  }
-
-  // If no substitutions were made, return original text
-  if (result.length === 0) {
-    return text
-  }
-
-  return result.join("")
-}
-
-module.exports = { replaceVariables }

package/ui/prose/utilities/brackets.js

@@ -1,21 +0,0 @@
-// Find the matching closing bracket, accounting for nested brackets
-function findMatchingBracket(text, startPos) {
-  let depth = 1
-  let i = startPos + 1
-
-  while (i < text.length && depth > 0) {
-    if (text[i] === "[" && text[i - 1] !== "\\") {
-      depth++
-    } else if (text[i] === "]" && text[i - 1] !== "\\") {
-      depth--
-      if (depth === 0) {
-        return i
-      }
-    }
-    i++
-  }
-
-  return -1
-}
-
-module.exports = { findMatchingBracket }

package/ui/prose/utilities/convertNodes.js

@@ -1,193 +0,0 @@
-const { resolveAttributes } = require("./parseCustomTag")
-const { replaceVariables } = require("./replaceVariables")
-const { format } = require("./format")
-
-/**
- * Recursively parses nested lists with proper indentation handling
- */
-function parseList(
-  items,
-  startIndex,
-  parentIndent,
-  htmlParams,
-  data,
-  allComponents,
-) {
-  const list = []
-  let currentIndex = startIndex
-  const parentListType = items[startIndex].list
-
-  while (currentIndex < items.length) {
-    const item = items[currentIndex]
-
-    // Stop conditions
-    if (item.type !== "li" || item.indent < parentIndent) {
-      break
-    }
-
-    if (item.indent === parentIndent && item.list !== parentListType) {
-      break
-    }
-
-    if (item.indent > parentIndent) {
-      break
-    }
-
-    // Process current list item
-    const processedContent = replaceVariables(item.content, data)
-    const content = [format(processedContent, allComponents)]
-    currentIndex++
-
-    // Check for nested lists
-    const nextItem = items[currentIndex]
-    if (nextItem?.type === "li" && nextItem.indent > item.indent) {
-      const nestedResult = parseList(
-        items,
-        currentIndex,
-        nextItem.indent,
-        htmlParams,
-        data,
-        allComponents,
-      )
-      content.push(nestedResult.list)
-      currentIndex = nestedResult.nextIndex
-    }
-
-    list.push(allComponents.li(htmlParams, content))
-  }
-
-  const listElement =
-    parentListType === "ul"
-      ? allComponents.ul(htmlParams, list)
-      : allComponents.ol(htmlParams, list)
-
-  return { list: listElement, nextIndex: currentIndex }
-}
-
-/**
- * Processes a custom component item into a node
- */
-function processCustomComponentItem(item, params, data, markdownRenderer) {
-  const resolvedAttrs = resolveAttributes(item.attributes, data)
-
-  if (item.selfClosing) {
-    return item.component(resolvedAttrs)
-  }
-
-  if (item.singleLine) {
-    return item.component(resolvedAttrs, item.content)
-  }
-
-  // Multi-line component with children - recursively process markdown
-  const childContent = item.content
-    ? markdownRenderer(params, item.content)
-    : []
-  return item.component(resolvedAttrs, childContent)
-}
-
-/**
- * Processes blockquote items into a single blockquote node
- */
-function processBlockquotes(
-  items,
-  startIndex,
-  htmlParams,
-  data,
-  allComponents,
-) {
-  const lines = []
-  let i = startIndex
-
-  while (i < items.length && items[i].type === "blockquote") {
-    lines.push(items[i].content)
-    i++
-  }
-
-  const content = replaceVariables(lines.join("\n"), data)
-  const blockquote = allComponents.blockquote(
-    htmlParams,
-    allComponents.p(htmlParams, format(content, allComponents)),
-  )
-
-  return { node: blockquote, nextIndex: i }
-}
-
-/**
- * Converts parsed items into final node tree
- */
-function convertItemsToNodes(
-  items,
-  params,
-  htmlParams,
-  data,
-  allComponents,
-  markdownRenderer,
-) {
-  const result = []
-  let i = 0
-
-  while (i < items.length) {
-    const item = items[i]
-
-    if (item.type === "custom-component") {
-      result.push(
-        processCustomComponentItem(item, params, data, markdownRenderer),
-      )
-      i++
-    } else if (item.type === "li") {
-      const listResult = parseList(
-        items,
-        i,
-        item.indent,
-        htmlParams,
-        data,
-        allComponents,
-      )
-      result.push(listResult.list)
-      i = listResult.nextIndex
-    } else if (item.type === "blockquote") {
-      const { node, nextIndex } = processBlockquotes(
-        items,
-        i,
-        htmlParams,
-        data,
-        allComponents,
-      )
-      result.push(node)
-      i = nextIndex
-    } else if (item.type === "hr") {
-      result.push(allComponents.hr(htmlParams))
-      i++
-    } else if (item.type === "pre") {
-      // Code blocks - wrap in <pre><code>
-      const codeParams = item.language
-        ? { class: `language-${item.language}` }
-        : {}
-      result.push(
-        allComponents.pre(
-          htmlParams,
-          allComponents.code(codeParams, item.content),
-        ),
-      )
-      i++
-    } else {
-      // Regular block elements (h1-h6, p, etc.)
-      const { type, content } = item
-      const Component = allComponents[type] || allComponents.p
-      const processedContent = replaceVariables(content, data)
-      result.push(
-        Component(htmlParams, format(processedContent, allComponents)),
-      )
-      i++
-    }
-  }
-
-  return result
-}
-
-module.exports = {
-  parseList,
-  processCustomComponentItem,
-  processBlockquotes,
-  convertItemsToNodes,
-}

package/ui/prose/utilities/format.js

@@ -1,184 +0,0 @@
-const { findMatchingBracket } = require("./brackets")
-
-/**
- * Format inline markdown elements within text
- * Handles: images, links, code, bold, italic
- * @param {string} text - The text to format
- * @param {Object} allComponents - HTML component functions (contains a, img, code, strong, em, etc.)
- * @returns {Array|string} - Formatted content as array of components and strings
- */
-function format(text, allComponents) {
-  const { a: A, img: Img, code: Code, strong: Strong, em: Em } = allComponents
-
-  if (
-    !text.includes("*") &&
-    !text.includes("`") &&
-    !text.includes("[") &&
-    !text.includes("!") &&
-    !text.includes("<") &&
-    !text.includes("\\")
-  ) {
-    return text
-  }
-
-  const result = []
-  let i = 0
-
-  while (i < text.length) {
-    // Handle escape characters
-    if (text[i] === "\\") {
-      if (i + 1 < text.length) {
-        const nextChar = text[i + 1]
-        // Check if next char is a special markdown character
-        if (
-          nextChar === "*" ||
-          nextChar === "`" ||
-          nextChar === "[" ||
-          nextChar === "]" ||
-          nextChar === "(" ||
-          nextChar === ")" ||
-          nextChar === "!" ||
-          nextChar === "<" ||
-          nextChar === ">" ||
-          nextChar === "\\"
-        ) {
-          // Escape the next character - just add it as literal text
-          result.push(nextChar)
-          i += 2 // Skip both \ and the escaped character
-          continue
-        }
-        // If not a special char, keep both the backslash and the next character
-        result.push(text[i])
-        result.push(nextChar)
-        i += 2
-        continue
-      } else {
-        // Backslash at end of string
-        result.push(text[i])
-        i++
-        continue
-      }
-    }
-
-    if (text[i] === "!" && text[i + 1] === "[") {
-      // Try to parse markdown image ![alt](url)
-      const altEnd = text.indexOf("]", i + 2)
-
-      if (altEnd !== -1 && text[altEnd + 1] === "(") {
-        const urlEnd = text.indexOf(")", altEnd + 2)
-
-        if (urlEnd !== -1) {
-          const alt = text.substring(i + 2, altEnd)
-          const src = text.substring(altEnd + 2, urlEnd)
-          result.push(Img({ src, alt }))
-          i = urlEnd + 1
-          continue
-        }
-      }
-
-      // Not a valid image, treat as regular text (skip both ! and [)
-      result.push(text[i])
-      i++
-    } else if (text[i] === "[") {
-      // Try to parse markdown link [text](url)
-      const textEnd = findMatchingBracket(text, i)
-
-      if (textEnd !== -1 && text[textEnd + 1] === "(") {
-        const urlEnd = text.indexOf(")", textEnd + 2)
-
-        if (urlEnd !== -1) {
-          const linkText = text.substring(i + 1, textEnd)
-          const url = text.substring(textEnd + 2, urlEnd)
-          // Recursively format the link text to support images, bold, italic inside links
-          result.push(A({ href: url }, format(linkText, allComponents)))
-          i = urlEnd + 1
-          continue
-        }
-      }
-
-      // Not a valid link, treat as regular text
-      result.push(text[i])
-      i++
-    } else if (text[i] === "<") {
-      // Try to parse autolink <url> or <email>
-      const end = text.indexOf(">", i + 1)
-
-      if (end !== -1) {
-        const content = text.substring(i + 1, end)
-
-        // Check if it's a URL (starts with http:// or https://)
-        if (content.startsWith("http://") || content.startsWith("https://")) {
-          result.push(A({ href: content }, content))
-          i = end + 1
-          continue
-        }
-
-        // Check if it's an email (contains @ and looks like email)
-        if (
-          content.includes("@") &&
-          /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(content)
-        ) {
-          result.push(A({ href: `mailto:${content}` }, content))
-          i = end + 1
-          continue
-        }
-      }
-
-      // Not a valid autolink, treat as regular text
-      result.push(text[i])
-      i++
-    } else if (text[i] === "`") {
-      const end = text.indexOf("`", i + 1)
-      if (end === -1) {
-        result.push(text[i])
-        i++
-      } else {
-        result.push(Code({}, text.substring(i + 1, end)))
-        i = end + 1
-      }
-    } else if (text[i] === "*" && text[i + 1] === "*") {
-      const end = text.indexOf("**", i + 2)
-      if (end === -1) {
-        result.push(text[i])
-        i++
-      } else {
-        result.push(Strong(format(text.substring(i + 2, end), allComponents)))
-        i = end + 2
-      }
-    } else if (text[i] === "*") {
-      const end = text.indexOf("*", i + 1)
-      if (end === -1) {
-        result.push(text[i])
-        i++
-      } else {
-        result.push(Em(format(text.substring(i + 1, end), allComponents)))
-        i = end + 1
-      }
-    } else {
-      // Find next special character
-      const positions = [
-        text.indexOf("`", i),
-        text.indexOf("*", i),
-        text.indexOf("[", i),
-        text.indexOf("<", i),
-        text.indexOf("\\", i),
-      ].filter((pos) => pos !== -1)
-
-      // Look for image pattern ![
-      const exclamPos = text.indexOf("!", i)
-      if (exclamPos !== -1 && text[exclamPos + 1] === "[") {
-        positions.push(exclamPos)
-      }
-
-      const next = positions.length > 0 ? Math.min(...positions) : text.length
-
-      result.push(text.substring(i, next))
-      if (next === text.length) break
-      i = next
-    }
-  }
-
-  return result.length > 0 ? result : text
-}
-
-module.exports = { format }

package/ui/prose/utilities/params.js

@@ -1,29 +0,0 @@
-/**
- * Extracts HTML parameters from params object by filtering out special keys
- */
-function extractHtmlParams(params) {
-  if (!params) return {}
-
-  return Object.keys(params).reduce((acc, key) => {
-    if (key !== "components" && key !== "data") {
-      acc[key] = params[key]
-    }
-    return acc
-  }, {})
-}
-
-/**
- * Merges builtin HTML tags with custom components
- * Custom components can override builtin tags if needed
- */
-function mergeComponents(builtinHtmlTags, customComponents) {
-  return {
-    ...builtinHtmlTags,
-    ...customComponents,
-  }
-}
-
-module.exports = {
-  extractHtmlParams,
-  mergeComponents,
-}