@zenithbuild/cli 0.6.6 → 0.6.9

package/dist/resolve-components.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Walk `srcDir/components/` recursively. Return Map<PascalName, absPath>.
+ * Errors on duplicate component names within the registry.
+ *
+ * Also scans `srcDir/layouts/` for layout components (Document Mode).
+ *
+ * @param {string} srcDir — absolute path to the project's `src/` directory
+ * @returns {Map<string, string>}
+ */
+export function buildComponentRegistry(srcDir: string): Map<string, string>;
+/**
+ * Strip all <script ...>...</script> and <style ...>...</style> blocks
+ * from a .zen source. Return template-only markup.
+ *
+ * @param {string} zenSource
+ * @returns {string}
+ */
+export function extractTemplate(zenSource: string): string;
+/**
+ * Returns true if the template contains <!doctype or <html,
+ * indicating it's a Document Mode component (layout wrapper).
+ *
+ * @param {string} template
+ * @returns {boolean}
+ */
+export function isDocumentMode(template: string): boolean;
+/**
+ * Recursively expand PascalCase component tags in `source`.
+ *
+ * @param {string} source — page or component template source
+ * @param {Map<string, string>} registry — component name → .zen file path
+ * @param {string} sourceFile — source file path (for error messages)
+ * @param {Set<string>} [visited] — cycle detection set
+ * @returns {{ expandedSource: string, usedComponents: string[] }}
+ */
+export function expandComponents(source: string, registry: Map<string, string>, sourceFile: string, visited?: Set<string>): {
+    expandedSource: string;
+    usedComponents: string[];
+};

package/dist/resolve-components.js

@@ -8,14 +8,11 @@
 // Pipeline:
 //   buildComponentRegistry() → expandComponents() → expanded source string
 // ---------------------------------------------------------------------------
-
 import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { basename, extname, join } from 'node:path';
-
 // ---------------------------------------------------------------------------
 // Registry: Map<PascalCaseName, absolutePath>
 // ---------------------------------------------------------------------------
-
 /**
  * Walk `srcDir/components/` recursively. Return Map<PascalName, absPath>.
  * Errors on duplicate component names within the registry.
@@ -28,21 +25,19 @@ import { basename, extname, join } from 'node:path';
 export function buildComponentRegistry(srcDir) {
     /** @type {Map<string, string>} */
     const registry = new Map();
-
     const scanDirs = ['components', 'layouts', 'globals'];
     for (const sub of scanDirs) {
         const dir = join(srcDir, sub);
         try {
             statSync(dir);
-        } catch {
+        }
+        catch {
             continue; // Directory doesn't exist, skip
         }
         walkDir(dir, registry);
     }
-
     return registry;
 }
