ether-code 0.9.6 → 0.9.8

package/cli/ether.js

@@ -6,7 +6,7 @@ const http = require('http')
 const { EtherCompiler } = require('./compiler')
 const { Watcher } = require('./watcher')
 
-const VERSION = '0.9.6'
+const VERSION = '0.9.8'
 
 const COLORS = {
   reset: '\x1b[0m',

package/generators/html-generator.js

@@ -589,6 +589,12 @@ class HTMLGenerator {
       case 'include':
         this.generateInclude(node)
         break
+      case 'EtherCSS':
+        this.generateEtherCSS(node)
+        break
+      case 'EtherJS':
+        this.generateEtherJS(node)
+        break
       default:
         if (node.tag || node.tagName || node.name) {
           this.generateElement(node)
@@ -1069,6 +1075,58 @@ class HTMLGenerator {
     })
     return result.join('\n')
   }
+
+  generateEtherCSS(node) {
+    if (!node.source) return
+    
+    try {
+      const { EtherParserCSS } = require('./ether-parser-css')
+      const { CSSGenerator } = require('./css-generator')
+      
+      const cssParser = new EtherParserCSS()
+      const cssAst = cssParser.parse(node.source)
+      
+      const cssGenerator = new CSSGenerator()
+      cssGenerator.loadI18n('./i18n-css.json')
+      const cssOutput = cssGenerator.generate(cssAst)
+      
+      if (cssOutput) {
+        const lines = cssOutput.split('\n')
+        for (const line of lines) {
+          this.writeLine(line)
+        }
+      }
+    } catch (e) {
+      this.writeLine('/* Erreur de compilation CSS: ' + e.message + ' */')
+      this.writeLine(node.source)
+    }
+  }
+
+  generateEtherJS(node) {
+    if (!node.source) return
+    
+    try {
+      const { EtherParserJS } = require('./ether-parser-js')
+      const { JSGenerator } = require('./js-generator')
+      
+      const jsParser = new EtherParserJS()
+      const jsAst = jsParser.parse(node.source)
+      
+      const jsGenerator = new JSGenerator()
+      jsGenerator.loadI18n('./i18n-js.json')
+      const jsOutput = jsGenerator.generate(jsAst)
+      
+      if (jsOutput) {
+        const lines = jsOutput.split('\n')
+        for (const line of lines) {
+          this.writeLine(line)
+        }
+      }
+    } catch (e) {
+      this.writeLine('// Erreur de compilation JS: ' + e.message)
+      this.writeLine(node.source)
+    }
+  }
 }
 
 module.exports = {

package/generators/php-generator.js

@@ -356,8 +356,10 @@ class PHPGenerator {
     this.output = ''
     this.indent = 0
     this.closureVariables = new Set()
+    this.importedClasses = new Set()
     
     this.collectClosureVariables(ast)
+    this.collectImportedClasses(ast)
 
     if (ast.phpTag !== false) {
       this.output = '<?php\n'
@@ -382,6 +384,27 @@ class PHPGenerator {
     return this.output.trim()
   }
 
+  collectImportedClasses(ast) {
+    const nodes = Array.isArray(ast) ? ast : (ast?.body || [ast])
+    
+    for (const node of nodes) {
+      if (!node) continue
+      
+      if (node.type === 'UseStatement') {
+        if (node.imports && node.imports.length > 0) {
+          for (const imp of node.imports) {
+            const path = imp.path || imp.name || ''
+            const className = path.split('\\').pop()
+            if (className) this.importedClasses.add(className)
+          }
+        } else if (node.name) {
+          const className = node.name.split('\\').pop()
+          if (className) this.importedClasses.add(className)
+        }
+      }
+    }
+  }
+
   collectClosureVariables(ast) {
     const nodes = Array.isArray(ast) ? ast : (ast?.body || [ast])
     
@@ -963,6 +986,12 @@ class PHPGenerator {
   }
 
   prefixGlobalClass(name) {
+    if (!name) return name
+    
+    if (this.importedClasses && this.importedClasses.has(name)) {
+      return name
+    }
+    
     const phpGlobalClasses = [
       'Exception', 'Error', 'TypeError', 'ValueError', 'ArgumentCountError',
       'ArithmeticError', 'DivisionByZeroError', 'ParseError', 'AssertionError',

package/lexer/ether-lexer.js

@@ -419,7 +419,7 @@ class EtherLexer {
           break
         }
         if (this.peek() === '\n') {
-          this.tokens.push(new Token(TokenType.ERROR, 'Chaîne non terminée', startLine, startCol, this.currentIndent))
+          this.tokens.push(new Token(TokenType.ERROR, 'Chaîne non terminée', startLine, startCol, this.currentIndent))
           return
         }
       }
@@ -458,7 +458,7 @@ class EtherLexer {
             value += String.fromCodePoint(parseInt(unicode, 16))
             break
           default:
-            value += escaped
+            value += '\\' + escaped
         }
       } else {
         value += this.advance()
@@ -1001,7 +1001,7 @@ class EtherLexer {
         break
 
       default:
-        this.tokens.push(new Token(TokenType.ERROR, `Caractère inattendu: ${char}`, startLine, startCol, this.currentIndent))
+        this.tokens.push(new Token(TokenType.ERROR, `Caractère inattendu: ${char}`, startLine, startCol, this.currentIndent))
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ether-code",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "description": "Ether - Le langage intentionnel",
   "main": "cli/compiler.js",
   "bin": {

package/parsers/ether-parser-html.js

@@ -118,14 +118,14 @@ class EtherParserHTML extends EtherParserBase {
       'lecture': ['seule', 'auto'],
       'nouvelle': ['fenetre'],
       'a': ['popup'],
-      'jeu': ['caracteres', 'caractères'],
+      'jeu': ['caracteres', 'caractères'],
       'equivalent': ['http'],
-      'équivalent': ['http'],
+      'équivalent': ['http'],
       'fusion': ['colonnes', 'lignes'],
-      'plein': ['ecran', 'écran'],
+      'plein': ['ecran', 'écran'],
       'bac': ['sable'],
-      'origine': ['croisee', 'croisée'],
-      'sources': ['reactives', 'réactives']
+      'origine': ['croisee', 'croisée'],
+      'sources': ['reactives', 'réactives']
     }
     
     while (!this.isAtEnd()) {
@@ -203,9 +203,22 @@ class EtherParserHTML extends EtherParserBase {
     const rawContentTags = ['script', 'style']
     const isRawContent = rawContentTags.includes(tag)
     const isScript = tag === 'script'
+    const isStyle = tag === 'style'
     
     if (this.match(TokenType.INDENT)) {
-      if (isRawContent) {
+      if (isStyle) {
+        const etherSource = this.collectEtherBlock()
+        children.push({
+          type: 'EtherCSS',
+          source: etherSource
+        })
+      } else if (isScript) {
+        const etherSource = this.collectEtherBlock()
+        children.push({
+          type: 'EtherJS',
+          source: etherSource
+        })
+      } else if (isRawContent) {
         let rawText = []
         while (!this.isAtEnd()) {
           const current = this.current()
@@ -227,11 +240,7 @@ class EtherParserHTML extends EtherParserBase {
           }
           
           if (current && current.type === TokenType.STRING) {
-            if (isScript) {
-              rawText.push("'" + current.value.replace(/'/g, "\\'") + "'")
-            } else {
-              rawText.push(current.value)
-            }
+            rawText.push(current.value)
             this.advance()
             continue
           }
@@ -321,6 +330,84 @@ class EtherParserHTML extends EtherParserBase {
     return String(token.value)
   }
 
+  collectEtherBlock() {
+    const lines = []
+    let currentLine = []
+    let indentDepth = 1
+    
+    while (!this.isAtEnd()) {
+      const current = this.current()
+      
+      if (current && current.type === TokenType.DEDENT) {
+        if (currentLine.length > 0) {
+          lines.push('  '.repeat(Math.max(0, indentDepth - 1)) + this.joinTokens(currentLine))
+          currentLine = []
+        }
+        indentDepth--
+        this.advance()
+        if (indentDepth <= 0) {
+          break
+        }
+        continue
+      }
+      
+      if (current && current.type === TokenType.INDENT) {
+        if (currentLine.length > 0) {
+          lines.push('  '.repeat(Math.max(0, indentDepth - 1)) + this.joinTokens(currentLine))
+          currentLine = []
+        }
+        indentDepth++
+        this.advance()
+        continue
+      }
+      
+      if (current && current.type === TokenType.NEWLINE) {
+        if (currentLine.length > 0) {
+          lines.push('  '.repeat(Math.max(0, indentDepth - 1)) + this.joinTokens(currentLine))
+          currentLine = []
+        }
+        this.advance()
+        continue
+      }
+      
+      if (!current || current.type === TokenType.EOF) break
+      
+      if (current.type === TokenType.STRING) {
+        currentLine.push('"' + current.value + '"')
+      } else {
+        currentLine.push(this.tokenToString(current))
+      }
+      this.advance()
+    }
+    
+    if (currentLine.length > 0) {
+      lines.push('  '.repeat(Math.max(0, indentDepth - 1)) + this.joinTokens(currentLine))
+    }
+    
+    return lines.join('\n')
+  }
+
+  joinTokens(tokens) {
+    let result = ''
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i]
+      const prevToken = i > 0 ? tokens[i - 1] : null
+      
+      const noSpaceBefore = [':', ',', ')', ']']
+      const noSpaceAfter = ['.', '#', '(', '[', '::', '-']
+      
+      if (i > 0) {
+        const needSpace = !noSpaceBefore.includes(token) && !noSpaceAfter.includes(prevToken)
+        if (needSpace) {
+          result += ' '
+        }
+      }
+      
+      result += token
+    }
+    return result
+  }
+
   processCompoundTags(tagName) {
     const nextToken = this.current()
     if (!nextToken || nextToken.type !== TokenType.IDENTIFIER) {
@@ -585,4 +672,4 @@ class EtherParserHTML extends EtherParserBase {
   }
 }
 
-module.exports = { EtherParserHTML }
+module.exports = { EtherParserHTML }