domma-cms 1.8.43 → 1.8.44

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [1.8.44] - 2026-10-23
+
+- **Blocks with empty fields no longer show raw HTML.** A block placeholder on its own line with nothing to fill it (`{{bio}}` when there is no bio) left a blank line, which ended the block's HTML in the Markdown, and what followed showed on the page as code - the About page's team card printed its contact links as raw tags. Such a line is now dropped when it fills empty (`fillTemplateLines()` in `markdown.js`), for collection displays and block short tags alike; a template's own blank lines stay, since they are how it hands a Markdown value to marked.
+- **Inline code on an indented HTML line shows again.** `<code>` inside an HTML line indented four or more spaces came out as `SC1:0` - the code-region scrub stored the line holding the code's placeholder and restored it only once. Restore now restores what it brings back too.
+
 ## [1.8.43] - 2026-10-23
 
 - **What is inside a short tag is indented too.** Shift+Alt+F now indents the content of `[grid]`, `[col]`, `[card]`, `[tabs]` and the other container short tags by how deeply it nests, not only the tag lines, and Enter after an opening tag goes one deeper. A nested list or fenced code keeps its shape inside. The renderer takes the nesting indent off before anything else (a container's content loses the indent its lines share), so four spaces inside a card is no longer a code block - and a page written flat reads exactly as before (checked across the fleet's 1,700 pages).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domma-cms",
-  "version": "1.8.43",
+  "version": "1.8.44",
   "description": "File-based CMS powered by Domma and Fastify. Run npx domma-cms my-site to create a new project.",
   "type": "module",
   "main": "server/server.js",

package/server/services/markdown.js

@@ -423,10 +423,29 @@ export function buildBlockStyleTag(blockName, css) {
  * @param {object} e             - Collection entry { id, data, meta }
  * @returns {string}
  */
+/**
+ * A filled block goes into Markdown as HTML, and a blank line ends an HTML block:
+ * what follows, indented, marked then shows as code - raw tags on the page. A
+ * placeholder alone on its line with nothing to fill it (`    {{bio}}` with no
+ * bio) made exactly that blank line, so such a line goes. The template's OWN
+ * blank lines stay: they are how a template hands a Markdown value to marked.
+ * Each line is filled by itself, in one pass as before.
+ */
+function fillTemplateLines(template, fill) {
+    const PLACEHOLDER = /\{\{\{(\w+)\}\}\}|\{\{([\w_]+)(?::([^{}]+))?\}\}/g;
+    const out = [];
+    for (const line of template.split('\n')) {
+        const filled = line.replace(PLACEHOLDER, fill);
+        if (!filled.trim() && line.trim() && /\{\{/.test(line)) continue;
+        out.push(filled);
+    }
+    return out.join('\n');
+}
+
 function interpolateBlockTemplate(blockTemplate, e) {
     // One pass: a raw value put in (pre-rendered HTML) is never read again for
     // placeholders - text that shows "{{title}}" keeps it.
-    return blockTemplate.replace(/\{\{\{(\w+)\}\}\}|\{\{([\w_]+)(?::([^{}]+))?\}\}/g, (_, raw, key, fmt) => {
+    return fillTemplateLines(blockTemplate, (_, raw, key, fmt) => {
         // Entry values never carry a shortcode into the page (inertShortcodes);
         // the template's own markup is untouched.
         if (raw !== undefined) return inertShortcodes(String(e.data?.[raw] ?? ''));
@@ -510,7 +529,7 @@ function renderCollectionBlocks(entries, blockTemplate, emptyMsg, ctaOpts, cols,
 function renderBlockFromAttrs(tmpl, attrs, blockName = '') {
     // Triple-brace raw pass-through and `{{field}}` (optional `:format`, e.g. `{{date:DD MMM YYYY}}`)
     // in one pass, so a raw value is never read again for placeholders.
-    const rendered = tmpl.replace(/\{\{\{(\w+)\}\}\}|\{\{([\w_]+)(?::([^{}]+))?\}\}/g, (_, rawKey, key, fmt) => {
+    const rendered = fillTemplateLines(tmpl, (_, rawKey, key, fmt) => {
         if (rawKey !== undefined) return String(attrs[rawKey] ?? '');
         const raw = attrs[key] ?? '';
         if (fmt) {
@@ -1967,7 +1986,10 @@ export function scrubCodeRegions(markdown, preserveIndented = false) {
   // Inline code spans (single or multiple backticks, non-greedy)
   scrubbed = scrubbed.replace(/`+[^`\n]+`+/g, placeholder);
 
-  const restore = (s) => s.replace(new RegExp(`\\x02SC${callId}:(\\d+)\\x03`, 'g'), (_, i) => store[parseInt(i, 10)]);
+  // A stored region can hold an earlier placeholder of this same call - an indented
+  // line (preserveIndented) holding an inline <code> - so what comes back is
+  // restored too. Restoring it once left "SC1:0" on the page.
+  const restore = (s) => s.replace(new RegExp(`\\x02SC${callId}:(\\d+)\\x03`, 'g'), (_, i) => restore(store[parseInt(i, 10)]));
   return {scrubbed, restore};
 }