@willwade/aac-processors 0.0.9 → 0.0.10

package/dist/utilities/screenshotConverter.js

@@ -0,0 +1,453 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScreenshotConverter = void 0;
+const treeStructure_1 = require("../core/treeStructure");
+const path_1 = __importDefault(require("path"));
+class ScreenshotConverter {
+    /**
+     * Parse filename to extract page hierarchy and names
+     * Examples:
+     * - "Home.png" → pageName: "Home", parentPath: ""
+     * - "Home->Fragen.png" → pageName: "Fragen", parentPath: "Home"
+     * - "Home->Settings->Profile.jpg" → pageName: "Profile", parentPath: "Home->Settings"
+     */
+    static parseFilename(filename, delimiter = '->') {
+        const baseName = path_1.default.parse(filename).name;
+        const parts = baseName.split(delimiter).map((part) => part.trim());
+        return {
+            pageName: parts[parts.length - 1] || baseName,
+            parentPath: parts.slice(0, -1).join(delimiter),
+        };
+    }
+    /**
+     * Build page hierarchy from an array of screenshots
+     */
+    static buildPageHierarchy(screenshots) {
+        const hierarchy = {};
+        const delimiter = this.defaultOptions.filenameDelimiter || '->';
+        // First pass: parse all filenames
+        screenshots.forEach((screenshot, index) => {
+            const { pageName, parentPath } = this.parseFilename(screenshot.filename, delimiter);
+            screenshot.pageName = pageName;
+            screenshot.parentPath = parentPath;
+            const pageId = `page_${index}`;
+            hierarchy[pageId] = {
+                page: screenshot,
+                children: [],
+                parent: undefined,
+            };
+        });
+        // Second pass: establish parent-child relationships
+        Object.entries(hierarchy).forEach(([pageId, entry]) => {
+            const parentPath = entry.page.parentPath;
+            if (parentPath) {
+                // Find parent by matching the full path
+                const parent = Object.values(hierarchy).find((h) => h.page.pageName === parentPath.split(delimiter).pop());
+                if (parent) {
+                    entry.parent = Object.keys(hierarchy).find((key) => hierarchy[key] === parent);
+                    parent.children.push(pageId);
+                }
+            }
+        });
+        return hierarchy;
+    }
+    static parseOCRText(ocrResult) {
+        const lines = ocrResult.split('\n').filter((line) => line.trim());
+        const cells = [];
+        const categories = new Set();
+        // Skip header metadata
+        const contentStart = lines.findIndex((line) => line.includes('ich möchte') && !line.includes('ich möchte	ich'));
+        if (contentStart === -1) {
+            // Try another approach if the first pattern doesn't match
+            const gridStart = lines.findIndex((line) => line.includes('ich möchte') && line.split(/\s+/).length > 2);
+            if (gridStart === -1)
+                return { rows: 6, cols: 11, cells: [], categories: [] };
+        }
+        // Find the line with the grid content (usually has tab-separated values)
+        const gridLineIndex = lines.findIndex((line) => line.includes('ich möchte') && line.includes('\t') && line.split(/\s+/).length > 5);
+        let rows = 6;
+        let cols = 11;
+        // If we found a properly formatted grid line
+        if (gridLineIndex !== -1) {
+            const gridLine = lines[gridLineIndex];
+            // Split by tabs to get individual cell values
+            const tokens = gridLine
+                .split('\t')
+                .map((t) => t.trim())
+                .filter((t) => t);
+            cols = Math.max(tokens.length, cols);
+            // Create first row from the main grid line
+            tokens.forEach((token, col) => {
+                const isCategory = this.isCategoryToken(token);
+                const isNavigation = this.isNavigationToken(token);
+                const isEmpty = !token || token === '...' || token === '';
+                if (isCategory)
+                    categories.add(token);
+                if (!isEmpty) {
+                    cells.push({
+                        text: token,
+                        row: 0,
+                        col,
+                        isCategory,
+                        isNavigation,
+                        isEmpty,
+                    });
+                }
+            });
+            // Process subsequent lines
+            let currentRow = 1;
+            for (let i = gridLineIndex + 1; i < lines.length; i++) {
+                const line = lines[i].trim();
+                if (!line)
+                    continue;
+                // Skip lines that look like headers or metadata
+                if (line.match(/^\d+:\d+/) || line.match(/[A-Z][a-z]{2},\s+\d+/) || line.includes('%'))
+                    continue;
+                // Skip duplicate "ich möchte" at start
+                if (line === 'ich möchte' && currentRow === 1) {
+                    currentRow = 0;
+                    continue;
+                }
+                const tokens = line
+                    .split('\t')
+                    .map((t) => t.trim())
+                    .filter((t) => t);
+                tokens.forEach((token, col) => {
+                    const isCategory = this.isCategoryToken(token);
+                    const isNavigation = this.isNavigationToken(token);
+                    const isEmpty = !token || token === '...' || token === '';
+                    if (isCategory)
+                        categories.add(token);
+                    if (!isEmpty) {
+                        cells.push({
+                            text: token,
+                            row: currentRow,
+                            col,
+                            isCategory,
+                            isNavigation,
+                            isEmpty,
+                        });
+                    }
+                });
+                currentRow++;
+                if (currentRow >= rows)
+                    break;
+            }
+        }
+        else {
+            // Fallback: simple whitespace parsing for unstructured OCR
+            let currentRow = 0;
+            lines.forEach((line, _lineIndex) => {
+                if (!line.trim())
+                    return;
+                // Skip metadata
+                if (line.includes('%') || line.match(/\d+:\d+/) || line.match(/[A-Z][a-z]{2},\s+\d+/))
+                    return;
+                const tokens = line.trim().split(/\s+/);
+                tokens.forEach((token, tokenIndex) => {
+                    if (tokenIndex >= cols)
+                        return; // Skip if beyond expected columns
+                    const isCategory = this.isCategoryToken(token);
+                    const isNavigation = this.isNavigationToken(token);
+                    const isEmpty = !token || token.trim() === '' || token === '...';
+                    if (isCategory)
+                        categories.add(token);
+                    if (!isEmpty) {
+                        cells.push({
+                            text: token,
+                            row: currentRow,
+                            col: tokenIndex,
+                            isCategory,
+                            isNavigation,
+                            isEmpty,
+                        });
+                    }
+                });
+                currentRow++;
+            });
+        }
+        // Auto-detect actual grid dimensions
+        if (cells.length > 0) {
+            rows = Math.max(...cells.map((c) => c.row)) + 1;
+            cols = Math.max(...cells.map((c) => c.col)) + 1;
+        }
+        return {
+            rows,
+            cols,
+            cells,
+            categories: Array.from(categories),
+        };
+    }
+    static isCategoryToken(token) {
+        const knownCategories = [
+            // English categories
+            'Questions',
+            'Meetings',
+            'Praise',
+            'Complaints',
+            'Phrases',
+            'Conversations',
+            'Verbs',
+            'People',
+            'Messages',
+            'Properties',
+            'Feelings',
+            'Actions',
+            'Activities',
+            'Food',
+            'Drink',
+            'Colors',
+            'Shapes',
+            'Settings',
+            'Home',
+            'Back',
+            'Next',
+            'Menu',
+            // German categories
+            'Fragen',
+            'Treffen',
+            'Lob',
+            'Beschwerde',
+            'Sprüche',
+            'Gespräche',
+            'Verben',
+            'Leute',
+            'Mitteilungen',
+            'Eigenschaften',
+            'Gefühle',
+            'Spielen',
+            'Multimedia',
+            'Essen',
+            'Trinken',
+            'Farben/Formen',
+        ];
+        // Check for known categories
+        if (knownCategories.includes(token)) {
+            return true;
+        }
+        // Check for common category patterns
+        const categoryPatterns = [
+            /.*Questions?$/,
+            /.*Category.*/,
+            /.*Menu.*/,
+            /.*Settings?$/,
+            /.*Options?$/,
+            /谈话/i, // Chinese
+            /質問/i, // Japanese
+            /preguntas/i, // Spanish
+        ];
+        return categoryPatterns.some((pattern) => pattern.test(token));
+    }
+    static isNavigationToken(token) {
+        const navTokens = [
+            // English
+            'Home',
+            'Back',
+            'Next',
+            'Previous',
+            'Menu',
+            'Settings',
+            'Exit',
+            'Close',
+            'OK',
+            'Cancel',
+            'Yes',
+            'No',
+            'Help',
+            'Search',
+            // German
+            'Home',
+            'Zurück',
+            'Weiter',
+            'Menü',
+            'Einstellungen',
+            'Beenden',
+            'Schließen',
+            'Hilfe',
+            'Suche',
+            // Navigation indicators
+            '←',
+            '→',
+            '↑',
+            '↓',
+            '◀',
+            '▶',
+            '▲',
+            '▼',
+        ];
+        return (navTokens.includes(token) || token === '←' || token === '→' || token === '↑' || token === '↓');
+    }
+    static convertToAACPage(screenshotPage, pageHierarchy, options) {
+        const opts = {
+            ...this.defaultOptions,
+            ...options,
+        };
+        const buttons = [];
+        // Convert cells to AAC buttons
+        screenshotPage.grid.cells.forEach((cell) => {
+            if (cell.isEmpty && !opts.includeEmptyCells)
+                return;
+            const button = new treeStructure_1.AACButton({
+                id: `cell_${cell.row}_${cell.col}`,
+                label: cell.text,
+                message: cell.text,
+                style: {
+                    backgroundColor: cell.isCategory ? '#4CAF50' : cell.isNavigation ? '#2196F3' : '#FFFFFF',
+                    fontColor: cell.isCategory || cell.isNavigation ? '#FFFFFF' : '#000000',
+                    borderColor: '#CCCCCC',
+                    borderWidth: 1,
+                },
+                semanticAction: this.createSemanticAction(cell, screenshotPage, pageHierarchy, opts),
+                x: cell.col,
+                y: cell.row,
+            });
+            buttons.push(button);
+        });
+        return new treeStructure_1.AACPage({
+            id: screenshotPage.pageName || 'screenshot_page',
+            name: screenshotPage.pageTitle || screenshotPage.pageName || 'Screenshot Page',
+            buttons,
+            grid: {
+                columns: screenshotPage.grid.cols,
+                rows: screenshotPage.grid.rows,
+            },
+            style: {
+                backgroundColor: '#F5F5F5',
+            },
+            parentId: null,
+        });
+    }
+    static createSemanticAction(cell, screenshotPage, pageHierarchy, options) {
+        if (cell.isEmpty)
+            return undefined;
+        const _opts = {
+            ...this.defaultOptions,
+            ...options,
+        };
+        if (cell.isCategory) {
+            // Try to find target page in hierarchy based on category name
+            let targetId = `category_${cell.text.toLowerCase().replace(/\s+/g, '_')}`;
+            if (pageHierarchy) {
+                // Look for a page that matches this category
+                const matchingPage = Object.values(pageHierarchy).find((h) => h.page.pageName?.toLowerCase() === cell.text.toLowerCase());
+                if (matchingPage) {
+                    targetId = matchingPage.page.pageName || targetId;
+                }
+            }
+            return {
+                category: treeStructure_1.AACSemanticCategory.NAVIGATION,
+                intent: treeStructure_1.AACSemanticIntent.NAVIGATE_TO,
+                targetId,
+                parameters: { category: cell.text },
+            };
+        }
+        if (cell.isNavigation) {
+            const text = cell.text.toLowerCase();
+            // Home navigation
+            if (text === 'home' || text === '⌂') {
+                return {
+                    category: treeStructure_1.AACSemanticCategory.NAVIGATION,
+                    intent: treeStructure_1.AACSemanticIntent.GO_HOME,
+                };
+            }
+            // Back navigation
+            if (text === 'back' || text === 'zurück' || text === '←' || text === '◀') {
+                return {
+                    category: treeStructure_1.AACSemanticCategory.NAVIGATION,
+                    intent: treeStructure_1.AACSemanticIntent.GO_BACK,
+                };
+            }
+            // Next/forward navigation
+            if (text === 'next' || text === 'weiter' || text === '→' || text === '▶') {
+                // If we have hierarchy, navigate to parent
+                if (pageHierarchy && screenshotPage.parentPath) {
+                    const parentId = Object.keys(pageHierarchy).find((key) => pageHierarchy[key].page.pageName === screenshotPage.parentPath?.split('->').pop());
+                    if (parentId) {
+                        return {
+                            category: treeStructure_1.AACSemanticCategory.NAVIGATION,
+                            intent: treeStructure_1.AACSemanticIntent.NAVIGATE_TO,
+                            targetId: parentId,
+                        };
+                    }
+                }
+                return {
+                    category: treeStructure_1.AACSemanticCategory.NAVIGATION,
+                    intent: treeStructure_1.AACSemanticIntent.NAVIGATE_TO,
+                    targetId: 'next_page',
+                    parameters: { direction: 'next' },
+                };
+            }
+            // Menu navigation
+            if (text === 'menu' || text === 'menü') {
+                return {
+                    category: treeStructure_1.AACSemanticCategory.NAVIGATION,
+                    intent: treeStructure_1.AACSemanticIntent.NAVIGATE_TO,
+                    targetId: 'main_menu',
+                };
+            }
+        }
+        // Default to speaking the text
+        return {
+            category: treeStructure_1.AACSemanticCategory.COMMUNICATION,
+            intent: treeStructure_1.AACSemanticIntent.SPEAK_IMMEDIATE,
+            text: cell.text,
+            richText: {
+                text: cell.text,
+            },
+        };
+    }
+    static convertToAACTree(screenshotPages, options) {
+        const opts = { ...this.defaultOptions, ...options };
+        const tree = new treeStructure_1.AACTree();
+        // Build page hierarchy
+        const pageHierarchy = this.buildPageHierarchy(screenshotPages);
+        // Set metadata on tree
+        tree.version = '1.0';
+        tree.metadata = {
+            name: 'Screenshot Conversion',
+            author: 'AAC Processors',
+            description: 'Converted from screenshot images',
+            language: opts.language,
+        };
+        // Convert each screenshot page to AAC page
+        screenshotPages.forEach((screenshotPage, index) => {
+            const page = this.convertToAACPage(screenshotPage, pageHierarchy, opts);
+            // Ensure unique ID by using page name if available
+            if (screenshotPage.pageName) {
+                page.id = this.sanitizePageId(screenshotPage.pageName);
+            }
+            else {
+                page.id = `screenshot_page_${index}`;
+            }
+            tree.addPage(page);
+        });
+        // Set root page to the one with no parent
+        const rootPage = Object.entries(pageHierarchy).find(([_, entry]) => !entry.parent);
+        if (rootPage) {
+            const rootPageId = this.sanitizePageId(rootPage[1].page.pageName || 'home');
+            if (tree.pages[rootPageId]) {
+                tree.rootId = rootPageId;
+            }
+        }
+        return tree;
+    }
+    static sanitizePageId(pageName) {
+        return pageName
+            .toLowerCase()
+            .replace(/[^a-z0-9]/g, '_')
+            .replace(/_+/g, '_')
+            .replace(/^_|_$/g, '');
+    }
+}
+exports.ScreenshotConverter = ScreenshotConverter;
+ScreenshotConverter.defaultOptions = {
+    includeEmptyCells: false,
+    generateIds: true,
+    targetPlatform: 'grid3',
+    language: 'en',
+    fallbackCategory: 'General',
+    filenameDelimiter: '->',
+};

