ether-code 0.1.6 → 0.1.8

package/generators/ts-generator.js

@@ -12,33 +12,33 @@ class TSGenerator extends JSGenerator {
       'type': 'type',
       'interface': 'interface',
       'enum': 'enum',
-      'énumération': 'enum',
+      'enumeration': 'enum',
       'declare': 'declare',
-      'déclarer': 'declare',
+      'declarer': 'declare',
       'namespace': 'namespace',
       'espace de noms': 'namespace',
       'module': 'module',
       'abstract': 'abstract',
       'abstrait': 'abstract',
       'implements': 'implements',
-      'implémente': 'implements',
+      'implemente': 'implements',
       'extends': 'extends',
-      'étend': 'extends',
+      'etend': 'extends',
       'readonly': 'readonly',
       'lecture seule': 'readonly',
       'public': 'public',
       'private': 'private',
-      'privé': 'private',
+      'prive': 'private',
       'protected': 'protected',
-      'protégé': 'protected',
+      'protege': 'protected',
       'override': 'override',
       'remplacer': 'override',
       'keyof': 'keyof',
-      'clé de': 'keyof',
+      'cle de': 'keyof',
       'typeof': 'typeof',
       'type de': 'typeof',
       'infer': 'infer',
-      'inférer': 'infer',
+      'inferer': 'infer',
       'satisfies': 'satisfies',
       'satisfait': 'satisfies',
       'as': 'as',
@@ -47,9 +47,9 @@ class TSGenerator extends JSGenerator {
       'est': 'is',
       'asserts': 'asserts',
       'affirme': 'asserts',
-      'chaîne': 'string',
+      'chaine': 'string',
       'nombre': 'number',
-      'booléen': 'boolean',
+      'booleen': 'boolean',
       'symbole': 'symbol',
       'vide': 'void',
       'nul type': 'null',
@@ -80,7 +80,7 @@ class TSGenerator extends JSGenerator {
       'returntype': 'ReturnType',
       'type retour': 'ReturnType',
       'parameters': 'Parameters',
-      'paramètres type': 'Parameters',
+      'parametres type': 'Parameters',
       'awaited': 'Awaited',
       'attendu type': 'Awaited'
     }
@@ -95,7 +95,6 @@ class TSGenerator extends JSGenerator {
 
     switch (node.type) {
       case 'TypeAlias':
-      case 'TypeAliasDeclaration':
         return this.generateTypeAlias(node)
       case 'InterfaceDeclaration':
         return this.generateInterface(node)
@@ -131,11 +130,10 @@ class TSGenerator extends JSGenerator {
   generateTypeAlias(node) {
     const name = node.name
     const typeParams = node.typeParameters ? this.generateTypeParams(node.typeParameters) : ''
-    const typeNode = node.aliasType || node.typeValue || 
-                     (typeof node.type === 'object' ? node.type : null)
-    const type = this.generateType(typeNode)
+    const type = this.generateType(node.type)
     
     this.writeLine(`type ${name}${typeParams} = ${type};`)
+    this.writeLine('')
   }
 
   generateInterface(node) {
@@ -161,19 +159,17 @@ class TSGenerator extends JSGenerator {
     const readonly = member.readonly ? 'readonly ' : ''
     const optional = member.optional ? '?' : ''
     const name = member.name || member.key
+    const type = this.generateType(member.type || member.value)
     
     if (member.kind === 'method' || member.method) {
       const typeParams = member.typeParameters ? this.generateTypeParams(member.typeParameters) : ''
       const params = this.generateTypedParams(member.params || member.parameters || [])
-      const returnType = this.generateType(member.returnType || member.type || 'void')
+      const returnType = member.returnType ? this.generateType(member.returnType) : 'void'
       this.writeLine(`${readonly}${name}${optional}${typeParams}(${params}): ${returnType};`)
     } else if (member.kind === 'index' || member.index) {
-      const keyName = member.keyName || 'key'
       const keyType = this.generateType(member.keyType || 'string')
-      const valueType = this.generateType(member.type || member.valueType || 'any')
-      this.writeLine(`[${keyName}: ${keyType}]: ${valueType};`)
+      this.writeLine(`[key: ${keyType}]: ${type};`)
     } else {
-      const type = this.generateType(member.type || member.value)
       this.writeLine(`${readonly}${name}${optional}: ${type};`)
     }
   }
@@ -190,59 +186,37 @@ class TSGenerator extends JSGenerator {
       const member = members[i]
       const memberName = member.name || member
       const value = member.value !== undefined ? ` = ${this.generateNode(member.value)}` : ''
-      this.writeLine(`${memberName}${value},`)
+      const comma = i < members.length - 1 ? ',' : ''
+      this.writeLine(`${memberName}${value}${comma}`)
     }
     
     this.indent--
     this.writeLine('}')
+    this.writeLine('')
   }
 
   generateType(type) {
     if (!type) return 'any'
     if (typeof type === 'string') return this.translate(type)
     
-    const typeKind = type.kind || (typeof type.type === 'string' ? type.type : null)
-    
-    switch (typeKind) {
-      case 'string':
-      case 'chaîne':
-        return 'string'
-      case 'number':
-      case 'nombre':
-        return 'number'
-      case 'boolean':
-      case 'booléen':
-        return 'boolean'
-      case 'void':
-        return 'void'
-      case 'null':
-        return 'null'
-      case 'undefined':
-        return 'undefined'
-      case 'any':
-        return 'any'
-      case 'never':
-        return 'never'
-      case 'unknown':
-        return 'unknown'
-      case 'référence':
-        const refName = this.translate(type.name)
-        if (type.typeArguments) {
-          return `${refName}<${type.typeArguments.map(a => this.generateType(a)).join(', ')}>`
+    switch (type.type || type.kind) {
+      case 'TypeAnnotation':
+        let result = this.translate(type.name)
+        if (type.generic && type.generic.length > 0) {
+          result += '<' + type.generic.map(g => this.generateType(g)).join(', ') + '>'
         }
-        return refName
-      case 'literal':
-        if (typeof type.value === 'string') return `"${type.value}"`
-        if (typeof type.value === 'boolean') return type.value ? 'true' : 'false'
-        return String(type.value)
+        if (type.isArray) {
+          result += '[]'
+        }
+        return result
       case 'union':
-        return (type.types || []).map(t => this.generateType(t)).join(' | ')
+        return type.types.map(t => this.generateType(t)).join(' | ')
       case 'intersection':
-        return (type.types || []).map(t => this.generateType(t)).join(' & ')
+        return type.types.map(t => this.generateType(t)).join(' & ')
       case 'array':
         return `${this.generateType(type.elementType)}[]`
       case 'tuple':
-        return `[${(type.elements || type.elementTypes || []).map(e => this.generateType(e)).join(', ')}]`
+        return `[${type.elements.map(e => this.generateType(e)).join(', ')}]`
       case 'generic':
         const base = this.generateType(type.base)
         const args = type.arguments.map(a => this.generateType(a)).join(', ')
@@ -253,6 +227,8 @@ class TSGenerator extends JSGenerator {
         return `(${params}) => ${ret}`
       case 'object':
         return this.generateObjectType(type)
+      case 'literal':
+        return this.generateLiteralType(type)
       case 'conditional':
         const check = this.generateType(type.checkType)
         const ext = this.generateType(type.extendsType)
@@ -260,38 +236,21 @@ class TSGenerator extends JSGenerator {
         const falseT = this.generateType(type.falseType)
         return `${check} extends ${ext} ? ${trueT} : ${falseT}`
       case 'keyof':
-        return `keyof ${this.generateType(type.type || type.operand)}`
+        return `keyof ${this.generateType(type.operand)}`
       case 'typeof':
-        return `typeof ${type.expression || this.generateNode(type.operand)}`
+        return `typeof ${this.generateNode(type.operand)}`
       case 'indexed':
-        return `${this.generateType(type.objectType || type.object)}[${this.generateType(type.indexType || type.index)}]`
+        return `${this.generateType(type.object)}[${this.generateType(type.index)}]`
       case 'mapped':
         return this.generateMappedType(type)
       case 'infer':
         return `infer ${type.name}`
-      case 'template':
-        return this.generateTemplateLiteralType(type)
       default:
-        if (type.name) {
-          const name = this.translate(type.name)
-          if (type.typeArguments) {
-            return `${name}<${type.typeArguments.map(a => this.generateType(a)).join(', ')}>`
-          }
-          return name
-        }
+        if (type.name) return this.translate(type.name)
         return 'any'
     }
   }
 
-  generateTemplateLiteralType(type) {
-    const parts = (type.parts || []).map(p => {
-      if (typeof p === 'string') return p
-      if (p.name) return '${' + this.generateType(p) + '}'
-      return this.generateType(p)
-    })
-    return '`' + parts.join('') + '`'
-  }
-
   generateObjectType(type) {
     const members = (type.members || type.properties || []).map(m => {
       const readonly = m.readonly ? 'readonly ' : ''
@@ -312,18 +271,10 @@ class TSGenerator extends JSGenerator {
   generateMappedType(type) {
     const readonly = type.readonly ? (type.readonly === '-' ? '-readonly ' : 'readonly ') : ''
     const optional = type.optional ? (type.optional === '-' ? '-?' : '?') : ''
-    
-    let key, constraint
-    if (type.typeParameter) {
-      key = type.typeParameter.name || 'K'
-      constraint = this.generateType(type.typeParameter.constraint)
-    } else {
-      key = type.key || 'K'
-      constraint = this.generateType(type.constraint)
-    }
-    
+    const key = type.key || 'K'
+    const constraint = this.generateType(type.constraint)
     const as = type.as ? ` as ${this.generateType(type.as)}` : ''
-    const valueType = this.generateType(type.valueType || type.value || type.type)
+    const valueType = this.generateType(type.value)
     
     return `{ ${readonly}[${key} in ${constraint}${as}]${optional}: ${valueType} }`
   }
@@ -405,11 +356,9 @@ class TSGenerator extends JSGenerator {
 
   generateTypeAssertion(node) {
     const expression = this.generateNode(node.expression)
-    const typeNode = node.typeAnnotation || node.assertedType || 
-                     (node.type !== 'TypeAssertion' ? node.type : null)
-    const type = this.generateType(typeNode)
+    const type = this.generateType(node.type)
     
-    if (node.asStyle !== false) {
+    if (node.asStyle) {
       return `${expression} as ${type}`
     }
     return `<${type}>${expression}`
@@ -436,25 +385,24 @@ class TSGenerator extends JSGenerator {
   generateVariableDeclaration(node) {
     const kind = this.translate(node.kind || 'let')
     
-    for (const decl of node.declarations || []) {
-      let name
-      if (typeof decl.id === 'string') {
-        name = decl.id
-      } else if (decl.id?.name) {
-        name = decl.id.name
-      } else if (typeof decl.name === 'string') {
-        name = decl.name
-      } else if (decl.name?.name) {
-        name = decl.name.name
-      } else {
-        name = this.generateNode(decl.id || decl.name)
+    if (node.declarations && node.declarations.length > 0) {
+      for (const decl of node.declarations) {
+        const name = this.generateNode(decl.id || decl.name)
+        const type = decl.type ? ': ' + this.generateType(decl.type) : ''
+        
+        if (decl.init) {
+          const init = this.generateNode(decl.init)
+          this.writeLine(`${kind} ${name}${type} = ${init};`)
+        } else {
+          this.writeLine(`${kind} ${name}${type};`)
+        }
       }
+    } else {
+      const name = typeof node.name === 'string' ? node.name : this.generateNode(node.name)
+      const type = node.typeAnnotation ? ': ' + this.generateType(node.typeAnnotation) : ''
       
-      const typeNode = decl.typeAnnotation || decl.type
-      const type = typeNode ? ': ' + this.generateType(typeNode) : ''
-      
-      if (decl.init) {
-        const init = this.generateNode(decl.init)
+      if (node.init) {
+        const init = this.generateNode(node.init)
         this.writeLine(`${kind} ${name}${type} = ${init};`)
       } else {
         this.writeLine(`${kind} ${name}${type};`)
@@ -512,8 +460,7 @@ class TSGenerator extends JSGenerator {
     if (node.kind === 'property' || node.type === 'PropertyDefinition' || node.property) {
       const name = this.translate(node.key?.name || node.name || '')
       const optional = node.optional ? '?' : ''
-      const typeNode = node.typeAnnotation || node.type
-      const type = typeNode && typeof typeNode === 'object' ? ': ' + this.generateType(typeNode) : ''
+      const type = node.typeAnnotation ? ': ' + this.generateType(node.typeAnnotation) : ''
       const value = node.value ? ' = ' + this.generateNode(node.value) : ''
       this.writeLine(`${modifiers}${name}${optional}${type}${value};`)
       return
@@ -541,27 +488,6 @@ class TSGenerator extends JSGenerator {
     this.writeLine('}')
     this.writeLine('')
   }
-
-  generateArrowFunction(node) {
-    const async = node.async ? 'async ' : ''
-    const params = this.generateTypedParams(node.params || [])
-    const returnType = node.returnType ? ': ' + this.generateType(node.returnType) : ''
-
-    if (node.body?.type === 'BlockStatement') {
-      let body = ''
-      const savedOutput = this.output
-      this.output = ''
-      this.indent++
-      this.generateNode(node.body)
-      this.indent--
-      body = this.output.trim()
-      this.output = savedOutput
-      return `${async}(${params})${returnType} => {\n${body}\n${this.getIndent()}}`
-    } else {
-      const body = this.generateNode(node.body)
-      return `${async}(${params})${returnType} => ${body}`
-    }
-  }
 }
 
 module.exports = {