@zenithbuild/cli 0.7.11 → 0.7.12

package/dist/scoped-server-data/manifest-integration.d.ts

@@ -0,0 +1,4 @@
+import type { AnalyzeRouteScopedServerMetadataOptions, AnalyzeRouteScopedServerMetadataResult, ScopedServerDiagnostic } from './types.js';
+export type { AnalyzeRouteScopedServerMetadataOptions, AnalyzeRouteScopedServerMetadataResult, ManifestScopedServerDataEntry } from './types.js';
+export declare function analyzeRouteScopedServerMetadata(options: AnalyzeRouteScopedServerMetadataOptions): AnalyzeRouteScopedServerMetadataResult;
+export declare function assertNoScopedServerBuildErrors(diagnostics: ScopedServerDiagnostic[], contextFile: string): void;

package/dist/scoped-server-data/manifest-integration.js

@@ -0,0 +1,125 @@
+import { resolve } from 'node:path';
+import { collectExpandedComponentOccurrences } from '../component-occurrences.js';
+import { scanRouteScopedServerOwners, toOwnerKey } from './owner-scanner.js';
+import { sortScopedServerDiagnostics } from './diagnostics.js';
+import { parseScopedComponentStaticProps } from './static-props.js';
+export function analyzeRouteScopedServerMetadata(options) {
+    const pageSource = String(options.pageSource || '');
+    const pageFile = resolve(String(options.pageFile || ''));
+    const srcDir = resolve(String(options.srcDir || ''));
+    const registry = options.registry;
+    const compilerOpts = options.compilerOpts || {};
+    const scanResult = scanRouteScopedServerOwners({
+        pageSource,
+        pageFile,
+        registry,
+        srcDir,
+        compilerOpts
+    });
+    const componentOccurrences = collectExpandedComponentOccurrences(pageSource, registry, pageFile);
+    const occurrenceCountByPath = buildOccurrenceCountByPath(componentOccurrences);
+    const occurrenceDetails = buildScopedComponentOccurrenceDetails({
+        componentOccurrences,
+        owners: scanResult.owners,
+        srcDir
+    });
+    const scopedServerData = scanResult.owners.map((owner) => toManifestScopedServerDataEntry(owner, occurrenceCountByPath, occurrenceDetails.byOwnerKey));
+    return {
+        hasScopedServerData: scopedServerData.length > 0,
+        scopedServerData,
+        diagnostics: sortScopedServerDiagnostics([
+            ...scanResult.diagnostics,
+            ...occurrenceDetails.diagnostics
+        ])
+    };
+}
+export function assertNoScopedServerBuildErrors(diagnostics, contextFile) {
+    const errors = diagnostics.filter((item) => item.severity === 'error');
+    if (errors.length === 0) {
+        return;
+    }
+    const first = errors[0];
+    throw new Error(`[zenith] Build failed for ${contextFile}: ${first.code} ${first.message} (${first.filePath})`);
+}
+function toManifestScopedServerDataEntry(owner, occurrenceCountByPath, occurrenceDetailsByOwnerKey) {
+    const instanceStrategy = resolveInstanceStrategy(owner, occurrenceCountByPath);
+    const entry = {
+        ownerKind: owner.ownerKind,
+        ownerKey: owner.ownerKey,
+        syntax: owner.syntax,
+        exportName: owner.exportName,
+        instanceStrategy
+    };
+    if (owner.syntax === 'variables' && owner.serializedVariableNames.length > 0) {
+        entry.serializedVariableNames = [...owner.serializedVariableNames];
+    }
+    if (owner.ownerKind === 'component') {
+        const occurrences = occurrenceDetailsByOwnerKey.get(owner.ownerKey) || [];
+        if (instanceStrategy === 'per-instance') {
+            entry.instances = occurrences.map(({ key, occurrenceId, props }) => ({
+                key,
+                occurrenceId,
+                props
+            }));
+        }
+        else if (occurrences.length === 1 && Object.keys(occurrences[0].props).length > 0) {
+            entry.props = occurrences[0].props;
+        }
+    }
+    return entry;
+}
+function buildScopedComponentOccurrenceDetails({ componentOccurrences, owners, srcDir }) {
+    const componentOwnerByKey = new Map();
+    for (const owner of owners) {
+        if (owner.ownerKind === 'component') {
+            componentOwnerByKey.set(owner.ownerKey, owner);
+        }
+    }
+    const byOwnerKey = new Map();
+    const occurrenceCountByOwnerKey = new Map();
+    const diagnostics = [];
+    for (const occurrence of componentOccurrences) {
+        if (typeof occurrence.componentPath !== 'string' || occurrence.componentPath.length === 0) {
+            continue;
+        }
+        const ownerKey = toOwnerKey(occurrence.componentPath, srcDir);
+        if (!componentOwnerByKey.has(ownerKey)) {
+            continue;
+        }
+        const index = occurrenceCountByOwnerKey.get(ownerKey) || 0;
+        occurrenceCountByOwnerKey.set(ownerKey, index + 1);
+        const occurrenceId = `o${index}`;
+        const parsed = parseScopedComponentStaticProps({
+            attrs: occurrence.attrs,
+            ownerKey,
+            contextFile: occurrence.ownerPath || occurrence.componentPath,
+            occurrenceId
+        });
+        diagnostics.push(...parsed.diagnostics);
+        if (!byOwnerKey.has(ownerKey)) {
+            byOwnerKey.set(ownerKey, []);
+        }
+        byOwnerKey.get(ownerKey)?.push({
+            key: `component:${ownerKey}:${occurrenceId}`,
+            occurrenceId,
+            props: parsed.props
+        });
+    }
+    return { byOwnerKey, diagnostics };
+}
+function resolveInstanceStrategy(owner, occurrenceCountByPath) {
+    if (owner.ownerKind === 'layout') {
+        return 'singleton';
+    }
+    const resolvedPath = resolve(owner.ownerPath);
+    const count = occurrenceCountByPath.get(resolvedPath) ?? 1;
+    return count > 1 ? 'per-instance' : 'singleton';
+}
+function buildOccurrenceCountByPath(componentOccurrences) {
+    const occurrenceCountByPath = new Map();
+    for (const occurrence of componentOccurrences) {
+        const key = occurrence.componentPath || occurrence.name;
+        occurrenceCountByPath.set(key, (occurrenceCountByPath.get(key) || 0) + 1);
+    }
+    return occurrenceCountByPath;
+}

