Retoma pendências da Issue 103 sobre atribuição de valores específicos

exemplos/exemplo.foles

@@ -30,4 +30,4 @@
 
 lmht {
     cor-fundo: hsl(50, 80%, 80%);
-}
+}

exemplos/exemplo6.foles

@@ -0,0 +1,15 @@
+lmht {
+    recursos-fonte: "c2sc", "hist";
+}
+
+lmht {
+    eventos-ponteiro: delimitarCaixa;
+}
+
+lmht {
+    espacamento-letras: .2rem;
+}
+
+lmht {
+    fonte-texto: "Times New Roman", sans-serifa;
+}

fontes/avaliador-sintatico/avaliador-sintatico.ts

@@ -1793,9 +1793,26 @@
             return classeModificadora as Modificador;
         }
 
-        const atribuicaoAbreviada =
-            this.tratarAtribuicaoAbreviada(valoresModificador);
+        if (valoresModificador[0].tipo === tiposDeSimbolos.PONTO) {
+            const valorComPonto = `${valoresModificador[0].lexema}${valoresModificador[1].lexema}`;
+            const classeModificadora = new SeletorModificador(
+                modificador.lexema,
+                valorComPonto,
+                quantificador && quantificador.hasOwnProperty("lexema")
+                    ? quantificador.lexema
+                    : quantificador,
+                {
+                    linha: modificador.linha,
+                    colunaInicial: modificador.colunaInicial,
+                    colunaFinal: modificador.colunaFinal,
+                },
+            );
+
+            return classeModificadora as Modificador;
+        }
 