-
 /**
  * @param {string} dir
  * @param {Map<string, string>} registry
@@ -51,11 +46,11 @@ function walkDir(dir, registry) {
     let entries;
     try {
         entries = readdirSync(dir);
-    } catch {
+    }
+    catch {
         return;
     }
     entries.sort();
-
     for (const name of entries) {
         const fullPath = join(dir, name);
         const info = statSync(fullPath);
@@ -63,28 +58,24 @@ function walkDir(dir, registry) {
             walkDir(fullPath, registry);
             continue;
         }
-        if (extname(name) !== '.zen') continue;
-
+        if (extname(name) !== '.zen')
+            continue;
         const componentName = basename(name, '.zen');
         // Only register PascalCase names (first char uppercase)
-        if (!/^[A-Z]/.test(componentName)) continue;
-
+        if (!/^[A-Z]/.test(componentName))
+            continue;
         if (registry.has(componentName)) {
-            throw new Error(
-                `Duplicate component name "${componentName}":\n` +
+            throw new Error(`Duplicate component name "${componentName}":\n` +
                 `  1) ${registry.get(componentName)}\n` +
                 `  2) ${fullPath}\n` +
-                `Rename one to resolve the conflict.`
-            );
+                `Rename one to resolve the conflict.`);
         }
         registry.set(componentName, fullPath);
     }
 }
-
 // ---------------------------------------------------------------------------
 // Template extraction
 // ---------------------------------------------------------------------------
-
 /**
  * Strip all <script ...>...</script> and <style ...>...</style> blocks
  * from a .zen source. Return template-only markup.
@@ -95,15 +86,12 @@ function walkDir(dir, registry) {
 export function extractTemplate(zenSource) {
     // Remove <script ...>...</script> blocks (greedy matching for nested content)
     let template = zenSource;
-
     // Strip script blocks (handles <script>, <script lang="ts">, etc.)
     template = stripBlock(template, 'script');
     // Strip style blocks
     template = stripBlock(template, 'style');
-
     return template.trim();
 }
-
 /**
  * Strip a matched pair of <tag ...>...</tag> from source.
  * Handles multiple occurrences and attributes on the opening tag.
@@ -116,19 +104,15 @@ function stripBlock(source, tag) {
     // Use a regex that matches <tag ...>...</tag> including multiline content
     // We need a non-greedy approach for nested scenarios, but script/style
     // blocks cannot be nested in HTML, so we can match the first closing tag.
-    const re = new RegExp(
-        `<${tag}(?:\\s[^>]*)?>` +    // opening tag with optional attributes
-        `[\\s\\S]*?` +                // content (non-greedy)
-        `</${tag}>`,                   // closing tag
-        'gi'
-    );
+    const re = new RegExp(`<${tag}(?:\\s[^>]*)?>` + // opening tag with optional attributes
+        `[\\s\\S]*?` + // content (non-greedy)
+        `</${tag}>`, // closing tag
+    'gi');
     return source.replace(re, '');
 }
-
 // ---------------------------------------------------------------------------
 // Document Mode detection
 // ---------------------------------------------------------------------------
-
 /**
  * Returns true if the template contains <!doctype or <html,
  * indicating it's a Document Mode component (layout wrapper).
@@ -140,13 +124,10 @@ export function isDocumentMode(template) {
     const lower = template.toLowerCase();
     return lower.includes('<!doctype') || lower.includes('<html');
 }
-
 // ---------------------------------------------------------------------------
 // Component expansion
 // ---------------------------------------------------------------------------
-
 const OPEN_COMPONENT_TAG_RE = /<([A-Z][a-zA-Z0-9]*)(\s[^<>]*?)?\s*(\/?)>/g;
-
 /**
  * Recursively expand PascalCase component tags in `source`.
  *
@@ -160,7 +141,6 @@ export function expandComponents(source, registry, sourceFile, visited) {
     if (visited && visited.size > 0) {
         throw new Error('expandComponents() does not accept a pre-populated visited set');
     }
-
     const usedComponents = [];
     const expandedSource = expandSource(source, registry, sourceFile, [], usedComponents);
     return {
@@ -168,7 +148,6 @@ export function expandComponents(source, registry, sourceFile, visited) {
         usedComponents: [...new Set(usedComponents)],
     };
 }
-
 /**
  * Expand component tags recursively.
  *
@@ -183,51 +162,27 @@ function expandSource(source, registry, sourceFile, chain, usedComponents) {
     let output = source;
     let iterations = 0;
     const MAX_ITERATIONS = 10_000;
-
     while (iterations < MAX_ITERATIONS) {
         iterations += 1;
         const tag = findNextKnownTag(output, registry, 0);
         if (!tag) {
             return output;
         }
-
         let children = '';
         let replaceEnd = tag.end;
-
         if (!tag.selfClosing) {
             const close = findMatchingClose(output, tag.name, tag.end);
             if (!close) {
-                throw new Error(
-                    `Unclosed component tag <${tag.name}> in ${sourceFile} at offset ${tag.start}`
-                );
+                throw new Error(`Unclosed component tag <${tag.name}> in ${sourceFile} at offset ${tag.start}`);
             }
-            children = expandSource(
-                output.slice(tag.end, close.contentEnd),
-                registry,
-                sourceFile,
-                chain,
-                usedComponents
-            );
+            children = expandSource(output.slice(tag.end, close.contentEnd), registry, sourceFile, chain, usedComponents);
             replaceEnd = close.tagEnd;
         }
-
-        const replacement = expandTag(
-            tag.name,
-            children,
-            registry,
-            sourceFile,
-            chain,
-            usedComponents
-        );
-
+        const replacement = expandTag(tag.name, children, registry, sourceFile, chain, usedComponents);
         output = output.slice(0, tag.start) + replacement + output.slice(replaceEnd);
     }
-
-    throw new Error(
-        `Component expansion exceeded ${MAX_ITERATIONS} replacements in ${sourceFile}.`
-    );
+    throw new Error(`Component expansion exceeded ${MAX_ITERATIONS} replacements in ${sourceFile}.`);
 }
-
 /**
  * Find the next component opening tag that exists in the registry.
  *
@@ -238,7 +193,6 @@ function expandSource(source, registry, sourceFile, chain, usedComponents) {
  */
 function findNextKnownTag(source, registry, startIndex) {
     OPEN_COMPONENT_TAG_RE.lastIndex = startIndex;
-
     let match;
     while ((match = OPEN_COMPONENT_TAG_RE.exec(source)) !== null) {
         const name = match[1];
@@ -255,10 +209,8 @@ function findNextKnownTag(source, registry, startIndex) {
             selfClosing: match[3] === '/',
         };
     }
-
     return null;
 }
