@zenithbuild/core 1.2.2 → 1.2.4

package/compiler/test/component-stacking.test.ts

@@ -1,365 +0,0 @@
-/**
- * Component Stacking Test
- * 
- * Tests that multiple sibling components and multiple instances
- * of the same component render correctly.
- */
-
-import { compileZenSource } from '../index'
-import { discoverComponents, type ComponentMetadata } from '../discovery/componentDiscovery'
-import { resolveComponentsInIR } from '../transform/componentResolver'
-import { parseTemplate } from '../parse/parseTemplate'
-import * as fs from 'fs'
-import * as path from 'path'
-
-// Test 1: Multiple sibling components
-async function testMultipleSiblingComponents() {
-  console.log('\n=== Test 1: Multiple Sibling Components ===\n')
-  
-  // Create mock components
-  const mockComponents = new Map<string, ComponentMetadata>()
-  
-  mockComponents.set('Header', {
-    name: 'Header',
-    path: '/mock/Header.zen',
-    template: '<header class="test-header">Header Content</header>',
-    nodes: [{
-      type: 'element',
-      tag: 'header',
-      attributes: [{ name: 'class', value: 'test-header', location: { line: 1, column: 1 } }],
-      children: [{ type: 'text', value: 'Header Content', location: { line: 1, column: 1 } }],
-      location: { line: 1, column: 1 }
-    }],
-    slots: [],
-    props: [],
-    styles: [],
-    script: null,
-    scriptAttributes: null,
-    hasScript: false,
-    hasStyles: false
-  })
-  
-  mockComponents.set('Hero', {
-    name: 'Hero',
-    path: '/mock/Hero.zen',
-    template: '<section class="test-hero">Hero Content</section>',
-    nodes: [{
-      type: 'element',
-      tag: 'section',
-      attributes: [{ name: 'class', value: 'test-hero', location: { line: 1, column: 1 } }],
-      children: [{ type: 'text', value: 'Hero Content', location: { line: 1, column: 1 } }],
-      location: { line: 1, column: 1 }
-    }],
-    slots: [],
-    props: [],
-    styles: [],
-    script: null,
-    scriptAttributes: null,
-    hasScript: false,
-    hasStyles: false
-  })
-  
-  mockComponents.set('Footer', {
-    name: 'Footer',
-    path: '/mock/Footer.zen',
-    template: '<footer class="test-footer">Footer Content</footer>',
-    nodes: [{
-      type: 'element',
-      tag: 'footer',
-      attributes: [{ name: 'class', value: 'test-footer', location: { line: 1, column: 1 } }],
-      children: [{ type: 'text', value: 'Footer Content', location: { line: 1, column: 1 } }],
-      location: { line: 1, column: 1 }
-    }],
-    slots: [],
-    props: [],
-    styles: [],
-    script: null,
-    scriptAttributes: null,
-    hasScript: false,
-    hasStyles: false
-  })
-  
-  // Test source with multiple sibling components
-  const testSource = `
-<script setup="ts">
-</script>
-<div class="page">
-  <Header />
-  <Hero />
-  <Footer />
-</div>
-`
-  
-  // Parse the template
-  const template = parseTemplate(testSource, 'test.zen')
-  
-  console.log('Parsed nodes:', JSON.stringify(template.nodes, null, 2))
-  console.log('\nComponent nodes found:')
-  
-  // Find all component nodes
-  function findComponents(nodes: any[], depth = 0): void {
-    for (const node of nodes) {
-      if (node.type === 'component') {
-        console.log(`${'  '.repeat(depth)}Component: ${node.name}`)
-      } else if (node.type === 'element') {
-        console.log(`${'  '.repeat(depth)}Element: <${node.tag}>`)
-        if (node.children) {
-          findComponents(node.children, depth + 1)
-        }
-      }
-    }
-  }
-  
-  findComponents(template.nodes)
-  
-  // Create IR
-  const ir = {
-    filePath: 'test.zen',
-    template,
-    script: { raw: '', attributes: {} },
-    styles: []
-  }
-  
-  // Resolve components
-  const resolvedIR = resolveComponentsInIR(ir, mockComponents)
-  
-  console.log('\nResolved nodes:', JSON.stringify(resolvedIR.template.nodes, null, 2))
-  
-  // Count how many test-* classes appear in the resolved HTML
-  const jsonStr = JSON.stringify(resolvedIR.template.nodes)
-  const countHeaders = (jsonStr.match(/"value":"test-header"/g) || []).length
-  const countHeros = (jsonStr.match(/"value":"test-hero"/g) || []).length
-  const countFooters = (jsonStr.match(/"value":"test-footer"/g) || []).length
-  
-  console.log(`\nResults:`)
-  console.log(`  Headers: ${countHeaders} (expected: 1)`)
-  console.log(`  Heros: ${countHeros} (expected: 1)`)
-  console.log(`  Footers: ${countFooters} (expected: 1)`)
-  
-  const passed = countHeaders === 1 && countHeros === 1 && countFooters === 1
-  console.log(`\n${passed ? '✅ PASSED' : '❌ FAILED'}: Multiple sibling components`)
-  
-  return passed
-}
-
-// Test 2: Multiple instances of the same component
-async function testMultipleInstances() {
-  console.log('\n=== Test 2: Multiple Instances of Same Component ===\n')
-  
-  const mockComponents = new Map<string, ComponentMetadata>()
-  
-  mockComponents.set('Card', {
-    name: 'Card',
-    path: '/mock/Card.zen',
-    template: '<div class="card">Card Content</div>',
-    nodes: [{
-      type: 'element',
-      tag: 'div',
-      attributes: [{ name: 'class', value: 'card', location: { line: 1, column: 1 } }],
-      children: [{ type: 'text', value: 'Card Content', location: { line: 1, column: 1 } }],
-      location: { line: 1, column: 1 }
-    }],
-    slots: [],
-    props: [],
-    styles: [],
-    script: null,
-    scriptAttributes: null,
-    hasScript: false,
-    hasStyles: false
-  })
-  
-  const testSource = `
-<script setup="ts">
-</script>
-<div class="grid">
-  <Card />
-  <Card />
-  <Card />
-</div>
-`
-  
-  const template = parseTemplate(testSource, 'test.zen')
-  
-  console.log('Component nodes found:')
-  
-  function countComponents(nodes: any[]): number {
-    let count = 0
-    for (const node of nodes) {
-      if (node.type === 'component') {
-        console.log(`  Found component: ${node.name}`)
-        count++
-      } else if (node.type === 'element' && node.children) {
-        count += countComponents(node.children)
-      }
-    }
-    return count
-  }
-  
-  const componentCount = countComponents(template.nodes)
-  console.log(`Total component nodes before resolution: ${componentCount}`)
-  
-  const ir = {
-    filePath: 'test.zen',
-    template,
-    script: { raw: '', attributes: {} },
-    styles: []
-  }
-  
-  const resolvedIR = resolveComponentsInIR(ir, mockComponents)
-  
-  // Count card divs in resolved output - search for the attribute value
-  const jsonStr = JSON.stringify(resolvedIR.template.nodes)
-  const cardCount = (jsonStr.match(/"value":"card"/g) || []).length
-  
-  console.log(`\nResolved JSON (first 500 chars): ${jsonStr.substring(0, 500)}...`)
-  console.log(`\nCard divs in resolved output: ${cardCount} (expected: 3)`)
-  
-  const passed = cardCount === 3
-  console.log(`\n${passed ? '✅ PASSED' : '❌ FAILED'}: Multiple instances of same component`)
-  
-  return passed
-}
-
-// Test 3: Nested components
-async function testNestedComponents() {
-  console.log('\n=== Test 3: Nested Components ===\n')
-  
-  const mockComponents = new Map<string, ComponentMetadata>()
-  
-  mockComponents.set('Outer', {
-    name: 'Outer',
-    path: '/mock/Outer.zen',
-    template: '<div class="outer"><slot /></div>',
-    nodes: [{
-      type: 'element',
-      tag: 'div',
-      attributes: [{ name: 'class', value: 'outer', location: { line: 1, column: 1 } }],
-      children: [{
-        type: 'element',
-        tag: 'slot',
-        attributes: [],
-        children: [],
-        location: { line: 1, column: 1 }
-      }],
-      location: { line: 1, column: 1 }
-    }],
-    slots: [{ name: null, location: { line: 1, column: 1 } }],
-    props: [],
-    styles: [],
-    script: null,
-    scriptAttributes: null,
-    hasScript: false,
-    hasStyles: false
-  })
-  
-  mockComponents.set('Inner', {
-    name: 'Inner',
-    path: '/mock/Inner.zen',
-    template: '<span class="inner">Inner Content</span>',
-    nodes: [{
-      type: 'element',
-      tag: 'span',
-      attributes: [{ name: 'class', value: 'inner', location: { line: 1, column: 1 } }],
-      children: [{ type: 'text', value: 'Inner Content', location: { line: 1, column: 1 } }],
-      location: { line: 1, column: 1 }
-    }],
-    slots: [],
-    props: [],
-    styles: [],
-    script: null,
-    scriptAttributes: null,
-    hasScript: false,
-    hasStyles: false
-  })
-  
-  const testSource = `
-<script setup="ts">
-</script>
-<Outer>
-  <Inner />
-</Outer>
-`
-  
-  const template = parseTemplate(testSource, 'test.zen')
-  
-  const ir = {
-    filePath: 'test.zen',
-    template,
-    script: { raw: '', attributes: {} },
-    styles: []
-  }
-  
-  const resolvedIR = resolveComponentsInIR(ir, mockComponents)
-  
-  const jsonStr = JSON.stringify(resolvedIR.template.nodes)
-  const hasOuter = jsonStr.includes('"value":"outer"')
-  const hasInner = jsonStr.includes('"value":"inner"')
-  
-  console.log(`Resolved JSON (first 500 chars): ${jsonStr.substring(0, 500)}...`)
-  console.log(`Outer div present: ${hasOuter}`)
-  console.log(`Inner span present: ${hasInner}`)
-  
-  const passed = hasOuter && hasInner
-  console.log(`\n${passed ? '✅ PASSED' : '❌ FAILED'}: Nested components`)
-  
-  return passed
-}
-
-// Test 4: Auto-import naming (filename-based)
-async function testAutoImportNaming() {
-  console.log('\n=== Test 4: Auto-Import Naming ===\n')
-  
-  // Test the naming algorithm directly
-  // With the new convention, component name = filename (subdirectories are ignored)
-  const testCases = [
-    { input: 'components/Header.zen', expected: 'Header' },
-    { input: 'components/globals/Header.zen', expected: 'Header' }, // Filename only!
-    { input: 'components/ui/buttons/Primary.zen', expected: 'Primary' },
-    { input: 'components/sections/HeroSection.zen', expected: 'HeroSection' },
-    { input: 'components/ui-kit/Button.zen', expected: 'Button' },
-  ]
-  
-  let passed = true
-  
-  for (const tc of testCases) {
-    // Component name is just the filename without .zen extension
-    const result = path.basename(tc.input, '.zen')
-    
-    const match = result === tc.expected
-    console.log(`  ${match ? '✓' : '✗'} "${tc.input}" → "${result}" (expected: "${tc.expected}")`)
-    
-    if (!match) passed = false
-  }
-  
-  console.log(`\n${passed ? '✅ PASSED' : '❌ FAILED'}: Auto-import naming`)
-  
-  return passed
-}
-
-// Run all tests
-async function runTests() {
-  console.log('╔════════════════════════════════════════════╗')
-  console.log('║    Component Stacking Tests                ║')
-  console.log('╚════════════════════════════════════════════╝')
-  
-  const results = []
-  
-  results.push(await testMultipleSiblingComponents())
-  results.push(await testMultipleInstances())
-  results.push(await testNestedComponents())
-  results.push(await testAutoImportNaming())
-  
-  console.log('\n════════════════════════════════════════════')
-  console.log('Summary:')
-  console.log(`  Total: ${results.length}`)
-  console.log(`  Passed: ${results.filter(r => r).length}`)
-  console.log(`  Failed: ${results.filter(r => !r).length}`)
-  console.log('════════════════════════════════════════════\n')
-  
-  process.exit(results.every(r => r) ? 0 : 1)
-}
-
-runTests().catch(err => {
-  console.error('Test error:', err)
-  process.exit(1)
-})

