@willwade/aac-processors 0.0.15 → 0.0.17

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

@@ -10,31 +10,40 @@ exports.ComparisonAnalyzer = void 0;
 const sentence_1 = require("./sentence");
 const vocabulary_1 = require("./vocabulary");
 const index_1 = require("../reference/index");
+const effort_1 = require("./effort");
 class ComparisonAnalyzer {
     constructor() {
         this.vocabAnalyzer = new vocabulary_1.VocabularyAnalyzer();
         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 +71,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,
@@ -70,7 +80,7 @@ class ComparisonAnalyzer {
             };
         });
         // Calculate CARE components
-        const careComponents = this.calculateCareComponents(targetResult, compareResult, overlappingWords);
+        const careComponents = this.calculateCareComponents(targetResult, compareResult, overlappingWords, options);
         // Analyze high/low effort words
         const highEffortWords = [];
         const lowEffortWords = [];
@@ -124,8 +134,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 +151,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 +161,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 +187,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,
@@ -195,78 +217,198 @@ class ComparisonAnalyzer {
     /**
      * Calculate CARE component scores
      */
-    calculateCareComponents(targetResult, compareResult, _overlappingWords) {
-        // Create word maps
+    calculateCareComponents(targetResult, compareResult, _overlappingWords, options) {
+        // Load common words with baseline efforts (matching Ruby line 527-534)
+        const commonWordsData = this.referenceLoader.loadCommonWords();
+        const commonWords = new Map();
+        commonWordsData.words.forEach((word) => {
+            commonWords.set(word.toLowerCase(), commonWordsData.efforts[word] || 0);
+        });
+        // Determine prediction settings (default: use common words efforts, not prediction)
+        const usePrediction = options?.usePrediction || false; // Default FALSE (use common words)
+        const predictionSelections = options?.predictionSelections || 1.5;
+        const debugMode = process.env.DEBUG_METRICS === 'true';
+        // Helper function to calculate fallback effort
+        const getFallbackEffort = (word, hasPrediction, spellingBaseEffort) => {
+            const wordLower = word.toLowerCase();
+            // Check common words efforts first (matching Ruby line 533)
+            if (commonWords.has(wordLower)) {
+                const effort = commonWords.get(wordLower);
+                return effort !== undefined ? effort : (0, effort_1.spellingEffort)(word, 10, 2.5);
+            }
+            // If usePrediction is true and prediction is available, use prediction
+            if (usePrediction && hasPrediction && spellingBaseEffort !== undefined) {
+                return (0, effort_1.predictionEffort)(spellingBaseEffort, 2.5, predictionSelections, 2);
+            }
+            // Fallback to manual spelling (matching Ruby spelling_effort: 10 + word.length * 2.5)
+            return (0, effort_1.spellingEffort)(word, 10, 2.5);
+        };
+        // Debug: Check settings
+        const targetHasPrediction = targetResult.has_dynamic_prediction && targetResult.spelling_effort_base !== undefined;
+        const _compareHasPrediction = compareResult.has_dynamic_prediction && compareResult.spelling_effort_base !== undefined;
+        if (debugMode) {
+            console.log(`\n🔍 DEBUG Fallback Effort Settings:`);
+            console.log(`  Common words loaded: ${commonWords.size}`);
+            console.log(`  usePrediction option: ${usePrediction}`);
+            console.log(`  Target has prediction capability: ${targetHasPrediction}`);
+            console.log(`  Target spelling_base: ${targetResult.spelling_effort_base?.toFixed(2) || 'undefined'}`);
+        }
+        // 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
         const coreLists = this.referenceLoader.loadCoreLists();
         const fringe = this.referenceLoader.loadFringe();
+        const commonFringe = this.referenceLoader.loadCommonFringe();
         const sentences = this.referenceLoader.loadSentences();
-        // Calculate core coverage
+        // Calculate core coverage and effort (matching Ruby lines 609-647)
         let coreCount = 0;
         let compCoreCount = 0;
+        let targetCoreEffort = 0;
+        let compCoreEffort = 0;
         const allCoreWords = new Set();
         coreLists.forEach((list) => {
             list.words.forEach((word) => allCoreWords.add(word.toLowerCase()));
         });
         allCoreWords.forEach((word) => {
-            if (targetWords.has(word))
+            const key = this.normalize(word);
+            const targetBtn = targetWords.get(key);
+            const compareBtn = compareWords.get(key);
+            if (targetBtn) {
                 coreCount++;
-            if (compareWords.has(word))
+                targetCoreEffort += targetBtn.effort;
+            }
+            else {
+                // Fallback to spelling or prediction effort
+                targetCoreEffort += getFallbackEffort(word, targetResult.has_dynamic_prediction || false, targetResult.spelling_effort_base);
+            }
+            if (compareBtn) {
                 compCoreCount++;
+                compCoreEffort += compareBtn.effort;
+            }
+            else {
+                compCoreEffort += getFallbackEffort(word, compareResult.has_dynamic_prediction || false, compareResult.spelling_effort_base);
+            }
         });
-        // Calculate sentence construction effort
-        let sentenceEffort = 0;
-        let compSentenceEffort = 0;
-        let sentenceWordCount = 0;
+        const avgCoreEffort = allCoreWords.size > 0 ? targetCoreEffort / allCoreWords.size : 0;
+        const avgCompCoreEffort = allCoreWords.size > 0 ? compCoreEffort / allCoreWords.size : 0;
+        // Calculate core component scores (matching Ruby lines 644-647)
+        const coreScore = avgCoreEffort * 5.0;
+        const compCoreScore = avgCompCoreEffort * 5.0;
+        // Calculate sentence construction effort (matching Ruby lines 654-668)
+        const sentenceEfforts = [];
+        const compSentenceEfforts = [];
         sentences.forEach((words) => {
+            let targetSentenceEffort = 0;
+            let compSentenceEffort = 0;
             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;
+                    targetSentenceEffort += targetBtn.effort;
                 }
                 else {
-                    sentenceEffort += 10 + word.length * 2.5; // Spelling effort
+                    targetSentenceEffort += getFallbackEffort(word, targetResult.has_dynamic_prediction || false, targetResult.spelling_effort_base);
                 }
                 if (compareBtn) {
                     compSentenceEffort += compareBtn.effort;
                 }
                 else {
-                    compSentenceEffort += 10 + word.length * 2.5;
+                    compSentenceEffort += getFallbackEffort(word, compareResult.has_dynamic_prediction || false, compareResult.spelling_effort_base);
                 }
-                sentenceWordCount++;
             });
+            // Average effort per sentence (matching Ruby line 657)
+            sentenceEfforts.push(targetSentenceEffort / words.length);
+            compSentenceEfforts.push(compSentenceEffort / words.length);
         });
