@zeropress/build-core 0.1.14 → 0.1.16

package/src/index.d.ts

@@ -1,25 +1,10 @@
 import type { PreviewDataV05 } from '@zeropress/preview-data-validator';
+import type { ThemeManifest } from '@zeropress/theme-validator';
 
 export interface ThemePackage {
-  metadata: {
-    name: string;
-    version: string;
-    author?: string | null;
-    description?: string;
+  metadata: ThemeManifest & {
     thumbnail?: string;
     settings?: Record<string, unknown>;
-    menuSlots?: Record<string, {
-      title: string;
-      description?: string;
-    }>;
-    widgetAreas?: 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.3';
   };
   templates: Map<string, string>;
   partials: Map<string, string>;
@@ -39,7 +24,6 @@ export interface BuildWriter {
 export interface BuildOptions {
   assetHashing?: boolean;
   generateSpecialFiles?: boolean;
-  injectHtmx?: boolean;
   writeManifest?: boolean;
 }
 

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

@@ -0,0 +1,221 @@
+function isWhitespace(value) {
+  return /^[\s\r\n\t]*$/.test(value);
+}
+
+export class ControlFlowRenderer {
+  constructor(options = {}) {
+    this.resolvePath = typeof options.resolvePath === 'function'
+      ? options.resolvePath
+      : ((data, path) => path.split('.').reduce((current, segment) => {
+        if (current == null || typeof current !== 'object') {
+          return undefined;
+        }
+        return current[segment];
+      }, data));
+    this.renderText = typeof options.renderText === 'function'
+      ? options.renderText
+      : ((value) => value);
+  }
+
+  render(template, data, renderOptions = {}) {
+    const nodes = this.parse(template);
+    return this.renderNodes(nodes, data, renderOptions);
+  }
+
+  parse(template) {
+    const source = String(template || '');
+    const { nodes, nextIndex, stopTag } = this.parseNodes(source, 0, new Set());
+    if (stopTag) {
+      throw new Error(`Unexpected closing tag ${stopTag}`);
+    }
+    if (nextIndex !== source.length) {
+      throw new Error('Unexpected parser termination');
+    }
+    return nodes;
+  }
+
+  parseNodes(source, startIndex, stopTags) {
+    const nodes = [];
+    let index = startIndex;
+
+    while (index < source.length) {
+      const nextDelimiter = source.indexOf('{{', index);
+      if (nextDelimiter === -1) {
+        nodes.push({ type: 'text', value: source.slice(index) });
+        return { nodes, nextIndex: source.length, stopTag: null };
+      }
+
+      if (nextDelimiter > index) {
+        nodes.push({ type: 'text', value: source.slice(index, nextDelimiter) });
+      }
+
+      if (source.startsWith('{{!--', nextDelimiter)) {
+        const end = source.indexOf('--}}', nextDelimiter + 5);
+        if (end === -1) {
+          throw new Error('Unclosed block comment');
+        }
+        const commentBody = source.slice(nextDelimiter + 5, end);
+        if (commentBody.includes('{{!--')) {
+          throw new Error('Nested block comments are not allowed');
+        }
+        index = end + 4;
+        continue;
+      }
+
+      if (source.startsWith('{{!', nextDelimiter)) {
+        const end = source.indexOf('}}', nextDelimiter + 3);
+        if (end === -1) {
+          throw new Error('Unclosed inline comment');
+        }
+        index = end + 2;
+        continue;
+      }
+
+      const tokenEnd = source.indexOf('}}', nextDelimiter + 2);
+      if (tokenEnd === -1) {
+        throw new Error('Unclosed template tag');
+      }
+
+      const rawToken = source.slice(nextDelimiter, tokenEnd + 2);
+      const token = source.slice(nextDelimiter + 2, tokenEnd).trim();
+
+      if (token.startsWith('/')) {
+        const tagName = token.slice(1).trim();
+        if (!stopTags.has(tagName)) {
+          throw new Error(`Unexpected closing tag /${tagName}`);
+        }
+        return { nodes, nextIndex: tokenEnd + 2, stopTag: tagName };
+      }
+
+      if (token === '#else') {
+        if (!stopTags.has('else')) {
+          throw new Error('Unexpected else tag');
+        }
+        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}`);
+        }
+        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');
+        }
+        nodes.push({ type: 'if_eq', path, literal, consequent: ifResult.nodes, alternate: elseNodes });
+        index = 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;
+        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);
+        if (!match) {
+          throw new Error(`Invalid for expression: ${expression}`);
+        }
+        const [, itemName, path] = match;
+        const forResult = this.parseNodes(source, tokenEnd + 2, new Set(['for']));
+        if (forResult.stopTag !== 'for') {
+          throw new Error('Unclosed for block');
+        }
+        nodes.push({ type: 'for', itemName, path, body: forResult.nodes });
+        index = forResult.nextIndex;
+        continue;
+      }
+
+      nodes.push({ type: 'text', value: rawToken });
+      index = tokenEnd + 2;
+    }
+
+    if (stopTags.size > 0) {
+      const expected = Array.from(stopTags).filter((entry) => entry !== 'else').join(', ');
+      throw new Error(`Missing closing tag for ${expected}`);
+    }
+
+    return { nodes, nextIndex: source.length, stopTag: null };
+  }
+
+  renderNodes(nodes, data, renderOptions) {
+    return nodes.map((node) => this.renderNode(node, data, renderOptions)).join('');
+  }
+
+  renderNode(node, data, renderOptions) {
+    switch (node.type) {
+      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)
+          : 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)
+          : this.renderNodes(node.alternate, data, renderOptions);
+      }
+      case 'for': {
+        const items = this.resolvePath(data, node.path);
+        if (!Array.isArray(items) || items.length === 0) {
+          return '';
+        }
+        return items
+          .map((item, index) => this.renderNodes(node.body, {
+            ...data,
+            [node.itemName]: item,
+            $index: index,
+          }, renderOptions))
+          .join('');
+      }
+      default:
+        return '';
+    }
+  }
+
+  isTruthy(value) {
+    if (Array.isArray(value)) {
+      return value.length > 0;
+    }
+    if (typeof value === 'string') {
+      return value.length > 0;
+    }
+    return Boolean(value);
+  }
+}

package/src/render/partial-resolver.js

@@ -0,0 +1,23 @@
+export class PartialResolver {
+  static PARTIAL_PATTERN = /\{\{partial:([a-zA-Z_][a-zA-Z0-9_-]*(?:\/[a-zA-Z_][a-zA-Z0-9_-]*)*)\}\}/g;
+
+  resolve(template, partials) {
+    return this.resolveTemplate(String(template || ''), partials, []);
+  }
+
+  resolveTemplate(template, partials, activeStack) {
+    return template.replace(PartialResolver.PARTIAL_PATTERN, (_, partialName) => {
+      if (!partials.has(partialName)) {
+        throw new Error(`Partial "${partialName}" not found`);
+      }
+
+      if (activeStack.includes(partialName)) {
+        const cycle = [...activeStack, partialName].join(' -> ');
+        throw new Error(`Circular partial reference detected: ${cycle}`);
+      }
+
+      const partialContent = partials.get(partialName);
+      return this.resolveTemplate(String(partialContent || ''), partials, [...activeStack, partialName]);
+    });
+  }
+}

package/src/render/variable-resolver.js

@@ -3,14 +3,14 @@ export class VariableResolver {
   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) {
+  resolve(template, data, options = {}) {
     let result = template.replace(VariableResolver.MENU_PATTERN, (_, menuId) => {
       return this.renderMenu(data?.menus?.[menuId]);
     });
 
     result = result.replace(VariableResolver.VARIABLE_PATTERN, (_, variablePath) => {
       const value = this.resolvePath(data, variablePath);
-      return value == null ? '' : String(value);
+      return this.renderValue(value, variablePath, options);
     });
 
     result = result.replace(VariableResolver.STANDALONE_PATTERN, (match, variableName) => {
@@ -19,7 +19,7 @@ export class VariableResolver {
       }
 
       const value = data[variableName];
-      return value == null ? '' : String(value);
+      return this.renderValue(value, variableName, options);
     });
 
     return result;
@@ -64,11 +64,54 @@ export class VariableResolver {
     return `<li><a href="${url}" target="${target}"${rel}>${title}</a>${children}</li>`;
   }
 
+  renderValue(value, variablePath, options = {}) {
+    if (value == null) {
+      return '';
+    }
+
+    const stringValue = String(value);
+    if (options.escapeValues !== true) {
+      return stringValue;
+    }
+
+    if (this.shouldRenderRaw(variablePath, options)) {
+      return stringValue;
+    }
+
+    return this.escapeHtml(stringValue);
+  }
+
+  shouldRenderRaw(variablePath, options = {}) {
+    if (options.rawPaths instanceof Set && options.rawPaths.has(variablePath)) {
+      return true;
+    }
+
+    if (options.rawPathPrefixes instanceof Set) {
+      for (const prefix of options.rawPathPrefixes) {
+        if (variablePath === prefix || variablePath.startsWith(`${prefix}.`)) {
+          return true;
+        }
+      }
+    }
+
+    const lastSegment = variablePath.split('.').pop();
+    if (lastSegment === 'html' || lastSegment?.endsWith('_html')) {
+      return true;
+    }
+
+    if (lastSegment?.endsWith('_url')) {
+      return true;
+    }
+
+    return false;
+  }
+
   escapeHtml(value) {
     return value
       .replaceAll('&', '&amp;')
       .replaceAll('<', '&lt;')
       .replaceAll('>', '&gt;')
-      .replaceAll('"', '&quot;');
+      .replaceAll('"', '&quot;')
+      .replaceAll("'", '&#39;');
   }
 }

package/src/render/zeropress-engine.js

@@ -1,10 +1,17 @@
 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';
 
 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),
+      renderText: (value, data, renderOptions) => this.variableResolver.resolve(value, data, renderOptions),
+    });
     this.themePackage = null;
   }
 
@@ -27,9 +34,10 @@ export class ZeroPressEngine {
       throw new Error('Template "layout" not found');
     }
 
-    const renderedContent = this.variableResolver.resolve(template, this.combineRenderData(data, context));
+    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.variableResolver.resolve(layoutWithSlots, this.combineRenderData(data, context));
+    return this.renderTemplate(this.expandPartials(layoutWithSlots), renderData);
   }
 
   combineRenderData(data, context) {
@@ -40,4 +48,24 @@ export class ZeroPressEngine {
       language: context.language,
     };
   }
+
+  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;
+    }
+
+    return this.partialResolver.resolve(template, this.themePackage.partials);
+  }
 }

package/src/theme/load-theme-dir.js

@@ -16,6 +16,10 @@ export async function loadThemePackageFromDir(themeDir) {
 
   const rawThemeJson = String(fileMap.get('theme.json'));
   const themeJson = JSON.parse(rawThemeJson);
+  const manifest = validation.manifest;
+  if (!manifest) {
+    throw new Error('Theme validation failed: normalized manifest not available');
+  }
   const templates = new Map();
   const partials = new Map();
   const assets = new Map();
@@ -45,18 +49,9 @@ export async function loadThemePackageFromDir(themeDir) {
 
   return {
     metadata: {
-      name: themeJson.name,
-      version: themeJson.version,
-      author: themeJson.author,
-      description: themeJson.description,
+      ...manifest,
       thumbnail: themeJson.thumbnail,
       settings: themeJson.settings || {},
-      menuSlots: themeJson.menuSlots,
-      widgetAreas: themeJson.widgetAreas,
-      namespace: themeJson.namespace,
-      slug: themeJson.slug,
-      license: themeJson.license,
-      runtime: themeJson.runtime,
     },
     templates,
     partials,