@willwade/aac-processors 0.0.12 → 0.0.14

package/dist/processors/gridset/pluginTypes.js

@@ -106,10 +106,10 @@ function detectPluginCellType(content) {
     if (!content) {
         return { cellType: Grid3CellType.Regular };
     }
-    const contentType = content.ContentType || content.contenttype || content.ContentType;
-    const contentSubType = content.ContentSubType || content.contentsubtype || content.ContentSubType;
+    const contentType = content.ContentType || content.contenttype;
+    const contentSubType = content.ContentSubType || content.contentsubtype;
     // Workspace cells - full editing workspaces
-    if (contentType === 'Workspace') {
+    if (contentType === 'Workspace' || content.Style?.BasedOnStyle === 'Workspace') {
         return {
             cellType: Grid3CellType.Workspace,
             subType: contentSubType || undefined,
@@ -118,7 +118,7 @@ function detectPluginCellType(content) {
         };
     }
     // LiveCell detection - dynamic content displays
-    if (contentType === 'LiveCell') {
+    if (contentType === 'LiveCell' || content.Style?.BasedOnStyle === 'LiveCell') {
         return {
             cellType: Grid3CellType.LiveCell,
             liveCellType: contentSubType || undefined,
@@ -127,7 +127,7 @@ function detectPluginCellType(content) {
         };
     }
     // AutoContent detection - dynamic word/content suggestions
-    if (contentType === 'AutoContent') {
+    if (contentType === 'AutoContent' || content.Style?.BasedOnStyle === 'AutoContent') {
         const autoContentType = extractAutoContentType(content);
         return {
             cellType: Grid3CellType.AutoContent,
@@ -172,38 +172,38 @@ function inferWorkspacePlugin(subType) {
         return undefined;
     const normalized = subType.toLowerCase();
     if (normalized.includes('chat'))
-        return 'chat';
+        return 'Grid3.Chat';
     if (normalized.includes('email') || normalized.includes('mail'))
-        return 'email';
-    if (normalized.includes('word') || normalized.includes('processor'))
-        return 'wordprocessor';
+        return 'Grid3.Email';
+    if (normalized.includes('word') || normalized.includes('doc'))
+        return 'Grid3.WordProcessor';
     if (normalized.includes('phone'))
-        return 'phone';
+        return 'Grid3.Phone';
     if (normalized.includes('sms') || normalized.includes('text'))
-        return 'sms';
-    if (normalized.includes('web') || normalized.includes('browser'))
-        return 'webbrowser';
-    if (normalized.includes('computer') || normalized.includes('control'))
-        return 'computercontrol';
-    if (normalized.includes('calculator') || normalized.includes('calc'))
-        return 'calculator';
-    if (normalized.includes('timer') || normalized.includes('stopwatch'))
-        return 'timer';
+        return 'Grid3.Sms';
+    if (normalized.includes('browser') || normalized.includes('web'))
+        return 'Grid3.WebBrowser';
+    if (normalized.includes('computer'))
+        return 'Grid3.ComputerControl';
+    if (normalized.includes('calc'))
+        return 'Grid3.Calculator';
+    if (normalized.includes('timer'))
+        return 'Grid3.Timer';
     if (normalized.includes('music') || normalized.includes('video'))
-        return 'musicvideo';
+        return 'Grid3.MusicVideo';
     if (normalized.includes('photo') || normalized.includes('image'))
-        return 'photos';
+        return 'Grid3.Photos';
     if (normalized.includes('contact'))
-        return 'contacts';
+        return 'Grid3.Contacts';
     if (normalized.includes('learning'))
-        return 'interactivelearning';
-    if (normalized.includes('message') && normalized.includes('bank'))
-        return 'messagebanking';
-    if (normalized.includes('env') || normalized.includes('ir'))
-        return 'environmentcontrol';
-    if (normalized.includes('setting'))
-        return 'settings';
-    return undefined;
+        return 'Grid3.InteractiveLearning';
+    if (normalized.includes('message') && normalized.includes('banking'))
+        return 'Grid3.MessageBanking';
+    if (normalized.includes('control'))
+        return 'Grid3.EnvironmentControl';
+    if (normalized.includes('settings'))
+        return 'Grid3.Settings';
+    return `Grid3.${subType}`;
 }
 /**
  * Infer plugin ID from live cell type
@@ -212,24 +212,25 @@ function inferLiveCellPlugin(liveCellType) {
     if (!liveCellType)
         return undefined;
     const normalized = liveCellType.toLowerCase();
-    if (normalized.includes('clock') || normalized.includes('time') || normalized.includes('date')) {
-        return 'clock';
-    }
+    if (normalized.includes('clock'))
+        return 'Grid3.Clock';
+    if (normalized.includes('date'))
+        return 'Grid3.Clock';
     if (normalized.includes('volume'))
-        return 'speech';
+        return 'Grid3.Volume';
     if (normalized.includes('speed'))
-        return 'speech';
+        return 'Grid3.Speed';
     if (normalized.includes('voice'))
-        return 'speech';
+        return 'Grid3.Speech';
     if (normalized.includes('message'))
-        return 'chat';
+        return 'Grid3.Chat';
     if (normalized.includes('battery'))
-        return 'settings';
-    if (normalized.includes('wifi') || normalized.includes('network'))
-        return 'settings';
+        return 'Grid3.Battery';
+    if (normalized.includes('wifi'))
+        return 'Grid3.Wifi';
     if (normalized.includes('bluetooth'))
-        return 'settings';
-    return undefined;
+        return 'Grid3.Bluetooth';
+    return `Grid3.${liveCellType}`;
 }
 /**
  * Infer plugin ID from auto content type
@@ -239,24 +240,24 @@ function inferAutoContentPlugin(autoContentType) {
         return undefined;
     const normalized = autoContentType.toLowerCase();
     if (normalized.includes('voice') || normalized.includes('speed'))
-        return 'speech';
+        return 'Grid3.Speech';
     if (normalized.includes('email') || normalized.includes('mail'))
-        return 'email';
+        return 'Grid3.Email';
     if (normalized.includes('phone'))
-        return 'phone';
+        return 'Grid3.Phone';
     if (normalized.includes('sms') || normalized.includes('text'))
-        return 'sms';
+        return 'Grid3.Sms';
     if (normalized.includes('web') ||
         normalized.includes('favorite') ||
         normalized.includes('history')) {
-        return 'webbrowser';
+        return 'Grid3.WebBrowser';
     }
     if (normalized.includes('prediction'))
-        return 'prediction';
+        return 'Grid3.Prediction';
     if (normalized.includes('grammar'))
-        return 'grammar';
+        return 'Grid3.Grammar';
     if (normalized.includes('context'))
-        return 'autocontent';
+        return 'Grid3.AutoContent';
     return undefined;
 }
 /**

package/dist/processors/gridset/symbolAlignment.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Symbol Alignment for Translation
+ *
+ * Utilities to preserve symbol positions during text translation.
+ * When translating AAC gridset messages that contain symbols attached
+ * to specific words, we need to maintain the symbol-to-word associations
+ * across languages.
+ *
+ * Example:
+ *   English: "I want apple juice" with apple symbol on "apple"
+ *   Spanish: "Yo quiero jugo de manzana" with apple symbol on "manzana"
+ */
+/**
+ * Represents a symbol anchored to a specific word in the text
+ */
+export interface SymbolAnchor {
+    symbolRef: string;
+    wordIndex: number;
+    originalWord: string;
+    startPos: number;
+    endPos: number;
+}
+/**
+ * Parsed message with symbol anchors
+ */
+export interface ParsedMessage {
+    text: string;
+    words: string[];
+    symbols: SymbolAnchor[];
+}
+/**
+ * Translation result with preserved symbols
+ */
+export interface TranslatedMessage {
+    text: string;
+    alignment: {
+        originalWord: string;
+        translatedWord: string;
+        originalIndex: number;
+        translatedIndex: number;
+    }[];
+}
+/**
+ * Parse a message to extract text and symbol anchors.
+ *
+ * This handles various formats:
+ * 1. Plain text with no symbols
+ * 2. Rich text with embedded symbol markers (future enhancement)
+ * 3. Text where symbols are tracked separately (via richText.symbols)
+ *
+ * For now, this assumes symbols are tracked separately in the richText structure.
+ * The text itself is plain, and we need to tokenize it to find word positions.
+ *
+ * @param message - The message text (may contain words or be plain)
+ * @param richTextSymbols - Optional symbols from richText.symbols array
+ * @returns Parsed message with word positions and symbol anchors
+ */
+export declare function parseMessageWithSymbols(message: string, richTextSymbols?: Array<{
+    text: string;
+    image?: string;
+}>): ParsedMessage;
+/**
+ * Align words from original text to translated text.
+ *
+ * This is a simple alignment strategy that works for many cases:
+ * 1. Exact word matching (for cognates, names, numbers)
+ * 2. Position-based alignment (assumes similar word order)
+ *
+ * For more accurate alignment, you could integrate with:
+ * - Translation APIs that return alignment (e.g., Google Translate's word alignment)
+ * - Statistical machine translation alignment tools
+ * - Bilingual dictionaries
+ *
+ * @param originalWords - Words from the original text
+ * @param translatedWords - Words from the translated text
+ * @returns Alignment mapping between original and translated word indices
+ */
+export declare function alignWords(originalWords: string[], translatedWords: string[]): TranslatedMessage['alignment'];
+/**
+ * Reattach symbols to translated text based on word alignment.
+ *
+ * @param translatedText - The translated plain text
+ * @param originalParsed - The original parsed message with symbols
+ * @param alignment - Word alignment between original and translation
+ * @returns Translated text with symbols embedded (as rich text structure)
+ */
+export declare function reattachSymbols(translatedText: string, originalParsed: ParsedMessage, alignment: TranslatedMessage['alignment']): {
+    text: string;
+    richTextSymbols: Array<{
+        text: string;
+        image?: string;
+    }>;
+};
+/**
+ * Complete pipeline: translate a message while preserving symbol positions.
+ *
+ * @param originalMessage - The original message text
+ * @param translatedText - The translated text (from translation API)
+ * @param richTextSymbols - Original symbols from richText.symbols
+ * @returns Object with translated text and aligned symbols
+ */
+export declare function translateWithSymbols(originalMessage: string, translatedText: string, richTextSymbols?: Array<{
+    text: string;
+    image?: string;
+}>): {
+    text: string;
+    richTextSymbols: Array<{
+        text: string;
+        image?: string;
+    }>;
+};
+/**
+ * Extract symbols from a button for use during translation.
+ *
+ * This helper extracts symbols from either:
+ * - button.semanticAction.richText.symbols
+ * - button.image (if it's a symbol library reference)
+ *
+ * @param button - The AAC button
+ * @returns Array of symbol attachments
+ */
+export declare function extractSymbolsFromButton(button: any): Array<{
+    text: string;
+    image?: string;
+}> | undefined;

package/dist/processors/gridset/symbolAlignment.js

@@ -0,0 +1,283 @@
+"use strict";
+/**
+ * Symbol Alignment for Translation
+ *
+ * Utilities to preserve symbol positions during text translation.
+ * When translating AAC gridset messages that contain symbols attached
+ * to specific words, we need to maintain the symbol-to-word associations
+ * across languages.
+ *
+ * Example:
+ *   English: "I want apple juice" with apple symbol on "apple"
+ *   Spanish: "Yo quiero jugo de manzana" with apple symbol on "manzana"
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMessageWithSymbols = parseMessageWithSymbols;
+exports.alignWords = alignWords;
+exports.reattachSymbols = reattachSymbols;
+exports.translateWithSymbols = translateWithSymbols;
+exports.extractSymbolsFromButton = extractSymbolsFromButton;
+/**
+ * Parse a message to extract text and symbol anchors.
+ *
+ * This handles various formats:
+ * 1. Plain text with no symbols
+ * 2. Rich text with embedded symbol markers (future enhancement)
+ * 3. Text where symbols are tracked separately (via richText.symbols)
+ *
+ * For now, this assumes symbols are tracked separately in the richText structure.
+ * The text itself is plain, and we need to tokenize it to find word positions.
+ *
+ * @param message - The message text (may contain words or be plain)
+ * @param richTextSymbols - Optional symbols from richText.symbols array
+ * @returns Parsed message with word positions and symbol anchors
+ */
+function parseMessageWithSymbols(message, richTextSymbols) {
+    // Normalize whitespace for consistent tokenization
+    const normalizedMessage = message.trim().replace(/\s+/g, ' ');
+    // Tokenize into words, preserving punctuation
+    const words = [];
+    const wordPositions = [];
+    // Split by whitespace but track positions
+    let currentPos = 0;
+    const parts = normalizedMessage.split(/(\s+)/); // Keep delimiters
+    for (const part of parts) {
+        if (part.trim().length > 0) {
+            // This is a word
+            const startPos = currentPos;
+            const endPos = currentPos + part.length;
+            words.push(part);
+            wordPositions.push({ start: startPos, end: endPos, word: part });
+            currentPos = endPos;
+        }
+        else {
+            // This is whitespace
+            currentPos += part.length;
+        }
+    }
+    // Extract symbol anchors from richText.symbols if provided
+    const symbols = [];
+    if (richTextSymbols && richTextSymbols.length > 0) {
+        for (const sym of richTextSymbols) {
+            // Find which word this symbol is attached to
+            const wordIndex = words.findIndex((w) => w === sym.text);
+            if (wordIndex !== -1) {
+                const pos = wordPositions[wordIndex];
+                symbols.push({
+                    symbolRef: sym.image || '',
+                    wordIndex,
+                    originalWord: sym.text,
+                    startPos: pos.start,
+                    endPos: pos.end,
+                });
+            }
+            else {
+                // Fuzzy match - find closest word (handles case differences, punctuation)
+                const normalizedSymText = sym.text.toLowerCase().replace(/[^\w]/g, '');
+                const fuzzyIndex = words.findIndex((w) => w.toLowerCase().replace(/[^\w]/g, '') === normalizedSymText);
+                if (fuzzyIndex !== -1) {
+                    const pos = wordPositions[fuzzyIndex];
+                    symbols.push({
+                        symbolRef: sym.image || '',
+                        wordIndex: fuzzyIndex,
+                        originalWord: words[fuzzyIndex],
+                        startPos: pos.start,
+                        endPos: pos.end,
+                    });
+                }
+            }
+        }
+    }
+    return {
+        text: normalizedMessage,
+        words,
+        symbols,
+    };
+}
+/**
+ * Align words from original text to translated text.
+ *
+ * This is a simple alignment strategy that works for many cases:
+ * 1. Exact word matching (for cognates, names, numbers)
+ * 2. Position-based alignment (assumes similar word order)
+ *
+ * For more accurate alignment, you could integrate with:
+ * - Translation APIs that return alignment (e.g., Google Translate's word alignment)
+ * - Statistical machine translation alignment tools
+ * - Bilingual dictionaries
+ *
+ * @param originalWords - Words from the original text
+ * @param translatedWords - Words from the translated text
+ * @returns Alignment mapping between original and translated word indices
+ */
+function alignWords(originalWords, translatedWords) {
+    const alignment = [];
+    // Strategy 1: Try to match identical words (numbers, names, cognates)
+    const matchedTranslatedIndices = new Set();
+    for (let origIdx = 0; origIdx < originalWords.length; origIdx++) {
+        const origWord = originalWords[origIdx];
+        const normalizedOrig = origWord.toLowerCase().replace(/[^\w]/g, '');
+        // Try to find this word in the translation
+        for (let transIdx = 0; transIdx < translatedWords.length; transIdx++) {
+            if (matchedTranslatedIndices.has(transIdx))
+                continue;
+            const transWord = translatedWords[transIdx];
+            const normalizedTrans = transWord.toLowerCase().replace(/[^\w]/g, '');
+            // Exact match (case-insensitive, ignoring punctuation)
+            if (normalizedOrig === normalizedTrans && normalizedOrig.length > 0) {
+                alignment.push({
+                    originalWord: origWord,
+                    translatedWord: transWord,
+                    originalIndex: origIdx,
+                    translatedIndex: transIdx,
+                });
+                matchedTranslatedIndices.add(transIdx);
+                break;
+            }
+        }
+    }
+    // Strategy 2: For unmatched words, use positional alignment
+    // This is a simple fallback that assumes similar word order
+    for (let origIdx = 0; origIdx < originalWords.length; origIdx++) {
+        if (alignment.find((a) => a.originalIndex === origIdx))
+            continue; // Already matched
+        // Find the closest unmatched position in translation
+        let bestTransIdx = -1;
+        let minDistance = Infinity;
+        for (let transIdx = 0; transIdx < translatedWords.length; transIdx++) {
+            if (matchedTranslatedIndices.has(transIdx))
+                continue;
+            // Calculate relative position
+            const relativeOrigPos = origIdx / originalWords.length;
+            const relativeTransPos = transIdx / translatedWords.length;
+            const distance = Math.abs(relativeOrigPos - relativeTransPos);
+            if (distance < minDistance) {
+                minDistance = distance;
+                bestTransIdx = transIdx;
+            }
+        }
+        if (bestTransIdx !== -1) {
+            alignment.push({
+                originalWord: originalWords[origIdx],
+                translatedWord: translatedWords[bestTransIdx],
+                originalIndex: origIdx,
+                translatedIndex: bestTransIdx,
+            });
+            matchedTranslatedIndices.add(bestTransIdx);
+        }
+    }
+    return alignment;
+}
+/**
+ * Reattach symbols to translated text based on word alignment.
+ *
+ * @param translatedText - The translated plain text
+ * @param originalParsed - The original parsed message with symbols
+ * @param alignment - Word alignment between original and translation
+ * @returns Translated text with symbols embedded (as rich text structure)
+ */
+function reattachSymbols(translatedText, originalParsed, alignment) {
+    // Tokenize the translated text
+    const translatedWords = translatedText
+        .trim()
+        .replace(/\s+/g, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length > 0);
+    // Create the rich text symbols array
+    const richTextSymbols = [];
+    for (const symbol of originalParsed.symbols) {
+        // Find the alignment for this word
+        const wordAlignment = alignment.find((a) => a.originalIndex === symbol.wordIndex);
+        if (wordAlignment && wordAlignment.translatedIndex < translatedWords.length) {
+            const translatedWord = translatedWords[wordAlignment.translatedIndex];
+            // Attach the symbol to the translated word
+            richTextSymbols.push({
+                text: translatedWord,
+                image: symbol.symbolRef,
+            });
+        }
+        else {
+            // Fallback: keep symbol on original word if no alignment found
+            richTextSymbols.push({
+                text: symbol.originalWord,
+                image: symbol.symbolRef,
+            });
+        }
+    }
+    return {
+        text: translatedText,
+        richTextSymbols,
+    };
+}
+/**
+ * Complete pipeline: translate a message while preserving symbol positions.
+ *
+ * @param originalMessage - The original message text
+ * @param translatedText - The translated text (from translation API)
+ * @param richTextSymbols - Original symbols from richText.symbols
+ * @returns Object with translated text and aligned symbols
+ */
+function translateWithSymbols(originalMessage, translatedText, richTextSymbols) {
+    // Step 1: Parse original message
+    const parsedOriginal = parseMessageWithSymbols(originalMessage, richTextSymbols);
+    // If no symbols, return as-is
+    if (parsedOriginal.symbols.length === 0) {
+        return {
+            text: translatedText,
+            richTextSymbols: [],
+        };
+    }
+    // Step 2: Tokenize translated text
+    const translatedWords = translatedText
+        .trim()
+        .replace(/\s+/g, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length > 0);
+    // Step 3: Align words
+    const alignment = alignWords(parsedOriginal.words, translatedWords);
+    // Step 4: Reattach symbols
+    const result = reattachSymbols(translatedText, parsedOriginal, alignment);
+    return result;
+}
+/**
+ * Extract symbols from a button for use during translation.
+ *
+ * This helper extracts symbols from either:
+ * - button.semanticAction.richText.symbols
+ * - button.image (if it's a symbol library reference)
+ *
+ * @param button - The AAC button
+ * @returns Array of symbol attachments
+ */
+function extractSymbolsFromButton(button) {
+    // First check richText structure
+    if (button.semanticAction?.richText?.symbols) {
+        return button.semanticAction.richText.symbols;
+    }
+    // Check if button has a symbol library reference as image
+    if (button.symbolLibrary && button.symbolPath) {
+        // Create a symbol attachment for the label/message
+        const text = button.label || button.message || '';
+        if (text) {
+            return [
+                {
+                    text,
+                    image: `[${button.symbolLibrary}]${button.symbolPath}`,
+                },
+            ];
+        }
+    }
+    // Check if image field contains a symbol reference
+    if (button.image && button.image.startsWith('[')) {
+        const text = button.label || button.message || '';
+        if (text) {
+            return [
+                {
+                    text,
+                    image: button.image,
+                },
+            ];
+        }
+    }
+    return undefined;
+}

package/dist/processors/gridset/symbolExtractor.js

@@ -154,10 +154,11 @@ function extractSymbolLibraryImage(reference, options = {}) {
         };
     }
     // Successfully extracted!
-    const format = detectImageFormat(resolved.data);
+    const data = resolved.data;
+    const format = data ? detectImageFormat(data) : 'unknown';
     return {
         found: true,
-        data: resolved.data,
+        data,
         format,
         source: 'symbol-library',
         reference: reference,

package/dist/processors/gridset/symbolSearch.js

@@ -126,13 +126,15 @@ function searchSymbols(searchTerm, options = {}) {
         // Exact match first
         if (index.searchTerms.has(lowerSearchTerm)) {
             const symbolFilename = index.searchTerms.get(lowerSearchTerm);
-            results.push({
-                searchTerm: lowerSearchTerm,
-                symbolFilename,
-                displayName: index.filenames.get(symbolFilename) || lowerSearchTerm,
-                library: libraryName,
-                exactMatch: true,
-            });
+            if (symbolFilename) {
+                results.push({
+                    searchTerm: lowerSearchTerm,
+                    symbolFilename,
+                    displayName: index.filenames.get(symbolFilename) || lowerSearchTerm,
+                    library: libraryName,
+                    exactMatch: true,
+                });
+            }
         }
         // Fuzzy match if enabled
         if (options.fuzzyMatch !== false) {

package/dist/processors/gridsetProcessor.d.ts

@@ -1,5 +1,6 @@
 import { BaseProcessor, ProcessorOptions, ExtractStringsResult, TranslatedString, SourceString } from '../core/baseProcessor';
 import { AACTree } from '../core/treeStructure';
+import { type ButtonForTranslation, type LLMLTranslationResult } from '../utilities/translation/translationProcessor';
 import { ValidationResult } from '../validation/validationTypes';
 declare class GridsetProcessor extends BaseProcessor {
     constructor(options?: ProcessorOptions);
@@ -18,6 +19,31 @@ declare class GridsetProcessor extends BaseProcessor {
     extractTexts(filePathOrBuffer: string | Buffer): string[];
     loadIntoTree(filePathOrBuffer: string | Buffer): AACTree;
     processTexts(filePathOrBuffer: string | Buffer, translations: Map<string, string>, outputPath: string): Buffer;
+    /**
+     * Extract symbol information from a gridset for LLM-based translation.
+     * Returns a structured format showing which buttons have symbols and their context.
+     *
+     * This method uses shared translation utilities that work across all AAC formats.
+     *
+     * @param filePathOrBuffer - Path to gridset file or buffer
+     * @returns Array of symbol information for LLM processing
+     */
+    extractSymbolsForLLM(filePathOrBuffer: string | Buffer): ButtonForTranslation[];
+    /**
+     * Apply LLM translations with symbol information.
+     * The LLM should provide translations with symbol attachments in the correct positions.
+     *
+     * This method uses shared translation utilities that work across all AAC formats.
+     *
+     * @param filePathOrBuffer - Path to gridset file or buffer
+     * @param llmTranslations - Array of LLM translations with symbol info
+     * @param outputPath - Where to save the translated gridset
+     * @param options - Translation options (e.g., allowPartial for testing)
+     * @returns Buffer of the translated gridset
+     */
+    processLLMTranslations(filePathOrBuffer: string | Buffer, llmTranslations: LLMLTranslationResult[], outputPath: string, options?: {
+        allowPartial?: boolean;
+    }): Buffer;
     saveFromTree(tree: AACTree, outputPath: string): void;
     private calculateColumnDefinitions;
     private calculateRowDefinitions;