@zenithbuild/cli 0.6.6 → 0.6.9

package/dist/compiler-bridge-runner.d.ts

@@ -0,0 +1,5 @@
+export type BridgeArgs = {
+    bridgeModule: string;
+    filePath: string;
+    stdin: boolean;
+};

package/dist/compiler-bridge-runner.js

@@ -0,0 +1,70 @@
+import { readFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+/**
+ * @typedef {{ bridgeModule: string, filePath: string, stdin: boolean }} BridgeArgs
+ */
+/**
+ * @param {string[]} argv
+ * @returns {BridgeArgs}
+ */
+function readArgs(argv) {
+    /** @type {BridgeArgs} */
+    const args = {
+        bridgeModule: '',
+        filePath: '',
+        stdin: false
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === '--bridge-module') {
+            args.bridgeModule = argv[index + 1] || '';
+            index += 1;
+            continue;
+        }
+        if (token === '--stdin') {
+            args.stdin = true;
+            args.filePath = argv[index + 1] || '';
+            index += 1;
+            continue;
+        }
+        if (!token.startsWith('--') && !args.filePath) {
+            args.filePath = token;
+        }
+    }
+    return args;
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(typeof chunk === 'string' ? chunk : chunk.toString('utf8'));
+    }
+    return chunks.join('');
+}
+async function main() {
+    const args = readArgs(process.argv.slice(2));
+    if (!args.bridgeModule) {
+        throw new Error('Missing --bridge-module');
+    }
+    if (!args.filePath) {
+        throw new Error('Missing compiler file path');
+    }
+    const bridgeModuleUrl = pathToFileURL(args.bridgeModule).href;
+    const bridgeModule = await import(bridgeModuleUrl);
+    if (typeof bridgeModule.compile !== 'function') {
+        throw new Error('Compiler bridge does not export compile()');
+    }
+    const result = args.stdin
+        ? await bridgeModule.compile({
+            source: await readStdin(),
+            filePath: args.filePath
+        })
+        : await bridgeModule.compile(args.filePath);
+    process.stdout.write(JSON.stringify(result));
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message) {
+        process.stderr.write(`${message}\n`);
+    }
+    process.exitCode = 1;
+});

package/dist/component-instance-ir.d.ts

@@ -0,0 +1,6 @@
+export function cloneComponentIrForInstance(compIr: any, instanceId: any, extractDeclaredIdentifiers: any, resolveStateKeyFromBindings: any): {
+    ir: any;
+    renameMap: Map<any, string>;
+    refIdentifierPairs: any;
+};
+export function applyOccurrenceRewritePlans(pageIr: any, occurrencePlans: any, resolveBindingMetadata: any): void;

package/dist/component-instance-ir.js

@@ -1,11 +1,9 @@
 function deepClone(value) {
     return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
 }
