nuxt-ui-elements 0.1.31 → 0.1.33

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-ui-elements",
   "configKey": "uiElements",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/runtime/composables/useUploadManager/index.d.ts

@@ -184,8 +184,8 @@ export declare const useUploadManager: <TUploadResult = any>(_options?: UploadOp
         };
     })[]>>;
     totalProgress: import("vue").ComputedRef<number>;
-    addFiles: (newFiles: File[]) => Promise<(UploadFile | null)[]>;
-    addFile: (file: File) => Promise<UploadFile | null>;
+    addFiles: (newFiles: File[]) => Promise<UploadFile[]>;
+    addFile: (file: File) => Promise<UploadFile>;
     onGetRemoteFile: (fn: GetRemoteFileFn) => void;
     onUpload: (fn: UploadFn<TUploadResult>) => void;
     removeFile: (fileId: string) => Promise<void>;
@@ -453,14 +453,14 @@ export declare const useUploadManager: <TUploadResult = any>(_options?: UploadOp
         } | undefined;
         uploadResult?: import("vue").UnwrapRef<TUploadResult> | undefined;
         meta: Record<string, unknown>;
-    } | undefined;
+    };
     upload: () => Promise<void>;
     reset: () => void;
     status: import("vue").Ref<UploadStatus, UploadStatus>;
     getFileData: (fileId: string) => Promise<Blob>;
     getFileURL: (fileId: string) => Promise<string>;
     getFileStream: (fileId: string) => Promise<ReadableStream<Uint8Array>>;
-    replaceFileData: (fileId: string, newData: Blob, newName?: string) => Promise<void>;
+    replaceFileData: (fileId: string, newData: Blob, newName?: string, shouldAutoUpload?: boolean) => Promise<UploadFile>;
     updateFile: (fileId: string, updatedFile: Partial<UploadFile<TUploadResult>>) => void;
     initializeExistingFiles: (initialFiles: Array<Partial<UploadFile>>) => Promise<void>;
     addPlugin: (plugin: UploaderPlugin<any, any>) => void;

package/dist/runtime/composables/useUploadManager/index.js

@@ -1,7 +1,11 @@
 import mitt from "mitt";
-import { computed, readonly, ref } from "vue";
-import { ValidatorAllowedFileTypes, ValidatorMaxfileSize, ValidatorMaxFiles } from "./validators/index.js";
+import { computed, onBeforeUnmount, readonly, ref } from "vue";
+import { ValidatorAllowedFileTypes, ValidatorMaxFileSize, ValidatorMaxFiles } from "./validators/index.js";
 import { PluginThumbnailGenerator, PluginImageCompressor } from "./plugins/index.js";
