ether-code 0.1.6 → 0.1.8

package/generators/js-generator.js

@@ -5,54 +5,12 @@ class JSGenerator {
     this.i18n = null
     this.indent = 0
     this.output = ''
-    this.keywordMap = {}
-    this.methodMap = {}
-    this.operatorMap = {}
-    
-    this.buildGenericMaps()
     
     if (i18nPath) {
       this.loadI18n(i18nPath)
     }
   }
 
-  buildGenericMaps() {
-    this.keywordMap = {
-      'variable': 'let', 'constante': 'const', 'var': 'var',
-      'fonction': 'function', 'retourner': 'return',
-      'si': 'if', 'sinon': 'else', 'sinon si': 'else if',
-      'pour': 'for', 'tant que': 'while', 'faire': 'do',
-      'selon': 'switch', 'cas': 'case', 'défaut': 'default',
-      'sortir': 'break', 'continuer': 'continue',
-      'essayer': 'try', 'attraper': 'catch', 'finalement': 'finally',
-      'lancer': 'throw', 'nouveau': 'new',
-      'classe': 'class', 'étend': 'extends', 'super': 'super',
-      'statique': 'static', 'obtenir': 'get', 'définir': 'set',
-      'importer': 'import', 'exporter': 'export', 'depuis': 'from',
-      'asynchrone': 'asynchrone', 'attendre': 'await',
-      'vrai': 'true', 'faux': 'false', 'nul': 'null', 'indefini': 'undefined',
-      'typeof': 'typeof', 'instanceof': 'instanceof', 'dans': 'in', 'de': 'of'
-    }
-    
-    this.methodMap = {
-      'afficher': 'console.log',
-      'ajouter': 'push', 'retirer': 'pop', 'insérer': 'unshift',
-      'filtrer': 'filter', 'mapper': 'map', 'réduire': 'reduce',
-      'trouver': 'find', 'certains': 'some', 'tous': 'every',
-      'joindre': 'join', 'diviser': 'split',
-      'longueur': 'length', 'taille': 'length',
-      'majuscules': 'toUpperCase', 'minuscules': 'toLowerCase',
-      'inclut': 'includes', 'indice de': 'indexOf',
-      'tableau': 'Array', 'objet': 'Object', 'chaîne': 'String', 'nombre': 'Number'
-    }
-    
-    this.operatorMap = {
-      'et': '&&', 'ou': '||', 'non': '!',
-      'egal': '===', 'different': '!==',
-      'plus': '+', 'moins': '-', 'fois': '*', 'divise': '/'
-    }
-  }
-
   loadI18n(filePath) {
     const content = fs.readFileSync(filePath, 'utf-8')
     this.i18n = JSON.parse(content)
@@ -122,7 +80,7 @@ class JSGenerator {
       'faire': 'do',
       'selon': 'switch',
       'cas': 'case',
-      'défaut': 'default',
+      'defaut': 'default',
       'sortir': 'break',
       'continuer': 'continue',
       'essayer': 'try',
@@ -143,20 +101,20 @@ class JSGenerator {
       'indefini': 'undefined',
       'ceci': 'this',
       'classe': 'class',
-      'étend': 'extends',
+      'etend': 'extends',
       'super': 'super',
       'constructeur': 'constructor',
       'statique': 'static',
       'obtenir': 'get',
-      'définir': 'set',
-      'asynchrone': 'asynchrone',
+      'definir': 'set',
+      'asynchrone': 'async',
       'attendre': 'await',
       'produire': 'yield',
       'importer': 'import',
       'exporter': 'export',
       'depuis': 'from',
       'comme': 'as',
-      'par défaut': 'default',
+      'par defaut': 'default',
       'et': '&&',
       'ou': '||',
       'non': '!',
@@ -176,7 +134,7 @@ class JSGenerator {
       'ajouter': 'push',
       'retirer': 'pop',
       'decaler': 'shift',
-      'insérer début': 'unshift',
+      'inserer debut': 'unshift',
       'trancher': 'slice',
       'epiisser': 'splice',
       'concatener': 'concat',
@@ -185,7 +143,7 @@ class JSGenerator {
       'trier': 'sort',
       'filtrer': 'filter',
       'mapper': 'map',
-      'réduire': 'reduce',
+      'reduire': 'reduce',
       'trouver': 'find',
       'trouver index': 'findIndex',
       'chaque': 'forEach',
@@ -200,31 +158,31 @@ class JSGenerator {
       'supprimer espaces': 'trim',
       'commence par': 'startsWith',
       'finit par': 'endsWith',
-      'sous chaîne': 'substring',
+      'sous chaine': 'substring',
       'afficher': 'console.log',
       'alerte': 'alert',
       'confirmer': 'confirm',
       'demander': 'prompt',
       'document': 'document',
       'fenetre': 'window',
-      'élément par id': 'getElementById',
-      'éléments par classe': 'getElementsByClassName',
-      'éléments par tag': 'getElementsByTagName',
-      'sélecteur': 'querySelector',
+      'element par id': 'getElementById',
+      'elements par classe': 'getElementsByClassName',
+      'elements par tag': 'getElementsByTagName',
+      'selecteur': 'querySelector',
       'selecteurs': 'querySelectorAll',
-      'créer élément': 'createElement',
+      'creer element': 'createElement',
       'ajouter enfant': 'appendChild',
       'supprimer enfant': 'removeChild',
       'attribut': 'getAttribute',
-      'définir attribut': 'setAttribute',
-      'écouter': 'addEventListener',
+      'definir attribut': 'setAttribute',
+      'ecouter': 'addEventListener',
       'stopper ecoute': 'removeEventListener',
-      'empêcher défaut': 'preventDefault',
+      'empecher defaut': 'preventDefault',
       'stopper propagation': 'stopPropagation',
       'stockage local': 'localStorage',
       'stockage session': 'sessionStorage',
       'obtenir item': 'getItem',
-      'définir item': 'setItem',
+      'definir item': 'setItem',
       'supprimer item': 'removeItem',
       'vider': 'clear',
       'temporisation': 'setTimeout',
@@ -232,25 +190,25 @@ class JSGenerator {
       'annuler temporisation': 'clearTimeout',
       'annuler intervalle': 'clearInterval',
       'promesse': 'Promise',
-      'résoudre': 'resolve',
+      'resoudre': 'resolve',
       'rejeter': 'reject',
       'alors': 'then',
       'capturer': 'catch',
       'tout': 'all',
       'course': 'race',
-      'récupérer': 'fetch',
+      'recuperer': 'fetch',
       'json': 'json',
       'texte': 'text',
-      'réponse': 'response',
-      'requête': 'request',
-      'entêtes': 'headers',
+      'reponse': 'response',
+      'requete': 'request',
+      'entetes': 'headers',
       'corps': 'body',
-      'méthode': 'method',
+      'methode': 'method',
       'analyser': 'JSON.parse',
       'convertir': 'JSON.stringify',
       'nombre': 'Number',
-      'chaîne': 'String',
-      'booléen': 'Boolean',
+      'chaine': 'String',
+      'booleen': 'Boolean',
       'tableau': 'Array',
       'objet': 'Object',
       'date': 'Date',
@@ -258,11 +216,11 @@ class JSGenerator {
       'expression reguliere': 'RegExp',
       'erreur': 'Error',
       'erreur type': 'TypeError',
-      'erreur référence': 'ReferenceError',
+      'erreur reference': 'ReferenceError',
       'erreur syntaxe': 'SyntaxError',
       'erreur plage': 'RangeError',
       'math': 'Math',
-      'aléatoire': 'random',
+      'aleatoire': 'random',
       'plancher': 'floor',
       'plafond': 'ceil',
       'arrondi': 'round',
@@ -289,22 +247,13 @@ class JSGenerator {
 
     if (Array.isArray(ast)) {
       for (const node of ast) {
-        const result = this.generateNode(node)
-        if (result !== undefined && this.output === '') {
-          this.output = result
-        }
+        this.generateNode(node)
       }
     } else if (ast && ast.type) {
-      const result = this.generateNode(ast)
-      if (result !== undefined && this.output === '') {
-        this.output = result
-      }
+      this.generateNode(ast)
     } else if (ast && ast.body) {
       for (const node of ast.body) {
-        const result = this.generateNode(node)
-        if (result !== undefined && this.output === '') {
-          this.output = result
-        }
+        this.generateNode(node)
       }
     }
 
@@ -396,6 +345,8 @@ class JSGenerator {
         return this.generateArrayExpression(node)
       case 'Identifier':
         return this.translate(node.name)
+      case 'Parameter':
+        return this.generateParameter(node)
       case 'Literal':
         return this.generateLiteral(node)
       case 'TemplateLiteral':
@@ -404,8 +355,6 @@ class JSGenerator {
         return this.generateNewExpression(node)
       case 'AwaitExpression':
         return this.generateAwaitExpression(node)
-      case 'UpdateExpression':
-        return this.generateUpdateExpression(node)
       default:
         if (node.expression) {
           return this.generateNode(node.expression)
@@ -414,15 +363,6 @@ class JSGenerator {
     }
   }
 
-  generateUpdateExpression(node) {
-    const arg = this.generateNode(node.argument)
-    const op = node.operator
-    if (node.prefix) {
-      return `${op}${arg}`
-    }
-    return `${arg}${op}`
-  }
-
   generateProgram(node) {
     for (const statement of node.body || []) {
       this.generateNode(statement)
@@ -431,24 +371,21 @@ class JSGenerator {
 
   generateVariableDeclaration(node) {
     const kind = this.translate(node.kind || 'let')
-    const declarations = node.declarations || []
-
-    for (const decl of declarations) {
-      let name
-      if (decl.id) {
-        if (typeof decl.id === 'string') {
-          name = this.translate(decl.id)
-        } else if (decl.id.name) {
-          name = this.translate(decl.id.name)
+    
+    if (node.declarations && Array.isArray(node.declarations)) {
+      for (const decl of node.declarations) {
+        const name = this.generateNode(decl.id || decl.name)
+        if (decl.init) {
+          const init = this.generateNode(decl.init)
+          this.writeLine(`${kind} ${name} = ${init};`)
         } else {
-          name = this.generateNode(decl.id)
+          this.writeLine(`${kind} ${name};`)
         }
-      } else if (decl.name) {
-        name = this.translate(typeof decl.name === 'string' ? decl.name : decl.name.name)
       }
-      
-      if (decl.init) {
-        const init = this.generateNode(decl.init)
+    } else {
+      const name = typeof node.name === 'string' ? node.name : this.generateNode(node.name)
+      if (node.init) {
+        const init = this.generateNode(node.init)
         this.writeLine(`${kind} ${name} = ${init};`)
       } else {
         this.writeLine(`${kind} ${name};`)
@@ -460,7 +397,7 @@ class JSGenerator {
     const async = node.async ? 'async ' : ''
     const generator = node.generator ? '*' : ''
     const name = this.translate(node.id?.name || node.name || '')
-    const params = (node.params || []).map(p => this.generateNode(p)).join(', ')
+    const params = (node.params || []).map(p => this.generateParameter(p)).join(', ')
 
     this.writeLine(`${async}function${generator} ${name}(${params}) {`)
     this.indent++
@@ -470,6 +407,24 @@ class JSGenerator {
     this.writeLine('')
   }
 
+  generateParameter(node) {
+    if (!node) return ''
+    if (typeof node === 'string') return node
+    if (node.type === 'Identifier') return this.translate(node.name)
+    
+    let result = this.translate(node.name || '')
+    
+    if (node.typeAnnotation) {
+      result += `: ${this.generateNode(node.typeAnnotation)}`
+    }
+    
+    if (node.default) {
+      result += ` = ${this.generateNode(node.default)}`
+    }
+    
+    return result
+  }
+
   generateClassDeclaration(node) {
     const name = this.translate(node.id?.name || node.name || '')
     const extend = node.superClass ? ` extends ${this.generateNode(node.superClass)}` : ''
@@ -520,25 +475,8 @@ class JSGenerator {
 
     if (node.alternate) {
       if (node.alternate.type === 'IfStatement') {
-        this.output = this.output.trimEnd() + '\n' + this.getIndent() + '} else '
-        const altTest = this.generateNode(node.alternate.test)
-        this.output += `if (${altTest}) {\n`
-        this.indent++
-        this.generateNode(node.alternate.consequent)
-        this.indent--
-        if (node.alternate.alternate) {
-          if (node.alternate.alternate.type === 'IfStatement') {
-            this.generateIfStatement({ ...node.alternate, test: node.alternate.alternate.test, consequent: node.alternate.alternate.consequent, alternate: node.alternate.alternate.alternate })
-          } else {
-            this.writeLine('} else {')
-            this.indent++
-            this.generateNode(node.alternate.alternate)
-            this.indent--
-            this.writeLine('}')
-          }
-        } else {
-          this.writeLine('}')
-        }
+        this.output = this.output.trimEnd() + ' else '
+        this.generateIfStatement(node.alternate)
       } else {
         this.writeLine('} else {')
         this.indent++
@@ -552,16 +490,9 @@ class JSGenerator {
   }
 
   generateForStatement(node) {
-    let init = ''
-    if (node.init) {
-      const saved = this.output
-      this.output = ''
-      this.generateNode(node.init)
-      init = this.output.trim().replace(/;$/, '')
-      this.output = saved
-    }
-    const test = node.test ? (this.generateNode(node.test) || '') : ''
-    const update = node.update ? (this.generateNode(node.update) || '') : ''
+    const init = node.init ? this.generateNode(node.init).replace(/;$/, '') : ''
+    const test = node.test ? this.generateNode(node.test) : ''
+    const update = node.update ? this.generateNode(node.update) : ''
 
     this.writeLine(`for (${init}; ${test}; ${update}) {`)
     this.indent++
@@ -571,21 +502,8 @@ class JSGenerator {
   }
 
   generateForOfStatement(node) {
-    let left = ''
-    if (node.left?.type === 'VariableDeclaration') {
-      const kind = this.translate(node.left.kind || 'const')
-      const decl = node.left.declarations?.[0]
-      let name = ''
-      if (decl?.id?.name) {
-        name = this.translate(decl.id.name)
-      } else if (decl?.name) {
-        name = this.translate(typeof decl.name === 'string' ? decl.name : decl.name.name)
-      }
-      left = `${kind} ${name}`
-    } else {
-      left = this.generateNode(node.left) || ''
-    }
-    const right = this.generateNode(node.right) || ''
+    const left = this.generateNode(node.left)
+    const right = this.generateNode(node.right)
     const keyword = node.type === 'ForInStatement' ? 'in' : 'of'
 
     this.writeLine(`for (${left} ${keyword} ${right}) {`)
@@ -661,8 +579,9 @@ class JSGenerator {
   }
 
   generateReturnStatement(node) {
-    if (node.argument) {
-      const arg = this.generateNode(node.argument)
+    const value = node.argument || node.value
+    if (value) {
+      const arg = this.generateNode(value)
       this.writeLine(`return ${arg};`)
     } else {
       this.writeLine('return;')
@@ -841,14 +760,14 @@ class JSGenerator {
 
   generateLiteral(node) {
     if (node.raw) return node.raw
-    if (node.regex) {
-      return `/${node.regex.pattern}/${node.regex.flags || ''}`
-    }
     if (typeof node.value === 'string') {
       return `"${node.value.replace(/"/g, '\\"')}"`
     }
     if (node.value === null) return 'null'
     if (node.value === undefined) return 'undefined'
+    if (node.regex) {
+      return `/${node.regex.pattern}/${node.regex.flags}`
+    }
     return String(node.value)
   }