+        const atribuicaoAbreviada = this.tratarAtribuicaoAbreviada(valoresModificador);
+
         const classeModificadora = new SeletorModificador(
             modificador.lexema,
             atribuicaoAbreviada,

fontes/foles.ts

@@ -118,6 +118,6 @@ export class FolEs {
 }
 
 //  const testeFoles = new FolEs(false);
-//  console.log(testeFoles.converterParaCss('../exemplos/exemplo5.foles'));
+//  console.log(testeFoles.converterParaCss('../exemplos/exemplo6.foles'));
 //  console.log(a.converterParaFolEs('../exemplos/reverso/exemplo-metodos.css'));
 //  console.log(a.converterParaFolEs('../exemplos/reverso/exemplo-codigo.css'));

fontes/lexador/palavras-reservadas/foles.ts

@@ -396,12 +396,15 @@ export default {
     "forcar-fim": tiposDeSimbolos.QUALITATIVO,
     "forçar-fim": tiposDeSimbolos.QUALITATIVO,
     frente: tiposDeSimbolos.QUALITATIVO,
+    "grossa": tiposDeSimbolos.QUALITATIVO,
     "inicio-em-linha": tiposDeSimbolos.QUALITATIVO,
     "início-em-linha": tiposDeSimbolos.QUALITATIVO,
     isolar: tiposDeSimbolos.QUALITATIVO,
     manipulacao: tiposDeSimbolos.QUALITATIVO,
     manipulação: tiposDeSimbolos.QUALITATIVO,
     manual: tiposDeSimbolos.QUALITATIVO,
+    "media": tiposDeSimbolos.QUALITATIVO,
+    "média": tiposDeSimbolos.QUALITATIVO,
     "modo-conteudo": tiposDeSimbolos.QUALITATIVO,
     "modo-conteúdo": tiposDeSimbolos.QUALITATIVO,
     "mudar-conteudo": tiposDeSimbolos.QUALITATIVO,

fontes/modificadores/atributos/fontes.ts

@@ -0,0 +1,15 @@
+export const fontes: { [nomeFoles: string]: string } = {
+    // Fontes (family font name)
+    Arial: "Arial",
+    "Brush Script MT": "Brush Script MT",
+    "Courier New": "Courier New",
+    Garamond: "Garamond",
+    "Gill Sans Extrabold": "Gill Sans Extrabold",
+    Georgia: "Georgia",
+    Helvetica: "Helvetica",
+    "Lucida Console": "Lucida Console",
+    Tahoma: "Tahoma",
+    "Trebuchet MS": "Trebuchet MS",
+    "Times New Roman": "Times New Roman",
+    Verdana: "Verdana",
+};

fontes/modificadores/espacamento-letras.ts

@@ -22,8 +22,14 @@ export class EspacamentoLetras extends Modificador {
 
         // Também pode receber valores numéricos com ponto (.) na frente
         // Ex.: espaçamento-letras: .2rem;
+        let valorComPonto = false;
 
         if (!valorVariavel) {
+            if (valor.includes('.')) {
+                valorComPonto = true;
+                valor = valor.replace('.', '');
+            }
+
             validarValorNumerico(
                 "espaçamento-letras",
                 valor,
@@ -41,6 +47,7 @@ export class EspacamentoLetras extends Modificador {
             }
         }
 
+        if (valorComPonto) valor = `.${valor}`;
         this.valor = valor;
     }
 }

fontes/modificadores/eventos-ponteiro.ts

@@ -1,11 +1,22 @@
-import { valoresGlobais } from "./atributos/globais";
 import { Modificador, PragmasModificador } from "./superclasse";
 import { validarValores } from "./validacoes/comum";
 
 export class EventosPonteiro extends Modificador {
     valoresAceitos: { [valorFoles: string]: string } = {
         auto: "auto",
         nenhum: "none",
+        pinturaVisivel: "visiblePainted",
+        pinturaVisível: "visiblePainted",
+        preenchimentoVisivel: "visibleFill",
+        preenchimentoVisível: "visibleFill",
+        tracoVisivel: "visibleStroke",
+        traçoVisível: "visibleStroke",
+        pintado: "painted",
+        preencher: "fill",
+        tracado: "stroke",
+        traçado: "stroke",
+        delimitarCaixa: "bounding-box",
+        tudo: "all",
     };
 
     constructor(

fontes/modificadores/fonte-texto.ts

@@ -1,5 +1,6 @@
 import { Modificador, PragmasModificador } from "./superclasse";
-import { validarValores } from "./validacoes/comum";
+import { validarValorFonte } from "./validacoes/fonte";
+import { validarValorString } from "./validacoes/string";
 
 export class FonteTexto extends Modificador {
     valoresAceitos: { [valorFoles: string]: string } = {
@@ -16,6 +17,21 @@ export class FonteTexto extends Modificador {
         math: "math",
         emoji: "emoji",
         fangsong: "fangsong",
+        "serifa": "serif",
+        "sem-serifa": "sans-serif",
+        "monoespaço": "monospace",
+        "monoespaco": "monospace",
+        "cursiva": "cursive",
+        "fantasia": "fantasy",
+        "sistema-iu": "system-ui",
+        "iu-serifa": "ui-serif",
+        "iu-sem-serifa": "ui-sans-serif",
+        "iu-monoespaço": "ui-monospace",
+        "iu-monoespaco": "ui-monospace",
+        "iu-arredondada": "ui-rounded",
+        "matematica": "math",
+        "matemática": "math",
+        "serifa-chinesa": "fangsong",
     };
 
     constructor(
@@ -26,18 +42,22 @@ export class FonteTexto extends Modificador {
     ) {
         super("fonte-texto", "font-family", pragmas);
 
-        // OBS.: A lista de valores aceitos inclui todas as FONTES GENÉRICAS (<generic-name>).
-        // Porém, o modificador também pode receber DOIS PARÂMETROS,
-        // sendo o PRIMEIRO o nome de qualquer fonte existente (<family-name>).
+        if (!valorVariavel) {
+            if (valor.includes(",")) {
+                const separarValores = valor.split(", ");
 
-        // Ex.: fonte-texto: "Gill Sans Extrabold", sans-serif;
-
-        // OBS.2: Fontes com mais de uma palavra devem ser passadas como string (entre "");
-        // OBS.3: O segundo parâmetro é obrigatório para o caso da primeira fonte não estar disponível.
-
-        // A lógica abaixo cobre somente o recebimento dos valores genéricos.
-        if (!valorVariavel)
-            validarValores("fonte-texto", valor, this.valoresAceitos);
+                separarValores.forEach((valorIndividual) => {
+                    const valorString = validarValorString(valorIndividual);
+                    if (valorString) valorIndividual = valorIndividual.replace(/^["']|["']$/g, '');
+                    validarValorFonte("fonte-texto", valorIndividual, this.valoresAceitos);
+                });
+            } else {
+                const valorString = validarValorString(valor);
+                if (valorString) valor = valor.replace(/^["']|["']$/g, '');
+                validarValorFonte("fonte-texto", valor, this.valoresAceitos);
+                if (valorString) valor = `"${valor}"`;
+            }
+        }
 
         this.valor = valor;
     }

fontes/modificadores/recursos-fonte.ts

@@ -1,5 +1,7 @@
 import { Modificador, PragmasModificador } from "./superclasse";
 import { validarValores } from "./validacoes/comum";
+import { validarValorNumerico } from "./validacoes/numerica";
+import { validarValorString } from "./validacoes/string";
 
 export class RecursosFonte extends Modificador {
     valoresAceitos: { [valorFoles: string]: string } = {
@@ -14,8 +16,37 @@ export class RecursosFonte extends Modificador {
     ) {
         super("recursos-fonte", "font-feature-settings", pragmas);
 
-        if (!valorVariavel)
-            validarValores("recursos-fonte", valor, this.valoresAceitos);
+        const valoresExtra = ["feature-tag-value"];
+
+        if (!valorVariavel) {
+            if (valor.includes(",")) {
+                const separarValores = valor.split(", ");
+
+                separarValores.forEach((valorIndividual) => {
+                    const validacaoString = validarValorString(valorIndividual);
+
+                    // Valor feature-tag-value: string de 4 caracteres (comprimento 6 com as aspas)
+                    const validacaoTagValue = valorIndividual.length === 6;
+
+                    if (validacaoString && validacaoTagValue) {
+                        this.valoresAceitos[valorIndividual] = valorIndividual;
+                    }
+
+                    validarValorNumerico("recursos-fonte", valorIndividual, this.valoresAceitos, valoresExtra);
+                });
+            } else {
+                const validacaoString = validarValorString(valor);
+
+                // Valor feature-tag-value: string de 4 caracteres (comprimento 6 com as aspas)
+                const validacaoTagValue = valor.length === 6;
+
+                if (validacaoString && validacaoTagValue) {
+                    this.valoresAceitos[valor] = valor;
+                }
+
+                validarValores("recursos-fonte", valor, this.valoresAceitos, valoresExtra);
+            }
+        }
 
         this.valor = valor;
     }

fontes/modificadores/validacoes/fonte.ts

@@ -0,0 +1,21 @@
+import { fontes } from "../atributos/fontes";
+import { valoresGlobais } from "../atributos/globais";
+
+export function validarValorFonte(
+    nomePropriedade: string,
+    valor: any,
+    valoresAceitos: { [valorFoles: string]: string },
+    valoresExtra?: any,
+) {
+    if (
+        !(valor in fontes) &&
+        !(valor in valoresAceitos) &&
+        !(valor in valoresGlobais)
+    ) {
+        throw new Error(`Propriedade '${nomePropriedade}' com valor ${valor} inválido. Valores aceitos:
+            ${Object.keys(fontes).reduce((final, atual) => (final += `, ${atual}`))},
+            ${Object.keys(valoresAceitos).reduce((final, atual) => (final += `, ${atual}`))},
+            ${Object.keys(valoresGlobais).reduce((final, atual) => (final += `, ${atual}`))}.
+        `);
+    }
+}

fontes/serializadores/serializador.ts

@@ -8,6 +8,7 @@ import estruturasHtml from "../tradutores/estruturas-html";
 import { DeclaracaoVariavel } from "../declaracoes/declaracao-variavel";
 import { Declaracao } from "../declaracoes/declaracao";
 import { SeletorModificador } from "../modificadores/superclasse";
+import { fontes } from "../modificadores/atributos/fontes";
 
 /**
  * A classe que efetivamente traduz FolEs para CSS.
@@ -31,9 +32,8 @@ export class Serializador {
     ): string {
         // Caso 1: Número-Quantificador ou somente Número.
         if (Number(modificador.valor) || modificador.valor === "0") {
-            return `${" ".repeat(indentacao)}${modificador.propriedadeCss}: ${
-                modificador.valor
-            }${modificador.quantificador || ""};\n`;
+            return `${" ".repeat(indentacao)}${modificador.propriedadeCss}: ${modificador.valor
+                }${modificador.quantificador || ""};\n`;
         }
 
         // Caso 2: Tradução do valor contida no objeto 'valoresAceitos'.
@@ -43,19 +43,46 @@ export class Serializador {
         ) {
             const objetoValores = modificador["valoresAceitos"];
             const valorTraduzido = objetoValores[modificador.valor];
-            return `${" ".repeat(indentacao)}${
-                modificador.propriedadeCss
-            }: ${valorTraduzido};\n`;
+            return `${" ".repeat(indentacao)}${modificador.propriedadeCss
+                }: ${valorTraduzido};\n`;
         }
 
         // Caso 3: Valor é RGB, RGBA, HSL, HSLA ou HEX, ou seja, um método.
         if (modificador.valor instanceof Metodo) {
-            return `${" ".repeat(indentacao)}${modificador.propriedadeCss}: ${
-                modificador.valor.paraTexto() || ""
-            };\n`;
+            return `${" ".repeat(indentacao)}${modificador.propriedadeCss}: ${modificador.valor.paraTexto() || ""
+                };\n`;
         }
 
-        // Caso 4: Atribuição Abreviada | Múltiplos valores separados por espaço, vírgula ou barra
+        // Caso 4: Valor com aspas - como as fontes de texto.
+        if (modificador.valor.includes('"')) {
+            if (modificador.valor.includes(",")) {
+                const separarValores = modificador.valor.split(", ");
+                const valorSemAspas = separarValores[0].replace(/["']/g, '');
+
+                // Trecho específico para tratamento de fontes com grafia
+                if (Object.keys(fontes).includes(valorSemAspas)) {
+                    let unirValores = '';
+                    separarValores.forEach((valorIndividual) => {
+                        if (
+                            modificador["valoresAceitos"] !== undefined &&
+                            modificador["valoresAceitos"].hasOwnProperty(valorIndividual)
+                        ) {
+                            const objetoValores = modificador["valoresAceitos"];
+                            const valorTraduzido = objetoValores[valorIndividual];
+                            separarValores[1] = valorTraduzido;
+                            unirValores = separarValores.join(", ");
+                        }
+                    });
+                    return `${" ".repeat(indentacao)}${modificador.propriedadeCss}: ${unirValores};\n`;
+                } else {
+                    return `${" ".repeat(indentacao)}${modificador.propriedadeCss}: ${modificador.valor};\n`;
+                }
+            } else {
+                return `${" ".repeat(indentacao)}${modificador.propriedadeCss}: ${modificador.valor};\n`;
+            }
+        }
+
+        // Caso 5: Atribuição Abreviada | Múltiplos valores separados por espaço, vírgula ou barra
         if (modificador.valor.includes(" ")) {
             if (modificador.valor.includes(",")) {
                 const separarValores: Array<string> =
@@ -80,26 +107,21 @@ export class Serializador {
                 );
 
                 if (valoresTraduzidos.length !== 0) {
-                    return `${" ".repeat(indentacao)}${modificador.propriedadeCss}: ${
-                        valoresTraduzidos
-                    };\n`;
+                    return `${" ".repeat(indentacao)}${modificador.propriedadeCss}: ${valoresTraduzidos
+                        };\n`;
                 } else {
-                    return `${" ".repeat(indentacao)}${modificador.propriedadeCss}: ${
-                        modificador.valor
-                    };\n`;
+                    return `${" ".repeat(indentacao)}${modificador.propriedadeCss}: ${modificador.valor
+                        };\n`;
                 }
             }
 
-            return `${" ".repeat(indentacao)}${modificador.propriedadeCss}: ${
-                modificador.valor
-            };\n`;
+            return `${" ".repeat(indentacao)}${modificador.propriedadeCss}: ${modificador.valor
+                };\n`;
         }
 
-        // Caso 5: É um valor genérico, cuja tradução está na lista 'valoresGerais'.
+        // Caso 6: É um valor genérico, cuja tradução está na lista 'valoresGerais'.
         const valorTraduzido = valoresGerais[modificador.valor];
-        return `${" ".repeat(indentacao)}${
-            modificador.propriedadeCss
-        }: ${valorTraduzido};\n`;
+        return `${" ".repeat(indentacao)}${modificador.propriedadeCss}: ${valorTraduzido};\n`;
     }
 
     serializarBlocoDeclaracao(
@@ -193,7 +215,7 @@ export class Serializador {
     validarValoresVariaveis(declaracao: BlocoDeclaracao): void {
         const nomeFolEs =
             declaracao.modificadores[0].nomeFoles.length > 1 &&
-            typeof declaracao.modificadores[0].nomeFoles === "object"
+                typeof declaracao.modificadores[0].nomeFoles === "object"
                 ? declaracao.modificadores[0].nomeFoles[0].toString()
                 : declaracao.modificadores[0].nomeFoles.toString();
 

testes/modificadores/status.test.ts

@@ -217,7 +217,5 @@ describe('Testando Seletores com STATUS como atributo', () => {
                 expect(resultadoTradutor).toContain('normal');
             }
         });
-
-
     });
 });