@willwade/aac-processors 0.0.3

package/dist/processors/dotProcessor.d.ts

@@ -0,0 +1,21 @@
+import { BaseProcessor, ProcessorOptions, ExtractStringsResult, TranslatedString, SourceString } from '../core/baseProcessor';
+import { AACTree } from '../core/treeStructure';
+declare class DotProcessor extends BaseProcessor {
+    constructor(options?: ProcessorOptions);
+    private parseDotFile;
+    extractTexts(filePathOrBuffer: string | Buffer): string[];
+    loadIntoTree(filePathOrBuffer: string | Buffer): AACTree;
+    processTexts(filePathOrBuffer: string | Buffer, translations: Map<string, string>, outputPath: string): Buffer;
+    saveFromTree(tree: AACTree, _outputPath: string): void;
+    /**
+     * Extract strings with metadata for aac-tools-platform compatibility
+     * Uses the generic implementation from BaseProcessor
+     */
+    extractStringsWithMetadata(filePath: string): Promise<ExtractStringsResult>;
+    /**
+     * Generate translated download for aac-tools-platform compatibility
+     * Uses the generic implementation from BaseProcessor
+     */
+    generateTranslatedDownload(filePath: string, translatedStrings: TranslatedString[], sourceStrings: SourceString[]): Promise<string>;
+}
+export { DotProcessor };

