@zenithbuild/core 0.5.0 → 0.6.0

package/compiler/parse/importTypes.ts

@@ -0,0 +1,78 @@
+/**
+ * Import Metadata Types
+ * 
+ * Structured types for deterministic import parsing.
+ * These types represent the parsed AST data for all ES module import forms.
+ * 
+ * Phase 1: Analysis only - no bundling, no resolution, no emission.
+ */
+
+/**
+ * Import kind classification covering all static import forms
+ */
+export type ImportKind =
+    | 'default'        // import x from "mod"
+    | 'named'          // import { a, b } from "mod"
+    | 'namespace'      // import * as x from "mod"
+    | 'side-effect'    // import "mod"
+    | 're-export'      // export { x } from "mod"
+    | 're-export-all'  // export * from "mod"
+
+/**
+ * Individual specifier within an import declaration
+ */
+export interface ImportSpecifier {
+    /** Local binding name used in this module */
+    local: string
+    /** Original exported name (differs from local when aliased: `import { x as y }`) */
+    imported?: string
+}
+
+/**
+ * Structured import metadata - parsed from AST
+ * 
+ * This is the canonical representation of an import declaration.
+ * All imports in source MUST appear as ParsedImport entries.
+ */
+export interface ParsedImport {
+    /** Classification of import type */
+    kind: ImportKind
+    /** Module specifier (e.g., 'gsap', './Button.zen', '../utils') */
+    source: string
+    /** Bound names and their aliases */
+    specifiers: ImportSpecifier[]
+    /** TypeScript type-only import (import type { ... }) */
+    isTypeOnly: boolean
+    /** Source location for error reporting */
+    location: {
+        start: number
+        end: number
+        line: number
+        column: number
+    }
+    /** Original source text of the import statement */
+    raw: string
+}
+
+/**
+ * Result of parsing all imports from a source file
+ */
+export interface ImportParseResult {
+    /** All parsed imports */
+    imports: ParsedImport[]
+    /** Source file path for error context */
+    filePath: string
+    /** Whether parsing completed successfully */
+    success: boolean
+    /** Any errors encountered during parsing */
+    errors: ImportParseError[]
+}
+
+/**
+ * Error encountered during import parsing
+ */
+export interface ImportParseError {
+    message: string
+    line?: number
+    column?: number
+}

package/compiler/parse/parseImports.ts

