@willwade/aac-processors 0.1.6 → 0.1.8

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

@@ -0,0 +1,221 @@
+/**
+ * Effort Score Calculation Algorithms
+ *
+ * Implements the core effort calculation algorithms from the Ruby aac-metrics tool.
+ * These algorithms calculate how difficult it is to access each button based on
+ * distance, visual scanning, grid complexity, and motor planning support.
+ */
+/**
+ * Constants for effort score calculation
+ * Values match the Ruby implementation exactly
+ */
+export const EFFORT_CONSTANTS = {
+    SQRT2: Math.sqrt(2),
+    BUTTON_SIZE_MULTIPLIER: 0.09,
+    FIELD_SIZE_MULTIPLIER: 0.005,
+    VISUAL_SCAN_MULTIPLIER: 0.015,
+    BOARD_CHANGE_PROCESSING_EFFORT: 1.0,
+    BOARD_HOME_EFFORT: 1.0,
+    COMBINED_WORDS_REMEMBERING_EFFORT: 1.0,
+    DISTANCE_MULTIPLIER: 0.4,
+    DISTANCE_THRESHOLD_TO_SKIP_VISUAL_SCAN: 0.1,
+    SKIPPED_VISUAL_SCAN_DISTANCE_MULTIPLIER: 0.5,
+    SAME_LOCATION_AS_PRIOR_DISCOUNT: 0.1,
+    RECOGNIZABLE_SEMANTIC_FROM_PRIOR_DISCOUNT: 0.5,
+    RECOGNIZABLE_SEMANTIC_FROM_OTHER_DISCOUNT: 0.5,
+    REUSED_SEMANTIC_FROM_OTHER_BONUS: 0.0025,
+    RECOGNIZABLE_CLONE_FROM_PRIOR_DISCOUNT: 0.33,
+    RECOGNIZABLE_CLONE_FROM_OTHER_DISCOUNT: 0.33,
+    REUSED_CLONE_FROM_OTHER_BONUS: 0.005,
+    SCAN_STEP_COST: 0.015, // Matches visual scan multiplier
+    SCAN_SELECTION_COST: 0.1, // Cost of a switch selection
+    DEFAULT_SCAN_ERROR_RATE: 0.1, // 10% chance of missing a selection
+    SCAN_RETRY_PENALTY: 1.0, // Cost multiplier for a full loop retry
+};
+/**
+ * Calculate button size effort based on grid dimensions
+ * Larger grids require more visual scanning and discrimination
+ *
+ * @param rows - Number of rows in the grid
+ * @param cols - Number of columns in the grid
+ * @returns Button size effort score
+ */
+export function buttonSizeEffort(rows, cols) {
+    return EFFORT_CONSTANTS.BUTTON_SIZE_MULTIPLIER * ((rows + cols) / 2);
+}
+/**
+ * Calculate field size effort based on number of visible buttons
+ * More buttons = more visual clutter = higher effort
+ *
+ * @param buttonCount - Number of visible buttons on the board
+ * @returns Field size effort score
+ */
+export function fieldSizeEffort(buttonCount) {
+    return EFFORT_CONSTANTS.FIELD_SIZE_MULTIPLIER * buttonCount;
+}
+/**
+ * Calculate visual scanning effort
+ * Effort increases with each button that must be scanned before reaching target
+ *
+ * @param priorButtons - Number of buttons visually scanned before target
+ * @returns Visual scan effort score
+ */
+export function visualScanEffort(priorButtons) {
+    return priorButtons * EFFORT_CONSTANTS.VISUAL_SCAN_MULTIPLIER;
+}
+/**
+ * Calculate distance effort from entry point to button center
+ * Uses Euclidean distance normalized by sqrt(2)
+ *
+ * @param x - Button center X coordinate (0-1 normalized)
+ * @param y - Button center Y coordinate (0-1 normalized)
+ * @param entryX - Entry point X coordinate (0-1 normalized, default 1.0 = bottom-right)
+ * @param entryY - Entry point Y coordinate (0-1 normalized, default 1.0 = bottom-right)
+ * @returns Distance effort score
+ */
+export function distanceEffort(x, y, entryX = 1.0, entryY = 1.0) {
+    const distance = Math.sqrt(Math.pow(x - entryX, 2) + Math.pow(y - entryY, 2));
+    return (distance / EFFORT_CONSTANTS.SQRT2) * EFFORT_CONSTANTS.DISTANCE_MULTIPLIER;
+}
+/**
+ * Calculate spelling effort for words not available in the board set
+ *
+ * @param word - The word to spell
+ * @param entryEffort - Effort to reach the spelling/keyboard page
+ * @param perLetterEffort - Average effort per letter on the keyboard
+ * @returns Spelling effort score
+ */
+export function spellingEffort(word, entryEffort = 10, perLetterEffort = 2.5) {
+    return entryEffort + word.length * perLetterEffort;
+}
+/**
+ * Calculate effort to access a word via prediction
+ *
+ * When prediction is available, the user:
+ * 1. Navigates to the spelling/keyboard page (entryEffort)
+ * 2. Types first 1-3 letters to trigger predictions
+ * 3. Selects from 1-3 predictions (average selections)
+ *
+ * @param entryEffort - Effort to reach the spelling/keyboard page
+ * @param perLetterEffort - Average effort per letter on the keyboard
+ * @param avgSelections - Average number of predictions to check (default 1.5)
+ * @param lettersToType - Letters to type before prediction appears (default 2)
+ * @returns Prediction effort score
+ */
+export function predictionEffort(entryEffort = 10, perLetterEffort = 2.5, avgSelections = 1.5, lettersToType = 2) {
+    // Cost to navigate to keyboard + type first few letters + select from predictions
+    const typingCost = lettersToType * perLetterEffort;
+    const selectionCost = avgSelections * EFFORT_CONSTANTS.SCAN_SELECTION_COST;
+    return entryEffort + typingCost + selectionCost;
+}
+/**
+ * Calculate base board effort
+ * Combines button size and field size efforts
+ *
+ * @param rows - Number of rows in the grid
+ * @param cols - Number of columns in the grid
+ * @param buttonCount - Number of visible buttons
+ * @returns Base board effort score
+ */
+export function baseBoardEffort(rows, cols, buttonCount) {
+    const sizeEffort = buttonSizeEffort(rows, cols);
+    const fieldEffort = fieldSizeEffort(buttonCount);
+    return sizeEffort + fieldEffort;
+}
+/**
+ * Apply reuse discount based on semantic_id/clone_id frequency
+ *
+ * @param boardEffort - Current board effort
+ * @param reuseDiscount - Calculated reuse discount
+ * @returns Adjusted board effort
+ */
+export function applyReuseDiscount(boardEffort, reuseDiscount) {
+    return Math.max(0, boardEffort - reuseDiscount);
+}
+/**
+ * Calculate button-level effort with motor planning discounts
+ *
+ * @param baseEffort - Base board effort
+ * @param boardPcts - Percentage of links matching semantic_id/clone_id
+ * @param button - Button data
+ * @returns Adjusted button effort
+ */
+export function calculateButtonEffort(baseEffort, boardPcts, button) {
+    let buttonEffort = baseEffort;
+    // Apply discounts for semantic_id
+    if (button.semantic_id && boardPcts[button.semantic_id]) {
+        const discount = EFFORT_CONSTANTS.SAME_LOCATION_AS_PRIOR_DISCOUNT / boardPcts[button.semantic_id];
+        buttonEffort = Math.min(buttonEffort, buttonEffort * discount);
+    }
+    // Apply discounts for clone_id
+    if (button.clone_id && boardPcts[button.clone_id]) {
+        const discount = EFFORT_CONSTANTS.SAME_LOCATION_AS_PRIOR_DISCOUNT / boardPcts[button.clone_id];
+        buttonEffort = Math.min(buttonEffort, buttonEffort * discount);
+    }
+    return buttonEffort;
+}
+/**
+ * Calculate distance with motor planning discounts
+ *
+ * @param distance - Raw distance effort
+ * @param boardPcts - Percentage of links matching semantic_id/clone_id
+ * @param button - Button data
+ * @param setPcts - Percentage of boards containing semantic_id/clone_id
+ * @returns Adjusted distance effort
+ */
+export function calculateDistanceWithDiscounts(distance, boardPcts, button, setPcts) {
+    let adjustedDistance = distance;
+    // Apply semantic_id discounts
+    if (button.semantic_id) {
+        if (boardPcts[button.semantic_id]) {
+            const discount = EFFORT_CONSTANTS.SAME_LOCATION_AS_PRIOR_DISCOUNT / boardPcts[button.semantic_id];
+            adjustedDistance = Math.min(adjustedDistance, adjustedDistance * discount);
+        }
+        else if (setPcts[button.semantic_id]) {
+            const discount = EFFORT_CONSTANTS.RECOGNIZABLE_SEMANTIC_FROM_OTHER_DISCOUNT / setPcts[button.semantic_id];
+            adjustedDistance = Math.min(adjustedDistance, adjustedDistance * discount);
+        }
+    }
+    // Apply clone_id discounts
+    if (button.clone_id) {
+        if (boardPcts[button.clone_id]) {
+            const discount = EFFORT_CONSTANTS.SAME_LOCATION_AS_PRIOR_DISCOUNT / boardPcts[button.clone_id];
+            adjustedDistance = Math.min(adjustedDistance, adjustedDistance * discount);
+        }
+        else if (setPcts[button.clone_id]) {
+            const discount = EFFORT_CONSTANTS.RECOGNIZABLE_CLONE_FROM_OTHER_DISCOUNT / setPcts[button.clone_id];
+            adjustedDistance = Math.min(adjustedDistance, adjustedDistance * discount);
+        }
+    }
+    return adjustedDistance;
+}
+/**
+ * Check if visual scan should be skipped (button close to previous)
+ *
+ * @param distance - Distance from previous button
+ * @returns True if close enough to skip full visual scan
+ */
+export function shouldSkipVisualScan(distance) {
+    return distance < EFFORT_CONSTANTS.DISTANCE_THRESHOLD_TO_SKIP_VISUAL_SCAN;
+}
+/**
+ * Calculate local scan effort when buttons are close
+ *
+ * @param distance - Distance between buttons
+ * @returns Local scan effort
+ */
+export function localScanEffort(distance) {
+    return distance * EFFORT_CONSTANTS.SKIPPED_VISUAL_SCAN_DISTANCE_MULTIPLIER;
+}
+/**
+ * Calculate effort for switch scanning
+ *
+ * @param steps - Number of scan steps to reach target
+ * @param selections - Number of switch selections required
+ * @param stepCost - Optional override for scan step cost
+ * @param selectionCost - Optional override for scan selection cost
+ * @returns Scanning effort score
+ */
+export function scanningEffort(steps, selections, stepCost = EFFORT_CONSTANTS.SCAN_STEP_COST, selectionCost = EFFORT_CONSTANTS.SCAN_SELECTION_COST) {
+    return steps * stepCost + selections * selectionCost;
+}