-
 function escapeIdentifier(identifier) {
     return identifier.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-
 function replaceIdentifierRefs(input, renameMap) {
     let output = String(input || '');
     const entries = [...renameMap.entries()].sort((a, b) => b[0].length - a[0].length);
@@ -15,31 +13,26 @@ function replaceIdentifierRefs(input, renameMap) {
     }
     return output;
 }
-
 function collectRenameTargets(compIr, extractDeclaredIdentifiers) {
     const targets = new Set();
-
     const stateBindings = Array.isArray(compIr?.hoisted?.state) ? compIr.hoisted.state : [];
     for (const entry of stateBindings) {
         if (typeof entry?.key === 'string' && entry.key.length > 0) {
             targets.add(entry.key);
         }
     }
-
     const functions = Array.isArray(compIr?.hoisted?.functions) ? compIr.hoisted.functions : [];
     for (const fnName of functions) {
         if (typeof fnName === 'string' && fnName.length > 0) {
             targets.add(fnName);
         }
     }
-
     const signals = Array.isArray(compIr?.hoisted?.signals) ? compIr.hoisted.signals : [];
     for (const signalName of signals) {
         if (typeof signalName === 'string' && signalName.length > 0) {
             targets.add(signalName);
         }
     }
-
     const declarations = Array.isArray(compIr?.hoisted?.declarations) ? compIr.hoisted.declarations : [];
     for (const declaration of declarations) {
         if (typeof declaration !== 'string') {
@@ -49,14 +42,11 @@ function collectRenameTargets(compIr, extractDeclaredIdentifiers) {
             targets.add(identifier);
         }
     }
-
     return [...targets];
 }
-
 function buildRefIdentifierMap(baseIr, renameMap, resolveStateKeyFromBindings) {
     const baseState = Array.isArray(baseIr?.hoisted?.state) ? baseIr.hoisted.state : [];
     const baseRefs = Array.isArray(baseIr?.ref_bindings) ? baseIr.ref_bindings : [];
-
     return baseRefs.map((binding) => {
         const raw = typeof binding?.identifier === 'string' ? binding.identifier : null;
         const resolvedBase = raw ? resolveStateKeyFromBindings(raw, baseState) : null;
@@ -67,17 +57,14 @@ function buildRefIdentifierMap(baseIr, renameMap, resolveStateKeyFromBindings) {
         };
     }).filter((entry) => typeof entry.raw === 'string' && typeof entry.rewritten === 'string');
 }
-
 export function cloneComponentIrForInstance(compIr, instanceId, extractDeclaredIdentifiers, resolveStateKeyFromBindings) {
     const suffix = `__inst${instanceId}`;
     const cloned = deepClone(compIr);
     const renameTargets = collectRenameTargets(compIr, extractDeclaredIdentifiers);
     const renameMap = new Map(renameTargets.map((name) => [name, `${name}${suffix}`]));
-
     if (Array.isArray(cloned?.expressions)) {
         cloned.expressions = cloned.expressions.map((expr) => replaceIdentifierRefs(expr, renameMap));
     }
-
     if (Array.isArray(cloned?.expression_bindings)) {
         cloned.expression_bindings = cloned.expression_bindings.map((binding) => {
             if (!binding || typeof binding !== 'object') {
@@ -98,7 +85,6 @@ export function cloneComponentIrForInstance(compIr, instanceId, extractDeclaredI
             };
         });
     }
-
     if (cloned?.hoisted) {
         if (Array.isArray(cloned.hoisted.declarations)) {
             cloned.hoisted.declarations = cloned.hoisted.declarations.map((line) => replaceIdentifierRefs(line, renameMap));
@@ -123,7 +109,6 @@ export function cloneComponentIrForInstance(compIr, instanceId, extractDeclaredI
             cloned.hoisted.code = cloned.hoisted.code.map((line) => replaceIdentifierRefs(line, renameMap));
         }
     }
-
     if (Array.isArray(cloned?.ref_bindings)) {
         const clonedState = Array.isArray(cloned?.hoisted?.state) ? cloned.hoisted.state : [];
         cloned.ref_bindings = cloned.ref_bindings.map((binding) => {
@@ -137,7 +122,6 @@ export function cloneComponentIrForInstance(compIr, instanceId, extractDeclaredI
             };
         });
     }
-
     const refIdentifierPairs = buildRefIdentifierMap(compIr, renameMap, resolveStateKeyFromBindings);
     return {
         ir: cloned,
@@ -145,15 +129,12 @@ export function cloneComponentIrForInstance(compIr, instanceId, extractDeclaredI
         refIdentifierPairs
     };
 }
-
 export function applyOccurrenceRewritePlans(pageIr, occurrencePlans, resolveBindingMetadata) {
     const expressions = Array.isArray(pageIr?.expressions) ? pageIr.expressions : [];
     const bindings = Array.isArray(pageIr?.expression_bindings) ? pageIr.expression_bindings : [];
     const refBindings = Array.isArray(pageIr?.ref_bindings) ? pageIr.ref_bindings : [];
-
     let exprCursor = 0;
     let refCursor = 0;
-
     for (const plan of occurrencePlans) {
         const sequence = Array.isArray(plan?.expressionSequence) ? plan.expressionSequence : [];
         for (const item of sequence) {
@@ -194,7 +175,6 @@ export function applyOccurrenceRewritePlans(pageIr, occurrencePlans, resolveBind
             }
             exprCursor = found + 1;
         }
-
         const refSequence = Array.isArray(plan?.refSequence) ? plan.refSequence : [];
         for (const refItem of refSequence) {
             if (typeof refItem?.raw !== 'string' || typeof refItem?.rewritten !== 'string') {

package/dist/component-occurrences.d.ts

@@ -0,0 +1,6 @@
+export function collectExpandedComponentOccurrences(source: any, registry: any, sourceFile: any): {
+    name: string;
+    attrs: string;
+    ownerPath: string;
+    componentPath: string;
+}[];

package/dist/component-occurrences.js

@@ -1,24 +1,19 @@
 import { readFileSync } from 'node:fs';
 import { extractTemplate, isDocumentMode } from './resolve-components.js';
-
 const OPEN_COMPONENT_TAG_RE = /<([A-Z][a-zA-Z0-9]*)(\s[^<>]*?)?\s*(\/?)>/g;
-
 export function collectExpandedComponentOccurrences(source, registry, sourceFile) {
     /** @type {Array<{ name: string, attrs: string, ownerPath: string, componentPath: string }>} */
     const occurrences = [];
     walkSource(String(source || ''), registry, sourceFile, [], occurrences);
     return occurrences;
 }
-
 function walkSource(source, registry, sourceFile, chain, occurrences) {
     let cursor = 0;
-
     while (cursor < source.length) {
         const tag = findNextKnownTag(source, registry, cursor);
         if (!tag) {
             return;
         }
-
         let children = '';
         let replaceEnd = tag.end;
         if (!tag.selfClosing) {
@@ -29,7 +24,6 @@ function walkSource(source, registry, sourceFile, chain, occurrences) {
             children = source.slice(tag.end, close.contentEnd);
             replaceEnd = close.tagEnd;
         }
-
         const compPath = registry.get(tag.name);
         if (!compPath) {
             throw new Error(`Unknown component "${tag.name}" referenced in ${sourceFile}`);
@@ -38,47 +32,35 @@ function walkSource(source, registry, sourceFile, chain, occurrences) {
             const cycle = [...chain, tag.name].join(' -> ');
             throw new Error(`Circular component dependency detected: ${cycle}\nFile: ${sourceFile}`);
         }
-
         occurrences.push({
             name: tag.name,
             attrs: String(tag.attrs || '').trim(),
             ownerPath: sourceFile,
             componentPath: compPath
         });
-
         const compSource = readFileSync(compPath, 'utf8');
         const nextTemplate = materializeTemplate(compSource, tag.name, children, compPath);
         walkSource(nextTemplate, registry, compPath, [...chain, tag.name], occurrences);
         cursor = replaceEnd;
     }
 }
-
 function materializeTemplate(componentSource, name, children, componentPath) {
     let template = extractTemplate(componentSource);
     const slotCount = countSlots(template);
-
     if (isDocumentMode(template)) {
         if (slotCount !== 1) {
-            throw new Error(
-                `Document Mode component "${name}" must contain exactly one <slot />, found ${slotCount}.\nFile: ${componentPath}`
-            );
+            throw new Error(`Document Mode component "${name}" must contain exactly one <slot />, found ${slotCount}.\nFile: ${componentPath}`);
         }
         return replaceSlot(template, children);
     }
-
     if (children.trim().length > 0 && slotCount === 0) {
-        throw new Error(
-            `Component "${name}" has children but its template has no <slot />.\nEither add <slot /> to ${componentPath} or make the tag self-closing.`
-        );
+        throw new Error(`Component "${name}" has children but its template has no <slot />.\nEither add <slot /> to ${componentPath} or make the tag self-closing.`);
     }
-
     if (slotCount > 0) {
         template = replaceSlot(template, children || '');
     }
-
     return template;
 }
-
 function findNextKnownTag(source, registry, startIndex) {
     OPEN_COMPONENT_TAG_RE.lastIndex = startIndex;
     let match;
@@ -100,25 +82,23 @@ function findNextKnownTag(source, registry, startIndex) {
     }
     return null;
 }
-
 function isInsideExpressionScope(source, index) {
     let depth = 0;
     for (let i = 0; i < index; i++) {
         if (source[i] === '{') {
             depth += 1;
-        } else if (source[i] === '}') {
+        }
+        else if (source[i] === '}') {
             depth = Math.max(0, depth - 1);
         }
     }
     return depth > 0;
 }
-
 function findMatchingClose(source, tagName, startAfterOpen) {
     let depth = 1;
     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] === '/';
@@ -134,19 +114,17 @@ function findMatchingClose(source, tagName, startAfterOpen) {
                     tagEnd: match.index + match[0].length
                 };
             }
-        } else {
+        }
+        else {
             depth += 1;
         }
     }
-
     return null;
 }
-
 function countSlots(template) {
     const matches = template.match(/<slot\s*>\s*<\/slot>|<slot\s*\/>|<slot\s*>/gi);
     return matches ? matches.length : 0;
 }
-
 function replaceSlot(template, content) {
     return template.replace(/<slot\s*>\s*<\/slot>|<slot\s*\/>|<slot\s*>/i, content);
 }

package/dist/dev-server.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Create and start a development server.
+ *
+ * @param {{ pagesDir: string, outDir: string, port?: number, host?: string, config?: object, logger?: object | null }} options
+ * @returns {Promise<{ server: import('http').Server, port: number, close: () => void }>}
+ */
+export function createDevServer(options: {
+    pagesDir: string;
+    outDir: string;
+    port?: number;
+    host?: string;
+    config?: object;
+    logger?: object | null;
+}): Promise<{
+    server: import("http").Server;
+    port: number;
+    close: () => void;
+}>;