@willwade/aac-processors 0.2.3 → 0.2.5

package/dist/browser/processors/obfProcessor.js

@@ -48,7 +48,7 @@ class ObfProcessor extends BaseProcessor {
                     return null;
                 }
             }
-            catch (err) {
+            catch (_err) {
                 continue;
             }
         }
@@ -94,7 +94,7 @@ class ObfProcessor extends BaseProcessor {
                         return dataUrl;
                     }
                 }
-                catch (err) {
+                catch (_err) {
                     // Continue to next path
                     continue;
                 }
@@ -318,7 +318,7 @@ class ObfProcessor extends BaseProcessor {
                     return obj;
                 }
             }
-            catch (error) {
+            catch (_error) {
                 // Log parsing errors for debugging but don't throw
             }
             return null;
@@ -725,7 +725,7 @@ class ObfProcessor extends BaseProcessor {
             // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-return
             return require('../validation/obfValidator').ObfValidator;
         }
-        catch (error) {
+        catch (_error) {
             throw new Error('Validation utilities are not available in this environment.');
         }
     }

package/dist/browser/processors/snap/helpers.js

@@ -24,7 +24,7 @@ async function collectFiles(root, matcher, maxDepth = 3, fileAdapter = defaultFi
         try {
             entries = await listDir(current.dir);
         }
-        catch (error) {
+        catch (_error) {
             continue;
         }
         for (const entry of entries) {
@@ -130,7 +130,7 @@ export async function openImage(dbOrFile, entryPath, fileAdapter = defaultFileAd
                 const dir = dirname(dbPath);
                 await removePath(dir);
             }
-            catch (e) {
+            catch (_e) {
                 // Ignore cleanup errors
             }
         }
@@ -174,7 +174,7 @@ export async function findSnapPackages(packageNamePattern = 'TobiiDynavox', file
             }
         }
     }
-    catch (error) {
+    catch (_error) {
         // Silently fail if directory access fails
     }
     return results;

package/dist/browser/processors/snapProcessor.js

@@ -215,7 +215,7 @@ class SnapProcessor extends BaseProcessor {
                             try {
                                 positions = JSON.parse(sg.SerializedGridPositions);
                             }
-                            catch (e) {
+                            catch (_e) {
                                 // Invalid JSON, skip this group
                                 return;
                             }
@@ -436,7 +436,7 @@ class SnapProcessor extends BaseProcessor {
                                 }
                             }
                         }
-                        catch (e) {
+                        catch (_e) {
                             // Ignore JSON parse errors in commands
                         }
                     }

package/dist/browser/processors/touchchatProcessor.js

@@ -101,7 +101,7 @@ class TouchChatProcessor extends BaseProcessor {
                     idMappings.set(mapping.numeric_id, mapping.string_id);
                 });
             }
-            catch (e) {
+            catch (_e) {
                 // No mapping table, use numeric IDs as strings
             }
             // Load styles
@@ -119,7 +119,7 @@ class TouchChatProcessor extends BaseProcessor {
                     pageStyles.set(style.id, style);
                 });
             }
-            catch (e) {
+            catch (_e) {
                 // console.log('No styles found:', e);
             }
             // First, load all pages and get their names from resources
@@ -307,7 +307,7 @@ class TouchChatProcessor extends BaseProcessor {
                     }
                 });
             }
-            catch (e) {
+            catch (_e) {
                 // console.log('No button box cells found:', e);
             }
             // Load buttons directly linked to pages via resources
@@ -366,7 +366,7 @@ class TouchChatProcessor extends BaseProcessor {
                         page.addButton(button);
                 });
             }
-            catch (e) {
+            catch (_e) {
                 // console.log('No direct page buttons found:', e);
             }
             // Load navigation actions
@@ -413,7 +413,7 @@ class TouchChatProcessor extends BaseProcessor {
                     }
                 });
             }
-            catch (e) {
+            catch (_e) {
                 // console.log('No navigation actions found:', e);
             }
             // Try to load root ID from multiple sources in order of priority
@@ -454,7 +454,7 @@ class TouchChatProcessor extends BaseProcessor {
                     tree.metadata.defaultHomePageId = rootPageId;
                 }
             }