-        const avgSentenceEffort = sentenceWordCount > 0 ? sentenceEffort / sentenceWordCount : 0;
-        const compAvgSentenceEffort = sentenceWordCount > 0 ? compSentenceEffort / sentenceWordCount : 0;
-        // Calculate fringe coverage
+        const avgSentenceEffort = sentenceEfforts.length > 0
+            ? sentenceEfforts.reduce((a, b) => a + b, 0) / sentenceEfforts.length
+            : 0;
+        const compAvgSentenceEffort = compSentenceEfforts.length > 0
+            ? compSentenceEfforts.reduce((a, b) => a + b, 0) / compSentenceEfforts.length
+            : 0;
+        // Sentence component scores (matching Ruby line 665-668)
+        const sentenceScore = avgSentenceEffort * 3.0;
+        const compSentenceScore = compAvgSentenceEffort * 3.0;
+        // Calculate fringe effort (matching Ruby lines 670-687)
+        const fringeEfforts = [];
+        const compFringeEfforts = [];
         let fringeCount = 0;
         let compFringeCount = 0;
-        let commonFringeCount = 0;
         fringe.forEach((word) => {
-            const inTarget = targetWords.has(word);
-            const inCompare = compareWords.has(word);
-            if (inTarget)
+            const key = this.normalize(word);
+            const targetBtn = targetWords.get(key);
+            const compareBtn = compareWords.get(key);
+            if (targetBtn) {
+                fringeEfforts.push(targetBtn.effort);
                 fringeCount++;
-            if (inCompare)
+            }
+            else {
+                fringeEfforts.push(getFallbackEffort(word, targetResult.has_dynamic_prediction || false, targetResult.spelling_effort_base));
+            }
+            if (compareBtn) {
+                compFringeEfforts.push(compareBtn.effort);
                 compFringeCount++;
-            if (inTarget && inCompare)
+            }
+            else {
+                compFringeEfforts.push(getFallbackEffort(word, compareResult.has_dynamic_prediction || false, compareResult.spelling_effort_base));
+            }
+        });
+        const avgFringeEffort = fringeEfforts.length > 0
+            ? fringeEfforts.reduce((a, b) => a + b, 0) / fringeEfforts.length
+            : 0;
+        const avgCompFringeEffort = compFringeEfforts.length > 0
+            ? compFringeEfforts.reduce((a, b) => a + b, 0) / compFringeEfforts.length
+            : 0;
+        // Fringe component scores (matching Ruby line 684-687)
+        const fringeScore = avgFringeEffort * 2.0;
+        const compFringeScore = avgCompFringeEffort * 2.0;
+        // Calculate common fringe effort (matching Ruby lines 689-705)
+        const commonFringeEfforts = [];
+        const compCommonFringeEfforts = [];
+        let commonFringeCount = 0;
+        commonFringe.forEach((word) => {
+            const key = this.normalize(word);
+            const targetBtn = targetWords.get(key);
+            const compareBtn = compareWords.get(key);
+            if (targetBtn && compareBtn) {
+                commonFringeEfforts.push(targetBtn.effort);
+                compCommonFringeEfforts.push(compareBtn.effort);
                 commonFringeCount++;
+            }
         });