package/compiler/test/map-lowering.test.ts

@@ -1,130 +0,0 @@
-import { parseTemplate } from '../parse/parseTemplate'
-import { transformTemplate } from '../transform/transformTemplate'
-import { lowerFragments } from '../transform/fragmentLowering'
-import { transformNode } from '../transform/transformNode'
-import type { ZenIR, TemplateNode, ExpressionNode, LoopFragmentNode } from '../ir/types'
-
-async function testMapLowering() {
-    console.log('--- Testing JSX .map() Lowering ---')
-
-    const source = `
-    <div>
-      {items.map((item, index) => (
-        <li key={index} class={item.active ? 'active' : ''}>
-          {item.text}
-        </li>
-      ))}
-    </div>
-  `
-
-    try {
-        const template = parseTemplate(source, 'test.zen')
-
-        // Recursive search for LoopFragmentNode
-        function findNode(nodes: TemplateNode[], type: string): any {
-            for (const node of nodes) {
-                if (node.type === type) return node
-                if ('children' in node) {
-                    const found = findNode(node.children, type)
-                    if (found) return found
-                }
-                if (node.type === 'loop-fragment') {
-                    const found = findNode(node.body, type)
-                    if (found) return found
-                }
-                if (node.type === 'conditional-fragment') {
-                    const foundC = findNode(node.consequent, type)
-                    if (foundC) return foundC
-                    const foundA = findNode(node.alternate, type)
-                    if (foundA) return foundA
-                }
-            }
-            return null
-        }
-
-        const loopNode = findNode(template.nodes, 'loop-fragment') as LoopFragmentNode
-
-        if (!loopNode) {
-            console.log('Template structure:', JSON.stringify(template.nodes, null, 2))
-            throw new Error('LoopFragmentNode not found in template')
-        }
-
-        console.assert(loopNode.source.startsWith('expr_'), 'Loop source should be an expression ID')
-        const sourceExpr = template.expressions.find(e => e.id === loopNode.source)
-        console.assert(sourceExpr?.code === 'items', `Expected source code "items", got "${sourceExpr?.code}"`)
-
-        // Check if inner expressions are registered
-        const li = loopNode.body.find(n => n.type === 'element' && n.tag === 'li') as any
-        const classAttr = li?.attributes.find((a: any) => a.name === 'class')
-        console.assert(classAttr?.value.id.startsWith('expr_'), 'Inner attribute expression should be an ID')
-
-        const textExpr = li?.children.find((n: any) => n.type === 'expression') as ExpressionNode
-        console.assert(textExpr?.expression.startsWith('expr_'), 'Inner text expression should be an ID')
-
-        // Final transformation
-        const ir: ZenIR = {
-            filePath: 'test.zen',
-            template,
-            script: null,
-            styles: []
-        }
-
-        const compiled = transformTemplate(ir)
-        console.assert(compiled.html.includes('data-zen-loop="loop_0"'), 'HTML should contain loop marker')
-        console.assert(compiled.html.includes(`data-zen-source="${loopNode.source}"`), 'HTML should contain source expression ID')
-
-        console.log('✅ JSX .map() lowering test passed')
-    } catch (e) {
-        console.error('❌ JSX .map() lowering test failed:', e)
-        process.exit(1)
-    }
-}
-
-async function testInvariantEnforcement() {
-    console.log('--- Testing INV-EXPR-REG-001 Invariant Enforcement ---')
-
-    const expressions: any[] = []
-    const badNode: ExpressionNode = {
-        type: 'expression',
-        expression: 'raw.code.here', // Should be expr_N
-        location: { line: 1, column: 1 }
-    }
-
-    try {
-        // We need to call lowerFragments but it calls assertNoRawExpressions
-        lowerFragments([badNode], 'test.zen', expressions)
-        console.error('❌ Invariant enforcement failed to catch raw expression')
-        process.exit(1)
-    } catch (e: any) {
-        console.assert(e.name === 'InvariantError', 'Expected InvariantError')
-        console.assert(e.message.includes('INV-EXPR-REG-001'), 'Expected INV-EXPR-REG-001 in error message')
-        console.log('✅ Invariant enforcement caught raw expression')
-    }
-
-    // Test transformNode safety
-    try {
-        const expressionsList: any[] = []
-        const badLoopNode: any = {
-            type: 'loop-fragment',
-            source: 'raw_source',
-            itemVar: 'item',
-            body: [],
-            location: { line: 1, column: 1 }
-        }
-        transformNode(badLoopNode, expressionsList)
-        console.error('❌ transformNode failed to catch raw loop source')
-        process.exit(1)
-    } catch (e: any) {
-        console.assert(e.name === 'InvariantError', 'Expected InvariantError in transformNode')
-        console.assert(e.message.includes('Raw loop source found'), 'Expected Loop source error')
-        console.log('✅ transformNode caught raw loop source')
-    }
-}
-
-async function runTests() {
-    await testMapLowering()
-    await testInvariantEnforcement()
-    console.log('--- All tests completed successfully ---')
-}
-
-runTests()