package/dist/browser/utilities/analytics/metrics/obl-types.js

@@ -0,0 +1,6 @@
+/**
+ * .obl (Open Board Logging) File Format Types
+ *
+ * Based on the .obl specification for AAC logging.
+ */
+export {};

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

@@ -0,0 +1,282 @@
+import { AACSemanticIntent, AACSemanticCategory } from '../../../core/treeStructure';
+/**
+ * .obl (Open Board Logging) Utility
+ *
+ * Provides parsing and generation support for the .obl format.
+ */
+export class OblUtil {
+    /**
+     * Parse an OBL JSON string.
+     * Handles the optional /* notice * / at the start of the file.
+     */
+    static parse(json) {
+        // Remove potential comment at the start
+        let cleanJson = json.trim();
+        if (cleanJson.startsWith('/*')) {
+            const endComment = cleanJson.indexOf('*/');
+            if (endComment !== -1) {
+                cleanJson = cleanJson.substring(endComment + 2).trim();
+            }
+        }
+        return JSON.parse(cleanJson);
+    }
+    /**
+     * Stringify an OBL file object.
+     * Optionally adds the recommended notice comment.
+     */
+    static stringify(obl, includeNotice = true) {
+        const json = JSON.stringify(obl, null, 2);
+        if (includeNotice) {
+            return `/* NOTICE: The following information represents an individual's communication and should be treated respectfully and securely. */\n${json}`;
+        }
+        return json;
+    }
+    /**
+     * Convert an OBL file to internal HistoryEntry format.
+     */
+    static toHistoryEntries(obl) {
+        const entries = [];
+        const source = obl.source || 'OBL';
+        // OBL is session-based and event-based.
+        // HistoryEntry is content-based with occurrences.
+        // We'll group events by content (label/text) to match HistoryEntry structure.
+        const contentMap = new Map();
+        for (const session of obl.sessions) {
+            for (const event of session.events) {
+                let content = '';
+                const evtAny = event;
+                const occurrence = {
+                    timestamp: new Date(event.timestamp),
+                    modeling: event.modeling,
+                    pageId: evtAny.board_id || null,
+                    latitude: event.geo?.[0] || null,
+                    longitude: event.geo?.[1] || null,
+                    type: event.type,
+                    // Store all other OBL fields in the occurrence
+                    buttonId: evtAny.button_id || null,
+                    boardId: evtAny.board_id || null,
+                    spoken: evtAny.spoken,
+                    vocalization: evtAny.vocalization,
+                    imageUrl: evtAny.image_url,
+                    actions: evtAny.actions,
+                };
+                if (event.type === 'button') {
+                    const btn = event;
+                    content = btn.vocalization || btn.label;
+                }
+                else if (event.type === 'utterance') {
+                    const utt = event;
+                    content = utt.text;
+                }
+                else if (event.type === 'action') {
+                    const act = event;
+                    content = act.action;
+                }
+                else if (event.type === 'note') {
+                    const note = event;
+                    content = note.text;
+                }
+                else {
+                    const evtAny = event;
+                    content = evtAny.label || evtAny.text || evtAny.action || 'unknown';
+                }
+                const occurrences = contentMap.get(content) || [];
+                occurrences.push(occurrence);
+                contentMap.set(content, occurrences);
+            }
+        }
+        contentMap.forEach((occurrences, content) => {
+            entries.push({
+                id: `obl:${content}`,
+                source: source,
+                content: content,
+                occurrences: occurrences.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime()),
+            });
+        });
+        return entries;
+    }
+    /**
+     * Convert HistoryEntries to an OBL file object.
+     */
+    static fromHistoryEntries(entries, userId, source) {
+        const events = [];
+        for (const entry of entries) {
+            for (const occ of entry.occurrences) {
+                const timestamp = occ.timestamp.toISOString();
+                const intent = occ.intent;
+                let oblType = occ.type || 'button';
+                let actionStr = undefined;
+                // Smart mapping based on AACSemanticIntent
+                if (intent === AACSemanticIntent.CLEAR_TEXT) {
+                    oblType = 'action';
+                    actionStr = ':clear';
+                }
+                else if (intent === AACSemanticIntent.GO_HOME) {
+                    oblType = 'action';
+                    actionStr = ':home';
+                }
+                else if (intent === AACSemanticIntent.NAVIGATE_TO) {
+                    oblType = 'action';
+                    actionStr = ':open_board';
+                }
+                else if (intent === AACSemanticIntent.GO_BACK) {
+                    oblType = 'action';
+                    actionStr = ':back';
+                }
+                else if (intent === AACSemanticIntent.DELETE_CHARACTER) {
+                    oblType = 'action';
+                    actionStr = ':backspace';
+                }
+                else if (intent === AACSemanticIntent.SPEAK_IMMEDIATE ||
+                    intent === AACSemanticIntent.SPEAK_TEXT) {
+                    // Speak could be a button or an utterance or an action
+                    if (oblType !== 'utterance' && oblType !== 'button') {
+                        oblType = 'action';
+                        actionStr = ':speak';
+                    }
+                }
+                const common = {
+                    id: Math.random().toString(36).substring(2, 11),
+                    timestamp,
+                    modeling: occ.modeling,
+                    type: oblType,
+                };
+                if (occ.latitude !== null &&
+                    occ.latitude !== undefined &&
+                    occ.longitude !== null &&
+                    occ.longitude !== undefined) {
+                    common.geo = [occ.latitude, occ.longitude];
+                }
+                if (oblType === 'utterance') {
+                    events.push({
+                        ...common,
+                        text: entry.content,
+                    });
+                }
+                else if (oblType === 'action') {
+                    events.push({
+                        ...common,
+                        action: actionStr || entry.content,
+                        destination_board_id: occ.boardId || undefined,
+                        text: intent === AACSemanticIntent.SPEAK_TEXT ? entry.content : undefined,
+                    });
+                }
+                else if (oblType === 'note') {
+                    events.push({
+                        ...common,
+                        text: entry.content,
+                    });
+                }
+                else {
+                    // Default to button
+                    events.push({
+                        ...common,
+                        type: 'button',
+                        label: occ.vocalization ? entry.content : entry.content,
+                        spoken: occ.spoken ??
+                            occ.category === AACSemanticCategory.COMMUNICATION,
+                        button_id: occ.buttonId || undefined,
+                        board_id: occ.boardId || occ.pageId || undefined,
+                        vocalization: occ.vocalization || undefined,
+                        image_url: occ.imageUrl || undefined,
+                        actions: occ.actions || undefined,
+                    });
+                }
+            }
+        }
+        // Sort events by timestamp
+        events.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+        const started = events.length > 0 ? events[0].timestamp : new Date().toISOString();
+        const ended = events.length > 0 ? events[events.length - 1].timestamp : new Date().toISOString();
+        const session = {
+            id: 'session-1',
+            type: 'log',
+            started,
+            ended,
+            events,
+        };
+        return {
+            format: 'open-board-log-0.1',
+            user_id: userId,
+            source: source || 'aac-processors',
+            sessions: [session],
+        };
+    }
+}
+/**
+ * .obl Anonymization Utility
+ */
+export class OblAnonymizer {
+    /**
+     * Apply anonymization to an OBL file.
+     */
+    static anonymize(obl, types) {
+        const newObl = JSON.parse(JSON.stringify(obl));
+        newObl.anonymized = true;
+        for (const session of newObl.sessions) {
+            session.anonymizations = session.anonymizations || [];
+            if (types.includes('timestamp_shift')) {
+                this.applyTimestampShift(session);
+                if (!session.anonymizations.includes('timestamp_shift'))
+                    session.anonymizations.push('timestamp_shift');
+            }
+            if (types.includes('geolocation_masking')) {
+                this.applyGeolocationMasking(session);
+                if (!session.anonymizations.includes('geolocation_masking'))
+                    session.anonymizations.push('geolocation_masking');
+            }
+            if (types.includes('url_stripping')) {
+                this.applyUrlStripping(session);
+                if (!session.anonymizations.includes('url_stripping'))
+                    session.anonymizations.push('url_stripping');
+            }
+            if (types.includes('name_masking')) {
+                this.applyNameMasking(newObl, session);
+                if (!session.anonymizations.includes('name_masking'))
+                    session.anonymizations.push('name_masking');
+            }
+        }
+        return newObl;
+    }
+    static applyTimestampShift(session) {
+        if (session.events.length === 0)
+            return;
+        const firstEventTime = session.events.length > 0 ? new Date(session.events[0].timestamp).getTime() : Infinity;
+        const sessionStartTime = session.started ? new Date(session.started).getTime() : Infinity;
+        const firstTimestamp = Math.min(firstEventTime, sessionStartTime);
+        if (firstTimestamp === Infinity)
+            return;
+        const targetStart = new Date('2000-01-01T00:00:00.000Z').getTime();
+        const offset = targetStart - firstTimestamp;
+        session.started = new Date(new Date(session.started).getTime() + offset).toISOString();
+        session.ended = new Date(new Date(session.ended).getTime() + offset).toISOString();
+        for (const event of session.events) {
+            event.timestamp = new Date(new Date(event.timestamp).getTime() + offset).toISOString();
+        }
+    }
+    static applyGeolocationMasking(session) {
+        for (const event of session.events) {
+            delete event.geo;
+            delete event.location_id;
+        }
+    }
+    static applyUrlStripping(session) {
+        for (const event of session.events) {
+            if (event.type === 'button') {
+                delete event.image_url;
+            }
+            if (event.type === 'note') {
+                delete event.author_url;
+                delete event.author_email;
+            }
+        }
+    }
+    static applyNameMasking(obl, session) {
+        delete obl.user_name;
+        for (const event of session.events) {
+            if (event.type === 'note') {
+                delete event.author_name;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,121 @@
+/**
+ * Sentence Construction Analysis
+ *
+ * Calculates the effort required to construct test sentences
+ * from the AAC board set, including spelling fallback for missing words.
+ */
+import { spellingEffort } from './effort';
+export class SentenceAnalyzer {
+    /**
+     * Analyze effort to construct a set of test sentences
+     */
+    analyzeSentences(metrics, sentences) {
+        return sentences.map((words) => this.analyzeSentence(metrics, words));
+    }
+    /**
+     * Analyze effort to construct a single sentence
+     */
+    analyzeSentence(metrics, words) {
+        const wordEfforts = [];
+        let totalEffort = 0;
+        let typing = false;
+        const missingWords = [];
+        // Create word lookup map
+        const wordMap = new Map();
+        metrics.buttons.forEach((btn) => {
+            const existing = wordMap.get(btn.label.toLowerCase());
+            if (!existing || btn.effort < existing.effort) {
+                wordMap.set(btn.label.toLowerCase(), { effort: btn.effort });
+            }
+        });
+        // Calculate effort for each word
+        words.forEach((word) => {
+            const lowerWord = word.toLowerCase();
+            const found = wordMap.get(lowerWord);
+            if (found) {
+                wordEfforts.push({ word, effort: found.effort, typed: false });
+                totalEffort += found.effort;
+            }
+            else {
+                // Word not found - check for dynamic prediction fallback
+                let wordEffort = 0;
+                const isTyped = true;
+                const baseSpell = spellingEffort(word, metrics.spelling_effort_base || 10, metrics.spelling_effort_per_letter || 2.5);
+                if (metrics.has_dynamic_prediction) {
+                    // Predictive fallback: Base + (limited letters) + selection
+                    // We assume on average typing 40% of the word finds it in the dictionary
+                    const predictiveEffort = (metrics.spelling_effort_base || 10) +
+                        word.length * 0.4 * (metrics.spelling_effort_per_letter || 2.5) +
+                        6.0; // Fixed selection cost from prediction bar
+                    wordEffort = Math.min(baseSpell, predictiveEffort);
+                }
+                else {
+                    wordEffort = baseSpell;
+                }
+                wordEfforts.push({ word, effort: wordEffort, typed: isTyped });
+                totalEffort += wordEffort;
+                typing = true;
+                missingWords.push(word);
+            }
+        });
+        const averageEffort = totalEffort / words.length;
+        // Reconstruct sentence for display
+        const sentence = this.reconstructSentence(words);
+        return {
+            sentence,
+            words,
+            effort: averageEffort,
+            total_effort: totalEffort,
+            typing,
+            missing_words: missingWords,
+            word_efforts: wordEfforts,
+        };
+    }
+    /**
+     * Reconstruct sentence from word array
+     */
+    reconstructSentence(words) {
+        return words
+            .map((word, idx) => {
+            // Capitalize first word
+            if (idx === 0) {
+                return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+            }
+            return word.toLowerCase();
+        })
+            .join(' ');
+    }
+    /**
+     * Calculate statistics across all sentences
+     */
+    calculateStatistics(analyses) {
+        const totalSentences = analyses.length;
+        const sentencesRequiringTyping = analyses.filter((a) => a.typing).length;
+        const sentencesWithoutTyping = totalSentences - sentencesRequiringTyping;
+        const efforts = analyses.map((a) => a.effort);
+        const averageEffort = efforts.reduce((sum, e) => sum + e, 0) / efforts.length;
+        const minEffort = Math.min(...efforts);
+        const maxEffort = Math.max(...efforts);
+        // Calculate median
+        const sortedEfforts = [...efforts].sort((a, b) => a - b);
+        const medianEffort = sortedEfforts.length % 2 === 0
+            ? (sortedEfforts[sortedEfforts.length / 2 - 1] + sortedEfforts[sortedEfforts.length / 2]) /
+                2
+            : sortedEfforts[Math.floor(sortedEfforts.length / 2)];
+        const totalWords = analyses.reduce((sum, a) => sum + a.words.length, 0);
+        const wordsRequiringTyping = analyses.reduce((sum, a) => sum + a.missing_words.length, 0);
+        const typingPercent = (wordsRequiringTyping / totalWords) * 100;
+        return {
+            total_sentences: totalSentences,
+            sentences_requiring_typing: sentencesRequiringTyping,
+            sentences_without_typing: sentencesWithoutTyping,
+            average_effort: averageEffort,
+            min_effort: minEffort,
+            max_effort: maxEffort,
+            median_effort: medianEffort,
+            total_words: totalWords,
+            words_requiring_typing: wordsRequiringTyping,
+            typing_percent: typingPercent,
+        };
+    }
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Metrics Types and Interfaces
+ *
+ * Defines the data structures used for AAC metrics analysis
+ */
+export {};