ether-code 0.6.3 → 0.6.5

package/cli/compiler.js

@@ -70,20 +70,52 @@ class EtherCompiler {
     this.parser = null
     this.resolvedIncludes = new Set()
     
-    this.initGenerators()
     this.initParser()
+    this.initGenerators()
   }
 
   initGenerators() {
     const i18nDir = path.join(__dirname, '..', 'i18n')
     
+    const jsI18n = path.join(i18nDir, 'i18n-js.json')
+    if (fs.existsSync(jsI18n)) {
+      this.generators['js'] = new JSGenerator(jsI18n)
+    } else {
+      this.generators['js'] = new JSGenerator()
+    }
+    this.generators['javascript'] = this.generators['js']
+    
+    const cssI18n = path.join(i18nDir, 'i18n-css.json')
+    if (fs.existsSync(cssI18n)) {
+      this.generators['css'] = new CSSGenerator(cssI18n)
+    } else {
+      this.generators['css'] = new CSSGenerator()
+    }
+    
     for (const [target, GeneratorClass] of Object.entries(GENERATORS)) {
+      if (target === 'js' || target === 'javascript' || target === 'css') {
+        continue
+      }
+      
       const i18nFile = path.join(i18nDir, `i18n-${this.normalizeTarget(target)}.json`)
       
-      if (fs.existsSync(i18nFile)) {
-        this.generators[target] = new GeneratorClass(i18nFile)
+      if (target === 'html') {
+        const options = {
+          parser: this.parser,
+          jsGenerator: this.generators['js'],
+          cssGenerator: this.generators['css']
+        }
+        if (fs.existsSync(i18nFile)) {
+          this.generators[target] = new GeneratorClass(i18nFile, options)
+        } else {
+          this.generators[target] = new GeneratorClass(null, options)
+        }
       } else {
-        this.generators[target] = new GeneratorClass()
+        if (fs.existsSync(i18nFile)) {
+          this.generators[target] = new GeneratorClass(i18nFile)
+        } else {
+          this.generators[target] = new GeneratorClass()
+        }
       }
     }
   }

package/cli/ether.js

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

package/ether-parser.js

@@ -17,16 +17,16 @@ class EtherParser {
   initCompoundTerms() {
     this.compoundOperators = {
       'strictement egal': '===',
-      'strictement égal': '===',
+      'strictement égal': '===',
       'strictement different': '!==',
-      'strictement différent': '!==',
+      'strictement différent': '!==',
       'superieur ou egal': '>=',
-      'supérieur ou égal': '>=',
+      'supérieur ou égal': '>=',
       'inferieur ou egal': '<=',
-      'inférieur ou égal': '<=',
+      'inférieur ou égal': '<=',
       'coalescence nulle': '??',
       'chainage optionnel': '?.',
-      'chaînage optionnel': '?.'
+      'chaînage optionnel': '?.'
     }
     
     this.compoundKeywords = {
@@ -36,7 +36,7 @@ class EtherParser {
       'fonction asynchrone': 'async function',
       'fonction async': 'async function',
       'fonction generatrice': 'function*',
-      'fonction génératrice': 'function*',
+      'fonction génératrice': 'function*',
       'variable globale': 'var'
     }
 
@@ -281,7 +281,7 @@ class EtherParser {
   expect(type) {
     const token = this.current()
     if (!token || token.type !== type) {
-      throw new Error(`Attendu ${type}, reçu ${token ? token.type : 'EOF'}`)
+      throw new Error(`Attendu ${type}, reçu ${token ? token.type : 'EOF'}`)
     }
     return this.advance()
   }
@@ -695,7 +695,7 @@ class EtherParser {
       'alignement': ['texte'],
       'decoration': ['texte'],
       'transformation': ['texte'],
-      'ombre': ['texte', 'boite', 'boîte'],
+      'ombre': ['texte', 'boite', 'boîte'],
       'espacement': ['lettres'],
       'bordure': ['haut', 'bas', 'gauche', 'droite', 'couleur', 'style', 'largeur', 'arrondi'],
       'couleur': ['bordure', 'fond', 'texte', 'remplissage'],
@@ -706,19 +706,19 @@ class EtherParser {
       'direction': ['flex'],
       'enveloppe': ['flex'],
       'justifier': ['contenu'],
-      'aligner': ['elements', 'éléments', 'contenu'],
+      'aligner': ['elements', 'éléments', 'contenu'],
       'colonnes': ['grille'],
       'lignes': ['grille'],
       'espace': ['ligne', 'colonne', 'blanc'],
-      'débordement': ['x', 'y'],
+      'débordement': ['x', 'y'],
       'debordement': ['x', 'y'],
-      'événements': ['pointeur'],
+      'événements': ['pointeur'],
       'evenements': ['pointeur'],
-      'modèle': ['boite', 'boîte'],
-      'modele': ['boite', 'boîte'],
+      'modèle': ['boite', 'boîte'],
+      'modele': ['boite', 'boîte'],
       'filtre': ['fond'],
       'decoupe': ['fond'],
-      'découpe': ['fond'],
+      'découpe': ['fond'],
       'origine': ['transformation', 'perspective'],
       'liste': ['style', 'type', 'position', 'image'],
     }
@@ -1178,6 +1178,7 @@ class EtherParser {
   parseHTMLElement() {
     const tagToken = this.current()
     let tagName = this.normalizeAccents(tagToken.value)
+    const originalTagName = tagName
     this.advance()
     
     const includeKeywords = ['inclure', 'requiert', 'include', 'require', 'importer']
@@ -1565,21 +1566,258 @@ class EtherParser {
       })
     }
     
+    const rawContentTags = ['script', 'style']
+    const isRawContent = rawContentTags.includes(tag)
+    const isScript = tag === 'script'
+    
     if (this.match(TokenType.INDENT)) {
-      while (!this.isAtEnd()) {
-        const current = this.current()
-        
-        if (current && current.type === TokenType.DEDENT) {
-          this.advance()
-          break
+      if (isRawContent) {
+        let rawText = []
+        while (!this.isAtEnd()) {
+          const current = this.current()
+          
+          if (current && current.type === TokenType.DEDENT) {
+            this.advance()
+            break
+          }
+          
+          if (current && current.type === TokenType.NEWLINE) {
+            rawText.push('\n')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.INDENT) {
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.STRING) {
+            if (isScript) {
+              rawText.push("'" + current.value.replace(/'/g, "\\'") + "'")
+            } else {
+              rawText.push(current.value)
+            }
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.LPAREN) {
+            rawText.push('(')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.RPAREN) {
+            rawText.push(')')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.LBRACKET) {
+            rawText.push('[')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.RBRACKET) {
+            rawText.push(']')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.LBRACE) {
+            rawText.push('{')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.RBRACE) {
+            rawText.push('}')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.DOT) {
+            rawText.push('.')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.COMMA) {
+            rawText.push(',')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.COLON) {
+            rawText.push(':')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.EQUALS) {
+            rawText.push('=')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.DOUBLE_EQUALS) {
+            rawText.push('==')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.NOT_EQUALS) {
+            rawText.push('!=')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.BANG) {
+            rawText.push('!')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.PLUS) {
+            rawText.push(current.value)
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.MINUS) {
+            rawText.push(current.value)
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.STAR) {
+            rawText.push(current.value)
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.SLASH) {
+            rawText.push('/')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.PERCENT) {
+            rawText.push('%')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.AMPERSAND) {
+            rawText.push('&')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.DOUBLE_AMPERSAND) {
+            rawText.push('&&')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.PIPE) {
+            rawText.push('|')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.DOUBLE_PIPE) {
+            rawText.push('||')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.LT) {
+            rawText.push('<')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.GT) {
+            rawText.push('>')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.LTE) {
+            rawText.push('<=')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.GTE) {
+            rawText.push('>=')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.QUESTION) {
+            rawText.push('?')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.FAT_ARROW) {
+            rawText.push('=>')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.ARROW) {
+            rawText.push('->')
+            this.advance()
+            continue
+          }
+          
+          if (current && current.type === TokenType.SEMICOLON) {
+            rawText.push(';')
+            this.advance()
+            continue
+          }
+          
+          if (current) {
+            rawText.push(String(current.value))
+            this.advance()
+          }
         }
         
-        const child = this.parseHTMLNode()
-        if (child) {
-          children.push(child)
+        const textContent = rawText.join('').trim()
+        if (textContent) {
+          children.push({
+            type: 'Text',
+            content: textContent
+          })
         }
-        
-        this.skipNewlines()
+      } else {
+        while (!this.isAtEnd()) {
+          const current = this.current()
+          
+          if (current && current.type === TokenType.DEDENT) {
+            this.advance()
+            break
+          }
+          
+          const child = this.parseHTMLNode()
+          if (child) {
+            children.push(child)
+          }
+          
+          this.skipNewlines()
+        }
+      }
+    }
+    
+    if (originalTagName === 'document') {
+      return {
+        type: 'Doctype',
+        children: children
       }
     }
     
@@ -1782,7 +2020,8 @@ class EtherParser {
       'zone': 'area'
     }
     
-    return translations[lower] || translations[withSpaces] || map[lower] || map[withSpaces] || tag
+    const result = translations[lower] || translations[withSpaces] || map[lower] || map[withSpaces] || tag
+    return result.replace(/^<!DOCTYPE\s+/i, '').replace(/^<|>$/g, '').trim() || 'div'
   }
 
   parseJS() {
@@ -2557,16 +2796,16 @@ class EtherParser {
     let left = this.parseComparison(lang)
     
     while (true) {
-      if (this.matchValue('strictement egal') || this.matchValue('strictement égal')) {
+      if (this.matchValue('strictement egal') || this.matchValue('strictement égal')) {
         const right = this.parseComparison(lang)
         left = { type: 'BinaryExpression', operator: '===', left, right }
-      } else if (this.matchValue('strictement different') || this.matchValue('strictement différent')) {
+      } else if (this.matchValue('strictement different') || this.matchValue('strictement différent')) {
         const right = this.parseComparison(lang)
         left = { type: 'BinaryExpression', operator: '!==', left, right }
-      } else if (this.match(TokenType.DOUBLE_EQUALS) || this.matchValue('egal') || this.matchValue('egale') || this.matchValue('égal')) {
+      } else if (this.match(TokenType.DOUBLE_EQUALS) || this.matchValue('egal') || this.matchValue('egale') || this.matchValue('égal')) {
         const right = this.parseComparison(lang)
         left = { type: 'BinaryExpression', operator: '===', left, right }
-      } else if (this.match(TokenType.NOT_EQUALS) || this.matchValue('different') || this.matchValue('différent')) {
+      } else if (this.match(TokenType.NOT_EQUALS) || this.matchValue('different') || this.matchValue('différent')) {
         const right = this.parseComparison(lang)
         left = { type: 'BinaryExpression', operator: '!==', left, right }
       } else {
@@ -2581,16 +2820,16 @@ class EtherParser {
     let left = this.parseAdditive(lang)
     
     while (true) {
-      if (this.matchValue('superieur ou egal') || this.matchValue('supérieur ou égal') || this.match(TokenType.GTE)) {
+      if (this.matchValue('superieur ou egal') || this.matchValue('supérieur ou égal') || this.match(TokenType.GTE)) {
         const right = this.parseAdditive(lang)
         left = { type: 'BinaryExpression', operator: '>=', left, right }
-      } else if (this.matchValue('inferieur ou egal') || this.matchValue('inférieur ou égal') || this.match(TokenType.LTE)) {
+      } else if (this.matchValue('inferieur ou egal') || this.matchValue('inférieur ou égal') || this.match(TokenType.LTE)) {
         const right = this.parseAdditive(lang)
         left = { type: 'BinaryExpression', operator: '<=', left, right }
-      } else if (this.match(TokenType.LT) || this.matchValue('inferieur') || this.matchValue('inférieur')) {
+      } else if (this.match(TokenType.LT) || this.matchValue('inferieur') || this.matchValue('inférieur')) {
         const right = this.parseAdditive(lang)
         left = { type: 'BinaryExpression', operator: '<', left, right }
-      } else if (this.match(TokenType.GT) || this.matchValue('superieur') || this.matchValue('supérieur')) {
+      } else if (this.match(TokenType.GT) || this.matchValue('superieur') || this.matchValue('supérieur')) {
         const right = this.parseAdditive(lang)
         left = { type: 'BinaryExpression', operator: '>', left, right }
       } else {

package/generators/html-generator.js

@@ -1,7 +1,7 @@
 const fs = require('fs')
 
 class HTMLGenerator {
-  constructor(i18nPath = null) {
+  constructor(i18nPath = null, options = {}) {
     this.i18n = null
     this.indent = 0
     this.output = ''
@@ -15,6 +15,10 @@ class HTMLGenerator {
     this.multiWordTags = []
     this.multiWordAttrs = []
     
+    this.parser = options.parser || null
+    this.jsGenerator = options.jsGenerator || null
+    this.cssGenerator = options.cssGenerator || null
+    
     if (i18nPath) {
       this.loadI18n(i18nPath)
     }
@@ -537,8 +541,20 @@ class HTMLGenerator {
     this.output = ''
     this.indent = 0
 
-    if (ast.type === 'document' || ast.type === 'root') {
-      for (const child of ast.children || []) {
+    if (ast.type === 'Document' || ast.type === 'document' || ast.type === 'root') {
+      const children = ast.children || []
+      
+      if (children.length > 0) {
+        const firstChild = children[0]
+        const firstType = (firstChild.type || '').toLowerCase()
+        const firstTag = (firstChild.tag || firstChild.tagName || '').toLowerCase()
+        
+        if (firstType !== 'doctype' && (firstTag === 'html' || firstTag === 'document')) {
+          this.output += '<!DOCTYPE html>\n'
+        }
+      }
+      
+      for (const child of children) {
         this.generateNode(child)
       }
     } else {
@@ -552,19 +568,24 @@ class HTMLGenerator {
     if (!node) return
 
     switch (node.type) {
+      case 'Doctype':
       case 'doctype':
         this.generateDoctype(node)
         break
+      case 'Element':
       case 'element':
       case 'tag':
         this.generateElement(node)
         break
+      case 'Text':
       case 'text':
         this.generateText(node)
         break
+      case 'Comment':
       case 'comment':
         this.generateComment(node)
         break
+      case 'Include':
       case 'include':
         this.generateInclude(node)
         break
@@ -609,8 +630,18 @@ class HTMLGenerator {
     const textContent = typeof children === 'string' ? children :
                         (node.text || node.textContent || null)
 
+    const isRawContent = (tag.toLowerCase() === 'script' || tag.toLowerCase() === 'style')
+
     if (textContent && !hasChildren) {
-      this.writeLine(`<${tag}${attributes}>${this.escapeHtml(textContent)}</${tag}>`)
+      if (isRawContent) {
+        this.writeLine(`<${tag}${attributes}>`)
+        this.indent++
+        this.writeLine(textContent)
+        this.indent--
+        this.writeLine(`</${tag}>`)
+      } else {
+        this.writeLine(`<${tag}${attributes}>${this.escapeHtml(textContent)}</${tag}>`)
+      }
       return
     }
 
@@ -622,11 +653,33 @@ class HTMLGenerator {
     this.writeLine(`<${tag}${attributes}>`)
     this.indent++
 
-    for (const child of children) {
-      if (typeof child === 'string') {
-        this.writeLine(this.escapeHtml(child))
-      } else {
-        this.generateNode(child)
+    if (isRawContent) {
+      let rawContent = ''
+      for (const child of children) {
+        if (typeof child === 'string') {
+          rawContent += child
+        } else if (child.type === 'Text' || child.type === 'text') {
+          const content = child.content || child.text || child.value || ''
+          if (content.trim()) {
+            rawContent += content
+          }
+        }
+      }
+      
+      if (rawContent.trim()) {
+        const generatedCode = this.compileEmbeddedCode(rawContent.trim(), tag.toLowerCase())
+        const lines = generatedCode.split('\n')
+        for (const line of lines) {
+          this.writeLine(line)
+        }
+      }
+    } else {
+      for (const child of children) {
+        if (typeof child === 'string') {
+          this.writeLine(this.escapeHtml(child))
+        } else {
+          this.generateNode(child)
+        }
       }
     }
 
@@ -856,6 +909,11 @@ class HTMLGenerator {
 
   generateDoctype(node) {
     this.output += '<!DOCTYPE html>\n'
+    if (node.children && node.children.length > 0) {
+      for (const child of node.children) {
+        this.generateNode(child)
+      }
+    }
   }
 
   generateInclude(node) {
@@ -953,6 +1011,44 @@ class HTMLGenerator {
       }
     }
   }
+
+  compileEmbeddedCode(code, tagType) {
+    const etherKeywords = [
+      'journal', 'afficher', 'variable', 'constante', 'fonction', 'si', 'sinon',
+      'pour', 'tant que', 'retourner', 'classe', 'methode', 'importer',
+      'fond', 'couleur', 'marge', 'bordure', 'police', 'largeur', 'hauteur',
+      'remplissage', 'alignement', 'affichage', 'position', 'flexbox', 'grille'
+    ]
+    
+    const lowerCode = code.toLowerCase()
+    const hasEtherKeywords = etherKeywords.some(kw => lowerCode.includes(kw))
+    
+    if (!hasEtherKeywords) {
+      return code
+    }
+    
+    if (tagType === 'script' && this.parser && this.jsGenerator) {
+      try {
+        const ast = this.parser.parse(code, 'js')
+        const generated = this.jsGenerator.generate(ast)
+        return generated || code
+      } catch (e) {
+        return code
+      }
+    }
+    
+    if (tagType === 'style' && this.parser && this.cssGenerator) {
+      try {
+        const ast = this.parser.parse(code, 'css')
+        const generated = this.cssGenerator.generate(ast)
+        return generated || code
+      } catch (e) {
+        return code
+      }
+    }
+    
+    return code
+  }
 }
 
 module.exports = {

package/package.json

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