@zenithbuild/cli 0.6.3 → 0.6.5

package/dist/component-instance-ir.js

@@ -0,0 +1,217 @@
+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);
+    for (const [from, to] of entries) {
+        const pattern = new RegExp(`\\b${escapeIdentifier(from)}\\b`, 'g');
+        output = output.replace(pattern, to);
+    }
+    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') {
+            continue;
+        }
+        for (const identifier of extractDeclaredIdentifiers(declaration)) {
+            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;
+        const rewritten = resolvedBase ? (renameMap.get(resolvedBase) || null) : null;
+        return {
+            raw,
+            rewritten: rewritten || null
+        };
+    }).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') {
+                return binding;
+            }
+            return {
+                ...binding,
+                literal: typeof binding.literal === 'string' ? replaceIdentifierRefs(binding.literal, renameMap) : binding.literal,
+                compiled_expr: typeof binding.compiled_expr === 'string'
+                    ? replaceIdentifierRefs(binding.compiled_expr, renameMap)
+                    : binding.compiled_expr,
+                component_instance: typeof binding.component_instance === 'string'
+                    ? replaceIdentifierRefs(binding.component_instance, renameMap)
+                    : binding.component_instance,
+                component_binding: typeof binding.component_binding === 'string'
+                    ? replaceIdentifierRefs(binding.component_binding, renameMap)
+                    : binding.component_binding
+            };
+        });
+    }
+
+    if (cloned?.hoisted) {
+        if (Array.isArray(cloned.hoisted.declarations)) {
+            cloned.hoisted.declarations = cloned.hoisted.declarations.map((line) => replaceIdentifierRefs(line, renameMap));
+        }
+        if (Array.isArray(cloned.hoisted.functions)) {
+            cloned.hoisted.functions = cloned.hoisted.functions.map((name) => renameMap.get(name) || name);
+        }
+        if (Array.isArray(cloned.hoisted.signals)) {
+            cloned.hoisted.signals = cloned.hoisted.signals.map((name) => renameMap.get(name) || name);
+        }
+        if (Array.isArray(cloned.hoisted.state)) {
+            cloned.hoisted.state = cloned.hoisted.state.map((entry) => {
+                if (!entry || typeof entry !== 'object') {
+                    return entry;
+                }
+                const key = typeof entry.key === 'string' ? (renameMap.get(entry.key) || entry.key) : entry.key;
+                const value = typeof entry.value === 'string' ? replaceIdentifierRefs(entry.value, renameMap) : entry.value;
+                return { ...entry, key, value };
+            });
+        }
+        if (Array.isArray(cloned.hoisted.code)) {
+            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) => {
+            if (!binding || typeof binding !== 'object' || typeof binding.identifier !== 'string') {
+                return binding;
+            }
+            const resolved = resolveStateKeyFromBindings(binding.identifier, clonedState);
+            return {
+                ...binding,
+                identifier: resolved || binding.identifier
+            };
+        });
+    }
+
+    const refIdentifierPairs = buildRefIdentifierMap(compIr, renameMap, resolveStateKeyFromBindings);
+    return {
+        ir: cloned,
+        renameMap,
+        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) {
+            if (typeof item?.raw !== 'string') {
+                continue;
+            }
+            let found = -1;
+            for (let index = exprCursor; index < expressions.length; index++) {
+                if (expressions[index] === item.raw) {
+                    found = index;
+                    break;
+                }
+            }
+            if (found === -1) {
+                continue;
+            }
+            const rewritten = typeof item.rewritten === 'string' && item.rewritten.length > 0
+                ? item.rewritten
+                : item.raw;
+            expressions[found] = rewritten;
+            const binding = bindings[found];
+            if (binding && typeof binding === 'object') {
+                if (binding.literal === item.raw) {
+                    binding.literal = rewritten;
+                }
+                if (binding.compiled_expr === item.raw) {
+                    binding.compiled_expr = rewritten;
+                }
+                const resolved = resolveBindingMetadata(plan.rewrite, item.binding);
+                if (resolved) {
+                    binding.compiled_expr = resolved.compiled_expr;
+                    binding.signal_index = resolved.signal_index;
+                    binding.signal_indices = resolved.signal_indices;
+                    binding.state_index = resolved.state_index;
+                    binding.component_instance = resolved.component_instance;
+                    binding.component_binding = resolved.component_binding;
+                }
+            }
+            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') {
+                continue;
+            }
+            let found = -1;
+            for (let index = refCursor; index < refBindings.length; index++) {
+                if (refBindings[index]?.identifier === refItem.raw) {
+                    found = index;
+                    break;
+                }
+            }
+            if (found === -1) {
+                continue;
+            }
+            refBindings[found].identifier = refItem.rewritten;
+            refCursor = found + 1;
+        }
+    }
+}

package/dist/component-occurrences.js

