ether-code 0.7.8 → 0.7.9

package/parsers/ether-parser-html.js

@@ -0,0 +1,588 @@
+const { EtherParserBase, TokenType } = require('./ether-parser-base')
+
+class EtherParserHTML extends EtherParserBase {
+  constructor(options = {}) {
+    super(options)
+    this.loadI18n(['i18n-html.json'])
+  }
+
+  parse(source) {
+    this.tokenize(source)
+    return this.parseHTML()
+  }
+
+  parseHTML() {
+    const document = {
+      type: 'Document',
+      children: []
+    }
+    
+    this.skipNewlines()
+    
+    while (!this.isAtEnd()) {
+      const node = this.parseHTMLNode()
+      if (node) {
+        document.children.push(node)
+      }
+      this.skipNewlines()
+    }
+    
+    return document
+  }
+
+  parseHTMLNode() {
+    this.skipNewlines()
+    const token = this.current()
+    
+    if (!token || token.type === TokenType.EOF) return null
+    
+    if (token.type === TokenType.IDENTIFIER) {
+      return this.parseHTMLElement()
+    }
+    
+    if (token.type === TokenType.STRING) {
+      this.advance()
+      return {
+        type: 'Text',
+        content: token.value.replace(/^["']|["']$/g, '')
+      }
+    }
+    
+    this.advance()
+    return null
+  }
+
+  parseHTMLElement() {
+    const tagToken = this.current()
+    let tagName = this.normalizeAccents(tagToken.value)
+    const originalTagName = tagName
+    this.advance()
+    
+    const includeKeywords = ['inclure', 'requiert', 'include', 'require', 'importer']
+    if (includeKeywords.includes(tagName)) {
+      let includePath = null
+      
+      if (this.current() && this.current().type === TokenType.COLON) {
+        this.advance()
+      }
+      
+      const pathToken = this.current()
+      if (pathToken && pathToken.type === TokenType.STRING) {
+        includePath = pathToken.value.replace(/^["']|["']$/g, '')
+        this.advance()
+      } else if (pathToken && pathToken.type === TokenType.IDENTIFIER) {
+        let pathParts = [pathToken.value]
+        this.advance()
+        while (this.current() && (this.current().type === TokenType.SLASH || this.current().type === TokenType.DOT || this.current().type === TokenType.IDENTIFIER)) {
+          if (this.current().type === TokenType.SLASH) {
+            pathParts.push('/')
+          } else if (this.current().type === TokenType.DOT) {
+            pathParts.push('.')
+          } else {
+            pathParts.push(this.current().value)
+          }
+          this.advance()
+        }
+        includePath = pathParts.join('')
+      }
+      
+      this.skipNewlines()
+      
+      return {
+        type: 'Include',
+        path: includePath,
+        resolved: false
+      }
+    }
+    
+    tagName = this.processCompoundTags(tagName)
+    
+    const tag = this.translateHTMLTag(tagName)
+    
+    const attributes = {}
+    let inlineText = null
+    
+    const compoundAttrs = {
+      'texte': ['alternatif'],
+      'longueur': ['max', 'min'],
+      'valeur': ['max', 'min'],
+      'zone': ['depot'],
+      'mode': ['saisie'],
+      'verification': ['orthographe'],
+      'ordre': ['tabulation'],
+      'action': ['formulaire'],
+      'methode': ['formulaire'],
+      'encodage': ['formulaire'],
+      'validation': ['formulaire', 'auto'],
+      'cible': ['formulaire', 'popover'],
+      'lecture': ['seule', 'auto'],
+      'nouvelle': ['fenetre'],
+      'a': ['popup'],
+      'jeu': ['caracteres', 'caractères'],
+      'equivalent': ['http'],
+      'équivalent': ['http'],
+      'fusion': ['colonnes', 'lignes'],
+      'plein': ['ecran', 'écran'],
+      'bac': ['sable'],
+      'origine': ['croisee', 'croisée'],
+      'sources': ['reactives', 'réactives']
+    }
+    
+    while (!this.isAtEnd()) {
+      const current = this.current()
+      
+      if (!current || current.type === TokenType.NEWLINE || 
+          current.type === TokenType.INDENT || current.type === TokenType.EOF) {
+        break
+      }
+      
+      if (current.type === TokenType.STRING) {
+        inlineText = current.value.replace(/^["']|["']$/g, '')
+        this.advance()
+        break
+      }
+      
+      if (current.type === TokenType.IDENTIFIER) {
+        let attrName = current.value.toLowerCase()
+        this.advance()
+        
+        if (compoundAttrs[attrName]) {
+          const nextTok = this.current()
+          if (nextTok && nextTok.type === TokenType.IDENTIFIER) {
+            const nextVal = nextTok.value.toLowerCase()
+            if (compoundAttrs[attrName].includes(nextVal)) {
+              attrName = attrName + ' ' + nextVal
+              this.advance()
+            }
+          }
+        }
+        
+        const nextToken = this.current()
+        
+        if (nextToken && (nextToken.type === TokenType.EQUALS || nextToken.type === TokenType.COLON)) {
+          this.advance()
+          const valueToken = this.current()
+          if (valueToken) {
+            if (valueToken.type === TokenType.STRING) {
+              attributes[attrName] = valueToken.value.replace(/^["']|["']$/g, '')
+            } else if (valueToken.type === TokenType.IDENTIFIER || 
+                       valueToken.type === TokenType.NUMBER || valueToken.type === TokenType.INTEGER) {
+              attributes[attrName] = valueToken.value
+            }
+            this.advance()
+          }
+          
+          if (this.current() && this.current().type === TokenType.COMMA) {
+            this.advance()
+          }
+        } else {
+          attributes[attrName] = true
+          
+          if (this.current() && this.current().type === TokenType.COMMA) {
+            this.advance()
+          }
+        }
+      } else if (current.type === TokenType.COMMA) {
+        this.advance()
+      } else {
+        break
+      }
+    }
+    
+    this.skipNewlines()
+    
+    const children = []
+    
+    if (inlineText) {
+      children.push({
+        type: 'Text',
+        content: inlineText
+      })
+    }
+    
+    const rawContentTags = ['script', 'style']
+    const isRawContent = rawContentTags.includes(tag)
+    const isScript = tag === 'script'
+    
+    if (this.match(TokenType.INDENT)) {
+      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
+          }
+          
+          rawText.push(this.tokenToString(current))
+          this.advance()
+        }
+        
+        const textContent = rawText.join('').trim()
+        if (textContent) {
+          children.push({
+            type: 'Text',
+            content: textContent
+          })
+        }
+      } 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
+      }
+    }
+    
+    return {
+      type: 'Element',
+      tag: tag,
+      attributes: attributes,
+      children: children
+    }
+  }
+
+  tokenToString(token) {
+    if (!token) return ''
+    
+    const tokenMap = {
+      [TokenType.LPAREN]: '(',
+      [TokenType.RPAREN]: ')',
+      [TokenType.LBRACKET]: '[',
+      [TokenType.RBRACKET]: ']',
+      [TokenType.LBRACE]: '{',
+      [TokenType.RBRACE]: '}',
+      [TokenType.DOT]: '.',
+      [TokenType.COMMA]: ',',
+      [TokenType.COLON]: ':',
+      [TokenType.EQUALS]: '=',
+      [TokenType.DOUBLE_EQUALS]: '==',
+      [TokenType.NOT_EQUALS]: '!=',
+      [TokenType.BANG]: '!',
+      [TokenType.SLASH]: '/',
+      [TokenType.PERCENT]: '%',
+      [TokenType.AMPERSAND]: '&',
+      [TokenType.DOUBLE_AMPERSAND]: '&&',
+      [TokenType.PIPE]: '|',
+      [TokenType.DOUBLE_PIPE]: '||',
+      [TokenType.LT]: '<',
+      [TokenType.GT]: '>',
+      [TokenType.LTE]: '<=',
+      [TokenType.GTE]: '>=',
+      [TokenType.QUESTION]: '?',
+      [TokenType.FAT_ARROW]: '=>',
+      [TokenType.ARROW]: '->',
+      [TokenType.SEMICOLON]: ';'
+    }
+    
+    if (tokenMap[token.type]) {
+      return tokenMap[token.type]
+    }
+    
+    return String(token.value)
+  }
+
+  processCompoundTags(tagName) {
+    const nextToken = this.current()
+    if (!nextToken || nextToken.type !== TokenType.IDENTIFIER) {
+      return tagName
+    }
+    
+    const compoundMap = {
+      'titre': { check: () => nextToken.type === TokenType.NUMBER || nextToken.type === TokenType.INTEGER, process: () => `titre${nextToken.value}` },
+      'liste ordonnee': { keywords: ['ordonnee', 'ordered'] },
+      'element liste': { keywords: ['liste', 'list'] },
+      'zone texte': { keywords: ['texte', 'text'] },
+      'retour ligne': { keywords: ['ligne', 'line'] },
+      'ligne horizontale': { keywords: ['horizontale'] },
+      'entete cellule': { keywords: ['entete', 'header'] },
+      'groupe titres': { keywords: ['titres'] },
+      'groupe options': { keywords: ['options'] },
+      'groupe colonnes': { keywords: ['colonnes'] },
+      'entete tableau': { keywords: ['tableau', 'table'] },
+      'corps tableau': { keywords: ['tableau', 'table'] },
+      'pied tableau': { keywords: ['tableau', 'table'] },
+      'legende tableau': { keywords: ['tableau', 'table'] },
+      'legende figure': { keywords: ['figure'] },
+      'ensemble champs': { keywords: ['champs', 'fields'] },
+      'liste donnees': { keywords: ['donnees', 'data'] },
+      'liste description': { keywords: ['description'] },
+      'image reactive': { keywords: ['reactive', 'responsive'] },
+      'cadre en ligne': { keywords: ['en'], nextKeyword: 'ligne' },
+      'citation bloc': { keywords: ['bloc', 'block'] },
+      'reference citation': { keywords: ['citation'] },
+      'sans script': { keywords: ['script'] },
+      'isolation bidi': { keywords: ['bidi'] },
+      'remplacement bidi': { keywords: ['bidi'] },
+      'annotation ruby': { keywords: ['ruby', 'rubis'] },
+      'parentheses ruby': { keywords: ['ruby', 'rubis'] },
+      'carte image': { keywords: ['image'] },
+      'texte alternatif': { keywords: ['alternatif', 'alt'] },
+      'entree clavier': { keywords: ['clavier'] },
+      'sortie exemple': { keywords: ['exemple'] },
+      'definition description': { keywords: ['description'] }
+    }
+    
+    const nextVal = this.normalizeAccents(nextToken.value)
+    
+    if (tagName === 'titre' && (nextToken.type === TokenType.NUMBER || nextToken.type === TokenType.INTEGER)) {
+      const num = parseInt(nextToken.value)
+      if (num >= 1 && num <= 6) {
+        this.advance()
+        return `titre${num}`
+      }
+    }
+    
+    const compounds = [
+      { base: 'liste', next: ['ordonnee', 'ordered'], result: 'liste ordonnee' },
+      { base: 'element', next: ['liste', 'list'], result: 'element liste' },
+      { base: 'zone', next: ['texte', 'text'], result: 'zone texte' },
+      { base: 'retour', next: ['ligne', 'line'], result: 'retour ligne' },
+      { base: 'saut', next: ['ligne', 'line'], result: 'retour ligne' },
+      { base: 'ligne', next: ['horizontale'], result: 'ligne horizontale' },
+      { base: 'cellule', next: ['entete', 'header'], result: 'entete cellule' },
+      { base: 'groupe', next: ['titres'], result: 'groupe titres' },
+      { base: 'groupe', next: ['options'], result: 'groupe options' },
+      { base: 'groupe', next: ['colonnes'], result: 'groupe colonnes' },
+      { base: 'entete', next: ['tableau', 'table'], result: 'entete tableau' },
+      { base: 'corps', next: ['tableau', 'table'], result: 'corps tableau' },
+      { base: 'pied', next: ['tableau', 'table'], result: 'pied tableau' },
+      { base: 'legende', next: ['tableau', 'table'], result: 'legende tableau' },
+      { base: 'legende', next: ['figure'], result: 'legende figure' },
+      { base: 'ensemble', next: ['champs', 'fields'], result: 'ensemble champs' },
+      { base: 'liste', next: ['donnees', 'data'], result: 'liste donnees' },
+      { base: 'liste', next: ['description'], result: 'liste description' },
+      { base: 'image', next: ['reactive', 'responsive'], result: 'image reactive' },
+      { base: 'citation', next: ['bloc', 'block'], result: 'citation bloc' },
+      { base: 'reference', next: ['citation'], result: 'reference citation' },
+      { base: 'sans', next: ['script'], result: 'sans script' },
+      { base: 'isolation', next: ['bidi'], result: 'isolation bidi' },
+      { base: 'remplacement', next: ['bidi'], result: 'remplacement bidi' },
+      { base: 'annotation', next: ['ruby', 'rubis'], result: 'annotation ruby' },
+      { base: 'parentheses', next: ['ruby', 'rubis'], result: 'parentheses ruby' },
+      { base: 'carte', next: ['image'], result: 'carte image' },
+      { base: 'texte', next: ['alternatif', 'alt'], result: 'texte alternatif' },
+      { base: 'entree', next: ['clavier'], result: 'entree clavier' },
+      { base: 'sortie', next: ['exemple'], result: 'sortie exemple' },
+      { base: 'definition', next: ['description'], result: 'definition description' }
+    ]
+    
+    for (const compound of compounds) {
+      if (tagName === compound.base && compound.next.includes(nextVal)) {
+        this.advance()
+        return compound.result
+      }
+    }
+    
+    return tagName
+  }
+
+  translateHTMLTag(tag) {
+    const map = this.reverseMaps.html || {}
+    const lower = this.normalizeAccents(tag)
+    const withSpaces = lower.replace(/-/g, ' ')
+    
+    const translations = {
+      'document': 'html',
+      'page': 'html',
+      'tete': 'head',
+      'corps': 'body',
+      'entete': 'header',
+      'piedpage': 'footer',
+      'pied': 'footer',
+      'navigation': 'nav',
+      'nav': 'nav',
+      'principal': 'main',
+      'section': 'section',
+      'article': 'article',
+      'cote': 'aside',
+      'aside': 'aside',
+      'titre': 'title',
+      'titre1': 'h1',
+      'titre2': 'h2',
+      'titre3': 'h3',
+      'titre4': 'h4',
+      'titre5': 'h5',
+      'titre6': 'h6',
+      'titre 1': 'h1',
+      'titre 2': 'h2',
+      'titre 3': 'h3',
+      'titre 4': 'h4',
+      'titre 5': 'h5',
+      'titre 6': 'h6',
+      'groupe titres': 'hgroup',
+      'paragraphe': 'p',
+      'texte': 'span',
+      'division': 'div',
+      'div': 'div',
+      'bloc': 'div',
+      'span': 'span',
+      'lien': 'a',
+      'ressource': 'link',
+      'lien externe': 'link',
+      'image': 'img',
+      'liste': 'ul',
+      'liste ordonnee': 'ol',
+      'liste non ordonnee': 'ul',
+      'element': 'li',
+      'element liste': 'li',
+      'tableau': 'table',
+      'ligne': 'tr',
+      'cellule': 'td',
+      'entete cellule': 'th',
+      'formulaire': 'form',
+      'champ': 'input',
+      'entree': 'input',
+      'input': 'input',
+      'zone texte': 'textarea',
+      'bouton': 'button',
+      'selection': 'select',
+      'option': 'option',
+      'etiquette': 'label',
+      'gras': 'strong',
+      'fort': 'strong',
+      'italique': 'em',
+      'emphase': 'em',
+      'souligne': 'u',
+      'barre': 's',
+      'code': 'code',
+      'pre': 'pre',
+      'preformate': 'pre',
+      'citation': 'blockquote',
+      'retour ligne': 'br',
+      'saut ligne': 'br',
+      'br': 'br',
+      'ligne horizontale': 'hr',
+      'hr': 'hr',
+      'video': 'video',
+      'audio': 'audio',
+      'source': 'source',
+      'cadre': 'iframe',
+      'canvas': 'canvas',
+      'toile': 'canvas',
+      'figure': 'figure',
+      'legende': 'legend',
+      'legende figure': 'figcaption',
+      'legende tableau': 'caption',
+      'legende ensemble': 'legend',
+      'entete tableau': 'thead',
+      'corps tableau': 'tbody',
+      'pied tableau': 'tfoot',
+      'ensemble champs': 'fieldset',
+      'liste donnees': 'datalist',
+      'liste description': 'dl',
+      'definition description': 'dd',
+      'image reactive': 'picture',
+      'cadre en ligne': 'iframe',
+      'citation bloc': 'blockquote',
+      'reference citation': 'cite',
+      'groupe options': 'optgroup',
+      'groupe colonnes': 'colgroup',
+      'colonne': 'col',
+      'entree clavier': 'kbd',
+      'sortie exemple': 'samp',
+      'texte alternatif': 'alt',
+      'resultat': 'output',
+      'piste': 'track',
+      'insere': 'ins',
+      'supprime': 'del',
+      'donnee': 'data',
+      'retour ligne possible': 'wbr',
+      'carte image': 'map',
+      'script': 'script',
+      'details': 'details',
+      'resume': 'summary',
+      'dialogue': 'dialog',
+      'modele': 'template',
+      'emplacement': 'slot',
+      'temps': 'time',
+      'marque': 'mark',
+      'metre': 'meter',
+      'progression': 'progress',
+      'sortie': 'output',
+      'donnees': 'data',
+      'clavier': 'kbd',
+      'exemple': 'samp',
+      'variable': 'var',
+      'abreviation': 'abbr',
+      'indice': 'sub',
+      'exposant': 'sup',
+      'petit': 'small',
+      'cite': 'cite',
+      'definition': 'dfn',
+      'adresse': 'address',
+      'rubis': 'ruby',
+      'texte rubis': 'rt',
+      'parenthese rubis': 'rp',
+      'bidirectionnel': 'bdi',
+      'direction': 'bdo',
+      'cesure': 'wbr',
+      'noscript': 'noscript',
+      'sans script': 'noscript',
+      'isolation bidi': 'bdi',
+      'remplacement bidi': 'bdo',
+      'annotation ruby': 'rt',
+      'parentheses ruby': 'rp',
+      'terme': 'dt',
+      'menu': 'menu',
+      'recherche': 'search',
+      'objet': 'object',
+      'integrer': 'embed',
+      'svg': 'svg',
+      'math': 'math',
+      'zone': 'area'
+    }
+    
+    const result = translations[lower] || translations[withSpaces] || map[lower] || map[withSpaces] || tag
+    return result.replace(/^<!DOCTYPE\s+/i, '').replace(/^<|>$/g, '').trim() || 'div'
+  }
+
+  parseStatement(lang) {
+    return null
+  }
+
+  parseExpression(lang) {
+    return null
+  }
+}
+
+module.exports = { EtherParserHTML }