nuxt-upload-kit 0.1.4 → 0.1.8

package/README.md

@@ -6,6 +6,9 @@
 
 <p align="center">A powerful, plugin-based file upload manager for Nuxt applications.</p>
 
+> [!WARNING]
+> This module is experimental and under active development. The API may change between versions without notice. Use in production at your own risk.
+
 ## Features
 
 - 🔌 **Plugin System** - Extensible architecture with built-in plugins for validation, compression, and storage
@@ -14,7 +17,6 @@
 - 🎥 **Video Compression** - FFmpeg-powered video compression (optional)
 - ✅ **Validation** - File type, size, and count validation out of the box
 - 📊 **Progress Tracking** - Real-time upload progress with events
-- 🔄 **File Lifecycle** - Complete control over file preprocessing, processing, and post-upload
 
 ## Installation
 
@@ -91,80 +93,9 @@ const handleUpload = () => uploader.upload()
 </template>
 ```
 
-## Using Storage Plugins
-
-### Azure Data Lake Storage
-
-```typescript
-import { PluginAzureDataLake } from "nuxt-upload-kit"
-
-const uploader = useUploadKit({
-  storage: PluginAzureDataLake({
-    sasURL: "https://your-storage.blob.core.windows.net/container?sv=...",
-    path: "uploads/images",
-  }),
-  thumbnails: true,
-})
-```
-
-## Configuration Options
-
-| Option             | Type                            | Default | Description                     |
-| ------------------ | ------------------------------- | ------- | ------------------------------- |
-| `storage`          | `StoragePlugin`                 | -       | Storage plugin for file uploads |
-| `plugins`          | `ProcessingPlugin[]`            | `[]`    | Additional processing plugins   |
-| `maxFiles`         | `number \| false`               | `false` | Maximum number of files         |
-| `maxFileSize`      | `number \| false`               | `false` | Maximum file size in bytes      |
-| `allowedFileTypes` | `string[] \| false`             | `false` | Allowed MIME types              |
-| `thumbnails`       | `boolean \| ThumbnailOptions`   | `false` | Enable thumbnail generation     |
-| `imageCompression` | `boolean \| CompressionOptions` | `false` | Enable image compression        |
-| `autoProceed`      | `boolean`                       | `false` | Auto-upload after adding files  |
-
-## Events
-
-```typescript
-uploader.on("file:added", (file) => console.log("Added:", file.name))
-uploader.on("file:removed", (file) => console.log("Removed:", file.name))
-uploader.on("file:error", ({ file, error }) => console.error(error))
-uploader.on("upload:start", (files) => console.log("Starting upload"))
-uploader.on("upload:progress", ({ file, progress }) => console.log(progress))
-uploader.on("upload:complete", (files) => console.log("Complete!"))
-```
-
-## Creating Custom Plugins
-
-```typescript
-import { defineProcessingPlugin } from "nuxt-upload-kit"
-
-const MyPlugin = defineProcessingPlugin<{ option: string }>((options) => ({
-  id: "my-plugin",
-  hooks: {
-    validate: async (file, context) => {
-      // Validation logic
-      return file
-    },
-    process: async (file, context) => {
-      // Processing logic
-      context.emit("processed", { file })
-      return file
-    },
-  },
-}))
-```
-
-## Optional Dependencies
+## Documentation
 
-For video compression, install FFmpeg:
-
-```bash
-pnpm add @ffmpeg/ffmpeg @ffmpeg/util
-```
-
-For Azure storage, install the Azure SDK:
-
-```bash
-pnpm add @azure/storage-file-datalake
-```
+For full documentation, visit [nuxt-upload-kit.vercel.app](https://nuxt-upload-kit.vercel.app)
 
 ## License
 

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-upload-kit",
   "configKey": "uploadKit",
-  "version": "0.1.4",
+  "version": "0.1.8",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

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

@@ -21,7 +21,7 @@ const defaultOptions = {
   maxFiles: false,
   thumbnails: false,
   imageCompression: false,
-  autoProceed: false
+  autoUpload: false
 };
 export const useUploadKit = (_options = {}) => {
   const options = { ...defaultOptions, ..._options };
@@ -29,6 +29,7 @@ export const useUploadKit = (_options = {}) => {
   const emitter = mitt();
   const status = ref("waiting");
   const createdObjectURLs = /* @__PURE__ */ new Map();
+  let hasEmittedFilesUploaded = false;
   const pluginEmitFunctions = /* @__PURE__ */ new Map();
   const getPluginEmitFn = (pluginId) => {
     let emitFn = pluginEmitFunctions.get(pluginId);
@@ -199,7 +200,8 @@ This is deprecated. Use the 'storage' option instead:
       const fileToAdd = preprocessedFile || validatedFile;
       files.value.push(fileToAdd);
       emitter.emit("file:added", fileToAdd);
-      if (options.autoProceed) {
+      hasEmittedFilesUploaded = false;
+      if (options.autoUpload) {
         upload();
       }
       return validatedFile;
@@ -320,7 +322,8 @@ This is deprecated. Use the 'storage' option instead:
     files.value[index] = finalFile;
     emitter.emit("file:replaced", finalFile);
     emitter.emit("file:added", finalFile);
-    const shouldUpload = shouldAutoUpload ?? options.autoProceed;
+    hasEmittedFilesUploaded = false;
+    const shouldUpload = shouldAutoUpload ?? options.autoUpload;
     if (shouldUpload) {
       upload();
     }
@@ -400,6 +403,11 @@ This is deprecated. Use the 'storage' option instead:
     }
     const completed = files.value.filter((f) => f.status === "complete");
     emitter.emit("upload:complete", completed);
+    const allComplete = files.value.every((f) => f.status === "complete");
+    if (allComplete && files.value.length > 0 && !hasEmittedFilesUploaded) {
+      hasEmittedFilesUploaded = true;
+      emitter.emit("files:uploaded", files.value);
+    }
   };
   const reset = () => {
     cleanupObjectURLs(createdObjectURLs);
@@ -431,25 +439,23 @@ This is deprecated. Use the 'storage' option instead:
     let currentFile = file;
     for (const plugin of options.plugins) {
       const hook = plugin.hooks[stage];
-      if (hook) {
-        try {
-          const context = {
-            files: files.value,
-            options,
-            emit: getPluginEmitFn(plugin.id)
-          };
-          const result = await callPluginHook(hook, stage, currentFile, context);
-          if (!result) continue;
-          if (currentFile && "id" in result) {
-            currentFile = result;
-          }
-        } catch (error) {
-          if (currentFile) {
-            emitter.emit("file:error", { file: currentFile, error });
-          }
-          console.error(`Plugin ${plugin.id} ${stage} hook error:`, error);
-          return null;
+      if (!hook) continue;
+      try {
+        const context = {
+          files: files.value,
+          options,
+          emit: getPluginEmitFn(plugin.id)
+        };
+        const result = await callPluginHook(hook, stage, currentFile, context);
+        if (result && currentFile && "id" in result) {
+          currentFile = result;
+        }
+      } catch (error) {
+        if (currentFile) {
+          emitter.emit("file:error", { file: currentFile, error });
         }
+        console.error(`Plugin ${plugin.id} ${stage} hook error:`, error);
+        return null;
       }
     }
     return currentFile;

package/dist/runtime/composables/useUploadKit/plugins/storage/aws-s3.d.ts

@@ -0,0 +1,63 @@
+export interface AWSS3Options {
+    /**
+     * Function to get a presigned URL for uploading a file
+     * Your backend should generate this using AWS SDK's getSignedUrl
+     *
+     * @example
+     * ```typescript
+     * getPresignedUploadUrl: async (fileId, contentType) => {
+     *   const response = await fetch('/api/s3/presign', {
+     *     method: 'POST',
+     *     body: JSON.stringify({ key: fileId, contentType })
+     *   })
+     *   const { uploadUrl, publicUrl } = await response.json()
+     *   return { uploadUrl, publicUrl }
+     * }
+     * ```
+     */
+    getPresignedUploadUrl: (fileId: string, contentType: string, metadata: {
+        fileName: string;
+        fileSize: number;
+    }) => Promise<{
+        /** Presigned URL for PUT upload */
+        uploadUrl: string;
+        /** Public URL where the file will be accessible after upload */
+        publicUrl: string;
+    }>;
+    /**
+     * Optional function to get a presigned URL for downloading/reading a file
+     * Required if you want to use getRemoteFile hook
+     */
+    getPresignedDownloadUrl?: (fileId: string) => Promise<string>;
+    /**
+     * Optional function to delete a file
+     * Your backend should handle the actual deletion
+     */
+    deleteFile?: (fileId: string) => Promise<void>;
+    /**
+     * 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 AWSS3UploadResult {
+    /**
+     * Public URL to the uploaded file
+     */
+    url: string;
+    /**
+     * S3 object key (file ID used for upload)
+     */
+    key: string;
+    /**
+     * ETag of the uploaded object (from response headers)
+     */
+    etag?: string;
+}
+export declare const PluginAWSS3: (options: AWSS3Options) => import("../../types.js").StoragePlugin<AWSS3UploadResult, Record<string, never>>;

package/dist/runtime/composables/useUploadKit/plugins/storage/aws-s3.js

@@ -0,0 +1,111 @@
+import { defineStorageAdapter } from "../../types.js";
+export const PluginAWSS3 = defineStorageAdapter((options) => {
+  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(
+            `[S3 Storage] ${operationName} failed (attempt ${attempt + 1}/${maxRetries + 1}). Retrying in ${delay}ms...`,
+            error
+          );
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw new Error(`[S3 Storage] ${operationName} failed after ${maxRetries + 1} attempts: ${lastError?.message}`);
+  }
+  return {
+    id: "aws-s3-storage",
+    hooks: {
+      /**
+       * Upload file to S3 using presigned URL
+       */
+      async upload(file, context) {
+        if (file.source !== "local" || file.data === null) {
+          throw new Error("Cannot upload remote file - no local data available");
+        }
+        return withRetry(async () => {
+          const { uploadUrl, publicUrl } = await options.getPresignedUploadUrl(file.id, file.mimeType, {
+            fileName: file.name,
+            fileSize: file.size
+          });
+          const etag = await uploadWithProgress(uploadUrl, file.data, file.mimeType, context.onProgress);
+          return {
+            url: publicUrl,
+            key: file.id,
+            etag
+          };
+        }, `Upload file "${file.name}"`);
+      },
+      /**
+       * Get remote file metadata
+       */
+      async getRemoteFile(fileId, _context) {
+        if (!options.getPresignedDownloadUrl) {
+          throw new Error("[S3 Storage] getPresignedDownloadUrl is required to fetch remote files");
+        }
+        return withRetry(async () => {
+          const downloadUrl = await options.getPresignedDownloadUrl(fileId);
+          const response = await fetch(downloadUrl, { method: "HEAD" });
+          if (!response.ok) {
+            throw new Error(`Failed to get file metadata: ${response.status}`);
+          }
+          return {
+            size: Number.parseInt(response.headers.get("content-length") || "0", 10),
+            mimeType: response.headers.get("content-type") || "application/octet-stream",
+            remoteUrl: downloadUrl
+          };
+        }, `Get remote file "${fileId}"`);
+      },
+      /**
+       * Delete file from S3
+       */
+      async remove(file, _context) {
+        if (!options.deleteFile) {
+          throw new Error("[S3 Storage] deleteFile callback is required to delete files");
+        }
+        return withRetry(async () => {
+          await options.deleteFile(file.id);
+        }, `Delete file "${file.name}"`);
+      }
+    }
+  };
+});
+function uploadWithProgress(url, data, contentType, onProgress) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.upload.addEventListener("progress", (event) => {
+      if (event.lengthComputable) {
+        const percentage = Math.round(event.loaded / event.total * 100);
+        onProgress(percentage);
+      }
+    });
+    xhr.addEventListener("load", () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        const etag = xhr.getResponseHeader("ETag")?.replaceAll('"', "");
+        resolve(etag);
+      } else {
+        reject(new Error(`Upload failed with status ${xhr.status}: ${xhr.statusText}`));
+      }
+    });
+    xhr.addEventListener("error", () => {
+      reject(new Error("Upload failed due to network error"));
+    });
+    xhr.addEventListener("abort", () => {
+      reject(new Error("Upload was aborted"));
+    });
+    xhr.open("PUT", url);
+    xhr.setRequestHeader("Content-Type", contentType);
+    xhr.send(data);
+  });
+}

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

@@ -1,7 +1,7 @@
 import { ref } from "vue";
 import { DataLakeDirectoryClient } from "@azure/storage-file-datalake";
-import { defineStoragePlugin } from "../../types.js";
-export const PluginAzureDataLake = defineStoragePlugin((options) => {
+import { defineStorageAdapter } from "../../types.js";
+export const PluginAzureDataLake = defineStorageAdapter((options) => {
   const sasURL = ref(options.sasURL || "");
   let refreshPromise = null;
   const directoryCheckedCache = /* @__PURE__ */ new Set();

package/dist/runtime/composables/useUploadKit/plugins/storage/cloudflare-r2.d.ts

@@ -0,0 +1,63 @@
+export interface CloudflareR2Options {
+    /**
+     * Function to get a presigned URL for uploading a file
+     * Your backend should generate this using AWS SDK's getSignedUrl with R2 endpoint
+     *
+     * @example
+     * ```typescript
+     * getPresignedUploadUrl: async (fileId, contentType) => {
+     *   const response = await fetch('/api/r2/presign', {
+     *     method: 'POST',
+     *     body: JSON.stringify({ key: fileId, contentType })
+     *   })
+     *   const { uploadUrl, publicUrl } = await response.json()
+     *   return { uploadUrl, publicUrl }
+     * }
+     * ```
+     */
+    getPresignedUploadUrl: (fileId: string, contentType: string, metadata: {
+        fileName: string;
+        fileSize: number;
+    }) => Promise<{
+        /** Presigned URL for PUT upload */
+        uploadUrl: string;
+        /** Public URL where the file will be accessible after upload (r2.dev or custom domain) */
+        publicUrl: string;
+    }>;
+    /**
+     * Optional function to get a presigned URL for downloading/reading a file
+     * Required if you want to use getRemoteFile hook
+     */
+    getPresignedDownloadUrl?: (fileId: string) => Promise<string>;
+    /**
+     * Optional function to delete a file
+     * Your backend should handle the actual deletion
+     */
+    deleteFile?: (fileId: string) => Promise<void>;
+    /**
+     * 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 CloudflareR2UploadResult {
+    /**
+     * Public URL to the uploaded file
+     */
+    url: string;
+    /**
+     * R2 object key (file ID used for upload)
+     */
+    key: string;
+    /**
+     * ETag of the uploaded object (from response headers)
+     */
+    etag?: string;
+}
+export declare const PluginCloudflareR2: (options: CloudflareR2Options) => import("../../types.js").StoragePlugin<CloudflareR2UploadResult, Record<string, never>>;

package/dist/runtime/composables/useUploadKit/plugins/storage/cloudflare-r2.js

@@ -0,0 +1,111 @@
+import { defineStorageAdapter } from "../../types.js";
+export const PluginCloudflareR2 = defineStorageAdapter((options) => {
+  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(
+            `[R2 Storage] ${operationName} failed (attempt ${attempt + 1}/${maxRetries + 1}). Retrying in ${delay}ms...`,
+            error
+          );
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw new Error(`[R2 Storage] ${operationName} failed after ${maxRetries + 1} attempts: ${lastError?.message}`);
+  }
+  return {
+    id: "cloudflare-r2-storage",
+    hooks: {
+      /**
+       * Upload file to R2 using presigned URL
+       */
+      async upload(file, context) {
+        if (file.source !== "local" || file.data === null) {
+          throw new Error("Cannot upload remote file - no local data available");
+        }
+        return withRetry(async () => {
+          const { uploadUrl, publicUrl } = await options.getPresignedUploadUrl(file.id, file.mimeType, {
+            fileName: file.name,
+            fileSize: file.size
+          });
+          const etag = await uploadWithProgress(uploadUrl, file.data, file.mimeType, context.onProgress);
+          return {
+            url: publicUrl,
+            key: file.id,
+            etag
+          };
+        }, `Upload file "${file.name}"`);
+      },
+      /**
+       * Get remote file metadata from R2
+       */
+      async getRemoteFile(fileId, _context) {
+        if (!options.getPresignedDownloadUrl) {
+          throw new Error("[R2 Storage] getPresignedDownloadUrl is required to fetch remote files");
+        }
+        return withRetry(async () => {
+          const downloadUrl = await options.getPresignedDownloadUrl(fileId);
+          const response = await fetch(downloadUrl, { method: "HEAD" });
+          if (!response.ok) {
+            throw new Error(`Failed to get file metadata: ${response.status}`);
+          }
+          return {
+            size: Number.parseInt(response.headers.get("content-length") || "0", 10),
+            mimeType: response.headers.get("content-type") || "application/octet-stream",
+            remoteUrl: downloadUrl
+          };
+        }, `Get remote file "${fileId}"`);
+      },
+      /**
+       * Delete file from R2
+       */
+      async remove(file, _context) {
+        if (!options.deleteFile) {
+          throw new Error("[R2 Storage] deleteFile callback is required to delete files");
+        }
+        return withRetry(async () => {
+          await options.deleteFile(file.id);
+        }, `Delete file "${file.name}"`);
+      }
+    }
+  };
+});
+function uploadWithProgress(url, data, contentType, onProgress) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.upload.addEventListener("progress", (event) => {
+      if (event.lengthComputable) {
+        const percentage = Math.round(event.loaded / event.total * 100);
+        onProgress(percentage);
+      }
+    });
+    xhr.addEventListener("load", () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        const etag = xhr.getResponseHeader("ETag")?.replaceAll('"', "");
+        resolve(etag);
+      } else {
+        reject(new Error(`Upload failed with status ${xhr.status}: ${xhr.statusText}`));
+      }
+    });
+    xhr.addEventListener("error", () => {
+      reject(new Error("Upload failed due to network error"));
+    });
+    xhr.addEventListener("abort", () => {
+      reject(new Error("Upload was aborted"));
+    });
+    xhr.open("PUT", url);
+    xhr.setRequestHeader("Content-Type", contentType);
+    xhr.send(data);
+  });
+}

package/dist/runtime/composables/useUploadKit/plugins/storage/firebase-storage.d.ts

@@ -0,0 +1,71 @@
+import { type FirebaseStorage } from "firebase/storage";
+export interface FirebaseStorageOptions {
+    /**
+     * Firebase Storage instance
+     * You must initialize Firebase and pass the storage instance
+     * @example
+     * ```typescript
+     * import { getStorage } from 'firebase/storage'
+     * import { initializeApp } from 'firebase/app'
+     *
+     * const app = initializeApp({ ... })
+     * const storage = getStorage(app)
+     *
+     * PluginFirebaseStorage({ storage })
+     * ```
+     */
+    storage: FirebaseStorage;
+    /**
+     * Optional path prefix (folder) for uploaded files
+     * @example "uploads/images"
+     */
+    path?: string;
+    /**
+     * Custom metadata to attach to uploaded files
+     */
+    customMetadata?: Record<string, string>;
+    /**
+     * Cache-Control header for uploaded files
+     * @example "max-age=31536000" for 1 year caching
+     */
+    cacheControl?: string;
+    /**
+     * Content-Disposition header
+     * @example "attachment; filename=file.pdf"
+     */
+    contentDisposition?: string;
+    /**
+     * 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 FirebaseStorageUploadResult {
+    /**
+     * Public download URL for the uploaded file
+     */
+    url: string;
+    /**
+     * Full path in Firebase Storage
+     */
+    fullPath: string;
+    /**
+     * Storage bucket name
+     */
+    bucket: string;
+    /**
+     * File generation (version identifier)
+     */
+    generation?: string;
+    /**
+     * MD5 hash of the uploaded content
+     */
+    md5Hash?: string;
+}
+export declare const PluginFirebaseStorage: (options: FirebaseStorageOptions) => import("../../types.js").StoragePlugin<FirebaseStorageUploadResult, Record<string, never>>;

package/dist/runtime/composables/useUploadKit/plugins/storage/firebase-storage.js

@@ -0,0 +1,122 @@
+import {
+  ref as storageRef,
+  uploadBytesResumable,
+  getDownloadURL,
+  getMetadata,
+  deleteObject
+} from "firebase/storage";
+import { defineStorageAdapter } from "../../types.js";
+export const PluginFirebaseStorage = defineStorageAdapter((options) => {
+  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(
+            `[Firebase Storage] ${operationName} failed (attempt ${attempt + 1}/${maxRetries + 1}). Retrying in ${delay}ms...`,
+            error
+          );
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw new Error(`[Firebase Storage] ${operationName} failed after ${maxRetries + 1} attempts: ${lastError?.message}`);
+  }
+  const buildPath = (fileId) => {
+    if (options.path) {
+      const cleanPath = options.path.replace(/^\/+/, "").replace(/\/+$/, "");
+      return `${cleanPath}/${fileId}`;
+    }
+    return fileId;
+  };
+  const getStorageRef = (fileId) => {
+    const path = buildPath(fileId);
+    return storageRef(options.storage, path);
+  };
+  const uploadToFirebase = (fileId, data, mimeType, fileName, onProgress) => {
+    const fileRef = getStorageRef(fileId);
+    const metadata = {
+      contentType: mimeType,
+      cacheControl: options.cacheControl,
+      contentDisposition: options.contentDisposition,
+      customMetadata: {
+        ...options.customMetadata,
+        originalName: fileName,
+        size: String(data.size)
+      }
+    };
+    return new Promise((resolve, reject) => {
+      const uploadTask = uploadBytesResumable(fileRef, data, metadata);
+      const handleProgress = (snapshot) => {
+        const percentage = Math.round(snapshot.bytesTransferred / snapshot.totalBytes * 100);
+        onProgress(percentage);
+      };
+      const handleError = (error) => reject(error);
+      const handleComplete = async () => {
+        try {
+          const downloadURL = await getDownloadURL(uploadTask.snapshot.ref);
+          const uploadMetadata = uploadTask.snapshot.metadata;
+          resolve({
+            url: downloadURL,
+            fullPath: uploadMetadata.fullPath,
+            bucket: uploadMetadata.bucket,
+            generation: uploadMetadata.generation,
+            md5Hash: uploadMetadata.md5Hash
+          });
+        } catch (error) {
+          reject(error);
+        }
+      };
+      uploadTask.on("state_changed", handleProgress, handleError, handleComplete);
+    });
+  };
+  return {
+    id: "firebase-storage",
+    hooks: {
+      /**
+       * Upload file to Firebase Storage
+       */
+      async upload(file, context) {
+        if (file.source !== "local" || file.data === null) {
+          throw new Error("Cannot upload remote file - no local data available");
+        }
+        return withRetry(
+          () => uploadToFirebase(file.id, file.data, file.mimeType, file.name, context.onProgress),
+          `Upload file "${file.name}"`
+        );
+      },
+      /**
+       * Get remote file metadata from Firebase Storage
+       */
+      async getRemoteFile(fileId, _context) {
+        return withRetry(async () => {
+          const fileRef = getStorageRef(fileId);
+          const [metadata, downloadURL] = await Promise.all([getMetadata(fileRef), getDownloadURL(fileRef)]);
+          return {
+            size: metadata.size,
+            mimeType: metadata.contentType || "application/octet-stream",
+            remoteUrl: downloadURL
+          };
+        }, `Get remote file "${fileId}"`);
+      },
+      /**
+       * Delete file from Firebase Storage
+       */
+      async remove(file, _context) {
+        return withRetry(async () => {
+          const fileRef = getStorageRef(file.id);
+          await deleteObject(fileRef);
+        }, `Delete file "${file.name}"`);
+      }
+    }
+  };
+});

package/dist/runtime/composables/useUploadKit/plugins/storage/index.d.ts

@@ -8,3 +8,18 @@
  * If you need multiple storage destinations, create multiple uploader instances.
  */
 export { PluginAzureDataLake, type AzureDataLakeOptions, type AzureUploadResult } from "./azure-datalake.js";
+/**
+ * AWS S3 Storage Adapter (also works with S3-compatible services: MinIO, DigitalOcean Spaces, Wasabi, Backblaze B2)
+ * @experimental This adapter is experimental and may change in future releases.
+ */
+export { PluginAWSS3, type AWSS3Options, type AWSS3UploadResult } from "./aws-s3.js";
+/**
+ * Cloudflare R2 Storage Adapter
+ * @experimental This adapter is experimental and may change in future releases.
+ */
+export { PluginCloudflareR2, type CloudflareR2Options, type CloudflareR2UploadResult } from "./cloudflare-r2.js";
+/**
+ * Firebase Storage Adapter
+ * @experimental This adapter is experimental and may change in future releases.
+ */
+export { PluginFirebaseStorage, type FirebaseStorageOptions, type FirebaseStorageUploadResult } from "./firebase-storage.js";

package/dist/runtime/composables/useUploadKit/plugins/storage/index.js

@@ -1 +1,4 @@
 export { PluginAzureDataLake } from "./azure-datalake.js";
+export { PluginAWSS3 } from "./aws-s3.js";
+export { PluginCloudflareR2 } from "./cloudflare-r2.js";
+export { PluginFirebaseStorage } from "./firebase-storage.js";

package/dist/runtime/composables/useUploadKit/types.d.ts

@@ -230,7 +230,7 @@ export interface UploadOptions {
      * Automatically start upload after files are added
      * @default false
      */
-    autoProceed?: boolean;
+    autoUpload?: boolean;
 }
 export interface ThumbnailOptions {
     width?: number;
@@ -265,6 +265,8 @@ type CoreUploaderEvents<TUploadResult = any> = {
         oldIndex: number;
         newIndex: number;
     };
+    /** Emitted when all files have finished uploading (all files have 'complete' status) */
+    "files:uploaded": Array<Readonly<UploadFile<TUploadResult>>>;
 };
 export type UploaderEvents<TUploadResult = any> = CoreUploaderEvents<TUploadResult>;
 /**
@@ -390,13 +392,13 @@ export interface Plugin<TUploadResult = any, TPluginEvents extends Record<string
  */
 export declare function defineProcessingPlugin<TPluginOptions = unknown, TPluginEvents extends Record<string, any> = Record<string, never>>(factory: (options: TPluginOptions) => ProcessingPlugin<any, TPluginEvents>): (options: TPluginOptions) => ProcessingPlugin<any, TPluginEvents>;
 /**
- * Define a storage plugin (Azure, S3, GCS, etc.)
+ * Define a storage adapter (Azure, S3, GCS, etc.)
  *
- * Storage plugins MUST implement the `upload` hook and should return an object with a `url` property.
+ * Storage adapters MUST implement the `upload` hook and should return an object with a `url` property.
  *
  * @example Azure Storage
  * ```typescript
