boxwood 2.8.2 → 2.10.0

package/adapters/express/index.js

@@ -32,15 +32,23 @@ function engine(options = {}) {
     try {
       const template = await compileFile(path)
       // Automatically inject nonce from res.locals if available
-      const templateOptions = options && options._locals && options._locals.nonce
-        ? { ...options, nonce: options._locals.nonce }
-        : options
+      const templateOptions =
+        options && options._locals && options._locals.nonce
+          ? { ...options, nonce: options._locals.nonce }
+          : options
       const html = template(templateOptions)
       if (callback) return callback(null, html)
       return html
     } catch (error) {
-      if (callback) return callback(error)
-      return error.message
+      // Enhance error message with file path for better debugging
+      const exception = new Error(
+        `Error rendering view "${path}": ${error.message}`,
+      )
+      exception.stack = error.stack
+      exception.originalError = error
+      exception.viewPath = path
+      if (callback) return callback(exception)
+      return exception.message
     }
   }
   return render

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "boxwood",
-  "version": "2.8.2",
+  "version": "2.10.0",
   "description": "Compile HTML templates into JS",
   "main": "index.js",
   "types": "index.d.ts",
@@ -49,8 +49,8 @@
     "benchmark": "2.1.4",
     "c8": "^11.0.0",
     "express": "^5.2.1",
-    "handlebars": "^4.7.8",
-    "jsdom": "^28.1.0",
+    "handlebars": "^4.7.9",
+    "jsdom": "^29.1.1",
     "mustache": "^4.2.0",
     "underscore": "^1.13.8"
   },

package/ui/markdown/index.js

@@ -103,61 +103,96 @@ function Markdown(params, children) {
   const lines = children
     .trim()
     .split("\n")
-    .map((line) => line.trim())
-    .filter(Boolean)
+    .filter((line) => line.trim().length > 0)
+    .map((line) => {
+      // Preserve leading spaces for indentation tracking
+      const trimmed = line.trim()
+      const leadingSpaces = line.length - line.trimStart().length
+      return { text: trimmed, indent: leadingSpaces }
+    })
 
   const items = lines
-    .map((line) => {
-      if (UNORDERED_MARKERS.some((marker) => line.startsWith(marker))) {
-        const content = line.substring(2)
+    .map(({ text, indent }) => {
+      if (UNORDERED_MARKERS.some((marker) => text.startsWith(marker))) {
+        const content = text.substring(2)
         if (!content) return null
-        return { type: "li", list: "ul", content }
+        return { type: "li", list: "ul", content, indent }
       }
 
-      if (ORDERED_LIST_REGEXP.test(line)) {
-        const content = line.replace(ORDERED_LIST_REGEXP, "")
+      if (ORDERED_LIST_REGEXP.test(text)) {
+        const content = text.replace(ORDERED_LIST_REGEXP, "")
         if (!content) return null
-        return { type: "li", list: "ol", content }
+        return { type: "li", list: "ol", content, indent }
       }
 
       for (const { prefix, type } of HEADINGS) {
-        if (line.startsWith(prefix)) {
-          return { type, content: line.substring(prefix.length) }
+        if (text.startsWith(prefix)) {
+          return { type, content: text.substring(prefix.length), indent }
         }
       }
 
-      if (line.startsWith("> ")) {
-        return { type: "blockquote", content: line.substring(2) }
+      if (text.startsWith("> ")) {
+        return { type: "blockquote", content: text.substring(2), indent }
       }
 
-      return { type: "p", content: line }
+      return { type: "p", content: text, indent }
     })
     .filter(Boolean)
 
   const nodes = []
   let i = 0
 
-  while (i < items.length) {
-    const item = items[i]
+  function parseList(startIndex, parentIndent) {
+    const list = []
+    let currentIndex = startIndex
+    const parentListType = items[startIndex].list
 
-    if (item.type === "li") {
-      const list = []
-      const parent = item.list
-
-      while (
-        i < items.length &&
-        items[i].type === "li" &&
-        items[i].list === parent
-      ) {
-        list.push(Li(params, format(items[i].content)))
-        i++
+    while (currentIndex < items.length) {
+      const item = items[currentIndex]
+
+      // Stop if not a list item or indent is less than expected
+      if (item.type !== "li" || item.indent < parentIndent) {
+        break
       }
 
-      if (parent === "ul") {
-        nodes.push(Ul(params, list))
-      } else if (parent === "ol") {
-        nodes.push(Ol(params, list))
+      // Stop if indent matches but list type differs
+      if (item.indent === parentIndent && item.list !== parentListType) {
+        break
+      }
+
+      // Skip items with greater indent (they belong to nested lists)
+      if (item.indent > parentIndent) {
+        break
       }
+
+      // Process current item at the correct indent level
+      const content = [format(item.content)]
+      currentIndex++
+
+      // Check if next item is a nested list
+      const nextItem = items[currentIndex]
+      if (nextItem?.type === "li" && nextItem.indent > item.indent) {
+        const nestedResult = parseList(currentIndex, nextItem.indent)
+        content.push(nestedResult.list)
+        currentIndex = nestedResult.nextIndex
+      }
+
+      list.push(Li(params, content))
+    }
+
+    const listElement =
+      parentListType === "ul" ? Ul(params, list) : Ol(params, list)
+
+    return { list: listElement, nextIndex: currentIndex }
+  }
+
+  while (i < items.length) {
+    const item = items[i]
+
+    if (item.type === "li") {
+      const result = parseList(i, item.indent)
+      nodes.push(result.list)
+      i = result.nextIndex
     } else if (item.type === "blockquote") {
       const lines = []