boxwood 2.17.0 → 2.18.0

package/ui/markdown/utilities/parseCustomTag.js

@@ -1,218 +0,0 @@
-/**
- * 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/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,
-}