@willwade/aac-processors 0.1.11 → 0.1.12

package/dist/browser/processors/gridset/resolver.js

@@ -42,6 +42,13 @@ export function resolveGrid3CellImage(zip, args, zipEntries) {
     const y = args.y;
     const entries = new Set(listZipEntries(zip, zipEntries));
     const has = (p) => entries.has(normalizeZipPathLocal(p));
+    // Debug logging for cells that fail to resolve
+    const shouldDebug = imageName?.startsWith('-') && x !== undefined && y !== undefined;
+    const debugLog = (msg) => {
+        if (shouldDebug) {
+            console.log(`[Resolver] ${baseDir} (${x},${y}) "${imageName}": ${msg}`);
+        }
+    };
     // Built-in resource like [grid3x]... (old format, not symbol library)
     // Check this BEFORE general symbol references to avoid misclassification
     if (imageName && imageName.startsWith('[')) {
@@ -72,6 +79,7 @@ export function resolveGrid3CellImage(zip, args, zipEntries) {
         // to be prefixed with the cell coordinates
         if (imageName.startsWith('-') && x != null && y != null) {
             const coordPrefixed = joinBaseDir(baseDir, `${x}-${y}${imageName}`);
+            debugLog(`trying coord-prefixed: ${coordPrefixed}, found: ${has(coordPrefixed)}`);
             if (has(coordPrefixed))
                 return coordPrefixed;
         }
@@ -114,12 +122,14 @@ export function resolveGrid3CellImage(zip, args, zipEntries) {
                 `${x}-${y}.jpg`,
                 `${x}-${y}.png`,
             ].map((n) => joinBaseDir(baseDir, n));
+            debugLog(`trying candidates: ${candidates.filter(has).join(', ') || 'none found'}`);
             for (const c of candidates) {
                 if (has(c))
                     return c;
             }
         }
     }
+    debugLog(`NOT FOUND - returning null`);
     return null;
 }
 /**

package/dist/browser/processors/gridsetProcessor.js

@@ -646,15 +646,130 @@ class GridsetProcessor extends BaseProcessor {
                     // Track WordList AutoContent cells and their positions for "more" button placement
                     const wordListAutoContentCells = [];
                     let wordListCellIndex = 0;
+                    // Helper function to find next available position in grid (auto-flow)
+                    // Returns {x, y} for next available slot that can accommodate the given span
+                    const findNextAvailablePosition = (width, height, gridLayout) => {
+                        for (let y = 0; y < maxRows; y++) {
+                            for (let x = 0; x <= maxCols - width; x++) {
+                                // Check if this position and the required span area are all free
+                                let fits = true;
+                                for (let dy = 0; dy < height && y + dy < maxRows; dy++) {
+                                    for (let dx = 0; dx < width && x + dx < maxCols; dx++) {
+                                        if (gridLayout[y + dy][x + dx] !== null) {
+                                            fits = false;
+                                            break;
+                                        }
+                                    }
+                                    if (!fits)
+                                        break;
+                                }
+                                if (fits) {
+                                    return { x, y };
+                                }
+                            }
+                        }
+                        // If no position found, return 0,0 (will be placed at first available)
+                        return { x: 0, y: 0 };
+                    };
+                    // Helper function to find next available X position in a specific row
+                    const findNextAvailableXInRow = (rowY, width, gridLayout) => {
+                        for (let x = 0; x <= maxCols - width; x++) {
+                            let fits = true;
+                            for (let dx = 0; dx < width; dx++) {
+                                if (gridLayout[rowY][x + dx] !== null) {
+                                    fits = false;
+                                    break;
+                                }
+                            }
+                            if (fits)
+                                return x;
+                        }
+                        return 0;
+                    };
+                    const cellsWithExplicitPosition = [];
+                    const cellsWithYOnly = [];
+                    const cellsWithXOnly = [];
+                    const cellsWithAutoFlow = [];
                     cellArr.forEach((cell, idx) => {
                         if (!cell || !cell.Content)
                             return;
-                        // Extract position information from cell attributes
-                        // Grid3 uses 1-based coordinates, convert to 0-based for internal use
-                        const cellX = Math.max(0, parseInt(String(cell['@_X'] || '1'), 10) - 1);
-                        const cellY = Math.max(0, parseInt(String(cell['@_Y'] || '1'), 10) - 1);
+                        const hasX = cell['@_X'] !== undefined;
+                        const hasY = cell['@_Y'] !== undefined;
+                        if (hasX && hasY) {
+                            cellsWithExplicitPosition.push({ cell, idx });
+                        }
+                        else if (hasY && !hasX) {
+                            cellsWithYOnly.push({ cell, idx });
+                        }
+                        else if (!hasY && hasX) {
+                            cellsWithXOnly.push({ cell, idx });
+                        }
+                        else {
+                            cellsWithAutoFlow.push({ cell, idx });
+                        }
+                    });
+                    // Process cells in order: explicit -> Y-only -> X-only -> auto-flow
+                    const allCellsToProcess = [
+                        ...cellsWithExplicitPosition,
+                        ...cellsWithYOnly,
+                        ...cellsWithXOnly,
+                        ...cellsWithAutoFlow,
+                    ];
+                    allCellsToProcess.forEach(({ cell, idx }) => {
+                        // Extract span information first
                         const colSpan = parseInt(String(cell['@_ColumnSpan'] || '1'), 10);
                         const rowSpan = parseInt(String(cell['@_RowSpan'] || '1'), 10);
+                        // Determine position based on what attributes are present
+                        const hasX = cell['@_X'] !== undefined;
+                        const hasY = cell['@_Y'] !== undefined;
+                        let cellX;
+                        let cellY;
+                        if (hasX && hasY) {
+                            // Explicit position: both X and Y provided
+                            // Grid 3 XML coordinates are already 0-based, use them directly
+                            cellX = Math.max(0, parseInt(String(cell['@_X']), 10));
+                            cellY = Math.max(0, parseInt(String(cell['@_Y']), 10));
+                        }
+                        else if (hasY && !hasX) {
+                            // Y-only: auto-flow X in the specified row
+                            // Grid 3 XML coordinates are already 0-based, use them directly
+                            cellY = Math.max(0, parseInt(String(cell['@_Y']), 10));
+                            cellX = findNextAvailableXInRow(cellY, colSpan, gridLayout);
+                        }
+                        else if (!hasY && hasX) {
+                            // X-only: place at specified X in next available row
+                            // Grid 3 XML coordinates are already 0-based, use them directly
+                            cellX = Math.max(0, parseInt(String(cell['@_X']), 10));
+                            // Find first row where this X position is available
+                            cellY = 0;
+                            let found = false;
+                            for (let y = 0; y < maxRows; y++) {
+                                let fits = true;
+                                for (let dx = 0; dx < colSpan && cellX + dx < maxCols; dx++) {
+                                    if (gridLayout[y][cellX + dx] !== null) {
+                                        fits = false;
+                                        break;
+                                    }
+                                }
+                                if (fits) {
+                                    cellY = y;
+                                    found = true;
+                                    break;
+                                }
+                            }
+                            if (!found) {
+                                // No available row found, use auto-flow
+                                const pos = findNextAvailablePosition(colSpan, rowSpan, gridLayout);
+                                cellX = pos.x;
+                                cellY = pos.y;
+                            }
+                        }
+                        else {
+                            // No position: auto-flow both X and Y
+                            const pos = findNextAvailablePosition(colSpan, rowSpan, gridLayout);
+                            cellX = pos.x;
+                            cellY = pos.y;
+                        }
                         // Extract scan block number (1-8) for block scanning support
                         const scanBlock = parseInt(String(cell['@_ScanBlock'] || '1'), 10);
                         // Extract visibility from Grid 3's <Visibility> child element
@@ -797,6 +912,13 @@ class GridsetProcessor extends BaseProcessor {
                             y: cellY,
                             dynamicFiles,
                         }, entries) || undefined;
+                        // Debug: log resolution for cells with images
+                        if (declaredImageName && resolvedImageEntry) {
+                            console.log(`[GridsetProcessor] Cell (${cellX + 1},${cellY + 1}) [XML coords]: ${declaredImageName} -> ${resolvedImageEntry}`);
+                        }
+                        else if (declaredImageName && !resolvedImageEntry) {
+                            console.log(`[GridsetProcessor] Cell (${cellX + 1},${cellY + 1}) [XML coords]: ${declaredImageName} -> NOT FOUND`);
+                        }
                         // Check if image is a symbol library reference
                         let symbolLibraryRef = null;
                         if (declaredImageName && isSymbolLibraryReference(declaredImageName)) {

package/dist/processors/gridset/resolver.js

@@ -47,6 +47,13 @@ function resolveGrid3CellImage(zip, args, zipEntries) {
     const y = args.y;
     const entries = new Set(listZipEntries(zip, zipEntries));
     const has = (p) => entries.has(normalizeZipPathLocal(p));
+    // Debug logging for cells that fail to resolve
+    const shouldDebug = imageName?.startsWith('-') && x !== undefined && y !== undefined;
+    const debugLog = (msg) => {
+        if (shouldDebug) {
+            console.log(`[Resolver] ${baseDir} (${x},${y}) "${imageName}": ${msg}`);
+        }
+    };
     // Built-in resource like [grid3x]... (old format, not symbol library)
     // Check this BEFORE general symbol references to avoid misclassification
     if (imageName && imageName.startsWith('[')) {
@@ -77,6 +84,7 @@ function resolveGrid3CellImage(zip, args, zipEntries) {
         // to be prefixed with the cell coordinates
         if (imageName.startsWith('-') && x != null && y != null) {
             const coordPrefixed = joinBaseDir(baseDir, `${x}-${y}${imageName}`);
+            debugLog(`trying coord-prefixed: ${coordPrefixed}, found: ${has(coordPrefixed)}`);
             if (has(coordPrefixed))
                 return coordPrefixed;
         }
@@ -119,12 +127,14 @@ function resolveGrid3CellImage(zip, args, zipEntries) {
                 `${x}-${y}.jpg`,
                 `${x}-${y}.png`,
             ].map((n) => joinBaseDir(baseDir, n));
+            debugLog(`trying candidates: ${candidates.filter(has).join(', ') || 'none found'}`);
             for (const c of candidates) {
                 if (has(c))
                     return c;
             }
         }
     }
+    debugLog(`NOT FOUND - returning null`);
     return null;
 }
 /**

package/dist/processors/gridsetProcessor.js

@@ -672,15 +672,130 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                     // Track WordList AutoContent cells and their positions for "more" button placement
                     const wordListAutoContentCells = [];
                     let wordListCellIndex = 0;
+                    // Helper function to find next available position in grid (auto-flow)
+                    // Returns {x, y} for next available slot that can accommodate the given span
+                    const findNextAvailablePosition = (width, height, gridLayout) => {
+                        for (let y = 0; y < maxRows; y++) {
+                            for (let x = 0; x <= maxCols - width; x++) {
+                                // Check if this position and the required span area are all free
+                                let fits = true;
+                                for (let dy = 0; dy < height && y + dy < maxRows; dy++) {
+                                    for (let dx = 0; dx < width && x + dx < maxCols; dx++) {
+                                        if (gridLayout[y + dy][x + dx] !== null) {
+                                            fits = false;
+                                            break;
+                                        }
+                                    }
+                                    if (!fits)
+                                        break;
+                                }
+                                if (fits) {
+                                    return { x, y };
+                                }
+                            }
+                        }
+                        // If no position found, return 0,0 (will be placed at first available)
+                        return { x: 0, y: 0 };
+                    };
+                    // Helper function to find next available X position in a specific row
+                    const findNextAvailableXInRow = (rowY, width, gridLayout) => {
+                        for (let x = 0; x <= maxCols - width; x++) {
+                            let fits = true;
+                            for (let dx = 0; dx < width; dx++) {
+                                if (gridLayout[rowY][x + dx] !== null) {
+                                    fits = false;
+                                    break;
+                                }
+                            }
+                            if (fits)
+                                return x;
+                        }
+                        return 0;
+                    };
+                    const cellsWithExplicitPosition = [];
+                    const cellsWithYOnly = [];
+                    const cellsWithXOnly = [];
+                    const cellsWithAutoFlow = [];
                     cellArr.forEach((cell, idx) => {
                         if (!cell || !cell.Content)
                             return;
-                        // Extract position information from cell attributes
-                        // Grid3 uses 1-based coordinates, convert to 0-based for internal use
-                        const cellX = Math.max(0, parseInt(String(cell['@_X'] || '1'), 10) - 1);
-                        const cellY = Math.max(0, parseInt(String(cell['@_Y'] || '1'), 10) - 1);
+                        const hasX = cell['@_X'] !== undefined;
+                        const hasY = cell['@_Y'] !== undefined;
+                        if (hasX && hasY) {
+                            cellsWithExplicitPosition.push({ cell, idx });
+                        }
+                        else if (hasY && !hasX) {
+                            cellsWithYOnly.push({ cell, idx });
+                        }
+                        else if (!hasY && hasX) {
+                            cellsWithXOnly.push({ cell, idx });
+                        }
+                        else {
+                            cellsWithAutoFlow.push({ cell, idx });
+                        }
+                    });
+                    // Process cells in order: explicit -> Y-only -> X-only -> auto-flow
+                    const allCellsToProcess = [
+                        ...cellsWithExplicitPosition,
+                        ...cellsWithYOnly,
+                        ...cellsWithXOnly,
+                        ...cellsWithAutoFlow,
+                    ];
+                    allCellsToProcess.forEach(({ cell, idx }) => {
+                        // Extract span information first
                         const colSpan = parseInt(String(cell['@_ColumnSpan'] || '1'), 10);
                         const rowSpan = parseInt(String(cell['@_RowSpan'] || '1'), 10);
+                        // Determine position based on what attributes are present
+                        const hasX = cell['@_X'] !== undefined;
+                        const hasY = cell['@_Y'] !== undefined;
+                        let cellX;
+                        let cellY;
+                        if (hasX && hasY) {
+                            // Explicit position: both X and Y provided
+                            // Grid 3 XML coordinates are already 0-based, use them directly
+                            cellX = Math.max(0, parseInt(String(cell['@_X']), 10));
+                            cellY = Math.max(0, parseInt(String(cell['@_Y']), 10));
+                        }
+                        else if (hasY && !hasX) {
+                            // Y-only: auto-flow X in the specified row
+                            // Grid 3 XML coordinates are already 0-based, use them directly
+                            cellY = Math.max(0, parseInt(String(cell['@_Y']), 10));
+                            cellX = findNextAvailableXInRow(cellY, colSpan, gridLayout);
+                        }
+                        else if (!hasY && hasX) {
+                            // X-only: place at specified X in next available row
+                            // Grid 3 XML coordinates are already 0-based, use them directly
+                            cellX = Math.max(0, parseInt(String(cell['@_X']), 10));
+                            // Find first row where this X position is available
+                            cellY = 0;
+                            let found = false;
+                            for (let y = 0; y < maxRows; y++) {
+                                let fits = true;
+                                for (let dx = 0; dx < colSpan && cellX + dx < maxCols; dx++) {
+                                    if (gridLayout[y][cellX + dx] !== null) {
+                                        fits = false;
+                                        break;
+                                    }
+                                }
+                                if (fits) {
+                                    cellY = y;
+                                    found = true;
+                                    break;
+                                }
+                            }
+                            if (!found) {
+                                // No available row found, use auto-flow
+                                const pos = findNextAvailablePosition(colSpan, rowSpan, gridLayout);
+                                cellX = pos.x;
+                                cellY = pos.y;
+                            }
+                        }
+                        else {
+                            // No position: auto-flow both X and Y
+                            const pos = findNextAvailablePosition(colSpan, rowSpan, gridLayout);
+                            cellX = pos.x;
+                            cellY = pos.y;
+                        }
                         // Extract scan block number (1-8) for block scanning support
                         const scanBlock = parseInt(String(cell['@_ScanBlock'] || '1'), 10);
                         // Extract visibility from Grid 3's <Visibility> child element
@@ -823,6 +938,13 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                             y: cellY,
                             dynamicFiles,
                         }, entries) || undefined;
+                        // Debug: log resolution for cells with images
+                        if (declaredImageName && resolvedImageEntry) {
+                            console.log(`[GridsetProcessor] Cell (${cellX + 1},${cellY + 1}) [XML coords]: ${declaredImageName} -> ${resolvedImageEntry}`);
+                        }
+                        else if (declaredImageName && !resolvedImageEntry) {
+                            console.log(`[GridsetProcessor] Cell (${cellX + 1},${cellY + 1}) [XML coords]: ${declaredImageName} -> NOT FOUND`);
+                        }
                         // Check if image is a symbol library reference
                         let symbolLibraryRef = null;
                         if (declaredImageName && (0, resolver_2.isSymbolLibraryReference)(declaredImageName)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@willwade/aac-processors",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "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",
@@ -80,13 +80,11 @@
   "files": [
     "dist/**/*",
     "docs/**/*",
