adding .sub to snap

Author: willwade

src/core/fileProcessor.ts

@@ -26,6 +26,13 @@ class FileProcessor {
   static detectFormat(filePathOrBuffer: string | Buffer): FileFormat {
     if (typeof filePathOrBuffer === 'string') {
       const ext = path.extname(filePathOrBuffer).toLowerCase();
+      const fileName = path.basename(filePathOrBuffer).toLowerCase();
+
+      // Handle double extensions like .sub.zip
+      if (fileName.endsWith('.sub.zip') || ext === '.sub') {
+        return 'snap';
+      }
+
       switch (ext) {
         case '.gridset':
         case '.gridsetx':

src/processors/snapProcessor.ts

@@ -17,8 +17,9 @@ import {
 import { generateCloneId } from '../utilities/analytics/utils/idGenerator';
 import { SnapValidator } from '../validation/snapValidator';
 import { ValidationResult } from '../validation/validationTypes';
-import { ProcessorInput, getFs, getNodeRequire, getPath, isNodeRuntime } from '../utils/io';
+import { ProcessorInput, getFs, getNodeRequire, getPath, isNodeRuntime, getOs } from '../utils/io';
 import { openSqliteDatabase, requireBetterSqlite3 } from '../utils/sqlite';
+import { openZipFromInput } from '../utils/zip';
 
 /**
  * Convert a Buffer or Uint8Array to base64 string (browser and Node compatible)
@@ -123,8 +124,45 @@ class SnapProcessor extends BaseProcessor {
     await Promise.resolve();
     const tree = new AACTree();
     let dbResult: Awaited<ReturnType<typeof openSqliteDatabase>> | null = null;
+    let cleanupTempZip: (() => void) | null = null;
+
     try {
-      dbResult = await openSqliteDatabase(filePathOrBuffer, { readonly: true });
+      // Handle .sub.zip files (Snap pageset backups containing .sps files)
+      let inputFile = filePathOrBuffer;
+
+      if (typeof filePathOrBuffer === 'string') {
+        const fileName = getPath().basename(filePathOrBuffer).toLowerCase();
+        if (fileName.endsWith('.sub.zip') || filePathOrBuffer.endsWith('.sub')) {
+          const fs = getFs();
+          const path = getPath();
+          const os = getOs();
+
+          // Extract .sub.zip to find the embedded .sps file
+          const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'snap-sub-'));
+          const { zip } = await openZipFromInput(filePathOrBuffer);
+
+          // Find the .sps file in the archive
+          const files = zip.listFiles();
+          const spsFile = files.find((f) => f.endsWith('.sps'));
+
+          if (!spsFile) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+            throw new Error('No .sps file found in .sub.zip archive');
+          }
+
+          // Extract the .sps file
+          const spsData = await zip.readFile(spsFile);
+          const extractedSpsPath = path.join(tempDir, path.basename(spsFile));
+          fs.writeFileSync(extractedSpsPath, Buffer.from(spsData));
+
+          inputFile = extractedSpsPath;
+          cleanupTempZip = () => {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+          };
+        }
+      }
+
+      dbResult = await openSqliteDatabase(inputFile, { readonly: true });
       const db = dbResult.db;
 
       const getTableColumns = (tableName: string): Set<string> => {
@@ -789,6 +827,14 @@ class SnapProcessor extends BaseProcessor {
       } else if (dbResult?.db) {
         dbResult.db.close();
       }
+      // Clean up temporary extracted .sps file from .sub.zip
+      if (cleanupTempZip) {
+        try {
+          cleanupTempZip();
+        } catch (e) {
+          console.warn('[SnapProcessor] Failed to clean up temporary .sps file:', e);
+        }
+      }
     }
   }
 

test/core/fileProcessor.test.ts

@@ -125,6 +125,9 @@ describe('FileProcessor', () => {
       it('should detect snap format', async () => {
         expect(FileProcessor.detectFormat('test.sps')).toBe('snap');
         expect(FileProcessor.detectFormat('test.spb')).toBe('snap');
+        expect(FileProcessor.detectFormat('test.sub')).toBe('snap');
+        expect(FileProcessor.detectFormat('test.sub.zip')).toBe('snap');
+        expect(FileProcessor.detectFormat('/path/to/My Pageset.sub.zip')).toBe('snap');
       });
 
       it('should detect dot format', async () => {

test/snapProcessor.test.ts

@@ -1,10 +1,12 @@
 import { SnapProcessor } from '../src/processors/snapProcessor';
 import { AACTree } from '../src/core/treeStructure';
 import path from 'path';
+import fs from 'fs';
 
 describe('SnapProcessor', () => {
   const exampleFile: string = path.join(__dirname, 'assets/snap/example.spb');
   const exampleSPSFile: string = path.join(__dirname, 'assets/snap/example.sps');
+  const exampleSubZipFile: string = path.join(__dirname, 'assets/snap/example.sub.zip');
 
   it('should extract all texts from a .spb file', async () => {
     const processor = new SnapProcessor();
@@ -58,6 +60,19 @@ describe('SnapProcessor', () => {
     }
   });
 
+  it('should handle .sub.zip files by extracting and processing the embedded .sps file', async () => {
+    const processor = new SnapProcessor();
+    // Skip test if example .sub.zip file doesn't exist
+    if (!fs.existsSync(exampleSubZipFile)) {
+      console.warn(`Skipping .sub.zip test - file not found: ${exampleSubZipFile}`);
+      return;
+    }
+    const tree: AACTree = await processor.loadIntoTree(exampleSubZipFile);
+    expect(tree).toBeTruthy();
+    const pageIds: string[] = Object.keys(tree.pages);
+    expect(pageIds.length).toBeGreaterThan(0);
+  });
+
   describe('Error Handling', () => {
     it('should throw error for non-existent file', async () => {
       const processor = new SnapProcessor();