@willwade/aac-processors 0.0.9 → 0.0.11

package/examples/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "aac-processors-examples",
+  "private": true,
+  "dependencies": {
+    "@google-cloud/translate": "^8.1.0",
+    "axios": "^1.6.8",
+    "commander": "^12.0.0",
+    "dotenv": "^16.4.5"
+  }
+}

package/examples/styling-example.ts

@@ -0,0 +1,316 @@
+#!/usr/bin/env ts-node
+
+/**
+ * Styling Example - Demonstrates comprehensive styling support in AACProcessors
+ * 
+ * This example shows how to:
+ * 1. Create AAC content with comprehensive styling
+ * 2. Save to different formats while preserving styling
+ * 3. Load and verify styling information
+ * 4. Convert between formats with styling preservation
+ */
+
+import { AACTree, AACPage, AACButton } from '../src/core/treeStructure';
+import { SnapProcessor } from '../src/processors/snapProcessor';
+import { TouchChatProcessor } from '../src/processors/touchchatProcessor';
+import { ObfProcessor } from '../src/processors/obfProcessor';
+import { GridsetProcessor } from '../src/processors/gridsetProcessor';
+import fs from 'fs';
+import path from 'path';
+
+// Create output directory
+const outputDir = path.join(__dirname, 'styled-output');
+if (!fs.existsSync(outputDir)) {
+  fs.mkdirSync(outputDir, { recursive: true });
+}
+
+console.log('🎨 AAC Styling Example');
+console.log('======================\n');
+
+// 1. Create a styled AAC tree
+console.log('1. Creating styled AAC content...');
+
+const tree = new AACTree();
+
+// Create a main page with styling
+const mainPage = new AACPage({
+  id: 'main-page',
+  name: 'Main Communication Board',
+  grid: [],
+  buttons: [],
+  parentId: null,
+  style: {
+    backgroundColor: '#f0f8ff', // Light blue background
+    fontFamily: 'Arial',
+    fontSize: 16,
+    borderColor: '#cccccc',
+  },
+});
+
+// Create greeting buttons with different styles
+const greetingButtons = [
+  {
+    id: 'hello-btn',
+    label: 'Hello',
+    message: 'Hello, how are you today?',
+    style: {
+      backgroundColor: '#4CAF50', // Green
+      fontColor: '#ffffff',
+      borderColor: '#45a049',
+      borderWidth: 2,
+      fontSize: 18,
+      fontFamily: 'Helvetica',
+      fontWeight: 'bold' as const,
+      labelOnTop: true,
+    },
+  },
+  {
+    id: 'goodbye-btn',
+    label: 'Goodbye',
+    message: 'Goodbye, see you later!',
+    style: {
+      backgroundColor: '#f44336', // Red
+      fontColor: '#ffffff',
+      borderColor: '#d32f2f',
+      borderWidth: 2,
+      fontSize: 18,
+      fontFamily: 'Helvetica',
+      fontWeight: 'bold' as const,
+      labelOnTop: true,
+    },
+  },
+  {
+    id: 'thanks-btn',
+    label: 'Thank You',
+    message: 'Thank you very much!',
+    style: {
+      backgroundColor: '#2196F3', // Blue
+      fontColor: '#ffffff',
+      borderColor: '#1976D2',
+      borderWidth: 1,
+      fontSize: 16,
+      fontFamily: 'Times',
+      fontStyle: 'italic' as const,
+      textUnderline: true,
+    },
+  },
+];
+
+// Add greeting buttons to the page
+greetingButtons.forEach((btnData) => {
+  const button = new AACButton({
+    id: btnData.id,
+    label: btnData.label,
+    message: btnData.message,
+    type: 'SPEAK',
+    action: null,
+    style: btnData.style,
+  });
+  mainPage.addButton(button);
+});
+
+// Create a navigation button to a second page
+const moreButton = new AACButton({
+  id: 'more-btn',
+  label: 'More Options',
+  message: 'Navigate to more options',
+  type: 'NAVIGATE',
+  targetPageId: 'more-page',
+  action: {
+    type: 'NAVIGATE',
+    targetPageId: 'more-page',
+  },
+  style: {
+    backgroundColor: '#FF9800', // Orange
+    fontColor: '#000000',
+    borderColor: '#F57C00',
+    borderWidth: 3,
+    fontSize: 14,
+    fontFamily: 'Georgia',
+    fontWeight: 'normal' as const,
+    transparent: false,
+  },
+});
+
+mainPage.addButton(moreButton);
+tree.addPage(mainPage);
+
+// Create a second page with different styling
+const morePage = new AACPage({
+  id: 'more-page',
+  name: 'More Options',
+  grid: [],
+  buttons: [],
+  parentId: 'main-page',
+  style: {
+    backgroundColor: '#fff3e0', // Light orange background
+    fontFamily: 'Verdana',
+    fontSize: 14,
+  },
+});
+
+// Add some action buttons with varied styling
+const actionButtons = [
+  {
+    id: 'eat-btn',
+    label: 'Eat',
+    message: 'I want to eat something',
+    style: {
+      backgroundColor: '#8BC34A', // Light green
+      fontColor: '#2E7D32',
+      borderColor: '#689F38',
+      borderWidth: 1,
+      fontSize: 16,
+      fontFamily: 'Arial',
+    },
+  },
+  {
+    id: 'drink-btn',
+    label: 'Drink',
+    message: 'I want something to drink',
+    style: {
+      backgroundColor: '#03A9F4', // Light blue
+      fontColor: '#ffffff',
+      borderColor: '#0288D1',
+      borderWidth: 1,
+      fontSize: 16,
+      fontFamily: 'Arial',
+    },
+  },
+];
+
+actionButtons.forEach((btnData) => {
+  const button = new AACButton({
+    id: btnData.id,
+    label: btnData.label,
+    message: btnData.message,
+    type: 'SPEAK',
+    action: null,
+    style: btnData.style,
+  });
+  morePage.addButton(button);
+});
+
+// Add back button
+const backButton = new AACButton({
+  id: 'back-btn',
+  label: 'Back',
+  message: 'Go back to main page',
+  type: 'NAVIGATE',
+  targetPageId: 'main-page',
+  action: {
+    type: 'NAVIGATE',
+    targetPageId: 'main-page',
+  },
+  style: {
+    backgroundColor: '#9E9E9E', // Gray
+    fontColor: '#ffffff',
+    borderColor: '#757575',
+    borderWidth: 1,
+    fontSize: 14,
+    fontFamily: 'Arial',
+    fontWeight: 'normal' as const,
+  },
+});
+
+morePage.addButton(backButton);
+tree.addPage(morePage);
+
+console.log(`✅ Created AAC tree with ${Object.keys(tree.pages).length} pages and comprehensive styling\n`);
+
+// 2. Save to different formats
+console.log('2. Saving to different formats with styling...');
+
+const processors = [
+  { name: 'Snap/SPS', processor: new SnapProcessor(), extension: 'spb' },
+  { name: 'TouchChat', processor: new TouchChatProcessor(), extension: 'ce' },
+  { name: 'OBF', processor: new ObfProcessor(), extension: 'obf' },
+  { name: 'Grid3', processor: new GridsetProcessor(), extension: 'gridset' },
+];
+
+const savedFiles: { [key: string]: string } = {};
+
+processors.forEach(({ name, processor, extension }) => {
+  try {
+    const filePath = path.join(outputDir, `styled-example.${extension}`);
+    processor.saveFromTree(tree, filePath);
+    savedFiles[name] = filePath;
+    console.log(`✅ Saved ${name} format: ${filePath}`);
+  } catch (error) {
+    console.log(`❌ Failed to save ${name} format: ${error}`);
+  }
+});
+
+console.log('\n3. Verifying styling preservation...');
+
+// 3. Load back and verify styling
+Object.entries(savedFiles).forEach(([formatName, filePath]) => {
+  try {
+    const processor = processors.find(p => p.name === formatName)?.processor;
+    if (!processor) return;
+
+    let loadedTree;
+    if (processor instanceof GridsetProcessor) {
+      loadedTree = processor.loadIntoTree(fs.readFileSync(filePath));
+    } else {
+      loadedTree = processor.loadIntoTree(filePath);
+    }
+    const loadedMainPage = loadedTree.getPage('main-page');
+    
+    if (loadedMainPage) {
+      const helloButton = loadedMainPage.buttons.find(b => b.label === 'Hello');
+      
+      console.log(`\n📋 ${formatName} styling verification:`);
+      console.log(`   Page background: ${loadedMainPage.style?.backgroundColor || 'Not preserved'}`);
+      console.log(`   Page font: ${loadedMainPage.style?.fontFamily || 'Not preserved'}`);
+      
+      if (helloButton?.style) {
+        console.log(`   Hello button background: ${helloButton.style.backgroundColor || 'Not preserved'}`);
+        console.log(`   Hello button font color: ${helloButton.style.fontColor || 'Not preserved'}`);
+        console.log(`   Hello button font weight: ${helloButton.style.fontWeight || 'Not preserved'}`);
+        console.log(`   Hello button border width: ${helloButton.style.borderWidth || 'Not preserved'}`);
+      } else {
+        console.log(`   Hello button styling: Not preserved`);
+      }
+    }
+  } catch (error) {
+    console.log(`❌ Failed to verify ${formatName}: ${error}`);
+  }
+});
+
+console.log('\n4. Cross-format conversion example...');
+
+// 4. Demonstrate cross-format conversion with styling preservation
+try {
+  // Load from Snap format
+  const snapPath = savedFiles['Snap/SPS'];
+  if (snapPath && fs.existsSync(snapPath)) {
+    const snapProcessor = new SnapProcessor();
+    const loadedFromSnap = snapProcessor.loadIntoTree(snapPath);
+    
+    // Save to TouchChat format
+    const touchChatProcessor = new TouchChatProcessor();
+    const convertedPath = path.join(outputDir, 'converted-snap-to-touchchat.ce');
+    touchChatProcessor.saveFromTree(loadedFromSnap, convertedPath);
+    
+    // Verify the conversion preserved styling
+    const reconvertedTree = touchChatProcessor.loadIntoTree(convertedPath);
+    const reconvertedPage = reconvertedTree.getPage('main-page');
+    const reconvertedButton = reconvertedPage?.buttons.find(b => b.label === 'Hello');
+    
+    console.log('✅ Cross-format conversion (Snap → TouchChat):');
+    console.log(`   Original background: ${tree.getPage('main-page')?.style?.backgroundColor}`);
+    console.log(`   Converted background: ${reconvertedPage?.style?.backgroundColor || 'Not preserved'}`);
+    console.log(`   Button styling preserved: ${reconvertedButton?.style ? 'Yes' : 'No'}`);
+  }
+} catch (error) {
+  console.log(`❌ Cross-format conversion failed: ${error}`);
+}
+
+console.log('\n🎉 Styling example completed!');
+console.log(`📁 Output files saved to: ${outputDir}`);
+console.log('\nKey takeaways:');
+console.log('• Styling information is preserved across all supported formats');
+console.log('• Each format supports different styling capabilities');
+console.log('• Cross-format conversion maintains compatible styling properties');
+console.log('• The AACStyle interface provides a unified styling model');

