@zenithbuild/core 0.3.3 → 0.4.2

package/compiler/transform/expressionTransformer.ts

@@ -0,0 +1,385 @@
+/**
+ * Expression JSX Transformer
+ * 
+ * Transforms JSX-like tags inside Zenith expressions into __zenith.h() calls.
+ * This allows Zenith to support JSX semantics without a full JSX compiler like Babel.
+ * 
+ * Handles:
+ * - Multi-line JSX expressions
+ * - Nested elements
+ * - Complex event handlers like onclick={() => fn(item)}
+ * - Expression attributes {expr}
+ * - Text interpolation {item.title}
+ */
+
+/**
+ * Find the end of a balanced brace expression
+ */
+function findBalancedBraceEnd(code: string, startIndex: number): number {
+    let braceCount = 1
+    let i = startIndex + 1
+    let inString = false
+    let stringChar = ''
+    let inTemplate = false
+
+    while (i < code.length && braceCount > 0) {
+        const char = code[i]
+        const prevChar = i > 0 ? code[i - 1] : ''
+
+        // Handle escape sequences
+        if (prevChar === '\\') {
+            i++
+            continue
+        }
+
+        // Handle string literals
+        if (!inString && !inTemplate && (char === '"' || char === "'")) {
+            inString = true
+            stringChar = char
+            i++
+            continue
+        }
+
+        if (inString && char === stringChar) {
+            inString = false
+            stringChar = ''
+            i++
+            continue
+        }
+
+        // Handle template literals
+        if (!inString && !inTemplate && char === '`') {
+            inTemplate = true
+            i++
+            continue
+        }
+
+        if (inTemplate && char === '`') {
+            inTemplate = false
+            i++
+            continue
+        }
+
+        // Count braces only when not in strings
+        if (!inString && !inTemplate) {
+            if (char === '{') braceCount++
+            else if (char === '}') braceCount--
+        }
+
+        i++
+    }
+
+    return braceCount === 0 ? i : -1
+}
+
+/**
+ * Parse JSX attributes using balanced parsing for expression values
+ */
+function parseJSXAttributes(code: string, startIndex: number): {
+    attrs: string;
+    endIndex: number;
+    isSelfClosing: boolean
+} {
+    const attrPairs: string[] = []
+    let i = startIndex
+
+    // Skip whitespace
+    while (i < code.length && /\s/.test(code[i]!)) i++
+
+    while (i < code.length) {
+        const char = code[i]
+
+        // Check for end of opening tag
+        if (char === '>') {
+            return { attrs: formatAttrs(attrPairs), endIndex: i + 1, isSelfClosing: false }
+        }
+        if (char === '/' && code[i + 1] === '>') {
+            return { attrs: formatAttrs(attrPairs), endIndex: i + 2, isSelfClosing: true }
+        }
+
+        // Parse attribute name
+        const nameMatch = code.slice(i).match(/^([a-zA-Z_][a-zA-Z0-9_-]*)/)
+        if (!nameMatch) {
+            i++
+            continue
+        }
+
+        const attrName = nameMatch[1]!
+        i += attrName.length
+
+        // Skip whitespace
+        while (i < code.length && /\s/.test(code[i]!)) i++
+
+        // Check for value
+        if (code[i] !== '=') {
+            attrPairs.push(`"${attrName}": true`)
+            continue
+        }
+
+        i++ // Skip '='
+
+        // Skip whitespace
+        while (i < code.length && /\s/.test(code[i]!)) i++
+
+        // Parse value
+        if (code[i] === '"' || code[i] === "'") {
+            const quote = code[i]
+            let endQuote = i + 1
+            while (endQuote < code.length && code[endQuote] !== quote) {
+                if (code[endQuote] === '\\') endQuote++ // Skip escaped chars
+                endQuote++
+            }
+            const value = code.slice(i + 1, endQuote)
+            attrPairs.push(`"${attrName}": "${value}"`)
+            i = endQuote + 1
+        } else if (code[i] === '{') {
+            // Expression value - find balanced end
+            const endBrace = findBalancedBraceEnd(code, i)
+            if (endBrace === -1) {
+                i++
+                continue
+            }
+            const expr = code.slice(i + 1, endBrace - 1).trim()
+            attrPairs.push(`"${attrName}": ${expr}`)
+            i = endBrace
+        } else {
+            // Unquoted value (rare in JSX, but support it)
+            const unquotedMatch = code.slice(i).match(/^([^\s/>]+)/)
+            if (unquotedMatch) {
+                attrPairs.push(`"${attrName}": "${unquotedMatch[1]}"`)
+                i += unquotedMatch[1]!.length
+            }
+        }
+
+        // Skip whitespace
+        while (i < code.length && /\s/.test(code[i]!)) i++
+    }
+
+    return { attrs: formatAttrs(attrPairs), endIndex: i, isSelfClosing: false }
+}
+
+function formatAttrs(pairs: string[]): string {
+    return pairs.length > 0 ? `{ ${pairs.join(', ')} }` : 'null'
+}
+
+/**
+ * Find the matching closing tag for an element
+ */
+function findClosingTag(code: string, startIndex: number, tagName: string): number {
+    let depth = 1
+    let i = startIndex
+    const openPattern = new RegExp(`<${tagName}(?:\\s|>|/>)`, 'i')
+    const closeTag = `</${tagName}>`
+
+    while (i < code.length && depth > 0) {
+        // Check for closing tag
+        if (code.slice(i, i + closeTag.length).toLowerCase() === closeTag.toLowerCase()) {
+            depth--
+            if (depth === 0) return i
+            i += closeTag.length
+            continue
+        }
+
+        // Check for opening tag (same name, nested)
+        const openMatch = code.slice(i).match(openPattern)
+        if (openMatch && openMatch.index === 0) {
+            // Check if it's self-closing
+            const selfClosing = code.slice(i).match(new RegExp(`<${tagName}[^>]*/>`, 'i'))
+            if (!selfClosing || selfClosing.index !== 0) {
+                depth++
+            }
+            i += openMatch[0].length
+            continue
+        }
+
+        i++
+    }
+
+    return -1
+}
+
+/**
+ * Parse JSX children content
+ */
+function parseJSXChildren(code: string, startIndex: number, tagName: string): {
+    children: string;
+    endIndex: number
+} {
+    const closingIndex = findClosingTag(code, startIndex, tagName)
+    if (closingIndex === -1) {
+        return { children: 'null', endIndex: code.length }
+    }
+
+    const content = code.slice(startIndex, closingIndex)
+
+    if (!content.trim()) {
+        return { children: 'null', endIndex: closingIndex }
+    }
+
+    // Transform the children content
+    const transformedContent = transformChildContent(content)
+
+    return { children: transformedContent, endIndex: closingIndex }
+}
+
+/**
+ * Transform content that may contain text, expressions, and nested JSX
+ */
+function transformChildContent(content: string): string {
+    const parts: string[] = []
+    let i = 0
+    let currentText = ''
+
+    while (i < content.length) {
+        const char = content[i]
+
+        // Check for JSX element
+        if (char === '<' && /[a-zA-Z]/.test(content[i + 1] || '')) {
+            // Save any accumulated text
+            if (currentText.trim()) {
+                parts.push(`"${escapeString(currentText.trim())}"`)
+                currentText = ''
+            }
+
+            // Try to parse as JSX element
+            const parsed = parseJSXElement(content, i)
+            if (parsed) {
+                parts.push(parsed.hCall)
+                i = parsed.endIndex
+                continue
+            }
+        }
+
+        // Check for expression {expr}
+        if (char === '{') {
+            const endBrace = findBalancedBraceEnd(content, i)
+            if (endBrace !== -1) {
+                // Save any accumulated text
+                if (currentText.trim()) {
+                    parts.push(`"${escapeString(currentText.trim())}"`)
+                    currentText = ''
+                }
+
+                // Extract and add expression
+                const expr = content.slice(i + 1, endBrace - 1).trim()
+                if (expr) {
+                    // Transform any JSX inside the expression
+                    const transformedExpr = transformExpressionJSX(expr)
+                    parts.push(transformedExpr)
+                }
+                i = endBrace
+                continue
+            }
+        }
+
+        // Accumulate text
+        currentText += char
+        i++
+    }
+
+    // Add remaining text
+    if (currentText.trim()) {
+        parts.push(`"${escapeString(currentText.trim())}"`)
+    }
+
+    if (parts.length === 0) return 'null'
+    if (parts.length === 1) return parts[0]!
+    return `[${parts.join(', ')}]`
+}
+
+/**
+ * Escape a string for use in JavaScript
+ */
+function escapeString(str: string): string {
+    return str
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/\t/g, '\\t')
+}
+
+/**
+ * Parse a single JSX element starting at the given index
+ */
+function parseJSXElement(code: string, startIndex: number): { hCall: string; endIndex: number } | null {
+    // Extract tag name
+    const tagMatch = code.slice(startIndex).match(/^<([a-zA-Z][a-zA-Z0-9]*)/)
+    if (!tagMatch) return null
+
+    const tagName = tagMatch[1]!
+    let i = startIndex + tagMatch[0].length
+
+    // Parse attributes
+    const { attrs, endIndex: attrEnd, isSelfClosing } = parseJSXAttributes(code, i)
+    i = attrEnd
+
+    if (isSelfClosing) {
+        return {
+            hCall: `__zenith.h("${tagName}", ${attrs}, null)`,
+            endIndex: i
+        }
+    }
+
+    // Parse children until closing tag
+    const { children, endIndex: childEnd } = parseJSXChildren(code, i, tagName)
+    i = childEnd
+
+    // Skip closing tag
+    const closeTag = `</${tagName}>`
+    if (code.slice(i, i + closeTag.length).toLowerCase() === closeTag.toLowerCase()) {
+        i += closeTag.length
+    }
+
+    return {
+        hCall: `__zenith.h("${tagName}", ${attrs}, ${children})`,
+        endIndex: i
+    }
+}
+
+/**
+ * Main transformer function
+ * 
+ * Transforms JSX-like tags inside Zenith expressions into __zenith.h() calls.
+ */
+export function transformExpressionJSX(code: string): string {
+    // Skip if no JSX-like content (optimization)
+    if (!/<[a-zA-Z]/.test(code)) {
+        return code
+    }
+
+    let result = ''
+    let i = 0
+
+    while (i < code.length) {
+        // Look for potential JSX tag start
+        // Only treat as JSX if it follows common JSX contexts: (, return, =, :, ,, [, ?
+        if (code[i] === '<' && /[a-zA-Z]/.test(code[i + 1] || '')) {
+            // Check if this looks like a JSX context
+            const beforeChar = i > 0 ? code[i - 1] : ''
+            const beforeTrimmed = code.slice(0, i).trimEnd()
+            const lastChar = beforeTrimmed[beforeTrimmed.length - 1] || ''
+
+            // Common JSX-starting contexts
+            const jsxContexts = ['(', '=', ':', ',', '[', '?', '{', 'n'] // 'n' for 'return'
+            const isJSXContext = jsxContexts.includes(lastChar) ||
+                beforeTrimmed.endsWith('return') ||
+                beforeTrimmed === '' ||
+                (beforeChar && /\s/.test(beforeChar))
+
+            if (isJSXContext) {
+                const parsed = parseJSXElement(code, i)
+                if (parsed) {
+                    result += parsed.hCall
+                    i = parsed.endIndex
+                    continue
+                }
+            }
+        }
+
+        result += code[i]
+        i++
+    }
+
+    return result
+}

