scanner-image-split abides by auto zip

frontend/src/hooks/tools/scannerImageSplit/useScannerImageSplitOperation.ts

@@ -1,8 +1,9 @@
+import { useCallback } from 'react';
 import { useTranslation } from 'react-i18next';
-import { ToolType, useToolOperation } from '../shared/useToolOperation';
+import { ToolType, useToolOperation, ToolOperationConfig } from '../shared/useToolOperation';
 import { createStandardErrorHandler } from '../../../utils/toolErrorHandler';
 import { ScannerImageSplitParameters, defaultParameters } from './useScannerImageSplitParameters';
-import { zipFileService } from '../../../services/zipFileService';
+import { useToolResources } from '../shared/useToolResources';
 
 export const buildScannerImageSplitFormData = (parameters: ScannerImageSplitParameters, file: File): FormData => {
   const formData = new FormData();
@@ -15,40 +16,46 @@ export const buildScannerImageSplitFormData = (parameters: ScannerImageSplitPara
   return formData;
 };
 
-// Custom response handler to handle ZIP files that might be misidentified
-const scannerImageSplitResponseHandler = async (responseData: Blob, inputFiles: File[]): Promise<File[]> => {
-  try {
-    // Always try to extract as ZIP first, regardless of content-type
-    const extractionResult = await zipFileService.extractAllFiles(responseData);
-    if (extractionResult.success && extractionResult.extractedFiles.length > 0) {
-      return extractionResult.extractedFiles;
-    }
-  } catch (error) {
-    console.warn('Failed to extract as ZIP, treating as single file:', error);
-  }
-
-  // Fallback: treat as single file (PNG image)
-  const inputFileName = inputFiles[0]?.name || 'document';
-  const baseFileName = inputFileName.replace(/\.[^.]+$/, '');
-  const singleFile = new File([responseData], `${baseFileName}.png`, { type: 'image/png' });
-  return [singleFile];
-};
-
+// Static configuration object
 export const scannerImageSplitOperationConfig = {
   toolType: ToolType.singleFile,
   buildFormData: buildScannerImageSplitFormData,
   operationType: 'scannerImageSplit',
   endpoint: '/api/v1/misc/extract-image-scans',
-  multiFileEndpoint: false,
-  responseHandler: scannerImageSplitResponseHandler,
   defaultParameters,
 } as const;
 
 export const useScannerImageSplitOperation = () => {
   const { t } = useTranslation();
+  const { extractAllZipFiles } = useToolResources();
 
-  return useToolOperation<ScannerImageSplitParameters>({
+  // Custom response handler that extracts ZIP files containing images
+  // Can't add to exported config because it requires access to the hook so must be part of the hook
+  const responseHandler = useCallback(async (blob: Blob, originalFiles: File[]): Promise<File[]> => {
+    try {
+      // Scanner image split returns ZIP files with multiple images
+      const extractedFiles = await extractAllZipFiles(blob);
+
+      // If extraction succeeded and returned files, use them
+      if (extractedFiles.length > 0) {
+        return extractedFiles;
+      }
+    } catch (error) {
+      console.warn('Failed to extract as ZIP, treating as single file:', error);
+    }
+
+    // Fallback: treat as single file (PNG image)
+    const inputFileName = originalFiles[0]?.name || 'document';
+    const baseFileName = inputFileName.replace(/\.[^.]+$/, '');
+    const singleFile = new File([blob], `${baseFileName}.png`, { type: 'image/png' });
+    return [singleFile];
+  }, [extractAllZipFiles]);
+
+  const config: ToolOperationConfig<ScannerImageSplitParameters> = {
     ...scannerImageSplitOperationConfig,
+    responseHandler,
     getErrorMessage: createStandardErrorHandler(t('scannerImageSplit.error.failed', 'An error occurred while extracting image scans.'))
-  });
+  };
+
+  return useToolOperation(config);
 };

frontend/src/hooks/tools/shared/useToolResources.ts

@@ -99,30 +99,21 @@ export const useToolResources = () => {
     }
   }, [preferences.autoUnzip]);
 
-  const extractAllZipFiles = useCallback(async (zipBlob: Blob): Promise<File[]> => {
+  const extractAllZipFiles = useCallback(async (zipBlob: Blob, skipAutoUnzip = false): Promise<File[]> => {
     try {
-      const JSZip = (await import('jszip')).default;
-      const zip = new JSZip();
-
-      const arrayBuffer = await zipBlob.arrayBuffer();
-      const zipContent = await zip.loadAsync(arrayBuffer);
-
-      const extractedFiles: File[] = [];
-
-      for (const [filename, file] of Object.entries(zipContent.files)) {
-        if (!file.dir) {
-          const content = await file.async('blob');
-          const extractedFile = new File([content], filename, { type: 'application/pdf' });
-          extractedFiles.push(extractedFile);
-        }
+      // Check if auto-unzip is disabled (unless explicitly skipped like in automation)
+      if (!skipAutoUnzip && !preferences.autoUnzip) {
+        return [new File([zipBlob], 'result.zip', { type: 'application/zip' })];
       }
 
-      return extractedFiles;
+      const zipFile = new File([zipBlob], 'temp.zip', { type: 'application/zip' });
+      const extractionResult = await zipFileService.extractAllFiles(zipFile);
+      return extractionResult.success ? extractionResult.extractedFiles : [];
     } catch (error) {
-      console.error('Error in extractAllZipFiles:', error);
+      console.error('useToolResources.extractAllZipFiles - Error:', error);
       return [];
     }
-  }, []);
+  }, [preferences.autoUnzip]);
 
   const createDownloadInfo = useCallback(async (
     files: File[],