@willwade/aac-processors 0.0.29 → 0.1.0

package/dist/browser/index.browser.js

@@ -0,0 +1,73 @@
+/**
+ * AACProcessors Browser Entry
+ *
+ * Browser-safe exports only (no Node-only dependencies).
+ *
+ * **NOTE: Gridset .gridsetx files**
+ * GridsetProcessor supports regular `.gridset` files in browser.
+ * Encrypted `.gridsetx` files require Node.js for crypto operations and are not supported in browser.
+ */
+// ===================================================================
+// CORE TYPES
+// ===================================================================
+export * from './core/treeStructure';
+export * from './core/baseProcessor';
+export * from './core/stringCasing';
+// ===================================================================
+// BROWSER-SAFE PROCESSORS
+// ===================================================================
+export { DotProcessor } from './processors/dotProcessor';
+export { OpmlProcessor } from './processors/opmlProcessor';
+export { ObfProcessor } from './processors/obfProcessor';
+export { GridsetProcessor } from './processors/gridsetProcessor';
+export { ApplePanelsProcessor } from './processors/applePanelsProcessor';
+export { AstericsGridProcessor } from './processors/astericsGridProcessor';
+import { DotProcessor } from './processors/dotProcessor';
+import { OpmlProcessor } from './processors/opmlProcessor';
+import { ObfProcessor } from './processors/obfProcessor';
+import { GridsetProcessor } from './processors/gridsetProcessor';
+import { ApplePanelsProcessor } from './processors/applePanelsProcessor';
+import { AstericsGridProcessor } from './processors/astericsGridProcessor';
+/**
+ * Factory function to get the appropriate processor for a file extension
+ * @param filePathOrExtension - File path or extension (e.g., '.dot', '/path/to/file.obf')
+ * @returns The appropriate processor instance
+ * @throws Error if the file extension is not supported
+ */
+export function getProcessor(filePathOrExtension) {
+    const extension = filePathOrExtension.includes('.')
+        ? filePathOrExtension.substring(filePathOrExtension.lastIndexOf('.'))
+        : filePathOrExtension;
+    switch (extension.toLowerCase()) {
+        case '.dot':
+            return new DotProcessor();
+        case '.opml':
+            return new OpmlProcessor();
+        case '.obf':
+        case '.obz':
+            return new ObfProcessor();
+        case '.gridset':
+            return new GridsetProcessor();
+        case '.plist':
+            return new ApplePanelsProcessor();
+        case '.grd':
+            return new AstericsGridProcessor();
+        default:
+            throw new Error(`Unsupported file extension: ${extension}`);
+    }
+}
+/**
+ * Get all supported file extensions
+ * @returns Array of supported file extensions
+ */
+export function getSupportedExtensions() {
+    return ['.dot', '.opml', '.obf', '.obz', '.gridset', '.plist', '.grd'];
+}
+/**
+ * Check if a file extension is supported
+ * @param extension - File extension to check
+ * @returns True if the extension is supported
+ */
+export function isExtensionSupported(extension) {
+    return getSupportedExtensions().includes(extension.toLowerCase());
+}

package/dist/browser/processors/applePanelsProcessor.js