@@ -0,0 +1,309 @@
+/**
+ * Import Parser Module
+ * 
+ * Phase 1: Deterministic import parsing using Acorn AST.
+ * 
+ * This module parses JavaScript/TypeScript source code and extracts
+ * structured metadata for all import declarations. It does NOT:
+ * - Resolve imports
+ * - Bundle dependencies
+ * - Emit any code
+ * 
+ * All import analysis happens at compile time.
+ */
+
+import * as acorn from 'acorn'
+import type {
+    ParsedImport,
+    ImportSpecifier,
+    ImportKind,
+    ImportParseResult,
+    ImportParseError
+} from './importTypes'
+
+// Acorn AST node types (simplified for our use case)
+interface AcornNode {
+    type: string
+    start: number
+    end: number
+    loc?: {
+        start: { line: number; column: number }
+        end: { line: number; column: number }
+    }
+}
+
+interface ImportDeclarationNode extends AcornNode {
+    type: 'ImportDeclaration'
+    source: { value: string; raw: string }
+    specifiers: Array<{
+        type: 'ImportDefaultSpecifier' | 'ImportSpecifier' | 'ImportNamespaceSpecifier'
+        local: { name: string }
+        imported?: { name: string }
+    }>
+    importKind?: 'type' | 'value'
+}
+
+interface ExportNamedDeclarationNode extends AcornNode {
+    type: 'ExportNamedDeclaration'
+    source?: { value: string; raw: string }
+    specifiers: Array<{
+        type: 'ExportSpecifier'
+        local: { name: string }
+        exported: { name: string }
+    }>
+    exportKind?: 'type' | 'value'
+}
+
+interface ExportAllDeclarationNode extends AcornNode {
+    type: 'ExportAllDeclaration'
+    source: { value: string; raw: string }
+    exported?: { name: string }
+}
+
+interface ProgramNode extends AcornNode {
+    type: 'Program'
+    body: AcornNode[]
+}
+
+/**
+ * Parse an ImportDeclaration AST node into structured metadata
+ */
+function parseImportDeclaration(
+    node: ImportDeclarationNode,
+    source: string
+): ParsedImport {
+    const specifiers: ImportSpecifier[] = []
+    let kind: ImportKind = 'side-effect'
+
+    for (const spec of node.specifiers) {
+        if (spec.type === 'ImportDefaultSpecifier') {
+            kind = 'default'
+            specifiers.push({ local: spec.local.name })
+        } else if (spec.type === 'ImportNamespaceSpecifier') {
+            kind = 'namespace'
+            specifiers.push({ local: spec.local.name })
+        } else if (spec.type === 'ImportSpecifier') {
+            kind = 'named'
+            specifiers.push({
+                local: spec.local.name,
+                imported: spec.imported?.name !== spec.local.name
+                    ? spec.imported?.name
+                    : undefined
+            })
+        }
+    }
+
+    // If no specifiers, it's a side-effect import
+    if (node.specifiers.length === 0) {
+        kind = 'side-effect'
+    }
+
+    return {
+        kind,
+        source: node.source.value,
+        specifiers,
+        isTypeOnly: node.importKind === 'type',
+        location: {
+            start: node.start,
+            end: node.end,
+            line: node.loc?.start.line ?? 1,
+            column: node.loc?.start.column ?? 0
+        },
+        raw: source.slice(node.start, node.end)
+    }
+}
+
+/**
+ * Parse an ExportNamedDeclaration with source (re-export)
+ */
+function parseReExport(
+    node: ExportNamedDeclarationNode,
+    source: string
+): ParsedImport {
+    const specifiers: ImportSpecifier[] = node.specifiers.map(spec => ({
+        local: spec.exported.name,
+        imported: spec.local.name !== spec.exported.name
+            ? spec.local.name
+            : undefined
+    }))
+
+    return {
+        kind: 're-export',
+        source: node.source!.value,
+        specifiers,
+        isTypeOnly: node.exportKind === 'type',
+        location: {
+            start: node.start,
+            end: node.end,
+            line: node.loc?.start.line ?? 1,
+            column: node.loc?.start.column ?? 0
+        },
+        raw: source.slice(node.start, node.end)
+    }
+}
+
+/**
+ * Parse an ExportAllDeclaration (export * from "mod")
+ */
+function parseExportAll(
+    node: ExportAllDeclarationNode,
+    source: string
+): ParsedImport {
+    return {
+        kind: 're-export-all',
+        source: node.source.value,
+        specifiers: node.exported
+            ? [{ local: node.exported.name }]
+            : [],
+        isTypeOnly: false,
+        location: {
+            start: node.start,
+            end: node.end,
+            line: node.loc?.start.line ?? 1,
+            column: node.loc?.start.column ?? 0
+        },
+        raw: source.slice(node.start, node.end)
+    }
+}
+
+/**
+ * Parse all imports from a source file using Acorn AST parser
+ * 
+ * @param source - JavaScript/TypeScript source code
+ * @param filePath - Path to the source file (for error context)
+ * @returns ParsedImport[] - All import declarations found
+ * 
+ * @example
+ * const result = parseImports(`
+ *   import { gsap } from 'gsap';
+ *   import Button from './Button.zen';
+ * `, 'MyComponent.zen');
+ * 
+ * // result.imports[0].kind === 'named'
+ * // result.imports[0].source === 'gsap'
+ */
+export function parseImports(
+    source: string,
+    filePath: string
+): ImportParseResult {
+    const imports: ParsedImport[] = []
+    const errors: ImportParseError[] = []
+
+    // Strip TypeScript type annotations for parsing
+    // Acorn doesn't support TypeScript, so we handle type imports specially
+    const strippedSource = stripTypeAnnotations(source)
+
+    let ast: ProgramNode
+
+    try {
+        ast = acorn.parse(strippedSource, {
+            ecmaVersion: 'latest',
+            sourceType: 'module',
+            locations: true
+        }) as unknown as ProgramNode
+    } catch (error: any) {
+        // Parse error - return with error info
+        return {
+            imports: [],
+            filePath,
+            success: false,
+            errors: [{
+                message: `Parse error: ${error.message}`,
+                line: error.loc?.line,
+                column: error.loc?.column
+            }]
+        }
+    }
+
+    // Walk the AST to find all import/export declarations
+    for (const node of ast.body) {
+        try {
+            if (node.type === 'ImportDeclaration') {
+                imports.push(parseImportDeclaration(
+                    node as ImportDeclarationNode,
+                    strippedSource
+                ))
+            } else if (node.type === 'ExportNamedDeclaration') {
+                const exportNode = node as ExportNamedDeclarationNode
+                // Only process re-exports (exports with a source)
+                if (exportNode.source) {
+                    imports.push(parseReExport(exportNode, strippedSource))
+                }
+            } else if (node.type === 'ExportAllDeclaration') {
+                imports.push(parseExportAll(
+                    node as ExportAllDeclarationNode,
+                    strippedSource
+                ))
+            }
+        } catch (error: any) {
+            errors.push({
+                message: `Failed to parse node: ${error.message}`,
+                line: (node as any).loc?.start?.line
+            })
+        }
+    }
+
+    return {
+        imports,
+        filePath,
+        success: errors.length === 0,
+        errors
+    }
+}
+
+/**
+ * Strip TypeScript-specific syntax that Acorn can't parse
+ * This is a simple preprocessing step for common patterns
+ */
+function stripTypeAnnotations(source: string): string {
+    // Handle `import type` by converting to regular import
+    // The isTypeOnly flag will be set based on the original text
+    let result = source
+
+    // Track which imports are type-only before stripping
+    const typeImportPattern = /import\s+type\s+/g
+    result = result.replace(typeImportPattern, 'import ')
+
+    // Strip inline type annotations in destructuring
+    // e.g., `import { type Foo, Bar }` -> `import { Foo, Bar }`
+    result = result.replace(/,\s*type\s+(\w+)/g, ', $1')
+    result = result.replace(/{\s*type\s+(\w+)/g, '{ $1')
+
+    // Strip type-only exports
+    result = result.replace(/export\s+type\s+{/g, 'export {')
+
+    return result
+}
+
+/**
+ * Check if the original source has a type import at the given position
+ */
+export function isTypeImportAtPosition(source: string, position: number): boolean {
+    const before = source.slice(Math.max(0, position - 20), position)
+    return /import\s+type\s*$/.test(before)
+}
+
+/**
+ * Categorize imports by their module source type
+ */
+export function categorizeImports(imports: ParsedImport[]): {
+    zenImports: ParsedImport[]      // .zen file imports (compile-time)
+    npmImports: ParsedImport[]      // Package imports (npm)
+    relativeImports: ParsedImport[] // Relative path imports
+} {
+    const zenImports: ParsedImport[] = []
+    const npmImports: ParsedImport[] = []
+    const relativeImports: ParsedImport[] = []
+
+    for (const imp of imports) {
+        if (imp.source.endsWith('.zen')) {
+            zenImports.push(imp)
+        } else if (imp.source.startsWith('./') || imp.source.startsWith('../')) {
+            relativeImports.push(imp)
+        } else {
+            npmImports.push(imp)
+        }
+    }
+
+    return { zenImports, npmImports, relativeImports }
+}

package/compiler/runtime/transformIR.ts

@@ -71,8 +71,8 @@ export async function transformIR(ir: ZenIR): Promise<RuntimeCode> {
   // Transform script (remove state and prop declarations, they're handled by runtime)
   const scriptCode = transformStateDeclarations(scriptContent)
 
-  // Transform component scripts for instance-scoped execution (async)
-  const componentScriptResult = await transformAllComponentScripts(ir.componentScripts || [])
+  // Transform component scripts for instance-scoped execution (synchronous - Acorn)
+  const componentScriptResult = transformAllComponentScripts(ir.componentScripts || [])
 
   // Generate complete runtime bundle
   const bundle = generateRuntimeBundle({

package/compiler/transform/componentScriptTransformer.ts

@@ -5,24 +5,18 @@
  * Uses namespace binding pattern for cleaner output:
  *   const { signal, effect, onMount, ... } = __inst;
  * 
- * Uses es-module-lexer to parse imports:
- * - .zen imports are stripped (compile-time resolved)
- * - npm imports are extracted as structured metadata for bundling
+ * Uses Acorn AST parser for deterministic import parsing.
+ * Phase 1: Analysis only - imports are parsed and categorized.
+ * Phase 2 (bundling) happens in dev.ts.
  * 
- * IMPORTANT: No regex-based import parsing.
+ * Import handling:
+ * - .zen imports: Stripped (compile-time resolved)
+ * - npm imports: Stored as structured metadata for later bundling
  */
 
-import { init, parse } from 'es-module-lexer'
 import type { ComponentScriptIR, ScriptImport } from '../ir/types'
-
-// Initialize es-module-lexer (must be called before parsing)
-let lexerInitialized = false
-async function ensureLexerInit(): Promise<void> {
-    if (!lexerInitialized) {
-        await init
-        lexerInitialized = true
-    }
-}
+import { parseImports, categorizeImports } from '../parse/parseImports'
+import type { ParsedImport } from '../parse/importTypes'
 
 /**
  * Namespace bindings - destructured from the instance
@@ -58,74 +52,100 @@ export interface TransformResult {
 }
 
 /**
- * Parse and extract imports from script content using es-module-lexer
- * 
- * @param scriptContent - Raw script content
- * @returns Object with imports array and script with imports stripped
+ * Convert ParsedImport to ScriptImport for compatibility with existing IR
  */
-export async function parseAndExtractImports(scriptContent: string): Promise<{
-    imports: ScriptImport[]
-    strippedCode: string
-}> {
-    await ensureLexerInit()
-
-    const imports: ScriptImport[] = []
-    const [parsedImports] = parse(scriptContent)
+function toScriptImport(parsed: ParsedImport): ScriptImport {
+    // Build specifiers string from parsed specifiers
+    let specifiers = ''
+
+    if (parsed.kind === 'default') {
+        specifiers = parsed.specifiers[0]?.local || ''
+    } else if (parsed.kind === 'namespace') {
+        specifiers = `* as ${parsed.specifiers[0]?.local || ''}`
+    } else if (parsed.kind === 'named') {
+        const parts = parsed.specifiers.map(s =>
+            s.imported ? `${s.imported} as ${s.local}` : s.local
+        )
+        specifiers = `{ ${parts.join(', ')} }`
+    } else if (parsed.kind === 'side-effect') {
+        specifiers = ''
+    }
 
-    // Sort imports by start position (descending) for safe removal
-    const sortedImports = [...parsedImports].sort((a, b) => b.ss - a.ss)
+    return {
+        source: parsed.source,
+        specifiers,
+        typeOnly: parsed.isTypeOnly,
+        sideEffect: parsed.kind === 'side-effect'
+    }
+}
 
-    let strippedCode = scriptContent
+/**
+ * Strip imports from source code based on parsed import locations
+ * 
+ * @param source - Original source code
+ * @param imports - Parsed imports to strip
+ * @returns Source with imports removed
+ */
+function stripImportsFromSource(source: string, imports: ParsedImport[]): string {
+    if (imports.length === 0) return source
 
-    for (const imp of sortedImports) {
-        const source = imp.n || ''  // Module specifier
-        const importStatement = scriptContent.slice(imp.ss, imp.se)
+    // Sort by start position descending for safe removal
+    const sorted = [...imports].sort((a, b) => b.location.start - a.location.start)
 
-        // Skip .zen file imports (compile-time resolved) - just strip them
-        if (source.endsWith('.zen')) {
-            strippedCode = strippedCode.slice(0, imp.ss) + strippedCode.slice(imp.se)
-            continue
-        }
+    let result = source
+    for (const imp of sorted) {
+        // Remove the import statement
+        const before = result.slice(0, imp.location.start)
+        const after = result.slice(imp.location.end)
 
-        // Skip relative imports (compile-time resolved) - just strip them
-        if (source.startsWith('./') || source.startsWith('../')) {
-            strippedCode = strippedCode.slice(0, imp.ss) + strippedCode.slice(imp.se)
-            continue
-        }
+        // Also remove trailing newline if present
+        const trimmedAfter = after.startsWith('\n') ? after.slice(1) : after
+        result = before + trimmedAfter
+    }
 
-        // This is an npm/external import - extract as structured metadata
-        const isTypeOnly = importStatement.startsWith('import type')
-        const isSideEffect = imp.ss === imp.se || !importStatement.includes(' from ')
-
-        // Extract specifiers from the import statement
-        let specifiers = ''
-        if (!isSideEffect) {
-            const fromIndex = importStatement.indexOf(' from ')
-            if (fromIndex !== -1) {
-                // Get everything between 'import' (or 'import type') and 'from'
-                const start = isTypeOnly ? 'import type '.length : 'import '.length
-                specifiers = importStatement.slice(start, fromIndex).trim()
-            }
-        }
+    return result
+}
 
-        imports.push({
-            source,
-            specifiers,
-            typeOnly: isTypeOnly,
-            sideEffect: isSideEffect
-        })
+/**
+ * Parse and extract imports from script content using Acorn AST parser
+ * 
+ * Phase 1: Deterministic parsing - no bundling or resolution
+ * 
+ * @param scriptContent - Raw script content
+ * @param componentName - Name of the component (for error context)
+ * @returns Object with npm imports array and script with all imports stripped
+ */
+export function parseAndExtractImports(
+    scriptContent: string,
+    componentName: string = 'unknown'
+): {
+    imports: ScriptImport[]
+    strippedCode: string
+} {
+    // Parse imports using Acorn AST
+    const parseResult = parseImports(scriptContent, componentName)
 
-        // Strip the import from the code (it will be hoisted to bundle top)
-        strippedCode = strippedCode.slice(0, imp.ss) + strippedCode.slice(imp.se)
+    if (!parseResult.success) {
+        console.warn(`[Zenith] Import parse warnings for ${componentName}:`, parseResult.errors)
     }
 
-    // Clean up any leftover empty lines from stripped imports
-    strippedCode = strippedCode.replace(/^\s*\n/gm, '')
+    // Categorize imports
+    const { zenImports, npmImports, relativeImports } = categorizeImports(parseResult.imports)
+
+    // Convert npm imports to ScriptImport format
+    const scriptImports = npmImports.map(toScriptImport)
 
-    // Reverse imports array since we processed in reverse order
-    imports.reverse()
+    // Strip ALL imports from source (zen, npm, and relative)
+    // - .zen imports: resolved at compile time
+    // - npm imports: will be bundled separately
+    // - relative imports: resolved at compile time
+    const allImportsToStrip = [...zenImports, ...npmImports, ...relativeImports]
+    const strippedCode = stripImportsFromSource(scriptContent, allImportsToStrip)
 
-    return { imports, strippedCode }
+    return {
+        imports: scriptImports,
+        strippedCode
+    }
 }
 
 /**
@@ -136,13 +156,13 @@ export async function parseAndExtractImports(scriptContent: string): Promise<{
  * @param props - Declared prop names
  * @returns TransformResult with transformed script and extracted imports
  */
-export async function transformComponentScript(
+export function transformComponentScript(
     componentName: string,
     scriptContent: string,
     props: string[]
-): Promise<TransformResult> {
-    // Parse and extract imports using es-module-lexer
-    const { imports, strippedCode } = await parseAndExtractImports(scriptContent)
+): TransformResult {
+    // Parse and extract imports using Acorn AST
+    const { imports, strippedCode } = parseAndExtractImports(scriptContent, componentName)
 
     let transformed = strippedCode
 
@@ -247,34 +267,34 @@ export function emitImports(imports: ScriptImport[]): string {
 /**
  * Transform all component scripts from collected ComponentScriptIR
  * 
+ * Now synchronous since Acorn parsing is synchronous.
+ * 
  * @param componentScripts - Array of component script IRs
  * @returns TransformAllResult with combined code and deduplicated imports
  */
-export async function transformAllComponentScripts(
+export function transformAllComponentScripts(
     componentScripts: ComponentScriptIR[]
-): Promise<TransformAllResult> {
+): TransformAllResult {
     if (!componentScripts || componentScripts.length === 0) {
         return { code: '', imports: [] }
     }
 
     const allImports: ScriptImport[] = []
 
-    const factories = await Promise.all(
-        componentScripts
-            .filter(comp => comp.script && comp.script.trim().length > 0)
-            .map(async comp => {
-                const result = await transformComponentScript(
-                    comp.name,
-                    comp.script,
-                    comp.props
-                )
-
-                // Collect imports
-                allImports.push(...result.imports)
-
-                return generateComponentFactory(comp.name, result.script, comp.props)
-            })
-    )
+    const factories = componentScripts
+        .filter(comp => comp.script && comp.script.trim().length > 0)
+        .map(comp => {
+            const result = transformComponentScript(
+                comp.name,
+                comp.script,
+                comp.props
+            )
+
+            // Collect imports
+            allImports.push(...result.imports)
+
+            return generateComponentFactory(comp.name, result.script, comp.props)
+        })
 
     return {
         code: factories.join('\n'),

package/dist/cli.js

@@ -17,6 +17,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;