Merge branch 'obf-folder' into obf-save-image-files

chrisbaume · chrisbaume · commit 780e2e8a624a · 2026-04-28T10:41:23.000+01:00
diff --git a/src/processors/gridsetProcessor.ts b/src/processors/gridsetProcessor.ts
@@ -1292,9 +1292,12 @@ class GridsetProcessor extends BaseProcessor {
                     break;
 
                   case 'Jump.ToKeyboard': {
-                    // Navigate to the set keyboard if we found one in settings
+                    // Prefer explicit keyboard page metadata when available.
+                    // Some Gridsets resolve the keyboard page in metadata
+                    // without preserving tree.keyboardGridName during parse.
                     const keyboardGridName = (tree as any).keyboardGridName as string;
-                    const keyboardPageId = gridNameToIdMap.get(keyboardGridName);
+                    const keyboardPageId =
+                      tree.metadata?.defaultKeyboardPageId || gridNameToIdMap.get(keyboardGridName);
                     if (keyboardPageId && !navigationTarget) {
                       navigationTarget = keyboardPageId;
                     }
@@ -1900,6 +1903,7 @@ class GridsetProcessor extends BaseProcessor {
           settingsData?.gridSetSettings?.keyboardGrid ||
           settingsData?.GridsetSettings?.KeyboardGrid;
         if (keyboardGridName && typeof keyboardGridName === 'string') {
+          (tree as any).keyboardGridName = keyboardGridName;
           metadata.defaultKeyboardPageId = gridNameToIdMap.get(keyboardGridName);
         }
       }
@@ -1909,6 +1913,24 @@ class GridsetProcessor extends BaseProcessor {
 
     // Set metadata on tree
     tree.metadata = metadata;
+    if (metadata.defaultKeyboardPageId) {
+      Object.values(tree.pages).forEach((page) => {
+        page.buttons.forEach((button) => {
+          if (
+            button?.semanticAction?.platformData?.grid3?.commandId === 'Jump.ToKeyboard' &&
+            !button.targetPageId
+          ) {
+            button.targetPageId = metadata.defaultKeyboardPageId;
+            if (button.semanticAction) {
+              button.semanticAction.targetId = metadata.defaultKeyboardPageId;
+              if (button.semanticAction.fallback?.type === 'NAVIGATE') {
+                button.semanticAction.fallback.targetPageId = metadata.defaultKeyboardPageId;
+              }
+            }
+          }
+        });
+      });
+    }
 
     return tree;
   }
@@ -2494,6 +2516,152 @@ class GridsetProcessor extends BaseProcessor {
     };
   }
 
+  /**
+   * Save a modified tree while preserving all original files (settings, images, assets)
+   * This method only updates the grid.xml files for pages in the tree, keeping everything else intact.
+   *
+   * @param originalPath - Path to the original gridset file
+   * @param tree - Modified AACTree with pages to save
+   * @param outputPath - Path where the modified gridset should be saved
+   */
+  async saveModifiedTree(originalPath: string, tree: AACTree, outputPath: string): Promise<void> {
+    const { readBinaryFromInput, writeBinaryToPath } = this.options.fileAdapter;
+
+    if (Object.keys(tree.pages).length === 0) {
+      // Empty tree, just copy the original
+      const originalBuffer = await readBinaryFromInput(originalPath);
+      await writeBinaryToPath(outputPath, originalBuffer);
+      return;
+    }
+
+    const AdmZip = (await import('adm-zip')).default;
+    const originalZip = new AdmZip(originalPath);
+    const outputZip = new AdmZip();
+
+    // Collect styles from the tree for grid.xml files
+    const uniqueStyles = new Map<string, { id: string; style: AACStyle }>();
+    let styleIdCounter = 1;
+
+    const addStyle = (style: AACStyle | undefined): string => {
+      if (!style) return '';
+      const normalizedStyle: AACStyle = { ...style };
+      const styleKey = JSON.stringify(normalizedStyle);
+      const existing = uniqueStyles.get(styleKey);
+      if (existing) return existing.id;
+
+      const styleId = `Style${styleIdCounter++}`;
+      uniqueStyles.set(styleKey, { id: styleId, style: normalizedStyle });
+      return styleId;
+    };
+
+    // Collect all styles from pages and buttons
+    Object.values(tree.pages).forEach((page) => {
+      addStyle(page.style);
+      page.buttons.forEach((button) => {
+        addStyle(button.style);
+      });
+    });
+
+    // Track which grid files we're modifying
+    const modifiedGridFiles = new Set<string>();
+
+    // Generate grid.xml files for pages in the tree
+    const newGridFiles = new Map<string, string>();
+
+    for (const page of Object.values(tree.pages)) {
+      const gridPath = `Grids/${page.name}/grid.xml`;
+      modifiedGridFiles.add(gridPath);
+
+      // Build the grid XML content
+      const gridData = {
+        Grid: {
+          '@_xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+          GridGuid: page.id,
+          ColumnDefinitions: this.calculateColumnDefinitions(page),
+          RowDefinitions: this.calculateRowDefinitions(page, false),
+          AutoContentCommands: '',
+          Cells:
+            page.buttons.length > 0
+              ? {
+                  Cell: this.filterPageButtons(page.buttons).map((button, btnIndex) => {
+                    const buttonStyleId = button.style ? addStyle(button.style) : '';
+                    const position = this.findButtonPosition(page, button, btnIndex);
+
+                    const captionAndImage: Record<string, unknown> = {
+                      Caption: button.label || '',
+                    };
+
+                    // Handle image references
+                    if (button.image) {
+                      captionAndImage.Image = `${button.image}`;
+                    }
+
+                    const cell: Record<string, unknown> = {
+                      '@_Column': position.x,
+                      '@_Row': position.y,
+                      captionAndImage,
+                    };
+
+                    if (position.columnSpan > 1) {
+                      cell['@_ColumnSpan'] = position.columnSpan;
+                    }
+                    if (position.rowSpan > 1) {
+                      cell['@_RowSpan'] = position.rowSpan;
+                    }
+
+                    if (buttonStyleId) {
+                      cell.CellStyle = buttonStyleId;
+                    }
+
+                    if (button.message && button.message !== button.label) {
+                      // Use spoken message if different from label
+                      const spoken = button.message;
+                      const cellContent: Record<string, unknown> = {
+                        spoken,
+                        type: 'text',
+                      };
+                      cell['ContentCell'] = cellContent;
+                    }
+
+                    return cell;
+                  }),
+                }
+              : undefined,
+        },
+      };
+
+      const gridBuilder = new XMLBuilder({
+        ignoreAttributes: false,
+        format: true,
+        indentBy: '  ',
+        suppressEmptyNode: true,
+      });
+
+      newGridFiles.set(gridPath, gridBuilder.build(gridData));
+    }
+
+    // Copy all files from original zip, replacing modified grid files
+    for (const entry of originalZip.getEntries()) {
+      if (entry.isDirectory) continue;
+
+      // Skip grid.xml files that we're modifying
+      if (modifiedGridFiles.has(entry.entryName)) {
+        const newContent = newGridFiles.get(entry.entryName);
+        if (newContent) {
+          outputZip.addFile(entry.entryName, Buffer.from(newContent, 'utf8'));
+        }
+        continue;
+      }
+
+      // Copy all other files as-is
+      outputZip.addFile(entry.entryName, entry.getData());
+    }
+
+    // Write the output ZIP
+    const outputBuffer = outputZip.toBuffer();
+    await writeBinaryToPath(outputPath, outputBuffer);
+  }
+
   // Helper method to find button position with span information
   private findButtonPosition(
     page: AACPage,
diff --git a/src/processors/obfProcessor.ts b/src/processors/obfProcessor.ts
@@ -838,6 +838,92 @@ class ObfProcessor extends BaseProcessor {
     }
   }
 
+  /**
+   * Save a modified tree while preserving all original files (images, sounds, assets)
+   * This method only updates the .obf files for pages in the tree, keeping everything else intact.
+   *
+   * @param originalPath - Path to the original OBF/OBZ file
+   * @param tree - Modified AACTree with pages to save
+   * @param outputPath - Path where the modified file should be saved
+   */
+  async saveModifiedTree(originalPath: string, tree: AACTree, outputPath: string): Promise<void> {
+    const { writeBinaryToPath, readBinaryFromInput } = this.options.fileAdapter;
+
+    // If output is .obf (single file), use regular save
+    if (outputPath.endsWith('.obf')) {
+      await this.saveFromTree(tree, outputPath);
+      return;
+    }
+
+    if (Object.keys(tree.pages).length === 0) {
+      // Empty tree, just copy the original
+      const originalBuffer = await readBinaryFromInput(originalPath);
+      await writeBinaryToPath(outputPath, originalBuffer);
+      return;
+    }
+
+    const AdmZip = (await import('adm-zip')).default;
+    const originalZip = new AdmZip(originalPath);
+    const outputZip = new AdmZip();
+
+    const getPageFilename = (id: string): string => (id.endsWith('.obf') ? id : `${id}.obf`);
+
+    // Track which .obf files we're modifying
+    const modifiedObfFiles = new Set<string>();
+
+    // Generate new .obf files for pages in the tree
+    const newObfFiles = new Map<string, string>();
+
+    for (const page of Object.values(tree.pages)) {
+      const obfFilename = getPageFilename(page.id);
+      modifiedObfFiles.add(obfFilename);
+
+      const obfBoard = this.createObfBoardFromPage(page, 'Board', tree.metadata);
+      const obfContent = JSON.stringify(obfBoard, null, 2);
+      newObfFiles.set(obfFilename, obfContent);
+    }
+
+    // Generate updated manifest if we have pages
+    if (Object.keys(tree.pages).length > 0) {
+      modifiedObfFiles.add('manifest.json');
+
+      const manifest: ObfManifest = {
+        format: OBF_FORMAT_VERSION,
+        root: tree.metadata.defaultHomePageId,
+        paths: {
+          boards: Object.fromEntries(
+            Object.entries(tree.pages).map(([id, page]) => [id, getPageFilename(page.id)])
+          ),
+          images: {},
+          sounds: {},
+        },
+      };
+
+      newObfFiles.set('manifest.json', JSON.stringify(manifest));
+    }
+
+    // Copy all files from original zip, replacing modified .obf files
+    for (const entry of originalZip.getEntries()) {
+      if (entry.isDirectory) continue;
+
+      // Skip .obf files that we're modifying
+      if (modifiedObfFiles.has(entry.entryName)) {
+        const newContent = newObfFiles.get(entry.entryName);
+        if (newContent) {
+          outputZip.addFile(entry.entryName, Buffer.from(newContent, 'utf8'));
+        }
+        continue;
+      }
+
+      // Copy all other files as-is (preserves images, sounds, etc.)
+      outputZip.addFile(entry.entryName, entry.getData());
+    }
+
+    // Write the output ZIP
+    const outputBuffer = outputZip.toBuffer();
+    await writeBinaryToPath(outputPath, outputBuffer);
+  }
+
   /**
    * Extract strings with metadata for aac-tools-platform compatibility
    * Uses the generic implementation from BaseProcessor
diff --git a/test/gridsetProcessor.test.ts b/test/gridsetProcessor.test.ts
@@ -83,4 +83,91 @@ describe('GridsetProcessor', () => {
       }
     });
   });
+
+  describe('saveModifiedTree', () => {
+    const tempOutputPath = path.join(__dirname, 'temp_gridset_modified.gridset');
+    const tempSaveFromTreePath = path.join(__dirname, 'temp_gridset_saveFromTree.gridset');
+
+    afterEach(async () => {
+      if (fs.existsSync(tempOutputPath)) {
+        fs.unlinkSync(tempOutputPath);
+      }
+      if (fs.existsSync(tempSaveFromTreePath)) {
+        fs.unlinkSync(tempSaveFromTreePath);
+      }
+    });
+
+    it('should preserve original file size better than saveFromTree', async () => {
+      const processor = new GridsetProcessor();
+
+      // Load the original file
+      const fileBuffer = fs.readFileSync(exampleFile);
+      const tree = await processor.loadIntoTree(fileBuffer);
+      const originalSize = fileBuffer.length;
+
+      // Save using saveModifiedTree
+      await processor.saveModifiedTree(exampleFile, tree, tempOutputPath);
+      const modifiedSize = fs.statSync(tempOutputPath).size;
+
+      // Save using saveFromTree for comparison
+      await processor.saveFromTree(tree, tempSaveFromTreePath);
+      const saveFromTreeSize = fs.statSync(tempSaveFromTreePath).size;
+
+      // saveModifiedTree should preserve file size much better than saveFromTree
+      expect(modifiedSize).toBeGreaterThan(saveFromTreeSize);
+
+      // saveModifiedTree should be at least 80% of original size (preserves most assets)
+      expect(modifiedSize / originalSize).toBeGreaterThan(0.8);
+    });
+
+    it('should produce a valid loadable gridset', async () => {
+      const processor = new GridsetProcessor();
+
+      // Load the original file
+      const fileBuffer = fs.readFileSync(exampleFile);
+      const tree = await processor.loadIntoTree(fileBuffer);
+      const originalPageCount = Object.keys(tree.pages).length;
+
+      // Save using saveModifiedTree
+      await processor.saveModifiedTree(exampleFile, tree, tempOutputPath);
+
+      // Load the saved file
+      const savedBuffer = fs.readFileSync(tempOutputPath);
+      const savedTree = await processor.loadIntoTree(savedBuffer);
+
+      // Verify the saved tree has the same pages
+      expect(Object.keys(savedTree.pages).length).toBe(originalPageCount);
+      expect(savedTree.rootId).toBe(tree.rootId);
+    });
+
+    it('should handle empty tree by copying original', async () => {
+      const processor = new GridsetProcessor();
+
+      // Create an empty tree
+      const emptyTree: AACTree = {
+        pages: {},
+        rootId: null,
+        toolbarId: null,
+        dashboardId: null,
+        metadata: {},
+        addPage() {
+          throw new Error('Not implemented');
+        },
+        getPage() {
+          return undefined;
+        },
+        traverse() {
+          // Empty - nothing to traverse
+        },
+      };
+
+      // Save using saveModifiedTree
+      await processor.saveModifiedTree(exampleFile, emptyTree, tempOutputPath);
+
+      // Verify the file was copied (same size)
+      const originalSize = fs.statSync(exampleFile).size;
+      const copiedSize = fs.statSync(tempOutputPath).size;
+      expect(copiedSize).toBe(originalSize);
+    });
+  });
 });
diff --git a/test/obfProcessor.test.ts b/test/obfProcessor.test.ts