@@ -0,0 +1,582 @@
+import { BaseProcessor, } from '../core/baseProcessor';
+import { AACTree, AACPage, AACButton, AACSemanticCategory, AACSemanticIntent, } from '../core/treeStructure';
+// Removed unused import: FileProcessor
+import plist from 'plist';
+import { ValidationFailureError, buildValidationResultFromMessage, } from '../validation/validationTypes';
+import { getBasename, getFs, getPath, readBinaryFromInput, readTextFromInput, writeTextToPath, } from '../utils/io';
+function isNormalizedPanel(panel) {
+    return typeof panel.id === 'string';
+}
+function normalizePanel(panel, fallbackId) {
+    const rawId = panel.ID || fallbackId;
+    const buttons = Array.isArray(panel.PanelObjects)
+        ? panel.PanelObjects.filter((obj) => obj.PanelObjectType === 'Button')
+        : [];
+    const normalizedButtons = buttons.map((btn) => {
+        const firstAction = Array.isArray(btn.Actions) && btn.Actions.length > 0 ? btn.Actions[0] : undefined;
+        const isCharSequence = firstAction &&
+            (firstAction.ActionType === 'ActionPressKeyCharSequence' ||
+                firstAction.ActionType === 'ActionSendKeys');
+        const charString = isCharSequence ? firstAction?.ActionParam?.CharString : undefined;
+        const targetPanel = firstAction && firstAction.ActionType === 'ActionOpenPanel'
+            ? firstAction.ActionParam?.PanelID?.replace(/^USER\./, '')
+            : undefined;
+        return {
+            label: btn.DisplayText || 'Button',
+            message: charString || btn.DisplayText || 'Button',
+            DisplayColor: btn.DisplayColor,
+            DisplayImageWeight: btn.DisplayImageWeight,
+            FontSize: btn.FontSize,
+            Rect: btn.Rect,
+            targetPanel,
+        };
+    });
+    return {
+        id: rawId.replace(/^USER\./, ''),
+        name: panel.Name || 'Panel',
+        buttons: normalizedButtons,
+    };
+}
+function normalizeActionParameters(input) {
+    if (typeof input === 'object' && input !== null) {
+        return { ...input };
+    }
+    return {};
+}
+class ApplePanelsProcessor extends BaseProcessor {
+    constructor(options) {
+        super(options);
+    }
+    // Helper function to parse Apple Panels Rect format "{{x, y}, {width, height}}"
+    parseRect(rectString) {
+        if (!rectString)
+            return null;
+        // Parse format like "{{0, 0}, {100, 25}}"
+        const match = rectString.match(/\{\{(\d+),\s*(\d+)\},\s*\{(\d+),\s*(\d+)\}\}/);
+        if (!match)
+            return null;
+        return {
+            x: parseInt(match[1], 10),
+            y: parseInt(match[2], 10),
+            width: parseInt(match[3], 10),
+            height: parseInt(match[4], 10),
+        };
+    }
+    // Convert pixel coordinates to grid coordinates (assuming 25px grid cells)
+    pixelToGrid(pixelX, pixelY, cellSize = 25) {
+        return {
+            gridX: Math.floor(pixelX / cellSize),
+            gridY: Math.floor(pixelY / cellSize),
+        };
+    }
+    async extractTexts(filePathOrBuffer) {
+        const tree = await this.loadIntoTree(filePathOrBuffer);
+        const texts = [];
+        for (const pageId in tree.pages) {
+            const page = tree.pages[pageId];
+            if (page.name)
+                texts.push(page.name);
+            page.buttons.forEach((btn) => {
+                if (btn.label)
+                    texts.push(btn.label);
+                if (btn.message && btn.message !== btn.label)
+                    texts.push(btn.message);
+            });
+        }
+        return texts;
+    }
+    async loadIntoTree(filePathOrBuffer) {
+        await Promise.resolve();
+        const filename = typeof filePathOrBuffer === 'string' ? getBasename(filePathOrBuffer) : 'upload.plist';
+        let buffer;
+        try {
+            if (typeof filePathOrBuffer === 'string') {
+                const fs = getFs();
+                const path = getPath();
+                if (filePathOrBuffer.endsWith('.ascconfig')) {
+                    const panelDefsPath = path.join(filePathOrBuffer, 'Contents', 'Resources', 'PanelDefinitions.plist');
+                    if (fs.existsSync(panelDefsPath)) {
+                        buffer = fs.readFileSync(panelDefsPath);
+                    }
+                    else {
+                        const validation = buildValidationResultFromMessage({
+                            filename,
+                            filesize: 0,
+                            format: 'applepanels',
+                            message: `Apple Panels file not found: ${panelDefsPath}`,
+                            type: 'missing',
+                            description: 'PanelDefinitions.plist',
+                        });
+                        throw new ValidationFailureError('Apple Panels file not found', validation);
+                    }
+                }
+                else {
+                    buffer = fs.readFileSync(filePathOrBuffer);
+                }
+            }
+            else {
+                buffer = readBinaryFromInput(filePathOrBuffer);
+            }
+            const content = readTextFromInput(buffer);
+            const parsedData = plist.parse(content);
+            let panelsData = [];
+            if (Array.isArray(parsedData.panels)) {
+                panelsData = parsedData.panels.map((panel, index) => {
+                    if (isNormalizedPanel(panel)) {
+                        return panel;
+                    }
+                    const panelData = panel || {
+                        PanelObjects: [],
+                    };
+                    return normalizePanel(panelData, `panel_${index}`);
+                });
+            }
+            else if (parsedData.Panels) {
+                const panelsDict = parsedData.Panels;
+                panelsData = Object.keys(panelsDict).map((panelId) => {
+                    const rawPanel = panelsDict[panelId] || { PanelObjects: [] };
+                    return normalizePanel(rawPanel, panelId);
+                });
+            }
+            if (panelsData.length === 0) {
+                const validation = buildValidationResultFromMessage({
+                    filename,
+                    filesize: buffer.byteLength,
+                    format: 'applepanels',
+                    message: 'No panels found in Apple Panels file',
+                    type: 'structure',
+                    description: 'Panels definition',
+                });
+                throw new ValidationFailureError('Apple Panels has no panels', validation);
+            }
+            const data = { panels: panelsData };
+            const tree = new AACTree();
+            tree.metadata.format = 'applepanels';
+            data.panels.forEach((panel) => {
+                const page = new AACPage({
+                    id: panel.id,
+                    name: panel.name,
+                    grid: [],
+                    buttons: [],
+                    parentId: null,
+                });
+                const gridLayout = [];
+                const maxRows = 20;
+                const maxCols = 20;
+                for (let r = 0; r < maxRows; r++) {
+                    gridLayout[r] = new Array(maxCols).fill(null);
+                }
+                panel.buttons.forEach((btn, idx) => {
+                    let semanticAction;
+                    if (btn.targetPanel) {
+                        semanticAction = {
+                            category: AACSemanticCategory.NAVIGATION,
+                            intent: AACSemanticIntent.NAVIGATE_TO,
+                            targetId: btn.targetPanel,
+                            platformData: {
+                                applePanels: {
+                                    actionType: 'ActionOpenPanel',
+                                    parameters: { PanelID: `USER.${btn.targetPanel}` },
+                                },
+                            },
+                            fallback: {
+                                type: 'NAVIGATE',
+                                targetPageId: btn.targetPanel,
+                            },
+                        };
+                    }
+                    else {
+                        semanticAction = {
+                            category: AACSemanticCategory.COMMUNICATION,
+                            intent: AACSemanticIntent.SPEAK_TEXT,
+                            text: btn.message || btn.label,
+                            platformData: {
+                                applePanels: {
+                                    actionType: 'ActionPressKeyCharSequence',
+                                    parameters: {
+                                        CharString: btn.message || btn.label || '',
+                                        isStickyKey: false,
+                                    },
+                                },
+                            },
+                            fallback: {
+                                type: 'SPEAK',
+                                message: btn.message || btn.label,
+                            },
+                        };
+                    }
+                    const button = new AACButton({
+                        id: `${panel.id}_btn_${idx}`,
+                        label: btn.label,
+                        message: btn.message || btn.label,
+                        targetPageId: btn.targetPanel,
+                        semanticAction: semanticAction,
+                        style: {
+                            backgroundColor: btn.DisplayColor,
+                            fontSize: btn.FontSize,
+                            fontWeight: btn.DisplayImageWeight === 'bold' ? 'bold' : 'normal',
+                        },
+                    });
+                    page.addButton(button);
+                    if (btn.Rect) {
+                        const rect = this.parseRect(btn.Rect);
+                        if (rect) {
+                            const gridPos = this.pixelToGrid(rect.x, rect.y);
+                            const gridWidth = Math.max(1, Math.ceil(rect.width / 25));
+                            const gridHeight = Math.max(1, Math.ceil(rect.height / 25));
+                            for (let r = gridPos.gridY; r < gridPos.gridY + gridHeight && r < maxRows; r++) {
+                                for (let c = gridPos.gridX; c < gridPos.gridX + gridWidth && c < maxCols; c++) {
+                                    if (gridLayout[r] && gridLayout[r][c] === null) {
+                                        gridLayout[r][c] = button;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                });
+                page.grid = gridLayout;
+                tree.addPage(page);
+            });
+            return tree;
+        }
+        catch (err) {
+            if (err instanceof ValidationFailureError) {
+                throw err;
+            }
+            const validation = buildValidationResultFromMessage({
+                filename,
+                filesize: typeof filePathOrBuffer === 'string'
+                    ? (() => {
+                        const fs = getFs();
+                        return fs.existsSync(filePathOrBuffer) ? fs.statSync(filePathOrBuffer).size : 0;
+                    })()
+                    : readBinaryFromInput(filePathOrBuffer).byteLength,
+                format: 'applepanels',
+                message: err?.message || 'Failed to parse Apple Panels file',
+                type: 'parse',
+                description: 'Parse Apple Panels plist',
+            });
+            throw new ValidationFailureError('Failed to load Apple Panels file', validation, err);
+        }
+    }
+    async processTexts(filePathOrBuffer, translations, outputPath) {
+        // Load the tree, apply translations, and save to new file
+        const tree = await this.loadIntoTree(filePathOrBuffer);
+        // Apply translations to all text content
+        Object.values(tree.pages).forEach((page) => {
+            // Translate page names
+            if (page.name && translations.has(page.name)) {
+                const translatedName = translations.get(page.name);
+                if (translatedName !== undefined) {
+                    page.name = translatedName;
+                }
+            }
+            // Translate button labels and messages
+            page.buttons.forEach((button) => {
+                if (button.label && translations.has(button.label)) {
+                    const translatedLabel = translations.get(button.label);
+                    if (translatedLabel !== undefined) {
+                        button.label = translatedLabel;
+                    }
+                }
+                if (button.message && translations.has(button.message)) {
+                    const translatedMessage = translations.get(button.message);
+                    if (translatedMessage !== undefined) {
+                        button.message = translatedMessage;
+                    }
+                }
+                if (button.semanticAction) {
+                    const intentStr = String(button.semanticAction.intent);
+                    if (intentStr === 'SPEAK_TEXT' || intentStr === 'INSERT_TEXT') {
+                        const updatedText = button.message || button.label || '';
+                        button.semanticAction.text = updatedText;
+                        if (button.semanticAction.fallback) {
+                            button.semanticAction.fallback.message = updatedText;
+                        }
+                        const platformParams = button.semanticAction.platformData?.applePanels?.parameters;
+                        if (platformParams && typeof platformParams === 'object') {
+                            if ('CharString' in platformParams) {
+                                platformParams.CharString = updatedText;
+                            }
+                            if ('PanelID' in platformParams && button.targetPageId) {
+                                platformParams.PanelID = `USER.${button.targetPageId}`;
+                            }
+                        }
+                    }
+                }
+            });
+        });
+        // Save the translated tree to the requested location and return its content
+        await this.saveFromTree(tree, outputPath);
+        if (outputPath.endsWith('.plist')) {
+            return readBinaryFromInput(outputPath);
+        }
+        const path = getPath();
+        const configPath = outputPath.endsWith('.ascconfig') ? outputPath : `${outputPath}.ascconfig`;
+        const panelDefsPath = path.join(configPath, 'Contents', 'Resources', 'PanelDefinitions.plist');
+        return readBinaryFromInput(panelDefsPath);
+    }
+    async saveFromTree(tree, outputPath) {
+        await Promise.resolve();
+        // Support two output modes:
+        // 1) Single-file .plist (PanelDefinitions.plist content written directly)
+        // 2) Apple Panels bundle folder (*.ascconfig) with Contents/Resources structure
+        const isSinglePlist = outputPath.endsWith('.plist');
+        // Prepare folder structure only when exporting as bundle
+        let configPath = '';
+        let contentsPath = '';
+        let resourcesPath = '';
+        if (!isSinglePlist) {
+            const fs = getFs();
+            const path = getPath();
+            configPath = outputPath.endsWith('.ascconfig') ? outputPath : `${outputPath}.ascconfig`;
+            contentsPath = path.join(configPath, 'Contents');
+            resourcesPath = path.join(contentsPath, 'Resources');
+            if (!fs.existsSync(configPath))
+                fs.mkdirSync(configPath, { recursive: true });
+            if (!fs.existsSync(contentsPath))
+                fs.mkdirSync(contentsPath, { recursive: true });
+            if (!fs.existsSync(resourcesPath))
+                fs.mkdirSync(resourcesPath, { recursive: true });
+            // Create Info.plist (bundle mode only)
+            const infoPlist = {
+                ASCConfigurationDisplayName: tree.metadata?.name || 'AAC Processors Export',
+                ASCConfigurationIdentifier: `com.aacprocessors.${Date.now()}`,
+                ASCConfigurationProductSupportType: 'VirtualKeyboard',
+                ASCConfigurationVersion: tree.metadata?.version || '7.1',
+                CFBundleDevelopmentRegion: tree.metadata?.locale || 'en',
+                CFBundleIdentifier: 'com.aacprocessors.panel.export',
+                CFBundleName: tree.metadata?.name || 'AAC Processors Panels',
+                CFBundleShortVersionString: tree.metadata?.version || '1.0',
+                CFBundleVersion: '1',
+                NSHumanReadableCopyright: tree.metadata?.copyright ||
+                    `Generated by AAC Processors${tree.metadata?.author ? ` - Author: ${tree.metadata.author}` : ''}`,
+            };
+            const infoPlistContent = plist.build(infoPlist);
+            writeTextToPath(path.join(contentsPath, 'Info.plist'), infoPlistContent);
+            // Create AssetIndex.plist (empty)
+            const assetIndexContent = plist.build({});
+            writeTextToPath(path.join(resourcesPath, 'AssetIndex.plist'), assetIndexContent);
+        }
+        // Build PanelDefinitions content from tree
+        const panelsDict = {};
+        Object.values(tree.pages).forEach((page, pageIndex) => {
+            const panelId = `USER.${page.id}`;
+            // Detect actual grid dimensions from the source data
+            let gridCols = 4; // Default fallback
+            if (page.grid && page.grid.length > 0) {
+                // Use actual grid dimensions from source
+                gridCols = page.grid[0] ? page.grid[0].length : 4;
+                // Find the actual used area to avoid empty space
+                let maxUsedX = 0, maxUsedY = 0;
+                for (let y = 0; y < page.grid.length; y++) {
+                    for (let x = 0; x < page.grid[y].length; x++) {
+                        if (page.grid[y][x]) {
+                            maxUsedX = Math.max(maxUsedX, x);
+                            maxUsedY = Math.max(maxUsedY, y);
+                        }
+                    }
+                }
+                // Use the actual used dimensions if they're reasonable
+                if (maxUsedX > 0 && maxUsedY > 0) {
+                    gridCols = maxUsedX + 1;
+                }
+            }
+            else {
+                // Intelligent auto-layout: try to make a reasonable grid
+                const buttonCount = page.buttons.length;
+                if (buttonCount <= 6) {
+                    gridCols = Math.min(buttonCount, 3); // 1-3 columns for small sets
+                }
+                else if (buttonCount <= 12) {
+                    gridCols = 4; // 4 columns for medium sets
+                }
+                else if (buttonCount <= 24) {
+                    gridCols = 6; // 6 columns for larger sets
+                }
+                else {
+                    gridCols = 8; // 8 columns for very large sets
+                }
+            }
+            const panelObjects = page.buttons.map((button, buttonIndex) => {
+                // Find button position in grid layout and convert to Rect format
+                let rect;
+                if (page.grid && page.grid.length > 0) {
+                    // Search for button in actual grid layout
+                    let found = false;
+                    for (let y = 0; y < page.grid.length && !found; y++) {
+                        for (let x = 0; x < page.grid[y].length && !found; x++) {
+                            const gridButton = page.grid[y][x];
+                            if (gridButton && gridButton.id === button.id) {
+                                // Convert grid coordinates to pixel coordinates
+                                const pixelX = x * 105; // 105px per column (100px button + 5px spacing)
+                                const pixelY = y * 30; // 30px per row (25px button + 5px spacing)
+                                rect = `{{${pixelX}, ${pixelY}}, {100, 25}}`;
+                                found = true;
+                            }
+                        }
+                    }
+                    if (!found) {
+                        // Button not found in grid, use auto-layout
+                        const autoX = (buttonIndex % gridCols) * 105;
+                        const autoY = Math.floor(buttonIndex / gridCols) * 30;
+                        rect = `{{${autoX}, ${autoY}}, {100, 25}}`;
+                    }
+                }
+                else {
+                    // Use auto-layout with detected grid dimensions
+                    const autoX = (buttonIndex % gridCols) * 105;
+                    const autoY = Math.floor(buttonIndex / gridCols) * 30;
+                    rect = `{{${autoX}, ${autoY}}, {100, 25}}`;
+                }
+                const buttonObj = {
+                    ButtonType: 0,
+                    DisplayText: button.label || 'Button',
+                    FontSize: button.style?.fontSize || 12,
+                    ID: `Button.${button.id}`,
+                    PanelObjectType: 'Button',
+                    Rect: rect ?? '{{0, 0}, {100, 25}}',
+                    Actions: [],
+                };
+                if (button.style?.backgroundColor) {
+                    buttonObj.DisplayColor = button.style.backgroundColor;
+                }
+                if (button.style?.fontWeight === 'bold') {
+                    buttonObj.DisplayImageWeight = 'FontWeightBold';
+                }
+                else {
+                    buttonObj.DisplayImageWeight = 'FontWeightRegular';
+                }
+                // Add actions - prefer semantic action if available
+                buttonObj.Actions = [this.createApplePanelsAction(button)];
+                return buttonObj;
+            });
+            panelsDict[panelId] = {
+                DisplayOrder: pageIndex + 1,
+                GlidingLensSize: 5,
+                HasTransientPosition: false,
+                HideHome: false,
+                HideMinimize: false,
+                HidePanelAdjustments: false,
+                HideSwitchDock: false,
+                HideSwitchDockContextualButtons: false,
+                HideTitlebar: false,
+                ID: panelId,
+                Name: page.name || 'Panel',
+                PanelObjects: panelObjects,
+                ProductSupportType: 'All',
+                Rect: '{{15, 75}, {425, 55}}',
+                ScanStyle: 0,
+                ShowPanelLocationString: 'CustomPanelList',
+                UsesPinnedResizing: false,
+            };
+        });
+        const panelsValue = Object.fromEntries(Object.entries(panelsDict).map(([key, value]) => [key, value]));
+        const panelDefinitions = {
+            Panels: panelsValue,
+            ToolbarOrdering: {
+                ToolbarIdentifiersAfterBasePanel: [],
+                ToolbarIdentifiersPriorToBasePanel: [],
+            },
+        };
+        const panelDefsContent = plist.build(panelDefinitions);
+        if (isSinglePlist) {
+            // Write single PanelDefinitions.plist file directly
+            const fs = getFs();
+            const path = getPath();
+            const dir = path.dirname(outputPath);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            writeTextToPath(outputPath, panelDefsContent);
+        }
+        else {
+            // Write into bundle structure
+            const path = getPath();
+            writeTextToPath(path.join(resourcesPath, 'PanelDefinitions.plist'), panelDefsContent);
+        }
+    }
+    createApplePanelsAction(button) {
+        // Use semantic action if available
+        if (button.semanticAction?.platformData?.applePanels) {
+            const applePanelsData = button.semanticAction.platformData.applePanels;
+            return {
+                ActionParam: normalizeActionParameters(applePanelsData.parameters),
+                ActionRecordedOffset: 0.0,
+                ActionType: applePanelsData.actionType,
+                ID: `Action.${button.id}`,
+            };
+        }
+        // Handle semantic actions without Apple Panels specific data
+        if (button.semanticAction) {
+            const intentStr = String(button.semanticAction.intent);
+            switch (intentStr) {
+                case 'NAVIGATE_TO':
+                    return {
+                        ActionParam: {
+                            PanelID: `USER.${button.semanticAction.targetId || button.targetPageId || ''}`,
+                        },
+                        ActionRecordedOffset: 0.0,
+                        ActionType: 'ActionOpenPanel',
+                        ID: `Action.${button.id}`,
+                    };
+                case 'SPEAK_TEXT':
+                case 'INSERT_TEXT':
+                    return {
+                        ActionParam: {
+                            CharString: button.semanticAction.text || button.message || button.label || '',
+                            isStickyKey: false,
+                        },
+                        ActionRecordedOffset: 0.0,
+                        ActionType: 'ActionPressKeyCharSequence',
+                        ID: `Action.${button.id}`,
+                    };
+                case 'SEND_KEYS':
+                    return {
+                        ActionParam: {
+                            CharString: button.semanticAction.text || '',
+                            isStickyKey: false,
+                        },
+                        ActionRecordedOffset: 0.0,
+                        ActionType: 'ActionSendKeys',
+                        ID: `Action.${button.id}`,
+                    };
+                default:
+                    // Fallback to speech for unknown semantic actions
+                    return {
+                        ActionParam: {
+                            CharString: button.semanticAction.fallback?.message || button.message || button.label || '',
+                            isStickyKey: false,
+                        },
+                        ActionRecordedOffset: 0.0,
+                        ActionType: 'ActionPressKeyCharSequence',
+                        ID: `Action.${button.id}`,
+                    };
+            }
+        }
+        // Default SPEAK action if no semantic action
+        return {
+            ActionParam: {
+                CharString: button.message || button.label || '',
+                isStickyKey: false,
+            },
+            ActionRecordedOffset: 0.0,
+            ActionType: 'ActionPressKeyCharSequence',
+            ID: `Action.${button.id}`,
+        };
+    }
+    /**
+     * Extract strings with metadata for aac-tools-platform compatibility
+     * Uses the generic implementation from BaseProcessor
+     */
+    extractStringsWithMetadata(filePath) {
+        return this.extractStringsWithMetadataGeneric(filePath);
+    }
+    /**
+     * Generate translated download for aac-tools-platform compatibility
+     * Uses the generic implementation from BaseProcessor
+     */
+    generateTranslatedDownload(filePath, translatedStrings, sourceStrings) {
+        return this.generateTranslatedDownloadGeneric(filePath, translatedStrings, sourceStrings);
+    }
+}
+export { ApplePanelsProcessor };