@willwade/aac-processors 0.0.14 → 0.0.16

package/dist/types/aac.js

@@ -7,7 +7,7 @@ exports.CellScanningOrder = exports.ScanningSelectionMethod = void 0;
  */
 var ScanningSelectionMethod;
 (function (ScanningSelectionMethod) {
-    /** Automatically advance through items at timed intervals */
+    /** Automatically advance through items at timed intervals (1 Switch) */
     ScanningSelectionMethod["AutoScan"] = "AutoScan";
     /** Automatic scanning with overscan (two-stage scanning) */
     ScanningSelectionMethod["AutoScanWithOverscan"] = "AutoScanWithOverscan";
@@ -15,8 +15,12 @@ var ScanningSelectionMethod;
     ScanningSelectionMethod["HoldToAdvance"] = "HoldToAdvance";
     /** Hold to advance with overscan */
     ScanningSelectionMethod["HoldToAdvanceWithOverscan"] = "HoldToAdvanceWithOverscan";
-    /** Tap switch to advance, tap again to select */
+    /** Tap switch to advance, tap again to select (Automatic) */
     ScanningSelectionMethod["TapToAdvance"] = "TapToAdvance";
+    /** Tap switch to advance, another switch to select (2 Switch Step Scan) */
+    ScanningSelectionMethod["StepScan2Switch"] = "StepScan2Switch";
+    /** Tap switch 1 to advance, tap switch 1 again to select (1 Switch Step Scan) */
+    ScanningSelectionMethod["StepScan1Switch"] = "StepScan1Switch";
 })(ScanningSelectionMethod || (exports.ScanningSelectionMethod = ScanningSelectionMethod = {}));
 /**
  * Cell scanning order patterns

package/dist/utilities/analytics/metrics/comparison.d.ts

@@ -10,6 +10,7 @@ export declare class ComparisonAnalyzer {
     private sentenceAnalyzer;
     private referenceLoader;
     constructor();
+    private normalize;
     /**
      * Compare two board sets
      */

package/dist/utilities/analytics/metrics/comparison.js

@@ -16,25 +16,33 @@ class ComparisonAnalyzer {
         this.sentenceAnalyzer = new sentence_1.SentenceAnalyzer();
         this.referenceLoader = new index_1.ReferenceLoader();
     }
