@zeropress/build-core 0.1.9 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeropress/build-core",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Shared ZeroPress build and partial-render core",
   "type": "module",
   "license": "MIT",
@@ -33,7 +33,10 @@
     "node": ">=18.18.0"
   },
   "dependencies": {
-    "@zeropress/preview-data-validator": "^0.3.3",
-    "@zeropress/theme-validator": "^0.2.4"
+    "@zeropress/preview-data-validator": "^0.4.0",
+    "@zeropress/theme-validator": "^0.2.4",
+    "highlight.js": "^11.11.1",
+    "markdown-it": "^14.1.0",
+    "markdown-it-anchor": "^9.2.0"
   }
 }

package/src/api/build-site.js

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { assertPreviewData } from '@zeropress/preview-data-validator';
 import { validateThemeFiles } from '@zeropress/theme-validator';
 import { AssetProcessor } from '../assets/asset-processor.js';
+import { renderDocumentContent } from '../render/content-renderer.js';
 import { ZeroPressEngine } from '../render/zeropress-engine.js';
 
 const DEFAULT_OPTIONS = {
@@ -28,7 +29,7 @@ export async function buildSite(input) {
     await renderPost(state, post);
   }
 
-  for (const page of state.previewData.content.pages) {
+  for (const page of state.renderData.pages) {
     await renderPage(state, page);
   }
 
@@ -324,12 +325,15 @@ function normalizePreviewData(previewData) {
     site: normalizedSite,
     content: {
       ...previewData.content,
+      authors: previewData.content.authors.map((author) => ({
+        ...author,
+        avatar: normalizeMediaField(author.avatar, normalizedSite.mediaBaseUrl),
+      })),
       posts: previewData.content.posts
         .map((post) => ({
           ...post,
           published_at_iso: normalizeIsoTimestamp(post.published_at_iso),
           updated_at_iso: normalizeIsoTimestamp(post.updated_at_iso),
-          author_avatar: normalizeMediaField(post.author_avatar, normalizedSite.mediaBaseUrl),
           featured_image: normalizeMediaField(post.featured_image, normalizedSite.mediaBaseUrl),
         }))
         .sort((left, right) => toDate(right.published_at_iso).getTime() - toDate(left.published_at_iso).getTime()),
@@ -344,6 +348,7 @@ function normalizePreviewData(previewData) {
 }
 
 function createRenderData(previewData) {
+  const authorsById = new Map(previewData.content.authors.map((author) => [author.id, author]));
   const categoriesBySlug = new Map(previewData.content.categories.map((category) => [category.slug, category]));
   const tagsBySlug = new Map(previewData.content.tags.map((tag) => [tag.slug, tag]));
   const categoryPostsBySlug = new Map();
@@ -363,13 +368,15 @@ function createRenderData(previewData) {
     }
   }
 
-  const posts = previewData.content.posts.map((post) => preparePost(post, previewData.site, categoriesBySlug, tagsBySlug));
+  const posts = previewData.content.posts.map((post) => preparePost(post, previewData.site, authorsById, categoriesBySlug, tagsBySlug));
+  const pages = previewData.content.pages.map((page) => preparePage(page));
   const postBySlug = new Map(posts.map((post) => [post.slug, post]));
   const categoryLinks = renderCategoryLinks(previewData.content.categories, categoryCountBySlug);
   const tagLinks = renderTagLinks(previewData.content.tags, tagCountBySlug);
 
   return {
     posts,
+    pages,
     postBySlug,
     indexRoutes: buildPaginatedCollection({
       items: previewData.content.posts,
@@ -414,12 +421,30 @@ function createRenderData(previewData) {
   };
 }
 
-function preparePost(post, site, categoriesBySlug, tagsBySlug) {
+function preparePage(page) {
+  const documentType = normalizeDocumentType(page.document_type);
+
+  return {
+    ...page,
+    document_type: documentType,
+    html: renderDocumentContent(page.content, documentType),
+  };
+}
+
+function preparePost(post, site, authorsById, categoriesBySlug, tagsBySlug) {
+  const documentType = normalizeDocumentType(post.document_type);
+  const html = renderDocumentContent(post.content, documentType);
+  const author = authorsById.get(post.author_id);
+
   return {
     ...post,
+    document_type: documentType,
+    html,
+    author_name: normalizeNonEmptyString(author?.display_name, post.author_id),
+    author_avatar: author?.avatar,
     published_at: formatTimestamp(post.published_at_iso, site),
     updated_at: formatTimestamp(post.updated_at_iso, site),
-    reading_time: calculateReadingTime(post.html),
+    reading_time: calculateReadingTime(html),
     categories_html: renderInlineTaxonomyLinks(post.category_slugs, categoriesBySlug, 'category'),
     tags_html: renderInlineTaxonomyLinks(post.tag_slugs, tagsBySlug, 'tag'),
     comments_html: renderCommentsContainer(site, post),
@@ -776,6 +801,10 @@ function normalizeLocale(value) {
   }).join('-');
 }
 
+function normalizeDocumentType(value) {
+  return value === 'plaintext' || value === 'html' ? value : 'markdown';
+}
+
 function hasTemplate(state, templateName) {
   return state.engine.themePackage?.templates?.has(templateName) === true;
 }

package/src/index.d.ts

@@ -1,4 +1,4 @@
-import type { PreviewDataV04 } from '@zeropress/preview-data-validator';
+import type { PreviewDataV05 } from '@zeropress/preview-data-validator';
 
 export interface ThemePackage {
   metadata: {
@@ -62,14 +62,14 @@ export interface BuildSiteResult {
 }
 
 export function buildSite(input: {
-  previewData: PreviewDataV04;
+  previewData: PreviewDataV05;
   themePackage: ThemePackage;
   writer: BuildWriter;
   options?: BuildOptions;
 }): Promise<BuildSiteResult>;
 
 export function buildSelectedRoutes(input: {
-  previewData: PreviewDataV04;
+  previewData: PreviewDataV05;
   themePackage: ThemePackage;
   writer: BuildWriter;
   selection: BuildSelection;
@@ -77,7 +77,7 @@ export function buildSelectedRoutes(input: {
 }): Promise<BuildSiteResult>;
 
 export function buildSiteFromThemeDir(input: {
-  previewData: PreviewDataV04;
+  previewData: PreviewDataV05;
   themeDir: string;
   writer: BuildWriter;
   options?: BuildOptions;

package/src/render/content-renderer.js

@@ -0,0 +1,156 @@
+import MarkdownIt from 'markdown-it';
+import hljs from 'highlight.js';
+import anchor from 'markdown-it-anchor';
+
+const markdown = new MarkdownIt({
+  html: true,
+  linkify: true,
+  typographer: true,
+  breaks: true,
+  highlight(value, language) {
+    if (language && hljs.getLanguage(language)) {
+      try {
+        return hljs.highlight(value, { language }).value;
+      } catch {
+        return value;
+      }
+    }
+
+    try {
+      return hljs.highlightAuto(value).value;
+    } catch {
+      return value;
+    }
+  },
+});
+
+markdown.use(anchor, {
+  permalink: anchor.permalink.headerLink(),
+  slugify: slugify,
+});
+
+export function renderDocumentContent(content, documentType = 'markdown') {
+  const normalizedContent = typeof content === 'string' ? content : '';
+  const normalizedType = normalizeDocumentType(documentType);
+
+  if (normalizedType === 'plaintext') {
+    return transformPlaintext(normalizedContent);
+  }
+
+  if (normalizedType === 'html') {
+    return sanitizeHtml(normalizedContent);
+  }
+
+  return sanitizeHtml(markdown.render(normalizedContent));
+}
+
+function normalizeDocumentType(value) {
+  return value === 'plaintext' || value === 'html' ? value : 'markdown';
+}
+
+function transformPlaintext(content) {
+  const escaped = content
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+
+  const paragraphs = escaped
+    .split(/\n\s*\n/)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+
+  if (paragraphs.length === 0) {
+    return '';
+  }
+
+  return paragraphs.map((entry) => `<p>${entry}</p>`).join('\n');
+}
+
+function sanitizeHtml(html) {
+  const allowedTags = new Set([
+    'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+    'p', 'br', 'hr',
+    'strong', 'em', 'u', 's', 'code', 'pre',
+    'a', 'img',
+    'ul', 'ol', 'li',
+    'blockquote',
+    'table', 'thead', 'tbody', 'tr', 'th', 'td',
+    'div', 'span', 'nav',
+    'iframe',
+  ]);
+
+  const allowedAttributes = {
+    a: new Set(['href', 'title', 'class', 'id']),
+    img: new Set(['src', 'alt', 'title', 'class', 'id', 'width', 'height']),
+    iframe: new Set(['src', 'width', 'height', 'frameborder', 'allowfullscreen', 'class']),
+    '*': new Set(['class', 'id']),
+  };
+
+  const safeUriPattern = /^(?:(?:https?|mailto|tel):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i;
+
+  const stripped = html
+    .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, '')
+    .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, '');
+
+  const sanitized = stripped.replace(/<\/?([a-zA-Z][a-zA-Z0-9]*)\b([^>]*)?\/?>/g, (match, tag, attributeString) => {
+    const normalizedTag = tag.toLowerCase();
+
+    if (match.startsWith('</')) {
+      return allowedTags.has(normalizedTag) ? `</${normalizedTag}>` : '';
+    }
+
+    if (!allowedTags.has(normalizedTag)) {
+      return '';
+    }
+
+    const tagAllowedAttributes = allowedAttributes[normalizedTag] || new Set();
+    const globalAllowedAttributes = allowedAttributes['*'];
+    const filteredAttributes = [];
+
+    if (attributeString) {
+      const attributePattern = /([a-zA-Z][a-zA-Z0-9-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
+      let attributeMatch;
+
+      while ((attributeMatch = attributePattern.exec(attributeString)) !== null) {
+        const attributeName = attributeMatch[1].toLowerCase();
+        const attributeValue = attributeMatch[2] ?? attributeMatch[3] ?? attributeMatch[4] ?? '';
+
+        if (!tagAllowedAttributes.has(attributeName) && !globalAllowedAttributes.has(attributeName)) {
+          continue;
+        }
+
+        if ((attributeName === 'href' || attributeName === 'src') && !safeUriPattern.test(attributeValue)) {
+          continue;
+        }
+
+        filteredAttributes.push(`${attributeName}="${attributeValue}"`);
+      }
+    }
+
+    const isSelfClosing = match.endsWith('/>') || normalizedTag === 'br' || normalizedTag === 'hr' || normalizedTag === 'img';
+    const attributeSuffix = filteredAttributes.length > 0 ? ` ${filteredAttributes.join(' ')}` : '';
+    return isSelfClosing ? `<${normalizedTag}${attributeSuffix} />` : `<${normalizedTag}${attributeSuffix}>`;
+  });
+
+  return sanitized
+    .split(/(<[^>]+>)/g)
+    .map((part) => {
+      if (part.startsWith('<') && part.endsWith('>')) {
+        return part;
+      }
+
+      return part.replace(/&(?!(?:[a-zA-Z]+|#\d+|#x[0-9a-fA-F]+);)/g, '&amp;');
+    })
+    .join('');
+}
+
+function slugify(value) {
+  return String(value || '')
+    .toLowerCase()
+    .trim()
+    .replace(/[^\w\s-]/g, '')
+    .replace(/[\s_-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}