image_validator 0.1.0

A comprehensive Dart package for validating image files with support for multiple formats (JPEG, PNG, WebP). Provides robust validation for file integrity, dimensions, and file sizes with flexible con [...]

Image Validator

A comprehensive Dart package for validating image files with support for multiple image formats (JPEG, JPG, PNG, WebP). This package provides robust validation for file integrity, dimensions, and file sizes with flexible configuration options.

Features

• Multi-format Support: Validate JPEG, JPG, PNG, and WebP image files
• Multiple Validation Types:
  • File Integrity: Detect corrupted or invalid image files
  • Dimension Validation: Check image width and height constraints (min/max)
  • File Size Validation: Verify file size in MB or bytes
• Hybrid Detection: Intelligent image type detection using both file signatures and extensions
• Comprehensive Error Handling: Detailed error messages for validation failures
• Factory Pattern: Clean and extensible validation architecture

Platform Support

Android	iOS	macOS	Web	Linux	Windows
✅	✅	✅	✅	✅	✅

Requirements

• Flutter: >=3.3.0
• Dart: >=2.18.0 <4.0.0

Installation

Add this to your pubspec.yaml:

dependencies:
  image_validator: ^0.1.0

Then run:

flutter pub get

Supported Image Formats

Format	Detectors	Validators
JPEG/JPG	File Signature, Extension	Size (MB), Dimensions, Corruption Detection
PNG	File Signature, Extension	Size (MB), Dimensions, Corruption Detection
WebP	File Signature, Extension	Size (MB), Dimensions, Corruption Detection

Image Type Detection

The package includes three detection strategies:

1. Extension-Based Detection

Detects image type from file extension (.jpg, .jpeg, .png, .webp).

2. Signature-Based Detection

Detects image type from file magic bytes/signatures for accurate file type identification.

3. Hybrid Detection (Recommended)

Combines both strategies: first tries signature-based detection, falls back to extension-based if signature is unsupported.

import 'dart:io';
import 'package:image_validator/image_validator.dart';

// Detect image type
final file = File('path/to/image.jpg');
final detector = HybridDetector();
final imageType = detector.detect(file);
print(imageType); // ImageTypeEnum.jpg or .jpeg, .png, .webp, .unsupported

Usage Examples

JPEG Validators

Size Validation

import 'dart:io';
import 'package:image_validator/image_validator/validator/file_type_validator/jpeg_validators/jpeg_size_validator.dart';
import 'package:image_validator/image_validator/validator/validator_result.dart';

final file = File('path/to/image.jpeg');
final sizeValidator = JpegSizeValidator(maxSizeInMB: 10);
ValidationResult result = await sizeValidator.validate(file);

if (result.isValid) {
  print('Image size is valid');
} else {
  print('Error: ${result.errorMessage}');
}

Dimension Validation

import 'package:image_validator/image_validator/validator/file_type_validator/jpeg_validators/jpeg_dimension_validator.dart';

final file = File('path/to/image.jpeg');
final dimensionValidator = JpegDimensionValidator(
  maxWidth: 3000,
  maxHeight: 3000,
  minWidth: 100,
  minHeight: 100,
);
ValidationResult result = await dimensionValidator.validate(file);

if (!result.isValid) {
  print('Dimension error: ${result.errorMessage}');
}

Corruption Detection

import 'package:image_validator/image_validator/validator/file_type_validator/jpeg_validators/jpeg_corrupted_validator.dart';

final file = File('path/to/image.jpeg');
final corruptionValidator = JpegCorruptValidator();
ValidationResult result = await corruptionValidator.validate(file);

if (result.isValid) {
  print('Image is valid and not corrupted');
} else {
  print('Image is corrupted: ${result.errorMessage}');
}

Available Validators

All validators follow the same pattern as shown in the JPEG examples above. Below is a complete list of available validators for all supported formats:

JPEG Validators:

• JpegSizeValidator - Validate file size in MB
• JpegDimensionValidator - Validate image dimensions (width/height)
• JpegCorruptValidator - Detect corrupted JPEG files

PNG Validators:

• PngSizeValidator - Validate file size in MB
• PngDimensionValidator - Validate image dimensions (width/height)
• PngCorruptValidator - Detect corrupted PNG files

WebP Validators:

• WebpSizeValidator - Validate file size in MB
• WebpDimentionValidator - Validate image dimensions (width/height)
• WebpCorruptValidator - Detect corrupted WebP files

All validators can be used exactly like the JPEG examples shown above. Simply replace the validator class name and adjust parameters as needed (MB vs Bytes for size validation).

Validation Result

All validators return a ValidationResult object:

class ValidationResult {
  final bool isValid;                    // True if validation passed
  final String? errorMessage;            // Error description if validation failed
  final ImageTypeEnum? fileType;         // Detected image type
  final File? file;                      // Original file reference
}

Factory Pattern - Main Validator Collector (Recommended Approach)

The FileValidatorFactory is the primary way to manage and use validators throughout your project. It allows you to define all your validation rules in one place and reuse them across your entire application.

import 'package:image_validator/image_validator/validator/factory/file_validator_factory.dart';
import 'package:image_validator/image_validator/validator/file_type_validator/jpeg_validators/jpeg_size_validator.dart';
import 'package:image_validator/image_validator/validator/file_type_validator/jpeg_validators/jpeg_dimension_validator.dart';
import 'package:image_validator/image_validator/validator/file_type_validator/png_validators/png_size_validator.dart';
import 'package:image_validator/image_validator/validator/file_type_validator/webp_validators/webp_size_validator.dart';

// Define your factory once with all validation rules
final factory = FileValidatorFactory(
  jpeg: [
    JpegSizeValidator(maxSizeInMB: 10),
    JpegDimensionValidator(maxWidth: 3000, maxHeight: 3000),
  ],
  png: [
    PngSizeValidator(maxSizeInMB: 10),
  ],
  webp: [
    WebpSizeValidator(maxSizeInMB: 10),
  ],
);

// Use the factory to validate images anywhere in your project
final file = File('path/to/image.jpeg');
var detector =  HybridDetector();
final imageType =detector.detect(file); // Detect image type first
ValidationResult result = await factory.validate(
  type: imageType,
  file: file,
);

if (result.isValid) {
  print('Image passed all validations');
} else {
  print('Validation failed: ${result.errorMessage}');
}

Why use the Factory Pattern?

• Define all validation rules in a single, centralized location
• Reuse the same validation configuration across your entire project
• Easy to maintain and modify validation rules
• Supports multiple validators per image type
• Validates images sequentially, stopping at the first failure

Supported Image Types Enum

enum ImageTypeEnum {
  jpg('image/jpeg'),
  jpeg('image/jpeg'),
  png('image/png'),
  webp('image/webp'),
  unsupported('application/octet-stream');
}

Contributing

Contributions are welcome! If you find this package useful or would like to help improve it, feel free to:

• Report issues or bugs
• Submit pull requests with enhancements
• Share feedback and suggestions

Your contributions help make this package better for everyone.

License

See LICENSE file for details.