-
 /**
  * Detect whether `index` is inside a `{ ... }` expression scope.
  *
@@ -274,7 +226,6 @@ function isInsideExpressionScope(source, index) {
     let mode = 'code';
     let escaped = false;
     const lower = source.toLowerCase();
-
     for (let i = 0; i < index; i++) {
         if (mode === 'code') {
             if (lower.startsWith('<script', i)) {
@@ -294,10 +245,8 @@ function isInsideExpressionScope(source, index) {
                 continue;
             }
         }
-
         const ch = source[i];
         const next = i + 1 < index ? source[i + 1] : '';
-
         if (mode === 'line-comment') {
             if (ch === '\n') {
                 mode = 'code';
@@ -320,16 +269,13 @@ function isInsideExpressionScope(source, index) {
                 escaped = true;
                 continue;
             }
-            if (
-                (mode === 'single-quote' && ch === "'") ||
+            if ((mode === 'single-quote' && ch === "'") ||
                 (mode === 'double-quote' && ch === '"') ||
-                (mode === 'template' && ch === '`')
-            ) {
+                (mode === 'template' && ch === '`')) {
                 mode = 'code';
             }
             continue;
         }
-
         if (ch === '/' && next === '/') {
             mode = 'line-comment';
             i += 1;
@@ -360,10 +306,8 @@ function isInsideExpressionScope(source, index) {
             depth = Math.max(0, depth - 1);
         }
     }
-
     return depth > 0;
 }
-
 /**
  * Find the matching </Name> for an opening tag, accounting for nested
  * tags with the same name.
@@ -378,17 +322,14 @@ function findMatchingClose(source, tagName, startAfterOpen) {
     const escapedName = tagName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     const tagRe = new RegExp(`<(/?)${escapedName}(?:\\s[^<>]*?)?\\s*(/?)>`, 'g');
     tagRe.lastIndex = startAfterOpen;
-
     let match;
     while ((match = tagRe.exec(source)) !== null) {
         const isClose = match[1] === '/';
         const isSelfClose = match[2] === '/';
-
         if (isSelfClose && !isClose) {
             // Self-closing <Name />, doesn't affect depth.
             continue;
         }
-
         if (isClose) {
             depth--;
             if (depth === 0) {
@@ -397,14 +338,13 @@ function findMatchingClose(source, tagName, startAfterOpen) {
                     tagEnd: match.index + match[0].length,
                 };
             }
-        } else {
+        }
+        else {
             depth++;
         }
     }
-
     return null;
 }
-
 /**
  * Expand a single component tag into its template HTML.
  *
@@ -417,57 +357,44 @@ function findMatchingClose(source, tagName, startAfterOpen) {
  * @returns {string}
  */
 function expandTag(name, children, registry, sourceFile, chain, usedComponents) {
-
     const compPath = registry.get(name);
     if (!compPath) {
         throw new Error(`Unknown component "${name}" referenced in ${sourceFile}`);
     }
-
     // Cycle detection
     if (chain.includes(name)) {
         const cycle = [...chain, name].join(' -> ');
-        throw new Error(
-            `Circular component dependency detected: ${cycle}\n` +
-            `File: ${sourceFile}`
-        );
+        throw new Error(`Circular component dependency detected: ${cycle}\n` +
+            `File: ${sourceFile}`);
     }
-
     const compSource = readFileSync(compPath, 'utf8');
     let template = extractTemplate(compSource);
-
     // Check Document Mode
     const docMode = isDocumentMode(template);
-
     if (docMode) {
         // Document Mode: must contain exactly one <slot />
         const slotCount = countSlots(template);
         if (slotCount !== 1) {
-            throw new Error(
-                `Document Mode component "${name}" must contain exactly one <slot />, found ${slotCount}.\n` +
-                `File: ${compPath}`
-            );
+            throw new Error(`Document Mode component "${name}" must contain exactly one <slot />, found ${slotCount}.\n` +
+                `File: ${compPath}`);
         }
         // Replace <slot /> with children
         template = replaceSlot(template, children);
-    } else {
+    }
+    else {
         // Standard component
         const slotCount = countSlots(template);
         if (children.trim().length > 0 && slotCount === 0) {
-            throw new Error(
-                `Component "${name}" has children but its template has no <slot />.\n` +
-                `Either add <slot /> to ${compPath} or make the tag self-closing.`
-            );
+            throw new Error(`Component "${name}" has children but its template has no <slot />.\n` +
+                `Either add <slot /> to ${compPath} or make the tag self-closing.`);
         }
         if (slotCount > 0) {
             template = replaceSlot(template, children || '');
         }
     }
-
     usedComponents.push(name);
-
     return expandSource(template, registry, compPath, [...chain, name], usedComponents);
 }