- * export const PluginAzureDataLake = defineStoragePlugin<AzureOptions, AzureEvents>((options) => ({
+ * export const PluginAzureDataLake = defineStorageAdapter<AzureOptions, AzureEvents>((options) => ({
  *   id: 'azure-datalake-storage',
  *   hooks: {
  *     upload: async (file, context) => {
@@ -414,7 +416,11 @@ export declare function defineProcessingPlugin<TPluginOptions = unknown, TPlugin
  * }))
  * ```
  */
-export declare function defineStoragePlugin<TPluginOptions = unknown, TUploadResult = any, TPluginEvents extends Record<string, any> = Record<string, never>>(factory: (options: TPluginOptions) => StoragePlugin<TUploadResult, TPluginEvents>): (options: TPluginOptions) => StoragePlugin<TUploadResult, TPluginEvents>;
+export declare function defineStorageAdapter<TPluginOptions = unknown, TUploadResult = any, TPluginEvents extends Record<string, any> = Record<string, never>>(factory: (options: TPluginOptions) => StoragePlugin<TUploadResult, TPluginEvents>): (options: TPluginOptions) => StoragePlugin<TUploadResult, TPluginEvents>;
+/**
+ * @deprecated Use `defineStorageAdapter` instead
+ */
+export declare const defineStoragePlugin: typeof defineStorageAdapter;
 /**
  * Define an uploader plugin with type safety, context access, and custom events.
  * This is the universal plugin factory for all plugin types (storage, validators, processors).

package/dist/runtime/composables/useUploadKit/types.js

@@ -1,9 +1,10 @@
 export function defineProcessingPlugin(factory) {
   return factory;
 }
-export function defineStoragePlugin(factory) {
+export function defineStorageAdapter(factory) {
   return factory;
 }
+export const defineStoragePlugin = defineStorageAdapter;
 export function defineUploaderPlugin(factory) {
   return factory;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-upload-kit",
-  "version": "0.1.4",
+  "version": "0.1.8",
   "description": "A powerful, plugin-based file upload manager for Nuxt applications",
   "license": "MIT",
   "repository": "https://github.com/genu/nuxt-upload-kit.git",
@@ -27,6 +27,8 @@
     "mitt": "^3.0.1"
   },
   "devDependencies": {
+    "@aws-sdk/client-s3": "^3.969.0",
+    "@aws-sdk/lib-storage": "^3.969.0",
     "@azure/storage-file-datalake": "^12.28.1",
     "@ffmpeg/ffmpeg": "0.12.15",
     "@ffmpeg/util": "0.12.2",
@@ -42,7 +44,8 @@
     "eslint": "^9.39.2",
     "eslint-config-prettier": "10.1.8",
     "eslint-plugin-prettier": "5.5.5",
-    "happy-dom": "^20.1.0",
+    "firebase": "^12.7.0",
+    "happy-dom": "^20.2.0",
     "nuxt": "^4.2.2",
     "prettier": "^3.7.4",
     "typescript": "~5.9.3",