@zenithbuild/core 0.4.7 → 0.6.0

package/compiler/spa-build.ts

@@ -43,11 +43,11 @@ interface SPABuildOptions {
 /**
  * Compile a single page file
  */
-function compilePage(
+async function compilePage(
   pagePath: string,
   pagesDir: string,
   baseDir: string = process.cwd()
-): CompiledPage {
+): Promise<CompiledPage> {
   try {
     const layoutsDir = path.join(baseDir, 'app', 'layouts')
     const layouts = discoverLayouts(layoutsDir)
@@ -63,7 +63,7 @@ function compilePage(
     }
 
     // Use new compiler pipeline on the processed source
-    const result = compileZenSource(processedSource, pagePath)
+    const result = await compileZenSource(processedSource, pagePath)
 
     if (!result.finalized) {
       throw new Error(`Compilation failed: No finalized output`)
@@ -843,7 +843,7 @@ function generateHTMLShell(
 /**
  * Build SPA from pages directory
  */
-export function buildSPA(options: SPABuildOptions): void {
+export async function buildSPA(options: SPABuildOptions): Promise<void> {
   const { pagesDir, outDir, baseDir } = options
 
   // Clean output directory
@@ -870,7 +870,7 @@ export function buildSPA(options: SPABuildOptions): void {
     console.log(`[Zenith Build] Compiling: ${path.relative(pagesDir, pageFile)}`)
 
     try {
-      const compiled = compilePage(pageFile, pagesDir)
+      const compiled = await compilePage(pageFile, pagesDir)
       compiledPages.push(compiled)
     } catch (error) {
       console.error(`[Zenith Build] Error compiling ${pageFile}:`, error)

package/compiler/ssg-build.ts

@@ -65,11 +65,11 @@ export interface SSGBuildOptions {
 /**
  * Compile a single page file for SSG output
  */
-function compilePage(
+async function compilePage(
     pagePath: string,
     pagesDir: string,
     baseDir: string = process.cwd()
-): CompiledPage {
+): Promise<CompiledPage> {
     const source = fs.readFileSync(pagePath, 'utf-8')
 
     // Analyze page requirements
@@ -88,7 +88,7 @@ function compilePage(
     }
 
     // Compile with new pipeline
-    const result = compileZenSource(processedSource, pagePath)
+    const result = await compileZenSource(processedSource, pagePath)
 
     if (!result.finalized) {
         throw new Error(`Compilation failed for ${pagePath}: No finalized output`)
@@ -239,7 +239,7 @@ ${page.pageScript}
 /**
  * Build all pages using SSG approach
  */
-export function buildSSG(options: SSGBuildOptions): void {
+export async function buildSSG(options: SSGBuildOptions): Promise<void> {
     const { pagesDir, outDir, baseDir = path.dirname(pagesDir) } = options
     const contentDir = path.join(baseDir, 'content')
     const contentData = loadContent(contentDir)
@@ -275,7 +275,7 @@ export function buildSSG(options: SSGBuildOptions): void {
         console.log(`   Compiling: ${relativePath}`)
 
         try {
-            const compiled = compilePage(pageFile, pagesDir, baseDir)
+            const compiled = await compilePage(pageFile, pagesDir, baseDir)
             compiledPages.push(compiled)
 
             if (compiled.analysis.needsHydration) {
@@ -356,7 +356,7 @@ export function buildSSG(options: SSGBuildOptions): void {
         const custom404Path = path.join(pagesDir, candidate)
         if (fs.existsSync(custom404Path)) {
             try {
-                const compiled = compilePage(custom404Path, pagesDir, baseDir)
+                const compiled = await compilePage(custom404Path, pagesDir, baseDir)
                 const html = generatePageHTML(compiled, globalStyles, contentData)
                 fs.writeFileSync(path.join(outDir, '404.html'), html)
                 console.log('📦 Generated 404.html (custom)')

package/compiler/transform/componentScriptTransformer.ts

@@ -5,13 +5,18 @@
  * Uses namespace binding pattern for cleaner output:
  *   const { signal, effect, onMount, ... } = __inst;
  * 
- * Then rewrites zen* prefixed calls to unprefixed:
- *   zenSignal(v)  → signal(v)
- *   zenEffect(fn) → effect(fn)
- *   zenOnMount(fn) → onMount(fn)
+ * Uses Acorn AST parser for deterministic import parsing.
+ * Phase 1: Analysis only - imports are parsed and categorized.
+ * Phase 2 (bundling) happens in dev.ts.
+ * 
+ * Import handling:
+ * - .zen imports: Stripped (compile-time resolved)
+ * - npm imports: Stored as structured metadata for later bundling
  */
 
-import type { ComponentScriptIR } from '../ir/types'
+import type { ComponentScriptIR, ScriptImport } from '../ir/types'
+import { parseImports, categorizeImports } from '../parse/parseImports'
+import type { ParsedImport } from '../parse/importTypes'
 
 /**
  * Namespace bindings - destructured from the instance
@@ -38,32 +43,128 @@ const ZEN_PREFIX_MAPPINGS: Record<string, string> = {
     'zenOnUnmount': 'onUnmount',
 }
 
+/**
+ * Result of script transformation including extracted imports
+ */
+export interface TransformResult {
+    script: string           // Transformed script (imports removed)
+    imports: ScriptImport[]  // Structured npm imports to hoist
+}
+
+/**
+ * Convert ParsedImport to ScriptImport for compatibility with existing IR
+ */
+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 = ''
+    }
+
+    return {
+        source: parsed.source,
+        specifiers,
+        typeOnly: parsed.isTypeOnly,
+        sideEffect: parsed.kind === 'side-effect'
+    }
+}
+
+/**
+ * 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
+
+    // Sort by start position descending for safe removal
+    const sorted = [...imports].sort((a, b) => b.location.start - a.location.start)
+
+    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)
+
+        // Also remove trailing newline if present
+        const trimmedAfter = after.startsWith('\n') ? after.slice(1) : after
+        result = before + trimmedAfter
+    }
+
+    return result
+}
+
+/**
+ * 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)
+
+    if (!parseResult.success) {
+        console.warn(`[Zenith] Import parse warnings for ${componentName}:`, parseResult.errors)
+    }
+
+    // Categorize imports
+    const { zenImports, npmImports, relativeImports } = categorizeImports(parseResult.imports)
+
+    // Convert npm imports to ScriptImport format
+    const scriptImports = npmImports.map(toScriptImport)
+
+    // 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: scriptImports,
+        strippedCode
+    }
+}
+
 /**
  * Transform a component's script content for instance-scoped execution
  * 
  * @param componentName - Name of the component
  * @param scriptContent - Raw script content from the component
  * @param props - Declared prop names
- * @returns Transformed script ready for bundling
+ * @returns TransformResult with transformed script and extracted imports
  */
 export function transformComponentScript(
     componentName: string,
     scriptContent: string,
     props: string[]
-): string {
-    let transformed = scriptContent
-
-    // Strip import statements for .zen files (resolved at compile time)
-    transformed = transformed.replace(
-        /import\s+\w+\s+from\s+['"][^'"]*\.zen['"];?\s*/g,
-        ''
-    )
+): TransformResult {
+    // Parse and extract imports using Acorn AST
+    const { imports, strippedCode } = parseAndExtractImports(scriptContent, componentName)
 
-    // Strip any other relative imports (components are inlined)
-    transformed = transformed.replace(
-        /import\s+{[^}]*}\s+from\s+['"][^'"]+['"];?\s*/g,
-        ''
-    )
+    let transformed = strippedCode
 
     // Rewrite zen* prefixed calls to unprefixed (uses namespace bindings)
     for (const [zenName, unprefixedName] of Object.entries(ZEN_PREFIX_MAPPINGS)) {
@@ -72,7 +173,10 @@ export function transformComponentScript(
         transformed = transformed.replace(regex, `${unprefixedName}(`)
     }
 
-    return transformed.trim()
+    return {
+        script: transformed.trim(),
+        imports
+    }
 }
 
 /**
@@ -119,29 +223,81 @@ __zenith.defineComponent('${componentName}', function(props, rootElement) {
 `
 }
 
+/**
+ * Result of transforming all component scripts
+ */
+export interface TransformAllResult {
+    code: string             // Combined factory code
+    imports: ScriptImport[]  // All collected npm imports (deduplicated)
+}
+
+/**
+ * Deduplicate imports by (source + specifiers + typeOnly) tuple
+ * Returns deterministically sorted imports
+ */
+function deduplicateImports(imports: ScriptImport[]): ScriptImport[] {
+    const seen = new Map<string, ScriptImport>()
+
+    for (const imp of imports) {
+        const key = `${imp.source}|${imp.specifiers}|${imp.typeOnly}`
+        if (!seen.has(key)) {
+            seen.set(key, imp)
+        }
+    }
+
+    // Sort by source for deterministic output
+    return Array.from(seen.values()).sort((a, b) => a.source.localeCompare(b.source))
+}
+
+/**
+ * Emit import statements from structured metadata
+ */
+export function emitImports(imports: ScriptImport[]): string {
+    const deduplicated = deduplicateImports(imports)
+
+    return deduplicated.map(imp => {
+        if (imp.sideEffect) {
+            return `import '${imp.source}';`
+        }
+        const typePrefix = imp.typeOnly ? 'type ' : ''
+        return `import ${typePrefix}${imp.specifiers} from '${imp.source}';`
+    }).join('\n')
+}
+
 /**
  * Transform all component scripts from collected ComponentScriptIR
  * 
+ * Now synchronous since Acorn parsing is synchronous.
+ * 
  * @param componentScripts - Array of component script IRs
- * @returns Combined JavaScript code for all component factories
+ * @returns TransformAllResult with combined code and deduplicated imports
  */
 export function transformAllComponentScripts(
     componentScripts: ComponentScriptIR[]
-): string {
+): TransformAllResult {
     if (!componentScripts || componentScripts.length === 0) {
-        return ''
+        return { code: '', imports: [] }
     }
 
+    const allImports: ScriptImport[] = []
+
     const factories = componentScripts
         .filter(comp => comp.script && comp.script.trim().length > 0)
         .map(comp => {
-            const transformed = transformComponentScript(
+            const result = transformComponentScript(
                 comp.name,
                 comp.script,
                 comp.props
             )
-            return generateComponentFactory(comp.name, transformed, comp.props)
+
+            // Collect imports
+            allImports.push(...result.imports)
+
+            return generateComponentFactory(comp.name, result.script, comp.props)
         })
 
-    return factories.join('\n')
+    return {
+        code: factories.join('\n'),
+        imports: deduplicateImports(allImports)
+    }
 }

package/dist/cli.js

@@ -13,6 +13,11 @@
 #!/usr/bin/env bun
 #!/usr/bin/env bun
 #!/usr/bin/env bun
+#!/usr/bin/env bun
+#!/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;