@willwade/aac-processors 0.0.29 → 0.1.0

package/dist/browser/core/baseProcessor.js

@@ -0,0 +1,241 @@
+/**
+ * Base Processor for AAC File Formats
+ *
+ * This module provides base functionality for processing AAC (Augmentative and Alternative
+ * Communication) files across various formats (gridset, OBF, Snap, TouchChat, etc.).
+ *
+ * ## LLM-Based Translation with Symbol Preservation
+ *
+ * All processor formats support LLM-based translation that preserves symbol-to-word
+ * associations across languages. This is critical for AAC systems where visual symbols
+ * are attached to specific words.
+ *
+ * ### Usage Example:
+ *
+ * ```typescript
+ * import { extractAllButtonsForTranslation, createTranslationPrompt } from '../optional/translation/translationProcessor';
+ *
+ * // 1. Extract buttons from your format
+ * const buttons = extractAllButtonsForTranslation(myFormatButtons, (button) => ({
+ *   pageId: button.pageId,
+ *   pageName: button.pageName
+ * }));
+ *
+ * // 2. Create prompt for LLM
+ * const prompt = createTranslationPrompt(buttons, 'Spanish');
+ *
+ * // 3. Send to LLM (Gemini, GPT, etc.) and get response
+ * const llmResponse = await callLLMAPI(prompt);
+ *
+ * // 4. Apply translations to your format
+ * processor.processLLMTranslations(filePath, llmResponse, outputPath);
+ * ```
+ *
+ * ### Format-Specific Implementation:
+ *
+ * Each processor should implement:
+ * - `extractSymbolsForLLM()` - Uses extractAllButtonsForTranslation() utility
+ * - `processLLMTranslations()` - Applies translations using format-specific logic
+ *
+ * See `src/utilities/translation/translationProcessor.ts` for shared utilities.
+ */
+import { AACSemanticCategory } from './treeStructure';
+import { detectCasing, isNumericOrEmpty } from './stringCasing';
+class BaseProcessor {
+    constructor(options = {}) {
+        // Default configuration: exclude navigation/system buttons
+        this.options = {
+            excludeNavigationButtons: true,
+            excludeSystemButtons: true,
+            preserveAllButtons: false,
+            ...options,
+        };
+    }
+    // Helper method to determine if a button should be filtered out
+    shouldFilterButton(button) {
+        // If preserveAllButtons is true, never filter
+        if (this.options.preserveAllButtons) {
+            return false;
+        }
+        // Apply custom filter if provided
+        if (this.options.customButtonFilter) {
+            return !this.options.customButtonFilter(button);
+        }
+        // Check semantic action-based filtering
+        if (button.semanticAction) {
+            const { category, intent } = button.semanticAction;
+            // Filter specific navigation intents (toolbar navigation only)
+            if (this.options.excludeNavigationButtons) {
+                const i = String(intent);
+                if (i === 'GO_BACK' || i === 'GO_HOME') {
+                    return true;
+                }
+            }
+            // Filter system/text editing buttons by category
+            if (this.options.excludeSystemButtons && category === AACSemanticCategory.TEXT_EDITING) {
+                return true;
+            }
+            // Filter specific system intents
+            if (this.options.excludeSystemButtons) {
+                const i = String(intent);
+                if (i === 'DELETE_WORD' ||
+                    i === 'DELETE_CHARACTER' ||
+                    i === 'CLEAR_TEXT' ||
+                    i === 'COPY_TEXT') {
+                    return true;
+                }
+            }
+        }
+        // Fallback: check button labels for common navigation/system terms
+        // Only apply label-based filtering if button doesn't have semantic actions
+        if (!button.semanticAction &&
+            (this.options.excludeNavigationButtons || this.options.excludeSystemButtons)) {
+            const label = button.label?.toLowerCase() || '';
+            const message = button.message?.toLowerCase() || '';
+            // More conservative navigation terms (exclude "more" since it's often used for legitimate page navigation)
+            const navigationTerms = ['back', 'home', 'menu', 'settings'];
+            const systemTerms = ['delete', 'clear', 'copy', 'paste', 'undo', 'redo'];
+            if (this.options.excludeNavigationButtons &&
+                navigationTerms.some((term) => label.includes(term) || message.includes(term))) {
+                return true;
+            }
+            if (this.options.excludeSystemButtons &&
+                systemTerms.some((term) => label.includes(term) || message.includes(term))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // Helper method to filter buttons from a page
+    filterPageButtons(buttons) {
+        return buttons.filter((button) => !this.shouldFilterButton(button));
+    }
+    /**
+     * Generic implementation for extracting strings with metadata
+     * Can be used by any processor that doesn't need format-specific logic
+     * @param filePath - Path to the AAC file
+     * @returns Promise with extracted strings and metadata
+     */
+    async extractStringsWithMetadataGeneric(filePath) {
+        try {
+            const tree = await this.loadIntoTree(filePath);
+            const extractedMap = new Map();
+            // Process all pages and buttons
+            Object.values(tree.pages).forEach((page) => {
+                // Process page names
+                if (page.name && page.name.trim().length > 1 && !isNumericOrEmpty(page.name)) {
+                    const key = page.name.trim().toLowerCase();
+                    const vocabLocation = {
+                        table: 'pages',
+                        id: page.id,
+                        column: 'NAME',
+                        casing: detectCasing(page.name),
+                    };
+                    this.addToExtractedMap(extractedMap, key, page.name.trim(), vocabLocation);
+                }
+                page.buttons.forEach((button) => {
+                    // Process button labels
+                    if (button.label && button.label.trim().length > 1 && !isNumericOrEmpty(button.label)) {
+                        const key = button.label.trim().toLowerCase();
+                        const vocabLocation = {
+                            table: 'buttons',
+                            id: button.id,
+                            column: 'LABEL',
+                            casing: detectCasing(button.label),
+                        };
+                        this.addToExtractedMap(extractedMap, key, button.label.trim(), vocabLocation);
+                    }
+                    // Process button messages (if different from label)
+                    if (button.message &&
+                        button.message !== button.label &&
+                        button.message.trim().length > 1 &&
+                        !isNumericOrEmpty(button.message)) {
+                        const key = button.message.trim().toLowerCase();
+                        const vocabLocation = {
+                            table: 'buttons',
+                            id: button.id,
+                            column: 'MESSAGE',
+                            casing: detectCasing(button.message),
+                        };
+                        this.addToExtractedMap(extractedMap, key, button.message.trim(), vocabLocation);
+                    }
+                });
+            });
+            const extractedStrings = Array.from(extractedMap.values());
+            return { errors: [], extractedStrings };
+        }
+        catch (error) {
+            return {
+                errors: [
+                    {
+                        message: error instanceof Error ? error.message : 'Unknown extraction error',
+                        step: 'EXTRACT',
+                    },
+                ],
+                extractedStrings: [],
+            };
+        }
+    }
+    /**
+     * Generic implementation for generating translated downloads
+     * Can be used by any processor that doesn't need format-specific logic
+     * @param filePath - Path to the original AAC file
+     * @param translatedStrings - Array of translated string data
+     * @param sourceStrings - Array of source string data
+     * @returns Promise with path to the generated translated file
+     */
+    async generateTranslatedDownloadGeneric(filePath, translatedStrings, sourceStrings) {
+        // Build translation map from the provided data
+        const translations = new Map();
+        sourceStrings.forEach((sourceString) => {
+            const translated = translatedStrings.find((ts) => ts.sourcestringid.toString() === sourceString.id.toString());
+            if (translated) {
+                const translatedText = translated.overridestring.length > 0
+                    ? translated.overridestring
+                    : translated.translatedstring;
+                translations.set(sourceString.sourcestring, translatedText);
+            }
+        });
+        // Generate output path based on file extension
+        const outputPath = this.generateTranslatedOutputPath(filePath);
+        // Use existing processTexts method (now async)
+        await this.processTexts(filePath, translations, outputPath);
+        return outputPath;
+    }
+    /**
+     * Helper method to add extracted strings to the map, handling duplicates
+     * @param extractedMap - Map to store extracted strings
+     * @param key - Lowercase key for deduplication
+     * @param originalString - Original string with proper casing
+     * @param vocabLocation - Metadata about where the string was found
+     */
+    addToExtractedMap(extractedMap, key, originalString, vocabLocation) {
+        const existing = extractedMap.get(key);
+        if (existing) {
+            existing.vocabPlacementMeta.vocabLocations.push(vocabLocation);
+        }
+        else {
+            extractedMap.set(key, {
+                string: originalString, // Use original casing for the string value
+                vocabPlacementMeta: {
+                    vocabLocations: [vocabLocation],
+                },
+            });
+        }
+    }
+    /**
+     * Generate output path for translated file based on input file extension
+     * @param filePath - Original file path
+     * @returns Path for the translated output file
+     */
+    generateTranslatedOutputPath(filePath) {
+        const lastDotIndex = filePath.lastIndexOf('.');
+        if (lastDotIndex === -1) {
+            return filePath + '_translated';
+        }
+        const basePath = filePath.substring(0, lastDotIndex);
+        const extension = filePath.substring(lastDotIndex);
+        return `${basePath}_translated${extension}`;
+    }
+}
+export { BaseProcessor };

package/dist/browser/core/stringCasing.js

@@ -0,0 +1,179 @@
+/**
+ * String casing utilities for AAC text processing
+ * Used for detecting and managing text casing across different AAC formats
+ */
+export var StringCasing;
+(function (StringCasing) {
+    StringCasing["LOWER"] = "lower";
+    StringCasing["SNAKE"] = "snake";
+    StringCasing["CONSTANT"] = "constant";
+    StringCasing["CAMEL"] = "camel";
+    StringCasing["UPPER"] = "upper";
+    StringCasing["KEBAB"] = "kebab";
+    StringCasing["CAPITAL"] = "capital";
+    StringCasing["HEADER"] = "header";
+    StringCasing["PASCAL"] = "pascal";
+    StringCasing["TITLE"] = "title";
+    StringCasing["SENTENCE"] = "sentence";
+})(StringCasing || (StringCasing = {}));
+/**
+ * Detects the casing pattern of a given text string
+ * @param text - The text to analyze for casing pattern
+ * @returns StringCasing enum value representing the detected casing
+ */
+/**
+ * Infer the dominant casing style of a string (camel, pascal, snake, kebab, title, sentence, upper, lower).
+ */
+export function detectCasing(text) {
+    if (!text || text.length === 0)
+        return StringCasing.LOWER;
+    // Remove leading/trailing whitespace for analysis
+    const trimmed = text.trim();
+    if (trimmed.length === 0)
+        return StringCasing.LOWER;
+    // Check for specific patterns
+    // CONSTANT_CASE (ALL_CAPS_WITH_UNDERSCORES)
+    if (/^[A-Z][A-Z0-9_]*$/.test(trimmed) && trimmed.includes('_')) {
+        return StringCasing.CONSTANT;
+    }
+    // snake_case (lowercase_with_underscores)
+    if (/^[a-z][a-z0-9_]*$/.test(trimmed) && trimmed.includes('_')) {
+        return StringCasing.SNAKE;
+    }
+    // kebab-case (lowercase-with-hyphens)
+    if (/^[a-z][a-z0-9-]*$/.test(trimmed) && trimmed.includes('-')) {
+        return StringCasing.KEBAB;
+    }
+    // camelCase (firstWordLowerCaseFollowingWordsCapitalized)
+    if (/^[a-z][a-zA-Z0-9]*$/.test(trimmed) && /[A-Z]/.test(trimmed)) {
+        return StringCasing.CAMEL;
+    }
+    // PascalCase (FirstWordAndFollowingWordsCapitalized)
+    if (/^[A-Z][a-zA-Z0-9]*$/.test(trimmed) &&
+        /[a-z]/.test(trimmed) &&
+        /[A-Z].*[A-Z]/.test(trimmed)) {
+        return StringCasing.PASCAL;
+    }
+    // UPPER CASE (ALL UPPERCASE) - but only if more than one character
+    if (trimmed === trimmed.toUpperCase() && /[A-Z]/.test(trimmed) && trimmed.length > 1) {
+        return StringCasing.UPPER;
+    }
+    // lower case (all lowercase)
+    if (trimmed === trimmed.toLowerCase() && /[a-z]/.test(trimmed)) {
+        return StringCasing.LOWER;
+    }
+    // Title Case (First Letter Of Each Word Capitalized)
+    const words = trimmed.split(/\s+/);
+    if (words.length > 1 &&
+        words.every((word) => word.length > 0 &&
+            word[0] === word[0].toUpperCase() &&
+            (word.length === 1 || word.slice(1) === word.slice(1).toLowerCase()))) {
+        return StringCasing.TITLE;
+    }
+    // Header-Case (First-Letter-Of-Each-Word-Capitalized-With-Hyphens)
+    if (trimmed.includes('-')) {
+        const hyphenWords = trimmed.split('-');
+        if (hyphenWords.length > 1 &&
+            hyphenWords.every((word) => word.length > 0 &&
+                word[0] === word[0].toUpperCase() &&
+                (word.length === 1 || word.slice(1) === word.slice(1).toLowerCase()))) {
+            return StringCasing.HEADER;
+        }
+    }
+    // Sentence case (First letter capitalized, rest lowercase)
+    if (trimmed.length > 1 &&
+        trimmed[0] === trimmed[0].toUpperCase() &&
+        trimmed.slice(1) === trimmed.slice(1).toLowerCase()) {
+        return StringCasing.SENTENCE;
+    }
+    // Capital case (Just first letter capitalized, may have mixed case after)
+    if (trimmed[0] === trimmed[0].toUpperCase()) {
+        return StringCasing.CAPITAL;
+    }
+    // Default fallback
+    return StringCasing.LOWER;
+}
+/**
+ * Converts text to the specified casing
+ * @param text - The text to convert
+ * @param targetCasing - The desired casing format
+ * @returns The text converted to the target casing
+ */
+/**
+ * Convert a string into the requested casing style.
+ * @param text Input string
+ * @param targetCasing Desired casing variant
+ */
+export function convertCasing(text, targetCasing) {
+    if (!text || text.length === 0)
+        return text;
+    const trimmed = text.trim();
+    if (trimmed.length === 0)
+        return text;
+    switch (targetCasing) {
+        case StringCasing.LOWER:
+            return trimmed.toLowerCase();
+        case StringCasing.UPPER:
+            return trimmed.toUpperCase();
+        case StringCasing.CAPITAL:
+            return trimmed.charAt(0).toUpperCase() + trimmed.slice(1).toLowerCase();
+        case StringCasing.SENTENCE:
+            return trimmed.charAt(0).toUpperCase() + trimmed.slice(1).toLowerCase();
+        case StringCasing.TITLE:
+            return trimmed
+                .split(/\s+/)
+                .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+                .join(' ');
+        case StringCasing.CAMEL:
+            return trimmed
+                .split(/[\s_-]+/)
+                .map((word, index) => index === 0
+                ? word.toLowerCase()
+                : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+                .join('');
+        case StringCasing.PASCAL:
+            return trimmed
+                .split(/[\s_-]+/)
+                .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+                .join('');
+        case StringCasing.SNAKE:
+            return trimmed
+                .split(/[\s-]+/)
+                .map((word) => word.toLowerCase())
+                .join('_');
+        case StringCasing.CONSTANT:
+            return trimmed
+                .split(/[\s-]+/)
+                .map((word) => word.toUpperCase())
+                .join('_');
+        case StringCasing.KEBAB:
+            return trimmed
+                .split(/[\s_]+/)
+                .map((word) => word.toLowerCase())
+                .join('-');
+        case StringCasing.HEADER:
+            return trimmed
+                .split(/[\s_]+/)
+                .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+                .join('-');
+        default:
+            return trimmed;
+    }
+}
+/**
+ * Utility function to check if text is primarily numeric or empty
+ * Used for filtering out non-meaningful text content
+ * @param text - The text to check
+ * @returns True if the text should be considered non-meaningful
+ */
+/**
+ * Check whether a string is empty or represents a numeric value.
+ */
+export function isNumericOrEmpty(text) {
+    const trimmed = text.trim();
+    if (trimmed.length <= 1)
+        return true;
+    // Check if the entire string is numeric
+    const numericValue = parseInt(trimmed, 10);
+    return !isNaN(numericValue) && numericValue.toString() === trimmed;
+}

package/dist/browser/core/treeStructure.js

@@ -0,0 +1,255 @@
+// Semantic action categories for cross-platform compatibility
+export var AACSemanticCategory;
+(function (AACSemanticCategory) {
+    AACSemanticCategory["COMMUNICATION"] = "communication";
+    AACSemanticCategory["NAVIGATION"] = "navigation";
+    AACSemanticCategory["TEXT_EDITING"] = "text_editing";
+    AACSemanticCategory["SYSTEM_CONTROL"] = "system_control";
+    AACSemanticCategory["MEDIA"] = "media";
+    AACSemanticCategory["ACCESSIBILITY"] = "accessibility";
+    AACSemanticCategory["CUSTOM"] = "custom";
+})(AACSemanticCategory || (AACSemanticCategory = {}));
+// Semantic intents within each category
+export var AACSemanticIntent;
+(function (AACSemanticIntent) {
+    // Communication
+    AACSemanticIntent["SPEAK_TEXT"] = "SPEAK_TEXT";
+    AACSemanticIntent["SPEAK_IMMEDIATE"] = "SPEAK_IMMEDIATE";
+    AACSemanticIntent["STOP_SPEECH"] = "STOP_SPEECH";
+    AACSemanticIntent["INSERT_TEXT"] = "INSERT_TEXT";
+    // Navigation
+    AACSemanticIntent["NAVIGATE_TO"] = "NAVIGATE_TO";
+    AACSemanticIntent["GO_BACK"] = "GO_BACK";
+    AACSemanticIntent["GO_HOME"] = "GO_HOME";
+    // Text Editing
+    AACSemanticIntent["DELETE_WORD"] = "DELETE_WORD";
+    AACSemanticIntent["DELETE_CHARACTER"] = "DELETE_CHARACTER";
+    AACSemanticIntent["CLEAR_TEXT"] = "CLEAR_TEXT";
+    AACSemanticIntent["COPY_TEXT"] = "COPY_TEXT";
+    AACSemanticIntent["PASTE_TEXT"] = "PASTE_TEXT";
+    // System Control
+    AACSemanticIntent["SEND_KEYS"] = "SEND_KEYS";
+    AACSemanticIntent["MOUSE_CLICK"] = "MOUSE_CLICK";
+    // Media
+    AACSemanticIntent["PLAY_SOUND"] = "PLAY_SOUND";
+    AACSemanticIntent["PLAY_VIDEO"] = "PLAY_VIDEO";
+    // Accessibility
+    AACSemanticIntent["SCAN_NEXT"] = "SCAN_NEXT";
+    AACSemanticIntent["SCAN_SELECT"] = "SCAN_SELECT";
+    // Custom
+    AACSemanticIntent["PLATFORM_SPECIFIC"] = "PLATFORM_SPECIFIC";
+})(AACSemanticIntent || (AACSemanticIntent = {}));
+/**
+ * Scanning types for accessibility
+ */
+export var AACScanType;
+(function (AACScanType) {
+    AACScanType["LINEAR"] = "linear";
+    AACScanType["ROW_COLUMN"] = "row-column";
+    AACScanType["COLUMN_ROW"] = "column-row";
+    AACScanType["BLOCK_ROW_COLUMN"] = "block-row-column";
+    AACScanType["BLOCK_COLUMN_ROW"] = "block-column-row";
+})(AACScanType || (AACScanType = {}));
+export class AACButton {
+    constructor({ id, label = '', message = '', targetPageId, semanticAction, audioRecording, style, contentType, contentSubType, image, resolvedImageEntry, symbolLibrary, symbolPath, x, y, columnSpan, rowSpan, scanBlocks, scanBlock, visibility, directActivate, parameters, predictions, semantic_id, clone_id, 
+    // Legacy input support
+    type, action, }) {
+        this.id = id;
+        this.label = label;
+        this.message = message;
+        this.targetPageId = targetPageId;
+        this.semanticAction = semanticAction;
+        this.audioRecording = audioRecording;
+        this.style = style;
+        this.contentType = contentType;
+        this.contentSubType = contentSubType;
+        this.image = image;
+        this.resolvedImageEntry = resolvedImageEntry;
+        this.symbolLibrary = symbolLibrary;
+        this.symbolPath = symbolPath;
+        this.x = x;
+        this.y = y;
+        this.columnSpan = columnSpan;
+        this.rowSpan = rowSpan;
+        this.scanBlocks = scanBlocks;
+        this.scanBlock = scanBlock;
+        this.visibility = visibility;
+        this.directActivate = directActivate;
+        this.parameters = parameters;
+        this.predictions = predictions;
+        this.semantic_id = semantic_id;
+        this.clone_id = clone_id;
+        // Legacy mapping: if no semanticAction provided, derive from legacy `action` first
+        if (!this.semanticAction && action) {
+            if (action.type === 'NAVIGATE' && (action.targetPageId || this.targetPageId)) {
+                if (!this.targetPageId)
+                    this.targetPageId = action.targetPageId;
+                this.semanticAction = {
+                    category: AACSemanticCategory.NAVIGATION,
+                    intent: AACSemanticIntent.NAVIGATE_TO,
+                    targetId: this.targetPageId,
+                    fallback: { type: 'NAVIGATE', targetPageId: this.targetPageId },
+                };
+            }
+            else if (action.type === 'SPEAK') {
+                const text = action.message || this.message || this.label || '';
+                if (!this.message)
+                    this.message = text;
+                this.semanticAction = {
+                    category: AACSemanticCategory.COMMUNICATION,
+                    intent: AACSemanticIntent.SPEAK_TEXT,
+                    text,
+                    fallback: { type: 'SPEAK', message: text },
+                };
+            }
+            else {
+                this.semanticAction = {
+                    category: AACSemanticCategory.SYSTEM_CONTROL,
+                    intent: AACSemanticIntent.PLATFORM_SPECIFIC,
+                    fallback: { type: 'ACTION' },
+                };
+            }
+        }
+        // Legacy mapping: if still no semanticAction and `type` provided
+        if (!this.semanticAction && type) {
+            if (type === 'NAVIGATE' && this.targetPageId) {
+                this.semanticAction = {
+                    category: AACSemanticCategory.NAVIGATION,
+                    intent: AACSemanticIntent.NAVIGATE_TO,
+                    targetId: this.targetPageId,
+                    fallback: { type: 'NAVIGATE', targetPageId: this.targetPageId },
+                };
+            }
+            else if (type === 'SPEAK') {
+                const text = this.message || this.label || '';
+                this.semanticAction = {
+                    category: AACSemanticCategory.COMMUNICATION,
+                    intent: AACSemanticIntent.SPEAK_TEXT,
+                    text,
+                    fallback: { type: 'SPEAK', message: text },
+                };
+            }
+            else {
+                this.semanticAction = {
+                    category: AACSemanticCategory.SYSTEM_CONTROL,
+                    intent: AACSemanticIntent.PLATFORM_SPECIFIC,
+                    fallback: { type: 'ACTION' },
+                };
+            }
+        }
+    }
+    // Legacy compatibility properties
+    get type() {
+        if (this.semanticAction) {
+            const i = String(this.semanticAction.intent);
+            if (i === 'NAVIGATE_TO')
+                return 'NAVIGATE';
+            if (i === 'SPEAK_TEXT' || i === 'SPEAK_IMMEDIATE')
+                return 'SPEAK';
+            return 'ACTION';
+        }
+        if (this.targetPageId)
+            return 'NAVIGATE';
+        if (this.message)
+            return 'SPEAK';
+        return 'SPEAK';
+    }
+    get action() {
+        const t = this.type;
+        if (!t)
+            return null;
+        if (t === 'SPEAK' && !this.message && !this.label && !this.semanticAction) {
+            return null;
+        }
+        return { type: t, targetPageId: this.targetPageId, message: this.message };
+    }
+}
+export class AACPage {
+    constructor({ id, name = '', grid = [], buttons = [], parentId = null, style, locale, descriptionHtml, images, sounds, semantic_ids, clone_ids, scanningConfig, scanBlocksConfig, scanType, }) {
+        this.id = id;
+        this.name = name;
+        if (Array.isArray(grid)) {
+            this.grid = grid;
+        }
+        else if (grid && typeof grid === 'object' && 'columns' in grid && 'rows' in grid) {
+            const cols = grid.columns;
+            const rows = grid.rows;
+            this.grid = Array.from({ length: rows }, () => Array.from({ length: cols }, () => null));
+        }
+        else {
+            this.grid = [];
+        }
+        this.buttons = buttons;
+        this.parentId = parentId;
+        this.style = style;
+        this.locale = locale;
+        this.descriptionHtml = descriptionHtml;
+        this.images = images;
+        this.sounds = sounds;
+        this.semantic_ids = semantic_ids;
+        this.clone_ids = clone_ids;
+        this.scanningConfig = scanningConfig;
+        this.scanBlocksConfig = scanBlocksConfig;
+        this.scanType = scanType;
+    }
+    addButton(button) {
+        this.buttons.push(button);
+    }
+}
+export class AACTree {
+    get rootId() {
+        return this.metadata.defaultHomePageId || null;
+    }
+    set rootId(id) {
+        this.metadata.defaultHomePageId = id || undefined;
+    }
+    get toolbarId() {
+        return this.metadata.toolbarId || null;
+    }
+    set toolbarId(id) {
+        this.metadata.toolbarId = id || undefined;
+    }
+    get dashboardId() {
+        return this.metadata.dashboardId || null;
+    }
+    set dashboardId(id) {
+        this.metadata.dashboardId = id || undefined;
+    }
+    constructor() {
+        this.pages = {};
+        this.metadata = {};
+    }
+    addPage(page) {
+        this.pages[page.id] = page;
+        if (!this.rootId)
+            this.rootId = page.id;
+    }
+    getPage(id) {
+        return this.pages[id];
+    }
+    traverse(callback) {
+        const queue = Object.keys(this.pages);
+        const visited = new Set();
+        while (queue.length > 0) {
+            const id = queue.shift();
+            if (!id || visited.has(id))
+                continue;
+            visited.add(id);
+            const page = this.pages[id];
+            if (page) {
+                callback(page);
+                // Add child pages to queue
+                page.buttons
+                    .filter((b) => {
+                    const i = String(b.semanticAction?.intent);
+                    return i === 'NAVIGATE_TO' || !!b.semanticAction?.targetId || !!b.targetPageId;
+                })
+                    .forEach((b) => {
+                    const target = b.semanticAction?.targetId || b.targetPageId;
+                    if (target)
+                        queue.push(target);
+                });
+            }
+        }
+    }
+}