@zeropress/build-core 0.6.11 → 0.6.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeropress/build-core",
-  "version": "0.6.11",
+  "version": "0.6.12",
   "description": "Shared ZeroPress build core",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
   },
   "dependencies": {
     "@zeropress/slug-policy": "0.1.0",
-    "@zeropress/preview-data-validator": "0.6.6",
+    "@zeropress/preview-data-validator": "0.6.12",
     "@zeropress/theme-validator": "0.6.5",
     "highlight.js": "11.11.1",
     "markdown-it": "14.2.0",

package/src/api/build-site.js

@@ -449,6 +449,7 @@ function normalizePreviewData(previewData, options = {}) {
       ? normalizeSiteFavicon(previewData.site.favicon, media_base_url)
       : normalizeSiteFavicon(options.favicon, ''),
     logo: normalizeSiteLogo(previewData.site.logo, media_base_url),
+    newsletter: normalizeSiteNewsletter(previewData.site.newsletter),
     posts_per_page: Number.isInteger(previewData.site.posts_per_page) && previewData.site.posts_per_page > 0
       ? previewData.site.posts_per_page
       : DEFAULT_POSTS_PER_PAGE,
@@ -773,6 +774,27 @@ function normalizeSiteLogo(logo, media_base_url) {
   };
 }
 
+function normalizeSiteNewsletter(newsletter) {
+  if (!newsletter || typeof newsletter !== 'object' || Array.isArray(newsletter)) {
+    return undefined;
+  }
+
+  const title = normalizeOptionalString(newsletter.title);
+  const description = normalizeOptionalString(newsletter.description);
+  const buttonLabel = normalizeOptionalString(newsletter.button_label);
+  const signupUrl = normalizeOptionalString(newsletter.signup_url);
+  const embedUrl = normalizeOptionalString(newsletter.embed_url);
+
+  return {
+    enabled: newsletter.enabled === true,
+    ...(title ? { title } : {}),
+    ...(description ? { description } : {}),
+    ...(buttonLabel ? { button_label: buttonLabel } : {}),
+    ...(signupUrl ? { signup_url: signupUrl } : {}),
+    ...(embedUrl ? { embed_url: embedUrl } : {}),
+  };
+}
+
 function normalizePermalinks(permalinks) {
   const source = permalinks && typeof permalinks === 'object' ? permalinks : {};
   const outputStyle = typeof source.output_style === 'string' && PERMALINK_OUTPUT_STYLES.has(source.output_style)

package/src/render/content-renderer.js

@@ -10,6 +10,15 @@ const ALERT_TYPES = new Map([
   ['WARNING', { className: 'warning', title: 'Warning' }],
   ['CAUTION', { className: 'caution', title: 'Caution' }],
 ]);
+const ADMONITION_CONTAINER_TYPES = new Map([
+  ['NOTE', { className: 'note', title: 'Note' }],
+  ['INFO', { className: 'note', title: 'Info' }],
+  ['TIP', { className: 'tip', title: 'Tip' }],
+  ['IMPORTANT', { className: 'important', title: 'Important' }],
+  ['WARNING', { className: 'warning', title: 'Warning' }],
+  ['CAUTION', { className: 'caution', title: 'Caution' }],
+  ['DANGER', { className: 'caution', title: 'Danger' }],
+]);
 
 export function renderDocumentContent(content, documentType = 'markdown') {
   return renderDocument(content, documentType).html;
@@ -51,7 +60,7 @@ function createMarkdownRenderer(toc) {
     html: true,
     linkify: false,
     typographer: true,
-    breaks: true,
+    breaks: false,
     highlight(value, language) {
       if (language && hljs.getLanguage(language)) {
         try {
@@ -69,6 +78,7 @@ function createMarkdownRenderer(toc) {
     },
   });
 
+  markdown.use(markdownAdmonitionContainers);
   markdown.use(markdownTaskLists);
   markdown.use(markdownAlerts);
   markdown.use(markdownTableAlignmentClasses);
@@ -92,6 +102,107 @@ function createMarkdownRenderer(toc) {
   return markdown;
 }
 
+function markdownAdmonitionContainers(markdown) {
+  markdown.block.ruler.before('fence', 'zeropress_admonition_containers', (state, startLine, endLine, silent) => {
+    if (state.sCount[startLine] - state.blkIndent >= 4) {
+      return false;
+    }
+
+    const opener = parseAdmonitionContainerOpener(getLineText(state, startLine));
+    if (!opener) {
+      return false;
+    }
+
+    const alert = ADMONITION_CONTAINER_TYPES.get(opener.type.toUpperCase());
+    if (!alert) {
+      return false;
+    }
+
+    const closeLine = findAdmonitionContainerClose(state, startLine + 1, endLine, opener.markerLength);
+    if (closeLine === -1) {
+      return false;
+    }
+
+    if (silent) {
+      return true;
+    }
+
+    const openToken = state.push('admonition_container_open', 'aside', 1);
+    openToken.block = true;
+    openToken.markup = opener.markup;
+    openToken.map = [startLine, closeLine + 1];
+    openToken.attrSet('class', `zp-alert zp-alert--${alert.className}`);
+    openToken.attrSet('role', 'note');
+
+    state.tokens.push(...createAlertTitleTokens(state, alert.title));
+    state.md.block.tokenize(state, startLine + 1, closeLine);
+
+    const closeToken = state.push('admonition_container_close', 'aside', -1);
+    closeToken.block = true;
+    closeToken.markup = opener.markup;
+
+    state.line = closeLine + 1;
+    return true;
+  }, {
+    alt: ['paragraph', 'reference', 'blockquote', 'list'],
+  });
+}
+
+function getLineText(state, line) {
+  const start = state.bMarks[line] + state.tShift[line];
+  const end = state.eMarks[line];
+  return state.src.slice(start, end);
+}
+
+function parseAdmonitionContainerOpener(lineText) {
+  const match = /^(:{3,})[ \t]*([A-Za-z][A-Za-z0-9_-]*)(?=$|[ \t[\{])/.exec(lineText);
+  if (!match) {
+    return null;
+  }
+
+  return {
+    markup: match[1],
+    markerLength: match[1].length,
+    type: match[2],
+  };
+}
+
+function findAdmonitionContainerClose(state, startLine, endLine, markerLength) {
+  let fenceMarker = '';
+  let fenceLength = 0;
+
+  for (let line = startLine; line < endLine; line += 1) {
+    const lineText = getLineText(state, line);
+
+    if (fenceMarker) {
+      const fenceClose = new RegExp(`^${escapeRegExp(fenceMarker)}{${fenceLength},}[ \\t]*$`).exec(lineText);
+      if (fenceClose) {
+        fenceMarker = '';
+        fenceLength = 0;
+      }
+      continue;
+    }
+
+    const fenceOpen = /^(`{3,}|~{3,})/.exec(lineText);
+    if (fenceOpen) {
+      fenceMarker = fenceOpen[1][0];
+      fenceLength = fenceOpen[1].length;
+      continue;
+    }
+
+    const closeMatch = /^(:{3,})[ \t]*$/.exec(lineText);
+    if (closeMatch && closeMatch[1].length >= markerLength) {
+      return line;
+    }
+  }
+
+  return -1;
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 function markdownTableAlignmentClasses(markdown) {
   for (const tokenName of ['th_open', 'td_open']) {
     markdown.renderer.rules[tokenName] = (tokens, index, options, env, self) => {
@@ -209,8 +320,9 @@ function markdownAlerts(markdown) {
         state.tokens.splice(firstParagraph.openIndex, 3);
       }
 
-      state.tokens.splice(index + 1, 0, ...createAlertTitleTokens(state, alert.title));
-      index += 3;
+      const titleTokens = createAlertTitleTokens(state, alert.title);
+      state.tokens.splice(index + 1, 0, ...titleTokens);
+      index += titleTokens.length;
     }
   });
 }
@@ -272,18 +384,10 @@ function stripAlertMarker(inlineToken, state) {
 }
 
 function createAlertTitleTokens(state, title) {
-  const openToken = new state.Token('paragraph_open', 'p', 1);
-  openToken.attrSet('class', 'zp-alert__title');
-
-  const inlineToken = new state.Token('inline', '', 0);
-  inlineToken.content = title;
-  const textToken = new state.Token('text', '', 0);
-  textToken.content = title;
-  inlineToken.children = [textToken];
-
-  const closeToken = new state.Token('paragraph_close', 'p', -1);
-
-  return [openToken, inlineToken, closeToken];
+  const token = new state.Token('html_block', '', 0);
+  token.block = true;
+  token.content = `<p class="zp-alert__title">${escapeHtml(title)}</p>`;
+  return [token];
 }
 
 function addTokenClass(token, className) {
@@ -301,12 +405,7 @@ function normalizeDocumentType(value) {
 }
 
 function transformPlaintext(content) {
-  const escaped = content
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&#39;');
+  const escaped = escapeHtml(content);
 
   const paragraphs = escaped
     .split(/\n\s*\n/)
@@ -320,11 +419,20 @@ function transformPlaintext(content) {
   return paragraphs.map((entry) => `<p>${entry}</p>`).join('\n');
 }
 
+function escapeHtml(value) {
+  return String(value)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
 function sanitizeHtml(html) {
   const allowedTags = new Set([
     'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
     'p', 'br', 'hr',
-    'strong', 'em', 'u', 's', 'code', 'pre',
+    'strong', 'b', 'em', 'u', 's', 'sup', 'sub', 'code', 'pre',
     'a', 'img',
     'ul', 'ol', 'li',
     'blockquote', 'aside',
@@ -342,6 +450,8 @@ function sanitizeHtml(html) {
     iframe: new Set(['src', 'width', 'height', 'frameborder', 'allowfullscreen', 'class', 'title']),
     input: new Set(['type', 'checked', 'disabled', 'class', 'id', 'aria-label']),
     source: new Set(['src', 'srcset', 'sizes', 'type', 'media', 'width', 'height', 'class', 'id']),
+    th: new Set(['rowspan', 'colspan', 'align', 'class', 'id']),
+    td: new Set(['rowspan', 'colspan', 'align', 'class', 'id']),
     video: new Set(['src', 'controls', 'controlslist', 'autoplay', 'loop', 'muted', 'playsinline', 'poster', 'preload', 'width', 'height', 'class', 'id', 'title']),
     audio: new Set(['src', 'controls', 'controlslist', 'autoplay', 'loop', 'muted', 'preload', 'class', 'id', 'title']),
     track: new Set(['src', 'kind', 'srclang', 'label', 'default', 'class', 'id']),
@@ -370,6 +480,7 @@ function sanitizeHtml(html) {
     const filteredAttributes = [];
     let anchorTarget = '';
     let anchorRel = '';
+    let tableCellAlignClass = '';
 
     if (attributeString) {
       const attributePattern = /([a-zA-Z][a-zA-Z0-9-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
@@ -418,6 +529,24 @@ function sanitizeHtml(html) {
           continue;
         }
 
+        if ((normalizedTag === 'th' || normalizedTag === 'td') && (attributeName === 'rowspan' || attributeName === 'colspan')) {
+          const span = sanitizePositiveIntegerAttribute(attributeValue);
+          if (!span) {
+            continue;
+          }
+          filteredAttributes.push(`${attributeName}="${span}"`);
+          continue;
+        }
+
+        if ((normalizedTag === 'th' || normalizedTag === 'td') && attributeName === 'align') {
+          const alignment = sanitizeTableAlignment(attributeValue);
+          if (!alignment) {
+            continue;
+          }
+          tableCellAlignClass = `zp-align-${alignment}`;
+          continue;
+        }
+
         if (normalizedTag === 'input' && attributeName === 'type' && attributeValue !== 'checkbox') {
           continue;
         }
@@ -426,6 +555,10 @@ function sanitizeHtml(html) {
       }
     }
 
+    if (tableCellAlignClass) {
+      appendClassAttribute(filteredAttributes, tableCellAlignClass);
+    }
+
     if (normalizedTag === 'a') {
       if (anchorTarget) {
         filteredAttributes.push(`target="${anchorTarget}"`);
@@ -455,6 +588,40 @@ function sanitizeHtml(html) {
     .join('');
 }
 
+function appendClassAttribute(attributes, className) {
+  const classIndex = attributes.findIndex((attribute) => attribute.startsWith('class="'));
+  if (classIndex === -1) {
+    attributes.push(`class="${className}"`);
+    return;
+  }
+
+  const existingValue = attributes[classIndex].slice('class="'.length, -1);
+  const classes = existingValue.split(/\s+/).filter(Boolean);
+  if (!classes.includes(className)) {
+    classes.push(className);
+  }
+  attributes[classIndex] = `class="${classes.join(' ')}"`;
+}
+
+function sanitizePositiveIntegerAttribute(value) {
+  const normalized = String(value).trim();
+  if (!/^\d+$/.test(normalized)) {
+    return '';
+  }
+
+  const numericValue = Number(normalized);
+  if (!Number.isSafeInteger(numericValue) || numericValue < 1) {
+    return '';
+  }
+
+  return String(numericValue);
+}
+
+function sanitizeTableAlignment(value) {
+  const normalized = String(value).trim().toLowerCase();
+  return ['left', 'center', 'right'].includes(normalized) ? normalized : '';
+}
+
 function sanitizeAnchorTarget(value) {
   const normalized = String(value).trim().toLowerCase();
   return normalized === '_blank' ? '_blank' : '';