@designliquido/delegua
Version:
Linguagem de programação simples e moderna usando português estruturado.
182 lines • 6.15 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.palavrasNeutras = exports.gruposPalavrasParadigma = void 0;
exports.obterMapaLexemaParaParadigma = obterMapaLexemaParaParadigma;
exports.obterFormaAlternativa = obterFormaAlternativa;
exports.pertenceAoParadigma = pertenceAoParadigma;
const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
/**
* Grupos de palavras reservadas organizadas por paradigma.
* Cada grupo representa diferentes formas de expressar a mesma funcionalidade.
*/
exports.gruposPalavrasParadigma = [
{
tipo: delegua_1.default.ESCREVA,
imperativo: ['escreva'],
infinitivo: ['escrever'],
},
{
tipo: delegua_1.default.LEIA,
imperativo: ['leia'],
infinitivo: ['ler'],
},
{
tipo: delegua_1.default.CONTINUA,
imperativo: ['continua'],
infinitivo: ['continuar'],
},
{
tipo: delegua_1.default.RETORNA,
imperativo: ['retorna', 'retorne'],
infinitivo: ['retornar'],
},
{
tipo: delegua_1.default.ESCOLHA,
imperativo: ['escolha'],
infinitivo: ['escolher'],
},
{
tipo: delegua_1.default.TENTE,
imperativo: ['tente'],
infinitivo: ['tentar'],
},
{
tipo: delegua_1.default.PEGUE,
imperativo: ['pegue'],
infinitivo: ['pegar'],
},
{
tipo: delegua_1.default.QUEBRAR,
imperativo: ['quebre'],
infinitivo: ['quebrar'],
},
{
tipo: delegua_1.default.IMPORTAR,
imperativo: ['importe'],
infinitivo: ['importar'],
},
{
tipo: delegua_1.default.FAZER,
imperativo: ['faca', 'faça'],
infinitivo: ['fazer'],
},
];
/**
* Palavras neutras que não têm paradigma específico.
* Estas palavras são aceitas em todos os modos de paradigma.
*/
exports.palavrasNeutras = {
ajuda: delegua_1.default.AJUDA,
cada: delegua_1.default.CADA,
caso: delegua_1.default.CASO,
classe: delegua_1.default.CLASSE,
como: delegua_1.default.COMO,
construtor: delegua_1.default.CONSTRUTOR,
constante: delegua_1.default.CONSTANTE,
const: delegua_1.default.CONSTANTE,
contem: delegua_1.default.CONTEM,
contém: delegua_1.default.CONTEM,
de: delegua_1.default.DE,
e: delegua_1.default.E,
em: delegua_1.default.EM,
enquanto: delegua_1.default.ENQUANTO,
falhar: delegua_1.default.FALHAR,
falso: delegua_1.default.FALSO,
finalmente: delegua_1.default.FINALMENTE,
fixo: delegua_1.default.CONSTANTE,
funcao: delegua_1.default.FUNCAO,
função: delegua_1.default.FUNÇÃO,
herda: delegua_1.default.HERDA,
isto: delegua_1.default.ISTO,
nao: delegua_1.default.NAO,
não: delegua_1.default.NAO,
nulo: delegua_1.default.NULO,
ou: delegua_1.default.OU,
padrao: delegua_1.default.PADRAO,
padrão: delegua_1.default.PADRAO,
para: delegua_1.default.PARA,
se: delegua_1.default.SE,
senao: delegua_1.default.SENAO,
senão: delegua_1.default.SENÃO,
super: delegua_1.default.SUPER,
sustar: delegua_1.default.SUSTAR,
tendo: delegua_1.default.TENDO,
tipo: delegua_1.default.TIPO,
tudo: delegua_1.default.TUDO,
var: delegua_1.default.VARIAVEL,
variavel: delegua_1.default.VARIAVEL,
variável: delegua_1.default.VARIAVEL,
verdadeiro: delegua_1.default.VERDADEIRO,
};
/**
* Retorna um mapa de lexema para paradigma.
* Útil para verificar rapidamente se uma palavra pertence a um paradigma.
*/
function obterMapaLexemaParaParadigma() {
const mapa = new Map();
// Adiciona palavras neutras
for (const lexema of Object.keys(exports.palavrasNeutras)) {
mapa.set(lexema, 'neutro');
}
// Adiciona palavras de paradigmas
for (const grupo of exports.gruposPalavrasParadigma) {
if (grupo.imperativo) {
for (const lexema of grupo.imperativo) {
mapa.set(lexema, 'imperativo');
}
}
if (grupo.infinitivo) {
for (const lexema of grupo.infinitivo) {
mapa.set(lexema, 'infinitivo');
}
}
}
return mapa;
}
/**
* Obtém a forma alternativa de uma palavra para o paradigma especificado.
* @param lexema A palavra original
* @param paradigmaAlvo O paradigma desejado
* @returns A forma alternativa ou undefined se não houver conversão
*/
function obterFormaAlternativa(lexema, paradigmaAlvo) {
const lexemaMinusculo = lexema.toLowerCase();
// Encontra o grupo que contém este lexema
for (const grupo of exports.gruposPalavrasParadigma) {
const temImperativo = grupo.imperativo?.some((p) => p === lexemaMinusculo);
const temInfinitivo = grupo.infinitivo?.some((p) => p === lexemaMinusculo);
if (temImperativo || temInfinitivo) {
// Retorna a primeira forma do paradigma alvo
if (paradigmaAlvo === 'imperativo' && grupo.imperativo && grupo.imperativo.length > 0) {
return grupo.imperativo[0];
}
if (paradigmaAlvo === 'infinitivo' && grupo.infinitivo && grupo.infinitivo.length > 0) {
return grupo.infinitivo[0];
}
}
}
return undefined;
}
/**
* Verifica se um lexema pertence a um paradigma específico.
* @param lexema A palavra a verificar
* @param paradigma O paradigma a verificar
* @returns true se o lexema pertence ao paradigma ou é neutro
*/
function pertenceAoParadigma(lexema, paradigma) {
if (paradigma === 'ambos') {
return true;
}
const mapa = obterMapaLexemaParaParadigma();
const paradigmaLexema = mapa.get(lexema.toLowerCase());
// Palavras neutras são aceitas em todos os paradigmas
if (paradigmaLexema === 'neutro') {
return true;
}
// Verifica se o paradigma corresponde
return paradigmaLexema === paradigma;
}
//# sourceMappingURL=mapeamento-paradigmas.js.map