@willwade/aac-processors 0.2.9 → 0.2.11

package/dist/browser/processors/obfProcessor.js

@@ -80,7 +80,7 @@ class ObfProcessor extends BaseProcessor {
             // Images are typically stored in an 'images' folder or root
             const possiblePaths = [
                 imageData.path, // Explicit path if provided
-                `images/${imageData.filename || imageId}`, // Standard images folder
+                `images/${imageData.path || imageId}`, // Standard images folder
                 imageData.id, // Just the ID
             ].filter(Boolean);
             for (const imagePath of possiblePaths) {
@@ -126,14 +126,18 @@ class ObfProcessor extends BaseProcessor {
                 return 'image/png';
         }
     }
-    async processBoard(boardData, _boardPath, isZipEntry) {
+    getPageFilename(id, metadata) {
+        if (metadata._obfPagePaths && id in metadata._obfPagePaths)
+            return metadata._obfPagePaths[id];
+        if (id.endsWith('.obf'))
+            return id;
+        return `${id}.obf`;
+    }
+    async processBoard(boardData, _boardPath) {
         const sourceButtons = boardData.buttons || [];
         // Calculate page ID first (used to make button IDs unique)
-        const pageId = isZipEntry
-            ? _boardPath // Zip entry - use filename to match navigation paths
-            : boardData?.id
-                ? String(boardData.id)
-                : _boardPath?.split(/[/\\]/).pop() || '';
+        const pageId = boardData?.id ? String(boardData.id) : _boardPath?.split(/[/\\]/).pop() || '';
+        const images = boardData.images;
         const buttons = await Promise.all(sourceButtons.map(async (btn) => {
             const semanticAction = btn.load_board
                 ? {
@@ -157,11 +161,16 @@ class ObfProcessor extends BaseProcessor {
             // Resolve image if image_id is present
             let resolvedImage;
             let imageBuffer;
-            if (btn.image_id && boardData.images) {
-                resolvedImage =
-                    (await this.extractImageAsDataUrl(btn.image_id, boardData.images)) || undefined;
-                imageBuffer =
-                    (await this.extractImageAsBuffer(btn.image_id, boardData.images)) || undefined;
+            if (btn.image_id && images) {
+                resolvedImage = (await this.extractImageAsDataUrl(btn.image_id, images)) || undefined;
+                imageBuffer = (await this.extractImageAsBuffer(btn.image_id, images)) || undefined;
+                // save image data
+                if (images) {
+                    const imageIndex = images?.findIndex((img) => img.id === btn.image_id);
+                    if (imageIndex !== -1) {
+                        images[imageIndex].data = resolvedImage;
+                    }
+                }
             }
             // Build parameters object for Grid3 export compatibility
             const buttonParameters = {};
@@ -198,7 +207,7 @@ class ObfProcessor extends BaseProcessor {
             parentId: null,
             locale: boardData.locale,
             descriptionHtml: boardData.description_html,
-            images: boardData.images,
+            images,
             sounds: boardData.sounds,
         });
         // Process grid layout if available
@@ -288,7 +297,7 @@ class ObfProcessor extends BaseProcessor {
         return texts;
     }
     async loadIntoTree(filePathOrBuffer) {
-        const { readBinaryFromInput, readTextFromInput } = this.options.fileAdapter;
+        const { readBinaryFromInput, readTextFromInput, listDir, join, isDirectory } = this.options.fileAdapter;
         // Detailed logging for debugging input
         const bufferLength = typeof filePathOrBuffer === 'string'
             ? null
@@ -330,7 +339,7 @@ class ObfProcessor extends BaseProcessor {
                 const boardData = await tryParseObfJson(content);
                 if (boardData) {
                     console.log('[OBF] Detected .obf file, parsed as JSON');
-                    const page = await this.processBoard(boardData, filePathOrBuffer, false);
+                    const page = await this.processBoard(boardData, filePathOrBuffer);
                     tree.addPage(page);
                     // Set metadata from root board
                     tree.metadata.format = 'obf';
@@ -354,22 +363,30 @@ class ObfProcessor extends BaseProcessor {
                 throw err;
             }
         }
-        // Detect likely zip signature first
-        async function isLikelyZip(input) {
-            if (typeof input === 'string') {
-                const lowered = input.toLowerCase();
-                return lowered.endsWith('.zip') || lowered.endsWith('.obz');
+        // Determine if input is ZIP, directory, or OBF JSON string/buffer
+        let fileType = 'obf';
+        if (typeof filePathOrBuffer !== 'string') {
+            const bytes = await readBinaryFromInput(filePathOrBuffer);
+            if (bytes.length >= 2 && bytes[0] === 0x50 && bytes[1] === 0x4b)
+                fileType = 'zip';
+        }
+        else {
+            if (await isDirectory(filePathOrBuffer)) {
+                fileType = 'dir';
+            }
+            else {
+                const lowered = filePathOrBuffer.toLowerCase();
+                if (lowered.endsWith('.zip') || lowered.endsWith('.obz'))
+                    fileType = 'zip';
             }
-            const bytes = await readBinaryFromInput(input);
-            return bytes.length >= 2 && bytes[0] === 0x50 && bytes[1] === 0x4b;
         }
         // Check if input is a buffer or string that parses as OBF JSON; throw if neither JSON nor ZIP
-        if (!(await isLikelyZip(filePathOrBuffer))) {
+        if (fileType === 'obf') {
             const asJson = await tryParseObfJson(filePathOrBuffer);
             if (!asJson)
                 throw new Error('Invalid OBF content: not JSON and not ZIP');
             console.log('[OBF] Detected buffer/string as OBF JSON');
-            const page = await this.processBoard(asJson, '[bufferOrString]', false);
+            const page = await this.processBoard(asJson, '[bufferOrString]');
             tree.addPage(page);
             // Set metadata from root board
             tree.metadata.format = 'obf';
@@ -385,18 +402,31 @@ class ObfProcessor extends BaseProcessor {
             tree.rootId = page.id;
             return tree;
         }
-        try {
-            this.zipFile = await this.options.zipAdapter(filePathOrBuffer);
-        }
-        catch (err) {
-            console.error('[OBF] Error loading ZIP:', err);
-            throw err;
+        this.zipFile = {
+            readFile: async (name) => {
+                return await readBinaryFromInput(join(filePathOrBuffer, name));
+            },
+            listFiles: () => {
+                throw new Error('Not implemented for directory input');
+            },
+            writeFiles: () => {
+                throw new Error('Not implemented for directory input');
+            },
+        };
+        if (fileType === 'zip') {
+            try {
+                this.zipFile = await this.options.zipAdapter(filePathOrBuffer);
+            }
+            catch (err) {
+                console.error('[OBF] Error loading ZIP:', err);
+                throw err;
+            }
         }
         // Store the ZIP file reference for image extraction
         this.imageCache.clear(); // Clear cache for new file
-        console.log('[OBF] Detected zip archive, extracting .obf files');
+        console.log('[OBF] Detected zip archive or directory, extracting .obf files');
         // List manifest and OBF files
-        const filesInZip = this.zipFile.listFiles();
+        const filesInZip = fileType === 'zip' ? this.zipFile.listFiles() : await listDir(filePathOrBuffer);
         const manifestFile = filesInZip.filter((name) => name.toLowerCase() === 'manifest.json');
         let obfEntries = filesInZip.filter((name) => name.toLowerCase().endsWith('.obf'));
         // Attempt to read manifest
@@ -430,7 +460,7 @@ class ObfProcessor extends BaseProcessor {
                 const content = await this.zipFile.readFile(entryName);
                 const boardData = await tryParseObfJson(decodeText(content));
                 if (boardData) {
-                    const page = await this.processBoard(boardData, entryName, true);
+                    const page = await this.processBoard(boardData, entryName);
                     tree.addPage(page);
                     // Set metadata if not already set (use first board as reference)
                     if (!tree.metadata.format) {
@@ -439,12 +469,16 @@ class ObfProcessor extends BaseProcessor {
                         tree.metadata.description = boardData.description_html;
                         tree.metadata.locale = boardData.locale;
                         tree.metadata.id = boardData.id;
+                        tree.metadata._obfPagePaths = { [page.id]: entryName };
                         if (boardData.url)
                             tree.metadata.url = boardData.url;
                         if (boardData.locale)
                             tree.metadata.languages = [boardData.locale];
                         tree.rootId = page.id;
                     }
+                    else {
+                        tree.metadata._obfPagePaths[page.id] = entryName;
+                    }
                 }
                 else {
                     console.warn('[OBF] Skipped entry (not valid OBF JSON):', entryName);
@@ -497,11 +531,18 @@ class ObfProcessor extends BaseProcessor {
         }
         return { rows: totalRows, columns: totalColumns, order, buttonPositions };
     }
-    createObfBoardFromPage(page, fallbackName, metadata) {
+    createObfBoardFromPage(page, fallbackName, metadata, embedData = false) {
         const { rows, columns, order, buttonPositions } = this.buildGridMetadata(page);
         const boardName = metadata?.name && page.id === metadata?.defaultHomePageId
             ? metadata.name
             : page.name || fallbackName;
+        let images = Array.isArray(page.images) ? page.images : [];
+        if (!embedData) {
+            images = images.map((image) => {
+                delete image.data;
+                return image;
+            });
+        }
         return {
             format: OBF_FORMAT_VERSION,
             id: page.id,
@@ -538,7 +579,7 @@ class ObfProcessor extends BaseProcessor {
                     hidden: button.visibility === 'Hidden' || false,
                 };
             }),
-            images: Array.isArray(page.images) ? page.images : [],
+            images,
             sounds: Array.isArray(page.sounds) ? page.sounds : [],
         };
     }
@@ -575,23 +616,22 @@ class ObfProcessor extends BaseProcessor {
         await this.saveFromTree(tree, outputPath);
         return await readBinaryFromInput(outputPath);
     }
-    async saveFromTree(tree, outputPath) {
-        const { writeTextToPath, writeBinaryToPath, pathExists } = this.options.fileAdapter;
+    async saveFromTree(tree, outputPath, embedData = false) {
+        const { writeTextToPath, writeBinaryToPath, pathExists, mkDir, join } = this.options.fileAdapter;
         if (outputPath.endsWith('.obf')) {
             // Save as single OBF JSON file
             const rootPage = tree.rootId ? tree.getPage(tree.rootId) : Object.values(tree.pages)[0];
             if (!rootPage) {
                 throw new Error('No pages to save');
             }
-            const obfBoard = this.createObfBoardFromPage(rootPage, 'Exported Board', tree.metadata);
+            const obfBoard = this.createObfBoardFromPage(rootPage, 'Exported Board', tree.metadata, embedData);
             await writeTextToPath(outputPath, JSON.stringify(obfBoard, null, 2));
         }
         else {
-            const getPageFilename = (id) => (id.endsWith('.obf') ? id : `${id}.obf`);
             const files = Object.values(tree.pages).map((page) => {
-                const obfBoard = this.createObfBoardFromPage(page, 'Board', tree.metadata);
+                const obfBoard = this.createObfBoardFromPage(page, 'Board', tree.metadata, embedData);
                 const obfContent = JSON.stringify(obfBoard, null, 2);
-                const name = getPageFilename(page.id);
+                const name = this.getPageFilename(page.id, tree.metadata);
                 return {
                     name,
                     data: new TextEncoder().encode(obfContent),
@@ -601,7 +641,10 @@ class ObfProcessor extends BaseProcessor {
                 format: OBF_FORMAT_VERSION,
                 root: tree.metadata.defaultHomePageId,
                 paths: {
-                    boards: Object.fromEntries(Object.entries(tree.pages).map(([id, page]) => [id, getPageFilename(page.id)])),
+                    boards: Object.fromEntries(Object.entries(tree.pages).map(([id, page]) => [
+                        id,
+                        this.getPageFilename(page.id, tree.metadata),
+                    ])),
                     images: {}, //TODO Add support for saving images as files
                     sounds: {}, //TODO Add support for saving sounds as files
                 },
@@ -610,10 +653,22 @@ class ObfProcessor extends BaseProcessor {
                 name: 'manifest.json',
                 data: new TextEncoder().encode(JSON.stringify(manifest)),
             });
-            const fileExists = await pathExists(outputPath);
-            this.zipFile = await this.options.zipAdapter(fileExists ? outputPath : undefined, this.options.fileAdapter);
-            const zipData = await this.zipFile.writeFiles(files);
-            await writeBinaryToPath(outputPath, zipData);
+            if (outputPath.endsWith('.obz') || outputPath.endsWith('.zip')) {
+                console.log('[OBF] Saving to ZIP file:', outputPath);
+                const fileExists = await pathExists(outputPath);
+                this.zipFile = await this.options.zipAdapter(fileExists ? outputPath : undefined, this.options.fileAdapter);
+                const zipData = await this.zipFile.writeFiles(files);
+                await writeBinaryToPath(outputPath, zipData);
+            }
+            else {
+                console.log('[OBF] Saving to directory:', outputPath);
+                if (!(await pathExists(outputPath)))
+                    await mkDir(outputPath);
+                for (const file of files) {
+                    const filePath = join(outputPath, file.name);
+                    await writeBinaryToPath(filePath, file.data);
+                }
+            }
         }
     }
     /**
@@ -640,13 +695,12 @@ class ObfProcessor extends BaseProcessor {
         const AdmZip = (await import('adm-zip')).default;
         const originalZip = new AdmZip(originalPath);
         const outputZip = new AdmZip();
-        const getPageFilename = (id) => (id.endsWith('.obf') ? id : `${id}.obf`);
         // Track which .obf files we're modifying
         const modifiedObfFiles = new Set();
         // Generate new .obf files for pages in the tree
         const newObfFiles = new Map();
         for (const page of Object.values(tree.pages)) {
-            const obfFilename = getPageFilename(page.id);
+            const obfFilename = this.getPageFilename(page.id, tree.metadata);
             modifiedObfFiles.add(obfFilename);
             const obfBoard = this.createObfBoardFromPage(page, 'Board', tree.metadata);
             const obfContent = JSON.stringify(obfBoard, null, 2);
@@ -659,7 +713,10 @@ class ObfProcessor extends BaseProcessor {
                 format: OBF_FORMAT_VERSION,
                 root: tree.metadata.defaultHomePageId,
                 paths: {
-                    boards: Object.fromEntries(Object.entries(tree.pages).map(([id, page]) => [id, getPageFilename(page.id)])),
+                    boards: Object.fromEntries(Object.entries(tree.pages).map(([id, page]) => [
+                        id,
+                        this.getPageFilename(page.id, tree.metadata),
+                    ])),
                     images: {},
                     sounds: {},
                 },

package/dist/browser/utilities/analytics/morphology/index.js

@@ -1,3 +1,2 @@
 export { MorphologyEngine } from './engine';
-export { Grid3VerbsParser } from './grid3VerbsParser';
 export { WordFormGenerator } from './wordFormGenerator';

package/dist/browser/utils/sqlite.js

@@ -80,7 +80,9 @@ export async function openSqliteDatabase(input, options = {}) {
             throw new Error('SQLite file paths are not supported in browser environments.');
         }
         const Database = getBetterSqlite3();
-        const db = new Database(input, { readonly: options.readonly ?? true });
+        const db = new Database(input, {
+            readonly: options.readonly ?? true,
+        });
         return { db };
     }
     const data = await readBinaryFromInput(input);
@@ -93,7 +95,9 @@ export async function openSqliteDatabase(input, options = {}) {
     const dbPath = join(tempDir, 'input.sqlite');
     await writeBinaryToPath(dbPath, data);
     const Database = getBetterSqlite3();
-    const db = new Database(dbPath, { readonly: options.readonly ?? true });
+    const db = new Database(dbPath, {
+        readonly: options.readonly ?? true,
+    });
     const cleanup = async () => {
         try {
             db.close();

package/dist/processors/gridset/cellHelpers.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Grid3 Cell Helpers
+ *
+ * Utilities for working with Grid 3 cells, including finding button positions
+ * and calculating cell spans in grid layouts.
+ */
+import type { AACPage, AACButton } from '../../core/treeStructure';
+/**
+ * Cell position with span information
+ */
+export interface CellPosition {
+    /** X coordinate (column) */
+    x: number;
+    /** Y coordinate (row) */
+    y: number;
+    /** Number of columns the cell spans */
+    columnSpan: number;
+    /** Number of rows the cell spans */
+    rowSpan: number;
+}
+/**
+ * Find button position with span information
+ *
+ * Searches the page's grid layout for a button and calculates its position
+ * and span (how many columns/rows it occupies).
+ *
+ * @param page - The AAC page containing the button
+ * @param button - The button to locate
+ * @param fallbackIndex - Index to use if button not found in grid
+ * @returns Position and span information for the button
+ *
+ * @example
+ * const position = findButtonPosition(page, button, 0);
+ * console.log(`Button at ${position.x},${position.y} spans ${position.columnSpan}x${position.rowSpan}`);
+ */
+export declare function findButtonPosition(page: AACPage, button: AACButton, fallbackIndex: number): CellPosition;
+/**
+ * Calculate cell position key for Maps and Sets
+ *
+ * Creates a string key from X and Y coordinates for use as a Map key or Set entry.
+ *
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @returns String key in format "x,y"
+ *
+ * @example
+ * const key = cellPositionKey(5, 3);
+ * console.log(key); // "5,3"
+ */
+export declare function cellPositionKey(x: number, y: number): string;
+/**
+ * Parse cell position key
+ *
+ * Extracts X and Y coordinates from a position key string.
+ *
+ * @param key - Position key in format "x,y"
+ * @returns Object with x and y properties
+ *
+ * @example
+ * const pos = parseCellPositionKey("5,3");
+ * console.log(pos); // { x: 5, y: 3 }
+ */
+export declare function parseCellPositionKey(key: string): {
+    x: number;
+    y: number;
+};

package/dist/processors/gridset/cellHelpers.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Grid3 Cell Helpers
+ *
+ * Utilities for working with Grid 3 cells, including finding button positions
+ * and calculating cell spans in grid layouts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findButtonPosition = findButtonPosition;
+exports.cellPositionKey = cellPositionKey;
+exports.parseCellPositionKey = parseCellPositionKey;
+/**
+ * Find button position with span information
+ *
+ * Searches the page's grid layout for a button and calculates its position
+ * and span (how many columns/rows it occupies).
+ *
+ * @param page - The AAC page containing the button
+ * @param button - The button to locate
+ * @param fallbackIndex - Index to use if button not found in grid
+ * @returns Position and span information for the button
+ *
+ * @example
+ * const position = findButtonPosition(page, button, 0);
+ * console.log(`Button at ${position.x},${position.y} spans ${position.columnSpan}x${position.rowSpan}`);
+ */
+function findButtonPosition(page, button, fallbackIndex) {
+    if (page.grid && page.grid.length > 0) {
+        // Search for button in grid layout and calculate span
+        for (let y = 0; y < page.grid.length; y++) {
+            for (let x = 0; x < page.grid[y].length; x++) {
+                const current = page.grid[y][x];
+                if (current && current.id === button.id) {
+                    // Calculate span by checking how far the same button extends
+                    let columnSpan = 1;
+                    let rowSpan = 1;
+                    // Check column span (rightward)
+                    while (x + columnSpan < page.grid[y].length) {
+                        const right = page.grid[y][x + columnSpan];
+                        if (right && right.id === button.id) {
+                            columnSpan++;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    // Check row span (downward)
+                    while (y + rowSpan < page.grid.length) {
+                        const below = page.grid[y + rowSpan][x];
+                        if (below && below.id === button.id) {
+                            rowSpan++;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    return { x, y, columnSpan, rowSpan };
+                }
+            }
+        }
+    }
+    // Fallback positioning
+    const gridCols = page.grid?.[0]?.length || Math.ceil(Math.sqrt(page.buttons.length));
+    return {
+        x: fallbackIndex % gridCols,
+        y: Math.floor(fallbackIndex / gridCols),
+        columnSpan: 1,
+        rowSpan: 1,
+    };
+}
+/**
+ * Calculate cell position key for Maps and Sets
+ *
+ * Creates a string key from X and Y coordinates for use as a Map key or Set entry.
+ *
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @returns String key in format "x,y"
+ *
+ * @example
+ * const key = cellPositionKey(5, 3);
+ * console.log(key); // "5,3"
+ */
+function cellPositionKey(x, y) {
+    return `${x},${y}`;
+}
+/**
+ * Parse cell position key
+ *
+ * Extracts X and Y coordinates from a position key string.
+ *
+ * @param key - Position key in format "x,y"
+ * @returns Object with x and y properties
+ *
+ * @example
+ * const pos = parseCellPositionKey("5,3");
+ * console.log(pos); // { x: 5, y: 3 }
+ */
+function parseCellPositionKey(key) {
+    const [x, y] = key.split(',').map(Number);
+    return { x, y };
+}

package/dist/processors/gridset/gridCalculations.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Grid3 Grid Calculations
+ *
+ * Utilities for calculating grid dimensions and definitions
+ * based on page layout and button count.
+ */
+import type { AACPage } from '../../core/treeStructure';
+/**
+ * Grid definition structure for Grid 3 XML
+ */
+export interface GridDefinitions {
+    ColumnDefinition: any[];
+}
+export interface RowDefinitions {
+    RowDefinition: any[];
+}
+/**
+ * Calculate column definitions based on page layout
+ *
+ * Analyzes the page's grid structure to determine the number of columns.
+ * If no grid exists, estimates from button count.
+ *
+ * @param page - The AAC page to analyze
+ * @returns Column definitions object for Grid 3 XML
+ *
+ * @example
+ * const columns = calculateColumnDefinitions(page);
+ * // Returns: { ColumnDefinition: [{}, {}, {}, {}] } for 4 columns
+ */
+export declare function calculateColumnDefinitions(page: AACPage): GridDefinitions;
+/**
+ * Calculate row definitions based on page layout
+ *
+ * Analyzes the page's grid structure to determine the number of rows.
+ * If no grid exists, estimates from button count.
+ *
+ * @param page - The AAC page to analyze
+ * @param addWorkspaceOffset - Whether to add 1 row for workspace (default: false)
+ * @returns Row definitions object for Grid 3 XML
+ *
+ * @example
+ * const rows = calculateRowDefinitions(page, false);
+ * // Returns: { RowDefinition: [{}, {}, {}, {}] } for 4 rows
+ */
+export declare function calculateRowDefinitions(page: AACPage, addWorkspaceOffset?: boolean): RowDefinitions;

package/dist/processors/gridset/gridCalculations.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Grid3 Grid Calculations
+ *
+ * Utilities for calculating grid dimensions and definitions
+ * based on page layout and button count.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateColumnDefinitions = calculateColumnDefinitions;
+exports.calculateRowDefinitions = calculateRowDefinitions;
+/**
+ * Calculate column definitions based on page layout
+ *
+ * Analyzes the page's grid structure to determine the number of columns.
+ * If no grid exists, estimates from button count.
+ *
+ * @param page - The AAC page to analyze
+ * @returns Column definitions object for Grid 3 XML
+ *
+ * @example
+ * const columns = calculateColumnDefinitions(page);
+ * // Returns: { ColumnDefinition: [{}, {}, {}, {}] } for 4 columns
+ */
+function calculateColumnDefinitions(page) {
+    let maxCols = 4; // Default minimum
+    if (page.grid && page.grid.length > 0) {
+        maxCols = Math.max(maxCols, page.grid[0]?.length || 0);
+    }
+    else {
+        // Fallback: estimate from button count
+        maxCols = Math.max(4, Math.ceil(Math.sqrt(page.buttons.length)));
+    }
+    return {
+        ColumnDefinition: Array(maxCols).fill({}),
+    };
+}
+/**
+ * Calculate row definitions based on page layout
+ *
+ * Analyzes the page's grid structure to determine the number of rows.
+ * If no grid exists, estimates from button count.
+ *
+ * @param page - The AAC page to analyze
+ * @param addWorkspaceOffset - Whether to add 1 row for workspace (default: false)
+ * @returns Row definitions object for Grid 3 XML
+ *
+ * @example
+ * const rows = calculateRowDefinitions(page, false);
+ * // Returns: { RowDefinition: [{}, {}, {}, {}] } for 4 rows
+ */
+function calculateRowDefinitions(page, addWorkspaceOffset = false) {
+    let maxRows = 4; // Default minimum
+    const offset = addWorkspaceOffset ? 1 : 0;
+    if (page.grid && page.grid.length > 0) {
+        maxRows = Math.max(maxRows, page.grid.length + offset);
+    }
+    else {
+        // Fallback: estimate from button count
+        const estimatedCols = Math.ceil(Math.sqrt(page.buttons.length));
+        maxRows = Math.max(4, Math.ceil(page.buttons.length / estimatedCols)) + offset;
+    }
+    return {
+        RowDefinition: Array(maxRows).fill({}),
+    };
+}

package/dist/processors/gridset/helpers.js

@@ -167,7 +167,10 @@ function getCommonDocumentsPath() {
         // Query registry for Common Documents path
         const child_process = (0, io_1.getNodeRequire)()('child_process');
         const command = 'REG.EXE QUERY "HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders" /V "Common Documents"';
-        const output = child_process.execSync(command, { encoding: 'utf-8', windowsHide: true });
+        const output = child_process.execSync(command, {
+            encoding: 'utf-8',
+            windowsHide: true,
+        });
         // Parse the output to extract the path
         const match = output.match(/Common Documents\s+REG_SZ\s+(.+)/);
         if (match && match[1]) {

package/dist/processors/gridset/wordlistHelpers.js

@@ -69,9 +69,10 @@ function wordlistToXml(wordlist) {
     const items = wordlist.items.map((item) => ({
         WordListItem: {
             Text: {
-                s: {
-                    '@_Image': item.image || '',
-                    r: item.text,
+                p: {
+                    s: {
+                        r: item.text,
+                    },
                 },
             },
             Image: item.image || '',
@@ -137,7 +138,7 @@ async function extractWordlists(gridsetBuffer, password = (0, password_1.resolve
                             ? [itemsContainer.WordListItem]
                             : [];
                     const items = itemArray.map((item) => ({
-                        text: item.Text?.s?.r || item.text?.s?.r || '',
+                        text: item.Text?.p?.s?.r || item.Text?.s?.r || item.text?.p?.s?.r || item.text?.s?.r || '',
                         image: item.Image || item.image || undefined,
                         partOfSpeech: item.PartOfSpeech || item.partOfSpeech || 'Unknown',
                     }));
@@ -202,9 +203,10 @@ async function updateWordlist(gridsetBuffer, gridName, wordlist, password = (0,
                     const items = wordlist.items.map((item) => ({
                         WordListItem: {
                             Text: {
-                                s: {
-                                    '@_Image': item.image || '',
-                                    r: item.text,
+                                p: {
+                                    s: {
+                                        r: item.text,
+                                    },
                                 },
                             },
                             Image: item.image || '',