@lobehub/chat 1.142.2 → 1.142.4

package/src/features/FileManager/FileList/index.tsx

@@ -51,10 +51,15 @@ const FileList = memo<FileListProps>(({ knowledgeBaseId, category }) => {
 
   const [selectFileIds, setSelectedFileIds] = useState<string[]>([]);
   const [viewConfig, setViewConfig] = useState({ showFilesInKnowledgeBase: false });
+  const [lastSelectedIndex, setLastSelectedIndex] = useState<number | null>(null);
+  const [isTransitioning, setIsTransitioning] = useState(false);
 
   const viewMode = useGlobalStore((s) => s.status.fileManagerViewMode || 'list') as ViewMode;
   const updateSystemStatus = useGlobalStore((s) => s.updateSystemStatus);
-  const setViewMode = (mode: ViewMode) => updateSystemStatus({ fileManagerViewMode: mode });
+  const setViewMode = (mode: ViewMode) => {
+    setIsTransitioning(true);
+    updateSystemStatus({ fileManagerViewMode: mode });
+  };
 
   const [columnCount, setColumnCount] = useState(4);
 
@@ -105,6 +110,19 @@ const FileList = memo<FileListProps>(({ knowledgeBaseId, category }) => {
     ...viewConfig,
   });
 
+  // Handle view transition with a brief delay to show skeleton
+  React.useEffect(() => {
+    if (isTransitioning && data) {
+      // Use requestAnimationFrame to ensure smooth transition
+      requestAnimationFrame(() => {
+        const timer = setTimeout(() => {
+          setIsTransitioning(false);
+        }, 100);
+        return () => clearTimeout(timer);
+      });
+    }
+  }, [isTransitioning, viewMode, data]);
+
   useCheckTaskStatus(data);
 
   // Clean up selected files that no longer exist in the data
@@ -118,6 +136,13 @@ const FileList = memo<FileListProps>(({ knowledgeBaseId, category }) => {
     }
   }, [data]);
 
+  // Reset lastSelectedIndex when selection is cleared
+  React.useEffect(() => {
+    if (selectFileIds.length === 0) {
+      setLastSelectedIndex(null);
+    }
+  }, [selectFileIds.length]);
+
   // Memoize context object to avoid recreating on every render
   const masonryContext = useMemo(
     () => ({
@@ -161,7 +186,7 @@ const FileList = memo<FileListProps>(({ knowledgeBaseId, category }) => {
           </Flexbox>
         )}
       </Flexbox>
-      {isLoading ? (
+      {isLoading || isTransitioning ? (
         viewMode === 'masonry' ? (
           <MasonrySkeleton columnCount={columnCount} />
         ) : (
@@ -184,13 +209,30 @@ const FileList = memo<FileListProps>(({ knowledgeBaseId, category }) => {
               index={index}
               key={item.id}
               knowledgeBaseId={knowledgeBaseId}
-              onSelectedChange={(id, checked) => {
-                setSelectedFileIds((prev) => {
-                  if (checked) {
-                    return [...prev, id];
-                  }
-                  return prev.filter((item) => item !== id);
-                });
+              onSelectedChange={(id, checked, shiftKey, clickedIndex) => {
+                if (shiftKey && lastSelectedIndex !== null && selectFileIds.length > 0 && data) {
+                  // Range selection with shift key
+                  const start = Math.min(lastSelectedIndex, clickedIndex);
+                  const end = Math.max(lastSelectedIndex, clickedIndex);
+                  const rangeIds = data.slice(start, end + 1).map((item) => item.id);
+
+                  setSelectedFileIds((prev) => {
+                    // Create a Set for efficient lookup
+                    const prevSet = new Set(prev);
+                    // Add all items in range
+                    rangeIds.forEach((rangeId) => prevSet.add(rangeId));
+                    return Array.from(prevSet);
+                  });
+                } else {
+                  // Normal selection
+                  setSelectedFileIds((prev) => {
+                    if (checked) {
+                      return [...prev, id];
+                    }
+                    return prev.filter((item) => item !== id);
+                  });
+                }
+                setLastSelectedIndex(clickedIndex);
               }}
               selected={selectFileIds.includes(item.id)}
               {...item}

package/src/features/ModelSwitchPanel/index.tsx

@@ -161,6 +161,7 @@ const ModelSwitchPanel = memo<IProps>(({ children, onOpenChange, open }) => {
       onOpenChange={onOpenChange}
       open={open}
       placement={'topLeft'}
+      prefetch
     >
       {icon}
     </ActionDropdown>

package/src/locales/default/chat.ts

@@ -175,9 +175,9 @@ export default {
     addMember: '添加成员',
     allMembers: '全体成员',
     createGroup: '创建 Agent 团队',
-    noAvailableAgents: '没有可邀请的助手',
-    noSelectedAgents: '还未选择助手',
-    searchAgents: '搜索助手...',
+    noAvailableAgents: '没有可邀请的 Agent',
+    noSelectedAgents: '还未选择 Agent',
+    searchAgents: '搜索 Agent...',
     setInitialMembers: '选择团队成员',
   },
 
@@ -247,7 +247,7 @@ export default {
     jumpToMessage: '跳转至第 {{index}} 条消息',
     nextMessage: '下一条消息',
     previousMessage: '上一条消息',
-    senderAssistant: '助手',
+    senderAssistant: 'Agent',
     senderUser: '你',
   },
 

package/src/locales/default/file.ts

@@ -86,6 +86,7 @@ export default {
         restTime: '剩余 {{time}}',
       },
     },
+    fileQueueInfo: '正在上传前 {{count}} 个文件，剩余 {{remaining}} 个文件将排队上传',
     totalCount: '共 {{count}} 项',
     uploadStatus: {
       error: '上传出错',

package/src/store/file/slices/fileManager/action.test.ts

@@ -2,17 +2,50 @@ import { act, renderHook, waitFor } from '@testing-library/react';
 import { mutate } from 'swr';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { FILE_UPLOAD_BLACKLIST } from '@/const/file';
+import { message } from '@/components/AntdStaticMethods';
+import { FILE_UPLOAD_BLACKLIST, MAX_UPLOAD_FILE_COUNT } from '@/const/file';
 import { lambdaClient } from '@/libs/trpc/client';
 import { fileService } from '@/services/file';
 import { ragService } from '@/services/rag';
 import { FileListItem } from '@/types/files';
 import { UploadFileItem } from '@/types/files/upload';
+import { unzipFile } from '@/utils/unzipFile';
 
 import { useFileStore as useStore } from '../../store';
 
 vi.mock('zustand/traditional');
 
+// Mock i18next translation function
+vi.mock('i18next', () => ({
+  t: (key: string, options?: any) => {
+    // Return a mock translation string that includes the options for verification
+    if (key === 'uploadDock.fileQueueInfo' && options?.count !== undefined) {
+      return `Uploading ${options.count} files, ${options.remaining} queued`;
+    }
+    return key;
+  },
+}));
+
+// Mock message
+vi.mock('@/components/AntdStaticMethods', () => ({
+  message: {
+    info: vi.fn(),
+    warning: vi.fn(),
+  },
+}));
+
+// Mock unzipFile
+vi.mock('@/utils/unzipFile', () => ({
+  unzipFile: vi.fn(),
+}));
+
+// Mock p-map to run sequentially for easier testing
+vi.mock('p-map', () => ({
+  default: vi.fn(async (items, mapper) => {
+    return Promise.all(items.map(mapper));
+  }),
+}));
+
 // Mock SWR
 vi.mock('swr', async () => {
   const actual = await vi.importActual('swr');
@@ -398,6 +431,108 @@ describe('FileManagerActions', () => {
       // Should not auto-parse when upload returns undefined
       expect(parseSpy).not.toHaveBeenCalled();
     });
+
+    it('should enforce file count limit and queue excess files', async () => {
+      const { result } = renderHook(() => useStore());
+
+      // Create more files than the limit
+      const totalFiles = MAX_UPLOAD_FILE_COUNT + 5;
+      const files = Array.from(
+        { length: totalFiles },
+        (_, i) => new File(['content'], `file-${i}.txt`, { type: 'text/plain' }),
+      );
+
+      vi.spyOn(result.current, 'uploadWithProgress').mockResolvedValue({
+        id: 'file-1',
+        url: 'http://example.com/file-1',
+      });
+      vi.spyOn(result.current, 'refreshFileList').mockResolvedValue();
+      vi.spyOn(result.current, 'parseFilesToChunks').mockResolvedValue();
+      const dispatchSpy = vi.spyOn(result.current, 'dispatchDockFileList');
+
+      await act(async () => {
+        await result.current.pushDockFileList(files);
+      });
+
+      // Should add all files to dock (not just first MAX_UPLOAD_FILE_COUNT)
+      expect(dispatchSpy).toHaveBeenCalledWith({
+        atStart: true,
+        files: expect.arrayContaining([
+          expect.objectContaining({ file: expect.any(File), status: 'pending' }),
+        ]),
+        type: 'addFiles',
+      });
+
+      // Verify all files were dispatched
+      const dispatchCall = dispatchSpy.mock.calls.find((call) => call[0].type === 'addFiles');
+      expect(dispatchCall?.[0]).toHaveProperty('files');
+      if (dispatchCall && 'files' in dispatchCall[0]) {
+        expect(dispatchCall[0].files).toHaveLength(totalFiles);
+      }
+    });
+
+    it('should extract ZIP files and upload contents', async () => {
+      const { result } = renderHook(() => useStore());
+
+      const zipFile = new File(['zip content'], 'archive.zip', { type: 'application/zip' });
+      const extractedFiles = [
+        new File(['file1'], 'file1.txt', { type: 'text/plain' }),
+        new File(['file2'], 'file2.txt', { type: 'text/plain' }),
+      ];
+
+      vi.mocked(unzipFile).mockResolvedValue(extractedFiles);
+      vi.spyOn(result.current, 'uploadWithProgress').mockResolvedValue({
+        id: 'file-1',
+        url: 'http://example.com/file-1',
+      });
+      vi.spyOn(result.current, 'refreshFileList').mockResolvedValue();
+      vi.spyOn(result.current, 'parseFilesToChunks').mockResolvedValue();
+      const dispatchSpy = vi.spyOn(result.current, 'dispatchDockFileList');
+
+      await act(async () => {
+        await result.current.pushDockFileList([zipFile]);
+      });
+
+      // Should extract ZIP file
+      expect(unzipFile).toHaveBeenCalledWith(zipFile);
+
+      // Should upload extracted files
+      expect(dispatchSpy).toHaveBeenCalledWith({
+        atStart: true,
+        files: extractedFiles.map((file) => ({ file, id: file.name, status: 'pending' })),
+        type: 'addFiles',
+      });
+    });
+
+    it('should handle ZIP extraction errors gracefully', async () => {
+      const { result } = renderHook(() => useStore());
+
+      const zipFile = new File(['zip content'], 'archive.zip', { type: 'application/zip' });
+
+      vi.mocked(unzipFile).mockRejectedValue(new Error('Extraction failed'));
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      vi.spyOn(result.current, 'uploadWithProgress').mockResolvedValue({
+        id: 'file-1',
+        url: 'http://example.com/file-1',
+      });
+      vi.spyOn(result.current, 'refreshFileList').mockResolvedValue();
+      vi.spyOn(result.current, 'parseFilesToChunks').mockResolvedValue();
+      const dispatchSpy = vi.spyOn(result.current, 'dispatchDockFileList');
+
+      await act(async () => {
+        await result.current.pushDockFileList([zipFile]);
+      });
+
+      // Should log error
+      expect(consoleErrorSpy).toHaveBeenCalled();
+
+      // Should fallback to uploading the ZIP file itself
+      expect(dispatchSpy).toHaveBeenCalledWith({
+        atStart: true,
+        files: [{ file: zipFile, id: zipFile.name, status: 'pending' }],
+        type: 'addFiles',
+      });
+    });
   });
 
   describe('reEmbeddingChunks', () => {

package/src/store/file/slices/fileManager/action.ts

@@ -1,7 +1,8 @@
+import pMap from 'p-map';
 import { SWRResponse, mutate } from 'swr';
 import { StateCreator } from 'zustand/vanilla';
 
-import { FILE_UPLOAD_BLACKLIST } from '@/const/file';
+import { FILE_UPLOAD_BLACKLIST, MAX_UPLOAD_FILE_COUNT } from '@/const/file';
 import { useClientDataSWR } from '@/libs/swr';
 import { fileService } from '@/services/file';
 import { ServerService } from '@/services/file/server';
@@ -12,6 +13,7 @@ import {
 } from '@/store/file/reducers/uploadFileList';
 import { FileListItem, QueryFileListParams } from '@/types/files';
 import { isChunkingUnsupported } from '@/utils/isChunkingUnsupported';
+import { unzipFile } from '@/utils/unzipFile';
 
 import { FileStore } from '../../store';
 import { fileManagerSelectors } from './selectors';
@@ -89,18 +91,37 @@ export const createFileManageSlice: StateCreator<
   pushDockFileList: async (rawFiles, knowledgeBaseId) => {
     const { dispatchDockFileList } = get();
 
-    // 0. skip file in blacklist
-    const files = rawFiles.filter((file) => !FILE_UPLOAD_BLACKLIST.includes(file.name));
+    // 0. Process ZIP files and extract their contents
+    const filesToUpload: File[] = [];
+    for (const file of rawFiles) {
+      if (file.type === 'application/zip' || file.name.endsWith('.zip')) {
+        try {
+          const extractedFiles = await unzipFile(file);
+          filesToUpload.push(...extractedFiles);
+        } catch (error) {
+          console.error('Failed to extract ZIP file:', error);
+          // If extraction fails, treat it as a regular file
+          filesToUpload.push(file);
+        }
+      } else {
+        filesToUpload.push(file);
+      }
+    }
 
-    // 1. add files
+    // 1. skip file in blacklist
+    const files = filesToUpload.filter((file) => !FILE_UPLOAD_BLACKLIST.includes(file.name));
+
+    // 2. Add all files to dock
     dispatchDockFileList({
       atStart: true,
       files: files.map((file) => ({ file, id: file.name, status: 'pending' })),
       type: 'addFiles',
     });
 
-    const uploadResults = await Promise.all(
-      files.map(async (file) => {
+    // 3. Upload files with concurrency limit using p-map
+    const uploadResults = await pMap(
+      files,
+      async (file) => {
         const result = await get().uploadWithProgress({
           file,
           knowledgeBaseId,
@@ -110,10 +131,11 @@ export const createFileManageSlice: StateCreator<
         await get().refreshFileList();
 
         return { file, fileId: result?.id, fileType: file.type };
-      }),
+      },
+      { concurrency: MAX_UPLOAD_FILE_COUNT },
     );
 
-    // 2. auto-embed files that support chunking
+    // 4. auto-embed files that support chunking
     const fileIdsToEmbed = uploadResults
       .filter(({ fileType, fileId }) => fileId && !isChunkingUnsupported(fileType))
       .map(({ fileId }) => fileId!);

package/src/tools/web-browsing/Render/PageContent/index.tsx

@@ -12,10 +12,10 @@ import Result from './Result';
 interface PagesContentProps {
   messageId: string;
   results?: CrawlPluginState['results'];
-  urls: string[];
+  urls?: string[];
 }
 
-const PagesContent = memo<PagesContentProps>(({ results, messageId, urls }) => {
+const PagesContent = memo<PagesContentProps>(({ results, messageId, urls = [] }) => {
   const isMobile = useIsMobile();
 
   if (!results || results.length === 0) {

package/src/tools/web-browsing/Render/index.tsx

@@ -1,11 +1,12 @@
 import {
+  BuiltinRenderProps,
   CrawlMultiPagesQuery,
   CrawlPluginState,
   CrawlSinglePageQuery,
   SearchContent,
   SearchQuery,
   UniformSearchResponse,
- BuiltinRenderProps } from '@lobechat/types';
+} from '@lobechat/types';
 import { memo } from 'react';
 
 import { WebBrowsingApiName } from '@/tools/web-browsing';
@@ -22,7 +23,7 @@ const WebBrowsing = memo<BuiltinRenderProps<SearchContent[]>>(
           <Search
             messageId={messageId}
             pluginError={pluginError}
-            searchQuery={args as SearchQuery}
+            searchQuery={(args as SearchQuery) || {}}
             searchResponse={pluginState as UniformSearchResponse}
           />
         );
@@ -33,7 +34,7 @@ const WebBrowsing = memo<BuiltinRenderProps<SearchContent[]>>(
           <PageContent
             messageId={messageId}
             results={(pluginState as CrawlPluginState)?.results}
-            urls={[(args as CrawlSinglePageQuery).url]}
+            urls={[(args as CrawlSinglePageQuery)?.url]}
           />
         );
       }
@@ -43,7 +44,7 @@ const WebBrowsing = memo<BuiltinRenderProps<SearchContent[]>>(
           <PageContent
             messageId={messageId}
             results={(pluginState as CrawlPluginState)?.results}
-            urls={(args as CrawlMultiPagesQuery).urls}
+            urls={(args as CrawlMultiPagesQuery)?.urls}
           />
         );
       }

package/src/utils/unzipFile.test.ts

@@ -0,0 +1,128 @@
+import { zip } from 'fflate';
+import { describe, expect, it } from 'vitest';
+
+import { unzipFile } from './unzipFile';
+
+describe('unzipFile', () => {
+  it('should extract files from a ZIP archive', async () => {
+    // Create a mock ZIP file with test data
+    const testFiles = {
+      'test.txt': new TextEncoder().encode('Hello, World!'),
+      'folder/nested.txt': new TextEncoder().encode('Nested file content'),
+    };
+
+    const zipped = await new Promise<Uint8Array>((resolve, reject) => {
+      zip(testFiles, (error, data) => {
+        if (error) reject(error);
+        else resolve(data);
+      });
+    });
+
+    const zipFile = new File([new Uint8Array(zipped)], 'test.zip', { type: 'application/zip' });
+
+    const extractedFiles = await unzipFile(zipFile);
+
+    expect(extractedFiles).toHaveLength(2);
+    expect(extractedFiles[0].name).toBe('test.txt');
+    expect(extractedFiles[1].name).toBe('nested.txt');
+
+    // Verify file contents
+    const content1 = await extractedFiles[0].text();
+    expect(content1).toBe('Hello, World!');
+
+    const content2 = await extractedFiles[1].text();
+    expect(content2).toBe('Nested file content');
+  });
+
+  it('should skip directories in ZIP archive', async () => {
+    const testFiles = {
+      'file.txt': new TextEncoder().encode('File content'),
+      'folder/': new Uint8Array(0), // Directory entry
+    };
+
+    const zipped = await new Promise<Uint8Array>((resolve, reject) => {
+      zip(testFiles, (error, data) => {
+        if (error) reject(error);
+        else resolve(data);
+      });
+    });
+
+    const zipFile = new File([new Uint8Array(zipped)], 'test.zip', { type: 'application/zip' });
+
+    const extractedFiles = await unzipFile(zipFile);
+
+    expect(extractedFiles).toHaveLength(1);
+    expect(extractedFiles[0].name).toBe('file.txt');
+  });
+
+  it('should skip hidden files and __MACOSX directories', async () => {
+    const testFiles = {
+      '.hidden': new TextEncoder().encode('Hidden file'),
+      '__MACOSX/._file.txt': new TextEncoder().encode('Mac metadata'),
+      'visible.txt': new TextEncoder().encode('Visible file'),
+    };
+
+    const zipped = await new Promise<Uint8Array>((resolve, reject) => {
+      zip(testFiles, (error, data) => {
+        if (error) reject(error);
+        else resolve(data);
+      });
+    });
+
+    const zipFile = new File([new Uint8Array(zipped)], 'test.zip', { type: 'application/zip' });
+
+    const extractedFiles = await unzipFile(zipFile);
+
+    expect(extractedFiles).toHaveLength(1);
+    expect(extractedFiles[0].name).toBe('visible.txt');
+  });
+
+  it('should set correct MIME types for extracted files', async () => {
+    const testFiles = {
+      'document.pdf': new TextEncoder().encode('PDF content'),
+      'image.png': new TextEncoder().encode('PNG content'),
+      'code.ts': new TextEncoder().encode('TypeScript code'),
+    };
+
+    const zipped = await new Promise<Uint8Array>((resolve, reject) => {
+      zip(testFiles, (error, data) => {
+        if (error) reject(error);
+        else resolve(data);
+      });
+    });
+
+    const zipFile = new File([new Uint8Array(zipped)], 'test.zip', { type: 'application/zip' });
+
+    const extractedFiles = await unzipFile(zipFile);
+
+    expect(extractedFiles).toHaveLength(3);
+    expect(extractedFiles.find((f) => f.name === 'document.pdf')?.type).toBe('application/pdf');
+    expect(extractedFiles.find((f) => f.name === 'image.png')?.type).toBe('image/png');
+    expect(extractedFiles.find((f) => f.name === 'code.ts')?.type).toBe('text/typescript');
+  });
+
+  it('should handle empty ZIP files', async () => {
+    const testFiles = {};
+
+    const zipped = await new Promise<Uint8Array>((resolve, reject) => {
+      zip(testFiles, (error, data) => {
+        if (error) reject(error);
+        else resolve(data);
+      });
+    });
+
+    const zipFile = new File([new Uint8Array(zipped)], 'empty.zip', { type: 'application/zip' });
+
+    const extractedFiles = await unzipFile(zipFile);
+
+    expect(extractedFiles).toHaveLength(0);
+  });
+
+  it('should reject on invalid ZIP file', async () => {
+    const invalidFile = new File([new Uint8Array([1, 2, 3, 4])], 'invalid.zip', {
+      type: 'application/zip',
+    });
+
+    await expect(unzipFile(invalidFile)).rejects.toThrow();
+  });
+});

package/src/utils/unzipFile.ts

@@ -0,0 +1,122 @@
+import { unzip } from 'fflate';
+
+/**
+ * Determines the MIME type based on file extension
+ */
+const getFileType = (fileName: string): string => {
+  const extension = fileName.split('.').pop()?.toLowerCase() || '';
+
+  const mimeTypes: Record<string, string> = {
+    // Images
+    bmp: 'image/bmp',
+
+    // Code files
+    c: 'text/x-c',
+
+    cpp: 'text/x-c++',
+
+    cs: 'text/x-csharp',
+
+    css: 'text/css',
+
+    // Documents
+    csv: 'text/csv',
+
+    doc: 'application/msword',
+
+    docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+
+    gif: 'image/gif',
+
+    go: 'text/x-go',
+
+    html: 'text/html',
+
+    java: 'text/x-java',
+
+    jpeg: 'image/jpeg',
+
+    jpg: 'image/jpeg',
+
+    js: 'text/javascript',
+
+    json: 'application/json',
+
+    jsx: 'text/javascript',
+
+    md: 'text/markdown',
+
+    pdf: 'application/pdf',
+
+    php: 'application/x-httpd-php',
+
+    png: 'image/png',
+
+    ppt: 'application/vnd.ms-powerpoint',
+    pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    py: 'text/x-python',
+    rb: 'text/x-ruby',
+    rs: 'text/x-rust',
+    rtf: 'application/rtf',
+    sh: 'application/x-sh',
+    svg: 'image/svg+xml',
+    ts: 'text/typescript',
+    tsx: 'text/typescript',
+    txt: 'text/plain',
+    webp: 'image/webp',
+    xls: 'application/vnd.ms-excel',
+    xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    xml: 'application/xml',
+  };
+
+  return mimeTypes[extension] || 'application/octet-stream';
+};
+
+/**
+ * Extracts files from a ZIP archive
+ * @param zipFile - The ZIP file to extract
+ * @returns Promise that resolves to an array of extracted Files
+ */
+export const unzipFile = async (zipFile: File): Promise<File[]> => {
+  return new Promise((resolve, reject) => {
+    zipFile
+      .arrayBuffer()
+      .then((arrayBuffer) => {
+        const uint8Array = new Uint8Array(arrayBuffer);
+
+        unzip(uint8Array, (error, unzipped) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+
+          const extractedFiles: File[] = [];
+
+          for (const [path, data] of Object.entries(unzipped)) {
+            // Skip directories and hidden files
+            if (path.endsWith('/') || path.includes('__MACOSX') || path.startsWith('.')) {
+              continue;
+            }
+
+            // Get the filename from the path
+            const fileName = path.split('/').pop() || path;
+
+            // Create a File object from the extracted data
+            const blob = new Blob([new Uint8Array(data)], {
+              type: getFileType(fileName),
+            });
+            const file = new File([blob], fileName, {
+              type: getFileType(fileName),
+            });
+
+            extractedFiles.push(file);
+          }
+
+          resolve(extractedFiles);
+        });
+      })
+      .catch(() => {
+        reject(new Error('Failed to read ZIP file'));
+      });
+  });
+};