@evolve.ui/core-components 1.0.0

package/index-BAR19_eg.d.cts

@@ -0,0 +1,494 @@
+import { FileRejection } from "react-dropzone";
+
+//#region src/FileUpload/types/commonTypes.d.ts
+/**
+ * Possible error codes for file validation failures - these are the codes that are used in the validation messages.
+ * These are the codes used by React-Dropzone under the hood.
+ * @typedef {string} FileErrorCode
+ * @property {'file-invalid-type'} - File type not accepted
+ * @property {'file-too-large'} - File exceeds size limit
+ * @property {'too-many-files'} - Exceeds maximum file count
+ * @property {string} CustomError - Custom error message
+ */
+type FileErrorCode = 'file-invalid-type' | 'file-too-large' | 'too-many-files' | string;
+type RemoteFile = {
+  id?: string;
+  name: string;
+  type?: string;
+  url: string;
+};
+type FileResource = File | RemoteFile;
+/**
+ * Generic type for messages that can be either a string or a function that returns a string based on context
+ * This allows for dynamic messages that can incorporate data from the current validation context.
+ *
+ * @template T - The context type that will be passed to the message function
+ * @example
+ * // Static message
+ * const staticMessage: ContextAwareMessage<DynamicMessageContext> = "File type not supported";
+ *
+ * // Dynamic message that uses context
+ * const dynamicMessage: ContextAwareMessage<DynamicMessageContext> =
+ *   (context) => `File exceeds the ${context.formattedMaxSize} limit`;
+ */
+type ContextAwareMessage<T> = string | ((context: T) => string) | undefined;
+/**
+ * Base context with common properties used by all message types
+ * Contains the shared information needed to generate validation messages
+ * for both drag and drop events.
+ *
+ * @property acceptedFileExtensions - Comma-separated list of accepted file extensions (e.g., '.jpg, .png')
+ * @property errorCode - The validation error code triggering this message
+ * @property fileCount - Number of files involved in the validation event
+ * @property filePluralizationText - Properly pluralized text for file type (e.g., "image" or "images")
+ * @property formattedMaxSize - Human-readable maximum file size (e.g., "5 MB")
+ * @property maxFiles - Maximum number of files allowed
+ * @property maxFilesPluralizationText - Properly pluralized text for max files (e.g., "file" or "files")
+ * @property maxSizeBytes - Maximum file size in bytes
+ */
+type BaseDynamicMessageContext = {
+  acceptedFileExtensions?: string;
+  errorCode: string;
+  fileCount?: number;
+  filePluralizationText?: string;
+  formattedMaxSize?: string;
+  maxFiles?: number;
+  maxFilesPluralizationText?: string;
+  maxSizeBytes?: number;
+};
+/**
+ * Context for drag events with drag-specific properties
+ * Used to generate validation messages during file drag operations.
+ *
+ * @property draggedItems - The DataTransferItemList containing all items being dragged (not just rejected ones)
+ * @property eventType - Always 'drag' for drag events
+ */
+type DragMessageContext = BaseDynamicMessageContext & {
+  draggedItems?: DataTransferItemList;
+  eventType: 'drag';
+};
+/**
+ * Context for drop events with drop-specific properties
+ * Used to generate validation messages after files have been dropped.
+ *
+ * @property eventType - Always 'drop' for drop events
+ * @property rejectedFileList - Comma-separated list of rejected file names
+ * @property rejectedFiles - Array of File objects that failed validation
+ */
+type DropMessageContext = BaseDynamicMessageContext & {
+  eventType: 'drop';
+  rejectedFileList?: string;
+  rejectedFiles?: File[];
+};
+/**
+ * Guaranteed minimal properties available on all DynamicMessageContext variants.
+ * This type represents the contract for what you can ALWAYS safely destructure
+ * from any message context, regardless of whether it's a drag or drop event.
+ *
+ * Your custom validator message functions receive the full DynamicMessageContext,
+ * but you can safely destructure just these core properties for simple validators.
+ *
+ * @property fileCount - Number of files involved in the validation
+ * @property filePluralizationText - Properly pluralized text (e.g., "file" or "files")
+ *
+ * @example
+ * // Simple validator - only uses guaranteed properties
+ * const validator: FileValidator = (file) => {
+ *   if (invalid) {
+ *     return [{
+ *       code: 'custom-error',
+ *       message: ({ fileCount, filePluralizationText }) =>
+ *         `${fileCount} ${filePluralizationText} failed validation`
+ *     }];
+ *   }
+ *   return null;
+ * };
+ */
+type ValidationMessageContext = {
+  fileCount: number;
+  filePluralizationText: string;
+};
+/**
+ * Context object provided to dynamic message functions in validators.
+ * This is a union of drag and drop contexts, representing what's actually passed at runtime.
+ *
+ * While the full context includes many optional properties (like formattedMaxSize, maxFiles, etc.),
+ * you can always safely destructure the core properties: fileCount and filePluralizationText
+ * (see ValidationMessageContext for the guaranteed minimal subset).
+ *
+ * Use isDragContext or isDropContext type guards to access event-specific properties safely.
+ */
+type DynamicMessageContext = DragMessageContext | DropMessageContext;
+/**
+ * Type guard to check if a context is a drag context
+ * Use this before accessing drag-specific properties
+ *
+ * @param context - The message context to check
+ * @returns true if context is a drag context, false otherwise
+ */
+declare const isDragContext: (context: DynamicMessageContext) => context is DragMessageContext;
+/**
+ * Type guard to check if a context is a drop context
+ * Use this before accessing drop-specific properties
+ *
+ * @param context - The message context to check
+ * @returns true if context is a drop context, false otherwise
+ */
+declare const isDropContext: (context: DynamicMessageContext) => context is DropMessageContext;
+/**
+ * Parameters for generating validation messages
+ * Used to create appropriate error messages for different validation scenarios.
+ *
+ * @property code - The error code that triggered the validation failure
+ * @property count - Optional number of files that failed this specific validation
+ * @property message - Optional message string or function that generates a message based on context
+ * @property messageType - Optional string indicating the type of message ('drag' or 'drop')
+ */
+type ValidationMessageParams = {
+  code: FileErrorCode;
+  count?: number;
+  message?: ContextAwareMessage<DynamicMessageContext>;
+  messageType?: 'drag' | 'drop';
+};
+/**
+ * Represents a file validation error that can include dynamic messaging
+ * Used during the validation process before messages are finalized.
+ * This type allows for context-aware messages that can be resolved
+ * at runtime based on the validation context.
+ *
+ * @property code - Error code identifying the type of validation failure
+ * @property message - Human-readable error message or function that generates one
+ * @remarks Used during validation process before messages are finalized
+ */
+type DynamicFileError = {
+  code: FileErrorCode;
+  message: ContextAwareMessage<DynamicMessageContext>;
+};
+/**
+ * Structure for processed validation error responses
+ * The final form of validation errors after message resolution.
+ * Unlike DynamicFileError, FileError messages are always strings,
+ * as they have already been processed with context.
+ *
+ * @property code - Error code identifying the type of validation failure
+ * @property message - Human-readable error message
+ * @remarks Used for displaying validation results after message processing
+ */
+type FileError = {
+  code: FileErrorCode;
+  message: string;
+};
+/**
+ * Union type for validation errors that can be either a FileError or a DynamicFileError
+ * This type allows for flexibility in handling different types of validation errors
+ * and provides a common interface for processing them
+ */
+type ValidationError = FileError | DynamicFileError;
+/**
+ * Represents a file rejection from the upload process
+ * Re-exported from react-dropzone for convenience
+ *
+ * @property file - The rejected file
+ * @property errors - Array of errors associated with the rejected file
+ */
+type FileRejection$1 = FileRejection;
+/**
+ * Predefined categories of file types
+ * Used as a convenient shorthand for common file type groups
+ *
+ * @value 'images' - Common image formats (jpeg, png, gif, webp)
+ * @value 'pdfs' - PDF documents only
+ * @value 'documents' - Office and PDF documents (pdf, doc, docx, xls, xlsx)
+ */
+type CommonFileTypes = 'images' | 'pdfs' | 'documents';
+/**
+ * Ensures numbers are greater than 0; used for validation parameters
+ * A type utility that prevents negative numbers or zero from being used
+ * in places where only positive numbers make sense (e.g., file size limits)
+ */
+type PositiveNumber = number extends infer N ? N extends number ? N extends 0 ? never : N extends -1 ? never : number : never : never;
+/**
+ * Custom validation function for file uploads
+ * Implement this to create custom validation rules beyond the built-in ones
+ *
+ * @param file - File or DataTransferItem to validate
+ * @returns An array of ValidationError objects if validation fails, null if passes
+ */
+type FileValidator = (file: File | DataTransferItem) => ValidationError[] | null;
+/**
+ * Configuration for file validation
+ * Used to set up validation rules and behavior for file uploads
+ *
+ * @property accept - Allowed file types (preset categories or MIME types/extensions)
+ * @property error - Optional custom error to display regardless of validation results
+ * @property maxFiles - Maximum number of files allowed
+ * @property maxSize - Maximum file size in bytes
+ * @property strictValidation - If true, rejects all files when any validation fails
+ * @property validator - Optional custom validation function
+ */
+type ValidationConfig = {
+  accept?: CommonFileTypes | string[];
+  error?: FileError;
+  maxFiles?: number;
+  maxSize?: number;
+  strictValidation?: boolean;
+  validator?: FileValidator;
+};
+//#endregion
+//#region src/FileUpload/providers/UploadValidationProvider.d.ts
+/**
+ * Provider component that shares file validation logic and state across components
+ * @param props Object containing:
+ *   - accept: Optional file type restrictions (MIME types or preset categories)
+ *   - children: React child components
+ *   - error: Optional custom validation error object
+ *   - maxFiles: Optional maximum number of files allowed (1 for single file, undefined for unlimited)
+ *   - maxSize: Optional maximum file size in bytes
+ *   - strictValidation: Optional boolean to enable strict validation
+ *   - validator: Optional custom validation function
+ * @returns Provider component with shared validation context
+ * @remarks
+ * - Components can access validation through useValidationContext hook
+ * - If no provider is present, components will fall back to local validation logic
+ * - Validation state is shared between drag and drop operations
+ * - Errors must be explicitly set using the provided setter methods (setDragValidationError, setDropValidationErrors)
+ */
+type UploadValidationContextType = {
+  /** Accepted file types - either preset categories or an array of MIME types */accept?: CommonFileTypes | string[]; /** Clears all validation errors (both drag and drop errors) */
+  clearAllValidation: () => void; /** Clears drag-related validation errors */
+  clearDragValidation: () => void; /** Clears drop-related validation errors */
+  clearDropValidation: () => void; /** Current drag validation error or null if none */
+  dragValidationError: FileError | null; /** Array of drop validation errors */
+  dropValidationErrors: FileError[]; /** Files that failed validation with their rejection reasons */
+  fileRejections: FileRejection$1[]; /** Human-readable maximum file size (e.g., "5 MB") */
+  formattedMaxSize: string | undefined; /** Generates context-aware validation messages */
+  getValidationMessage: (params: ValidationMessageParams) => string; /** Maximum number of files allowed (1 for single file upload) */
+  maxFiles?: number; /** Maximum file size in bytes */
+  maxSize?: number; /** Sets the drag validation error */
+  setDragValidationError: (error: FileError | null) => void; /** Sets the drop validation errors array */
+  setDropValidationErrors: (errors: FileError[]) => void; /** Updates the file rejections array */
+  setFileRejections: (rejections: FileRejection$1[]) => void; /** When true, all files are rejected if any fail validation */
+  strictValidation?: boolean; /** Custom validation function for additional file checks */
+  validateCustomRules: FileValidator; /** Validates if adding new files would exceed the maximum file count */
+  validateFileCount: (currentCount: number, newCount: number) => boolean; /** Checks if a file size is within the allowed limit */
+  validateFileSize: (fileSize: number) => boolean; /** Validates file type against accepted types */
+  validateFileType: (fileType: string, mimeTypes?: Record<string, string[]>) => boolean;
+};
+declare const UploadValidationContext: import("react").Context<UploadValidationContextType | undefined>;
+type UploadValidationProviderProps = {
+  /** Optional array of accepted file types */accept?: CommonFileTypes | string[]; /** React children */
+  children: React.ReactNode; /** Error object to display custom validation errors */
+  error?: FileError; /** Maximum number of files (1 for single file, undefined for unlimited) */
+  maxFiles?: number; /** Maximum allowed file size in bytes (Unrestricted by default) */
+  maxSize?: number; /** Enable strict validation */
+  strictValidation?: boolean; /** Custom validator function */
+  validator?: FileValidator;
+};
+declare const UploadValidationProvider: {
+  ({
+    accept,
+    children,
+    error,
+    maxFiles,
+    maxSize,
+    strictValidation,
+    validator
+  }: UploadValidationProviderProps): import("react/jsx-runtime").JSX.Element;
+  displayName: string;
+};
+/**
+ * Hook to access the upload validation context
+ *
+ * Provides access to validation state, error handling, and validation methods
+ * for file upload components.
+ *
+ * @returns The UploadValidationContextType object with validation state and methods
+ * @throws Error if used outside of an UploadValidationProvider
+ *
+ * @example
+ * ```tsx
+ * const validation = useValidationContext();
+ *
+ * // Validate file type
+ * const isValidType = validation.validateFileType(file.type);
+ *
+ * // Set validation error
+ * if (!isValidType) {
+ *   validation.setDragValidationError({
+ *     code: 'invalid-file-type',
+ *     message: 'File type not supported'
+ *   });
+ * }
+ * ```
+ */
+declare const useValidationContext: () => UploadValidationContextType;
+//#endregion
+//#region src/FileUpload/providers/FileUploadProvider.d.ts
+/**
+ * Context type for the FileUploadProvider
+ * Contains both file state management and callback handlers for file operations.
+ * This context makes file upload state and operations available to all child components.
+ *
+ * @property disabled - Whether the file upload functionality is disabled
+ * @property files - Array of currently selected/uploaded files
+ * @property onDrop - Callback triggered when files are dropped, with both accepted and rejected files
+ * @property onDropAccepted - Callback triggered when files pass validation
+ * @property onDropRejected - Callback triggered when files fail validation
+ * @property onFileDelete - Callback triggered when a file is deleted from the preview
+ * @property setFiles - State setter function to update the files array
+ */
+type FileUploadContextType = {
+  disabled: boolean;
+  files: FileResource[];
+  onDrop?: (acceptedFiles: File[], rejectedFiles: FileRejection$1[]) => void;
+  onDropAccepted?: (files: File[]) => void;
+  onDropRejected?: (rejectedFiles: FileRejection$1[]) => void;
+  onFileDelete?: (fileResource: FileResource) => void;
+  setFiles: (files: FileResource[] | ((prev: FileResource[]) => FileResource[])) => void;
+};
+/**
+ * React context for file upload state and operations
+ * Used by the useFileUploadContext hook
+ */
+declare const FileUploadContext: import("react").Context<FileUploadContextType | undefined>;
+/**
+ * Configuration props for the FileUploadProvider
+ * These props control both file upload behavior and validation rules.
+ * Many of these properties are passed to the underlying ValidationProvider.
+ */
+type FileUploadProviderConfigProps = {
+  /**
+   * Allowed file types - either preset categories ('images', 'pdfs', 'documents')
+   * or an array of MIME types/extensions (e.g., ['image/jpeg', '.png'])
+   */
+  accept?: CommonFileTypes | string[];
+  /**
+   * Whether the upload is disabled
+   * When true, prevents any interaction with the upload components
+   */
+  disabled?: boolean;
+  /**
+   * Error object to display custom validation errors
+   * Overrides any validation errors with this custom error
+   */
+  error?: FileError;
+  /**
+   * Initial files to populate the uploader with
+   * These files will be present when the component first mounts
+   */
+  initialFiles?: FileResource[];
+  /**
+   * Maximum number of files allowed
+   * Set to 1 for single file upload, undefined for unlimited
+   */
+  maxFiles?: number;
+  /**
+   * Maximum allowed file size in bytes
+   * Example: 5 * 1024 * 1024 for 5MB
+   */
+  maxSize?: number;
+  /**
+   * Callback when files are dropped (regardless of validation result)
+   * Provides both accepted and rejected files for handling
+   */
+  onDrop?: (acceptedFiles: File[], rejectedFiles: FileRejection$1[]) => void;
+  /**
+   * Callback when files pass validation and are accepted
+   * Useful for immediately processing valid files
+   */
+  onDropAccepted?: (files: File[]) => void;
+  /**
+   * Callback when files fail validation
+   * Provides detailed rejection reasons for each file
+   */
+  onDropRejected?: (rejectedFiles: FileRejection$1[]) => void;
+  /**
+   * Callback when user clicks delete button on a file preview
+   * Used to remove files from state or external storage
+   */
+  onFileDelete?: (fileResource: FileResource) => void;
+  /**
+   * When true, if any file fails validation, all files are rejected
+   * When false (default), valid files are accepted even if others are rejected
+   */
+  strictValidation?: boolean;
+  /**
+   * Custom validator function for additional validation rules
+   * Allows you to implement validation beyond the built-in type/size checks
+   */
+  validator?: FileValidator;
+};
+/**
+ * Props for the FileUploadProvider component
+ * Extends the config props with React children
+ */
+type FileUploadProviderProps = FileUploadProviderConfigProps & {
+  /** React children */children: React.ReactNode;
+};
+/**
+ * Provider component for file upload functionality
+ *
+ * This provider manages both file state and validation rules:
+ * 1. Maintains file state (selected/uploaded files)
+ * 2. Provides context for drag/drop operations and file management
+ * 3. Wraps children with validation context for enforcing file rules
+ *
+ * While FileDropzone and FilePreviewList can function as standalone components,
+ * using this provider offers coordinated state management when using multiple
+ * file upload components together.
+ *
+ * @example
+ * ```tsx
+ * <FileUploadProvider
+ *   accept="images"
+ *   maxFiles={5}
+ *   maxSize={2 * 1024 * 1024}
+ *   onDropAccepted={(files) => console.log('Accepted:', files)}
+ * >
+ *   <FileDropzone />
+ *   <FilePreviewList />
+ * </FileUploadProvider>
+ * ```
+ */
+declare const FileUploadProvider: {
+  ({
+    accept,
+    children,
+    disabled,
+    error,
+    initialFiles,
+    maxFiles,
+    maxSize,
+    onDrop,
+    onDropAccepted,
+    onDropRejected,
+    onFileDelete,
+    strictValidation,
+    validator
+  }: FileUploadProviderProps): import("react/jsx-runtime").JSX.Element;
+  displayName: string;
+};
+/**
+ * Hook to access the file upload context
+ *
+ * Provides access to the current files array and operations for
+ * managing file uploads within the FileUploadProvider.
+ *
+ * @throws Error if used outside of a FileUploadProvider
+ * @returns The FileUploadContextType object with files array and handlers
+ *
+ * @example
+ * ```tsx
+ * const { files, setFiles, onFileDelete } = useFileUploadContext();
+ *
+ * // Remove a file
+ * const handleDelete = (fileToDelete) => {
+ *   onFileDelete?.(fileToDelete);
+ *   setFiles(files.filter(file => file.name !== fileToDelete.name));
+ * };
+ * ```
+ */
+declare const useFileUploadContext: () => FileUploadContextType;
+//#endregion
+export { isDropContext as C, isDragContext as S, PositiveNumber as _, UploadValidationContext as a, ValidationError as b, useValidationContext as c, DynamicMessageContext as d, FileError as f, FileValidator as g, FileResource as h, useFileUploadContext as i, CommonFileTypes as l, FileRejection$1 as m, FileUploadContextType as n, UploadValidationContextType as o, FileErrorCode as p, FileUploadProvider as r, UploadValidationProvider as s, FileUploadContext as t, DynamicFileError as u, RemoteFile as v, ValidationMessageContext as x, ValidationConfig as y };
+//# sourceMappingURL=index-BAR19_eg.d.cts.map

package/index-BAR19_eg.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BAR19_eg.d.cts","names":[],"sources":["../src/FileUpload/types/commonTypes.ts","../src/FileUpload/providers/UploadValidationProvider.tsx","../src/FileUpload/providers/FileUploadProvider.tsx"],"mappings":"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"}