nuxt-upload-kit 0.1.1

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

@@ -0,0 +1,488 @@
+import type { Emitter } from "mitt";
+/**
+ * PUBLIC API - Types users commonly need
+ * These are exported from the main package
+ */
+export type FileStatus = "waiting" | "preprocessing" | "uploading" | "postprocessing" | "complete" | "error";
+export type UploadStatus = "waiting" | "uploading";
+export interface FileProgress {
+    percentage: number;
+}
+export interface FileError {
+    message: string;
+    details?: unknown;
+}
+/**
+ * File source - indicates where the file originated from
+ *
+ * - 'local': File selected from user's device
+ * - 'storage': File loaded from remote storage (was previously uploaded)
+ * - Cloud picker sources: Files picked from cloud providers (future)
+ *   - 'instagram': Instagram picker
+ *   - 'dropbox': Dropbox picker
+ *   - 'google-drive': Google Drive picker
+ *   - 'onedrive': OneDrive picker
+ *   - ... add more as needed
+ */
+export type FileSource = "local" | "storage" | "instagram" | "dropbox" | "google-drive" | "onedrive";
+/**
+ * Base properties shared by both local and remote upload files
+ */
+export interface BaseUploadFile<TUploadResult = any> {
+    /** Unique identifier for the file */
+    id: string;
+    /** Original filename (e.g., "vacation-photo.jpg") */
+    name: string;
+    /** File size in bytes */
+    size: number;
+    /** MIME type (e.g., "image/jpeg", "video/mp4") */
+    mimeType: string;
+    /**
+     * Current upload status
+     */
+    status: FileStatus;
+    /**
+     * Preview URL for displaying in UI (always populated after initialization)
+     * - For local files: Generated by thumbnail plugin as data URL, or remoteUrl after upload
+     * - For remote files: Provided by backend/storage, or falls back to remoteUrl
+     * - No manual fallback needed: Always available for display
+     */
+    preview?: string;
+    /** Upload progress tracking */
+    progress: FileProgress;
+    /** Error information if upload fails */
+    error?: FileError;
+    /**
+     * Result returned by the upload function/storage plugin
+     * Can contain additional metadata like etag, key, etc.
+     */
+    uploadResult?: TUploadResult;
+    /**
+     * Custom metadata for storing additional file information
+     * Plugins can add data here (e.g., { extension: 'jpg', originalWidth: 4000 })
+     */
+    meta: Record<string, unknown>;
+}
+/**
+ * Local upload file - originates from user's device
+ *
+ * Lifecycle:
+ * 1. User selects file → created with data, no remoteUrl
+ * 2. Validation → runs validate hooks
+ * 3. Preprocessing → generates thumbnails (preview set here)
+ * 4. User clicks upload → runs process hooks (compression)
+ * 5. Upload → remoteUrl set after successful upload
+ *
+ * @example
+ * ```typescript
+ * const localFile: LocalUploadFile = {
+ *   source: 'local',
+ *   data: fileBlob,        // Has local data
+ *   remoteUrl: undefined,  // Not uploaded yet
+ *   preview: 'data:image/jpeg;base64,...', // Generated by thumbnail plugin
+ *   ...
+ * }
+ * ```
+ */
+export interface LocalUploadFile<TUploadResult = any> extends BaseUploadFile<TUploadResult> {
+    /** Always 'local' for files selected from user's device */
+    source: "local";
+    /**
+     * The actual file data (File from input or Blob)
+     * Available for processing, compression, thumbnail generation, etc.
+     */
+    data: File | Blob;
+    /**
+     * URL where file was uploaded (set after successful upload)
+     * undefined before upload, populated after upload completes
+     * Use to check if file has been uploaded: `if (file.remoteUrl) { ... }`
+     */
+    remoteUrl?: string;
+}
+/**
+ * Remote upload file - originates from remote source
+ *
+ * These files already exist remotely and don't need uploading.
+ * Common sources:
+ * - 'storage': Previously uploaded files being re-loaded
+ * - 'instagram', 'dropbox', etc.: Files from cloud pickers
+ *
+ * @example
+ * ```typescript
+ * const remoteFile: RemoteUploadFile = {
+ *   source: 'storage',
+ *   data: null,           // No local data - file is remote
+ *   remoteUrl: 'https://storage.com/file.jpg',  // Always present
+ *   preview: 'https://storage.com/thumbnails/file.jpg', // Optional, from backend
+ *   status: 'complete',   // Already uploaded
+ *   ...
+ * }
+ * ```
+ */
+export interface RemoteUploadFile<TUploadResult = any> extends BaseUploadFile<TUploadResult> {
+    /**
+     * Source of the remote file
+     * - 'storage': File from your storage (previously uploaded)
+     * - 'instagram', 'dropbox', etc.: File from cloud picker
+     */
+    source: Exclude<FileSource, "local">;
+    /**
+     * Always null for remote files (no local data available)
+     * File exists remotely and is accessed via remoteUrl
+     */
+    data: null;
+    /**
+     * URL to the remote file (always present for remote files)
+     * Use this to display/download the file
+     */
+    remoteUrl: string;
+}
+/**
+ * Upload file discriminated union
+ * Use file.source to narrow the type in your code:
+ *
+ * @example
+ * ```typescript
+ * if (file.source === 'local') {
+ *   // TypeScript knows: file is LocalUploadFile
+ *   URL.createObjectURL(file.data)
+ * } else {
+ *   // TypeScript knows: file is RemoteUploadFile
+ *   console.log(file.remoteUrl)
+ * }
+ * ```
+ */
+export type UploadFile<TUploadResult = any> = LocalUploadFile<TUploadResult> | RemoteUploadFile<TUploadResult>;
+export type UploadFn<TUploadResult = any> = (file: UploadFile<TUploadResult>, onProgress: (progress: number) => void) => Promise<TUploadResult>;
+export type GetRemoteFileFn = (fileId: string) => Promise<MinimumRemoteFileAttributes>;
+export interface UploadOptions {
+    /**
+     * Storage plugin for uploading files (only one storage plugin can be active)
+     *
+     * Storage plugins handle the actual upload, download, and deletion of files
+     * from remote storage (Azure, S3, GCS, etc.)
+     *
+     * @example
+     * ```typescript
+     * storage: PluginAzureDataLake({
+     *   sasURL: 'https://...',
+     *   path: 'uploads'
+     * })
+     * ```
+     */
+    storage?: StoragePlugin<any, any>;
+    /**
+     * Processing and validation plugins (validators, compressors, etc.)
+     *
+     * These plugins run during the file lifecycle:
+     * - validate: Check file before adding
+     * - preprocess: Generate thumbnails/previews immediately
+     * - process: Compress/transform before upload
+     * - complete: Post-upload processing
+     *
+     * @example
+     * ```typescript
+     * plugins: [
+     *   ValidatorMaxFiles({ maxFiles: 10 }),
+     *   PluginImageCompressor({ quality: 0.8 })
+     * ]
+     * ```
+     */
+    plugins?: ProcessingPlugin<any, any>[];
+    /**
+     * Validate maximum number of files
+     * - false: disabled
+     * - number: enabled with limit
+     * @default false
+     */
+    maxFiles?: false | number;
+    /**
+     * Validate maximum file size in bytes
+     * - false: disabled
+     * - number: enabled with limit
+     * @default false
+     */
+    maxFileSize?: false | number;
+    /**
+     * Validate allowed file MIME types
+     * - false: disabled
+     * - string[]: enabled with allowed types
+     * @default false
+     */
+    allowedFileTypes?: false | string[];
+    /**
+     * Generate thumbnail previews for images/videos
+     * - false: disabled
+     * - true: enabled with defaults
+     * - object: enabled with custom options
+     * @default false
+     */
+    thumbnails?: false | true | ThumbnailOptions;
+    /**
+     * Compress images before upload
+     * - false: disabled
+     * - true: enabled with defaults
+     * - object: enabled with custom options
+     * @default false
+     */
+    imageCompression?: false | true | ImageCompressionOptions;
+    /**
+     * Automatically start upload after files are added
+     * @default false
+     */
+    autoProceed?: boolean;
+}
+export interface ThumbnailOptions {
+    width?: number;
+    height?: number;
+    quality?: number;
+}
+export interface ImageCompressionOptions {
+    maxWidth?: number;
+    maxHeight?: number;
+    quality?: number;
+    outputFormat?: "jpeg" | "webp" | "png" | "auto";
+    minSizeToCompress?: number;
+    preserveMetadata?: boolean;
+}
+type CoreUploaderEvents<TUploadResult = any> = {
+    "file:added": Readonly<UploadFile<TUploadResult>>;
+    "file:removed": Readonly<UploadFile<TUploadResult>>;
+    "file:replaced": Readonly<UploadFile<TUploadResult>>;
+    "file:processing": Readonly<UploadFile<TUploadResult>>;
+    "file:error": {
+        file: Readonly<UploadFile<TUploadResult>>;
+        error: FileError;
+    };
+    "upload:start": Array<Readonly<UploadFile<TUploadResult>>>;
+    "upload:complete": Array<Required<Readonly<UploadFile<TUploadResult>>>>;
+    "upload:error": FileError;
+    "upload:progress": {
+        file: Readonly<UploadFile<TUploadResult>>;
+        progress: number;
+    };
+    "files:reorder": {
+        oldIndex: number;
+        newIndex: number;
+    };
+};
+export type UploaderEvents<TUploadResult = any> = CoreUploaderEvents<TUploadResult>;
+/**
+ * PLUGIN API - Types for building custom plugins
+ * Only needed if users want to create custom validators/processors
+ */
+export type PluginContext<TPluginEvents extends Record<string, any> = Record<string, never>> = {
+    files: UploadFile[];
+    options: UploadOptions;
+    /**
+     * Emit custom plugin events
+     * Events are automatically prefixed with the plugin ID
+     */
+    emit: <K extends keyof TPluginEvents>(event: K, payload: TPluginEvents[K]) => void;
+};
+export type ValidationHook<TPluginEvents extends Record<string, any> = Record<string, never>> = (file: UploadFile, context: PluginContext<TPluginEvents>) => Promise<true | UploadFile>;
+export type ProcessingHook<TPluginEvents extends Record<string, any> = Record<string, never>> = (file: UploadFile, context: PluginContext<TPluginEvents>) => Promise<UploadFile>;
+export type SetupHook<TPluginEvents extends Record<string, any> = Record<string, never>> = (context: PluginContext<TPluginEvents>) => Promise<void>;
+/**
+ * Storage hooks for handling upload/download/deletion operations
+ *
+ * Storage plugins MUST return an object containing a `url` property.
+ * This URL will be set as the file's `remoteUrl` after successful upload.
+ *
+ * @example
+ * ```typescript
+ * upload: async (file, context) => {
+ *   // Upload logic...
+ *   return {
+ *     url: 'https://storage.example.com/file.jpg',  // Required
+ *     key: 'uploads/file.jpg',                      // Optional
+ *     etag: 'abc123'                                // Optional
+ *   }
+ * }
+ * ```
+ */
+export type UploadHook<TUploadResult = any, TPluginEvents extends Record<string, any> = Record<string, never>> = (file: UploadFile<TUploadResult>, context: PluginContext<TPluginEvents> & {
+    onProgress: (progress: number) => void;
+}) => Promise<TUploadResult & {
+    url: string;
+}>;
+export type GetRemoteFileHook<TPluginEvents extends Record<string, any> = Record<string, never>> = (fileId: string, context: PluginContext<TPluginEvents>) => Promise<MinimumRemoteFileAttributes>;
+export type RemoveHook<TPluginEvents extends Record<string, any> = Record<string, never>> = (file: UploadFile, context: PluginContext<TPluginEvents>) => Promise<void>;
+export type PluginLifecycleStage = "validate" | "preprocess" | "process" | "upload" | "complete";
+/**
+ * Processing plugin hooks (validators, compressors, thumbnail generators)
+ */
+export type ProcessingPluginHooks<TPluginEvents extends Record<string, any> = Record<string, never>> = {
+    validate?: ValidationHook<TPluginEvents>;
+    preprocess?: ProcessingHook<TPluginEvents>;
+    process?: ProcessingHook<TPluginEvents>;
+    complete?: ProcessingHook<TPluginEvents>;
+};
+/**
+ * Storage plugin hooks (upload, download, delete from remote storage)
+ */
+export type StoragePluginHooks<TUploadResult = any, TPluginEvents extends Record<string, any> = Record<string, never>> = {
+    upload: UploadHook<TUploadResult, TPluginEvents>;
+    getRemoteFile?: GetRemoteFileHook<TPluginEvents>;
+    remove?: RemoveHook<TPluginEvents>;
+};
+/**
+ * All possible plugin hooks (for internal use)
+ */
+export type PluginHooks<TUploadResult = any, TPluginEvents extends Record<string, any> = Record<string, never>> = {
+    validate?: ValidationHook<TPluginEvents>;
+    preprocess?: ProcessingHook<TPluginEvents>;
+    process?: ProcessingHook<TPluginEvents>;
+    upload?: UploadHook<TUploadResult, TPluginEvents>;
+    getRemoteFile?: GetRemoteFileHook<TPluginEvents>;
+    remove?: RemoveHook<TPluginEvents>;
+    complete?: ProcessingHook<TPluginEvents>;
+};
+/**
+ * Processing plugin (validators, compressors, thumbnail generators)
+ *
+ * These plugins transform or validate files without handling storage.
+ */
+export interface ProcessingPlugin<_TUploadResult = any, TPluginEvents extends Record<string, any> = Record<string, never>> {
+    id: string;
+    hooks: ProcessingPluginHooks<TPluginEvents>;
+    options?: UploadOptions;
+    events?: TPluginEvents;
+}
+/**
+ * Storage plugin (Azure, S3, GCS, etc.)
+ *
+ * Storage plugins handle uploading, downloading, and deleting files from remote storage.
+ * Only one storage plugin can be active at a time.
+ */
+export interface StoragePlugin<TUploadResult = any, TPluginEvents extends Record<string, any> = Record<string, never>> {
+    id: string;
+    hooks: StoragePluginHooks<TUploadResult, TPluginEvents>;
+    options?: UploadOptions;
+    events?: TPluginEvents;
+}
+/**
+ * Base plugin interface (for internal use - supports both types)
+ */
+export interface Plugin<TUploadResult = any, TPluginEvents extends Record<string, any> = Record<string, never>> {
+    id: string;
+    hooks: PluginHooks<TUploadResult, TPluginEvents>;
+    options?: UploadOptions;
+    events?: TPluginEvents;
+}
+/**
+ * Define a processing plugin (validators, compressors, thumbnail generators)
+ *
+ * @example Validator
+ * ```typescript
+ * export const ValidatorMaxFiles = defineProcessingPlugin<ValidatorOptions>((options) => ({
+ *   id: 'validator-max-files',
+ *   hooks: {
+ *     validate: async (file, context) => {
+ *       if (context.files.length >= options.maxFiles) {
+ *         throw { message: 'Too many files' }
+ *       }
+ *       return file
+ *     }
+ *   }
+ * }))
+ * ```
+ */
+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.)
+ *
+ * Storage plugins 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) => ({
+ *   id: 'azure-datalake-storage',
+ *   hooks: {
+ *     upload: async (file, context) => {
+ *       const fileClient = await getFileClient(file.id)
+ *       await fileClient.upload(file.data, { onProgress: context.onProgress })
+ *       return { url: fileClient.url, blobPath: fileClient.name }
+ *     },
+ *     getRemoteFile: async (fileId, context) => {
+ *       // ... fetch file metadata ...
+ *     },
+ *     remove: async (file, context) => {
+ *       // ... delete file ...
+ *     }
+ *   }
+ * }))
+ * ```
+ */
+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>;
+/**
+ * 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).
+ *
+ * @deprecated Use defineProcessingPlugin or defineStoragePlugin instead for better type safety
+ *
+ * Hooks receive context as a parameter, making it clear when context is available.
+ * Context includes current files, options, and an emit function for custom events.
+ *
+ * @example Basic Plugin
+ * ```typescript
+ * export const ValidatorMaxFiles = defineUploaderPlugin<ValidatorOptions>((options) => ({
+ *   id: 'validator-max-files',
+ *   hooks: {
+ *     validate: async (file, context) => {
+ *       if (context.files.length >= options.maxFiles) {
+ *         throw { message: 'Too many files' }
+ *       }
+ *       return file
+ *     }
+ *   }
+ * }))
+ * ```
+ *
+ * @example Plugin with Custom Events
+ * ```typescript
+ * type CompressionEvents = {
+ *   start: { file: UploadFile; originalSize: number }
+ *   complete: { file: UploadFile; savedBytes: number }
+ * }
+ *
+ * export const PluginImageCompressor = defineUploaderPlugin<
+ *   ImageCompressorOptions,
+ *   CompressionEvents
+ * >((options) => ({
+ *   id: 'image-compressor',
+ *   hooks: {
+ *     process: async (file, context) => {
+ *       context.emit('start', { file, originalSize: file.size })
+ *       // ... compression logic ...
+ *       context.emit('complete', { file, savedBytes: 1000 })
+ *       return file
+ *     }
+ *   }
+ * }))
+ *
+ * // Usage - events are automatically prefixed with plugin ID
+ * uploader.on('image-compressor:complete', ({ file, savedBytes }) => {
+ *   console.log(`Saved ${savedBytes} bytes`)
+ * })
+ * ```
+ */
+export declare function defineUploaderPlugin<TPluginOptions = unknown, TPluginEvents extends Record<string, any> = Record<string, never>>(factory: (options: TPluginOptions) => Plugin<any, TPluginEvents>): (options: TPluginOptions) => Plugin<any, TPluginEvents>;
+/**
+ * INTERNAL TYPES - Not commonly needed by users
+ * Kept exported for edge cases but not primary API
+ */
+export type PreProcessor = (file: UploadFile) => Promise<UploadFile>;
+export type Uploader = (file: Readonly<UploadFile>, emiter: Emitter<Pick<UploaderEvents, "upload:error" | "upload:progress">>) => Promise<string>;
+export type Validator = (file: UploadFile) => Promise<boolean | FileError>;
+export type Processor = (file: UploadFile) => Promise<File | Blob>;
+export interface UploadBlob {
+    blobPath: string;
+}
+type MinimumRemoteFileAttributes = {
+    size: number;
+    mimeType: string;
+    remoteUrl: string;
+    preview?: string;
+};
+export {};

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

@@ -0,0 +1,9 @@
+export function defineProcessingPlugin(factory) {
+  return factory;
+}
+export function defineStoragePlugin(factory) {
+  return factory;
+}
+export function defineUploaderPlugin(factory) {
+  return factory;
+}

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

@@ -0,0 +1,23 @@
+import type { PluginContext, UploadFile, FileError, UploadOptions } from "./types.js";
+import type { Emitter } from "mitt";
+/**
+ * Create a plugin context object with consistent structure
+ */
+export declare function createPluginContext<TPluginEvents extends Record<string, any> = Record<string, never>>(pluginId: string, files: UploadFile[], options: UploadOptions, emitter: Emitter<any>): PluginContext<TPluginEvents>;
+/**
+ * Create a consistent file error object
+ */
+export declare function createFileError(file: UploadFile, error: unknown): FileError;
+/**
+ * Calculate thumbnail dimensions while maintaining aspect ratio
+ */
+export declare function calculateThumbnailDimensions(originalWidth: number, originalHeight: number, maxWidth: number, maxHeight: number): {
+    width: number;
+    height: number;
+};
+/**
+ * Cleanup object URLs to prevent memory leaks
+ * @param urlMap Map of file IDs to object URLs
+ * @param fileId Optional file ID to cleanup specific URL, or cleanup all if not provided
+ */
+export declare function cleanupObjectURLs(urlMap: Map<string, string>, fileId?: string): void;

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

@@ -0,0 +1,45 @@
+export function createPluginContext(pluginId, files, options, emitter) {
+  return {
+    files,
+    options,
+    emit: (event, payload) => {
+      const prefixedEvent = `${pluginId}:${String(event)}`;
+      emitter.emit(prefixedEvent, payload);
+    }
+  };
+}
+export function createFileError(file, error) {
+  return {
+    message: error instanceof Error ? error.message : String(error),
+    details: {
+      fileName: file.name,
+      fileSize: file.size,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+export function calculateThumbnailDimensions(originalWidth, originalHeight, maxWidth, maxHeight) {
+  const aspectRatio = originalWidth / originalHeight;
+  let width = maxWidth;
+  let height = maxHeight;
+  if (aspectRatio > 1) {
+    height = maxWidth / aspectRatio;
+  } else {
+    width = maxHeight * aspectRatio;
+  }
+  return { width, height };
+}
+export function cleanupObjectURLs(urlMap, fileId) {
+  if (fileId) {
+    const url = urlMap.get(fileId);
+    if (url) {
+      URL.revokeObjectURL(url);
+      urlMap.delete(fileId);
+    }
+  } else {
+    for (const url of urlMap.values()) {
+      URL.revokeObjectURL(url);
+    }
+    urlMap.clear();
+  }
+}

package/dist/runtime/composables/useUploadKit/validators/allowed-file-types.d.ts

@@ -0,0 +1,5 @@
+interface ValidatorAllowedFileTypesOptions {
+    allowedFileTypes?: string[];
+}
+export declare const ValidatorAllowedFileTypes: (options: ValidatorAllowedFileTypesOptions) => import("../types.js").ProcessingPlugin<any, Record<string, never>>;
+export {};

package/dist/runtime/composables/useUploadKit/validators/allowed-file-types.js

@@ -0,0 +1,17 @@
+import { defineProcessingPlugin } from "../types.js";
+export const ValidatorAllowedFileTypes = defineProcessingPlugin((options) => {
+  return {
+    id: "validator-allowed-file-types",
+    hooks: {
+      validate: async (file, _context) => {
+        if (!options.allowedFileTypes || options.allowedFileTypes.length === 0) {
+          return file;
+        }
+        if (options.allowedFileTypes.includes(file.mimeType)) {
+          return file;
+        }
+        throw { message: `File type ${file.mimeType} is not allowed` };
+      }
+    }
+  };
+});

package/dist/runtime/composables/useUploadKit/validators/duplicate-file.d.ts

@@ -0,0 +1,13 @@
+interface ValidatorDuplicateFileOptions {
+    /**
+     * Whether to allow duplicate files
+     * @default false
+     */
+    allowDuplicates?: boolean;
+    /**
+     * Custom error message for duplicates
+     */
+    errorMessage?: string;
+}
+export declare const ValidatorDuplicateFile: (options: ValidatorDuplicateFileOptions) => import("../types.js").Plugin<any, Record<string, never>>;
+export {};

package/dist/runtime/composables/useUploadKit/validators/duplicate-file.js

@@ -0,0 +1,27 @@
+import { defineUploaderPlugin } from "../types.js";
+export const ValidatorDuplicateFile = defineUploaderPlugin((options) => {
+  const { allowDuplicates = false, errorMessage = "This file has already been added" } = options;
+  return {
+    id: "validator-duplicate-file",
+    hooks: {
+      validate: async (file, context) => {
+        if (allowDuplicates) {
+          return file;
+        }
+        const isDuplicate = context.files.some((existingFile) => {
+          const sameSize = existingFile.size === file.size;
+          const sameName = existingFile.name === file.name;
+          let sameDate = true;
+          if (file.data instanceof File && existingFile.data instanceof File) {
+            sameDate = existingFile.data.lastModified === file.data.lastModified;
+          }
+          return sameSize && sameName && sameDate;
+        });
+        if (isDuplicate) {
+          throw { message: errorMessage, details: { fileName: file.name } };
+        }
+        return file;
+      }
+    }
+  };
+});

package/dist/runtime/composables/useUploadKit/validators/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./allowed-file-types.js";
+export * from "./max-file-size.js";
+export * from "./max-files.js";
+export * from "./duplicate-file.js";

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

@@ -0,0 +1,4 @@
+export * from "./allowed-file-types.js";
+export * from "./max-file-size.js";
+export * from "./max-files.js";
+export * from "./duplicate-file.js";

package/dist/runtime/composables/useUploadKit/validators/max-file-size.d.ts

@@ -0,0 +1,5 @@
+interface ValidatorMaxFileSizeOptions {
+    maxFileSize?: number;
+}
+export declare const ValidatorMaxFileSize: (options: ValidatorMaxFileSizeOptions) => import("../types.js").ProcessingPlugin<any, Record<string, never>>;
+export {};

package/dist/runtime/composables/useUploadKit/validators/max-file-size.js

@@ -0,0 +1,17 @@
+import { defineProcessingPlugin } from "../types.js";
+export const ValidatorMaxFileSize = defineProcessingPlugin((options) => {
+  return {
+    id: "validator-max-file-size",
+    hooks: {
+      validate: async (file, _context) => {
+        if (!options.maxFileSize || options.maxFileSize === Infinity) {
+          return file;
+        }
+        if (file.size <= options.maxFileSize) {
+          return file;
+        }
+        throw { message: `File size exceeds the maximum limit of ${options.maxFileSize} bytes` };
+      }
+    }
+  };
+});

package/dist/runtime/composables/useUploadKit/validators/max-files.d.ts

@@ -0,0 +1,5 @@
+interface ValidatorMaxFilesOptions {
+    maxFiles?: number;
+}
+export declare const ValidatorMaxFiles: (options: ValidatorMaxFilesOptions) => import("../types.js").ProcessingPlugin<any, Record<string, never>>;
+export {};