package/dist/processors/dotProcessor.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DotProcessor = void 0;
+const baseProcessor_1 = require("../core/baseProcessor");
+const treeStructure_1 = require("../core/treeStructure");
+// Removed unused import: FileProcessor
+const fs_1 = __importDefault(require("fs"));
+class DotProcessor extends baseProcessor_1.BaseProcessor {
+    constructor(options) {
+        super(options);
+    }
+    parseDotFile(content) {
+        const nodes = new Map();
+        const edges = [];
+        // Extract all edge statements using regex to handle single-line DOT files
+        const edgeRegex = /"?([^"\s]+)"?\s*->\s*"?([^"\s]+)"?(?:\s*\[label="([^"]+)"\])?/g;
+        const nodeRegex = /"?([^"\s]+)"?\s*\[label="([^"]+)"\]/g;
+        // Find all explicit node definitions
+        let nodeMatch;
+        while ((nodeMatch = nodeRegex.exec(content)) !== null) {
+            const [, id, label] = nodeMatch;
+            nodes.set(id, { id, label });
+        }
+        // Find all edge definitions
+        let edgeMatch;
+        while ((edgeMatch = edgeRegex.exec(content)) !== null) {
+            const [, from, to, label] = edgeMatch;
+            edges.push({ from, to, label });
+            // Add nodes if they don't exist (implicit definition)
+            if (!nodes.has(from)) {
+                nodes.set(from, { id: from, label: from });
+            }
+            if (!nodes.has(to)) {
+                nodes.set(to, { id: to, label: to });
+            }
+        }
+        return { nodes: Array.from(nodes.values()), edges };
+    }
+    extractTexts(filePathOrBuffer) {
+        const content = typeof filePathOrBuffer === 'string'
+            ? fs_1.default.readFileSync(filePathOrBuffer, 'utf8')
+            : filePathOrBuffer.toString('utf8');
+        const { nodes, edges } = this.parseDotFile(content);
+        const texts = [];
+        // Collect node labels
+        for (const node of nodes) {
+            texts.push(node.label);
+        }
+        // Collect edge labels
+        for (const edge of edges) {
+            if (edge.label) {
+                texts.push(edge.label);
+            }
+        }
+        return texts;
+    }
+    loadIntoTree(filePathOrBuffer) {
+        let content;
+        try {
+            content =
+                typeof filePathOrBuffer === 'string'
+                    ? fs_1.default.readFileSync(filePathOrBuffer, 'utf8')
+                    : filePathOrBuffer.toString('utf8');
+        }
+        catch (error) {
+            // Re-throw file system errors (like file not found)
+            if (typeof filePathOrBuffer === 'string') {
+                throw error;
+            }
+            // For buffer errors, return empty tree
+            return new treeStructure_1.AACTree();
+        }
+        // Check if content looks like text and is non-empty
+        if (!content || content.trim().length === 0) {
+            return new treeStructure_1.AACTree();
+        }
+        // Check for binary data (contains null bytes or non-printable characters) without control-regex
+        const head = content.substring(0, 100);
+        let hasControl = false;
+        for (let i = 0; i < head.length; i++) {
+            const code = head.charCodeAt(i);
+            if (code === 0 || (code >= 0 && code <= 8) || (code >= 14 && code <= 31) || code >= 127) {
+                hasControl = true;
+                break;
+            }
+        }
+        if (hasControl) {
+            return new treeStructure_1.AACTree();
+        }
+        const { nodes, edges } = this.parseDotFile(content);
+        const tree = new treeStructure_1.AACTree();
+        // Create pages for each node and add a self button representing the node label
+        for (const node of nodes) {
+            const page = new treeStructure_1.AACPage({
+                id: node.id,
+                name: node.label,
+                grid: [],
+                buttons: [],
+                parentId: null,
+            });
+            tree.addPage(page);
+            // Add a self button so single-node graphs yield one button
+            page.addButton(new treeStructure_1.AACButton({
+                id: `${node.id}_self`,
+                label: node.label,
+                message: node.label,
+                semanticAction: {
+                    intent: treeStructure_1.AACSemanticIntent.SPEAK_TEXT,
+                    text: node.label,
+                    fallback: { type: 'SPEAK', message: node.label },
+                },
+            }));
+        }
+        // Create navigation buttons based on edges
+        for (const edge of edges) {
+            const fromPage = tree.getPage(edge.from);
+            if (fromPage) {
+                const button = new treeStructure_1.AACButton({
+                    id: `nav_${edge.from}_${edge.to}`,
+                    label: edge.label || edge.to,
+                    message: '',
+                    targetPageId: edge.to,
+                });
+                fromPage.addButton(button);
+            }
+        }
+        return tree;
+    }
+    processTexts(filePathOrBuffer, translations, outputPath) {
+        const safeBuffer = Buffer.isBuffer(filePathOrBuffer)
+            ? filePathOrBuffer
+            : fs_1.default.readFileSync(filePathOrBuffer);
+        const content = safeBuffer.toString('utf8');
+        let translatedContent = content;
+        translations.forEach((translation, text) => {
+            if (typeof text === 'string' && typeof translation === 'string') {
+                // Escape special regex characters in the text
+                const escapedText = text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                const escapedTranslation = translation.replace(/\$/g, '$$$$'); // Escape $ in replacement
+                translatedContent = translatedContent.replace(new RegExp(`label="${escapedText}"`, 'g'), `label="${escapedTranslation}"`);
+            }
+        });
+        const resultBuffer = Buffer.from(translatedContent || '', 'utf8');
+        // Save to output path
+        fs_1.default.writeFileSync(outputPath, resultBuffer);
+        return resultBuffer;
+    }
+    saveFromTree(tree, _outputPath) {
+        let dotContent = 'digraph AACBoard {\n';
+        // Add nodes
+        for (const pageId in tree.pages) {
+            const page = tree.pages[pageId];
+            dotContent += `  "${page.id}" [label="${page.name}"]\n`;
+        }
+        // Add edges from navigation buttons (semantic intent or legacy targetPageId)
+        for (const pageId in tree.pages) {
+            const page = tree.pages[pageId];
+            page.buttons
+                .filter((btn) => {
+                const intentStr = String(btn.semanticAction?.intent);
+                return (intentStr === 'NAVIGATE_TO' || !!btn.targetPageId || !!btn.semanticAction?.targetId);
+            })
+                .forEach((btn) => {
+                const target = btn.semanticAction?.targetId || btn.targetPageId;
+                if (target) {
+                    dotContent += `  "${page.id}" -> "${target}" [label="${btn.label}"]\n`;
+                }
+            });
+        }
+        dotContent += '}\n';
+        fs_1.default.writeFileSync(_outputPath, dotContent);
+    }
+    /**
+     * Extract strings with metadata for aac-tools-platform compatibility
+     * Uses the generic implementation from BaseProcessor
+     */
+    async extractStringsWithMetadata(filePath) {
+        return this.extractStringsWithMetadataGeneric(filePath);
+    }
+    /**
+     * Generate translated download for aac-tools-platform compatibility
+     * Uses the generic implementation from BaseProcessor
+     */
+    async generateTranslatedDownload(filePath, translatedStrings, sourceStrings) {
+        return this.generateTranslatedDownloadGeneric(filePath, translatedStrings, sourceStrings);
+    }
+}
+exports.DotProcessor = DotProcessor;

package/dist/processors/excelProcessor.d.ts