package/dist/validation/baseValidator.d.ts

@@ -0,0 +1,80 @@
+import { ValidationResult, ValidationCheck, ValidationOptions } from './validationTypes';
+/**
+ * Base class for all format validators
+ * Provides the check-based validation system
+ */
+export declare abstract class BaseValidator {
+    protected _errors: number;
+    protected _warnings: number;
+    protected _checks: ValidationCheck[];
+    protected _sub_checks: ValidationResult[];
+    protected _blocked: boolean;
+    protected _options: ValidationOptions;
+    constructor(options?: ValidationOptions);
+    /**
+     * Reset validator state
+     */
+    protected reset(): void;
+    /**
+     * Add a validation check that will be executed
+     * @param type - Category of the check
+     * @param description - Human-readable description
+     * @param checkFn - Async function that performs the check
+     */
+    protected add_check(type: string, description: string, checkFn: () => Promise<void>): Promise<void>;
+    /**
+     * Add a synchronous validation check
+     */
+    protected add_check_sync(type: string, description: string, checkFn: () => void): void;
+    /**
+     * Throw a validation error
+     * @param message - Error message
+     * @param blocker - If true, stop further validation
+     */
+    protected err(message: string, blocker?: boolean): never;
+    /**
+     * Add a warning to the last check
+     * @param message - Warning message
+     */
+    protected warn(message: string): void;
+    /**
+     * Get the current error count
+     */
+    get errors(): number;
+    /**
+     * Get the current warning count
+     */
+    get warnings(): number;
+    /**
+     * Get all checks performed so far
+     */
+    get checks(): ValidationCheck[];
+    /**
+     * Get sub-validation results
+     */
+    get sub_checks(): ValidationResult[];
+    /**
+     * Check if validation has been blocked
+     */
+    get isBlocked(): boolean;
+    /**
+     * Build the final validation result
+     */
+    protected buildResult(filename: string, filesize: number, format: string): ValidationResult;
+    /**
+     * Abstract method - each validator must implement this
+     * @param content - The content to validate (can be string, buffer, object, etc.)
+     * @param filename - Name of the file being validated
+     * @param filesize - Size of the file in bytes
+     */
+    abstract validate(content: any, filename: string, filesize: number): Promise<ValidationResult>;
+    /**
+     * Static helper to validate from file path
+     * Must be implemented by subclasses if they support file-based validation
+     */
+    static validateFile(_filePath: string): Promise<ValidationResult>;
+    /**
+     * Static helper to identify if content is this validator's format
+     */
+    static identifyFormat(_content: any, _filename: string): Promise<boolean>;
+}

