@willwade/aac-processors 0.0.29 → 0.1.0

package/dist/browser/processors/gridset/symbolAlignment.js

@@ -0,0 +1,276 @@
+/**
+ * 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"
+ */
+/**
+ * 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 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
+ */
+export 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)
+ */
+export 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
+ */
+export 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
+ */
+export 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/browser/processors/gridset/symbols.js

@@ -0,0 +1,421 @@
+/**
+ * Grid 3 Symbol Library Resolution
+ *
+ * Grid 3 uses symbol libraries stored as .pix files in the installation directory.
+ * Symbol references in Grid files use the format: [library]/path/to/symbol.png
+ *
+ * Examples:
+ * - [widgit]/food/apple.png
+ * - [tawasl]/above bw.png
+ * - [ssnaps]963.jpg
+ * - [grid3x]/folder/document.png
+ *
+ * This module provides symbol resolution and metadata extraction.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import AdmZip from 'adm-zip';
+/**
+ * Default Grid 3 installation paths by platform
+ */
+const DEFAULT_GRID3_PATHS = {
+    win32: 'C:\\Program Files (x86)\\Smartbox\\Grid 3',
+    darwin: '/Applications/Grid 3.app/Contents/Resources',
+    linux: '/opt/smartbox/grid3',
+};
+/**
+ * Path to Symbols directory within Grid 3 installation
+ * Contains .symbols ZIP archives with actual images
+ */
+const SYMBOLS_SUBDIR = 'Resources\\Symbols';
+/**
+ * Path to symbol search indexes within Grid 3 installation
+ * Contains .pix index files for searching
+ */
+const SYMBOLSEARCH_SUBDIR = 'Locale';
+/**
+ * Known symbol libraries in Grid 3
+ */
+export const SYMBOL_LIBRARIES = {
+    WIDGIT: 'widgit',
+    TAWASL: 'tawasl',
+    SSNAPS: 'ssnaps',
+    GRID3X: 'grid3x',
+    GRID2X: 'grid2x',
+    BLISSX: 'blissx',
+    EYEGAZ: 'eyegaz',
+    INTERL: 'interl',
+    METACM: 'metacm',
+    MJPCS: 'mjpcs#',
+    PCSHC: 'pcshc#',
+    PCSTL: 'pcstl#',
+    SESENS: 'sesens',
+    SSTIX: 'sstix#',
+    SYMOJI: 'symoji',
+};
+/**
+ * Default locale to use
+ */
+export const DEFAULT_LOCALE = 'en-GB';
+/**
+ * Parse a symbol reference string
+ * @param reference - Symbol reference like "[widgit]/food/apple.png"
+ * @returns Parsed symbol reference
+ */
+export function parseSymbolReference(reference) {
+    const trimmed = reference.trim();
+    // Match pattern: [library]/path or [library]path
+    const match = trimmed.match(/^\[([^\]]+)\](.+)$/);
+    if (!match) {
+        return {
+            library: '',
+            path: trimmed,
+            fullReference: trimmed,
+            isValid: false,
+        };
+    }
+    const [, library, symbolPath] = match;
+    return {
+        library: library.toLowerCase(),
+        path: symbolPath.replace(/^\\+/, '').trim(), // Remove leading slashes
+        fullReference: trimmed,
+        isValid: true,
+    };
+}
+/**
+ * Check if a string is a symbol library reference
+ * @param reference - String to check
+ * @returns True if it's a symbol reference like [widgit]/...
+ */
+export function isSymbolReference(reference) {
+    return reference.trim().startsWith('[');
+}
+/**
+ * Get the default Grid 3 installation path for the current platform
+ * @returns Default Grid 3 path or empty string if not found
+ */
+export function getDefaultGrid3Path() {
+    const platform = process.platform;
+    const defaultPath = DEFAULT_GRID3_PATHS[platform] || '';
+    if (defaultPath && fs.existsSync(defaultPath)) {
+        return defaultPath;
+    }
+    // Try to find Grid 3 in common locations
+    const commonPaths = [
+        'C:\\Program Files (x86)\\Smartbox\\Grid 3',
+        'C:\\Program Files\\Smartbox\\Grid 3',
+        'C:\\Program Files\\Smartbox\\Grid 3',
+        '/Applications/Grid 3.app',
+        '/opt/smartbox/grid3',
+    ];
+    for (const testPath of commonPaths) {
+        if (fs.existsSync(testPath)) {
+            return testPath;
+        }
+    }
+    return '';
+}
+/**
+ * Get the Symbol Libraries directory path
+ * Contains .symbols ZIP archives with actual image files
+ * @param grid3Path - Grid 3 installation path
+ * @returns Path to Symbol Libraries directory (e.g., "C:\...\Grid 3\Resources\Symbols")
+ */
+export function getSymbolLibrariesDir(grid3Path) {
+    return path.join(grid3Path, SYMBOLS_SUBDIR);
+}
+/**
+ * Get the symbol search indexes directory path for a given locale
+ * Contains .pix index files for searching symbols
+ * @param grid3Path - Grid 3 installation path
+ * @param locale - Locale code (e.g., 'en-GB')
+ * @returns Path to symbol search indexes directory (e.g., "C:\...\Grid 3\Locale\en-GB\symbolsearch")
+ */
+export function getSymbolSearchIndexesDir(grid3Path, locale = DEFAULT_LOCALE) {
+    return path.join(grid3Path, SYMBOLSEARCH_SUBDIR, locale, 'symbolsearch');
+}
+/**
+ * Get all available symbol libraries in the Grid 3 installation
+ * @param options - Resolution options
+ * @returns Array of symbol library information
+ */
+export function getAvailableSymbolLibraries(options = {}) {
+    const grid3Path = options.grid3Path || options.symbolDir || getDefaultGrid3Path();
+    if (!grid3Path) {
+        return [];
+    }
+    const symbolsDir = getSymbolLibrariesDir(grid3Path);
+    if (!fs.existsSync(symbolsDir)) {
+        return [];
+    }
+    const libraries = [];
+    const files = fs.readdirSync(symbolsDir);
+    for (const file of files) {
+        if (file.endsWith('.symbols')) {
+            const fullPath = path.join(symbolsDir, file);
+            const stats = fs.statSync(fullPath);
+            const libraryName = path.basename(file, '.symbols');
+            libraries.push({
+                name: libraryName,
+                pixFile: fullPath, // Reuse this field for the .symbols file path
+                exists: true,
+                size: stats.size,
+                locale: 'global', // .symbols files are not locale-specific
+            });
+        }
+    }
+    return libraries.sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Check if a symbol library exists
+ * @param libraryName - Name of the library (e.g., 'widgit', 'tawasl')
+ * @param options - Resolution options
+ * @returns Symbol library info or undefined if not found
+ */
+export function getSymbolLibraryInfo(libraryName, options = {}) {
+    const grid3Path = options.grid3Path || options.symbolDir || getDefaultGrid3Path();
+    if (!grid3Path) {
+        return undefined;
+    }
+    const symbolsDir = getSymbolLibrariesDir(grid3Path);
+    const normalizedLibName = libraryName.toLowerCase();
+    // Try different case variations
+    const variations = [
+        normalizedLibName + '.symbols',
+        normalizedLibName.toUpperCase() + '.symbols',
+        libraryName + '.symbols',
+    ];
+    for (const file of variations) {
+        const fullPath = path.join(symbolsDir, file);
+        if (fs.existsSync(fullPath)) {
+            const stats = fs.statSync(fullPath);
+            return {
+                name: libraryName,
+                pixFile: fullPath,
+                exists: true,
+                size: stats.size,
+                locale: 'global',
+            };
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve a symbol reference to extract the actual image data
+ * @param reference - Symbol reference like "[tawasl]/above bw.png"
+ * @param options - Resolution options
+ * @returns Resolution result with image data if found
+ */
+export function resolveSymbolReference(reference, options = {}) {
+    const parsed = parseSymbolReference(reference);
+    if (!parsed.isValid) {
+        return {
+            reference: parsed,
+            found: false,
+            error: 'Invalid symbol reference format',
+        };
+    }
+    const grid3Path = options.grid3Path || getDefaultGrid3Path();
+    if (!grid3Path) {
+        return {
+            reference: parsed,
+            found: false,
+            error: 'Grid 3 installation not found. Please specify grid3Path.',
+        };
+    }
+    const libraryInfo = getSymbolLibraryInfo(parsed.library, { grid3Path });
+    if (!libraryInfo || !libraryInfo.exists) {
+        return {
+            reference: parsed,
+            found: false,
+            error: `Symbol library '${parsed.library}' not found at ${libraryInfo?.pixFile || 'unknown'}`,
+        };
+    }
+    try {
+        // .symbols files are ZIP archives
+        const zip = new AdmZip(libraryInfo.pixFile);
+        // The path in the symbol reference becomes the path within the symbols/ folder
+        // e.g., [tawasl]/above bw.png becomes symbols/above bw.png
+        const symbolPath = `symbols/${parsed.path}`;
+        const entry = zip.getEntry(symbolPath);
+        if (!entry) {
+            // Try without the symbols/ prefix (in case reference already includes it)
+            const altPath = parsed.path.startsWith('symbols/') ? parsed.path : `symbols/${parsed.path}`;
+            const altEntry = zip.getEntry(altPath);
+            if (!altEntry) {
+                return {
+                    reference: parsed,
+                    found: false,
+                    error: `Symbol '${parsed.path}' not found in library '${parsed.library}'`,
+                    path: libraryInfo.pixFile,
+                    libraryInfo,
+                };
+            }
+            // Found with alternate path
+            const data = altEntry.getData();
+            return {
+                reference: parsed,
+                found: true,
+                path: libraryInfo.pixFile,
+                data,
+                libraryInfo,
+            };
+        }
+        // Found the symbol!
+        const data = entry.getData();
+        return {
+            reference: parsed,
+            found: true,
+            path: libraryInfo.pixFile,
+            data,
+            libraryInfo,
+        };
+    }
+    catch (error) {
+        return {
+            reference: parsed,
+            found: false,
+            error: `Failed to extract symbol: ${error.message}`,
+            path: libraryInfo.pixFile,
+            libraryInfo,
+        };
+    }
+}
+/**
+ * Get all symbol references from a gridset
+ * This scans button images for symbol references
+ * @param tree - AAC tree from loaded gridset
+ * @returns Array of unique symbol references
+ */
+export function extractSymbolReferences(tree) {
+    const references = new Set();
+    for (const pageId in tree.pages) {
+        const page = tree.pages[pageId];
+        if (page.buttons) {
+            for (const button of page.buttons) {
+                if (button.image && isSymbolReference(String(button.image))) {
+                    references.add(String(button.image));
+                }
+                // Check for symbol library metadata
+                if (button.symbolLibrary) {
+                    const ref = `[${button.symbolLibrary}]${button.symbolPath || ''}`;
+                    references.add(ref);
+                }
+            }
+        }
+    }
+    return Array.from(references).sort();
+}
+/**
+ * Create a symbol reference from library and path
+ * @param library - Library name
+ * @param symbolPath - Path within the library
+ * @returns Formatted symbol reference
+ */
+export function createSymbolReference(library, symbolPath) {
+    const normalizedLib = library.toLowerCase().replace(/\[|\]/g, '');
+    const normalizedPath = symbolPath.replace(/^\\+/, '');
+    return `[${normalizedLib}]${normalizedPath}`;
+}
+/**
+ * Get the library name from a symbol reference
+ * @param reference - Symbol reference
+ * @returns Library name or empty string
+ */
+export function getSymbolLibraryName(reference) {
+    const parsed = parseSymbolReference(reference);
+    return parsed.library;
+}
+/**
+ * Get the symbol path from a symbol reference
+ * @param reference - Symbol reference
+ * @returns Symbol path or empty string
+ */
+export function getSymbolPath(reference) {
+    const parsed = parseSymbolReference(reference);
+    return parsed.path;
+}
+/**
+ * Check if a symbol library is one of the known Grid 3 libraries
+ * @param libraryName - Library name to check
+ * @returns True if it's a known library
+ */
+export function isKnownSymbolLibrary(libraryName) {
+    const normalized = libraryName.toLowerCase().replace(/\[|\]/g, '');
+    return Object.values(SYMBOL_LIBRARIES).includes(normalized);
+}
+/**
+ * Get display name for a symbol library
+ * @param libraryName - Library name
+ * @returns Human-readable display name
+ */
+export function getSymbolLibraryDisplayName(libraryName) {
+    const normalized = libraryName.toLowerCase().replace(/\[|\]/g, '');
+    const displayNames = {
+        widgit: 'Widgit Symbols',
+        tawasl: 'Tawasol (Arabic)',
+        ssnaps: 'Smartbox Symbol Snapshots',
+        grid3x: 'Grid 3 Extended',
+        grid2x: 'Grid 2 Extended',
+        blissx: 'Blissymbols',
+        eyegaz: 'Eye Gaze Symbols',
+        interl: 'International Symbols',
+        metacm: 'MetaComm',
+        mjpcs: 'Mayer-Johnson PCS',
+        pcshc: 'PCS High Contrast',
+        pcstl: 'PCS Thin Line',
+        sesens: 'Sensory Software',
+        sstix: 'Smartbox TIX',
+        symoji: 'Symbol Emoji',
+    };
+    return displayNames[normalized] || normalized.charAt(0).toUpperCase() + normalized.slice(1);
+}
+export function analyzeSymbolUsage(tree) {
+    const references = extractSymbolReferences(tree);
+    const byLibrary = {};
+    const libraries = new Set();
+    for (const ref of references) {
+        const lib = getSymbolLibraryName(ref);
+        byLibrary[lib] = (byLibrary[lib] || 0) + 1;
+        if (lib) {
+            libraries.add(lib);
+        }
+    }
+    return {
+        totalSymbols: references.length,
+        byLibrary,
+        uniqueReferences: references,
+        librariesUsed: Array.from(libraries).sort(),
+    };
+}
+/**
+ * Convert symbol reference to filename for embedded images
+ * Grid 3 sometimes embeds symbols with special naming
+ * @param reference - Symbol reference
+ * @param cellX - Cell X coordinate
+ * @param cellY - Cell Y coordinate
+ * @returns Generated filename
+ */
+export function symbolReferenceToFilename(reference, cellX, cellY) {
+    const parsed = parseSymbolReference(reference);
+    const ext = path.extname(parsed.path) || '.png';
+    // Grid 3 format: {x}-{y}-0-text-0.{ext}
+    return `${cellX}-${cellY}-0-text-0${ext}`;
+}
+// ============================================================================
+// BACKWARD COMPATIBILITY ALIASES
+// ============================================================================
+/**
+ * @deprecated Use getSymbolLibrariesDir() instead - more descriptive name
+ * Get the Symbols directory path (where .symbols ZIP archives are)
+ */
+export function getSymbolsDir(grid3Path) {
+    return getSymbolLibrariesDir(grid3Path);
+}
+/**
+ * @deprecated Use getSymbolSearchIndexesDir() instead - more descriptive name
+ * Get the symbol search directory for a given locale (where .pix index files are)
+ */
+export function getSymbolSearchDir(grid3Path, locale = DEFAULT_LOCALE) {
+    return getSymbolSearchIndexesDir(grid3Path, locale);
+}