@willwade/aac-processors 0.0.8 → 0.0.10

package/dist/validation/gridsetValidator.d.ts

@@ -0,0 +1,36 @@
+import { BaseValidator } from './baseValidator';
+import { ValidationResult } from './validationTypes';
+/**
+ * Validator for Grid3/Smartbox Gridset files (.gridset, .gridsetx)
+ */
+export declare class GridsetValidator extends BaseValidator {
+    constructor();
+    /**
+     * Validate a Gridset file from disk
+     */
+    static validateFile(filePath: string): Promise<ValidationResult>;
+    /**
+     * Check if content is Gridset format
+     */
+    static identifyFormat(content: any, filename: string): Promise<boolean>;
+    /**
+     * Main validation method
+     */
+    validate(content: Buffer | Uint8Array, filename: string, filesize: number): Promise<ValidationResult>;
+    /**
+     * Validate Gridset structure
+     */
+    private validateGridsetStructure;
+    /**
+     * Validate a single page
+     */
+    private validatePage;
+    /**
+     * Validate a single cell
+     */
+    private validateCell;
+    /**
+     * Validate color format (Grid3 uses ARGB format)
+     */
+    private isValidGrid3Color;
+}

package/dist/validation/gridsetValidator.js

@@ -0,0 +1,288 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridsetValidator = void 0;
+/* eslint-disable @typescript-eslint/require-await */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const xml2js = __importStar(require("xml2js"));
+const baseValidator_1 = require("./baseValidator");
+/**
+ * Validator for Grid3/Smartbox Gridset files (.gridset, .gridsetx)
+ */
+class GridsetValidator extends baseValidator_1.BaseValidator {
+    constructor() {
+        super();
+    }
+    /**
+     * Validate a Gridset file from disk
+     */
+    static async validateFile(filePath) {
+        const validator = new GridsetValidator();
+        const content = fs.readFileSync(filePath);
+        const stats = fs.statSync(filePath);
+        return validator.validate(content, path.basename(filePath), stats.size);
+    }
+    /**
+     * Check if content is Gridset format
+     */
+    static async identifyFormat(content, filename) {
+        const name = filename.toLowerCase();
+        if (name.endsWith('.gridset') || name.endsWith('.gridsetx')) {
+            return true;
+        }
+        // Try to parse as XML and check for gridset structure
+        try {
+            const contentStr = Buffer.isBuffer(content) ? content.toString('utf-8') : content;
+            const parser = new xml2js.Parser();
+            const result = await parser.parseStringPromise(contentStr);
+            return result && (result.gridset || result.Gridset);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Main validation method
+     */
+    async validate(content, filename, filesize) {
+        this.reset();
+        const isEncrypted = filename.toLowerCase().endsWith('.gridsetx');
+        // eslint-disable-next-line @typescript-eslint/require-await
+        await this.add_check('filename', 'file extension', async () => {
+            if (!filename.match(/\.gridsetx?$/)) {
+                this.warn('filename should end with .gridset or .gridsetx');
+            }
+        });
+        // For encrypted .gridsetx files, we can't validate the content
+        if (isEncrypted) {
+            // eslint-disable-next-line @typescript-eslint/require-await
+            await this.add_check('encrypted_format', 'encrypted gridsetx file', async () => {
+                this.warn('gridsetx files are encrypted and cannot be fully validated');
+            });
+            return this.buildResult(filename, filesize, 'gridset');
+        }
+        let xmlObj = null;
+        await this.add_check('xml_parse', 'valid XML', async () => {
+            try {
+                const parser = new xml2js.Parser();
+                const contentStr = content.toString('utf-8');
+                xmlObj = await parser.parseStringPromise(contentStr);
+            }
+            catch (e) {
+                this.err(`Failed to parse XML: ${e.message}`, true);
+            }
+        });
+        if (!xmlObj) {
+            return this.buildResult(filename, filesize, 'gridset');
+        }
+        // eslint-disable-next-line @typescript-eslint/require-await
+        await this.add_check('xml_structure', 'gridset root element', async () => {
+            if (!xmlObj.gridset && !xmlObj.Gridset) {
+                this.err('missing root gridset element', true);
+            }
+        });
+        const gridset = xmlObj.gridset || xmlObj.Gridset;
+        if (gridset) {
+            await this.validateGridsetStructure(gridset, filename, content);
+        }
+        return this.buildResult(filename, filesize, 'gridset');
+    }
+    /**
+     * Validate Gridset structure
+     */
+    async validateGridsetStructure(gridset, _filename, _content) {
+        // Check for required elements
+        await this.add_check('gridset_id', 'gridset id', async () => {
+            const id = gridset.$.id || gridset.$.Id;
+            if (!id) {
+                this.warn('gridset should have an id attribute');
+            }
+        });
+        await this.add_check('gridset_name', 'gridset name', async () => {
+            const name = gridset.$.name || gridset.$.Name || gridset.name?.[0];
+            if (!name) {
+                this.warn('gridset should have a name attribute or element');
+            }
+        });
+        // Check for pages
+        await this.add_check('pages', 'pages element', async () => {
+            if (!gridset.pages && !gridset.Pages) {
+                this.err('gridset must have a pages element');
+            }
+            else {
+                const pages = gridset.pages || gridset.Pages;
+                if (!pages[0] || !Array.isArray(pages[0].page)) {
+                    this.warn('pages should contain at least one page element');
+                }
+            }
+        });
+        // Validate individual pages
+        const pages = gridset.pages?.[0] || gridset.Pages?.[0];
+        if (pages && Array.isArray(pages.page)) {
+            await this.add_check('page_count', 'page count', async () => {
+                if (pages.page.length === 0) {
+                    this.err('gridset must contain at least one page');
+                }
+            });
+            for (let i = 0; i < Math.min(pages.page.length, 10); i++) {
+                // Limit to first 10 pages to avoid excessive validation
+                const page = pages.page[i];
+                await this.validatePage(page, i);
+            }
+        }
+        // Check for fixedCellSize
+        await this.add_check('fixed_cell_size', 'fixedCellSize element', async () => {
+            const fixedSize = gridset.fixedCellSize || gridset.FixedCellSize;
+            if (!fixedSize) {
+                this.warn('gridset should have a fixedCellSize element for consistency');
+            }
+            else {
+                // Validate fixedCellSize structure
+                const size = fixedSize[0];
+                if (size) {
+                    const width = size.$.width || size.$.Width;
+                    const height = size.$.height || size.$.Height;
+                    if (!width || !height) {
+                        this.warn('fixedCellSize should have both width and height attributes');
+                    }
+                    else if (isNaN(parseInt(width)) || isNaN(parseInt(height))) {
+                        this.err('fixedCellSize width and height must be valid numbers');
+                    }
+                }
+            }
+        });
+        // Check for styles
+        await this.add_check('styles', 'styles element', async () => {
+            const styles = gridset.styles || gridset.Styles;
+            if (!styles) {
+                this.warn('gridset should have a styles element for consistent formatting');
+            }
+        });
+    }
+    /**
+     * Validate a single page
+     */
+    async validatePage(page, index) {
+        await this.add_check(`page[${index}]_id`, `page ${index} id`, async () => {
+            const id = page.$.id || page.$.Id;
+            if (!id) {
+                this.err(`page at index ${index} is missing id attribute`);
+            }
+        });
+        await this.add_check(`page[${index}]_name`, `page ${index} name`, async () => {
+            const name = page.$.name || page.$.Name || page.name?.[0];
+            if (!name) {
+                this.warn(`page ${index} should have a name`);
+            }
+        });
+        // Check for cells
+        await this.add_check(`page[${index}]_cells`, `page ${index} cells`, async () => {
+            const cells = page.cells || page.Cells;
+            if (!cells) {
+                this.warn(`page ${index} should have a cells element`);
+            }
+            else {
+                const cellArray = cells[0]?.cell || cells[0]?.Cell;
+                if (!cellArray || !Array.isArray(cellArray) || cellArray.length === 0) {
+                    this.warn(`page ${index} should contain at least one cell`);
+                }
+            }
+        });
+        // Validate cells if present
+        const cells = page.cells?.[0] || page.Cells?.[0];
+        if (cells) {
+            const cellArray = cells.cell || cells.Cell;
+            if (Array.isArray(cellArray) && cellArray.length > 0) {
+                // Sample a few cells to validate
+                const sampleSize = Math.min(cellArray.length, 5);
+                for (let i = 0; i < sampleSize; i++) {
+                    await this.validateCell(cellArray[i], index, i);
+                }
+            }
+        }
+    }
+    /**
+     * Validate a single cell
+     */
+    async validateCell(cell, pageIdx, cellIdx) {
+        await this.add_check(`page[${pageIdx}]_cell[${cellIdx}]_id`, `cell id`, async () => {
+            const id = cell.$.id || cell.$.Id;
+            if (!id) {
+                this.warn(`cell ${cellIdx} on page ${pageIdx} is missing id attribute`);
+            }
+        });
+        await this.add_check(`page[${pageIdx}]_cell[${cellIdx}]_content`, `cell content`, async () => {
+            const label = cell.$.label || cell.$.Label;
+            const image = cell.$.image || cell.$.Image;
+            if (!label && !image) {
+                this.warn(`cell ${cellIdx} on page ${pageIdx} should have a label or image`);
+            }
+        });
+        // Check for color attributes
+        const backgroundColor = cell.$.backgroundColor || cell.$.BackgroundColor;
+        const _color = cell.$.color || cell.$.Color;
+        if (backgroundColor) {
+            await this.add_check(`page[${pageIdx}]_cell[${cellIdx}]_bg_color`, `cell background color`, async () => {
+                // Grid3 colors can be in various formats: named colors, hex, ARGB
+                // We just check it's not empty
+                if (backgroundColor.length === 0) {
+                    this.warn(`cell ${cellIdx} has empty background color`);
+                }
+            });
+        }
+        // Check for valid jump references
+        const jump = cell.$.jump || cell.$.Jump;
+        if (jump) {
+            await this.add_check(`page[${pageIdx}]_cell[${cellIdx}]_jump`, `cell jump reference`, async () => {
+                if (typeof jump !== 'string' || jump.length === 0) {
+                    this.warn(`cell ${cellIdx} has invalid jump reference`);
+                }
+            });
+        }
+    }
+    /**
+     * Validate color format (Grid3 uses ARGB format)
+     */
+    isValidGrid3Color(color) {
+        if (!color || color.length === 0)
+            return false;
+        // Named colors are valid
+        if (/^[a-zA-Z]+$/.test(color))
+            return true;
+        // ARGB format: #AARRGGBB or #RRGGBB
+        if (color.startsWith('#')) {
+            return color.length === 7 || color.length === 9;
+        }
+        // RGB format: rgb(r,g,b) or rgba(r,g,b,a)
+        if (color.startsWith('rgb')) {
+            return true; // Simplified check
+        }
+        return false;
+    }
+}
+exports.GridsetValidator = GridsetValidator;

package/dist/validation/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Validation system for AAC processors
+ * Provides consistent validation across all supported formats
+ */
+export { ValidationError, ValidationCheck, ValidationResult, ValidationOptions, ValidationRule, } from './validationTypes';
+export { BaseValidator } from './baseValidator';
+export { ObfValidator } from './obfValidator';
+export { GridsetValidator } from './gridsetValidator';
+export { SnapValidator } from './snapValidator';
+export { TouchChatValidator } from './touchChatValidator';
+import { BaseValidator } from './baseValidator';
+export declare function getValidatorForFormat(format: string): BaseValidator | null;
+export declare function getValidatorForFile(filename: string): BaseValidator | null;

package/dist/validation/index.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Validation system for AAC processors
+ * Provides consistent validation across all supported formats
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TouchChatValidator = exports.SnapValidator = exports.GridsetValidator = exports.ObfValidator = exports.BaseValidator = exports.ValidationError = void 0;
+exports.getValidatorForFormat = getValidatorForFormat;
+exports.getValidatorForFile = getValidatorForFile;
+var validationTypes_1 = require("./validationTypes");
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return validationTypes_1.ValidationError; } });
+var baseValidator_1 = require("./baseValidator");
+Object.defineProperty(exports, "BaseValidator", { enumerable: true, get: function () { return baseValidator_1.BaseValidator; } });
+// Individual format validators
+var obfValidator_1 = require("./obfValidator");
+Object.defineProperty(exports, "ObfValidator", { enumerable: true, get: function () { return obfValidator_1.ObfValidator; } });
+var gridsetValidator_1 = require("./gridsetValidator");
+Object.defineProperty(exports, "GridsetValidator", { enumerable: true, get: function () { return gridsetValidator_1.GridsetValidator; } });
+var snapValidator_1 = require("./snapValidator");
+Object.defineProperty(exports, "SnapValidator", { enumerable: true, get: function () { return snapValidator_1.SnapValidator; } });
+var touchChatValidator_1 = require("./touchChatValidator");
+Object.defineProperty(exports, "TouchChatValidator", { enumerable: true, get: function () { return touchChatValidator_1.TouchChatValidator; } });
+/**
+ * Main validator factory
+ * Returns the appropriate validator for a given format
+ */
+const obfValidator_2 = require("./obfValidator");
+const gridsetValidator_2 = require("./gridsetValidator");
+const snapValidator_2 = require("./snapValidator");
+const touchChatValidator_2 = require("./touchChatValidator");
+function getValidatorForFormat(format) {
+    switch (format.toLowerCase()) {
+        case 'obf':
+        case 'obz':
+            return new obfValidator_2.ObfValidator();
+        case 'gridset':
+        case 'gridsetx':
+            return new gridsetValidator_2.GridsetValidator();
+        case 'snap':
+        case 'spb':
+        case 'sps':
+            return new snapValidator_2.SnapValidator();
+        case 'touchchat':
+        case 'ce':
+            return new touchChatValidator_2.TouchChatValidator();
+        default:
+            return null;
+    }
+}
+function getValidatorForFile(filename) {
+    const ext = filename.toLowerCase().split('.').pop();
+    if (!ext)
+        return null;
+    switch (ext) {
+        case 'obf':
+        case 'obz':
+            return new obfValidator_2.ObfValidator();
+        case 'gridset':
+        case 'gridsetx':
+            return new gridsetValidator_2.GridsetValidator();
+        case 'spb':
+        case 'sps':
+            return new snapValidator_2.SnapValidator();
+        case 'ce':
+            return new touchChatValidator_2.TouchChatValidator();
+        default:
+            return null;
+    }
+}

package/dist/validation/obfValidator.d.ts

@@ -0,0 +1,44 @@
+import { BaseValidator } from './baseValidator';
+import { ValidationResult } from './validationTypes';
+/**
+ * Validator for Open Board Format (OBF/OBZ) files
+ */
+export declare class ObfValidator extends BaseValidator {
+    constructor();
+    /**
+     * Validate an OBF file from disk
+     */
+    static validateFile(filePath: string): Promise<ValidationResult>;
+    /**
+     * Check if content is OBF format
+     */
+    static identifyFormat(content: any, filename: string): Promise<boolean>;
+    /**
+     * Main validation method
+     */
+    validate(content: Buffer | Uint8Array, filename: string, filesize: number): Promise<ValidationResult>;
+    /**
+     * Validate OBF content
+     */
+    private validateObf;
+    /**
+     * Validate OBZ (zip) content
+     */
+    private validateObz;
+    /**
+     * Validate OBF board structure
+     */
+    private validateBoardStructure;
+    /**
+     * Validate a single button
+     */
+    private validateButton;
+    /**
+     * Validate OBZ structure
+     */
+    private validateObzStructure;
+    /**
+     * Validate manifest structure
+     */
+    private validateManifest;
+}