@@ -0,0 +1,152 @@
+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) {
+            const close = findMatchingClose(source, tag.name, tag.end);
+            if (!close) {
+                throw new Error(`Unclosed component tag <${tag.name}> in ${sourceFile} at offset ${tag.start}`);
+            }
+            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}`);
+        }
+        if (chain.includes(tag.name)) {
+            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}`
+            );
+        }
+        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.`
+        );
+    }
+
+    if (slotCount > 0) {
+        template = replaceSlot(template, children || '');
+    }
+
+    return template;
+}
+
+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];
+        if (!registry.has(name)) {
+            continue;
+        }
+        if (isInsideExpressionScope(source, match.index)) {
+            continue;
+        }
+        return {
+            name,
+            attrs: String(match[2] || ''),
+            start: match.index,
+            end: OPEN_COMPONENT_TAG_RE.lastIndex,
+            selfClosing: match[3] === '/'
+        };
+    }
+    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] === '}') {
+            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] === '/';
+        const isSelfClose = match[2] === '/';
+        if (isSelfClose && !isClose) {
+            continue;
+        }
+        if (isClose) {
+            depth -= 1;
+            if (depth === 0) {
+                return {
+                    contentEnd: match.index,
+                    tagEnd: match.index + match[0].length
+                };
+            }
+        } 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/index.js

@@ -116,6 +116,15 @@ export async function cli(args, cwd) {
     const outDir = join(projectRoot, 'dist');
     const config = await loadConfig(projectRoot);
 
+    if (command === 'build' || command === 'dev') {
+        const { maybeWarnAboutZenithVersionMismatch } = await import('./version-check.js');
+        await maybeWarnAboutZenithVersionMismatch({
+            projectRoot,
+            logger,
+            command
+        });
+    }
+
     if (command === 'build') {
         const { build } = await import('./build.js');
         logger.build('Building…');

package/dist/toolchain-paths.js

@@ -0,0 +1,110 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const CLI_ROOT = resolve(__dirname, '..');
+const localRequire = createRequire(import.meta.url);
+
+function safeCreateRequire(projectRoot) {
+    if (!projectRoot) {
+        return localRequire;
+    }
+    try {
+        return createRequire(resolve(projectRoot, 'package.json'));
+    } catch {
+        return localRequire;
+    }
+}
+
+function safeResolve(requireFn, specifier) {
+    try {
+        return requireFn.resolve(specifier);
+    } catch {
+        return null;
+    }
+}
+
+export function resolveBinary(candidates) {
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return candidates[0] || '';
+}
+
+export function resolvePackageRoot(packageName, projectRoot = null) {
+    const projectRequire = safeCreateRequire(projectRoot);
+    const projectPath = safeResolve(projectRequire, `${packageName}/package.json`);
+    if (projectPath) {
+        return dirname(projectPath);
+    }
+
+    const localPath = safeResolve(localRequire, `${packageName}/package.json`);
+    return localPath ? dirname(localPath) : null;
+}
+
+export function readInstalledPackageVersion(packageName, projectRoot = null) {
+    const packageRoot = resolvePackageRoot(packageName, projectRoot);
+    if (!packageRoot) {
+        return null;
+    }
+    try {
+        const pkg = JSON.parse(readFileSync(resolve(packageRoot, 'package.json'), 'utf8'));
+        return typeof pkg.version === 'string' ? pkg.version : null;
+    } catch {
+        return null;
+    }
+}
+
+export function readCliPackageVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(resolve(CLI_ROOT, 'package.json'), 'utf8'));
+        return typeof pkg.version === 'string' ? pkg.version : '0.0.0';
+    } catch {
+        return '0.0.0';
+    }
+}
+
+export function compilerBinCandidates(projectRoot = null) {
+    const candidates = [
+        resolve(CLI_ROOT, '../compiler/target/release/zenith-compiler'),
+        resolve(CLI_ROOT, '../zenith-compiler/target/release/zenith-compiler')
+    ];
+    const installedRoot = resolvePackageRoot('@zenithbuild/compiler', projectRoot);
+    if (installedRoot) {
+        candidates.unshift(resolve(installedRoot, 'target/release/zenith-compiler'));
+    }
+    return candidates;
+}
+
+export function resolveCompilerBin(projectRoot = null) {
+    return resolveBinary(compilerBinCandidates(projectRoot));
+}
+
+export function bundlerBinCandidates(projectRoot = null, env = process.env) {
+    const candidates = [];
+    const envBin = env?.ZENITH_BUNDLER_BIN;
+    if (typeof envBin === 'string' && envBin.length > 0) {
+        candidates.push(envBin);
+    }
+
+    const installedRoot = resolvePackageRoot('@zenithbuild/bundler', projectRoot);
+    if (installedRoot) {
+        candidates.push(resolve(installedRoot, 'target/release/zenith-bundler'));
+    }
+
+    candidates.push(
+        resolve(CLI_ROOT, '../bundler/target/release/zenith-bundler'),
+        resolve(CLI_ROOT, '../zenith-bundler/target/release/zenith-bundler')
+    );
+
+    return candidates;
+}
+
+export function resolveBundlerBin(projectRoot = null, env = process.env) {
+    return resolveBinary(bundlerBinCandidates(projectRoot, env));
+}