package/compiler/transform/transformNode.ts

@@ -50,7 +50,7 @@ export function transformNode(
           loopContext: activeLoopContext  // Phase 7: Attach loop context to binding
         })
 
-        return `<span data-zen-text="${bindingId}"></span>`
+        return `<span data-zen-text="${bindingId}" style="display: contents;"></span>`
       }
 
       case 'element': {

package/core/config/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Zenith Config
+ * 
+ * Public exports for zenith/config
+ */
+
+export { defineConfig } from './types';
+export type {
+    ZenithConfig,
+    ZenithPlugin,
+    PluginContext,
+    ContentSourceConfig,
+    ContentPluginOptions,
+    ContentItem
+} from './types';
+export { loadZenithConfig, hasZenithConfig } from './loader';

package/core/config/loader.ts

@@ -0,0 +1,69 @@
+/**
+ * Zenith Config Loader
+ * 
+ * Loads zenith.config.ts from the project root
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import type { ZenithConfig } from './types';
+
+/**
+ * Load zenith.config.ts from the project root
+ * 
+ * @param projectRoot - Absolute path to the project root
+ * @returns Parsed ZenithConfig or empty config if not found
+ */
+export async function loadZenithConfig(projectRoot: string): Promise<ZenithConfig> {
+    // Check for TypeScript config first, then JavaScript
+    const configPaths = [
+        path.join(projectRoot, 'zenith.config.ts'),
+        path.join(projectRoot, 'zenith.config.js'),
+        path.join(projectRoot, 'zenith.config.mjs'),
+    ];
+
+    let configPath: string | null = null;
+    for (const p of configPaths) {
+        if (fs.existsSync(p)) {
+            configPath = p;
+            break;
+        }
+    }
+
+    if (!configPath) {
+        // No config file found, return empty config
+        return { plugins: [] };
+    }
+
+    try {
+        // Use dynamic import to load the config
+        // Bun supports importing TS files directly
+        const configModule = await import(configPath);
+        const config = configModule.default || configModule;
+
+        // Validate basic structure
+        if (typeof config !== 'object' || config === null) {
+            console.warn(`[Zenith] Invalid config format in ${configPath}`);
+            return { plugins: [] };
+        }
+
+        return config as ZenithConfig;
+    } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`[Zenith] Failed to load config from ${configPath}:`, message);
+        return { plugins: [] };
+    }
+}
+
+/**
+ * Check if a zenith.config.ts exists in the project
+ */
+export function hasZenithConfig(projectRoot: string): boolean {
+    const configPaths = [
+        path.join(projectRoot, 'zenith.config.ts'),
+        path.join(projectRoot, 'zenith.config.js'),
+        path.join(projectRoot, 'zenith.config.mjs'),
+    ];
+
+    return configPaths.some(p => fs.existsSync(p));
+}

