@spacecorexdev/core 0.0.2 → 0.0.5

package/src/ui/FileManager/utils/fileUpload.ts

@@ -0,0 +1,714 @@
+import * as febs from 'febs-browser';
+import pako from 'pako';
+import { FileUploadHandler } from '../../upload/index';
+import { ResponseCode } from '../../../api/_base';
+import { file as fileAPI } from '../../../api/project';
+import type { FileManagerApi } from '../types';
+
+import { API } from '../../../api/index';
+
+// 导入 Worker
+import FileDeltaWorker from './fileDeltaWorker?worker';
+import uiToast from '../../UIToast';
+
+// ==================== 配置常量 ====================
+/**
+ * 文件大小阈值配置
+ * - MAX_FILE_SIZE: 最大文件大小（100MB）
+ * - MAX_DELTA_FILE_SIZE: 超过此大小（20MB）的文件将跳过差分计算，直接完整上传
+ * - MAX_DIFF_SIZE: 差分压缩后超过此大小（2MB），将回退到完整上传
+ */
+const MAX_FILE_SIZE = 100 * 1024 * 1024; // 100MB
+const MAX_DELTA_FILE_SIZE = 20 * 1024 * 1024; // 20MB
+const MAX_DIFF_SIZE = 2 * 1024 * 1024; // 2MB
+
+/**
+ * 超时配置（毫秒）
+ * - DELTA_COMPUTE_TIMEOUT: 差分计算超时时间（30秒）
+ * - 如果差分计算超时，自动回退到完整上传
+ */
+const DELTA_COMPUTE_TIMEOUT = 30000; // 30秒
+
+// ==================== Worker 管理模块 ====================
+/**
+ * Worker 任务信息
+ */
+interface WorkerTask {
+  id: string;
+  worker: Worker;
+  resolve: (result: { compressedPatch: ArrayBuffer; patchSize: number }) => void;
+  reject: (error: Error) => void;
+  onProgress?: (percent: number, message: string) => void;
+}
+
+/**
+ * Worker 管理器
+ */
+class DeltaWorkerManager {
+  private workers: Map<string, WorkerTask> = new Map();
+  private worker: Worker | null = null;
+  private isReady: boolean = false;
+  private readyPromise: Promise<void>;
+  private resolveReady!: () => void;
+
+  constructor() {
+    this.readyPromise = new Promise((resolve) => {
+      this.resolveReady = resolve;
+    });
+    this.initWorker();
+  }
+
+  /**
+   * 初始化 Worker
+   */
+  private initWorker() {
+    try {
+      this.worker = new FileDeltaWorker();
+      
+      this.worker.onmessage = (e: MessageEvent) => {
+        const { type, id, data, error } = e.data;
+        
+        switch (type) {
+          case 'ready': {
+            this.isReady = true;
+            this.resolveReady();
+            console.log('[Worker] 差分计算模块已就绪');
+            break;
+          }
+            
+          case 'progress': {
+            const task = this.workers.get(id);
+            if (task && task.onProgress) {
+              task.onProgress(data.percent, data.message);
+            }
+            break;
+          }
+            
+          case 'success': {
+            const successTask = this.workers.get(id);
+            if (successTask) {
+              successTask.resolve({
+                compressedPatch: data.compressedPatch,
+                patchSize: data.patchSize
+              });
+              this.workers.delete(id);
+            }
+            break;
+          }
+            
+          case 'error': {
+            const errorTask = this.workers.get(id);
+            if (errorTask) {
+              errorTask.reject(new Error(error || 'Worker 计算失败'));
+              this.workers.delete(id);
+            }
+            break;
+          }
+            
+          case 'aborted':
+            this.workers.delete(id);
+            break;
+        }
+      };
+
+      this.worker.onerror = (error) => {
+        console.error('[Worker] Worker 错误:', error);
+        // 遇到错误时重新初始化
+        this.terminate();
+        setTimeout(() => this.initWorker(), 1000);
+      };
+    } catch (err) {
+      console.error('[Worker] 初始化 Worker 失败:', err);
+    }
+  }
+
+  /**
+   * 等待 Worker 就绪
+   */
+  async waitForReady(): Promise<void> {
+    if (this.isReady) return;
+    return this.readyPromise;
+  }
+
+  /**
+   * 执行差分计算
+   * @param oldBuffer 旧文件数据
+   * @param newBuffer 新文件数据
+   * @param onProgress 进度回调
+   * @returns 压缩后的差分数据
+   */
+  async computeDelta(
+    oldBuffer: ArrayBuffer,
+    newBuffer: ArrayBuffer,
+    onProgress?: (percent: number, message: string) => void
+  ): Promise<{ compressedPatch: ArrayBuffer; patchSize: number }> {
+    await this.waitForReady();
+    
+    return new Promise((resolve, reject) => {
+      if (!this.worker) {
+        reject(new Error('Worker 未初始化'));
+        return;
+      }
+
+      const taskId = `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+      
+      const task: WorkerTask = {
+        id: taskId,
+        worker: this.worker,
+        resolve,
+        reject,
+        onProgress
+      };
+      
+      this.workers.set(taskId, task);
+      
+      this.worker.postMessage({
+        type: 'computeDelta',
+        id: taskId,
+        data: {
+          oldBuffer,
+          newBuffer,
+          taskId
+        }
+      });
+    });
+  }
+
+  /**
+   * 终止所有任务
+   */
+  terminate() {
+    this.workers.forEach((task, id) => {
+      task.worker.postMessage({ type: 'abort', data: { taskId: id } });
+    });
+    this.workers.clear();
+    
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+    this.isReady = false;
+    this.readyPromise = new Promise((resolve) => {
+      this.resolveReady = resolve;
+    });
+  }
+}
+
+// 创建全局 Worker 管理器实例
+const workerManager = new DeltaWorkerManager();
+
+// ==================== 辅助函数 ====================
+/**
+ * 带超时的 Promise
+ * @param promise 要执行的 Promise
+ * @param timeoutMs 超时时间（毫秒）
+ * @param errorMessage 超时时的错误信息
+ */
+const withTimeout = <T>(promise: Promise<T>, timeoutMs: number, errorMessage: string): Promise<T> => {
+  return Promise.race([
+    promise,
+    new Promise<T>((_, reject) =>
+      setTimeout(() => reject(new Error(errorMessage)), timeoutMs)
+    )
+  ]);
+};
+
+// 预加载 WASM 模块
+let wasmInstance: WebAssembly.Instance | null = null;
+
+interface BsdiffExports {
+  memory: WebAssembly.Memory;
+  alloc: (len: number) => number;
+  dealloc: (ptr: number, len: number) => void;
+  create_patch: (basePtr: number, baseLen: number, nextPtr: number, nextLen: number) => number;
+  apply_patch: (basePtr: number, baseLen: number, patchPtr: number, patchLen: number) => number;
+  output_ptr: () => number;
+  output_len: () => number;
+  free_output: () => void;
+}
+
+const loadWasm = async (): Promise<BsdiffExports> => {
+  if (wasmInstance) return wasmInstance.exports as unknown as BsdiffExports;
+  
+  const response = await fetch('/wasm/hdiff.wasm');
+  const wasmBuffer = await response.arrayBuffer();
+  const wasmModule = new WebAssembly.Module(wasmBuffer);
+  const instance = await WebAssembly.instantiate(wasmModule);
+  wasmInstance = instance;
+  return instance.exports as unknown as BsdiffExports;
+};
+
+// 创建补丁
+const createPatch = async (base: Uint8Array, next: Uint8Array): Promise<Uint8Array> => {
+  const wasm = await loadWasm();
+  
+  const basePtr = wasm.alloc(base.byteLength);
+  const nextPtr = wasm.alloc(next.byteLength);
+  
+  try {
+    new Uint8Array(wasm.memory.buffer, basePtr, base.byteLength).set(base);
+    new Uint8Array(wasm.memory.buffer, nextPtr, next.byteLength).set(next);
+    
+    const status = wasm.create_patch(basePtr, base.byteLength, nextPtr, next.byteLength);
+    
+    if (status !== 0) {
+      throw new Error(`BSDiff failed with status: ${status}`);
+    }
+    
+    const outPtr = wasm.output_ptr();
+    const outLen = wasm.output_len();
+    
+    if (outLen === 0) {
+      wasm.free_output();
+      return new Uint8Array();
+    }
+    
+    const output = new Uint8Array(wasm.memory.buffer, outPtr, outLen);
+    const copied = new Uint8Array(output);
+    wasm.free_output();
+    return copied;
+  } finally {
+    if (base.byteLength > 0) wasm.dealloc(basePtr, base.byteLength);
+    if (next.byteLength > 0) wasm.dealloc(nextPtr, next.byteLength);
+  }
+};
+
+// 封装的 delta 计算函数
+const computeDelta = async (oldBuffer: ArrayBuffer, newBuffer: ArrayBuffer): Promise<ArrayBuffer> => {
+  const oldArray = new Uint8Array(oldBuffer);
+  const newArray = new Uint8Array(newBuffer);
+  const patch = await createPatch(oldArray, newArray);
+  return patch.buffer as ArrayBuffer;
+};
+
+export const calculateCRC32 = (file: File): Promise<number> => {
+  return new Promise((resolve, reject) => {
+    febs.crypt.crc32_file(file as unknown as File, (crc: number) => {
+      if (crc === 0) {
+        reject(new Error('CRC32 计算失败'));
+      } else {
+        resolve(crc);
+      }
+    });
+  });
+};
+
+export const getMimeType = (fileName: string): string => {
+  const ext = fileName.toLowerCase().split('.').pop() || '';
+  switch (ext) {
+    case 'pptx':
+      return 'application/vnd.openxmlformats-officedocument.presentationml.presentation';
+    case 'xlsx':
+      return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+    case 'md':
+      return 'text/markdown';
+    default:
+      return 'application/octet-stream';
+  }
+};
+
+export const sanitizeFileName = (fileName: string): string => {
+  let result = fileName.trim();
+  result = febs.string.replace(result, '/', '');
+  result = febs.string.replace(result, '\\', '');
+  return result;
+};
+
+// 获取文件扩展名（包含点号），如 ".txt"；无扩展名或以点开头的隐藏文件返回空字符串
+export const getFileExtension = (fileName: string): string => {
+  const dot = fileName.lastIndexOf('.');
+  if (dot <= 0) return '';
+  return fileName.slice(dot);
+};
+
+// 去掉文件扩展名，保留名称部分
+export const stripFileExtension = (fileName: string): string => {
+  const ext = getFileExtension(fileName);
+  return ext ? fileName.slice(0, fileName.length - ext.length) : fileName;
+};
+
+export interface UploadFileResult {
+  crc32: number;
+  serverFileName: string;
+}
+
+export const uploadFileBlob = async (blob: Blob, fileName: string,
+  progress: (percent: number) => void,
+  finish?: (success: boolean) => void
+): Promise<UploadFileResult> => {
+  const mimeType = getMimeType(fileName);
+  const file = new File([blob], fileName, { type: mimeType });
+  const crc32 = await calculateCRC32(file);
+
+  if (blob.size > MAX_FILE_SIZE) {
+    return new Promise((resolve, reject) => reject('文件大小超过100MB，无法上传'));
+  }
+
+  return new Promise<UploadFileResult>((resolve, reject) => {
+    FileUploadHandler.uploadSingle(
+      file,
+      crc32,
+      progress,
+      (err) => {
+        reject(err);
+      },
+      (data) => {
+        if (data.code === ResponseCode.SUCCESS) {
+          finish?.(true);
+          // 服务器可能因重名自动重命名文件（如 "新建文档.md" → "新建文档 (11).md"），
+          // 返回服务器上真实的文件名，用于后续 addFile/updateFile 的 fileResourcePath。
+          const serverFileName = typeof data.data === 'string' ? data.data : fileName;
+          resolve({ crc32, serverFileName });
+        } else {
+          finish?.(false);
+          uiToast.error(data.message || '文件上传失败');
+          reject(new Error(data.message || '文件上传失败'));
+        }
+      }
+    );
+  });
+};
+
+export const uploadMarkdownContent = async (content: string, fileName: string,
+  progress: (percent: number) => void,
+  finish?: (success: boolean) => void
+): Promise<UploadFileResult> => {
+  const blob = new Blob([content], { type: 'text/markdown' });
+  return uploadFileBlob(blob, fileName, progress, finish);
+};
+
+/**
+ * 增量上传文件（通过bsdiff计算差异并压缩后上传）
+ * 优化点：
+ * 1. 文件大小预检查：超过10MB的文件直接完整上传
+ * 2. Worker 线程：差分计算在 Worker 线程执行，防止主线程卡顿
+ * 3. 实时进度显示：显示差分计算的各个阶段
+ * 4. 超时回退机制：差分计算超过30秒自动回退到完整上传
+ * 
+ * @param fileId 文件ID
+ * @param fileName 文件名
+ * @param oldBlob 旧文件Blob
+ * @param newBlob 新文件Blob
+ * @param progress 进度回调 (0-1)
+ * @param finish 完成回调
+ */
+export const uploadFileDelta = async (
+  fileId: string,
+  fileName: string,
+  oldBlob: Blob,
+  newBlob: Blob,
+  progress: (percent: number) => void,
+  finish: (success: boolean) => void,
+  forceFullUpload: boolean = false,
+  /**
+   * 差分上传失败时的回调（如 CRC32 不匹配）。
+   * 返回 true 表示确认全量上传，返回 false 表示取消。
+   * 未提供时自动回退全量上传（默认行为）。
+   */
+  onDeltaFail?: (response: { code: number; message?: string }) => Promise<boolean>,
+  /**
+   * 文件更新接口注入（CRM 等自定义数据源场景）。
+   * 传入后若缺少 updateFileDelta，则视为不支持差分上传，强制走全量上传。
+   */
+  apis?: Pick<FileManagerApi, 'updateFile' | 'updateFileDelta'>,
+): Promise<UploadFileResult> => {
+  try {
+    // 接口注入：缺省使用项目文件 API；自定义 apis 未提供 updateFileDelta 时不支持差分
+    const updateFileImpl = apis?.updateFile || ((data: Parameters<typeof fileAPI.updateFile>[0]) => API.project.file.updateFile(data));
+    const updateDeltaImpl = apis ? apis.updateFileDelta : ((data: Parameters<typeof fileAPI.updateFileDelta>[0]) => fileAPI.updateFileDelta(data));
+    const needFullUpload = forceFullUpload || !updateDeltaImpl;
+
+    const oldSize = oldBlob.size;
+    const newSize = newBlob.size;
+
+    const mimeType = getMimeType(fileName);
+    const newFile = new File([newBlob], fileName, { type: mimeType });
+    const crc32 = await calculateCRC32(newFile);
+
+    // ==================== 强制全量上传 ====================
+    // 用于 Word 等需要完整替换 styles.xml 的场景，跳过差分计算
+    if (needFullUpload) {
+      console.log('[上传优化] 强制全量上传');
+      progress?.(0.05);
+
+      const { serverFileName } = await uploadFileBlob(newBlob, fileName, percent => progress?.(0.05 + percent * 0.95));
+
+      const res = await updateFileImpl({
+        fileId,
+        fileName,
+        fileSize: newSize,
+        crc32,
+        fileResourcePath: serverFileName
+      });
+
+      if (res.code !== ResponseCode.SUCCESS) {
+        throw new Error(res.message || '更新文件元数据失败');
+      }
+
+      progress?.(1);
+      finish?.(true);
+      return { crc32, serverFileName };
+    }
+    
+    // ==================== 优化点1: 文件大小预检查 ====================
+    // 超过阈值的大文件直接使用完整上传，跳过耗时的差分计算
+    if (oldSize > MAX_DELTA_FILE_SIZE || newSize > MAX_DELTA_FILE_SIZE) {
+      console.log(`[上传优化] 文件过大（旧: ${(oldSize / 1024 / 1024).toFixed(2)}MB, 新: ${(newSize / 1024 / 1024).toFixed(2)}MB），跳过差分计算`);
+      progress?.(0.05);
+
+      const { serverFileName } = await uploadFileBlob(newBlob, fileName, percent => progress?.(0.05 + percent * 0.95));
+
+      const res = await updateFileImpl({
+        fileId,
+        fileName,
+        fileSize: newSize,
+        crc32,
+        fileResourcePath: serverFileName
+      });
+
+      if (res.code !== ResponseCode.SUCCESS) {
+        throw new Error(res.message || '更新文件元数据失败');
+      }
+
+      progress?.(1);
+      finish?.(true);
+      return { crc32, serverFileName };
+    }
+    
+    // ==================== 正常差分上传流程 ====================
+    progress?.(0.02);
+    
+    // 将 Blob 转换为 ArrayBuffer
+    const oldBuffer = await oldBlob.arrayBuffer();
+    const newBuffer = await newBlob.arrayBuffer();
+    
+    progress?.(0.05);
+    
+    // ==================== 优化点2 & 3: 使用 Worker 进行差分计算，并实时显示进度 ====================
+    let compressedPatch: Uint8Array;
+    try {
+      // 使用 withTimeout 包装 Worker 计算，设置30秒超时
+      const result = await withTimeout(
+        workerManager.computeDelta(
+          oldBuffer,
+          newBuffer,
+          (workerPercent: number, message: string) => {
+            // 将 Worker 的 0-1 进度映射到 0.05-0.5 的主进度
+            const mainPercent = 0.05 + workerPercent * 0.45;
+            progress?.(mainPercent);
+            console.log(`[差分计算] ${message} (${(workerPercent * 100).toFixed(0)}%)`);
+          }
+        ),
+        DELTA_COMPUTE_TIMEOUT,
+        `差分计算超时（${DELTA_COMPUTE_TIMEOUT / 1000}秒），自动回退到完整上传`
+      );
+      
+      compressedPatch = new Uint8Array(result.compressedPatch);
+      
+      console.log(`[上传优化] 差分计算完成，压缩后大小: ${(result.patchSize / 1024).toFixed(2)}KB`);
+      
+    } catch (deltaError) {
+      console.warn('[上传优化] 差分计算失败，自动回退到完整上传。原因:', deltaError instanceof Error ? deltaError.message : deltaError);
+      progress?.(0.5);
+
+      const { serverFileName } = await uploadFileBlob(newBlob, fileName, percent => progress?.(0.5 + percent * 0.5));
+
+      const res = await updateFileImpl({
+        fileId,
+        fileName,
+        fileSize: newSize,
+        crc32,
+        fileResourcePath: serverFileName
+      });
+
+      if (res.code !== ResponseCode.SUCCESS) {
+        throw new Error(res.message || '更新文件元数据失败');
+      }
+
+      progress?.(1);
+      finish?.(true);
+      return { crc32, serverFileName };
+    }
+
+    progress?.(0.5);
+
+    // ==================== 优化点4: 差异大小检查 ====================
+    if (compressedPatch.length === 0) {
+      progress?.(1);
+      console.log('[上传优化] 文件未变化，无需上传');
+      finish?.(true);
+      return { crc32, serverFileName: fileName };
+    }
+    
+    // 差异过大时回退到完整上传
+    if (compressedPatch.length > MAX_DIFF_SIZE) {
+      console.log(`[上传优化] 差异过大（${(compressedPatch.length / 1024).toFixed(2)}KB > 300KB），使用完整上传`);
+      progress?.(0.55);
+
+      const { serverFileName } = await uploadFileBlob(newBlob, fileName, percent => progress?.(0.55 + percent * 0.45));
+
+      const res = await updateFileImpl({
+        fileId,
+        fileName,
+        fileSize: newSize,
+        crc32,
+        fileResourcePath: serverFileName
+      });
+
+      if (res.code !== ResponseCode.SUCCESS) {
+        throw new Error(res.message || '更新文件元数据失败');
+      }
+
+      progress?.(1);
+      finish?.(true);
+      return { crc32, serverFileName };
+    }
+
+    progress?.(0.6);
+
+    // 转换为 base64 并上传差异
+    // 使用分块处理避免展开运算符导致的栈溢出（当 compressedPatch 较大时）
+    const CHUNK_SIZE = 8192;
+    let binaryString = '';
+    for (let i = 0; i < compressedPatch.length; i += CHUNK_SIZE) {
+      const chunk = compressedPatch.subarray(i, Math.min(i + CHUNK_SIZE, compressedPatch.length));
+      binaryString += String.fromCharCode(...chunk);
+    }
+    const deltaData = btoa(binaryString);
+
+    progress?.(0.7);
+
+    const response = await updateDeltaImpl!({
+      fileId,
+      deltaData,
+      deltaSize: compressedPatch.length,
+      newFileSize: newSize,
+      crc32,
+    });
+
+    console.log('[上传诊断] updateFileDelta 响应:', {
+      code: response.code,
+      message: response.message,
+      data: response.data,
+    });
+
+    progress?.(1);
+
+    if (response.code !== ResponseCode.SUCCESS) {
+      // 差分上传失败（基准文件不存在、CRC32 不匹配等）
+      console.warn(`[上传优化] 差分上传失败(code=${response.code})，回退全量上传:`, response.message);
+
+      // 如果提供了 onDeltaFail 回调，由调用方决定是否继续全量上传
+      if (onDeltaFail) {
+        const confirmed = await onDeltaFail({ code: response.code, message: response.message });
+        if (!confirmed) {
+          progress?.(1);
+          finish?.(false);
+          throw new Error('用户取消上传');
+        }
+      }
+
+      const { serverFileName } = await uploadFileBlob(newBlob, fileName, percent => progress?.(0.05 + percent * 0.95));
+
+      const res = await updateFileImpl({
+        fileId,
+        fileName,
+        fileSize: newSize,
+        crc32,
+        fileResourcePath: serverFileName
+      });
+
+      if (res.code !== ResponseCode.SUCCESS) {
+        throw new Error(res.message || '更新文件元数据失败');
+      }
+      progress?.(1);
+      finish?.(true);
+      return { crc32, serverFileName };
+    }
+
+    // 差分上传成功 — 使用服务器返回的 serverFileName（如果有），否则返回原始文件名
+    const serverFileName = response.data || fileName;
+    console.log('[上传优化] 差分上传成功');
+    progress?.(1);
+    finish?.(true);
+    return { crc32, serverFileName };
+  } catch (error) {
+    finish?.(false);
+    console.error('增量上传失败:', error);
+    throw error;
+  }
+};
+
+/**
+ * 增量上传 Markdown 内容
+ * @param fileId 文件ID
+ * @param oldContent 旧内容
+ * @param newContent 新内容
+ * @param progress 进度回调
+ * @param finish 完成回调
+ * @param forceFullUpload 是否强制全量上传（用于冲突覆盖场景）
+ */
+export const uploadMarkdownDelta = async (
+  fileId: string,
+  fileName: string,
+  oldContent: string,
+  newContent: string,
+  progress: (percent: number) => void,
+  finish: (success: boolean) => void,
+  forceFullUpload: boolean = false,
+  onDeltaFail?: (response: { code: number; message?: string }) => Promise<boolean>,
+  apis?: Pick<FileManagerApi, 'updateFile' | 'updateFileDelta'>,
+): Promise<UploadFileResult> => {
+  const oldBlob = new Blob([oldContent], { type: 'text/markdown' });
+  const newBlob = new Blob([newContent], { type: 'text/markdown' });
+  return uploadFileDelta(fileId, fileName, oldBlob, newBlob, progress, finish, forceFullUpload, onDeltaFail, apis);
+};
+
+export interface DroppedFile {
+  file: File;
+  relativePath: string;
+}
+
+export const extractFilesFromDrop = async (items: DataTransferItemList): Promise<DroppedFile[]> => {
+  const files: DroppedFile[] = [];
+
+  const processEntry = (entry: FileSystemEntry, parentPath: string = ''): Promise<void> => {
+    return new Promise((resolve) => {
+      if (entry.isFile) {
+        (entry as FileSystemFileEntry).file((file) => {
+          const relativePath = parentPath ? `${parentPath}/${file.name}` : file.name;
+          files.push({ file, relativePath });
+          resolve();
+        }, () => resolve());
+      } else if (entry.isDirectory) {
+        const directoryReader = (entry as FileSystemDirectoryEntry).createReader();
+        const dirPath = parentPath ? `${parentPath}/${entry.name}` : entry.name;
+
+        const readEntries = () => {
+          directoryReader.readEntries((entries) => {
+            if (entries.length === 0) {
+              resolve();
+              return;
+            }
+            Promise.all(entries.map((e) => processEntry(e, dirPath))).then(() => resolve());
+          }, () => resolve());
+        };
+        readEntries();
+      } else {
+        resolve();
+      }
+    });
+  };
+
+  const promises: Promise<void>[] = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const entry = item.webkitGetAsEntry?.();
+    if (entry) {
+      promises.push(processEntry(entry));
+    }
+  }
+
+  await Promise.all(promises);
+  return files;
+};