-
 /**
  * Count occurrences of <slot /> or <slot></slot> in template.
  * @param {string} template
@@ -477,7 +404,6 @@ function countSlots(template) {
     const matches = template.match(/<slot\s*>\s*<\/slot>|<slot\s*\/>|<slot\s*>/gi);
     return matches ? matches.length : 0;
 }
-
 /**
  * Replace <slot />, <slot/>, or <slot></slot> with replacement content.
  * @param {string} template

package/dist/server/resolve-request-route.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Deterministic route precedence:
+ *   static segment > param segment > catch-all segment.
+ * Tie-breakers: segment count (more specific first), then lexicographic path.
+ *
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+export function compareRouteSpecificity(a: string, b: string): number;
+/**
+ * @param {string} pathname
+ * @param {Array<{ path: string }>} routes
+ * @returns {{ entry: { path: string }, params: Record<string, string> } | null}
+ */
+export function matchRoute(pathname: string, routes: Array<{
+    path: string;
+}>): {
+    entry: {
+        path: string;
+    };
+    params: Record<string, string>;
+} | null;
+/**
+ * Resolve an incoming request URL against a manifest route list.
+ *
+ * @param {string | URL} reqUrl
+ * @param {Array<{ path: string }>} manifest
+ * @returns {{ matched: boolean, route: { path: string } | null, params: Record<string, string> }}
+ */
+export function resolveRequestRoute(reqUrl: string | URL, manifest: Array<{
+    path: string;
+}>): {
+    matched: boolean;
+    route: {
+        path: string;
+    } | null;
+    params: Record<string, string>;
+};