ether-code 0.1.8 → 0.2.0

package/ether-compiler.js

@@ -0,0 +1,190 @@
+const fs = require('fs')
+const path = require('path')
+const { EtherLexer, TokenType } = require('./lexer/ether-lexer')
+const { EtherParser } = require('./ether-parser')
+const { CSSGenerator } = require('./generators/css-generator')
+const { HTMLGenerator } = require('./generators/html-generator')
+const { JSGenerator } = require('./generators/js-generator')
+const { TSGenerator } = require('./generators/ts-generator')
+const { PHPGenerator } = require('./generators/php-generator')
+const { PythonGenerator } = require('./generators/python-generator')
+const { RubyGenerator } = require('./generators/ruby-generator')
+const { SQLGenerator } = require('./generators/sql-generator')
+const { NodeGenerator } = require('./generators/node-generator')
+const { ReactGenerator } = require('./generators/react-generator')
+const { GraphQLGenerator } = require('./generators/graphql-generator')
+
+class EtherCompiler {
+  constructor(options = {}) {
+    this.i18nDir = options.i18nDir || path.join(__dirname, 'i18n')
+    this.parser = new EtherParser({ i18nDir: this.i18nDir })
+    this.generators = {}
+    this.initGenerators()
+  }
+
+  initGenerators() {
+    const generatorConfigs = [
+      { name: 'css', Generator: CSSGenerator, i18n: 'i18n-css.json' },
+      { name: 'html', Generator: HTMLGenerator, i18n: 'i18n-html.json' },
+      { name: 'js', Generator: JSGenerator, i18n: 'i18n-js.json' },
+      { name: 'ts', Generator: TSGenerator, i18n: 'i18n-ts.json' },
+      { name: 'php', Generator: PHPGenerator, i18n: 'i18n-php.json' },
+      { name: 'python', Generator: PythonGenerator, i18n: 'i18n-python.json' },
+      { name: 'ruby', Generator: RubyGenerator, i18n: 'i18n-ruby.json' },
+      { name: 'sql', Generator: SQLGenerator, i18n: 'i18n-sql.json' },
+      { name: 'node', Generator: NodeGenerator, i18n: 'i18n-node.json' },
+      { name: 'react', Generator: ReactGenerator, i18n: 'i18n-react.json' },
+      { name: 'graphql', Generator: GraphQLGenerator, i18n: 'i18n-graphql.json' }
+    ]
+
+    for (const config of generatorConfigs) {
+      try {
+        const i18nPath = path.join(this.i18nDir, config.i18n)
+        if (fs.existsSync(i18nPath)) {
+          this.generators[config.name] = new config.Generator(i18nPath)
+        } else {
+          this.generators[config.name] = new config.Generator()
+        }
+      } catch (e) {
+        this.generators[config.name] = null
+      }
+    }
+
+    this.generators.javascript = this.generators.js
+    this.generators.typescript = this.generators.ts
+    this.generators.py = this.generators.python
+    this.generators.rb = this.generators.ruby
+    this.generators.nodejs = this.generators.node
+    this.generators.jsx = this.generators.react
+    this.generators.gql = this.generators.graphql
+  }
+
+  compile(source, targetLang = 'auto') {
+    const ast = this.parser.parse(source, targetLang)
+    const lang = this.detectLanguage(ast, targetLang, source)
+    const generator = this.generators[lang]
+
+    if (!generator) {
+      throw new Error(`Générateur non disponible pour: ${lang}`)
+    }
+
+    return generator.generate(ast)
+  }
+
+  detectLanguage(ast, targetLang, source) {
+    if (targetLang && targetLang !== 'auto') {
+      return targetLang.toLowerCase()
+    }
+
+    if (ast.type === 'StyleSheet') return 'css'
+    if (ast.type === 'Document') return 'html'
+    if (ast.type === 'SQLProgram') return 'sql'
+    if (ast.type === 'GraphQLProgram') return 'graphql'
+    if (ast.lang) return ast.lang
+
+    return this.parser.detectTargetLanguage(source)
+  }
+
+  compileFile(inputPath, outputPath = null, targetLang = 'auto') {
+    const source = fs.readFileSync(inputPath, 'utf-8')
+    const result = this.compile(source, targetLang)
+
+    if (outputPath) {
+      const dir = path.dirname(outputPath)
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true })
+      }
+      fs.writeFileSync(outputPath, result)
+    }
+
+    return result
+  }
+
+  getExtension(lang) {
+    const extensions = {
+      css: '.css',
+      html: '.html',
+      js: '.js',
+      javascript: '.js',
+      ts: '.ts',
+      typescript: '.ts',
+      php: '.php',
+      python: '.py',
+      py: '.py',
+      ruby: '.rb',
+      rb: '.rb',
+      sql: '.sql',
+      node: '.js',
+      nodejs: '.js',
+      react: '.jsx',
+      jsx: '.jsx',
+      graphql: '.graphql',
+      gql: '.graphql'
+    }
+    return extensions[lang] || '.txt'
+  }
+
+  parse(source, targetLang = 'auto') {
+    return this.parser.parse(source, targetLang)
+  }
+
+  generate(ast, lang) {
+    const generator = this.generators[lang]
+    if (!generator) {
+      throw new Error(`Générateur non disponible pour: ${lang}`)
+    }
+    return generator.generate(ast)
+  }
+
+  tokenize(source) {
+    const lexer = new EtherLexer(source)
+    return lexer.tokenize()
+  }
+
+  inferTargetFromFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase()
+    const extMap = {
+      '.eth': 'auto',
+      '.ether': 'auto',
+      '.ecss': 'css',
+      '.ehtml': 'html',
+      '.ejs': 'js',
+      '.ets': 'ts',
+      '.ephp': 'php',
+      '.epy': 'python',
+      '.erb': 'ruby',
+      '.esql': 'sql',
+      '.egql': 'graphql',
+      '.ejsx': 'react'
+    }
+    return extMap[ext] || 'auto'
+  }
+}
+
+function compile(source, targetLang = 'auto', options = {}) {
+  const compiler = new EtherCompiler(options)
+  return compiler.compile(source, targetLang)
+}
+
+function compileFile(inputPath, outputPath = null, targetLang = 'auto', options = {}) {
+  const compiler = new EtherCompiler(options)
+  return compiler.compileFile(inputPath, outputPath, targetLang)
+}
+
+function parse(source, targetLang = 'auto', options = {}) {
+  const compiler = new EtherCompiler(options)
+  return compiler.parse(source, targetLang)
+}
+
+function tokenize(source, options = {}) {
+  const lexer = new EtherLexer(source, options)
+  return lexer.tokenize()
+}
+
+module.exports = {
+  EtherCompiler,
+  compile,
+  compileFile,
+  parse,
+  tokenize
+}