nuxt-upload-kit 0.1.5 → 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

package/dist/module.json

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

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

@@ -392,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) => {
@@ -416,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.5",
+  "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",