+        const avgCommonFringeEffort = commonFringeEfforts.length > 0
+            ? commonFringeEfforts.reduce((a, b) => a + b, 0) / commonFringeEfforts.length
+            : 0;
+        const avgCompCommonFringeEffort = compCommonFringeEfforts.length > 0
+            ? compCommonFringeEfforts.reduce((a, b) => a + b, 0) / compCommonFringeEfforts.length
+            : 0;
+        // Common fringe component scores (matching Ruby line 702-705)
+        const commonFringeScore = avgCommonFringeEffort * 1.0;
+        const compCommonFringeScore = avgCompCommonFringeEffort * 1.0;
+        // Calculate total CARE effort tally (matching Ruby lines 707-708)
+        const PLACEHOLDER = 70;
+        const targetEffortTally = coreScore + sentenceScore + fringeScore + commonFringeScore + PLACEHOLDER;
+        const compEffortTally = compCoreScore + compSentenceScore + compFringeScore + compCommonFringeScore + PLACEHOLDER;
+        // Calculate final CARE scores (matching Ruby line 710-711)
+        // res[:target_effort_score] = [0.0, 350.0 - target_effort_tally].max
+        const careScore = Math.max(0, 350.0 - targetEffortTally);
+        const compCareScore = Math.max(0, 350.0 - compEffortTally);
         return {
             core: coreCount,
             comp_core: compCoreCount,
@@ -276,6 +418,9 @@ class ComparisonAnalyzer {
             comp_fringe: compFringeCount,
             common_fringe: commonFringeCount,
             comp_common_fringe: commonFringeCount,
+            // New composite CARE scores
+            care_score: careScore,
+            comp_care_score: compCareScore,
         };
     }
     /**
@@ -285,8 +430,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 +451,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
      */