-            catch (e) {
+            catch (_e) {
                 // No metadata table or other error, use first page as root
                 if (rootPageId) {
                     tree.rootId = rootPageId;

package/dist/browser/utilities/analytics/metrics/core.js

@@ -9,6 +9,7 @@
 import { AACSemanticCategory, AACScanType, } from '../../../core/treeStructure';
 import { CellScanningOrder, ScanningSelectionMethod } from '../../../types/aac';
 import { baseBoardEffort, distanceEffort, visualScanEffort, EFFORT_CONSTANTS, localScanEffort, scanningEffort, } from './effort';
+import { MorphologyEngine } from '../morphology';
 export class MetricsCalculator {
     constructor() {
         this.locale = 'en';
@@ -80,9 +81,11 @@ export class MetricsCalculator {
         });
         // Update buttons using dynamic spelling effort if applicable
         const buttons = Array.from(knownButtons.values()).sort((a, b) => a.effort - b.effort);
-        // Calculate metrics for word forms (smart grammar predictions) if enabled
-        // Default to true if not specified
-        const useSmartGrammar = options.useSmartGrammar !== false;
+        // Expand morphological predictions from POS tags if enabled or auto-detected
+        const useSmartGrammar = options.useSmartGrammar === true || this.treeHasPosTags(tree);
+        if (useSmartGrammar) {
+            this.expandMorphologicalPredictions(tree, options);
+        }
         if (useSmartGrammar) {
             const { wordFormMetrics, replacedLabels } = this.calculateWordFormMetrics(tree, buttons, options);
             // Remove buttons that were replaced by lower-effort word forms
@@ -151,13 +154,21 @@ export class MetricsCalculator {
                 }) || null;
         }
         if (!spellingPage)
-            return { spellingPage: null, spellingBaseEffort: 10, spellingAvgLetterEffort: 2.5 };
+            return {
+                spellingPage: null,
+                spellingBaseEffort: 10,
+                spellingAvgLetterEffort: 2.5,
+            };
         // Calculate effort to reach this page from root
         const rootBoard = tree.rootId
             ? tree.pages[tree.rootId]
             : Object.values(tree.pages).find((p) => !p.parentId);
         if (!rootBoard)
-            return { spellingPage, spellingBaseEffort: 10, spellingAvgLetterEffort: 2.5 };
+            return {
+                spellingPage,
+                spellingBaseEffort: 10,
+                spellingAvgLetterEffort: 2.5,
+            };
         // Analyze specifically to find the lowest effort path to the spelling page
         const result = this.analyzeFrom(tree, rootBoard, setPcts, true, options);
         const spellingBaseEffort = result.visitedBoardEfforts.get(spellingPage.id) ?? 10;
@@ -571,6 +582,157 @@ export class MetricsCalculator {
         boardPcts['all'] = totalLinks;
         return boardPcts;
     }
+    /**
+     * Quick check whether any button in the tree has a POS tag.
+     * Used to auto-enable smart grammar without requiring explicit opt-in.
+     */
+    treeHasPosTags(tree) {
+        for (const page of Object.values(tree.pages)) {
+            for (const row of page.grid) {
+                for (const btn of row) {
+                    if (btn?.pos && btn.pos !== 'Unknown' && btn.pos !== 'Ignore') {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Expand morphological predictions from POS tags on buttons
+     *
+     * For each button that has a POS tag (e.g., 'Verb', 'Noun'), use the
+     * MorphologyEngine to generate inflected word forms and populate the
+     * button's predictions array. This is done as a pre-processing step
+     * before calculateWordFormMetrics assigns effort to each form.
+     */
+    expandMorphologicalPredictions(tree, options) {
+        const locale = options.morphologyLocale || 'en-gb';
+        const morph = new MorphologyEngine(locale);
+        // Words that should never be POS-inferred (function words, determiners, etc.)
+        const skipInference = new Set([
+            'a',
+            'an',
+            'the',
+            'to',
+            'in',
+            'on',
+            'at',
+            'of',
+            'for',
+            'and',
+            'or',
+            'but',
+            'not',
+            'no',
+            'yes',
+            'is',
+            'am',
+            'are',
+            'was',
+            'were',
+            'be',
+            'been',
+            'being',
+            'has',
+            'have',
+            'had',
+            'do',
+            'does',
+            'did',
+            'will',
+            'would',
+            'could',
+            'should',
+            'shall',
+            'may',
+            'might',
+            'can',
+            'must',
+            'with',
+            'from',
+            'by',
+            'up',
+            'down',
+            'out',
+            'off',
+            'over',
+            'under',
+            'again',
+            'then',
+            'than',
+            'so',
+            'if',
+            'when',
+            'where',
+            'how',
+            'what',
+            'who',
+            'which',
+            'that',
+            'this',
+            'these',
+            'those',
+            'here',
+            'there',
+            'now',
+            'very',
+            'just',
+            'more',
+            'also',
+            'too',
+            'please',
+            'thank',
+            'hi',
+            'hello',
+            'bye',
+            'goodbye',
+            'okay',
+            'oh',
+            'wow',
+            'sorry',
+        ]);
+        for (const page of Object.values(tree.pages)) {
+            for (const row of page.grid) {
+                for (const btn of row) {
+                    if (!btn || !btn.label)
+                        continue;
+                    let pos = btn.pos;
+                    // If no POS tag (or Unknown/Ignore), attempt POS inference.
+                    // Many content words on topic pages lack POS tags even though
+                    // they are clearly nouns (e.g., "bird", "tree", "cloud").
+                    // Strategy: check irregular tables first for confident POS,
+                    // then fall back to Noun for single-word content labels.
+                    if (!pos || pos === 'Unknown' || pos === 'Ignore') {
+                        const lower = btn.label.toLowerCase();
+                        // Skip function words and multi-word labels
+                        if (!skipInference.has(lower) && !lower.includes(' ') && lower.length > 1) {
+                            // Check irregular tables for confident POS assignment
+                            const inferredPOS = morph.inferPOS(lower);
+                            if (inferredPOS) {
+                                pos = inferredPOS;
+                                btn.pos = inferredPOS;
+                            }
+                            else {
+                                // Default to Noun for untagged content words.
+                                // This generates plurals (e.g., bird → birds, tree → trees).
+                                pos = 'Noun';
+                                btn.pos = 'Noun';
+                            }
+                        }
+                    }
+                    if (!pos || pos === 'Unknown' || pos === 'Ignore')
+                        continue;
+                    const forms = morph.inflect(btn.label, pos);
+                    if (forms.length > 0) {
+                        const existing = btn.predictions || [];
+                        const merged = new Set([...existing, ...forms]);
+                        btn.predictions = Array.from(merged);
+                    }
+                }
+            }
+        }
+    }
     /**
      * Calculate metrics for word forms (smart grammar predictions)
      *
@@ -593,14 +755,53 @@ export class MetricsCalculator {
         // Track buttons by label to compare efforts
         const existingLabels = new Map();
         buttons.forEach((btn) => existingLabels.set(btn.label.toLowerCase(), btn));
+        // Build a map of POS tags from ALL tree buttons, keyed by lowercase label.
+        // This ensures words on BFS-unreachable pages still contribute POS data.
+        const treePosMap = new Map();
+        const treePredictionsMap = new Map();
+        Object.values(tree.pages).forEach((page) => {
+            page.grid.forEach((row) => {
+                row.forEach((btn) => {
+                    if (!btn || !btn.label)
+                        return;
+                    const lower = btn.label.toLowerCase();
+                    if (btn.pos && btn.pos !== 'Unknown' && btn.pos !== 'Ignore') {
+                        treePosMap.set(lower, btn.pos);
+                    }
+                    if (btn.predictions && btn.predictions.length > 0) {
+                        const existing = treePredictionsMap.get(lower);
+                        if (!existing || btn.predictions.length > existing.length) {
+                            treePredictionsMap.set(lower, btn.predictions);
+                        }
+                    }
+                });
+            });
+        });
+        // For metrics buttons that lack POS but have a tree counterpart with POS,
+        // propagate the POS tag so it's available in the output.
+        buttons.forEach((btn) => {
+            const lower = btn.label.toLowerCase();
+            if (!btn.pos || btn.pos === 'Unknown' || btn.pos === 'Ignore') {
+                const treePos = treePosMap.get(lower);
+                if (treePos)
+                    btn.pos = treePos;
+            }
+        });
+        // Note: buttons on pages unreachable via BFS from the root page are
+        // intentionally excluded. If there is no navigation path to a page,
+        // those buttons are not accessible to the user and should not count
+        // as available vocabulary.
         // Iterate through all pages to find buttons with predictions
         Object.values(tree.pages).forEach((page) => {
             page.grid.forEach((row) => {
                 row.forEach((btn) => {
                     if (!btn || !btn.predictions || btn.predictions.length === 0)
                         return;
-                    // Find the parent button's metrics
-                    const parentMetrics = buttons.find((b) => b.id === btn.id);
+                    // Find the parent button's metrics (by id first, then by label)
+                    let parentMetrics = buttons.find((b) => b.id === btn.id);
+                    if (!parentMetrics && btn.label) {
+                        parentMetrics = existingLabels.get(btn.label.toLowerCase());
+                    }
                     if (!parentMetrics)
                         return;
                     // Calculate effort for each word form
@@ -698,7 +899,11 @@ export class MetricsCalculator {
             // If no block assigned, treat as its own block at the end (fallback)
             if (blockId === null) {
                 const loop = board.grid.length + (board.grid[0]?.length || 0);
-                return { steps: rowIndex + colIndex + 1, selections: 1, loopSteps: loop };
+                return {
+                    steps: rowIndex + colIndex + 1,
+                    selections: 1,
+                    loopSteps: loop,
+                };
             }
             const blockConfig = board.scanBlocksConfig?.find((c) => c.id === blockId);
             const blockOrder = blockConfig?.order ?? blockId;

package/dist/browser/utilities/analytics/metrics/vocabulary.js

@@ -131,8 +131,20 @@ export class VocabularyAnalyzer {
     }
     /**
      * Check if a word is in the board set
+     *
+     * Checks both direct button labels and smart grammar word forms
+     * (morphological inflections stored as predictions).
      */
     hasWord(word, metrics) {
-        return metrics.buttons.some((b) => b.label.toLowerCase() === word.toLowerCase());
+        const lower = word.toLowerCase();
+        return metrics.buttons.some((b) => {
+            if (b.label.toLowerCase() === lower)
+                return true;
+            if (b.is_word_form && b.parent_button_label) {
+                if (b.label.toLowerCase() === lower)
+                    return true;
+            }
+            return false;
+        });
     }
 }