package/core/config/types.ts

@@ -0,0 +1,89 @@
+/**
+ * Zenith Config Types
+ * 
+ * Configuration interfaces for zenith.config.ts
+ */
+
+// ============================================
+// Content Plugin Types
+// ============================================
+
+/**
+ * Configuration for a content source
+ */
+export interface ContentSourceConfig {
+    /** Root directory relative to project root (e.g., "../zenith-docs" or "content") */
+    root: string;
+    /** Folders to include from the root (e.g., ["documentation"]). Defaults to all. */
+    include?: string[];
+    /** Folders to exclude from the root (e.g., ["changelog"]) */
+    exclude?: string[];
+}
+
+/**
+ * Options for the content plugin
+ */
+export interface ContentPluginOptions {
+    /** Named content sources mapped to their configuration */
+    sources?: Record<string, ContentSourceConfig>;
+    /** Legacy: Single content directory (deprecated, use sources instead) */
+    contentDir?: string;
+}
+
+// ============================================
+// Core Plugin Types
+// ============================================
+
+/**
+ * Context passed to plugins during setup
+ */
+export interface PluginContext {
+    /** Absolute path to project root */
+    projectRoot: string;
+    /** Set content data for the runtime */
+    setContentData: (data: Record<string, ContentItem[]>) => void;
+    /** Additional options passed from config */
+    options?: Record<string, unknown>;
+}
+
+/**
+ * A content item loaded from a source
+ */
+export interface ContentItem {
+    id?: string | number;
+    slug?: string | null;
+    collection?: string | null;
+    content?: string | null;
+    [key: string]: unknown;
+}
+
+/**
+ * A Zenith plugin definition
+ */
+export interface ZenithPlugin {
+    /** Unique plugin name */
+    name: string;
+    /** Setup function called during initialization */
+    setup: (ctx: PluginContext) => void | Promise<void>;
+    /** Plugin-specific configuration (preserved for reference) */
+    config?: unknown;
+}
+
+// ============================================
+// Main Config Types
+// ============================================
+
+/**
+ * Zenith configuration object
+ */
+export interface ZenithConfig {
+    /** List of plugins to load */
+    plugins?: ZenithPlugin[];
+}
+
+/**
+ * Define a Zenith configuration with full type safety
+ */
+export function defineConfig(config: ZenithConfig): ZenithConfig {
+    return config;
+}