package/examples/translate.js

@@ -0,0 +1,39 @@
+const TouchChatProcessor = require('../src/processors/touchChatProcessor');
+
+async function main() {
+  const filePath = process.argv[2];
+  if (!filePath) {
+    console.error('Please provide a TouchChat .ce file path');
+    process.exit(1);
+  }
+
+  const processor = new TouchChatProcessor();
+  const texts = processor.extractTexts(filePath);
+  console.log('Found texts:', texts.length);
+  
+  // Group texts by length to help identify patterns
+  const lengthGroups = {};
+  texts.forEach(text => {
+    const len = text.length;
+    if (!lengthGroups[len]) lengthGroups[len] = [];
+    lengthGroups[len].push(text);
+  });
+
+  console.log('\nTexts grouped by length:');
+  Object.entries(lengthGroups)
+    .sort(([a], [b]) => parseInt(a) - parseInt(b))
+    .forEach(([len, group]) => {
+      if (group.length > 0) {
+        console.log(`\nLength ${len} (${group.length} items):`);
+        // Show first 5 examples
+        console.log(group.slice(0, 5));
+      }
+    });
+
+  // Show unique texts to identify duplicates
+  const unique = new Set(texts);
+  console.log('\nUnique texts:', unique.size);
+  console.log('Duplicate texts:', texts.length - unique.size);
+}
+
+main().catch(console.error);