package/dist/validation/baseValidator.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseValidator = void 0;
+const validationTypes_1 = require("./validationTypes");
+/**
+ * Base class for all format validators
+ * Provides the check-based validation system
+ */
+class BaseValidator {
+    constructor(options = {}) {
+        this._errors = 0;
+        this._warnings = 0;
+        this._checks = [];
+        this._sub_checks = [];
+        this._blocked = false;
+        this._options = {
+            includeWarnings: options.includeWarnings ?? true,
+            stopOnBlocker: options.stopOnBlocker ?? true,
+            customRules: options.customRules || [],
+        };
+        this.reset();
+    }
+    /**
+     * Reset validator state
+     */
+    reset() {
+        this._errors = 0;
+        this._warnings = 0;
+        this._checks = [];
+        this._sub_checks = [];
+        this._blocked = false;
+    }
+    /**
+     * Add a validation check that will be executed
+     * @param type - Category of the check
+     * @param description - Human-readable description
+     * @param checkFn - Async function that performs the check
+     */
+    async add_check(type, description, checkFn) {
+        // Skip if blocked by a previous error
+        if (this._blocked && this._options.stopOnBlocker) {
+            return;
+        }
+        const checkObj = {
+            type,
+            description,
+            valid: true,
+        };
+        this._checks.push(checkObj);
+        try {
+            await checkFn();
+        }
+        catch (e) {
+            if (e instanceof validationTypes_1.ValidationError) {
+                this._errors++;
+                checkObj.valid = false;
+                checkObj.error = e.message;
+                if (e.blocker) {
+                    this._blocked = true;
+                }
+            }
+            else {
+                // Re-throw non-ValidationError exceptions
+                throw e;
+            }
+        }
+    }
+    /**
+     * Add a synchronous validation check
+     */
+    add_check_sync(type, description, checkFn) {
+        // Convert sync to async for consistency
+        // eslint-disable-next-line @typescript-eslint/require-await
+        void this.add_check(type, description, async () => checkFn());
+    }
+    /**
+     * Throw a validation error
+     * @param message - Error message
+     * @param blocker - If true, stop further validation
+     */
+    err(message, blocker = false) {
+        throw new validationTypes_1.ValidationError(message, blocker);
+    }
+    /**
+     * Add a warning to the last check
+     * @param message - Warning message
+     */
+    warn(message) {
+        if (!this._options.includeWarnings) {
+            return;
+        }
+        this._warnings++;
+        const lastCheck = this._checks[this._checks.length - 1];
+        if (lastCheck) {
+            lastCheck.warnings = lastCheck.warnings || [];
+            lastCheck.warnings.push(message);
+        }
+    }
+    /**
+     * Get the current error count
+     */
+    get errors() {
+        return this._errors;
+    }
+    /**
+     * Get the current warning count
+     */
+    get warnings() {
+        return this._warnings;
+    }
+    /**
+     * Get all checks performed so far
+     */
+    get checks() {
+        return this._checks;
+    }
+    /**
+     * Get sub-validation results
+     */
+    get sub_checks() {
+        return this._sub_checks;
+    }
+    /**
+     * Check if validation has been blocked
+     */
+    get isBlocked() {
+        return this._blocked;
+    }
+    /**
+     * Build the final validation result
+     */
+    buildResult(filename, filesize, format) {
+        return {
+            filename,
+            filesize,
+            format,
+            valid: this._errors === 0,
+            errors: this._errors,
+            warnings: this._warnings,
+            results: this._checks,
+            sub_results: this._sub_checks.length > 0 ? this._sub_checks : undefined,
+        };
+    }
+    /**
+     * Static helper to validate from file path
+     * Must be implemented by subclasses if they support file-based validation
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    static async validateFile(_filePath) {
+        throw new Error('validateFile must be implemented by subclass');
+    }
+    /**
+     * Static helper to identify if content is this validator's format
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    static async identifyFormat(_content, _filename) {
+        throw new Error('identifyFormat must be implemented by subclass');
+    }
+}
+exports.BaseValidator = BaseValidator;