@zeropress/build-core 0.1.9 → 0.1.11

package/README.md

@@ -4,7 +4,7 @@
 ![license](https://img.shields.io/npm/l/%40zeropress%2Fbuild-core)
 ![node](https://img.shields.io/node/v/%40zeropress%2Fbuild-core)
 
-Shared build and partial-render core for ZeroPress.
+Shared build core for ZeroPress.
 
 This package is the deterministic rendering engine used by:
 
@@ -33,7 +33,6 @@ npm install @zeropress/build-core
 ```js
 import {
   buildSite,
-  buildSelectedRoutes,
   buildSiteFromThemeDir,
   MemoryWriter,
   FilesystemWriter,
@@ -123,47 +122,6 @@ Notes:
 - `sitemap.xml` and `feed.xml` are emitted only when `site.url` is a non-empty canonical URL
 - `robots.txt` and `meta.json` are still emitted when `generateSpecialFiles` is enabled
 
-### `buildSelectedRoutes(input)`
-
-Renders only selected post and list routes while preserving full-build parity for those outputs.
-
-This is intended for targeted rebuilds, output parity checks, and other partial-render workflows.
-
-Current selection scope is limited to:
-
-- post detail routes
-- index pagination routes
-- archive routes
-- category routes
-- tag routes
-
-It does not currently support selecting individual page routes.
-
-Optional route templates are respected during both full and partial renders:
-
-- missing `archive.html` skips archive outputs
-- missing `category.html` skips category outputs
-- missing `tag.html` skips tag outputs
-- missing `404.html` skips `404.html` emission
-
-These cases do not fail the build.
-
-```js
-await buildSelectedRoutes({
-  previewData,
-  themePackage,
-  writer,
-  selection: {
-    posts: ['hello-zeropress'],
-    indexRoutes: ['/'],
-    archiveRoutes: ['/archive/'],
-    categoryRoutes: ['/categories/general/'],
-    tagRoutes: ['/tags/intro/'],
-    includeAssets: false,
-  },
-});
-```
-
 ### `buildSiteFromThemeDir(input)`
 
 Loads a theme directory from disk and renders it using the same core pipeline.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zeropress/build-core",
-  "version": "0.1.9",
-  "description": "Shared ZeroPress build and partial-render core",
+  "version": "0.1.11",
+  "description": "Shared ZeroPress build core",
   "type": "module",
   "license": "MIT",
   "exports": {
@@ -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.1",
+    "@zeropress/theme-validator": "^0.3.0",
+    "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);
   }
 
@@ -67,62 +68,6 @@ export async function buildSite(input) {
   return finalizeBuildResult(state.writer, state.summaries, options);
 }
 
-export async function buildSelectedRoutes(input) {
-  const options = { ...DEFAULT_OPTIONS, ...(input.options || {}) };
-  validateSelection(input.selection);
-
-  const state = await createBuildState(input, options);
-  const selectedPostSlugs = new Set((input.selection.posts || []).map((slug) => String(slug)));
-  const selectedIndexRoutes = new Set((input.selection.indexRoutes || []).map((route) => normalizeRoutePath(route)));
-  const selectedArchiveRoutes = new Set((input.selection.archiveRoutes || []).map((route) => normalizeRoutePath(route)));
-  const selectedCategoryRoutes = new Set((input.selection.categoryRoutes || []).map((route) => normalizeRoutePath(route)));
-  const selectedTagRoutes = new Set((input.selection.tagRoutes || []).map((route) => normalizeRoutePath(route)));
-
-  for (const post of state.renderData.posts) {
-    if (selectedPostSlugs.has(post.slug)) {
-      await renderPost(state, post);
-    }
-  }
-
-  for (const route of state.renderData.indexRoutes) {
-    if (selectedIndexRoutes.has(normalizeRoutePath(route.path))) {
-      await renderRoute(state, 'index', route);
-    }
-  }
-
-  if (hasTemplate(state, 'archive')) {
-    for (const route of state.renderData.archiveRoutes) {
-      if (selectedArchiveRoutes.has(normalizeRoutePath(route.path))) {
-        await renderRoute(state, 'archive', route);
-      }
-    }
-  }
-
-  if (hasTemplate(state, 'category')) {
-    for (const route of state.renderData.categoryRoutes) {
-      if (selectedCategoryRoutes.has(normalizeRoutePath(route.path))) {
-        await renderRoute(state, 'category', route);
-      }
-    }
-  }
-
-  if (hasTemplate(state, 'tag')) {
-    for (const route of state.renderData.tagRoutes) {
-      if (selectedTagRoutes.has(normalizeRoutePath(route.path))) {
-        await renderRoute(state, 'tag', route);
-      }
-    }
-  }
-
-  if (input.selection.includeAssets) {
-    for (const assetOutput of state.assetOutputs) {
-      await writeOutput(state.writer, state.summaries, assetOutput.path, assetOutput.content, assetOutput.contentType);
-    }
-  }
-
-  return finalizeBuildResult(state.writer, state.summaries, options);
-}
-
 async function createBuildState(input, options) {
   if (!input?.writer || typeof input.writer.write !== 'function') {
     throw new Error('buildSite requires a writer with an async write(file) method');
@@ -193,6 +138,7 @@ async function renderRoute(state, templateName, route) {
   let html = await state.engine.render(
     templateName,
     {
+      menus: state.previewData.menus,
       ...route,
       meta: buildPageMeta(state.previewData.site, {
         currentUrl,
@@ -213,6 +159,7 @@ async function renderPost(state, post) {
   let html = await state.engine.render(
     'post',
     {
+      menus: state.previewData.menus,
       post,
       meta: buildPageMeta(state.previewData.site, {
         currentUrl,
@@ -246,6 +193,7 @@ async function renderPage(state, page) {
   let html = await state.engine.render(
     'page',
     {
+      menus: state.previewData.menus,
       page,
       meta: buildPageMeta(state.previewData.site, {
         currentUrl,
@@ -275,6 +223,7 @@ async function maybeRenderNotFoundPage(state) {
   let html = await state.engine.render(
     '404',
     {
+      menus: state.previewData.menus,
       meta: buildPageMeta(state.previewData.site, {
         currentUrl: '/404.html',
         title: state.previewData.site.title,
@@ -288,23 +237,6 @@ async function maybeRenderNotFoundPage(state) {
   await writeOutput(state.writer, state.summaries, '404.html', html, 'text/html');
 }
 
-function validateSelection(selection) {
-  if (!selection || typeof selection !== 'object') {
-    throw new Error('buildSelectedRoutes requires a selection object');
-  }
-
-  const keys = ['posts', 'indexRoutes', 'archiveRoutes', 'categoryRoutes', 'tagRoutes'];
-  for (const key of keys) {
-    if (!Array.isArray(selection[key])) {
-      throw new Error(`buildSelectedRoutes selection.${key} must be an array`);
-    }
-  }
-
-  if (typeof selection.includeAssets !== 'boolean') {
-    throw new Error('buildSelectedRoutes selection.includeAssets must be a boolean');
-  }
-}
-
 function normalizePreviewData(previewData) {
   const normalizedSite = {
     ...previewData.site,
@@ -324,12 +256,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 +279,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 +299,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 +352,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 +732,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: {
@@ -8,10 +8,14 @@ export interface ThemePackage {
     description?: string;
     thumbnail?: string;
     settings?: Record<string, unknown>;
+    menuSlots?: Record<string, {
+      title: string;
+      description?: string;
+    }>;
     namespace?: string;
     slug?: string;
     license?: 'MIT' | 'Apache-2.0' | 'BSD-3-Clause' | 'GPL-3.0-only' | 'GPL-3.0-or-later';
-    runtime?: '0.2';
+    runtime?: '0.3';
   };
   templates: Map<string, string>;
   partials: Map<string, string>;
@@ -35,15 +39,6 @@ export interface BuildOptions {
   writeManifest?: boolean;
 }
 
-export interface BuildSelection {
-  posts: string[];
-  indexRoutes: string[];
-  archiveRoutes: string[];
-  categoryRoutes: string[];
-  tagRoutes: string[];
-  includeAssets: boolean;
-}
-
 export interface BuildSummaryFile {
   path: string;
   contentType: string;
@@ -62,22 +57,14 @@ export interface BuildSiteResult {
 }
 
 export function buildSite(input: {
-  previewData: PreviewDataV04;
-  themePackage: ThemePackage;
-  writer: BuildWriter;
-  options?: BuildOptions;
-}): Promise<BuildSiteResult>;
-
-export function buildSelectedRoutes(input: {
-  previewData: PreviewDataV04;
+  previewData: PreviewDataV05;
   themePackage: ThemePackage;
   writer: BuildWriter;
-  selection: BuildSelection;
   options?: BuildOptions;
 }): Promise<BuildSiteResult>;
 
 export function buildSiteFromThemeDir(input: {
-  previewData: PreviewDataV04;
+  previewData: PreviewDataV05;
   themeDir: string;
   writer: BuildWriter;
   options?: BuildOptions;

package/src/index.js

@@ -1,5 +1,4 @@
 export { buildSite } from './api/build-site.js';
-export { buildSelectedRoutes } from './api/build-site.js';
 export { buildSiteFromThemeDir } from './api/build-site-from-theme-dir.js';
 export { MemoryWriter } from './output/memory-writer.js';
 export { FilesystemWriter } from './output/filesystem-writer.js';

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, '');
+}

package/src/render/variable-resolver.js

@@ -1,17 +1,15 @@
 export class VariableResolver {
-  static VARIABLE_PATTERN = /\{\{([a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*)\}\}/g;
+  static MENU_PATTERN = /\{\{menu:([a-z][a-z0-9_-]{0,63})\}\}/g;
+  static VARIABLE_PATTERN = /\{\{([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)+)\}\}/g;
   static STANDALONE_PATTERN = /\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g;
 
   resolve(template, data) {
-    let result = template.replace(VariableResolver.VARIABLE_PATTERN, (_, variablePath) => {
-      const [prefix, field] = variablePath.split('.');
-      const prefixData = data[prefix];
-
-      if (!prefixData || typeof prefixData !== 'object') {
-        return '';
-      }
+    let result = template.replace(VariableResolver.MENU_PATTERN, (_, menuId) => {
+      return this.renderMenu(data?.menus?.[menuId]);
+    });
 
-      const value = prefixData[field];
+    result = result.replace(VariableResolver.VARIABLE_PATTERN, (_, variablePath) => {
+      const value = this.resolvePath(data, variablePath);
       return value == null ? '' : String(value);
     });
 
@@ -26,4 +24,51 @@ export class VariableResolver {
 
     return result;
   }
+
+  resolvePath(data, variablePath) {
+    const segments = variablePath.split('.');
+    let current = data;
+
+    for (const segment of segments) {
+      if (current == null || typeof current !== 'object') {
+        return undefined;
+      }
+
+      current = current[segment];
+    }
+
+    return current;
+  }
+
+  renderMenu(menu) {
+    if (!menu || !Array.isArray(menu.items) || menu.items.length === 0) {
+      return '';
+    }
+
+    return `<ul>${menu.items.map((item) => this.renderMenuItem(item)).join('')}</ul>`;
+  }
+
+  renderMenuItem(item) {
+    if (!item || typeof item !== 'object') {
+      return '';
+    }
+
+    const title = this.escapeHtml(String(item.title || ''));
+    const url = this.escapeHtml(String(item.url || ''));
+    const target = item.target === '_blank' ? '_blank' : '_self';
+    const rel = target === '_blank' ? ' rel="noreferrer noopener"' : '';
+    const children = Array.isArray(item.children) && item.children.length > 0
+      ? `<ul>${item.children.map((child) => this.renderMenuItem(child)).join('')}</ul>`
+      : '';
+
+    return `<li><a href="${url}" target="${target}"${rel}>${title}</a>${children}</li>`;
+  }
+
+  escapeHtml(value) {
+    return value
+      .replaceAll('&', '&amp;')
+      .replaceAll('<', '&lt;')
+      .replaceAll('>', '&gt;')
+      .replaceAll('"', '&quot;');
+  }
 }