package/core/plugins/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Zenith Plugins
+ * 
+ * Public exports for plugin system
+ */
+
+export { PluginRegistry, createPluginContext } from './registry';

package/core/plugins/registry.ts

@@ -0,0 +1,81 @@
+/**
+ * Zenith Plugin Registry
+ * 
+ * Manages plugin registration and initialization
+ */
+
+import type { ZenithPlugin, PluginContext, ContentItem } from '../config/types';
+
+/**
+ * Plugin registry for managing Zenith plugins
+ */
+export class PluginRegistry {
+    private plugins = new Map<string, ZenithPlugin>();
+
+    /**
+     * Register a plugin
+     */
+    register(plugin: ZenithPlugin): void {
+        if (this.plugins.has(plugin.name)) {
+            console.warn(`[Zenith] Plugin "${plugin.name}" is already registered. Overwriting.`);
+        }
+        this.plugins.set(plugin.name, plugin);
+    }
+
+    /**
+     * Get a plugin by name
+     */
+    get(name: string): ZenithPlugin | undefined {
+        return this.plugins.get(name);
+    }
+
+    /**
+     * Check if a plugin is registered
+     */
+    has(name: string): boolean {
+        return this.plugins.has(name);
+    }
+
+    /**
+     * Get all registered plugins
+     */
+    all(): ZenithPlugin[] {
+        return Array.from(this.plugins.values());
+    }
+
+    /**
+     * Initialize all plugins with the provided context
+     */
+    async initAll(ctx: PluginContext): Promise<void> {
+        for (const plugin of this.plugins.values()) {
+            try {
+                await plugin.setup(ctx);
+                console.log(`[Zenith] Plugin "${plugin.name}" initialized`);
+            } catch (error: unknown) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(`[Zenith] Failed to initialize plugin "${plugin.name}":`, message);
+            }
+        }
+    }
+
+    /**
+     * Clear all registered plugins
+     */
+    clear(): void {
+        this.plugins.clear();
+    }
+}
+
+/**
+ * Create a plugin context for initialization
+ */
+export function createPluginContext(
+    projectRoot: string,
+    contentSetter: (data: Record<string, ContentItem[]>) => void
+): PluginContext {
+    return {
+        projectRoot,
+        setContentData: contentSetter,
+        options: {}
+    };
+}

package/dist/cli.js

@@ -4,6 +4,7 @@
 #!/usr/bin/env bun
 #!/usr/bin/env bun
 #!/usr/bin/env bun
+#!/usr/bin/env bun
 // @bun
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;