+    normalize(word) {
+        return word
+            .toLowerCase()
+            .trim()
+            .replace(/[.?!,]/g, '');
+    }
     /**
      * Compare two board sets
      */
     compare(targetResult, compareResult, options) {
         // Create base result from target
         const baseResult = { ...targetResult };
-        // Create word maps
+        // Create word maps with normalized keys
         const targetWords = new Map();
         targetResult.buttons.forEach((btn) => {
-            const existing = targetWords.get(btn.label);
+            const key = this.normalize(btn.label);
+            const existing = targetWords.get(key);
             if (!existing || btn.effort < existing.effort) {
-                targetWords.set(btn.label, btn);
+                targetWords.set(key, btn);
             }
         });
         const compareWords = new Map();
         compareResult.buttons.forEach((btn) => {
-            const existing = compareWords.get(btn.label);
+            const key = this.normalize(btn.label);
+            const existing = compareWords.get(key);
             if (!existing || btn.effort < existing.effort) {
-                compareWords.set(btn.label, btn);
+                compareWords.set(key, btn);
             }
         });
         // Find missing/extra/overlapping words
@@ -62,7 +70,8 @@ class ComparisonAnalyzer {
         overlappingWords.sort((a, b) => a.localeCompare(b));
         // Add comparison metrics to buttons
         const enrichedButtons = targetResult.buttons.map((btn) => {
-            const compBtn = compareWords.get(btn.label);
+            const key = this.normalize(btn.label);
+            const compBtn = compareWords.get(key);
             return {
                 ...btn,
                 comp_level: compBtn?.level,
@@ -124,8 +133,9 @@ class ComparisonAnalyzer {
             let targetCovered = 0;
             let compareCovered = 0;
             list.words.forEach((word) => {
-                const targetBtn = targetWords.get(word);
-                const compareBtn = compareWords.get(word);
+                const key = this.normalize(word);
+                const targetBtn = targetWords.get(key);
+                const compareBtn = compareWords.get(key);
                 if (targetBtn) {
                     targetCovered++;
                     targetTotal += targetBtn.effort;
@@ -140,6 +150,9 @@ class ComparisonAnalyzer {
                 list: list.words,
                 average_effort: targetCovered > 0 ? targetTotal / targetCovered : 0,
                 comp_effort: compareCovered > 0 ? compareTotal / compareCovered : 0,
+                target_covered: targetCovered,
+                compare_covered: compareCovered,
+                total_words: list.words.length,
             };
         });
         // Analyze missing from specific lists
@@ -147,7 +160,8 @@ class ComparisonAnalyzer {
         coreLists.forEach((list) => {
             const listMissing = [];
             list.words.forEach((word) => {
-                if (!targetWords.has(word)) {
+                const key = this.normalize(word);
+                if (!targetWords.has(key)) {
                     listMissing.push(word);
                 }
             });
@@ -172,6 +186,13 @@ class ComparisonAnalyzer {
             comp_words: compareResult.total_words,
             comp_grid: compareResult.grid,
             comp_effort_score: this.calculateEffortScore(compareResult),
+            comp_spelling_effort_base: compareResult.spelling_effort_base,
+            comp_spelling_effort_per_letter: compareResult.spelling_effort_per_letter,
+            comp_spelling_page_id: compareResult.spelling_page_id,
+            has_dynamic_prediction: targetResult.has_dynamic_prediction,
+            prediction_page_id: targetResult.prediction_page_id,
+            comp_has_dynamic_prediction: compareResult.has_dynamic_prediction,
+            comp_prediction_page_id: compareResult.prediction_page_id,
             // Vocabulary comparison
             missing_words: missingWords,
             extra_words: extraWords,
@@ -196,19 +217,21 @@ class ComparisonAnalyzer {
      * Calculate CARE component scores
      */
     calculateCareComponents(targetResult, compareResult, _overlappingWords) {
-        // Create word maps
+        // Create word maps with normalized keys
         const targetWords = new Map();
         targetResult.buttons.forEach((btn) => {
-            const existing = targetWords.get(btn.label);
+            const key = this.normalize(btn.label);
+            const existing = targetWords.get(key);
             if (!existing || btn.effort < existing.effort) {
-                targetWords.set(btn.label, btn);
+                targetWords.set(key, btn);
             }
         });
         const compareWords = new Map();
         compareResult.buttons.forEach((btn) => {
-            const existing = compareWords.get(btn.label);
+            const key = this.normalize(btn.label);
+            const existing = compareWords.get(key);
             if (!existing || btn.effort < existing.effort) {
-                compareWords.set(btn.label, btn);
+                compareWords.set(key, btn);
             }
         });
         // Load reference data
@@ -223,9 +246,10 @@ class ComparisonAnalyzer {
             list.words.forEach((word) => allCoreWords.add(word.toLowerCase()));
         });
         allCoreWords.forEach((word) => {
-            if (targetWords.has(word))
+            const key = this.normalize(word);
+            if (targetWords.has(key))
                 coreCount++;
-            if (compareWords.has(word))
+            if (compareWords.has(key))
                 compCoreCount++;
         });
         // Calculate sentence construction effort
@@ -234,8 +258,9 @@ class ComparisonAnalyzer {
         let sentenceWordCount = 0;
         sentences.forEach((words) => {
             words.forEach((word) => {
-                const targetBtn = targetWords.get(word);
-                const compareBtn = compareWords.get(word);
+                const key = this.normalize(word);
+                const targetBtn = targetWords.get(key);
+                const compareBtn = compareWords.get(key);
                 if (targetBtn) {
                     sentenceEffort += targetBtn.effort;
                 }
@@ -258,8 +283,9 @@ class ComparisonAnalyzer {
         let compFringeCount = 0;
         let commonFringeCount = 0;
         fringe.forEach((word) => {
-            const inTarget = targetWords.has(word);
-            const inCompare = compareWords.has(word);
+            const key = this.normalize(word);
+            const inTarget = targetWords.has(key);
+            const inCompare = compareWords.has(key);
             if (inTarget)
                 fringeCount++;
             if (inCompare)
@@ -285,8 +311,9 @@ class ComparisonAnalyzer {
         const fringe = this.referenceLoader.loadFringe();
         const result = [];
         fringe.forEach((word) => {
-            const targetBtn = targetWords.get(word);
-            const compareBtn = compareWords.get(word);
+            const key = this.normalize(word);
+            const targetBtn = targetWords.get(key);
+            const compareBtn = compareWords.get(key);
             if (targetBtn) {
                 result.push({
                     word,
@@ -305,8 +332,9 @@ class ComparisonAnalyzer {
         const fringe = this.referenceLoader.loadFringe();
         const result = [];
         fringe.forEach((word) => {
-            const targetBtn = targetWords.get(word);
-            const compareBtn = compareWords.get(word);
+            const key = this.normalize(word);
+            const targetBtn = targetWords.get(key);
+            const compareBtn = compareWords.get(key);
             if (targetBtn && compareBtn) {
                 result.push({
                     word,

package/dist/utilities/analytics/metrics/core.d.ts

@@ -7,16 +7,21 @@
  * Based on: aac-metrics/lib/aac-metrics/metrics.rb
  */
 import { AACTree } from '../../../core/treeStructure';
-import { MetricsResult } from './types';
+import { MetricsOptions, MetricsResult } from './types';
 export declare class MetricsCalculator {
     private locale;
     /**
      * Main analysis function - calculates metrics for an AAC tree
      *
      * @param tree - The AAC tree to analyze
+     * @param options - Optional configuration for metrics calculation
      * @returns Complete metrics result
      */
-    analyze(tree: AACTree): MetricsResult;
+    analyze(tree: AACTree, options?: MetricsOptions): MetricsResult;
+    /**
+     * Identify keyboard/spelling page and calculate base/avg effort
+     */
+    private identifySpellingMetrics;
     /**
      * Build reference maps for semantic_id and clone_id frequencies
      */