chemistry-adapter.js•30.1 kB
/**
* Enhanced Chemistry Adapter for Educational Content Generation
* @module content-generation/chemistry-adapter
* @description Specialized adapter for chemistry content with molecular and reaction enhancements
* @version 5.0.0-alpha
*/
import { BaseAdapter } from './base-adapter.js';
export class ChemistryAdapter extends BaseAdapter {
constructor(config = {}) {
super({
...config,
subject: 'química',
enhancedFeatures: ['molecular_structures', 'reactions', 'periodic_table', 'laboratory']
});
// Initialize chemistry-specific capabilities
this.initializeChemistryCapabilities();
}
/**
* Initialize chemistry-specific enhancement modules
*/
initializeChemistryCapabilities() {
// Chemical reaction types and patterns
this.reactionTypes = {
synthesis: {
pattern: 'A + B → AB',
description: 'Reação de síntese ou combinação',
examples: ['H₂ + Cl₂ → 2HCl', '2Na + Cl₂ → 2NaCl']
},
decomposition: {
pattern: 'AB → A + B',
description: 'Reação de decomposição',
examples: ['2H₂O → 2H₂ + O₂', 'CaCO₃ → CaO + CO₂']
},
single_displacement: {
pattern: 'A + BC → AC + B',
description: 'Reação de simples troca',
examples: ['Zn + CuSO₄ → ZnSO₄ + Cu', 'Mg + 2HCl → MgCl₂ + H₂']
},
double_displacement: {
pattern: 'AB + CD → AD + CB',
description: 'Reação de dupla troca',
examples: ['AgNO₃ + NaCl → AgCl + NaNO₃', 'BaCl₂ + Na₂SO₄ → BaSO₄ + 2NaCl']
},
combustion: {
pattern: 'CₓHᵧ + O₂ → CO₂ + H₂O',
description: 'Reação de combustão',
examples: ['CH₄ + 2O₂ → CO₂ + 2H₂O', 'C₂H₆ + 7/2O₂ → 2CO₂ + 3H₂O']
},
acid_base: {
pattern: 'Ácido + Base → Sal + Água',
description: 'Reação ácido-base (neutralização)',
examples: ['HCl + NaOH → NaCl + H₂O', 'H₂SO₄ + 2KOH → K₂SO₄ + 2H₂O']
}
};
// Periodic table groups and properties
this.periodicGroups = {
alkali_metals: {
group: 1,
elements: ['Li', 'Na', 'K', 'Rb', 'Cs', 'Fr'],
properties: ['Um elétron de valência', 'Muito reativos', 'Formam íons +1', 'Baixa densidade']
},
alkaline_earth: {
group: 2,
elements: ['Be', 'Mg', 'Ca', 'Sr', 'Ba', 'Ra'],
properties: ['Dois elétrons de valência', 'Moderadamente reativos', 'Formam íons +2', 'Densidade baixa a média']
},
halogens: {
group: 17,
elements: ['F', 'Cl', 'Br', 'I', 'At'],
properties: ['Sete elétrons de valência', 'Muito reativos', 'Formam íons -1', 'Existem como moléculas diatômicas']
},
noble_gases: {
group: 18,
elements: ['He', 'Ne', 'Ar', 'Kr', 'Xe', 'Rn'],
properties: ['Oito elétrons de valência', 'Inertes químicamente', 'Gases em condições normais', 'Camada de valência completa']
}
};
// Molecular geometry types
this.molecularGeometries = {
linear: {
description: 'Geometria linear',
angle: '180°',
examples: ['BeF₂', 'CO₂', 'HCN'],
hybridization: 'sp'
},
trigonal_planar: {
description: 'Geometria trigonal plana',
angle: '120°',
examples: ['BF₃', 'SO₃', 'NO₃⁻'],
hybridization: 'sp²'
},
tetrahedral: {
description: 'Geometria tetraédrica',
angle: '109.5°',
examples: ['CH₄', 'CCl₄', 'NH₄⁺'],
hybridization: 'sp³'
},
trigonal_bipyramidal: {
description: 'Geometria bipiramidal trigonal',
angle: '90°/120°',
examples: ['PF₅', 'SF₄', 'ClF₃'],
hybridization: 'sp³d'
},
octahedral: {
description: 'Geometria octaédrica',
angle: '90°',
examples: ['SF₆', 'PF₆⁻', 'Fe(CN)₆³⁻'],
hybridization: 'sp³d²'
}
};
// Laboratory equipment and procedures
this.laboratoryEquipment = {
measurement: ['balança analítica', 'bureta', 'pipeta', 'proveta', 'micropipeta'],
heating: ['bico de bunsen', 'chapa aquecedora', 'manta aquecedora', 'banho-maria'],
separation: ['funil de separação', 'centrífuga', 'papel de filtro', 'evaporador rotativo'],
analysis: ['espectrômetro', 'cromatógrafo', 'titulador', 'pH-metro', 'condutivímetro']
};
// Chemical bonding types
this.bondingTypes = {
ionic: {
description: 'Ligação iônica - transferência de elétrons',
characteristics: ['Entre metal e não-metal', 'Formação de íons', 'Retículo cristalino'],
examples: ['NaCl', 'CaF₂', 'MgO']
},
covalent: {
description: 'Ligação covalente - compartilhamento de elétrons',
characteristics: ['Entre não-metais', 'Compartilhamento de pares eletrônicos', 'Formação de moléculas'],
examples: ['H₂O', 'CO₂', 'NH₃']
},
metallic: {
description: 'Ligação metálica - mar de elétrons',
characteristics: ['Entre metais', 'Elétrons deslocalizados', 'Condutividade elétrica'],
examples: ['Fe', 'Cu', 'Al']
},
hydrogen: {
description: 'Ligação de hidrogênio - interação eletrostática',
characteristics: ['Força intermolecular', 'H ligado a N, O ou F', 'Responsável por propriedades especiais'],
examples: ['H₂O', 'NH₃', 'HF']
}
};
// Thermodynamic concepts
this.thermodynamicConcepts = {
enthalpy: {
symbol: 'ΔH',
unit: 'kJ/mol',
description: 'Variação de entalpia - calor absorvido ou liberado',
types: ['formação', 'combustão', 'fusão', 'vaporização']
},
entropy: {
symbol: 'ΔS',
unit: 'J/(mol·K)',
description: 'Variação de entropia - medida da desordem',
factors: ['temperatura', 'estado físico', 'complexidade molecular']
},
gibbs: {
symbol: 'ΔG',
unit: 'kJ/mol',
description: 'Energia livre de Gibbs - espontaneidade da reação',
equation: 'ΔG = ΔH - TΔS'
}
};
}
/**
* Enhanced content generation with chemistry-specific features
* @param {Object} topicAnalysis - Result from analyzeTopic
* @param {Object} requirements - Content generation requirements
* @returns {Promise<Object>} Enhanced chemistry content
*/
async generateContent(topicAnalysis, requirements = {}) {
console.log('[CHEMISTRY-ADAPTER] Generating enhanced chemistry content for:', topicAnalysis.subject);
try {
// Generate base content first
const baseContent = await super.generateContent(topicAnalysis, requirements);
// Enhance with chemistry-specific content
const enhancedContent = await this.enhanceWithChemistryContent(baseContent, topicAnalysis);
console.log('[CHEMISTRY-ADAPTER] Chemistry enhancement complete');
return enhancedContent;
} catch (error) {
console.error('[CHEMISTRY-ADAPTER] Enhanced content generation failed:', error);
throw new Error(`Chemistry content generation failed: ${error.message}`);
}
}
/**
* Enhance base content with chemistry-specific features
* @param {Object} baseContent - Base content from BaseAdapter
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Promise<Object>} Enhanced content
*/
async enhanceWithChemistryContent(baseContent, topicAnalysis) {
const enhanced = { ...baseContent };
// Add chemistry metadata
enhanced.metadata.subject = 'química';
enhanced.metadata.enhancedFeatures = this.config.enhancedFeatures;
enhanced.metadata.chemistryType = this.identifyChemistryType(topicAnalysis);
// Enhance explanation with chemical concepts
if (enhanced.components.explanation) {
enhanced.components.explanation = await this.enhanceExplanationWithChemistry(
enhanced.components.explanation,
topicAnalysis
);
}
// Enhance examples with chemical reactions
if (enhanced.components.examples) {
enhanced.components.examples = await this.enhanceExamplesWithChemistry(
enhanced.components.examples,
topicAnalysis
);
}
// Enhance assessment with chemistry problems
if (enhanced.components.assessment) {
enhanced.components.assessment = await this.enhanceAssessmentWithChemistry(
enhanced.components.assessment,
topicAnalysis
);
}
// Add chemistry-specific components
enhanced.components.molecular_structures = await this.generateMolecularComponent(topicAnalysis);
enhanced.components.reactions = await this.generateReactionsComponent(topicAnalysis);
enhanced.components.periodic_table = await this.generatePeriodicTableComponent(topicAnalysis);
enhanced.components.laboratory = await this.generateLaboratoryComponent(topicAnalysis);
return enhanced;
}
/**
* Identify chemistry type from topic analysis
* @param {Object} topicAnalysis - Topic analysis result
* @returns {string} Chemistry type
*/
identifyChemistryType(topicAnalysis) {
const { keywords, concepts } = topicAnalysis;
const allTerms = [...keywords, ...concepts].join(' ').toLowerCase();
// Check for specific chemistry areas
if (allTerms.includes('orgânica') || allTerms.includes('carbono') || allTerms.includes('hidrocarboneto')) {
return 'organic';
}
if (allTerms.includes('inorgânica') || allTerms.includes('metal') || allTerms.includes('sal')) {
return 'inorganic';
}
if (allTerms.includes('analítica') || allTerms.includes('titulação') || allTerms.includes('concentração')) {
return 'analytical';
}
if (allTerms.includes('física') || allTerms.includes('termodinâmica') || allTerms.includes('cinética')) {
return 'physical';
}
if (allTerms.includes('bioquímica') || allTerms.includes('proteína') || allTerms.includes('enzima')) {
return 'biochemistry';
}
// Check for specific topics
if (allTerms.includes('átomo') || allTerms.includes('elétron') || allTerms.includes('orbital')) {
return 'atomic';
}
if (allTerms.includes('ligação') || allTerms.includes('molecular') || allTerms.includes('geometria')) {
return 'molecular';
}
if (allTerms.includes('reação') || allTerms.includes('equação') || allTerms.includes('balanceamento')) {
return 'reactions';
}
if (allTerms.includes('solução') || allTerms.includes('concentração') || allTerms.includes('molaridade')) {
return 'solutions';
}
if (allTerms.includes('ácido') || allTerms.includes('base') || allTerms.includes('ph')) {
return 'acid_base';
}
return 'general'; // Default chemistry type
}
/**
* Enhance explanation with chemistry content
* @param {Object} explanation - Base explanation component
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Promise<Object>} Enhanced explanation
*/
async enhanceExplanationWithChemistry(explanation, topicAnalysis) {
const enhanced = { ...explanation };
// Add chemistry principles
const chemistryType = this.identifyChemistryType(topicAnalysis);
const principles = this.getChemistryPrinciples(chemistryType);
// Enhance content with chemistry-specific information
enhanced.content += '\n\n**Princípios Químicos Fundamentais:**\n';
enhanced.content += principles.map(p => `• ${p}`).join('\n');
// Add molecular information if applicable
const molecularInfo = this.getMolecularInformation(chemistryType);
if (molecularInfo.length > 0) {
enhanced.content += '\n\n**Aspectos Moleculares:**\n';
enhanced.content += molecularInfo.map(info => `• ${info}`).join('\n');
}
// Add reaction information if applicable
const reactionInfo = this.getReactionInformation(chemistryType);
if (reactionInfo.length > 0) {
enhanced.content += '\n\n**Aspectos Reacionais:**\n';
enhanced.content += reactionInfo.map(info => `• ${info}`).join('\n');
}
return enhanced;
}
/**
* Enhance examples with chemistry reactions and problems
* @param {Object} examples - Base examples component
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Promise<Object>} Enhanced examples
*/
async enhanceExamplesWithChemistry(examples, topicAnalysis) {
const enhanced = { ...examples };
// Generate chemistry-specific examples
const chemistryType = this.identifyChemistryType(topicAnalysis);
const chemistryExamples = this.generateChemistryExamples(chemistryType);
enhanced.examples = [...enhanced.examples, ...chemistryExamples];
enhanced.content += '\n\n**Exemplos de Problemas de Química:**\n';
enhanced.content += chemistryExamples.map((ex, i) => `${i + 1}. ${ex}`).join('\n\n');
return enhanced;
}
/**
* Enhance assessment with chemistry problems
* @param {Object} assessment - Base assessment component
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Promise<Object>} Enhanced assessment
*/
async enhanceAssessmentWithChemistry(assessment, topicAnalysis) {
const enhanced = { ...assessment };
// Add chemistry-specific questions
const chemistryType = this.identifyChemistryType(topicAnalysis);
const chemistryQuestions = this.generateChemistryQuestions(chemistryType, topicAnalysis);
enhanced.questions = [...enhanced.questions, ...chemistryQuestions];
return enhanced;
}
/**
* Generate molecular structures component
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Promise<Object>} Molecular component
*/
async generateMolecularComponent(topicAnalysis) {
const chemistryType = this.identifyChemistryType(topicAnalysis);
const molecularAspects = this.getMolecularAspects(chemistryType);
return {
type: 'molecular_structures',
title: 'Estruturas Moleculares',
content: 'Compreender as estruturas moleculares é fundamental para entender as propriedades e comportamentos químicos.',
aspects: molecularAspects,
geometries: this.getRelevantGeometries(chemistryType),
bonding: this.getRelevantBonding(chemistryType),
duration: '8-12 minutos'
};
}
/**
* Generate reactions component
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Promise<Object>} Reactions component
*/
async generateReactionsComponent(topicAnalysis) {
const chemistryType = this.identifyChemistryType(topicAnalysis);
const reactionTypes = this.getRelevantReactions(chemistryType);
return {
type: 'reactions',
title: 'Reações Químicas',
content: 'As reações químicas são processos onde substâncias se transformam em outras com propriedades diferentes.',
reactionTypes: reactionTypes,
balancing: this.getBalancingMethods(),
mechanisms: this.getReactionMechanisms(chemistryType),
duration: '10-15 minutos'
};
}
/**
* Generate periodic table component
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Promise<Object>} Periodic table component
*/
async generatePeriodicTableComponent(topicAnalysis) {
const relevantGroups = this.getRelevantPeriodicGroups(topicAnalysis);
const trends = this.getPeriodicTrends();
return {
type: 'periodic_table',
title: 'Tabela Periódica e Propriedades',
content: 'A tabela periódica organiza os elementos de acordo com suas propriedades químicas e físicas.',
relevantGroups: relevantGroups,
trends: trends,
properties: this.getElementProperties(),
duration: '8-10 minutos'
};
}
/**
* Generate laboratory component
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Promise<Object>} Laboratory component
*/
async generateLaboratoryComponent(topicAnalysis) {
const chemistryType = this.identifyChemistryType(topicAnalysis);
const procedures = this.getLaboratoryProcedures(chemistryType);
const safety = this.getSafetyConsiderations(chemistryType);
return {
type: 'laboratory',
title: 'Aspectos Laboratoriais',
content: 'A prática laboratorial é essencial para compreender e aplicar conceitos químicos.',
procedures: procedures,
equipment: this.getRelevantEquipment(chemistryType),
safety: safety,
duration: '10-15 minutos'
};
}
/**
* Get chemistry principles for a given type
* @param {string} chemistryType - Type of chemistry
* @returns {Array} Chemistry principles
*/
getChemistryPrinciples(chemistryType) {
const principles = {
atomic: [
'Átomos são constituídos por prótons, nêutrons e elétrons',
'Elétrons ocupam orbitais com níveis de energia definidos',
'Configuração eletrônica determina propriedades químicas',
'Princípio da exclusão de Pauli e regra de Hund'
],
molecular: [
'Ligações químicas formam-se para estabilizar átomos',
'Geometria molecular influencia propriedades físicas',
'Hibridização explica geometrias moleculares',
'Forças intermoleculares afetam propriedades macroscópicas'
],
reactions: [
'Lei da conservação da massa em reações químicas',
'Velocidade de reação depende de concentração e temperatura',
'Catalisadores reduzem energia de ativação',
'Equilíbrio químico é dinâmico'
],
acid_base: [
'Ácidos doam prótons, bases recebem prótons',
'pH é medida da acidez de soluções',
'Tampões mantêm pH relativamente constante',
'Titulação permite determinar concentrações'
],
organic: [
'Carbono forma quatro ligações covalentes',
'Grupos funcionais determinam propriedades',
'Isomeria estrutural e espacial',
'Mecanismos de reação orgânica'
]
};
return principles[chemistryType] || principles.molecular;
}
/**
* Get molecular information for chemistry type
* @param {string} chemistryType - Type of chemistry
* @returns {Array} Molecular information
*/
getMolecularInformation(chemistryType) {
const info = {
molecular: [
'Forma molecular determina polaridade',
'Hibridização explica ângulos de ligação',
'Teoria VSEPR prevê geometria molecular',
'Ressonância estabiliza moléculas'
],
organic: [
'Cadeias carbônicas podem ser lineares, ramificadas ou cíclicas',
'Grupos funcionais conferem reatividade específica',
'Quiralidade e atividade óptica',
'Conjugação e aromaticidade'
],
inorganic: [
'Complexos metálicos e teoria do campo cristalino',
'Estados de oxidação e estrutura eletrônica',
'Poliedros de coordenação',
'Propriedades magnéticas e ópticas'
]
};
return info[chemistryType] || [];
}
/**
* Get reaction information for chemistry type
* @param {string} chemistryType - Type of chemistry
* @returns {Array} Reaction information
*/
getReactionInformation(chemistryType) {
const info = {
reactions: [
'Classificação por tipo de transformação',
'Balanceamento por tentativa e método algébrico',
'Estequiometria e cálculos quantitativos',
'Rendimento teórico e prático'
],
organic: [
'Substituição, adição e eliminação',
'Mecanismos radicalares e iônicos',
'Efeitos eletrônicos e estéricos',
'Síntese e retrossíntese'
],
acid_base: [
'Neutralização e formação de sais',
'Constantes de acidez e basicidade',
'Hidrólise de sais',
'Indicadores e curvas de titulação'
]
};
return info[chemistryType] || [];
}
/**
* Generate chemistry-specific examples
* @param {string} chemistryType - Type of chemistry
* @returns {Array} Chemistry examples
*/
generateChemistryExamples(chemistryType) {
const examples = {
reactions: [
'Balanceamento da equação: __ C₂H₆ + __ O₂ → __ CO₂ + __ H₂O',
'Cálculo de massa em reação: 2Na + Cl₂ → 2NaCl (massa de NaCl produzida)',
'Determinação do reagente limitante em síntese química'
],
acid_base: [
'Cálculo de pH de solução de HCl 0,1 M',
'Titulação de 25 mL de NaOH com HCl 0,2 M',
'Preparação de tampão acetato pH 4,7'
],
organic: [
'Nomenclatura IUPAC do 2-metil-3-hexanol',
'Reação de adição de HBr ao propeno',
'Identificação de grupos funcionais em biomoléculas'
],
solutions: [
'Preparação de solução NaCl 0,5 M a partir do sal sólido',
'Diluição de H₂SO₄ concentrado para 2 M',
'Cálculo de concentração após mistura de soluções'
],
atomic: [
'Configuração eletrônica do íon Fe³⁺',
'Cálculo de energia de ionização do sódio',
'Determinação de números quânticos do elétron mais externo'
]
};
return examples[chemistryType] || examples.reactions;
}
/**
* Generate chemistry-specific questions
* @param {string} chemistryType - Type of chemistry
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Array} Chemistry questions
*/
generateChemistryQuestions(chemistryType, topicAnalysis) {
const questions = [
{
type: 'multiple_choice',
question: `Qual é o conceito fundamental em ${chemistryType}?`,
options: [
'Estrutura atômica',
'Ligações químicas',
'Reações químicas',
'Todos os anteriores'
],
correct: 3,
explanation: 'Todos os conceitos são fundamentais na química.'
},
{
type: 'calculation',
question: `Resolva um problema quantitativo típico de ${chemistryType}.`,
requiredSteps: ['Dados', 'Equação', 'Cálculo', 'Resultado'],
chemistryType: chemistryType
},
{
type: 'structural',
question: `Desenhe ou descreva a estrutura relevante para ${topicAnalysis.subject}.`,
elements: ['fórmula', 'geometria', 'propriedades'],
expectedDetail: 'medium'
}
];
return questions;
}
/**
* Get molecular aspects for chemistry type
* @param {string} chemistryType - Type of chemistry
* @returns {Object} Molecular aspects
*/
getMolecularAspects(chemistryType) {
const aspects = {
molecular: {
structure: 'Arranjo tridimensional de átomos',
bonding: 'Ligações covalentes e sua natureza',
geometry: 'Forma molecular e ângulos de ligação',
properties: 'Relação estrutura-propriedade'
},
organic: {
skeleton: 'Cadeia carbônica e ramificações',
functional_groups: 'Grupos funcionais e reatividade',
isomerism: 'Isomeria estrutural e espacial',
mechanisms: 'Mecanismos de reação'
}
};
return aspects[chemistryType] || aspects.molecular;
}
/**
* Get relevant molecular geometries
* @param {string} chemistryType - Type of chemistry
* @returns {Array} Relevant geometries
*/
getRelevantGeometries(chemistryType) {
if (chemistryType === 'molecular' || chemistryType === 'inorganic') {
return Object.entries(this.molecularGeometries).map(([name, data]) => ({
name: name,
description: data.description,
angle: data.angle,
examples: data.examples
}));
}
return [this.molecularGeometries.tetrahedral, this.molecularGeometries.trigonal_planar];
}
/**
* Get relevant bonding information
* @param {string} chemistryType - Type of chemistry
* @returns {Array} Bonding information
*/
getRelevantBonding(chemistryType) {
if (chemistryType === 'molecular' || chemistryType === 'atomic') {
return Object.entries(this.bondingTypes).map(([type, data]) => ({
type: type,
description: data.description,
characteristics: data.characteristics,
examples: data.examples
}));
}
return [this.bondingTypes.covalent, this.bondingTypes.ionic];
}
/**
* Get relevant reactions for chemistry type
* @param {string} chemistryType - Type of chemistry
* @returns {Array} Reaction types
*/
getRelevantReactions(chemistryType) {
if (chemistryType === 'reactions' || chemistryType === 'general') {
return Object.entries(this.reactionTypes).map(([type, data]) => ({
type: type,
pattern: data.pattern,
description: data.description,
examples: data.examples
}));
}
return [this.reactionTypes.synthesis, this.reactionTypes.decomposition];
}
/**
* Get balancing methods
* @returns {Array} Balancing methods
*/
getBalancingMethods() {
return [
'Método da tentativa (inspeção)',
'Método algébrico (sistema de equações)',
'Método íon-elétron (reações redox)',
'Método do número de oxidação'
];
}
/**
* Get reaction mechanisms for chemistry type
* @param {string} chemistryType - Type of chemistry
* @returns {Array} Reaction mechanisms
*/
getReactionMechanisms(chemistryType) {
const mechanisms = {
organic: [
'Substituição nucleofílica (SN1, SN2)',
'Eliminação (E1, E2)',
'Adição eletrofílica',
'Substituição eletrofílica aromática'
],
inorganic: [
'Transferência de elétrons',
'Formação/quebra de ligações',
'Rearranjos moleculares',
'Catálise heterogênea'
]
};
return mechanisms[chemistryType] || ['Mecanismo elementar', 'Etapas múltiplas'];
}
/**
* Get relevant periodic groups
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Array} Periodic groups
*/
getRelevantPeriodicGroups(topicAnalysis) {
const { keywords, concepts } = topicAnalysis;
const allTerms = [...keywords, ...concepts].join(' ').toLowerCase();
const relevantGroups = [];
if (allTerms.includes('metal') || allTerms.includes('sódio') || allTerms.includes('potássio')) {
relevantGroups.push(this.periodicGroups.alkali_metals);
}
if (allTerms.includes('halogênio') || allTerms.includes('cloro') || allTerms.includes('flúor')) {
relevantGroups.push(this.periodicGroups.halogens);
}
if (allTerms.includes('gás nobre') || allTerms.includes('hélio') || allTerms.includes('argônio')) {
relevantGroups.push(this.periodicGroups.noble_gases);
}
return relevantGroups.length > 0 ? relevantGroups : [this.periodicGroups.alkali_metals];
}
/**
* Get periodic trends
* @returns {Array} Periodic trends
*/
getPeriodicTrends() {
return [
'Raio atômico diminui da esquerda para direita',
'Energia de ionização aumenta da esquerda para direita',
'Eletronegatividade aumenta da esquerda para direita',
'Caráter metálico diminui da esquerda para direita'
];
}
/**
* Get element properties
* @returns {Array} Element properties
*/
getElementProperties() {
return [
'Número atômico e massa atômica',
'Configuração eletrônica',
'Estados de oxidação',
'Propriedades físicas e químicas'
];
}
/**
* Get laboratory procedures for chemistry type
* @param {string} chemistryType - Type of chemistry
* @returns {Array} Laboratory procedures
*/
getLaboratoryProcedures(chemistryType) {
const procedures = {
analytical: [
'Titulação ácido-base',
'Gravimetria por precipitação',
'Espectrofotometria UV-Vis',
'Cromatografia em camada delgada'
],
organic: [
'Síntese orgânica',
'Purificação por destilação',
'Recristalização',
'Identificação por RMN'
],
general: [
'Preparação de soluções',
'Medição de pH',
'Observação de reações',
'Coleta e análise de dados'
]
};
return procedures[chemistryType] || procedures.general;
}
/**
* Get safety considerations for chemistry type
* @param {string} chemistryType - Type of chemistry
* @returns {Array} Safety considerations
*/
getSafetyConsiderations(chemistryType) {
return [
'Uso obrigatório de equipamentos de proteção individual (EPI)',
'Manuseio adequado de reagentes químicos',
'Conhecimento de procedimentos de emergência',
'Descarte correto de resíduos químicos',
'Ventilação adequada do ambiente',
'Primeiros socorros em caso de acidentes'
];
}
/**
* Get relevant equipment for chemistry type
* @param {string} chemistryType - Type of chemistry
* @returns {Array} Relevant equipment
*/
getRelevantEquipment(chemistryType) {
const equipment = {
analytical: [...this.laboratoryEquipment.measurement, ...this.laboratoryEquipment.analysis],
organic: [...this.laboratoryEquipment.heating, ...this.laboratoryEquipment.separation],
general: [...this.laboratoryEquipment.measurement, ...this.laboratoryEquipment.heating]
};
return equipment[chemistryType] || equipment.general;
}
}
// Factory function for creating ChemistryAdapter instances
export function createChemistryAdapter(config = {}) {
return new ChemistryAdapter(config);
}