@zeropress/build-core 0.6.10 → 0.6.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeropress/build-core",
-  "version": "0.6.10",
+  "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',
@@ -336,14 +444,16 @@ function sanitizeHtml(html) {
   ]);
 
   const allowedAttributes = {
-    a: new Set(['href', 'title', 'class', 'id']),
+    a: new Set(['href', 'title', 'class', 'id', 'target', 'rel']),
     aside: new Set(['role', 'class', 'id']),
     img: new Set(['src', 'srcset', 'sizes', 'alt', 'title', 'class', 'id', 'width', 'height', 'loading', 'decoding']),
     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']),
-    video: new Set(['src', 'controls', 'autoplay', 'loop', 'muted', 'playsinline', 'poster', 'preload', 'width', 'height', 'class', 'id', 'title']),
-    audio: new Set(['src', 'controls', 'autoplay', 'loop', 'muted', 'preload', 'class', 'id', 'title']),
+    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']),
     '*': new Set(['class', 'id']),
   };
@@ -368,6 +478,9 @@ function sanitizeHtml(html) {
     const tagAllowedAttributes = allowedAttributes[normalizedTag] || new Set();
     const globalAllowedAttributes = allowedAttributes['*'];
     const filteredAttributes = [];
+    let anchorTarget = '';
+    let anchorRel = '';
+    let tableCellAlignClass = '';
 
     if (attributeString) {
       const attributePattern = /([a-zA-Z][a-zA-Z0-9-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
@@ -385,10 +498,55 @@ function sanitizeHtml(html) {
           continue;
         }
 
+        if (normalizedTag === 'a' && attributeName === 'target') {
+          const target = sanitizeAnchorTarget(attributeValue);
+          if (!target) {
+            continue;
+          }
+          anchorTarget = target;
+          continue;
+        }
+
+        if (normalizedTag === 'a' && attributeName === 'rel') {
+          const rel = sanitizeRelList(attributeValue);
+          if (!rel) {
+            continue;
+          }
+          anchorRel = rel;
+          continue;
+        }
+
         if (attributeName === 'srcset' && !isSafeSrcset(attributeValue, safeUriPattern)) {
           continue;
         }
 
+        if (attributeName === 'controlslist') {
+          const controlsList = sanitizeControlsList(attributeValue);
+          if (!controlsList) {
+            continue;
+          }
+          filteredAttributes.push(`${attributeName}="${controlsList}"`);
+          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;
         }
@@ -397,6 +555,22 @@ function sanitizeHtml(html) {
       }
     }
 
+    if (tableCellAlignClass) {
+      appendClassAttribute(filteredAttributes, tableCellAlignClass);
+    }
+
+    if (normalizedTag === 'a') {
+      if (anchorTarget) {
+        filteredAttributes.push(`target="${anchorTarget}"`);
+      }
+      if (anchorTarget === '_blank') {
+        anchorRel = ensureBlankTargetRel(anchorRel);
+      }
+      if (anchorRel) {
+        filteredAttributes.push(`rel="${anchorRel}"`);
+      }
+    }
+
     const isSelfClosing = match.endsWith('/>') || normalizedTag === 'br' || normalizedTag === 'hr' || normalizedTag === 'img' || normalizedTag === 'input' || normalizedTag === 'source' || normalizedTag === 'track';
     const attributeSuffix = filteredAttributes.length > 0 ? ` ${filteredAttributes.join(' ')}` : '';
     return isSelfClosing ? `<${normalizedTag}${attributeSuffix} />` : `<${normalizedTag}${attributeSuffix}>`;
@@ -414,6 +588,86 @@ 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' : '';
+}
+
+function sanitizeRelList(value) {
+  const allowedTokens = new Set(['noopener', 'noreferrer', 'nofollow', 'ugc', 'sponsored', 'external']);
+  const tokens = String(value)
+    .toLowerCase()
+    .split(/\s+/)
+    .filter((token, index, allTokens) => (
+      allowedTokens.has(token)
+      && allTokens.indexOf(token) === index
+    ));
+
+  return tokens.join(' ');
+}
+
+function ensureBlankTargetRel(value) {
+  const tokens = String(value)
+    .toLowerCase()
+    .split(/\s+/)
+    .filter(Boolean);
+
+  for (const requiredToken of ['noopener', 'noreferrer']) {
+    if (!tokens.includes(requiredToken)) {
+      tokens.push(requiredToken);
+    }
+  }
+
+  return tokens.join(' ');
+}
+
+function sanitizeControlsList(value) {
+  const allowedTokens = new Set(['nodownload', 'nofullscreen', 'noremoteplayback']);
+  const tokens = String(value)
+    .toLowerCase()
+    .split(/\s+/)
+    .filter((token, index, allTokens) => (
+      allowedTokens.has(token)
+      && allTokens.indexOf(token) === index
+    ));
+
+  return tokens.join(' ');
+}
+
 function isSafeSrcset(value, safeUriPattern) {
   const candidates = String(value)
     .split(',')