package/dist/scoped-server-data/owner-scanner.d.ts

@@ -0,0 +1,6 @@
+import type { ScanRouteScopedServerOwnersOptions, ScanRouteScopedServerOwnersResult } from './types.js';
+export type { CompilerOptsLike, OwnerFileAnalysisResult, ScanRouteScopedServerOwnersOptions, ScanRouteScopedServerOwnersResult, ScopedServerDataOwner, ScopedServerDataOwnerBase, ScopedServerDiagnostic, ScopedServerOwnerKind, ScopedServerOwnerSyntax } from './types.js';
+export { analyzeOwnerServerFile } from './analyze-owner-file.js';
+export { createScopedServerDiagnostic, SCOPED_SERVER_DIAGNOSTIC, sortScopedServerDiagnostics } from './diagnostics.js';
+export declare function scanRouteScopedServerOwners(options: ScanRouteScopedServerOwnersOptions): ScanRouteScopedServerOwnersResult;
+export declare function toOwnerKey(ownerPath: string, srcDir: string): string;

package/dist/scoped-server-data/owner-scanner.js

@@ -0,0 +1,55 @@
+import { readFileSync } from 'node:fs';
+import { relative, resolve } from 'node:path';
+import { collectReachableOwnerPaths } from '../component-occurrences.js';
+import { extractTemplate, isDocumentMode } from '../resolve-components.js';
+import { analyzeOwnerServerFile } from './analyze-owner-file.js';
+import { createScopedServerDiagnostic, SCOPED_SERVER_DIAGNOSTIC, sortScopedServerDiagnostics } from './diagnostics.js';
+export { analyzeOwnerServerFile } from './analyze-owner-file.js';
+export { createScopedServerDiagnostic, SCOPED_SERVER_DIAGNOSTIC, sortScopedServerDiagnostics } from './diagnostics.js';
+export function scanRouteScopedServerOwners(options) {
+    const pageSource = String(options.pageSource || '');
+    const pageFile = String(options.pageFile || '');
+    const registry = options.registry;
+    const srcDir = resolve(String(options.srcDir || ''));
+    const compilerOpts = options.compilerOpts || {};
+    const owners = [];
+    const diagnostics = [];
+    diagnostics.push(...detectCompetingDocumentRoots(pageSource, registry, pageFile));
+    const ownerPaths = collectReachableOwnerPaths(pageSource, registry, pageFile).sort();
+    for (const ownerPath of ownerPaths) {
+        const ownerSource = readFileSync(ownerPath, 'utf8');
+        const result = analyzeOwnerServerFile(ownerSource, ownerPath, compilerOpts);
+        diagnostics.push(...result.diagnostics);
+        if (result.owner) {
+            owners.push({
+                ...result.owner,
+                ownerKey: toOwnerKey(ownerPath, srcDir)
+            });
+        }
+    }
+    return {
+        owners,
+        diagnostics: sortScopedServerDiagnostics(diagnostics)
+    };
+}
+function detectCompetingDocumentRoots(pageSource, registry, pageFile) {
+    const diagnostics = [];
+    let documentRootCount = 0;
+    if (isDocumentMode(extractTemplate(pageSource))) {
+        documentRootCount += 1;
+    }
+    for (const ownerPath of collectReachableOwnerPaths(pageSource, registry, pageFile)) {
+        const ownerTemplate = extractTemplate(readFileSync(ownerPath, 'utf8'));
+        if (isDocumentMode(ownerTemplate)) {
+            documentRootCount += 1;
+        }
+    }
+    if (documentRootCount > 1) {
+        diagnostics.push(createScopedServerDiagnostic(SCOPED_SERVER_DIAGNOSTIC.COMPETING_DOCUMENT_ROOTS, 'error', 'Page render must resolve to exactly one document root.', pageFile));
+    }
+    return diagnostics;
+}
+export function toOwnerKey(ownerPath, srcDir) {
+    const rel = relative(srcDir, resolve(ownerPath)).replace(/\\/g, '/');
+    return rel.startsWith('src/') ? rel : `src/${rel}`;
+}

