@zeropress/build-core 0.1.16 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeropress/build-core",
-  "version": "0.1.16",
+  "version": "0.2.1",
   "description": "Shared ZeroPress build core",
   "type": "module",
   "license": "MIT",
@@ -35,7 +35,7 @@
   "dependencies": {
     "@zeropress/slug-policy": "^0.1.0",
     "@zeropress/preview-data-validator": "^0.4.4",
-    "@zeropress/theme-validator": "^0.4.0",
+    "@zeropress/theme-validator": "^0.5.0",
     "highlight.js": "^11.11.1",
     "markdown-it": "^14.1.0",
     "markdown-it-anchor": "^9.2.0"

package/src/api/build-site.js

@@ -846,9 +846,71 @@ function buildStructuredPagination(paginationData) {
       url: page.url,
       current: page.current,
     })),
+    window: buildPaginationWindow(paginationData),
   };
 }
 
+function buildPaginationWindow(paginationData) {
+  const totalPages = paginationData.totalPages;
+  if (!Number.isInteger(totalPages) || totalPages <= 0) {
+    return [];
+  }
+
+  const currentPage = paginationData.currentPage;
+  const pageMap = new Map(
+    paginationData.pages.map((page) => [page.number, {
+      kind: 'page',
+      number: page.number,
+      url: page.url,
+      current: page.current,
+    }]),
+  );
+
+  if (totalPages <= 7) {
+    return paginationData.pages.map((page) => ({
+      kind: 'page',
+      number: page.number,
+      url: page.url,
+      current: page.current,
+    }));
+  }
+
+  const pageNumbers = new Set([1, totalPages, currentPage - 1, currentPage, currentPage + 1]);
+
+  if (currentPage <= 4) {
+    for (let number = 1; number <= 5; number += 1) {
+      pageNumbers.add(number);
+    }
+  }
+
+  if (currentPage >= totalPages - 3) {
+    for (let number = totalPages - 4; number <= totalPages; number += 1) {
+      pageNumbers.add(number);
+    }
+  }
+
+  const orderedNumbers = Array.from(pageNumbers)
+    .filter((number) => Number.isInteger(number) && number >= 1 && number <= totalPages)
+    .sort((left, right) => left - right);
+
+  const windowItems = [];
+  let previousNumber = null;
+
+  for (const number of orderedNumbers) {
+    if (previousNumber != null && number - previousNumber > 1) {
+      windowItems.push({ kind: 'gap' });
+    }
+
+    const pageItem = pageMap.get(number);
+    if (pageItem) {
+      windowItems.push(pageItem);
+    }
+    previousNumber = number;
+  }
+
+  return windowItems;
+}
+
 function buildStructuredPostItems(posts, postBySlug) {
   return posts
     .map((post) => postBySlug.get(post.slug))

package/src/render/control-flow-renderer.js

@@ -1,6 +1,8 @@
-function isWhitespace(value) {
-  return /^[\s\r\n\t]*$/.test(value);
-}
+import { parsePartialToken } from './partial-resolver.js';
+
+const PATH_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
+const FOR_EXPRESSION_REGEX = /^([a-zA-Z_][a-zA-Z0-9_]*)\s+in\s+([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)$/;
+const IF_EQ_EXPRESSION_REGEX = /^([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)\s+("(?:[^"\\]|\\.)*")$/;
 
 export class ControlFlowRenderer {
   constructor(options = {}) {
@@ -18,6 +20,13 @@ export class ControlFlowRenderer {
   }
 
   render(template, data, renderOptions = {}) {
+    return this.renderTemplate(template, data, {
+      ...renderOptions,
+      partialStack: Array.isArray(renderOptions.partialStack) ? renderOptions.partialStack : [],
+    });
+  }
+
+  renderTemplate(template, data, renderOptions) {
     const nodes = this.parse(template);
     return this.renderNodes(nodes, data, renderOptions);
   }
@@ -94,58 +103,46 @@ export class ControlFlowRenderer {
         return { nodes, nextIndex: tokenEnd + 2, stopTag: 'else' };
       }
 
-      if (token.startsWith('#if_eq ')) {
-        const expression = token.slice('#if_eq '.length).trim();
-        const match = /^([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)\s+("(?:[^"\\]|\\.)*")$/.exec(expression);
-        if (!match) {
-          throw new Error(`Invalid if_eq expression: ${expression}`);
+      if (token.startsWith('#else_if_eq ')) {
+        if (!stopTags.has('else_if_eq')) {
+          throw new Error('Unexpected else_if_eq tag');
         }
-        const [, path, literalSource] = match;
-        const literal = JSON.parse(literalSource);
-        const ifResult = this.parseNodes(source, tokenEnd + 2, new Set(['else', 'if_eq']));
-        let elseNodes = [];
-        let nextIndex = ifResult.nextIndex;
-        if (ifResult.stopTag === 'else') {
-          const elseResult = this.parseNodes(source, ifResult.nextIndex, new Set(['if_eq']));
-          if (elseResult.stopTag !== 'if_eq') {
-            throw new Error('Unclosed if_eq block after else');
-          }
-          elseNodes = elseResult.nodes;
-          nextIndex = elseResult.nextIndex;
-        } else if (ifResult.stopTag !== 'if_eq') {
-          throw new Error('Unclosed if_eq block');
+        return { nodes, nextIndex: tokenEnd + 2, stopTag: token };
+      }
+
+      if (token.startsWith('#else_if ')) {
+        if (!stopTags.has('else_if')) {
+          throw new Error('Unexpected else_if tag');
         }
-        nodes.push({ type: 'if_eq', path, literal, consequent: ifResult.nodes, alternate: elseNodes });
-        index = nextIndex;
+        return { nodes, nextIndex: tokenEnd + 2, stopTag: token };
+      }
+
+      if (token.startsWith('partial:')) {
+        const { name, args } = parsePartialToken(token);
+        nodes.push({ type: 'partial', name, args });
+        index = tokenEnd + 2;
+        continue;
+      }
+
+      if (token.startsWith('#if_eq ')) {
+        const expression = token.slice('#if_eq '.length).trim();
+        const block = this.parseIfEqBlock(source, tokenEnd + 2, expression);
+        nodes.push(block.node);
+        index = block.nextIndex;
         continue;
       }
 
       if (token.startsWith('#if ')) {
-        const path = token.slice('#if '.length).trim();
-        if (!/^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/.test(path)) {
-          throw new Error(`Invalid if expression: ${path}`);
-        }
-        const ifResult = this.parseNodes(source, tokenEnd + 2, new Set(['else', 'if']));
-        let elseNodes = [];
-        let nextIndex = ifResult.nextIndex;
-        if (ifResult.stopTag === 'else') {
-          const elseResult = this.parseNodes(source, ifResult.nextIndex, new Set(['if']));
-          if (elseResult.stopTag !== 'if') {
-            throw new Error('Unclosed if block after else');
-          }
-          elseNodes = elseResult.nodes;
-          nextIndex = elseResult.nextIndex;
-        } else if (ifResult.stopTag !== 'if') {
-          throw new Error('Unclosed if block');
-        }
-        nodes.push({ type: 'if', path, consequent: ifResult.nodes, alternate: elseNodes });
-        index = nextIndex;
+        const expression = token.slice('#if '.length).trim();
+        const block = this.parseIfBlock(source, tokenEnd + 2, expression);
+        nodes.push(block.node);
+        index = block.nextIndex;
         continue;
       }
 
       if (token.startsWith('#for ')) {
         const expression = token.slice('#for '.length).trim();
-        const match = /^([a-zA-Z_][a-zA-Z0-9_]*)\s+in\s+([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)$/.exec(expression);
+        const match = FOR_EXPRESSION_REGEX.exec(expression);
         if (!match) {
           throw new Error(`Invalid for expression: ${expression}`);
         }
@@ -164,13 +161,132 @@ export class ControlFlowRenderer {
     }
 
     if (stopTags.size > 0) {
-      const expected = Array.from(stopTags).filter((entry) => entry !== 'else').join(', ');
+      const expected = Array.from(stopTags).join(', ');
       throw new Error(`Missing closing tag for ${expected}`);
     }
 
     return { nodes, nextIndex: source.length, stopTag: null };
   }
 
+  parseIfBlock(source, startIndex, initialPath) {
+    if (!PATH_REGEX.test(initialPath)) {
+      throw new Error(`Invalid if expression: ${initialPath}`);
+    }
+
+    const branches = [];
+    let alternate = [];
+    let nextIndex = startIndex;
+    let currentPath = initialPath;
+
+    while (true) {
+      const branchResult = this.parseNodes(source, nextIndex, new Set(['else', 'else_if', 'if']));
+      branches.push({
+        path: currentPath,
+        consequent: branchResult.nodes,
+      });
+
+      if (branchResult.stopTag === 'else') {
+        const elseResult = this.parseNodes(source, branchResult.nextIndex, new Set(['if']));
+        if (elseResult.stopTag !== 'if') {
+          throw new Error('Unclosed if block after else');
+        }
+        alternate = elseResult.nodes;
+        nextIndex = elseResult.nextIndex;
+        break;
+      }
+
+      if (typeof branchResult.stopTag === 'string' && branchResult.stopTag.startsWith('#else_if ')) {
+        currentPath = branchResult.stopTag.slice('#else_if '.length).trim();
+        if (!PATH_REGEX.test(currentPath)) {
+          throw new Error(`Invalid else_if expression: ${currentPath}`);
+        }
+        nextIndex = branchResult.nextIndex;
+        continue;
+      }
+
+      if (branchResult.stopTag === 'if') {
+        nextIndex = branchResult.nextIndex;
+        break;
+      }
+
+      throw new Error('Unclosed if block');
+    }
+
+    return {
+      node: {
+        type: 'if',
+        branches,
+        alternate,
+      },
+      nextIndex,
+    };
+  }
+
+  parseIfEqBlock(source, startIndex, expression) {
+    const initialBranch = this.parseIfEqBranchExpression(expression, 'if_eq');
+    const branches = [];
+    let alternate = [];
+    let nextIndex = startIndex;
+    let currentBranch = initialBranch;
+
+    while (true) {
+      const branchResult = this.parseNodes(source, nextIndex, new Set(['else', 'else_if_eq', 'if_eq']));
+      branches.push({
+        path: currentBranch.path,
+        literal: currentBranch.literal,
+        consequent: branchResult.nodes,
+      });
+
+      if (branchResult.stopTag === 'else') {
+        const elseResult = this.parseNodes(source, branchResult.nextIndex, new Set(['if_eq']));
+        if (elseResult.stopTag !== 'if_eq') {
+          throw new Error('Unclosed if_eq block after else');
+        }
+        alternate = elseResult.nodes;
+        nextIndex = elseResult.nextIndex;
+        break;
+      }
+
+      if (typeof branchResult.stopTag === 'string' && branchResult.stopTag.startsWith('#else_if_eq ')) {
+        currentBranch = this.parseIfEqBranchExpression(
+          branchResult.stopTag.slice('#else_if_eq '.length).trim(),
+          'else_if_eq',
+        );
+        nextIndex = branchResult.nextIndex;
+        continue;
+      }
+
+      if (branchResult.stopTag === 'if_eq') {
+        nextIndex = branchResult.nextIndex;
+        break;
+      }
+
+      throw new Error('Unclosed if_eq block');
+    }
+
+    return {
+      node: {
+        type: 'if_eq',
+        branches,
+        alternate,
+      },
+      nextIndex,
+    };
+  }
+
+  parseIfEqBranchExpression(expression, tagName) {
+    const match = IF_EQ_EXPRESSION_REGEX.exec(expression);
+    if (!match) {
+      throw new Error(`Invalid ${tagName} expression: ${expression}`);
+    }
+
+    const [, path, literalSource] = match;
+    return {
+      path,
+      literal: JSON.parse(literalSource),
+    };
+  }
+
   renderNodes(nodes, data, renderOptions) {
     return nodes.map((node) => this.renderNode(node, data, renderOptions)).join('');
   }
@@ -180,15 +296,15 @@ export class ControlFlowRenderer {
       case 'text':
         return this.renderText(node.value, data, renderOptions);
       case 'if': {
-        const value = this.resolvePath(data, node.path);
-        return this.isTruthy(value)
-          ? this.renderNodes(node.consequent, data, renderOptions)
+        const branch = node.branches.find((entry) => this.isTruthy(this.resolvePath(data, entry.path)));
+        return branch
+          ? this.renderNodes(branch.consequent, data, renderOptions)
           : this.renderNodes(node.alternate, data, renderOptions);
       }
       case 'if_eq': {
-        const value = this.resolvePath(data, node.path);
-        return value === node.literal
-          ? this.renderNodes(node.consequent, data, renderOptions)
+        const branch = node.branches.find((entry) => this.resolvePath(data, entry.path) === entry.literal);
+        return branch
+          ? this.renderNodes(branch.consequent, data, renderOptions)
           : this.renderNodes(node.alternate, data, renderOptions);
       }
       case 'for': {
@@ -200,15 +316,45 @@ export class ControlFlowRenderer {
           .map((item, index) => this.renderNodes(node.body, {
             ...data,
             [node.itemName]: item,
-            $index: index,
+            loop: {
+              first: index === 0,
+              last: index === items.length - 1,
+              index,
+            },
           }, renderOptions))
           .join('');
       }
+      case 'partial':
+        return this.renderPartial(node, data, renderOptions);
       default:
         return '';
     }
   }
 
+  renderPartial(node, data, renderOptions) {
+    const partials = renderOptions?.partials;
+    if (!partials || !partials.has(node.name)) {
+      throw new Error(`Partial "${node.name}" not found`);
+    }
+
+    const activeStack = Array.isArray(renderOptions?.partialStack) ? renderOptions.partialStack : [];
+    if (activeStack.includes(node.name)) {
+      const cycle = [...activeStack, node.name].join(' -> ');
+      throw new Error(`Circular partial reference detected: ${cycle}`);
+    }
+
+    const partialTemplate = String(partials.get(node.name) || '');
+    const partialData = {
+      ...data,
+      partial: { ...node.args },
+    };
+
+    return this.renderTemplate(partialTemplate, partialData, {
+      ...renderOptions,
+      partialStack: [...activeStack, node.name],
+    });
+  }
+
   isTruthy(value) {
     if (Array.isArray(value)) {
       return value.length > 0;

package/src/render/partial-resolver.js

@@ -1,23 +1,114 @@
-export class PartialResolver {
-  static PARTIAL_PATTERN = /\{\{partial:([a-zA-Z_][a-zA-Z0-9_-]*(?:\/[a-zA-Z_][a-zA-Z0-9_-]*)*)\}\}/g;
+const PARTIAL_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_-]*(?:\/[a-zA-Z_][a-zA-Z0-9_-]*)*$/;
+const IDENTIFIER_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 
-  resolve(template, partials) {
-    return this.resolveTemplate(String(template || ''), partials, []);
+export function parsePartialToken(token) {
+  const source = String(token || '').trim();
+  if (!source.startsWith('partial:')) {
+    throw new Error(`Invalid partial token: ${source}`);
   }
 
-  resolveTemplate(template, partials, activeStack) {
-    return template.replace(PartialResolver.PARTIAL_PATTERN, (_, partialName) => {
-      if (!partials.has(partialName)) {
-        throw new Error(`Partial "${partialName}" not found`);
+  const expression = source.slice('partial:'.length).trim();
+  const nameMatch = /^([a-zA-Z_][a-zA-Z0-9_-]*(?:\/[a-zA-Z_][a-zA-Z0-9_-]*)*)(?:\s+|$)/.exec(expression);
+  if (!nameMatch) {
+    throw new Error(`Invalid partial reference: ${source}`);
+  }
+
+  const name = nameMatch[1];
+  if (!PARTIAL_NAME_REGEX.test(name)) {
+    throw new Error(`Invalid partial name: ${name}`);
+  }
+
+  const argsSource = expression.slice(name.length).trim();
+  const args = parsePartialArgs(argsSource);
+
+  return { name, args };
+}
+
+function parsePartialArgs(source) {
+  if (!source) {
+    return {};
+  }
+
+  const args = {};
+  let index = 0;
+
+  while (index < source.length) {
+    while (index < source.length && /\s/.test(source[index])) {
+      index += 1;
+    }
+
+    if (index >= source.length) {
+      break;
+    }
+
+    const keyMatch = /^[a-zA-Z_][a-zA-Z0-9_]*/.exec(source.slice(index));
+    if (!keyMatch) {
+      throw new Error(`Invalid partial argument syntax near "${source.slice(index)}"`);
+    }
+
+    const key = keyMatch[0];
+    if (!IDENTIFIER_REGEX.test(key)) {
+      throw new Error(`Invalid partial argument key: ${key}`);
+    }
+    if (Object.prototype.hasOwnProperty.call(args, key)) {
+      throw new Error(`Duplicate partial argument: ${key}`);
+    }
+
+    index += key.length;
+    if (source[index] !== '=') {
+      throw new Error(`Expected "=" after partial argument "${key}"`);
+    }
+    index += 1;
+
+    if (source[index] === '"') {
+      let cursor = index + 1;
+      let escaped = false;
+
+      while (cursor < source.length) {
+        const char = source[cursor];
+        if (escaped) {
+          escaped = false;
+          cursor += 1;
+          continue;
+        }
+        if (char === '\\') {
+          escaped = true;
+          cursor += 1;
+          continue;
+        }
+        if (char === '"') {
+          break;
+        }
+        cursor += 1;
       }
 
-      if (activeStack.includes(partialName)) {
-        const cycle = [...activeStack, partialName].join(' -> ');
-        throw new Error(`Circular partial reference detected: ${cycle}`);
+      if (cursor >= source.length || source[cursor] !== '"') {
+        throw new Error(`Unclosed string literal for partial argument "${key}"`);
       }
 
-      const partialContent = partials.get(partialName);
-      return this.resolveTemplate(String(partialContent || ''), partials, [...activeStack, partialName]);
-    });
+      args[key] = JSON.parse(source.slice(index, cursor + 1));
+      index = cursor + 1;
+      continue;
+    }
+
+    if (source.startsWith('true', index) && isValueBoundary(source, index + 4)) {
+      args[key] = true;
+      index += 4;
+      continue;
+    }
+
+    if (source.startsWith('false', index) && isValueBoundary(source, index + 5)) {
+      args[key] = false;
+      index += 5;
+      continue;
+    }
+
+    throw new Error(`Unsupported partial argument value for "${key}"`);
   }
+
+  return args;
+}
+
+function isValueBoundary(source, index) {
+  return index >= source.length || /\s/.test(source[index]);
 }

package/src/render/zeropress-engine.js

@@ -1,12 +1,12 @@
 import { SlotResolver } from './slot-resolver.js';
 import { VariableResolver } from './variable-resolver.js';
 import { ControlFlowRenderer } from './control-flow-renderer.js';
-import { PartialResolver } from './partial-resolver.js';
+
+const CONTENT_SLOT_PLACEHOLDER = '__ZEROPRESS_CONTENT_SLOT_4F30E5A44C1D__';
 
 export class ZeroPressEngine {
   constructor() {
     this.slotResolver = new SlotResolver();
-    this.partialResolver = new PartialResolver();
     this.variableResolver = new VariableResolver();
     this.controlFlowRenderer = new ControlFlowRenderer({
       resolvePath: (data, path) => this.variableResolver.resolvePath(data, path),
@@ -35,9 +35,9 @@ export class ZeroPressEngine {
     }
 
     const renderData = this.combineRenderData(data, context);
-    const renderedContent = this.renderTemplate(this.expandPartials(template), renderData);
-    const layoutWithSlots = this.slotResolver.resolve(layout, this.themePackage.partials, renderedContent);
-    return this.renderTemplate(this.expandPartials(layoutWithSlots), renderData);
+    const renderedContent = this.renderTemplate(template, renderData);
+    const layoutWithSlots = this.slotResolver.resolve(layout, this.themePackage.partials, CONTENT_SLOT_PLACEHOLDER);
+    return this.renderTemplate(layoutWithSlots, renderData).replaceAll(CONTENT_SLOT_PLACEHOLDER, renderedContent);
   }
 
   combineRenderData(data, context) {
@@ -50,22 +50,15 @@ export class ZeroPressEngine {
   }
 
   renderTemplate(template, data) {
-    if (this.themePackage?.metadata?.runtime === '0.4') {
-      return this.controlFlowRenderer.render(template, data, {
-        escapeValues: true,
-        rawPaths: new Set(['meta.head_tags']),
-        rawPathPrefixes: new Set(['meta']),
-      });
-    }
-
-    return this.variableResolver.resolve(template, data);
-  }
-
-  expandPartials(template) {
-    if (this.themePackage?.metadata?.runtime !== '0.4') {
-      return template;
+    if (this.themePackage?.metadata?.runtime !== '0.5') {
+      throw new Error(`Unsupported theme runtime: ${this.themePackage?.metadata?.runtime || 'unknown'}`);
     }
 
-    return this.partialResolver.resolve(template, this.themePackage.partials);
+    return this.controlFlowRenderer.render(template, data, {
+      escapeValues: true,
+      rawPaths: new Set(['meta.head_tags']),
+      rawPathPrefixes: new Set(['meta']),
+      partials: this.themePackage.partials,
+    });
   }
 }