ether-code 0.1.0

package/generators/ts-generator.js

@@ -0,0 +1,569 @@
+const fs = require('fs')
+const { JSGenerator } = require('./js-generator')
+
+class TSGenerator extends JSGenerator {
+  constructor(i18nPath = null) {
+    super(i18nPath)
+    this.extendMaps()
+  }
+
+  extendMaps() {
+    const tsTranslations = {
+      'type': 'type',
+      'interface': 'interface',
+      'enum': 'enum',
+      'énumération': 'enum',
+      'declare': 'declare',
+      'déclarer': 'declare',
+      'namespace': 'namespace',
+      'espace de noms': 'namespace',
+      'module': 'module',
+      'abstract': 'abstract',
+      'abstrait': 'abstract',
+      'implements': 'implements',
+      'implémente': 'implements',
+      'extends': 'extends',
+      'étend': 'extends',
+      'readonly': 'readonly',
+      'lecture seule': 'readonly',
+      'public': 'public',
+      'private': 'private',
+      'privé': 'private',
+      'protected': 'protected',
+      'protégé': 'protected',
+      'override': 'override',
+      'remplacer': 'override',
+      'keyof': 'keyof',
+      'clé de': 'keyof',
+      'typeof': 'typeof',
+      'type de': 'typeof',
+      'infer': 'infer',
+      'inférer': 'infer',
+      'satisfies': 'satisfies',
+      'satisfait': 'satisfies',
+      'as': 'as',
+      'comme': 'as',
+      'is': 'is',
+      'est': 'is',
+      'asserts': 'asserts',
+      'affirme': 'asserts',
+      'chaîne': 'string',
+      'nombre': 'number',
+      'booléen': 'boolean',
+      'symbole': 'symbol',
+      'vide': 'void',
+      'nul type': 'null',
+      'indefini type': 'undefined',
+      'jamais': 'never',
+      'inconnu': 'unknown',
+      'quelconque': 'any',
+      'objet': 'object',
+      'tableau type': 'Array',
+      'promesse': 'Promise',
+      'partial': 'Partial',
+      'partiel': 'Partial',
+      'required': 'Required',
+      'requis type': 'Required',
+      'readonly type': 'Readonly',
+      'record': 'Record',
+      'enregistrement': 'Record',
+      'pick': 'Pick',
+      'choisir': 'Pick',
+      'omit': 'Omit',
+      'omettre': 'Omit',
+      'exclude': 'Exclude',
+      'exclure': 'Exclude',
+      'extract': 'Extract',
+      'extraire type': 'Extract',
+      'nonnullable': 'NonNullable',
+      'non nullable': 'NonNullable',
+      'returntype': 'ReturnType',
+      'type retour': 'ReturnType',
+      'parameters': 'Parameters',
+      'paramètres type': 'Parameters',
+      'awaited': 'Awaited',
+      'attendu type': 'Awaited'
+    }
+
+    for (const [fr, ts] of Object.entries(tsTranslations)) {
+      this.keywordMap[fr] = ts
+    }
+  }
+
+  generateNode(node) {
+    if (!node) return ''
+
+    switch (node.type) {
+      case 'TypeAlias':
+      case 'TypeAliasDeclaration':
+        return this.generateTypeAlias(node)
+      case 'InterfaceDeclaration':
+        return this.generateInterface(node)
+      case 'EnumDeclaration':
+        return this.generateEnum(node)
+      case 'TypeAnnotation':
+        return this.generateTypeAnnotation(node)
+      case 'GenericType':
+        return this.generateGenericType(node)
+      case 'UnionType':
+        return this.generateUnionType(node)
+      case 'IntersectionType':
+        return this.generateIntersectionType(node)
+      case 'TupleType':
+        return this.generateTupleType(node)
+      case 'FunctionType':
+        return this.generateFunctionType(node)
+      case 'ConditionalType':
+        return this.generateConditionalType(node)
+      case 'MappedType':
+        return this.generateMappedType(node)
+      case 'IndexedAccessType':
+        return this.generateIndexedAccessType(node)
+      case 'TypeAssertion':
+        return this.generateTypeAssertion(node)
+      case 'NamespaceDeclaration':
+        return this.generateNamespace(node)
+      default:
+        return super.generateNode(node)
+    }
+  }
+
+  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)
+    
+    this.writeLine(`type ${name}${typeParams} = ${type};`)
+  }
+
+  generateInterface(node) {
+    const name = node.name
+    const typeParams = node.typeParameters ? this.generateTypeParams(node.typeParameters) : ''
+    const extend = node.extends && node.extends.length > 0 
+      ? ' extends ' + node.extends.map(e => this.generateType(e)).join(', ')
+      : ''
+    
+    this.writeLine(`interface ${name}${typeParams}${extend} {`)
+    this.indent++
+    
+    for (const member of node.members || node.properties || []) {
+      this.generateInterfaceMember(member)
+    }
+    
+    this.indent--
+    this.writeLine('}')
+    this.writeLine('')
+  }
+
+  generateInterfaceMember(member) {
+    const readonly = member.readonly ? 'readonly ' : ''
+    const optional = member.optional ? '?' : ''
+    const name = member.name || member.key
+    
+    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')
+      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};`)
+    } else {
+      const type = this.generateType(member.type || member.value)
+      this.writeLine(`${readonly}${name}${optional}: ${type};`)
+    }
+  }
+
+  generateEnum(node) {
+    const name = node.name
+    const isConst = node.const ? 'const ' : ''
+    
+    this.writeLine(`${isConst}enum ${name} {`)
+    this.indent++
+    
+    const members = node.members || []
+    for (let i = 0; i < members.length; i++) {
+      const member = members[i]
+      const memberName = member.name || member
+      const value = member.value !== undefined ? ` = ${this.generateNode(member.value)}` : ''
+      this.writeLine(`${memberName}${value},`)
+    }
+    
+    this.indent--
+    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(', ')}>`
+        }
+        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)
+      case 'union':
+        return (type.types || []).map(t => this.generateType(t)).join(' | ')
+      case 'intersection':
+        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(', ')}]`
+      case 'generic':
+        const base = this.generateType(type.base)
+        const args = type.arguments.map(a => this.generateType(a)).join(', ')
+        return `${base}<${args}>`
+      case 'function':
+        const params = this.generateTypedParams(type.parameters || [])
+        const ret = this.generateType(type.returnType)
+        return `(${params}) => ${ret}`
+      case 'object':
+        return this.generateObjectType(type)
+      case 'conditional':
+        const check = this.generateType(type.checkType)
+        const ext = this.generateType(type.extendsType)
+        const trueT = this.generateType(type.trueType)
+        const falseT = this.generateType(type.falseType)
+        return `${check} extends ${ext} ? ${trueT} : ${falseT}`
+      case 'keyof':
+        return `keyof ${this.generateType(type.type || type.operand)}`
+      case 'typeof':
+        return `typeof ${type.expression || this.generateNode(type.operand)}`
+      case 'indexed':
+        return `${this.generateType(type.objectType || type.object)}[${this.generateType(type.indexType || 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
+        }
+        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 ' : ''
+      const optional = m.optional ? '?' : ''
+      const name = m.name || m.key
+      const memberType = this.generateType(m.type || m.value)
+      return `${readonly}${name}${optional}: ${memberType}`
+    })
+    return `{ ${members.join('; ')} }`
+  }
+
+  generateLiteralType(type) {
+    if (typeof type.value === 'string') return `"${type.value}"`
+    if (typeof type.value === 'boolean') return type.value ? 'true' : 'false'
+    return String(type.value)
+  }
+
+  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 as = type.as ? ` as ${this.generateType(type.as)}` : ''
+    const valueType = this.generateType(type.valueType || type.value || type.type)
+    
+    return `{ ${readonly}[${key} in ${constraint}${as}]${optional}: ${valueType} }`
+  }
+
+  generateTypeParams(params) {
+    const items = params.map(p => {
+      let param = p.name || p
+      if (p.constraint) {
+        param += ` extends ${this.generateType(p.constraint)}`
+      }
+      if (p.default) {
+        param += ` = ${this.generateType(p.default)}`
+      }
+      return param
+    })
+    return `<${items.join(', ')}>`
+  }
+
+  generateTypedParams(params) {
+    return params.map(p => {
+      let param = ''
+      if (p.rest) param += '...'
+      param += p.name || p.arg || p
+      if (p.optional) param += '?'
+      if (p.type) param += ': ' + this.generateType(p.type)
+      if (p.default !== undefined) {
+        param += ' = ' + this.generateNode(p.default)
+      }
+      return param
+    }).join(', ')
+  }
+
+  generateTypeAnnotation(node) {
+    return this.generateType(node.typeAnnotation || node.type)
+  }
+
+  generateGenericType(node) {
+    const base = this.generateType(node.base || node.name)
+    const args = (node.typeArguments || node.arguments || []).map(a => this.generateType(a))
+    return `${base}<${args.join(', ')}>`
+  }
+
+  generateUnionType(node) {
+    return (node.types || []).map(t => this.generateType(t)).join(' | ')
+  }
+
+  generateIntersectionType(node) {
+    return (node.types || []).map(t => this.generateType(t)).join(' & ')
+  }
+
+  generateTupleType(node) {
+    const elements = (node.elements || node.types || []).map(e => {
+      if (e.optional) return this.generateType(e.type) + '?'
+      if (e.rest) return '...' + this.generateType(e.type)
+      return this.generateType(e)
+    })
+    return `[${elements.join(', ')}]`
+  }
+
+  generateFunctionType(node) {
+    const params = this.generateTypedParams(node.parameters || [])
+    const returnType = this.generateType(node.returnType)
+    return `(${params}) => ${returnType}`
+  }
+
+  generateConditionalType(node) {
+    const check = this.generateType(node.checkType)
+    const ext = this.generateType(node.extendsType)
+    const trueType = this.generateType(node.trueType)
+    const falseType = this.generateType(node.falseType)
+    return `${check} extends ${ext} ? ${trueType} : ${falseType}`
+  }
+
+  generateIndexedAccessType(node) {
+    const object = this.generateType(node.objectType)
+    const index = this.generateType(node.indexType)
+    return `${object}[${index}]`
+  }
+
+  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)
+    
+    if (node.asStyle !== false) {
+      return `${expression} as ${type}`
+    }
+    return `<${type}>${expression}`
+  }
+
+  generateNamespace(node) {
+    const name = node.name
+    this.writeLine(`namespace ${name} {`)
+    this.indent++
+    
+    for (const member of node.body || node.members || []) {
+      const exported = member.exported ? 'export ' : ''
+      if (exported) {
+        this.output += this.getIndent() + 'export '
+      }
+      this.generateNode(member)
+    }
+    
+    this.indent--
+    this.writeLine('}')
+    this.writeLine('')
+  }
+
+  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)
+      }
+      
+      const typeNode = decl.typeAnnotation || decl.type
+      const type = typeNode ? ': ' + this.generateType(typeNode) : ''
+      
+      if (decl.init) {
+        const init = this.generateNode(decl.init)
+        this.writeLine(`${kind} ${name}${type} = ${init};`)
+      } else {
+        this.writeLine(`${kind} ${name}${type};`)
+      }
+    }
+  }
+
+  generateFunctionDeclaration(node) {
+    const async = node.async ? 'async ' : ''
+    const generator = node.generator ? '*' : ''
+    const name = this.translate(node.id?.name || node.name || '')
+    const typeParams = node.typeParameters ? this.generateTypeParams(node.typeParameters) : ''
+    const params = this.generateTypedParams(node.params || [])
+    const returnType = node.returnType ? ': ' + this.generateType(node.returnType) : ''
+
+    this.writeLine(`${async}function${generator} ${name}${typeParams}(${params})${returnType} {`)
+    this.indent++
+    this.generateNode(node.body)
+    this.indent--
+    this.writeLine('}')
+    this.writeLine('')
+  }
+
+  generateClassDeclaration(node) {
+    const abstract = node.abstract ? 'abstract ' : ''
+    const name = this.translate(node.id?.name || node.name || '')
+    const typeParams = node.typeParameters ? this.generateTypeParams(node.typeParameters) : ''
+    const extend = node.superClass ? ` extends ${this.generateNode(node.superClass)}` : ''
+    const implement = node.implements && node.implements.length > 0
+      ? ` implements ${node.implements.map(i => this.generateType(i)).join(', ')}`
+      : ''
+
+    this.writeLine(`${abstract}class ${name}${typeParams}${extend}${implement} {`)
+    this.indent++
+
+    const body = node.body?.body || node.body || []
+    for (const member of body) {
+      this.generateClassMemberTS(member)
+    }
+
+    this.indent--
+    this.writeLine('}')
+    this.writeLine('')
+  }
+
+  generateClassMemberTS(node) {
+    const visibility = node.accessibility || node.visibility || ''
+    const isStatic = node.static ? 'static ' : ''
+    const readonly = node.readonly ? 'readonly ' : ''
+    const abstract = node.abstract ? 'abstract ' : ''
+    const override = node.override ? 'override ' : ''
+    
+    const modifiers = [visibility, isStatic, readonly, abstract, override].filter(m => m).join(' ')
+    
+    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 value = node.value ? ' = ' + this.generateNode(node.value) : ''
+      this.writeLine(`${modifiers}${name}${optional}${type}${value};`)
+      return
+    }
+    
+    const name = this.translate(node.key?.name || node.name || '')
+    const typeParams = node.typeParameters ? this.generateTypeParams(node.typeParameters) : ''
+    const params = this.generateTypedParams(node.value?.params || node.params || [])
+    const returnType = node.returnType ? ': ' + this.generateType(node.returnType) : ''
+
+    if (name === 'constructor' || name === 'constructeur') {
+      this.writeLine(`constructor(${params}) {`)
+    } else if (node.kind === 'get') {
+      this.writeLine(`${modifiers}get ${name}()${returnType} {`)
+    } else if (node.kind === 'set') {
+      this.writeLine(`${modifiers}set ${name}(${params}) {`)
+    } else {
+      const async = node.value?.async || node.async ? 'async ' : ''
+      this.writeLine(`${modifiers}${async}${name}${typeParams}(${params})${returnType} {`)
+    }
+
+    this.indent++
+    this.generateNode(node.value?.body || node.body)
+    this.indent--
+    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 = {
+  TSGenerator
+}