package/dist/scoped-server-data/parse-owner-server-block.d.ts

@@ -0,0 +1,12 @@
+import type { CompilerOptsLike, ScriptBlockPartition } from './types.js';
+interface ScriptBlockMatch extends ScriptBlockPartition {
+    full: string;
+    index: number;
+}
+export declare function findScriptBlocks(source: string): ScriptBlockMatch[];
+export declare function partitionScriptBlocks(source: string): {
+    serverBlocks: ScriptBlockPartition[];
+    clientBlocks: ScriptBlockPartition[];
+};
+export declare function serverBlockRequiresLangTs(attrs: string, compilerOpts?: CompilerOptsLike): boolean;
+export {};

package/dist/scoped-server-data/parse-owner-server-block.js

@@ -0,0 +1,35 @@
+export function findScriptBlocks(source) {
+    const scriptRe = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+    const blocks = [];
+    for (const match of String(source || '').matchAll(scriptRe)) {
+        blocks.push({
+            attrs: String(match[1] || ''),
+            body: String(match[2] || ''),
+            full: String(match[0] || ''),
+            index: typeof match.index === 'number' ? match.index : -1
+        });
+    }
+    return blocks;
+}
+export function partitionScriptBlocks(source) {
+    const serverBlocks = [];
+    const clientBlocks = [];
+    for (const block of findScriptBlocks(source)) {
+        if (/\bserver\b/i.test(block.attrs)) {
+            serverBlocks.push({ attrs: block.attrs, body: block.body });
+        }
+        else {
+            clientBlocks.push({ attrs: block.attrs, body: block.body });
+        }
+    }
+    return { serverBlocks, clientBlocks };
+}
+export function serverBlockRequiresLangTs(attrs, compilerOpts = {}) {
+    const hasLangTs = /\blang\s*=\s*["']ts["']/i.test(attrs);
+    if (hasLangTs) {
+        return false;
+    }
+    const hasLangJs = /\blang\s*=\s*["'](?:js|javascript)["']/i.test(attrs);
+    const hasAnyLang = /\blang\s*=/i.test(attrs);
+    return !compilerOpts.typescriptDefault || hasLangJs || hasAnyLang;
+}

package/dist/scoped-server-data/runtime.d.ts

@@ -0,0 +1,24 @@
+import type { ManifestScopedServerDataEntry } from './types.js';
+type ScopedEntry = ManifestScopedServerDataEntry & {
+    module?: string;
+};
+type ScopedModule = {
+    data?: unknown;
+};
+type ScopedModuleLoader = (entry: ScopedEntry) => Promise<ScopedModule>;
+export interface ExecuteScopedServerDataOptions {
+    route: {
+        path?: string;
+        route_kind?: string | null;
+        prerender?: boolean;
+        has_scoped_server_data?: boolean;
+        scoped_server_data?: ScopedEntry[];
+    };
+    ctx: unknown;
+    serverDir?: string | null;
+    loadModule?: ScopedModuleLoader;
+}
+export declare function hasExecutableScopedServerData(route: ExecuteScopedServerDataOptions['route']): boolean;
+export declare function mergeScopedSsrPayload(routePayload: unknown, scopedPayload: Record<string, Record<string, unknown>>): Record<string, unknown>;
+export declare function executeScopedServerData(options: ExecuteScopedServerDataOptions): Promise<Record<string, Record<string, unknown>>>;
+export {};

package/dist/scoped-server-data/runtime.js

@@ -0,0 +1,121 @@
+import { isAbsolute, resolve, sep } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { assertJsonSerializable } from '../server-contract/json-serializable.js';
+const INVALID_SCOPED_MODULE_PATH = '[Zenith:ScopedServerData] Invalid scoped server data module path.';
+export function hasExecutableScopedServerData(route) {
+    return route?.route_kind !== 'resource' &&
+        route?.prerender !== true &&
+        route?.has_scoped_server_data === true &&
+        Array.isArray(route?.scoped_server_data) &&
+        route.scoped_server_data.length > 0;
+}
+export function mergeScopedSsrPayload(routePayload, scopedPayload) {
+    const routeData = isPlainRecord(routePayload) ? routePayload : {};
+    if (Object.keys(scopedPayload || {}).length === 0) {
+        return routeData;
+    }
+    return {
+        ...routeData,
+        route: routeData,
+        scoped: scopedPayload
+    };
+}
+export async function executeScopedServerData(options) {
+    const route = options.route || {};
+    if (!hasExecutableScopedServerData(route)) {
+        return {};
+    }
+    const scoped = {};
+    const entries = route.scoped_server_data || [];
+    for (const entry of entries) {
+        const workItems = scopedPayloadWorkItems(entry);
+        const mod = await loadScopedModule(entry, options);
+        const dataFn = mod?.data;
+        if (typeof dataFn !== 'function') {
+            throw new Error(`[Zenith:ScopedServerData] Scoped server data module "${entry.module || entry.ownerKey}" must export data(ctx, props).`);
+        }
+        for (const item of workItems) {
+            const props = normalizeStaticProps(item.props, entry.ownerKey);
+            const result = await dataFn(options.ctx, props);
+            if (isRouteResultLike(result)) {
+                throw new Error(`[Zenith:ScopedServerData] Scoped server data owner "${entry.ownerKey}" must return a plain serializable object, not a route result.`);
+            }
+            assertJsonSerializable(result, `${entry.ownerKey}: scoped data return`);
+            scoped[item.key] = result;
+        }
+    }
+    return scoped;
+}
+async function loadScopedModule(entry, options) {
+    if (typeof options.loadModule === 'function') {
+        return options.loadModule(entry);
+    }
+    if (typeof options.serverDir !== 'string' || options.serverDir.length === 0) {
+        throw new Error('[Zenith:ScopedServerData] Cannot execute scoped server data without a server module root.');
+    }
+    const modulePath = resolveScopedServerModulePath(options.serverDir, entry.module);
+    return import(pathToFileURL(modulePath).href);
+}
+function scopedPayloadWorkItems(entry) {
+    const ownerKey = String(entry?.ownerKey || '');
+    if (entry?.instanceStrategy === 'per-instance') {
+        if (!Array.isArray(entry.instances) || entry.instances.length === 0) {
+            throw new Error(`[Zenith:ScopedServerData] Per-instance scoped server data owner "${ownerKey}" is missing instance metadata.`);
+        }
+        return entry.instances.map((instance) => {
+            const key = typeof instance?.key === 'string' && instance.key.length > 0
+                ? instance.key
+                : '';
+            if (!key.startsWith(`component:${ownerKey}:`)) {
+                throw new Error(`[Zenith:ScopedServerData] Invalid scoped server data instance key for "${ownerKey}".`);
+            }
+            return { key, props: instance.props || {} };
+        });
+    }
+    if (entry?.ownerKind === 'layout') {
+        return [{ key: `layout:${ownerKey}`, props: {} }];
+    }
+    if (entry?.ownerKind === 'component') {
+        return [{ key: `component:${ownerKey}`, props: entry.props || {} }];
+    }
+    throw new Error(`[Zenith:ScopedServerData] Unsupported scoped server data owner kind "${String(entry?.ownerKind || '')}".`);
+}
+function normalizeStaticProps(value, ownerKey) {
+    if (value == null) {
+        return {};
+    }
+    if (!isPlainRecord(value)) {
+        throw new Error(`[Zenith:ScopedServerData] Scoped server data props for "${ownerKey}" must be a plain object.`);
+    }
+    assertJsonSerializable(value, `${ownerKey}: scoped data props`);
+    return value;
+}
+function resolveScopedServerModulePath(serverDir, modulePath) {
+    const raw = String(modulePath || '');
+    if (!raw || isAbsolute(raw) || /^[A-Za-z]:[\\/]/.test(raw)) {
+        throw new Error(INVALID_SCOPED_MODULE_PATH);
+    }
+    const normalized = raw.replace(/\\/g, '/');
+    if (!normalized.startsWith('scoped/') || normalized.split('/').some((part) => part === '..' || part === '.')) {
+        throw new Error(INVALID_SCOPED_MODULE_PATH);
+    }
+    const scopedRoot = resolve(serverDir, 'scoped');
+    const outputPath = resolve(serverDir, normalized);
+    if (outputPath !== scopedRoot && !outputPath.startsWith(`${scopedRoot}${sep}`)) {
+        throw new Error(INVALID_SCOPED_MODULE_PATH);
+    }
+    return outputPath;
+}
+function isRouteResultLike(value) {
+    return Boolean(value &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        typeof value.kind === 'string');
+}
+function isPlainRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === null || proto === Object.prototype || proto?.constructor?.name === 'Object';
+}

package/dist/scoped-server-data/serialization-set.d.ts

@@ -0,0 +1,2 @@
+export declare function collectTemplateRootBindingRefs(template: string): Set<string>;
+export declare function computeSerializationSet(declaredNames: string[], template: string): string[];

package/dist/scoped-server-data/serialization-set.js

@@ -0,0 +1,52 @@
+const IDENT_START = /[A-Za-z_$]/;
+const IDENT_PART = /[A-Za-z0-9_$]/;
+export function collectTemplateRootBindingRefs(template) {
+    const refs = new Set();
+    const source = String(template || '');
+    let cursor = 0;
+    while (cursor < source.length) {
+        const open = source.indexOf('{', cursor);
+        if (open < 0) {
+            break;
+        }
+        const close = source.indexOf('}', open + 1);
+        if (close < 0) {
+            break;
+        }
+        const expr = source.slice(open + 1, close).trim();
+        const root = readExpressionRoot(expr);
+        if (root) {
+            refs.add(root);
+        }
+        cursor = close + 1;
+    }
+    return refs;
+}
+function readExpressionRoot(expr) {
+    if (!expr || expr.startsWith('//')) {
+        return null;
+    }
+    let i = 0;
+    while (i < expr.length && /\s/.test(expr[i] ?? '')) {
+        i += 1;
+    }
+    if (!IDENT_START.test(expr[i] ?? '')) {
+        return null;
+    }
+    let end = i + 1;
+    while (end < expr.length && IDENT_PART.test(expr[end] ?? '')) {
+        end += 1;
+    }
+    return expr.slice(i, end);
+}
+export function computeSerializationSet(declaredNames, template) {
+    const refs = collectTemplateRootBindingRefs(template);
+    const declared = new Set(declaredNames);
+    const serialized = [];
+    for (const name of refs) {
+        if (declared.has(name)) {
+            serialized.push(name);
+        }
+    }
+    return serialized.sort();
+}

package/dist/scoped-server-data/static-props.d.ts

@@ -0,0 +1,12 @@
+import type { ScopedServerDiagnostic, ScopedServerStaticProps } from './types.js';
+export interface ParseScopedComponentStaticPropsOptions {
+    attrs: string;
+    ownerKey: string;
+    contextFile: string;
+    occurrenceId?: string;
+}
+export interface ParseScopedComponentStaticPropsResult {
+    props: ScopedServerStaticProps;
+    diagnostics: ScopedServerDiagnostic[];
+}
+export declare function parseScopedComponentStaticProps(options: ParseScopedComponentStaticPropsOptions): ParseScopedComponentStaticPropsResult;