@willwade/aac-processors 0.0.30 → 0.1.0

package/dist/browser/processors/dotProcessor.js

@@ -0,0 +1,221 @@
+import { BaseProcessor, } from '../core/baseProcessor';
+import { AACTree, AACPage, AACButton, AACSemanticIntent } from '../core/treeStructure';
+// Removed unused import: FileProcessor
+import { ValidationFailureError, buildValidationResultFromMessage, } from '../validation/validationTypes';
+import { getBasename, readBinaryFromInput, readTextFromInput, writeBinaryToPath, writeTextToPath, encodeText, } from '../utils/io';
+class DotProcessor extends 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;
+        // We need to find nodes, but avoid matching the target of an edge which might look like a node definition
+        // e.g. A -> B [label="L"]  -- "B [label="L"]" looks like a node def
+        // Strategy: Find all edges, record them, and then "mask" them in the content to avoid false positives for nodes
+        let maskedContent = content;
+        let edgeMatch;
+        // Find all edge definitions
+        while ((edgeMatch = edgeRegex.exec(content)) !== null) {
+            const [fullMatch, 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 });
+            }
+            // Mask this edge in the content so we don't match it as a node
+            // We replace it with spaces to preserve indices if needed, but simple replacement is enough here
+            maskedContent = maskedContent.replace(fullMatch, ' '.repeat(fullMatch.length));
+        }
+        // Now find explicit node definitions in the masked content
+        // This regex matches: ID [label="LABEL"]
+        // We use a non-greedy match for the label content to handle escaped quotes if possible,
+        // but the previous regex `[^"]+` was too simple.
+        // Better regex for quoted string content: (?:[^"\\]|\\.)*
+        const nodeRegex = /"?([^"\s]+)"?\s*\[label="((?:[^"\\]|\\.)*)"\]/g;
+        let nodeMatch;
+        while ((nodeMatch = nodeRegex.exec(maskedContent)) !== null) {
+            const [, id, rawLabel] = nodeMatch;
+            // Unescape the label: replace \" with " and \\ with \
+            const label = rawLabel.replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+            // Only update if not already defined or if we want to override the implicit label
+            nodes.set(id, { id, label });
+        }
+        return { nodes: Array.from(nodes.values()), edges };
+    }
+    async extractTexts(filePathOrBuffer) {
+        await Promise.resolve();
+        const content = readTextFromInput(filePathOrBuffer);
+        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;
+    }
+    async loadIntoTree(filePathOrBuffer) {
+        await Promise.resolve();
+        const filename = typeof filePathOrBuffer === 'string' ? getBasename(filePathOrBuffer) : 'upload.dot';
+        const buffer = readBinaryFromInput(filePathOrBuffer);
+        const filesize = buffer.byteLength;
+        try {
+            const content = readTextFromInput(buffer);
+            if (!content || content.trim().length === 0) {
+                const validation = buildValidationResultFromMessage({
+                    filename,
+                    filesize,
+                    format: 'dot',
+                    message: 'DOT file is empty',
+                    type: 'content',
+                    description: 'DOT file content',
+                });
+                throw new ValidationFailureError('Empty DOT content', validation);
+            }
+            // Check for binary data (contains null bytes or non-printable characters)
+            const head = content.substring(0, 100);
+            for (let i = 0; i < head.length; i++) {
+                const code = head.charCodeAt(i);
+                if (code === 0 || (code >= 0 && code <= 8) || (code >= 14 && code <= 31)) {
+                    const validation = buildValidationResultFromMessage({
+                        filename,
+                        filesize,
+                        format: 'dot',
+                        message: 'DOT appears to be binary data',
+                        type: 'content',
+                        description: 'DOT file content',
+                    });
+                    throw new ValidationFailureError('Invalid DOT content', validation);
+                }
+            }
+            const { nodes, edges } = this.parseDotFile(content);
+            const tree = new AACTree();
+            tree.metadata.format = 'dot';
+            // Create pages for each node and add a self button representing the node label
+            for (const node of nodes) {
+                const page = new 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 AACButton({
+                    id: `${node.id}_self`,
+                    label: node.label,
+                    message: node.label,
+                    semanticAction: {
+                        intent: 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 AACButton({
+                        id: `nav_${edge.from}_${edge.to}`,
+                        label: edge.label || edge.to,
+                        message: '',
+                        targetPageId: edge.to,
+                    });
+                    fromPage.addButton(button);
+                }
+            }
+            return tree;
+        }
+        catch (error) {
+            if (error instanceof ValidationFailureError) {
+                throw error;
+            }
+            const validation = buildValidationResultFromMessage({
+                filename,
+                filesize,
+                format: 'dot',
+                message: error?.message || 'Failed to parse DOT file',
+                type: 'parse',
+                description: 'Parse DOT graph',
+            });
+            throw new ValidationFailureError('Failed to load DOT file', validation, error);
+        }
+    }
+    async processTexts(filePathOrBuffer, translations, outputPath) {
+        await Promise.resolve();
+        const content = readTextFromInput(filePathOrBuffer);
+        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 = encodeText(translatedContent || '');
+        writeBinaryToPath(outputPath, resultBuffer);
+        return resultBuffer;
+    }
+    async saveFromTree(tree, _outputPath) {
+        await Promise.resolve();
+        let dotContent = `digraph "${tree.metadata?.name || 'AACBoard'}" {\n`;
+        // Helper to escape DOT string
+        const escapeDotString = (str) => {
+            return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+        };
+        if (tree.metadata?.name) {
+            dotContent += `  label="${escapeDotString(tree.metadata.name)}";\n`;
+        }
+        // Add nodes
+        for (const pageId in tree.pages) {
+            const page = tree.pages[pageId];
+            dotContent += `  "${page.id}" [label="${escapeDotString(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="${escapeDotString(btn.label)}"]\n`;
+                }
+            });
+        }
+        dotContent += '}\n';
+        writeTextToPath(_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);
+    }
+}
+export { DotProcessor };