Merge pull request #24 from sonicbaume/zip-adapter-constructor

Encode zips using adapter

Author: willwade

src/core/baseProcessor.ts

@@ -44,10 +44,10 @@ import { AACTree, AACButton, AACSemanticCategory } from './treeStructure';
 import { StringCasing, detectCasing, isNumericOrEmpty } from './stringCasing';
 import { ValidationResult } from '../validation/validationTypes';
 import { BinaryOutput, ProcessorInput } from '../utils/io';
-import type { ZipAdapter } from '../utils/zip';
+import { getZipAdapter, ZipAdapter } from '../utils/zip';
 
 // Configuration options for processors
-export interface ProcessorOptions {
+export interface ProcessorConfig {
   // Filter out navigation/system buttons (enabled by default)
   excludeNavigationButtons?: boolean;
   excludeSystemButtons?: boolean;
@@ -73,9 +73,10 @@ export interface ProcessorOptions {
   // Defaults to 'en-GB' if not specified
   grid3Locale?: string;
 
-  // Optionally provide your own adapter for unzipping the input
-  zipAdapter?: (input: ProcessorInput) => Promise<{ zip: ZipAdapter }>;
+  // Adapter for handling encoding/decoding zip files
+  zipAdapter: (input?: ProcessorInput) => Promise<ZipAdapter>;
 }
+export type ProcessorOptions = Partial<ProcessorConfig>;
 
 // Types for aac-tools-platform compatibility
 export interface ExtractedString {
@@ -117,14 +118,15 @@ export interface SourceString {
 }
 
 abstract class BaseProcessor {
-  protected options: ProcessorOptions;
+  protected options: ProcessorConfig;
 
   constructor(options: ProcessorOptions = {}) {
     // Default configuration: exclude navigation/system buttons
     this.options = {
       excludeNavigationButtons: true,
       excludeSystemButtons: true,
       preserveAllButtons: false,
+      zipAdapter: getZipAdapter,
       ...options,
     };
   }

src/processors/gridset/helpers.ts

@@ -12,8 +12,8 @@ import { execSync } from 'child_process';
 import Database from 'better-sqlite3';
 import { dotNetTicksToDate } from '../../utils/dotnetTicks';
 import { getZipEntriesFromAdapter, resolveGridsetPasswordFromEnv } from './password';
-import { openZipFromInput, type ZipAdapter } from '../../utils/zip';
-import type { ProcessorInput } from '../../utils/io';
+import { ProcessorInput } from '../../utils/io';
+import { getZipAdapter, ZipAdapter } from '../../utils/zip';
 
 function normalizeZipPath(p: string): string {
   const unified = p.replace(/\\/g, '/');
@@ -64,12 +64,10 @@ export async function openImage(
   gridsetBuffer: Uint8Array,
   entryPath: string,
   password = resolveGridsetPasswordFromEnv(),
-  zipAdapter?: (input: ProcessorInput) => Promise<{ zip: ZipAdapter }>
+  zipAdapter?: (input?: ProcessorInput) => Promise<ZipAdapter>
 ): Promise<Uint8Array | null> {
   try {
-    const { zip } = zipAdapter
-      ? await zipAdapter(gridsetBuffer)
-      : await openZipFromInput(gridsetBuffer);
+    const zip = zipAdapter ? await zipAdapter(gridsetBuffer) : await getZipAdapter(gridsetBuffer);
     const entries = getZipEntriesFromAdapter(zip, password);
     const want = normalizeZipPath(entryPath);
     const entry = entries.find((e) => normalizeZipPath(e.entryName) === want);

src/processors/gridset/imageDebug.ts

@@ -5,11 +5,11 @@
  * correctly in Grid3 gridsets.
  */
 
-import { openZipFromInput, type ZipAdapter } from '../../utils/zip';
 import { getZipEntriesFromAdapter } from './password';
 import { resolveGridsetPasswordFromEnv } from './password';
 import { XMLParser } from 'fast-xml-parser';
 import { decodeText, type ProcessorInput } from '../../utils/io';
+import { getZipAdapter, ZipAdapter } from '../../utils/zip';
 
 export interface ImageIssue {
   gridName: string;
@@ -46,7 +46,7 @@ export interface ImageAuditResult {
 export async function auditGridsetImages(
   gridsetBuffer: Uint8Array,
   password = resolveGridsetPasswordFromEnv(),
-  zipAdapter?: (input: ProcessorInput) => Promise<{ zip: ZipAdapter }>
+  zipAdapter?: (input: ProcessorInput) => Promise<ZipAdapter>
 ): Promise<ImageAuditResult> {
   const issues: ImageIssue[] = [];
   const availableImages = new Set<string>();
@@ -56,9 +56,7 @@ export async function auditGridsetImages(
   let unresolvedImages = 0;
 
   try {
-    const { zip } = zipAdapter
-      ? await zipAdapter(gridsetBuffer)
-      : await openZipFromInput(gridsetBuffer);
+    const zip = zipAdapter ? await zipAdapter(gridsetBuffer) : await getZipAdapter(gridsetBuffer);
 
     const entries = getZipEntriesFromAdapter(zip, password);
     const parser = new XMLParser();

src/processors/gridset/password.ts

@@ -1,7 +1,7 @@
 import type JSZip from 'jszip';
 import { ProcessorOptions } from '../../core/baseProcessor';
 import { ProcessorInput } from '../../utils/io';
-import { type ZipAdapter } from '../../utils/zip';
+import { ZipAdapter } from '../../utils/zip';
 
 function getExtension(source: string): string {
   const index = source.lastIndexOf('.');

src/processors/gridset/symbolExtractor.ts

@@ -13,8 +13,9 @@
  */
 
 import * as fs from 'fs';
-import AdmZip from 'adm-zip';
 import { resolveSymbolReference, parseSymbolReference, type SymbolReference } from './symbols';
+import { ProcessorInput } from '../../utils/io';
+import { getZipAdapter, ZipAdapter } from '../../utils/zip';
 
 /**
  * Image extraction result
@@ -88,21 +89,22 @@ const OPEN_LICENSE_SYMBOLS: {
  * @param options - Extraction options
  * @returns Extracted image data
  */
-export function extractButtonImage(
+export async function extractButtonImage(
   gridsetBuffer: Buffer,
   resolvedImageEntry: string | undefined,
   symbolReference: string | undefined,
-  options: SymbolExtractionOptions = {}
-): ExtractedImage {
+  options: SymbolExtractionOptions = {},
+  zipAdapter: (input: ProcessorInput) => Promise<ZipAdapter>
+): Promise<ExtractedImage> {
   // Priority 1: Use embedded image if available
   if (resolvedImageEntry && options.preferEmbedded !== false) {
     try {
-      const zip = new AdmZip(gridsetBuffer);
-      const entries = zip.getEntries();
-      const entry = entries.find((e: any) => e.entryName === resolvedImageEntry);
+      const zip = zipAdapter ? await zipAdapter(gridsetBuffer) : await getZipAdapter(gridsetBuffer);
+      const entries = zip.listFiles();
+      const entry = entries.find((e) => e === resolvedImageEntry);
 
       if (entry) {
-        const data = entry.getData();
+        const data = Buffer.from(await zip.readFile(entry));
         const format = detectImageFormat(data);
         return {
           found: true,
@@ -119,7 +121,7 @@ export function extractButtonImage(
 
   // Priority 2: Check symbol library reference
   if (symbolReference) {
-    return extractSymbolLibraryImage(symbolReference, options);
+    return await extractSymbolLibraryImage(symbolReference, options);
   }
 
   // Not found
@@ -135,10 +137,10 @@ export function extractButtonImage(
  * @param options - Extraction options
  * @returns Extracted image or reference info
  */
-export function extractSymbolLibraryImage(
+export async function extractSymbolLibraryImage(
   reference: string,
   options: SymbolExtractionOptions = {}
-): ExtractedImage {
+): Promise<ExtractedImage> {
   const ref = parseSymbolReferenceSafe(reference);
 
   if (!ref || !ref.isValid) {
@@ -153,7 +155,7 @@ export function extractSymbolLibraryImage(
   const libInfo = OPEN_LICENSE_SYMBOLS[ref.library as keyof typeof OPEN_LICENSE_SYMBOLS];
 
   // Resolve symbol reference and extract from .symbols file
-  const resolved = resolveSymbolReference(reference, {
+  const resolved = await resolveSymbolReference(reference, {
     grid3Path: options.grid3Path,
   });
 

src/processors/gridset/symbols.ts

@@ -13,7 +13,8 @@
  * This module provides symbol resolution and metadata extraction.
  */
 
-import { getFs, getNodeRequire, getPath } from '../../utils/io';
+import { getFs, getPath, ProcessorInput } from '../../utils/io';
+import { getZipAdapter, ZipAdapter } from '../../utils/zip';
 
 /**
  * Default Grid 3 installation paths by platform
@@ -123,23 +124,6 @@ function getNodePath(): typeof import('path') {
   }
 }
 
-let cachedAdmZip: typeof import('adm-zip') | null = null;
-function getAdmZip(): typeof import('adm-zip') {
-  if (cachedAdmZip) return cachedAdmZip;
-  try {
-    const nodeRequire = getNodeRequire();
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const module = nodeRequire('adm-zip') as typeof import('adm-zip') & {
-      default?: typeof import('adm-zip');
-    };
-    const resolved = module.default || module;
-    cachedAdmZip = resolved;
-    return resolved;
-  } catch {
-    throw new Error('Symbol library access requires AdmZip in this environment.');
-  }
-}
-
 /**
  * Parse a symbol reference string
  * @param reference - Symbol reference like "[widgit]/food/apple.png"
@@ -337,10 +321,11 @@ export function getSymbolLibraryInfo(
  * @param options - Resolution options
  * @returns Resolution result with image data if found
  */
-export function resolveSymbolReference(
+export async function resolveSymbolReference(
   reference: string,
-  options: SymbolResolutionOptions = {}
-): SymbolResolutionResult {
+  options: SymbolResolutionOptions = {},
+  zipAdapter?: (input: ProcessorInput) => Promise<ZipAdapter>
+): Promise<SymbolResolutionResult> {
   const parsed = parseSymbolReference(reference);
 
   if (!parsed.isValid) {
@@ -373,19 +358,19 @@ export function resolveSymbolReference(
 
   try {
     // .symbols files are ZIP archives
-    const AdmZip = getAdmZip();
-    const zip = new AdmZip(libraryInfo.pixFile);
+    const zipFile = libraryInfo.pixFile;
+    const zip = zipAdapter ? await zipAdapter(zipFile) : await getZipAdapter(zipFile);
 
     // The path in the symbol reference becomes the path within the symbols/ folder
     // e.g., [tawasl]/above bw.png becomes symbols/above bw.png
     const symbolPath = `symbols/${parsed.path}`;
 
-    const entry = zip.getEntry(symbolPath);
+    const entry = await zip.readFile(symbolPath);
 
     if (!entry) {
       // Try without the symbols/ prefix (in case reference already includes it)
       const altPath = parsed.path.startsWith('symbols/') ? parsed.path : `symbols/${parsed.path}`;
-      const altEntry = zip.getEntry(altPath);
+      const altEntry = await zip.readFile(altPath);
 
       if (!altEntry) {
         return {
@@ -398,7 +383,7 @@ export function resolveSymbolReference(
       }
 
       // Found with alternate path
-      const data = altEntry.getData();
+      const data = Buffer.from(altEntry);
       return {
         reference: parsed,
         found: true,
@@ -409,7 +394,7 @@ export function resolveSymbolReference(
     }
 
     // Found the symbol!
-    const data = entry.getData();
+    const data = Buffer.from(entry);
     return {
       reference: parsed,
       found: true,

src/processors/gridset/wordlistHelpers.ts

@@ -11,9 +11,9 @@
 
 import { XMLParser, XMLBuilder } from 'fast-xml-parser';
 import { getZipEntriesFromAdapter, resolveGridsetPasswordFromEnv } from './password';
-import { openZipFromInput, type ZipAdapter } from '../../utils/zip';
-import { getNodeRequire, isNodeRuntime, type ProcessorInput } from '../../utils/io';
+import { type ProcessorInput } from '../../utils/io';
 import { decodeText } from '../../utils/io';
+import { getZipAdapter, ZipAdapter, ZipFile } from '../../utils/zip';
 
 /**
  * Represents a single item in a wordlist
@@ -131,15 +131,13 @@ export function wordlistToXml(wordlist: WordList): string {
 export async function extractWordlists(
   gridsetBuffer: Uint8Array,
   password = resolveGridsetPasswordFromEnv(),
-  zipAdapter?: (input: ProcessorInput) => Promise<{ zip: ZipAdapter }>
+  zipAdapter?: (input: ProcessorInput) => Promise<ZipAdapter>
 ): Promise<Map<string, WordList>> {
   const wordlists = new Map<string, WordList>();
   const parser = new XMLParser();
 
   try {
-    const { zip } = zipAdapter
-      ? await zipAdapter(gridsetBuffer)
-      : await openZipFromInput(gridsetBuffer);
+    const zip = zipAdapter ? await zipAdapter(gridsetBuffer) : await getZipAdapter(gridsetBuffer);
     const entries = getZipEntriesFromAdapter(zip, password);
 
     // Process each grid file
@@ -212,7 +210,8 @@ export async function updateWordlist(
   gridsetBuffer: Uint8Array,
   gridName: string,
   wordlist: WordList,
-  password = resolveGridsetPasswordFromEnv()
+  password = resolveGridsetPasswordFromEnv(),
+  zipAdapter?: (input: ProcessorInput) => Promise<ZipAdapter>
 ): Promise<Uint8Array> {
   const parser = new XMLParser();
   const builder = new XMLBuilder({
@@ -222,50 +221,9 @@ export async function updateWordlist(
     suppressEmptyNode: false,
   });
 
-  let entries: Array<{
-    entryName: string;
-    getData: () => Promise<Uint8Array>;
-  }>;
-  let saveZip: (() => Promise<Uint8Array>) | null = null;
-  let updateEntry: ((entryName: string, xml: string) => void) | null = null;
-
-  try {
-    if (isNodeRuntime()) {
-      const AdmZip = getNodeRequire()('adm-zip') as typeof import('adm-zip');
-      const zip = new AdmZip(Buffer.from(gridsetBuffer));
-      entries = zip.getEntries().map((entry) => ({
-        entryName: entry.entryName,
-        getData: () => Promise.resolve(entry.getData()),
-      }));
-      updateEntry = (entryName: string, xml: string) => {
-        zip.addFile(entryName, Buffer.from(xml, 'utf8'));
-      };
-      saveZip = () => Promise.resolve(zip.toBuffer());
-    } else {
-      const module = await import('jszip');
-      const JSZip = module.default || module;
-      const zip = await JSZip.loadAsync(gridsetBuffer);
-      entries = getZipEntriesFromAdapter(
-        {
-          listFiles: () => Object.keys(zip.files),
-          readFile: async (name: string) => {
-            const file = zip.file(name);
-            if (!file) {
-              throw new Error(`Zip entry not found: ${name}`);
-            }
-            return file.async('uint8array');
-          },
-        },
-        password
-      );
-      updateEntry = (entryName: string, xml: string) => {
-        zip.file(entryName, xml, { binary: false });
-      };
-      saveZip = async () => zip.generateAsync({ type: 'uint8array' });
-    }
-  } catch (error: any) {
-    throw new Error(`Invalid gridset buffer: ${error.message}`);
-  }
+  const updatedEntries: ZipFile[] = [];
+  const zip = zipAdapter ? await zipAdapter(gridsetBuffer) : await getZipAdapter(gridsetBuffer);
+  const entries = getZipEntriesFromAdapter(zip, password);
 
   let found = false;
 
@@ -308,9 +266,10 @@ export async function updateWordlist(
 
           // Rebuild the XML
           const updatedXml = builder.build(data);
-          if (updateEntry) {
-            updateEntry(entry.entryName, updatedXml);
-          }
+          updatedEntries.push({
+            name: entry.entryName,
+            data: updatedXml,
+          });
           found = true;
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error);
@@ -324,8 +283,5 @@ export async function updateWordlist(
     throw new Error(`Grid "${gridName}" not found in gridset`);
   }
 
-  if (!saveZip) {
-    throw new Error('Failed to serialize updated gridset.');
-  }
-  return await saveZip();
+  return await zip.writeFiles(updatedEntries);
 }