-    "examples/**/*",
     "README.md",
     "LICENSE"
   ],
   "directories": {
     "doc": "docs",
-    "example": "examples",
     "test": "test"
   },
   "scripts": {

package/examples/.keep

@@ -1 +0,0 @@
-

package/examples/README.md

@@ -1,55 +0,0 @@
-# AAC Processors Example Pagesets
-
-This directory contains example AAC pagesets in various formats used for testing and demonstration purposes.
-
-## Available Pagesets
-
-### Grid3 Format (.gridset)
-- **example.gridset** - Main example pageset with multiple grids and wordlists
-- **example-images.gridset** - Example pageset with embedded images
-
-### Snap Format (.spb, .sps)
-- **example.spb** - Snap pageset (binary format)
-- **example.sps** - Snap pageset (alternative format)
-
-### TouchChat Format (.ce)
-- **example.ce** - TouchChat pageset
-
-### OBF/OBZ Format (.obf, .obz)
-- **example.obf** - OBF pageset (JSON-based)
-- **example.obz** - OBZ pageset (compressed)
-
-**obf/** - Directory containing validation test samples from the obf-node project:
-- **simple.obf** - Simple, valid OBF file for basic validation tests
-- **aboutme.json** - Invalid OBF (missing locale field) for error testing
-- **hash.json** - Non-OBF JSON structure for format detection tests
-- **array.json** - JSON array (not object) for structure validation tests
-- **links.obz** - OBZ package with links for zip archive validation
-
-### Asterics Grid Format (.grd)
-- **example.grd** - Asterics Grid pageset
-- **example2.grd** - Alternative Asterics Grid pageset
-
-### DOT Format (.dot)
-- **example.dot** - Simple DOT format pageset
-- **communikate.dot** - Communikate DOT format pageset
-
-### OPML Format (.opml)
-- **example.opml** - OPML pageset
-
-### Styled Output
-- **styled-output/** - Directory containing example pagesets with styling applied
-
-## Usage
-
-These pagesets are used by:
-- Unit tests in the main test suite
-- Demo scripts in the `scripts/` directory
-- Integration examples
-
-To run demo scripts that use these pagesets, see the [scripts/README.md](../scripts/README.md).
-
-## Browser Demo (Vite)
-
-For browser testing, use the Vite demo in `examples/vitedemo`. It bundles the
-library and exercises real processors in a browser environment.