package/examples/translate_demo.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+
+const fs = require('fs').promises;
+const path = require('path');
+const { program } = require('commander');
+const { v2: { Translate } } = require('@google-cloud/translate');
+const axios = require('axios');
+const SnapProcessor = require('../src/processors/snapProcessor');
+const GridsetProcessor = require('../src/processors/gridsetProcessor');
+const TouchChatProcessor = require('../src/processors/touchChatProcessor');
+
+// Translation service configurations
+const AZURE_TRANSLATOR_KEY = process.env.AZURE_TRANSLATOR_KEY;
+const AZURE_TRANSLATOR_REGION = process.env.AZURE_TRANSLATOR_REGION || 'uksouth';
+const AZURE_TRANSLATOR_ENDPOINT = 'https://api.cognitive.microsofttranslator.com/translate';
+
+const GOOGLE_TRANSLATE_KEY = process.env.GOOGLE_TRANSLATE_KEY;
+const GEMINI_API_KEY = process.env.GEMINI_API_KEY;
+
+// Available processors
+const PROCESSORS = [
+    GridsetProcessor,
+    TouchChatProcessor,
+    SnapProcessor
+];
+
+// Cache handling
+async function loadCache(cacheFile) {
+    try {
+        const data = await fs.readFile(cacheFile, 'utf8');
+        return JSON.parse(data);
+    } catch (error) {
+        console.warn(`Warning: Cache file ${cacheFile} not found or corrupted. Creating new cache.`);
+        return {};
+    }
+}
+
+async function saveCache(cache, cacheFile) {
+    await fs.writeFile(cacheFile, JSON.stringify(cache, null, 2), 'utf8');
+}
+
+// Azure Translator
+async function azureTranslateBatch(texts, targetLanguage) {
+    if (!AZURE_TRANSLATOR_KEY) {
+        throw new Error('Azure Translator key not set. Set AZURE_TRANSLATOR_KEY environment variable.');
+    }
+
+    const headers = {
+        'Ocp-Apim-Subscription-Key': AZURE_TRANSLATOR_KEY,
+        'Ocp-Apim-Subscription-Region': AZURE_TRANSLATOR_REGION,
+        'Content-Type': 'application/json'
+    };
+
+    const params = {
+        'api-version': '3.0',
+        'from': 'en',
+        'to': targetLanguage
+    };
+
+    const batchSize = 100;
+    const allTranslations = [];
+
+    for (let i = 0; i < texts.length; i += batchSize) {
+        const batchTexts = texts.slice(i, i + batchSize);
+        const body = batchTexts.map(text => ({ text }));
+
+        try {
+            const response = await axios.post(AZURE_TRANSLATOR_ENDPOINT, body, { headers, params });
+            const translations = response.data.map(item => item.translations[0].text);
+            allTranslations.push(...translations);
+        } catch (error) {
+            console.error('Azure translation error:', error.message);
+            throw error;
+        }
+    }
+
+    return allTranslations;
+}
+
+// Google Translate
+async function googleTranslateTexts(texts, targetLanguage) {
+    if (!GOOGLE_TRANSLATE_KEY) {
+        throw new Error('Google Translate key not set. Set GOOGLE_TRANSLATE_KEY environment variable.');
+    }
+
+    try {
+        const translate = new Translate({ key: GOOGLE_TRANSLATE_KEY });
+        const batchSize = 50;
+        const batches = [];
+        
+        for (let i = 0; i < texts.length; i += batchSize) {
+            const batch = texts.slice(i, i + batchSize);
+            batches.push(batch);
+        }
+        
+        const allTranslations = [];
+        for (const batch of batches) {
+            console.log(`Translating batch of ${batch.length} texts...`);
+            const [translations] = await translate.translate(batch, targetLanguage);
+            allTranslations.push(...(Array.isArray(translations) ? translations : [translations]));
+        }
+        
+        return allTranslations;
+    } catch (error) {
+        console.error('Google translation error:', error.message);
+        throw error;
+    }
+}
+
+// Similarity calculation
+function calculateSimilarity(original, reverseTranslated) {
+    // Simple similarity score based on character differences
+    const maxLength = Math.max(original.length, reverseTranslated.length);
+    let differences = 0;
+    
+    for (let i = 0; i < maxLength; i++) {
+        if (original[i] !== reverseTranslated[i]) differences++;
+    }
+    
+    return 1 - (differences / maxLength);
+}
+
+// Translation validation
+async function validateTranslation(original, translated, targetLanguage) {
+    // Reverse translate back to English
+    const reverseTranslated = await googleTranslateTexts([translated], 'en');
+    const similarity = calculateSimilarity(original.toLowerCase(), reverseTranslated[0].toLowerCase());
+    return similarity;
+}
+
+// Main translation function
+async function translateTexts(texts, cache, targetLanguage, enableConfidenceCheck = false) {
+    const translations = {};
+    const uncachedTexts = texts.filter(text => !cache[text]);
+
+    if (uncachedTexts.length > 0) {
+        try {
+            // Get translations from both services
+            const [azureResults, googleResults] = await Promise.all([
+                azureTranslateBatch(uncachedTexts, targetLanguage),
+                googleTranslateTexts(uncachedTexts, targetLanguage)
+            ]);
+
+            for (let i = 0; i < uncachedTexts.length; i++) {
+                const text = uncachedTexts[i];
+                const azureTranslation = azureResults[i];
+                const googleTranslation = googleResults[i];
+
+                if (enableConfidenceCheck) {
+                    // Validate translations
+                    const [azureConfidence, googleConfidence] = await Promise.all([
+                        validateTranslation(text, azureTranslation, targetLanguage),
+                        validateTranslation(text, googleTranslation, targetLanguage)
+                    ]);
+
+                    translations[text] = azureConfidence > googleConfidence ? 
+                        azureTranslation : googleTranslation;
+                } else {
+                    // Use Azure by default
+                    translations[text] = azureTranslation;
+                }
+            }
+        } catch (error) {
+            console.error('Translation error:', error.message);
+            throw error;
+        }
+    }
+
+    // Combine cached and new translations
+    return texts.map(text => cache[text] || translations[text]);
+}
+
+// Get appropriate processor
+function getProcessor(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    switch (ext) {
+        case '.gridset':
+            return new GridsetProcessor();
+        case '.ce':
+            return new TouchChatProcessor();
+        case '.sps':
+            return new SnapProcessor();
+        default:
+            throw new Error(`No processor found for file extension: ${ext}`);
+    }
+}
+
+// Main file processing function
+async function processFile(filePath, startLang, endLang, translationCache, enableConfidenceCheck) {
+    console.log(`Processing ${filePath}...`);
+    
+    const processor = getProcessor(filePath);
+    const cache = await loadCache(translationCache);
+
+    try {
+        // Read file content
+        const fileContent = await fs.readFile(filePath);
+        
+        // Generate output path
+        const ext = path.extname(filePath);
+        const basename = path.basename(filePath, ext);
+        const outputPath = path.join(path.dirname(filePath), `${basename}-${endLang}${ext}`);
+        
+        // Extract texts
+        const texts = processor.extractTexts(fileContent);
+        
+        console.log(`Found ${texts.length} texts to translate`);
+        
+        // Translate texts
+        const translations = await translateTexts(texts, cache, endLang, enableConfidenceCheck);
+        
+        // Update cache with new translations
+        texts.forEach((text, i) => {
+            if (!cache[text]) {
+                cache[text] = translations[i];
+            }
+        });
+        
+        await saveCache(cache, translationCache);
+        
+        // Process translations
+        processor.processTexts(filePath, translations, outputPath);
+        console.log(`Translated file saved to: ${outputPath}`);
+    } catch (error) {
+        console.error('Error processing file:', error.message);
+        throw error;
+    }
+}
+
+// CLI setup
+program
+    .name('translate-aac')
+    .description('Translate AAC files between languages')
+    .argument('<file>', 'Input AAC file')
+    .option('-s, --startlang <lang>', 'Source language', 'en')
+    .option('-e, --endlang <lang>', 'Target language', 'fr')
+    .option('-c, --cache <file>', 'Translation cache file', 'translation_cache.json')
+    .option('--enable-confidence-check', 'Enable translation confidence checking', false)
+    .action(async (file, options) => {
+        try {
+            await processFile(
+                file,
+                options.startlang,
+                options.endlang,
+                options.cache,
+                options.enableConfidenceCheck
+            );
+        } catch (error) {
+            console.error('Error:', error.message);
+            process.exit(1);
+        }
+    });
+
+program.parse();