ether-code 0.1.9 → 0.2.0

package/cli/ether.js

@@ -0,0 +1,534 @@
+#!/usr/bin/env node
+
+const fs = require('fs')
+const path = require('path')
+const { EtherCompiler } = require('./compiler')
+const { Watcher } = require('./watcher')
+
+const VERSION = '0.2.0'
+
+const COLORS = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m'
+}
+
+function log(msg, color = '') {
+  console.log(`${color}${msg}${COLORS.reset}`)
+}
+
+function logSuccess(msg) {
+  log(`✓ ${msg}`, COLORS.green)
+}
+
+function logError(msg) {
+  log(`✗ ${msg}`, COLORS.red)
+}
+
+function logInfo(msg) {
+  log(`ℹ ${msg}`, COLORS.cyan)
+}
+
+function logWarning(msg) {
+  log(`⚠ ${msg}`, COLORS.yellow)
+}
+
+function showBanner() {
+  console.log(`
+${COLORS.cyan}${COLORS.bright}
+  ███████╗████████╗██╗  ██╗███████╗██████╗ 
+  ██╔════╝╚══██╔══╝██║  ██║██╔════╝██╔══██╗
+  █████╗     ██║   ███████║█████╗  ██████╔╝
+  ██╔══╝     ██║   ██╔══██║██╔══╝  ██╔══██╗
+  ███████╗   ██║   ██║  ██║███████╗██║  ██║
+  ╚══════╝   ╚═╝   ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝
+${COLORS.reset}
+  ${COLORS.dim}Le langage intentionnel - v${VERSION}${COLORS.reset}
+`)
+}
+
+function showHelp() {
+  showBanner()
+  console.log(`
+${COLORS.bright}UTILISATION${COLORS.reset}
+  ether <commande> [options]
+
+${COLORS.bright}COMMANDES${COLORS.reset}
+  ${COLORS.cyan}init${COLORS.reset}              Initialiser un nouveau projet Ether
+  ${COLORS.cyan}build${COLORS.reset}             Compiler les fichiers .eth
+  ${COLORS.cyan}dev${COLORS.reset}               Mode développement (watch + compilation auto)
+  ${COLORS.cyan}check${COLORS.reset}             Vérifier la syntaxe sans compiler
+  ${COLORS.cyan}help${COLORS.reset}              Afficher cette aide
+  ${COLORS.cyan}version${COLORS.reset}           Afficher la version
+
+${COLORS.bright}OPTIONS${COLORS.reset}
+  -c, --config        Chemin vers le fichier de configuration
+  -o, --output        Dossier de sortie
+  -w, --watch         Surveiller les changements (alias de dev)
+  -v, --verbose       Mode verbeux
+  -q, --quiet         Mode silencieux
+  --no-color          Désactiver les couleurs
+
+${COLORS.bright}EXEMPLES${COLORS.reset}
+  ${COLORS.dim}# Initialiser un projet${COLORS.reset}
+  ether init
+
+  ${COLORS.dim}# Compiler le projet${COLORS.reset}
+  ether build
+
+  ${COLORS.dim}# Mode développement${COLORS.reset}
+  ether dev
+
+  ${COLORS.dim}# Compiler avec config personnalisée${COLORS.reset}
+  ether build -c ./mon-config.js
+
+${COLORS.bright}DOCUMENTATION${COLORS.reset}
+  https://ether-code.com/docs
+`)
+}
+
+function showVersion() {
+  console.log(`Ether v${VERSION}`)
+}
+
+function loadConfig(configPath) {
+  const defaultConfig = {
+    src: './src',
+    out: './dist',
+    targets: {},
+    i18n: 'fr',
+    watch: {
+      ignored: ['node_modules', '.git', 'dist']
+    }
+  }
+
+  const configFile = configPath || path.join(process.cwd(), 'ether.config.js')
+  
+  if (fs.existsSync(configFile)) {
+    try {
+      const userConfig = require(configFile)
+      return { ...defaultConfig, ...userConfig }
+    } catch (err) {
+      logError(`Erreur de configuration: ${err.message}`)
+      return defaultConfig
+    }
+  }
+  
+  const jsonConfig = path.join(process.cwd(), 'ether.config.json')
+  if (fs.existsSync(jsonConfig)) {
+    try {
+      const content = fs.readFileSync(jsonConfig, 'utf-8')
+      const userConfig = JSON.parse(content)
+      return { ...defaultConfig, ...userConfig }
+    } catch (err) {
+      logError(`Erreur de configuration: ${err.message}`)
+      return defaultConfig
+    }
+  }
+
+  return defaultConfig
+}
+
+async function cmdInit() {
+  showBanner()
+  logInfo('Initialisation du projet Ether...')
+  
+  const cwd = process.cwd()
+  
+  const srcDir = path.join(cwd, 'src')
+  if (!fs.existsSync(srcDir)) {
+    fs.mkdirSync(srcDir, { recursive: true })
+    logSuccess('Dossier src/ créé')
+  }
+  
+  const distDir = path.join(cwd, 'dist')
+  if (!fs.existsSync(distDir)) {
+    fs.mkdirSync(distDir, { recursive: true })
+    logSuccess('Dossier dist/ créé')
+  }
+
+  const configContent = `module.exports = {
+  src: './src',
+  out: './dist',
+  
+  i18n: 'fr',
+  
+  targets: {
+    css: {
+      extension: '.css',
+      minify: false
+    },
+    html: {
+      extension: '.html',
+      minify: false
+    },
+    js: {
+      extension: '.js',
+      minify: false
+    }
+  },
+  
+  watch: {
+    ignored: ['node_modules', '.git', 'dist']
+  }
+}
+`
+
+  const configPath = path.join(cwd, 'ether.config.js')
+  if (!fs.existsSync(configPath)) {
+    fs.writeFileSync(configPath, configContent)
+    logSuccess('Fichier ether.config.js créé')
+  } else {
+    logWarning('ether.config.js existe déjà')
+  }
+
+  const exampleEth = `// cible: html
+
+document
+  tete
+    titre "Ma première page Ether"
+  
+  corps
+    entete
+      titre1 "Bienvenue sur Ether"
+    
+    principal
+      section
+        titre2 "Le langage intentionnel"
+        paragraphe "Ether permet d'écrire du code comme on pense."
+        
+    pied
+      paragraphe "Créé avec Ether"
+`
+
+  const examplePath = path.join(srcDir, 'index.eth')
+  if (!fs.existsSync(examplePath)) {
+    fs.writeFileSync(examplePath, exampleEth)
+    logSuccess('Fichier exemple src/index.eth créé')
+  }
+
+  console.log('')
+  logSuccess('Projet initialisé avec succès!')
+  console.log('')
+  logInfo('Prochaines étapes:')
+  console.log(`  1. Éditer ${COLORS.cyan}src/index.eth${COLORS.reset}`)
+  console.log(`  2. Lancer ${COLORS.cyan}ether dev${COLORS.reset} pour le mode développement`)
+  console.log(`  3. Ou ${COLORS.cyan}ether build${COLORS.reset} pour compiler`)
+  console.log('')
+}
+
+async function cmdBuild(options) {
+  const startTime = Date.now()
+  
+  if (!options.quiet) {
+    showBanner()
+    logInfo('Compilation en cours...')
+    console.log('')
+  }
+  
+  const config = loadConfig(options.config)
+  const srcDir = path.resolve(process.cwd(), config.src)
+  const outDir = path.resolve(process.cwd(), options.output || config.out)
+  
+  if (!fs.existsSync(srcDir)) {
+    logError(`Dossier source introuvable: ${srcDir}`)
+    process.exit(1)
+  }
+  
+  if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir, { recursive: true })
+  }
+  
+  const compiler = new EtherCompiler(config)
+  
+  const files = findEthFiles(srcDir)
+  
+  if (files.length === 0) {
+    logWarning('Aucun fichier .eth trouvé')
+    return
+  }
+  
+  let successCount = 0
+  let errorCount = 0
+  
+  for (const file of files) {
+    try {
+      const relativePath = path.relative(srcDir, file)
+      const result = await compiler.compileFile(file)
+      
+      for (const output of result.outputs) {
+        const outPath = path.join(outDir, output.path)
+        const outDirPath = path.dirname(outPath)
+        
+        if (!fs.existsSync(outDirPath)) {
+          fs.mkdirSync(outDirPath, { recursive: true })
+        }
+        
+        fs.writeFileSync(outPath, output.content)
+        
+        if (options.verbose) {
+          logSuccess(`${relativePath} → ${output.path}`)
+        }
+      }
+      
+      successCount++
+    } catch (err) {
+      errorCount++
+      logError(`${path.relative(srcDir, file)}: ${err.message}`)
+      
+      if (options.verbose) {
+        console.error(err.stack)
+      }
+    }
+  }
+  
+  const duration = Date.now() - startTime
+  
+  console.log('')
+  if (errorCount === 0) {
+    logSuccess(`${successCount} fichier(s) compilé(s) en ${duration}ms`)
+  } else {
+    logWarning(`${successCount} succès, ${errorCount} erreur(s) en ${duration}ms`)
+  }
+}
+
+async function cmdDev(options) {
+  showBanner()
+  
+  const config = loadConfig(options.config)
+  const srcDir = path.resolve(process.cwd(), config.src)
+  const outDir = path.resolve(process.cwd(), options.output || config.out)
+  
+  if (!fs.existsSync(srcDir)) {
+    logError(`Dossier source introuvable: ${srcDir}`)
+    process.exit(1)
+  }
+  
+  logInfo(`Surveillance de ${srcDir}`)
+  logInfo(`Sortie vers ${outDir}`)
+  
+  await cmdBuild({ ...options, quiet: true })
+  
+  const watcher = new Watcher(srcDir, config.watch)
+  const compiler = new EtherCompiler(config)
+  
+  watcher.on('change', async (filePath) => {
+    if (!filePath.endsWith('.eth')) return
+    
+    const relativePath = path.relative(srcDir, filePath)
+    logInfo(`Modification: ${relativePath}`)
+    
+    try {
+      const result = await compiler.compileFile(filePath)
+      
+      for (const output of result.outputs) {
+        const outPath = path.join(outDir, output.path)
+        const outDirPath = path.dirname(outPath)
+        
+        if (!fs.existsSync(outDirPath)) {
+          fs.mkdirSync(outDirPath, { recursive: true })
+        }
+        
+        fs.writeFileSync(outPath, output.content)
+        logSuccess(`→ ${output.path}`)
+      }
+    } catch (err) {
+      logError(err.message)
+    }
+  })
+  
+  watcher.on('add', async (filePath) => {
+    if (!filePath.endsWith('.eth')) return
+    
+    const relativePath = path.relative(srcDir, filePath)
+    logInfo(`Nouveau fichier: ${relativePath}`)
+    
+    try {
+      const result = await compiler.compileFile(filePath)
+      
+      for (const output of result.outputs) {
+        const outPath = path.join(outDir, output.path)
+        const outDirPath = path.dirname(outPath)
+        
+        if (!fs.existsSync(outDirPath)) {
+          fs.mkdirSync(outDirPath, { recursive: true })
+        }
+        
+        fs.writeFileSync(outPath, output.content)
+        logSuccess(`→ ${output.path}`)
+      }
+    } catch (err) {
+      logError(err.message)
+    }
+  })
+  
+  watcher.on('unlink', (filePath) => {
+    if (!filePath.endsWith('.eth')) return
+    logWarning(`Fichier supprimé: ${path.relative(srcDir, filePath)}`)
+  })
+  
+  watcher.start()
+  
+  process.on('SIGINT', () => {
+    console.log('')
+    logInfo('Arrêt du mode développement')
+    watcher.stop()
+    process.exit(0)
+  })
+}
+
+async function cmdCheck(options) {
+  showBanner()
+  logInfo('Vérification de la syntaxe...')
+  console.log('')
+  
+  const config = loadConfig(options.config)
+  const srcDir = path.resolve(process.cwd(), config.src)
+  
+  if (!fs.existsSync(srcDir)) {
+    logError(`Dossier source introuvable: ${srcDir}`)
+    process.exit(1)
+  }
+  
+  const compiler = new EtherCompiler(config)
+  const files = findEthFiles(srcDir)
+  
+  if (files.length === 0) {
+    logWarning('Aucun fichier .eth trouvé')
+    return
+  }
+  
+  let validCount = 0
+  let errorCount = 0
+  
+  for (const file of files) {
+    const relativePath = path.relative(srcDir, file)
+    
+    try {
+      await compiler.check(file)
+      logSuccess(relativePath)
+      validCount++
+    } catch (err) {
+      logError(`${relativePath}: ${err.message}`)
+      errorCount++
+    }
+  }
+  
+  console.log('')
+  if (errorCount === 0) {
+    logSuccess(`${validCount} fichier(s) valide(s)`)
+  } else {
+    logError(`${errorCount} erreur(s) sur ${files.length} fichier(s)`)
+    process.exit(1)
+  }
+}
+
+function findEthFiles(dir) {
+  const files = []
+  
+  function scan(currentDir) {
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true })
+    
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name)
+      
+      if (entry.isDirectory()) {
+        if (!['node_modules', '.git', 'dist'].includes(entry.name)) {
+          scan(fullPath)
+        }
+      } else if (entry.name.endsWith('.eth')) {
+        files.push(fullPath)
+      }
+    }
+  }
+  
+  scan(dir)
+  return files
+}
+
+function parseArgs(args) {
+  const options = {
+    command: null,
+    config: null,
+    output: null,
+    verbose: false,
+    quiet: false,
+    watch: false
+  }
+  
+  let i = 0
+  while (i < args.length) {
+    const arg = args[i]
+    
+    if (arg === '-c' || arg === '--config') {
+      options.config = args[++i]
+    } else if (arg === '-o' || arg === '--output') {
+      options.output = args[++i]
+    } else if (arg === '-v' || arg === '--verbose') {
+      options.verbose = true
+    } else if (arg === '-q' || arg === '--quiet') {
+      options.quiet = true
+    } else if (arg === '-w' || arg === '--watch') {
+      options.watch = true
+    } else if (arg === '--no-color') {
+      for (const key in COLORS) {
+        COLORS[key] = ''
+      }
+    } else if (!arg.startsWith('-')) {
+      if (!options.command) {
+        options.command = arg
+      }
+    }
+    
+    i++
+  }
+  
+  return options
+}
+
+async function main() {
+  const args = process.argv.slice(2)
+  const options = parseArgs(args)
+  
+  if (options.watch && !options.command) {
+    options.command = 'dev'
+  }
+  
+  switch (options.command) {
+    case 'init':
+      await cmdInit()
+      break
+    case 'build':
+      await cmdBuild(options)
+      break
+    case 'dev':
+    case 'watch':
+      await cmdDev(options)
+      break
+    case 'check':
+      await cmdCheck(options)
+      break
+    case 'version':
+    case '-V':
+    case '--version':
+      showVersion()
+      break
+    case 'help':
+    case '-h':
+    case '--help':
+    default:
+      showHelp()
+      break
+  }
+}
+
+main().catch(err => {
+  logError(err.message)
+  process.exit(1)
+})

