domma-cms 0.6.16 → 0.6.21

package/server/services/markdown.js

@@ -96,6 +96,49 @@ function renderCollectionBlocks(entries, blockTemplate, emptyMsg, ctaOpts, cols)
     return `<div class="${wrapperClass}">\n${items.join('\n')}\n</div>`;
 }
 
+/**
+ * Process [block template="name" field1="val" field2="val" /] shortcodes.
+ * Loads the named block template and substitutes {{placeholders}} with
+ * the supplied attribute values. Renders a single block instance.
+ *
+ * @param {string} content
+ * @returns {Promise<string>}
+ */
+async function processStaticBlocks(content) {
+    const pattern = /\[block\s+([\s\S]+?)\/\]/g;
+    const matches = [...content.matchAll(pattern)];
+    if (!matches.length) return content;
+
+    let output = content;
+    // Process in reverse so string indices stay valid as we replace
+    for (const match of matches.toReversed()) {
+        const attrsStr = match[1];
+        const attrs = {};
+        for (const [, key, dq, sq] of attrsStr.matchAll(/([\w-]+)=(?:"([^"]*)"|'([^']*)')/g)) {
+            attrs[key] = dq ?? sq ?? '';
+        }
+
+        const templateName = attrs.template;
+        if (!templateName) {
+            output = output.slice(0, match.index) + '' + output.slice(match.index + match[0].length);
+            continue;
+        }
+
+        let replacement = '';
+        try {
+            const tmpl = await loadBlockTemplate(templateName);
+            const rendered = tmpl.replace(/\{\{([\w_]+)\}\}/g, (_, key) => {
+                return escapeHtmlText(attrs[key] ?? '');
+            });
+            replacement = `<div class="dm-static-block">${rendered}</div>`;
+        } catch (_) {
+            // Template not found — emit nothing
+        }
+        output = output.slice(0, match.index) + replacement + output.slice(match.index + match[0].length);
+    }
+    return output;
+}
+
 function renderCollectionTable(slug, entries, visibleFields, attrs, ctaOpts) {
     const columns = visibleFields.map(f => ({key: f.name, title: f.label || f.name}));
     const rows = entries.map(e => {
@@ -1023,6 +1066,122 @@ function processBadgeBlocks(markdown) {
   return restore(result);
 }
 
+/**
+ * Pre-process [text] shortcodes before running through marked.
+ *
+ * Syntax (paired):
+ *   [text size="xl" bold italic color="primary" font="Georgia"]Your text[/text]
+ *
+ * Outputs a <span> with all resolved styles inlined.
+ *
+ * @param {string} markdown
+ * @returns {string}
+ */
+function processTextBlocks(markdown) {
+    const {scrubbed, restore} = scrubCodeRegions(markdown);
+
+    const SIZE_MAP = {
+        xs: '.75rem', sm: '.875rem', base: '1rem', lg: '1.125rem',
+        xl: '1.25rem', '2xl': '1.5rem', '3xl': '1.875rem', '4xl': '2.25rem',
+    };
+    const WEIGHT_MAP = {
+        thin: '100', light: '300', normal: '400', medium: '500',
+        semibold: '600', bold: '700', extrabold: '800', black: '900',
+    };
+    const SPACING_MAP = {
+        tight: '-0.05em', normal: '0em', wide: '0.05em', wider: '0.1em',
+    };
+    const COLOR_TOKENS = {
+        primary: 'var(--dm-color-primary)', secondary: 'var(--dm-color-secondary)',
+        muted: 'var(--dm-text-muted)', danger: 'var(--dm-color-danger)',
+        success: 'var(--dm-color-success)', warning: 'var(--dm-color-warning)',
+        info: 'var(--dm-color-info)',
+    };
+    const FONT_MAP = {
+        'Georgia': 'Georgia,serif',
+        'Arial': 'Arial,sans-serif',
+        'Verdana': 'Verdana,sans-serif',
+        'Courier New': "'Courier New',monospace",
+        'Times New Roman': "'Times New Roman',serif",
+        'Trebuchet MS': "'Trebuchet MS',sans-serif",
+    };
+    const TRANSFORM_MAP = {
+        upper: 'uppercase', lower: 'lowercase', capitalize: 'capitalize', none: 'none',
+    };
+    const DECORATION_MAP = {
+        underline: 'underline', 'line-through': 'line-through', none: 'none',
+    };
+
+    function buildText(attrStr, inner) {
+        const attrs = parseShortcodeAttrs(attrStr || '');
+        const styles = [];
+
+        if (attrs.size) {
+            styles.push(`font-size:${SIZE_MAP[attrs.size] || attrs.size}`);
+        }
+
+        if (attrs['point-size']) {
+            const pt = parseFloat(attrs['point-size']);
+            if (!isNaN(pt) && pt > 0) styles.push(`font-size:${pt}pt`);
+        }
+
+        // bold flag takes precedence over weight attr
+        const isBold = /\bbold\b/i.test(attrStr);
+        if (isBold) {
+            styles.push('font-weight:700');
+        } else if (attrs.weight && WEIGHT_MAP[attrs.weight]) {
+            styles.push(`font-weight:${WEIGHT_MAP[attrs.weight]}`);
+        }
+
+        if (/\bitalic\b/i.test(attrStr)) {
+            styles.push('font-style:italic');
+        }
+
+        if (attrs.color) {
+            styles.push(`color:${COLOR_TOKENS[attrs.color] || attrs.color}`);
+        }
+
+        if (attrs.font && FONT_MAP[attrs.font]) {
+            styles.push(`font-family:${FONT_MAP[attrs.font]}`);
+        }
+
+        if (attrs.transform && TRANSFORM_MAP[attrs.transform]) {
+            styles.push(`text-transform:${TRANSFORM_MAP[attrs.transform]}`);
+        }
+
+        if (attrs.decoration && DECORATION_MAP[attrs.decoration]) {
+            styles.push(`text-decoration:${DECORATION_MAP[attrs.decoration]}`);
+        }
+
+        if (attrs.spacing) {
+            styles.push(`letter-spacing:${SPACING_MAP[attrs.spacing] || attrs.spacing}`);
+        }
+
+        if (attrs.align) {
+            styles.push('display:block');
+            styles.push(`text-align:${escapeAttr(attrs.align)}`);
+        }
+
+        if (attrs.style) {
+            styles.push(attrs.style.trim().replace(/;+$/, ''));
+        }
+
+        const styleAttr = styles.length ? ` style="${styles.join(';')}"` : '';
+        const classAttr = attrs.class ? ` class="${escapeAttr(attrs.class)}"` : '';
+        const idAttr = attrs.id ? ` id="${escapeAttr(attrs.id)}"` : '';
+
+        return `<span${styleAttr}${classAttr}${idAttr}>${inner.trim()}</span>`;
+    }
+
+    // Note: [\s\S]*? allows multi-line body content (deliberate divergence from badge's [^\n]*?)
+    const result = scrubbed.replace(
+        /\[text([^\]]*)\]([\s\S]*?)\[\/text\]/gi,
+        (_, attrStr, body) => buildText(attrStr, body)
+    );
+
+    return restore(result);
+}
+
 /**
  * Pre-process [button] shortcodes before running through marked.
  *
@@ -1369,7 +1528,7 @@ function processHeroBlocks(markdown) {
         (twinkleColour ? ` data-fx-colour="${escapeAttr(twinkleColour)}"` : '')
         : '';
 
-      const processedBody = processBadgeBlocks(processCardBlocks(processGridBlocks(restore(body.trim()))));
+      const processedBody = processTextBlocks(processBadgeBlocks(processCardBlocks(processGridBlocks(restore(body.trim())))));
 
       let inner = '<div class="hero-content">';
       if (title) inner += `<h1 class="hero-title hero-title-responsive">${escapeAttr(title)}</h1>`;
@@ -1510,13 +1669,14 @@ export async function parseMarkdown(raw) {
   const extensions = getSanitizeExtensions();
 
   // Pipeline:
-  // beforeParse → collection → view → dconfig → plugin shortcodes → tabs → accordion → carousel
-    //   → countdown → timeline → spacer → center → icon → form → hero → table → badge → button → link → cta
-    //   → grid → card → slideover → marked → sanitize → afterParse
+  // beforeParse → collection → view → staticBlock → dconfig → plugin shortcodes → tabs → accordion → carousel
+  //   → countdown → timeline → spacer → center → icon → form → hero → table → badge → button → link → cta
+  //   → grid → card → slideover → marked → sanitize → afterParse
   const preprocessed = applyTransforms('markdown:beforeParse', content);
   const withCollection = await processCollectionBlocks(preprocessed);
   const withView = await processViewBlocks(withCollection);
-  const withDconfig = processDConfigBlocks(withView);
+  const withStaticBlock = await processStaticBlocks(withView);
+  const withDconfig = processDConfigBlocks(withStaticBlock);
   const withPluginShortcodes = processPluginShortcodes(withDconfig);
   const withTabs = processTabsBlocks(withPluginShortcodes);
   const withAccordion = processAccordionBlocks(withTabs);
@@ -1529,9 +1689,10 @@ export async function parseMarkdown(raw) {
   const withForm = await processFormBlocks(withIcon);
   const withHero = processHeroBlocks(withForm);
   const withTable = processTableBlocks(withHero);
-  const withBadge = processBadgeBlocks(withTable);
-    const withButton = processButtonBlocks(withBadge);
-    const withLink = processLinkBlocks(withButton);
+  const withBadge  = processBadgeBlocks(withTable);
+  const withText   = processTextBlocks(withBadge);
+  const withButton = processButtonBlocks(withText);
+  const withLink   = processLinkBlocks(withButton);
     const withCta = processCtaBlocks(withLink);
   const withGrid = processGridBlocks(withCta);
   const withCard = processCardBlocks(withGrid);

package/server/services/plugins.js

@@ -152,12 +152,13 @@ export async function registerPlugins(fastify) {
         const entryPath = path.join(PLUGINS_DIR, manifest.name, 'plugin.js');
         try {
             const { default: plugin } = await import(entryPath);
-          await loadConfigDefaults(manifest.name);
+            const settings = await getPluginSettings(manifest.name);
           const prefix = `/api/plugins/${manifest.name}`;
           await fastify.register(plugin, {
             prefix,
             auth: {authenticate, requireRole, requireAdmin},
-            hooks: {registerShortcode, registerSanitizeRules, registerTransform, on: hooks.on.bind(hooks)}
+              hooks: {registerShortcode, registerSanitizeRules, registerTransform, on: hooks.on.bind(hooks)},
+              settings
           });
             loaded.push(manifest.name);
         } catch (err) {