+import { createPluginContext, createFileError, cleanupObjectURLs } from "./utils.js";
+function isStoragePlugin(plugin) {
+  return plugin !== null && "upload" in plugin.hooks;
+}
 function getExtension(fullFileName) {
   const lastDot = fullFileName.lastIndexOf(".");
   if (lastDot === -1 || lastDot === fullFileName.length - 1) {
@@ -10,6 +14,7 @@ function getExtension(fullFileName) {
   return fullFileName.slice(lastDot + 1).toLocaleLowerCase();
 }
 const defaultOptions = {
+  storage: void 0,
   plugins: [],
   maxFileSize: false,
   allowedFileTypes: false,
@@ -23,6 +28,7 @@ export const useUploadManager = (_options = {}) => {
   const files = ref([]);
   const emitter = mitt();
   const status = ref("waiting");
+  const createdObjectURLs = /* @__PURE__ */ new Map();
   const pluginEmitFunctions = /* @__PURE__ */ new Map();
   const getPluginEmitFn = (pluginId) => {
     let emitFn = pluginEmitFunctions.get(pluginId);
@@ -46,45 +52,53 @@ export const useUploadManager = (_options = {}) => {
     const sum = files.value.reduce((acc, file) => acc + file.progress.percentage, 0);
     return Math.round(sum / files.value.length);
   });
-  const isStoragePlugin = (plugin) => {
-    return !!(plugin.hooks.upload || plugin.hooks.getRemoteFile || plugin.hooks.remove);
-  };
   const getStoragePlugin = () => {
+    if (options.storage) {
+      return options.storage;
+    }
     if (!options.plugins) return null;
     for (let i = options.plugins.length - 1; i >= 0; i--) {
-      const plugin = options.plugins[i];
-      if (plugin && isStoragePlugin(plugin)) {
+      const plugin = options.plugins[i] || null;
+      if (isStoragePlugin(plugin)) {
+        if (import.meta.dev) {
+          console.warn(
+            `[useUploadManager] Storage plugin "${plugin.id}" found in plugins array.
+This is deprecated. Use the 'storage' option instead:
+
+  useUploadManager({ storage: ${plugin.id}(...) })`
+          );
+        }
         return plugin;
       }
     }
     return null;
   };
   const addPlugin = (plugin) => {
-    if (isStoragePlugin(plugin)) {
-      const existingStorage = options.plugins?.find((p) => isStoragePlugin(p));
-      if (existingStorage && import.meta.dev) {
+    const hasUploadHook = "upload" in plugin.hooks;
+    if (hasUploadHook) {
+      if (import.meta.dev) {
         console.warn(
-          `[useUploadManager] Multiple storage plugins detected!
-
-You're trying to add "${plugin.id}" but "${existingStorage.id}" is already registered.
-The LAST storage plugin ("${plugin.id}") will be used for uploads.
+          `[useUploadManager] Storage plugin "${plugin.id}" should use the 'storage' option instead of 'plugins':
 
-\u{1F4A1} If you need multiple storage destinations, create separate uploader instances:
-
-   const s3Uploader = useUploadManager({ plugins: [PluginS3Storage({ ... })] })
-   const azureUploader = useUploadManager({ plugins: [PluginAzureStorage({ ... })] })
+  useUploadManager({
+    storage: ${plugin.id}({ ... }),  // \u2713 Correct
+    plugins: [...]                    // Only for validators/processors
+  })
 `
         );
       }
     }
-    ;
-    options.plugins?.push(plugin);
+    if (options.plugins) {
+      options.plugins.push(plugin);
+    } else {
+      options.plugins = [plugin];
+    }
   };
   if (options.maxFiles !== false && options.maxFiles !== void 0) {
     addPlugin(ValidatorMaxFiles({ maxFiles: options.maxFiles }));
   }
   if (options.maxFileSize !== false && options.maxFileSize !== void 0) {
-    addPlugin(ValidatorMaxfileSize({ maxFileSize: options.maxFileSize }));
+    addPlugin(ValidatorMaxFileSize({ maxFileSize: options.maxFileSize }));
   }
   if (options.allowedFileTypes !== false && options.allowedFileTypes !== void 0 && options.allowedFileTypes.length > 0) {
     addPlugin(ValidatorAllowedFileTypes({ allowedFileTypes: options.allowedFileTypes }));
@@ -93,8 +107,8 @@ The LAST storage plugin ("${plugin.id}") will be used for uploads.
     const thumbOpts = options.thumbnails === true ? {} : options.thumbnails || {};
     addPlugin(
       PluginThumbnailGenerator({
-        width: thumbOpts.width ?? 128,
-        height: thumbOpts.height ?? 128,
+        maxWidth: thumbOpts.width ?? 128,
+        maxHeight: thumbOpts.height ?? 128,
         quality: thumbOpts.quality ?? 1
       })
     );
@@ -131,14 +145,7 @@ The LAST storage plugin ("${plugin.id}") will be used for uploads.
         const storagePlugin = getStoragePlugin();
         let remoteFileData;
         if (storagePlugin?.hooks.getRemoteFile) {
-          const context = {
-            files: files.value,
-            options,
-            emit: (event, payload) => {
-              const prefixedEvent = `${storagePlugin.id}:${String(event)}`;
-              emitter.emit(prefixedEvent, payload);
-            }
-          };
+          const context = createPluginContext(storagePlugin.id, files.value, options, emitter);
           remoteFileData = await storagePlugin.hooks.getRemoteFile(file.id, context);
         } else {
           remoteFileData = await getRemoteFileFn(file.id);
@@ -154,12 +161,12 @@ The LAST storage plugin ("${plugin.id}") will be used for uploads.
           size: remoteFileData.size,
           mimeType: remoteFileData.mimeType,
           remoteUrl: remoteFileData.remoteUrl,
+          preview: remoteFileData.preview || file.preview || remoteFileData.remoteUrl,
+          // Use preview from storage, passed-in value, or fallback to remoteUrl
           source: "storage"
           // File loaded from remote storage
         };
-        const processedFile = await runPluginStage("process", existingFile);
-        if (!processedFile) return null;
-        return processedFile;
+        return existingFile;
       })
     );
     const filteredFiles = initializedfiles.filter((f) => f !== null);
@@ -183,46 +190,55 @@ The LAST storage plugin ("${plugin.id}") will be used for uploads.
         extension
       }
     };
-    const validatedFile = await runPluginStage("validate", uploadFile);
-    if (!validatedFile) return null;
-    const processedFile = await runPluginStage("process", validatedFile);
-    if (!processedFile) return null;
-    files.value.push(processedFile);
-    emitter.emit("file:added", processedFile);
-    if (options.autoProceed) {
-      upload();
+    try {
+      const validatedFile = await runPluginStage("validate", uploadFile);
+      if (!validatedFile) {
+        throw new Error(`File validation failed for ${file.name}`);
+      }
+      const preprocessedFile = await runPluginStage("preprocess", validatedFile);
+      const fileToAdd = preprocessedFile || validatedFile;
+      files.value.push(fileToAdd);
+      emitter.emit("file:added", fileToAdd);
+      if (options.autoProceed) {
+        upload();
+      }
+      return validatedFile;
+    } catch (err) {
+      const error = createFileError(uploadFile, err);
+      const fileWithError = { ...uploadFile, status: "error", error };
+      files.value.push(fileWithError);
+      emitter.emit("file:error", { file: fileWithError, error });
+      throw err;
     }
-    return processedFile;
   };
-  const addFiles = (newFiles) => {
-    return Promise.all(newFiles.map((file) => addFile(file)));
+  const addFiles = async (newFiles) => {
+    const results = await Promise.allSettled(newFiles.map((file) => addFile(file)));
+    const addedFiles = results.filter((r) => r.status === "fulfilled").map((r) => r.value);
+    return addedFiles;
   };
   const removeFile = async (fileId) => {
-    const file = getFile(fileId);
+    const file = files.value.find((f) => f.id === fileId);
     if (!file) return;
     if (file.remoteUrl) {
       const storagePlugin = getStoragePlugin();
       if (storagePlugin?.hooks.remove) {
         try {
-          const context = {
-            files: files.value,
-            options,
-            emit: (event, payload) => {
-              const prefixedEvent = `${storagePlugin.id}:${String(event)}`;
-              emitter.emit(prefixedEvent, payload);
-            }
-          };
+          const context = createPluginContext(storagePlugin.id, files.value, options, emitter);
           await storagePlugin.hooks.remove(file, context);
         } catch (error) {
           console.error(`Storage plugin remove error:`, error);
         }
       }
     }
+    cleanupObjectURLs(createdObjectURLs, file.id);
     files.value = files.value.filter((f) => f.id !== fileId);
     emitter.emit("file:removed", file);
   };
   const removeFiles = (fileIds) => {
     const removedFiles = files.value.filter((f) => fileIds.includes(f.id));
+    removedFiles.forEach((file) => {
+      cleanupObjectURLs(createdObjectURLs, file.id);
+    });
     files.value = files.value.filter((f) => !fileIds.includes(f.id));
     removedFiles.forEach((file) => {
       emitter.emit("file:removed", file);
@@ -231,6 +247,7 @@ The LAST storage plugin ("${plugin.id}") will be used for uploads.
   };
   const clearFiles = () => {
     const allFiles = [...files.value];
+    cleanupObjectURLs(createdObjectURLs);
     files.value = [];
     allFiles.forEach((file) => {
       emitter.emit("file:removed", file);
@@ -239,9 +256,6 @@ The LAST storage plugin ("${plugin.id}") will be used for uploads.
   };
   const getFileData = async (fileId) => {
     const file = getFile(fileId);
-    if (!file) {
-      throw new Error(`File not found: ${fileId}`);
-    }
     if (file.size > 100 * 1024 * 1024) {
       console.warn(
         `getFileData: Loading large file (${(file.size / 1024 / 1024).toFixed(2)}MB) into memory. Consider using getFileURL() or getFileStream() for better performance.`
@@ -258,19 +272,19 @@ The LAST storage plugin ("${plugin.id}") will be used for uploads.
   };
   const getFileURL = async (fileId) => {
     const file = getFile(fileId);
-    if (!file) {
-      throw new Error(`File not found: ${fileId}`);
-    }
     if (file.source === "local") {
-      return URL.createObjectURL(file.data);
+      const existingURL = createdObjectURLs.get(file.id);
+      if (existingURL) {
+        return existingURL;
+      }
+      const objectURL = URL.createObjectURL(file.data);
+      createdObjectURLs.set(file.id, objectURL);
+      return objectURL;
     }
     return file.remoteUrl;
   };
   const getFileStream = async (fileId) => {
     const file = getFile(fileId);
-    if (!file) {
-      throw new Error(`File not found: ${fileId}`);
-    }
     if (file.source === "local") {
       return file.data.stream();
     }
@@ -280,11 +294,9 @@ The LAST storage plugin ("${plugin.id}") will be used for uploads.
     }
     return response.body;
   };
-  const replaceFileData = async (fileId, newData, newName) => {
+  const replaceFileData = async (fileId, newData, newName, shouldAutoUpload) => {
     const file = getFile(fileId);
-    if (!file) {
-      throw new Error(`File not found: ${fileId}`);
-    }
+    cleanupObjectURLs(createdObjectURLs, fileId);
     const updatedFile = {
       ...file,
       source: "local",
@@ -294,12 +306,25 @@ The LAST storage plugin ("${plugin.id}") will be used for uploads.
       status: "waiting",
       // Mark as needing upload
       progress: { percentage: 0 },
-      remoteUrl: void 0
+      remoteUrl: void 0,
       // Clear old remote URL
+      meta: {}
+      // Clear old metadata (thumbnails, dimensions, etc.)
     };
+    const preprocessedFile = await runPluginStage("preprocess", updatedFile);
+    const finalFile = preprocessedFile || updatedFile;
     const index = files.value.findIndex((f) => f.id === fileId);
-    files.value[index] = updatedFile;
-    emitter.emit("file:added", updatedFile);
+    if (index === -1) {
+      throw new Error(`File not found: ${fileId}`);
+    }
+    files.value[index] = finalFile;
+    emitter.emit("file:replaced", finalFile);
+    emitter.emit("file:added", finalFile);
+    const shouldUpload = shouldAutoUpload ?? options.autoProceed;
+    if (shouldUpload) {
+      upload();
+    }
+    return finalFile;
   };
   const reorderFile = (oldIndex, newIndex) => {
     if (oldIndex === newIndex) {
@@ -321,20 +346,35 @@ The LAST storage plugin ("${plugin.id}") will be used for uploads.
     emitter.emit("files:reorder", { oldIndex, newIndex });
   };
   const getFile = (fileId) => {
-    return files.value.find((f) => f.id === fileId);
+    const file = files.value.find((f) => f.id === fileId);
+    if (!file) {
+      throw new Error(`File not found: ${fileId}`);
+    }
+    return file;
   };
   const upload = async () => {
     const filesToUpload = files.value.filter((f) => f.status === "waiting");
     emitter.emit("upload:start", filesToUpload);
     for (const file of filesToUpload) {
       try {
-        updateFile(file.id, { status: "uploading" });
+        const processedFile = await runPluginStage("process", file);
+        if (!processedFile) {
+          const error = createFileError(file, new Error("File processing failed"));
+          updateFile(file.id, { status: "error", error });
+          emitter.emit("file:error", { file, error });
+          continue;
+        }
+        if (processedFile.id !== file.id) {
+          files.value = files.value.map((f) => f.id === file.id ? processedFile : f);
+        }
+        updateFile(processedFile.id, { status: "uploading" });
         const onProgress = (progress) => {
-          updateFile(file.id, { progress: { percentage: progress } });
-          emitter.emit("upload:progress", { file, progress });
+          updateFile(processedFile.id, { progress: { percentage: progress } });
+          emitter.emit("upload:progress", { file: processedFile, progress });
         };
         const storagePlugin = getStoragePlugin();
         let uploadResult;
+        let remoteUrl;
         if (storagePlugin?.hooks.upload) {
           const context = {
             files: files.value,
@@ -342,21 +382,18 @@ The LAST storage plugin ("${plugin.id}") will be used for uploads.
             onProgress,
             emit: getPluginEmitFn(storagePlugin.id)
           };
-          uploadResult = await storagePlugin.hooks.upload(file, context);
+          const result = await storagePlugin.hooks.upload(processedFile, context);
+          uploadResult = result;
+          remoteUrl = result.url;
         } else {
-          uploadResult = await uploadFn(file, onProgress);
+          uploadResult = await uploadFn(processedFile, onProgress);
+          remoteUrl = typeof uploadResult === "string" ? uploadResult : void 0;
         }
-        const remoteUrl = uploadResult?.url;
-        updateFile(file.id, { status: "complete", uploadResult, remoteUrl });
+        const currentFile = files.value.find((f) => f.id === processedFile.id);
+        const preview = currentFile?.preview || remoteUrl;
+        updateFile(processedFile.id, { status: "complete", uploadResult, remoteUrl, preview });
       } catch (err) {
-        const error = {
-          message: err instanceof Error ? err.message : "Unknown upload error",
-          details: {
-            fileName: file.name,
-            fileSize: file.size,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          }
-        };
+        const error = createFileError(file, err);
         updateFile(file.id, { status: "error", error });
         emitter.emit("file:error", { file, error });
       }
@@ -365,13 +402,21 @@ The LAST storage plugin ("${plugin.id}") will be used for uploads.
     emitter.emit("upload:complete", completed);
   };
   const reset = () => {
+    cleanupObjectURLs(createdObjectURLs);
     files.value = [];
   };
+  onBeforeUnmount(() => {
+    createdObjectURLs.forEach((url) => {
+      URL.revokeObjectURL(url);
+    });
+    createdObjectURLs.clear();
+  });
   const callPluginHook = async (hook, stage, file, context) => {
     switch (stage) {
       case "validate":
         await hook(file, context);
         return file;
+      case "preprocess":
       case "process":
       case "complete":
         if (!file) throw new Error("File is required for this hook type");

package/dist/runtime/composables/useUploadManager/plugins/image-compressor.d.ts

@@ -52,5 +52,5 @@ interface ImageCompressorOptions {
      */
     preserveMetadata?: boolean;
 }
-export declare const PluginImageCompressor: (options: ImageCompressorOptions) => import("../types.js").Plugin<any, ImageCompressorEvents>;
+export declare const PluginImageCompressor: (options: ImageCompressorOptions) => import("../types.js").ProcessingPlugin<any, ImageCompressorEvents>;
 export {};

package/dist/runtime/composables/useUploadManager/plugins/image-compressor.js

@@ -1,5 +1,5 @@
-import { defineUploaderPlugin } from "../types.js";
-export const PluginImageCompressor = defineUploaderPlugin((pluginOptions) => {
+import { defineProcessingPlugin } from "../types.js";
+export const PluginImageCompressor = defineProcessingPlugin((pluginOptions) => {
   const {
     maxWidth = 1920,
     maxHeight = 1920,

package/dist/runtime/composables/useUploadManager/plugins/storage/azure-datalake.d.ts

@@ -30,6 +30,17 @@ export interface AzureDataLakeOptions {
      * @default true
      */
     autoCreateDirectory?: boolean;
+    /**
+     * Number of retry attempts for failed operations
+     * @default 3
+     */
+    retries?: number;
+    /**
+     * Initial delay between retries in milliseconds
+     * Uses exponential backoff: delay * (2 ^ attempt)
+     * @default 1000 (1 second)
+     */
+    retryDelay?: number;
 }
 export interface AzureUploadResult {
     /**
@@ -41,4 +52,4 @@ export interface AzureUploadResult {
      */
     blobPath: string;
 }
-export declare const PluginAzureDataLake: (options: AzureDataLakeOptions) => import("../../types.js").Plugin<any, Record<string, never>>;
+export declare const PluginAzureDataLake: (options: AzureDataLakeOptions) => import("../../types.js").StoragePlugin<AzureUploadResult, Record<string, never>>;

package/dist/runtime/composables/useUploadManager/plugins/storage/azure-datalake.js

@@ -1,10 +1,34 @@
 import { ref } from "vue";
 import { DataLakeDirectoryClient } from "@azure/storage-file-datalake";
-import { defineUploaderPlugin } from "../../types.js";
-export const PluginAzureDataLake = defineUploaderPlugin((options) => {
+import { defineStoragePlugin } from "../../types.js";
+export const PluginAzureDataLake = defineStoragePlugin((options) => {
   const sasURL = ref(options.sasURL || "");
   let refreshPromise = null;
   const directoryCheckedCache = /* @__PURE__ */ new Set();
+  const maxRetries = options.retries ?? 3;
+  const initialRetryDelay = options.retryDelay ?? 1e3;
+  async function withRetry(operation, operationName) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        if (attempt === maxRetries) {
+          break;
+        }
+        const delay = initialRetryDelay * Math.pow(2, attempt);
+        if (import.meta.dev) {
+          console.warn(
+            `[Azure Storage] ${operationName} failed (attempt ${attempt + 1}/${maxRetries + 1}). Retrying in ${delay}ms...`,
+            error
+          );
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw new Error(`[Azure Storage] ${operationName} failed after ${maxRetries + 1} attempts: ${lastError?.message}`);
+  }
   if (options.getSASUrl && !options.sasURL) {
     options.getSASUrl().then((url) => {
       sasURL.value = url;
@@ -61,46 +85,52 @@ export const PluginAzureDataLake = defineUploaderPlugin((options) => {
         if (file.source !== "local" || file.data === null) {
           throw new Error("Cannot upload remote file - no local data available");
         }
-        const fileClient = await getFileClient(file.id);
-        await fileClient.upload(file.data, {
-          metadata: {
-            ...options.metadata,
-            mimeType: file.mimeType,
-            size: String(file.size),
-            originalName: file.name
-          },
-          pathHttpHeaders: {
-            ...options.pathHttpHeaders,
-            contentType: file.mimeType
-          },
-          onProgress: ({ loadedBytes }) => {
-            const uploadedPercentage = Math.round(loadedBytes / file.size * 100);
-            context.onProgress(uploadedPercentage);
-          }
-        });
-        return {
-          url: fileClient.url,
-          blobPath: fileClient.name
-        };
+        return withRetry(async () => {
+          const fileClient = await getFileClient(file.id);
+          await fileClient.upload(file.data, {
+            metadata: {
+              ...options.metadata,
+              mimeType: file.mimeType,
+              size: String(file.size),
+              originalName: file.name
+            },
+            pathHttpHeaders: {
+              ...options.pathHttpHeaders,
+              contentType: file.mimeType
+            },
+            onProgress: ({ loadedBytes }) => {
+              const uploadedPercentage = Math.round(loadedBytes / file.size * 100);
+              context.onProgress(uploadedPercentage);
+            }
+          });
+          return {
+            url: fileClient.url,
+            blobPath: fileClient.name
+          };
+        }, `Upload file "${file.name}"`);
       },
       /**
        * Get remote file metadata from Azure
        */
       async getRemoteFile(fileId, _context) {
-        const fileClient = await getFileClient(fileId);
-        const properties = await fileClient.getProperties();
-        return {
-          size: properties.contentLength || 0,
-          mimeType: properties.contentType || "application/octet-stream",
-          remoteUrl: fileClient.url
-        };
+        return withRetry(async () => {
+          const fileClient = await getFileClient(fileId);
+          const properties = await fileClient.getProperties();
+          return {
+            size: properties.contentLength || 0,
+            mimeType: properties.contentType || "application/octet-stream",
+            remoteUrl: fileClient.url
+          };
+        }, `Get remote file "${fileId}"`);
       },
       /**
        * Delete file from Azure Blob Storage
        */
       async remove(file, _context) {
-        const fileClient = await getFileClient(file.id);
-        await fileClient.deleteIfExists();
+        return withRetry(async () => {
+          const fileClient = await getFileClient(file.id);
+          await fileClient.deleteIfExists();
+        }, `Delete file "${file.name}"`);
       }
     }
   };

package/dist/runtime/composables/useUploadManager/plugins/thumbnail-generator.d.ts

@@ -1,7 +1,8 @@
 interface ThumbnailGeneratorOptions {
-    width?: number;
-    height?: number;
+    maxWidth?: number;
+    maxHeight?: number;
     quality?: number;
+    videoCaptureTime?: number;
 }
-export declare const PluginThumbnailGenerator: (options: ThumbnailGeneratorOptions) => import("../types.js").Plugin<any, Record<string, never>>;
+export declare const PluginThumbnailGenerator: (options: ThumbnailGeneratorOptions) => import("../types.js").ProcessingPlugin<any, Record<string, never>>;
 export {};