@willwade/aac-processors 0.2.20 → 0.3.0

package/dist/validation/gridsetValidator.js

@@ -55,12 +55,12 @@ class GridsetValidator extends baseValidator_1.BaseValidator {
         if (name.endsWith('.gridset') || name.endsWith('.gridsetx')) {
             return true;
         }
-        // Try to parse as XML and check for gridset structure
+        // Try to parse as XML and check for a Grid 3 <Grid> root element
         try {
             const contentStr = typeof content === 'string' ? content : (0, io_1.decodeText)((0, io_1.toUint8Array)(content));
             const parser = new xml2js.Parser();
             const result = await parser.parseStringPromise(contentStr);
-            return result && (result.gridset || result.Gridset);
+            return !!(result && (result.Grid || result.grid));
         }
         catch {
             return false;
@@ -104,7 +104,7 @@ class GridsetValidator extends baseValidator_1.BaseValidator {
         return content[0] === 0x50 && content[1] === 0x4b && content[2] === 0x03 && content[3] === 0x04;
     }
     /**
-     * Validate a single XML file (legacy or exploded format)
+     * Validate a single grid.xml file (exploded/non-zip format)
      */
     async validateSingleXml(content, filename, _filesize) {
         let xmlObj = null;
@@ -120,49 +120,57 @@ class GridsetValidator extends baseValidator_1.BaseValidator {
         });
         if (!xmlObj)
             return;
-        await this.add_check('xml_structure', 'gridset root element', async () => {
-            if (!xmlObj.gridset && !xmlObj.Gridset) {
-                this.err('missing root gridset element', true);
+        await this.add_check('xml_structure', 'Grid root element', async () => {
+            if (!xmlObj.Grid && !xmlObj.grid) {
+                this.err('missing root Grid element', true);
             }
         });
-        const gridset = xmlObj.gridset || xmlObj.Gridset;
-        if (gridset) {
-            await this.validateGridsetStructure(gridset, filename, content);
+        const grid = xmlObj.Grid || xmlObj.grid;
+        if (grid) {
+            await this.validateGridStructure(grid, filename);
         }
     }
     /**
      * Validate a ZIP archive (.gridset)
+     *
+     * Real Grid 3 archives do NOT contain a top-level gridset.xml. The required
+     * structure is: Settings0/settings.xml + FileMap.xml + Grids/<name>/grid.xml
+     * (+ optional Styles, images, thumbnails).
      */
-    async validateZipArchive(content, filename, _filesize) {
+    async validateZipArchive(content, _filename, _filesize) {
         const zip = await this._options.zipAdapter(content);
         const entries = zip.listFiles();
-        // Check for gridset.xml (required)
-        await this.add_check('gridset_xml_presence', 'gridset.xml presence', async () => {
-            const gridsetEntry = entries.find((e) => e.toLowerCase() === 'gridset.xml');
-            if (!gridsetEntry) {
-                this.err('Missing gridset.xml in archive', true);
+        // --- Required: at least one Grids/<name>/grid.xml ---
+        const gridEntries = entries.filter((e) => /^Grids\/.+\/grid\.xml$/i.test(e));
+        await this.add_check('grid_xml_presence', 'Grids/*/grid.xml presence', async () => {
+            if (gridEntries.length === 0) {
+                this.err('No Grids/<name>/grid.xml found in archive', true);
             }
-            else {
+        });
+        // Validate the <Grid> structure of each grid.xml (sample up to 5)
+        for (let i = 0; i < Math.min(gridEntries.length, 5); i++) {
+            const entry = gridEntries[i];
+            await this.add_check(`grid_xml[${entry}]`, `grid structure: ${entry}`, async () => {
                 try {
-                    const gridsetXml = await zip.readFile(gridsetEntry);
+                    const gridXml = await zip.readFile(entry);
                     const parser = new xml2js.Parser();
-                    const xmlObj = await parser.parseStringPromise(gridsetXml);
-                    const gridset = xmlObj.gridset || xmlObj.Gridset;
-                    if (!gridset) {
-                        this.err('Invalid gridset.xml structure', true);
+                    const xmlObj = await parser.parseStringPromise(gridXml);
+                    const grid = xmlObj.Grid || xmlObj.grid;
+                    if (!grid) {
+                        this.err(`${entry}: missing root <Grid> element`);
                     }
                     else {
-                        await this.validateGridsetStructure(gridset, filename, new Uint8Array());
+                        await this.validateGridStructure(grid, entry);
                     }
                 }
                 catch (e) {
-                    this.err(`Failed to parse gridset.xml: ${e.message}`, true);
+                    this.err(`${entry}: failed to parse XML: ${e.message}`);
                 }
-            }
-        });
-        // Check for settings.xml (highly recommended/required for metadata)
+            });
+        }
+        // --- Recommended: Settings0/settings.xml ---
         await this.add_check('settings_xml_presence', 'settings.xml presence', async () => {
-            const settingsEntry = entries.find((e) => e.toLowerCase() === 'settings.xml');
+            const settingsEntry = entries.find((e) => e.toLowerCase() === 'settings.xml' || e.toLowerCase().endsWith('/settings.xml'));
             if (!settingsEntry) {
                 this.warn('Missing settings.xml in archive (required for full metadata)');
             }
@@ -187,188 +195,36 @@ class GridsetValidator extends baseValidator_1.BaseValidator {
                 }
             }
         });
-    }
-    /**
-     * 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');
+        // --- Recommended: FileMap.xml (used for image resolution) ---
+        await this.add_check('filemap_presence', 'FileMap.xml presence', async () => {
+            const filemapEntry = entries.find((e) => e.toLowerCase() === 'filemap.xml');
+            if (!filemapEntry) {
+                this.warn('Missing FileMap.xml in archive (used for image resolution)');
             }
         });
     }
     /**
-     * Validate a single page
+     * Validate a real Grid 3 <Grid> element (from grid.xml).
+     * Checks for GridGuid, Cells, and basic cell structure.
      */
-    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`);
+    async validateGridStructure(grid, label) {
+        await this.add_check(`${label}_gridguid`, 'GridGuid', async () => {
+            const guid = grid.GridGuid || grid.gridGuid;
+            if (!guid) {
+                this.warn(`${label}: missing <GridGuid> element`);
             }
         });
-        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;
+        await this.add_check(`${label}_cells`, 'Cells element', async () => {
+            const cells = grid.Cells || grid.cells;
             if (!cells) {
-                this.warn(`page ${index} should have a cells element`);
+                this.warn(`${label}: missing <Cells> element`);
+                return;
             }
-            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`);
-                }
+            const cellArray = cells[0]?.Cell || cells[0]?.cell;
+            if (!cellArray || !Array.isArray(cellArray) || cellArray.length === 0) {
+                this.warn(`${label}: <Cells> 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`);
-            }
-        });
-        // Validate scan block number (Grid 3 attribute)
-        await this.add_check(`page[${pageIdx}]_cell[${cellIdx}]_scanblock`, `cell scan block`, async () => {
-            const scanBlock = cell.$.scanBlock || cell.$.ScanBlock;
-            if (scanBlock !== undefined) {
-                const blockNum = parseInt(scanBlock, 10);
-                if (isNaN(blockNum) || blockNum < 1 || blockNum > 8) {
-                    this.err(`cell ${cellIdx} on page ${pageIdx} has invalid scanBlock value: ${scanBlock} (must be 1-8)`, false);
-                }
-            }
-        });
-        // 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@willwade/aac-processors",
-  "version": "0.2.20",
+  "version": "0.3.0",
   "description": "A comprehensive TypeScript library for processing AAC (Augmentative and Alternative Communication) file formats with translation support",
   "main": "dist/index.js",
   "browser": "dist/browser/index.browser.js",
@@ -60,6 +60,10 @@
       "types": "./dist/astericsGrid.d.ts",
       "default": "./dist/astericsGrid.js"
     },
+    "./gotalkNow": {
+      "types": "./dist/gotalkNow.d.ts",
+      "default": "./dist/gotalkNow.js"
+    },
     "./translation": {
       "types": "./dist/translation.d.ts",
       "default": "./dist/translation.js"