package/cli/watcher.js

@@ -0,0 +1,106 @@
+const fs = require('fs')
+const path = require('path')
+const EventEmitter = require('events')
+
+class Watcher extends EventEmitter {
+  constructor(dir, options = {}) {
+    super()
+    this.dir = dir
+    this.options = {
+      ignored: ['node_modules', '.git', 'dist'],
+      debounce: 100,
+      ...options
+    }
+    this.watchers = new Map()
+    this.debounceTimers = new Map()
+  }
+
+  start() {
+    this.watchDir(this.dir)
+  }
+
+  stop() {
+    for (const watcher of this.watchers.values()) {
+      watcher.close()
+    }
+    this.watchers.clear()
+    
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer)
+    }
+    this.debounceTimers.clear()
+  }
+
+  watchDir(dir) {
+    if (this.isIgnored(dir)) return
+
+    try {
+      const watcher = fs.watch(dir, { persistent: true }, (eventType, filename) => {
+        if (!filename) return
+        
+        const fullPath = path.join(dir, filename)
+        this.handleEvent(eventType, fullPath)
+      })
+
+      watcher.on('error', (err) => {
+        this.emit('error', err)
+      })
+
+      this.watchers.set(dir, watcher)
+
+      const entries = fs.readdirSync(dir, { withFileTypes: true })
+      for (const entry of entries) {
+        if (entry.isDirectory() && !this.isIgnored(entry.name)) {
+          this.watchDir(path.join(dir, entry.name))
+        }
+      }
+    } catch (err) {
+      this.emit('error', err)
+    }
+  }
+
+  handleEvent(eventType, filePath) {
+    const existing = this.debounceTimers.get(filePath)
+    if (existing) {
+      clearTimeout(existing)
+    }
+
+    const timer = setTimeout(() => {
+      this.debounceTimers.delete(filePath)
+      this.processEvent(filePath)
+    }, this.options.debounce)
+
+    this.debounceTimers.set(filePath, timer)
+  }
+
+  processEvent(filePath) {
+    try {
+      const exists = fs.existsSync(filePath)
+      
+      if (!exists) {
+        this.emit('unlink', filePath)
+        return
+      }
+
+      const stat = fs.statSync(filePath)
+      
+      if (stat.isDirectory()) {
+        if (!this.watchers.has(filePath)) {
+          this.watchDir(filePath)
+          this.emit('addDir', filePath)
+        }
+      } else {
+        this.emit('change', filePath)
+      }
+    } catch (err) {
+      this.emit('error', err)
+    }
+  }
+
+  isIgnored(name) {
+    const baseName = path.basename(name)
+    return this.options.ignored.includes(baseName) || baseName.startsWith('.')
+  }
+}
+
+module.exports = { Watcher }

package/ether-compiler.js

@@ -1,6 +1,6 @@
 const fs = require('fs')
 const path = require('path')
-const { EtherLexer, TokenType } = require('./ether-lexer')
+const { EtherLexer, TokenType } = require('./lexer/ether-lexer')
 const { EtherParser } = require('./ether-parser')
 const { CSSGenerator } = require('./generators/css-generator')
 const { HTMLGenerator } = require('./generators/html-generator')

package/ether-parser.js

@@ -1,5 +1,5 @@
 const fs = require('fs')
-const { EtherLexer, Token, TokenType } = require('./ether-lexer')
+const { EtherLexer, Token, TokenType } = require('./lexer/ether-lexer')
 
 class EtherParser {
   constructor(options = {}) {