@@ -0,0 +1,145 @@
+import { BaseProcessor, ExtractStringsResult, TranslatedString, SourceString } from '../core/baseProcessor';
+import { AACTree } from '../core/treeStructure';
+/**
+ * Excel Processor for converting AAC grids to Excel format
+ * Converts AAC tree structures to Excel workbooks with each page as a worksheet
+ * Supports visual styling, navigation links, and vocabulary analysis workflows
+ */
+export declare class ExcelProcessor extends BaseProcessor {
+    private static readonly NAVIGATION_BUTTONS;
+    /**
+     * Extract all text content from an Excel file
+     * @param filePathOrBuffer - Path to Excel file or Buffer containing Excel data
+     * @returns Array of all text content found in the Excel file
+     */
+    extractTexts(filePathOrBuffer: string | Buffer): string[];
+    /**
+     * Load Excel file into AACTree structure
+     * @param filePathOrBuffer - Path to Excel file or Buffer containing Excel data
+     * @returns AACTree representation of the Excel file
+     */
+    loadIntoTree(filePathOrBuffer: string | Buffer): AACTree;
+    /**
+     * Process texts in Excel file (apply translations)
+     * @param filePathOrBuffer - Path to Excel file or Buffer containing Excel data
+     * @param translations - Map of original text to translated text
+     * @param outputPath - Path where translated Excel file should be saved
+     * @returns Buffer containing the translated Excel file
+     */
+    processTexts(filePathOrBuffer: string | Buffer, translations: Map<string, string>, outputPath: string): Buffer;
+    /**
+     * Convert an AAC page to an Excel worksheet
+     * @param workbook - Excel workbook to add worksheet to
+     * @param page - AAC page to convert
+     * @param tree - Full AAC tree for navigation context
+     * @param usedNames - Set of already used worksheet names to avoid duplicates
+     */
+    private convertPageToWorksheet;
+    /**
+     * Calculate optimal grid dimensions for buttons
+     * @param page - AAC page to analyze
+     * @returns Object with rows and cols dimensions
+     */
+    private calculateGridDimensions;
+    /**
+     * Convert grid layout to Excel cells
+     * @param worksheet - Excel worksheet
+     * @param grid - 2D array of AAC buttons
+     * @param startRow - Starting row number
+     */
+    private convertGridLayout;
+    /**
+     * Convert button list to grid layout in Excel
+     * @param worksheet - Excel worksheet
+     * @param buttons - Array of AAC buttons
+     * @param rows - Number of rows in grid
+     * @param cols - Number of columns in grid
+     * @param startRow - Starting row number
+     */
+    private convertButtonsToGrid;
+    /**
+     * Set button data and formatting for an Excel cell
+     * @param worksheet - Excel worksheet
+     * @param button - AAC button to represent
+     * @param row - Excel row number
+     * @param col - Excel column number
+     */
+    private setButtonCell;
+    /**
+     * Apply AAC button styling to Excel cell
+     * @param cell - Excel cell to style
+     * @param style - AAC style object
+     */
+    private applyCellStyling;
+    /**
+     * Convert color string to ARGB format for Excel
+     * @param color - Color string (hex, rgb, etc.)
+     * @returns ARGB color string
+     */
+    private convertColorToArgb;
+    /**
+     * Add navigation link to cell for worksheet navigation
+     * @param cell - Excel cell to add link to
+     * @param targetPageId - Target page ID to link to
+     */
+    private addNavigationLink;
+    /**
+     * Set appropriate cell size for button representation
+     * @param worksheet - Excel worksheet
+     * @param row - Row number
+     * @param col - Column number
+     */
+    private setCellSize;
+    /**
+     * Add navigation row with standard AAC navigation buttons
+     * @param worksheet - Excel worksheet
+     * @param page - Current AAC page
+     * @param tree - Full AAC tree for navigation context
+     */
+    private addNavigationRow;
+    /**
+     * Apply general formatting to the worksheet
+     * @param worksheet - Excel worksheet
+     * @param rows - Number of content rows
+     * @param cols - Number of content columns
+     * @param startRow - Starting row for content
+     */
+    private formatWorksheet;
+    /**
+     * Sanitize worksheet name for Excel compatibility
+     * @param name - Original name
+     * @returns Sanitized name safe for Excel worksheet
+     */
+    private sanitizeWorksheetName;
+    /**
+     * Get a unique worksheet name by appending a number if needed
+     * @param name - Original name
+     * @param usedNames - Set of already used names (case-insensitive)
+     * @returns Unique worksheet name
+     */
+    private getUniqueWorksheetName;
+    /**
+     * Check if navigation row should be added (configurable feature)
+     * @returns True if navigation row should be added
+     */
+    private shouldAddNavigationRow;
+    /**
+     * Override saveFromTree to handle async nature of Excel operations
+     * Note: This method is async but maintains the sync interface for compatibility
+     */
+    saveFromTree(tree: AACTree, outputPath: string): Promise<void>;
+    /**
+     * Async version of saveFromTree for internal use
+     */
+    private saveFromTreeAsync;
+    /**
+     * Extract strings with metadata for aac-tools-platform compatibility
+     * Uses the generic implementation from BaseProcessor
+     */
+    extractStringsWithMetadata(filePath: string): Promise<ExtractStringsResult>;
+    /**
+     * Generate translated download for aac-tools-platform compatibility
+     * Uses the generic implementation from BaseProcessor
+     */
+    generateTranslatedDownload(filePath: string, translatedStrings: TranslatedString[], sourceStrings: SourceString[]): Promise<string>;
+}