snap-validate 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mini Validator Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,278 @@
+# Snap Validate ⚡
+
+[![npm version](https://badge.fury.io/js/snap-validate.svg)](https://badge.fury.io/js/snap-validate)
+[![Build Status](https://github.com/aniru-dh21/snap-validate/workflows/CI%2FCD%20Pipeline/badge.svg)](https://github.com/aniru-dh21/snap-validate/actions)
+[![Coverage Status](https://codecov.io/gh/aniru-dh21/snap-validate/branch/main/graph/badge.svg)](https://codecov.io/gh/aniru-dh21/snap-validate)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A lightning-fast, lightweight validation library for common patterns without heavy dependencies. Perfect for client-side and server-side validation with zero external dependencies.
+
+## Features
+
+- ⚡ **Lightning Fast**: Optimized for speed and performance
+- 🚀 **Lightweight**: No external dependencies, minimal footprint
+- 🔧 **Flexible**: Chainable validation rules and custom validators
+- 📧 **Common Patterns**: Email, phone, credit card, URL, password validation
+- 🌍 **International**: Support for different formats (US/International phone, postal codes)
+- 🧪 **Well Tested**: Comprehensive test suite with high coverage
+- 📦 **Easy Integration**: Works in Node.js and browsers
+- 🔗 **Chainable API**: Intuitive fluent interface
+
+## Installation
+
+```bash
+npm install snap-validate
+```
+
+## Quick Start
+
+```javascript
+const { validators, validate } = require('snap-validate');
+
+// Single field validation
+const emailResult = validators.email('user@example.com').validate();
+console.log(emailResult.isValid); // true
+
+// Schema validation
+const schema = {
+  email: validators.email,
+  phone: (value) => validators.phone(value, 'us'),
+  password: validators.password
+};
+
+const data = {
+  email: 'user@example.com',
+  phone: '(555) 123-4567',
+  password: 'SecurePass123'
+};
+
+const result = validate(schema, data);
+console.log(result.isValid); // true
+```
+
+## Available Validators
+
+### Email Validation
+
+```javascript
+validators.email('user@example.com').validate();
+```
+
+### Phone Number Validation
+
+```javascript
+// US format (default)
+validators.phone('(555) 123-4567').validate();
+
+// International format
+validators.phone('+1234567890', 'international').validate();
+
+// Simple numeric
+validators.phone('1234567890', 'simple').validate();
+```
+
+### Credit Card Validation
+
+```javascript
+// Uses Luhn algorithm
+validators.creditCard('4532015112830366').validate();
+```
+
+### URL Validation
+
+```javascript
+validators.url('https://example.com').validate();
+```
+
+### Password Validation
+
+```javascript
+// Default: min 8 chars, requires upper, lower, numbers
+validators.password('SecurePass123').validate();
+
+// Custom options
+validators.password('MyPass123!', {
+  minLength: 10,
+  requireUppercase: true,
+  requireLowercase: true,
+  requireNumbers: true,
+  requireSpecialChars: true
+}).validate();
+```
+
+### Alphanumeric Validation
+
+```javascript
+validators.alphanumeric('ABC123').validate();
+```
+
+### Numeric Validation
+
+```javascript
+validators.numeric('12345').validate();
+```
+
+### Zip Code Validation
+
+```javascript
+// US zip code
+validators.zipCode('12345').validate();
+validators.zipCode('12345-6789').validate();
+
+// Canadian postal code
+validators.zipCode('K1A 0A6', 'ca').validate();
+
+// UK postal code
+validators.zipCode('SW1A 1AA', 'uk').validate();
+```
+
+## Custom Validation
+
+### Using BaseValidator
+
+```javascript
+const { BaseValidator } = require('snap-validate');
+
+const customValidator = new BaseValidator('test-value')
+  .required('This field is required')
+  .min(5, 'Must be at least 5 characters')
+  .max(20, 'Must be no more than 20 characters')
+  .pattern(/^[a-zA-Z]+$/, 'Only letters allowed');
+
+const result = customValidator.validate();
+```
+
+### Schema Validation with Custom Rules
+
+```javascript
+const schema = {
+  username: (value) => new BaseValidator(value)
+    .required()
+    .min(3)
+    .max(20)
+    .pattern(/^[a-zA-Z0-9_]+$/, 'Username can only contain letters, numbers, and underscores'),
+  
+  email: validators.email,
+  
+  age: (value) => new BaseValidator(value)
+    .required()
+    .pattern(/^\d+$/, 'Age must be a number')
+};
+
+const userData = {
+  username: 'john_doe',
+  email: 'john@example.com',
+  age: '25'
+};
+
+const result = validate(schema, userData);
+```
+
+## Error Handling
+
+```javascript
+const result = validators.email('invalid-email').validate();
+
+if (!result.isValid) {
+  console.log('Validation errors:', result.errors);
+  // Output: ['Invalid email format']
+}
+
+// For schema validation
+const schemaResult = validate(schema, data);
+if (!schemaResult.isValid) {
+  const errors = schemaResult.getErrors();
+  console.log('Field errors:', errors);
+  // Output: { email: ['Invalid email format'], password: ['Password too weak'] }
+}
+```
+
+## Browser Usage
+
+```html
+<script src="https://unpkg.com/snap-validate/src/index.js"></script>
+<script>
+  const { validators } = SnapValidate;
+  
+  const result = validators.email('user@example.com').validate();
+  console.log(result.isValid);
+</script>
+```
+
+## API Reference
+
+### ValidationResult
+
+- `isValid: boolean` - Whether validation passed
+- `errors: string[]` - Array of error messages
+
+### BaseValidator Methods
+
+- `required(message?)` - Field is required
+- `min(length, message?)` - Minimum length validation
+- `max(length, message?)` - Maximum length validation
+- `pattern(regex, message?)` - Pattern matching validation
+- `validate()` - Execute validation and return result
+
+### Available Validators
+
+- `validators.email(value)`
+- `validators.phone(value, format?)`
+- `validators.creditCard(value)`
+- `validators.url(value)`
+- `validators.password(value, options?)`
+- `validators.alphanumeric(value)`
+- `validators.numeric(value)`
+- `validators.zipCode(value, country?)`
+
+
+## Contributing
+
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Run tests with coverage
+npm run test:coverage
+
+# Lint code
+npm run lint
+
+# Format code
+npm run format
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Changelog
+
+### v1.0.0
+
+- Initial release
+- Basic validation patterns (email, phone, credit card, URL, password)
+- Schema validation support
+- Comprehensive test suite
+- CI/CD pipeline setup
+- Lightning-fast performance optimizations
+
+---
+
+Made with ⚡ by [Ramachandra Anirudh Vemulapalli](https://github.com/aniru-dh21)

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "snap-validate",
+  "version": "0.1.0",
+  "description": "Lightweight validation library for common patterns without heavy dependencies",
+  "main": "src/index.js",
+  "types": "types/index.d.ts",
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src tests",
+    "lint:fix": "eslint src tests --fix",
+    "format": "prettier --write \"src/**/*.js\" \"tests/**/*.js\"",
+    "prepare": "husky install",
+    "prepublishOnly": "npm test && npm run lint",
+    "build": "echo 'No build step required for this library'",
+    "example": "node examples/basic-usage.js"
+  },
+  "keywords": [
+    "validation",
+    "validator",
+    "lightweight",
+    "snap",
+    "quick",
+    "fast",
+    "email",
+    "phone",
+    "credit-card",
+    "url",
+    "password",
+    "forms",
+    "input-validation",
+    "schema-validation",
+    "pattern-matching"
+  ],
+  "author": "Ramachandra Anirudh Vemulapalli",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aniru-dh21/snap-validate.git"
+  },
+  "bugs": {
+    "url": "https://github.com/aniru-dh21/snap-validate/issues"
+  },
+  "homepage": "https://github.com/aniru-dh21/snap-validate#readme",
+  "devDependencies": {
+    "@babel/core": "^7.24.0",
+    "@babel/preset-env": "^7.24.0",
+    "babel-jest": "^29.7.0",
+    "eslint": "^8.57.1",
+    "husky": "^9.1.0",
+    "jest": "^29.7.0",
+    "lint-staged": "^15.2.0",
+    "prettier": "^3.2.0"
+  },
+  "files": [
+    "src/",
+    "types/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "collectCoverageFrom": [
+      "src/**/*.js",
+      "!src/**/*.test.js"
+    ],
+    "coverageThreshold": {
+      "global": {
+        "branches": 80,
+        "functions": 80,
+        "lines": 80,
+        "statements": 80
+      }
+    }
+  },
+  "lint-staged": {
+    "*.js": [
+      "eslint --fix",
+      "prettier --write"
+    ]
+  }
+}

package/src/index.js

@@ -0,0 +1,236 @@
+/**
+ * Snap Validate - Lightweight validator library
+ * @version 0.0.1
+ */
+
+// Core validation class
+class ValidationResult {
+  constructor(isValid, errors = []) {
+    this.isValid = isValid;
+    this.errors = errors;
+  }
+
+  addError(message) {
+    this.errors.push(message);
+    this.isValid = false;
+    return this;
+  }
+}
+
+// Base validator class
+class BaseValidator {
+  constructor(value) {
+    this.value = value;
+    this.rules = [];
+  }
+
+  required(message = 'This field is required') {
+    this.rules.push(() => {
+      if (this.value === null || this.value === undefined || this.value === '') {
+        return new ValidationResult(false, [message]);
+      }
+      return new ValidationResult(true);
+    });
+    return this;
+  }
+
+  min(length, message = `Minimum length is ${length}`) {
+    this.rules.push(() => {
+      if (this.value && this.value.length < length) {
+        return new ValidationResult(false, [message]);
+      }
+      return new ValidationResult(true);
+    });
+    return this;
+  }
+
+  max(length, message = `Maximum length is ${length}`) {
+    this.rules.push(() => {
+      if (this.value && this.value.length > length) {
+        return new ValidationResult(false, [message]);
+      }
+      return new ValidationResult(true);
+    });
+    return this;
+  }
+
+  pattern(regex, message = 'Invalid format') {
+    this.rules.push(() => {
+      if (this.value && !regex.test(this.value)) {
+        return new ValidationResult(false, [message]);
+      }
+      return new ValidationResult(true);
+    });
+    return this;
+  }
+
+  validate() {
+    const result = new ValidationResult(true);
+
+    for (const rule of this.rules) {
+      const ruleResult = rule();
+      if (!ruleResult.isValid) {
+        result.isValid = false;
+        result.errors.push(...ruleResult.errors);
+      }
+    }
+
+    return result;
+  }
+}
+
+// Predefined validators
+const validators = {
+  email: (value) => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return new BaseValidator(value)
+      .required('Email is required')
+      .pattern(emailRegex, 'Invalid email format');
+  },
+
+  phone: (value, format = 'us') => {
+    const phoneRegex = {
+      us: /^\+?1?[-.\s]?\(?([0-9]{3})\)?[-.\s]?([0-9]{3})[-.\s]?([0-9]{4})$/,
+      international: /^\+[1-9]\d{1,14}$/,
+      simple: /^\d{10,15}$/
+    };
+
+    return new BaseValidator(value)
+      .required('Phone number is required')
+      .pattern(phoneRegex[format] || phoneRegex.simple, 'Invalid phone number format');
+  },
+
+  creditCard: (value) => {
+    // Luhn algorithm check
+    const luhnCheck = (num) => {
+      let sum = 0;
+      let isEven = false;
+
+      for (let i = num.length - 1; i >= 0; i--) {
+        let digit = parseInt(num[i]);
+
+        if (isEven) {
+          digit *= 2;
+          if (digit > 9) digit -= 9;
+        }
+
+        sum += digit;
+        isEven = !isEven;
+      }
+
+      return sum % 10 === 0;
+    };
+
+    const validator = new BaseValidator(value)
+      .required('Credit card number is required')
+      .pattern(/^\d{13,19}$/, 'Credit card must be 13-19 digits');
+
+    validator.rules.push(() => {
+      if (value && !luhnCheck(value.replace(/\s/g, ''))) {
+        return new ValidationResult(false, ['Invalid credit card number']);
+      }
+      return new ValidationResult(true);
+    });
+
+    return validator;
+  },
+
+  url: (value) => {
+    const urlRegex = /^(https?|ftp):\/\/[^\s/$.?#].[^\s]*$/i;
+    return new BaseValidator(value)
+      .required('URL is required')
+      .pattern(urlRegex, 'Invalid URL format');
+  },
+
+  password: (value, options = {}) => {
+    const {
+      minLength = 8,
+      requireUppercase = true,
+      requireLowercase = true,
+      requireNumbers = true,
+      requireSpecialChars = false
+    } = options;
+
+    const validator = new BaseValidator(value)
+      .required('Password is required')
+      .min(minLength, `Password must be at least ${minLength} characters`);
+
+    if (requireUppercase) {
+      validator.pattern(/[A-Z]/, 'Password must contain at least one uppercase letter');
+    }
+    if (requireLowercase) {
+      validator.pattern(/[a-z]/, 'Password must contain at least one lowercase letter');
+    }
+    if (requireNumbers) {
+      validator.pattern(/\d/, 'Password must contain at least one number');
+    }
+    if (requireSpecialChars) {
+      validator.pattern(/[!@#$%^&*(),.?":{}|<>]/, 'Password must contain at least one special character');
+    }
+
+    return validator;
+  },
+
+  alphanumeric: (value) => {
+    return new BaseValidator(value)
+      .required('This field is required')
+      .pattern(/^[a-zA-Z0-9]+$/, 'Only letters and number are allowed');
+  },
+
+  numeric: (value) => {
+    return new BaseValidator(value)
+      .required('This field is required')
+      .pattern(/^\d+$/, 'Only numbers are allowed');
+  },
+
+  zipCode: (value, country = 'us') => {
+    const zipRegex = {
+      us: /^\d{5}(-\d{4})?$/,
+      ca: /^[A-Za-z]\d[A-Za-z][ -]?\d[A-Za-z]\d$/,
+      uk: /^[A-Z]{1,2}\d[A-Z\d]? ?\d[A-Z]{2}$/i
+    };
+
+    return new BaseValidator(value)
+      .required('Zip code is required')
+      .pattern(zipRegex[country] || zipRegex.us, 'Invalid zip code format');
+  }
+};
+
+// Main validation function
+const validate = (schema, data) => {
+  const results = {};
+  let isValid = true;
+
+  for (const [field, validator] of Object.entries(schema)) {
+    const fieldValue = data[field];
+    const result = typeof validator === 'function'
+      ? validator(fieldValue).validate()
+      : validator.validate();
+
+    results[field] = result;
+    if (!result.isValid) {
+      isValid = false;
+    }
+  }
+
+  return {
+    isValid,
+    errors: results,
+    getErrors: () => {
+      const errors = {};
+      for (const [field, result] of Object.entries(results)) {
+        if (!result.isValid) {
+          errors[field] = result.errors;
+        }
+      }
+      return errors;
+    }
+  };
+};
+
+module.exports = {
+  BaseValidator,
+  ValidationResult,
+  validators,
+  validate
+};

package/types/index.d.ts

@@ -0,0 +1,60 @@
+declare module 'mini-validator' {
+  export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    addError(message: string): ValidationResult;
+  }
+
+  export interface PasswordOptions {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumbers?: boolean;
+    requireSpecialChars?: boolean;
+  }
+
+  export type PhoneFormat = 'us' | 'international' | 'simple';
+  export type CountryCode = 'us' | 'ca' | 'uk';
+
+  export class BaseValidator {
+    constructor(value: any);
+    required(message?: string): BaseValidator;
+    min(length: number, message?: string): BaseValidator;
+    max(length: number, message?: string): BaseValidator;
+    pattern(regex: RegExp, message?: string): BaseValidator;
+    validate(): ValidationResult;
+  }
+
+  export class ValidationResult {
+    constructor(isValid: boolean, errors?: string[]);
+    isValid: boolean;
+    errors: string[];
+    addError(message: string): ValidationResult;
+  }
+
+  export interface Validators {
+    email(value: string): BaseValidator;
+    phone(value: string, format?: PhoneFormat): BaseValidator;
+    creditCard(value: string): BaseValidator;
+    url(value: string): BaseValidator;
+    password(value: string, options?: PasswordOptions): BaseValidator;
+    alphanumeric(value: string): BaseValidator;
+    numeric(value: string): BaseValidator;
+    zipCode(value: string, country?: CountryCode): BaseValidator;
+  }
+
+  export interface SchemaValidationResult {
+    isValid: boolean;
+    errors: { [field: string]: ValidationResult };
+    getErrors(): { [field: string]: string[] };
+  }
+
+  export type ValidationFunction = (value: any) => BaseValidator;
+  export type Schema = { [field: string]: ValidationFunction };
+
+  export const validators: Validators;
+  export function validate(
+    schema: Schema,
+    data: { [key: string]: any }
+  ): SchemaValidationResult;
+}