package/compiler/test/validate-test.ts

@@ -1,104 +0,0 @@
-/**
- * Test Cases for Expression Validation
- * 
- * Phase 8/9/10: Tests that invalid expressions fail the build
- */
-
-import { validateExpressions, validateExpressionsOrThrow } from '../validate/validateExpressions'
-import type { ExpressionIR } from '../ir/types'
-
-/**
- * Test valid expressions
- */
-function testValidExpressions() {
-  const validExpressions: ExpressionIR[] = [
-    {
-      id: 'expr_0',
-      code: 'user.name',
-      location: { line: 10, column: 5 }
-    },
-    {
-      id: 'expr_1',
-      code: 'count + 1',
-      location: { line: 11, column: 8 }
-    },
-    {
-      id: 'expr_2',
-      code: 'isActive ? "on" : "off"',
-      location: { line: 12, column: 12 }
-    }
-  ]
-  
-  const result = validateExpressions(validExpressions, 'test.zen')
-  console.assert(result.valid === true, 'Valid expressions should pass validation')
-  console.assert(result.errors.length === 0, 'Valid expressions should have no errors')
-  console.log('✅ Valid expressions test passed')
-}
-
-/**
- * Test invalid expressions
- */
-function testInvalidExpressions() {
-  const invalidExpressions: ExpressionIR[] = [
-    {
-      id: 'expr_0',
-      code: 'user.name}', // Mismatched brace
-      location: { line: 10, column: 5 }
-    }
-  ]
-  
-  const result = validateExpressions(invalidExpressions, 'test.zen')
-  console.assert(result.valid === false, 'Invalid expressions should fail validation')
-  console.assert(result.errors.length > 0, 'Invalid expressions should have errors')
-  console.log('✅ Invalid expressions test passed')
-}
-
-/**
- * Test unsafe code detection
- */
-function testUnsafeCode() {
-  const unsafeExpressions: ExpressionIR[] = [
-    {
-      id: 'expr_0',
-      code: 'eval("alert(1)")',
-      location: { line: 10, column: 5 }
-    }
-  ]
-  
-  const result = validateExpressions(unsafeExpressions, 'test.zen')
-  console.assert(result.valid === false, 'Unsafe code should fail validation')
-  console.assert(result.errors.length > 0, 'Unsafe code should have errors')
-  console.log('✅ Unsafe code detection test passed')
-}
-
-/**
- * Test validateExpressionsOrThrow
- */
-function testThrowOnInvalid() {
-  const invalidExpressions: ExpressionIR[] = [
-    {
-      id: 'expr_0',
-      code: 'user.name}', // Mismatched brace
-      location: { line: 10, column: 5 }
-    }
-  ]
-  
-  try {
-    validateExpressionsOrThrow(invalidExpressions, 'test.zen')
-    console.assert(false, 'Should have thrown on invalid expressions')
-  } catch (error) {
-    console.assert(error instanceof Error, 'Should throw Error')
-    console.log('✅ Throw on invalid expressions test passed')
-  }
-}
-
-// Run tests
-if (require.main === module) {
-  console.log('Running validation tests...')
-  testValidExpressions()
-  testInvalidExpressions()
-  testUnsafeCode()
-  testThrowOnInvalid()
-  console.log('✅ All validation tests passed!')
-}
-