validatorcraft 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aman Sharma
+
+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,118 @@
+# validatorcraft
+
+A lightweight, zero-dependency JavaScript validation library for Node.js.
+
+## Features
+
+- **Zero Dependencies**: Lightweight and fast.
+- **Node.js Ready**: Works with Node >= 18.
+- **Pure Functions**: Returns only booleans, throws no unnecessary exceptions.
+- **Comprehensive**: Validate emails, phones, passwords, UUIDs, hex colors, and more.
+
+## Installation
+
+```bash
+npm install validatorcraft
+```
+
+## Usage
+
+```javascript
+const validator = require('validatorcraft');
+
+// Email Validation
+validator.isEmail('test@example.com'); // true
+
+// Phone Validation
+validator.isPhone('+1234567890'); // true
+
+// Password Validation
+validator.isStrongPassword('StrongP@ssw0rd'); // true
+
+// Hex Color
+validator.isHexColor('#ffffff'); // true
+
+// Length checks
+validator.betweenLength('hello', 3, 10); // true
+```
+
+## API Reference
+
+### `isEmail(email)`
+Validates proper email format.
+- **Returns**: `boolean`
+
+### `isPhone(phone)`
+Validates phone numbers, including international numbers beginning with `+`.
+- **Returns**: `boolean`
+
+### `isStrongPassword(password)`
+Validates passwords based on strong criteria:
+- Minimum 8 characters
+- At least one uppercase letter
+- At least one lowercase letter
+- At least one number
+- At least one special character
+- **Returns**: `boolean`
+
+### `isUsername(username)`
+Validates a username based on:
+- 3–20 characters long
+- Contains only letters, numbers, and underscores
+- **Returns**: `boolean`
+
+### `isURL(url)`
+Validates standard `http` and `https` URLs.
+- **Returns**: `boolean`
+
+### `isNumeric(value)`
+Returns true only if the string contains digits.
+- **Returns**: `boolean`
+
+### `isAlpha(value)`
+Returns true only if the string contains alphabetic characters.
+- **Returns**: `boolean`
+
+### `isAlphaNumeric(value)`
+Returns true only if the string contains alphanumeric characters.
+- **Returns**: `boolean`
+
+### `isEmpty(value)`
+Returns true for `""`, `null`, and `undefined`.
+- **Returns**: `boolean`
+
+### `minLength(str, len)`
+Checks if the string length is at least `len`.
+- **Returns**: `boolean`
+
+### `maxLength(str, len)`
+Checks if the string length is at most `len`.
+- **Returns**: `boolean`
+
+### `betweenLength(str, min, max)`
+Checks if the string length is between `min` and `max` (inclusive).
+- **Returns**: `boolean`
+
+### `isJSON(str)`
+Checks if a string is valid JSON.
+- **Returns**: `boolean`
+
+### `isUUID(str)`
+Checks if a string is a valid UUID v4.
+- **Returns**: `boolean`
+
+### `isHexColor(color)`
+Checks if a string is a valid hex color (e.g., `#fff`, `#000000`).
+- **Returns**: `boolean`
+
+### `isDate(date)`
+Checks if a string is a valid ISO date.
+- **Returns**: `boolean`
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License.

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "validatorcraft",
+  "version": "1.0.0",
+  "description": "A lightweight, dependency-free JavaScript validation library for Node.js.",
+  "main": "src/index.js",
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "test": "node --test tests/*.test.js"
+  },
+  "keywords": [
+    "validator",
+    "validation",
+    "validate",
+    "dependency-free",
+    "string",
+    "email",
+    "password",
+    "phone",
+    "url",
+    "uuid",
+    "json"
+  ],
+  "author": "Aman Sharma",
+  "license": "MIT",
+  "repository": {
+  "type": "git",
+  "url": "git+https://github.com/Amansharmacs1/validatorcraft.git"
+},
+"homepage": "https://github.com/Amansharmacs1/validatorcraft#readme",
+"bugs": {
+  "url": "https://github.com/Amansharmacs1/validatorcraft/issues"
+},
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/color.js

@@ -0,0 +1,13 @@
+/**
+ * Checks if a string is a valid hex color.
+ * Supports #RGB, #RGBA, #RRGGBB, #RRGGBBAA.
+ * @param {string} color - The string to check.
+ * @returns {boolean}
+ */
+function isHexColor(color) {
+  if (typeof color !== 'string') return false;
+  const regex = /^#([A-Fa-f0-9]{3,4}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$/;
+  return regex.test(color);
+}
+
+module.exports = { isHexColor };

package/src/date.js

@@ -0,0 +1,16 @@
+/**
+ * Checks if a string is a valid ISO date.
+ * @param {string} date - The string to check.
+ * @returns {boolean}
+ */
+function isDate(date) {
+  if (typeof date !== 'string') return false;
+  // Basic ISO format regex, e.g. YYYY-MM-DD or YYYY-MM-DDTHH:mm:ss.sssZ
+  const regex = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{1,3})?(Z|[+-]\d{2}:\d{2})?)?$/;
+  if (!regex.test(date)) return false;
+  
+  const parsedDate = new Date(date);
+  return !isNaN(parsedDate.getTime());
+}
+
+module.exports = { isDate };

package/src/email.js

@@ -0,0 +1,13 @@
+/**
+ * Validates a proper email format.
+ * @param {string} email - The email to validate.
+ * @returns {boolean} True if the email is valid, false otherwise.
+ */
+function isEmail(email) {
+  if (typeof email !== 'string') return false;
+  // A basic regex for email validation
+  const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return regex.test(email);
+}
+
+module.exports = { isEmail };

package/src/index.js

@@ -0,0 +1,30 @@
+const { isEmail } = require('./email');
+const { isPhone } = require('./phone');
+const { isStrongPassword } = require('./password');
+const { isUsername } = require('./username');
+const { isURL } = require('./url');
+const { isNumeric } = require('./number');
+const { isAlpha, isAlphaNumeric, isEmpty, minLength, maxLength, betweenLength } = require('./string');
+const { isJSON } = require('./json');
+const { isUUID } = require('./uuid');
+const { isHexColor } = require('./color');
+const { isDate } = require('./date');
+
+module.exports = {
+  isEmail,
+  isPhone,
+  isStrongPassword,
+  isUsername,
+  isURL,
+  isNumeric,
+  isAlpha,
+  isAlphaNumeric,
+  isEmpty,
+  minLength,
+  maxLength,
+  betweenLength,
+  isJSON,
+  isUUID,
+  isHexColor,
+  isDate
+};

package/src/json.js

@@ -0,0 +1,16 @@
+/**
+ * Checks if a string is valid JSON.
+ * @param {string} str - The string to check.
+ * @returns {boolean}
+ */
+function isJSON(str) {
+  if (typeof str !== 'string') return false;
+  try {
+    JSON.parse(str);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+module.exports = { isJSON };

package/src/number.js

@@ -0,0 +1,13 @@
+/**
+ * Returns true only if the string contains digits.
+ * @param {string} value - The value to check.
+ * @returns {boolean}
+ */
+function isNumeric(value) {
+  if (typeof value !== 'string') return false;
+  if (value.length === 0) return false;
+  const regex = /^\d+$/;
+  return regex.test(value);
+}
+
+module.exports = { isNumeric };

package/src/password.js

@@ -0,0 +1,19 @@
+/**
+ * Validates a strong password.
+ * Minimum 8 characters, at least one uppercase, one lowercase, one number, and one special character.
+ * @param {string} password - The password to validate.
+ * @returns {boolean} True if strong, false otherwise.
+ */
+function isStrongPassword(password) {
+  if (typeof password !== 'string') return false;
+  if (password.length < 8) return false;
+  
+  const hasUppercase = /[A-Z]/.test(password);
+  const hasLowercase = /[a-z]/.test(password);
+  const hasNumber = /[0-9]/.test(password);
+  const hasSpecial = /[^A-Za-z0-9]/.test(password);
+  
+  return hasUppercase && hasLowercase && hasNumber && hasSpecial;
+}
+
+module.exports = { isStrongPassword };

package/src/phone.js

@@ -0,0 +1,13 @@
+/**
+ * Validates international phone numbers, including those beginning with +.
+ * @param {string} phone - The phone number to validate.
+ * @returns {boolean} True if valid, false otherwise.
+ */
+function isPhone(phone) {
+  if (typeof phone !== 'string') return false;
+  // Allows optional +, followed by 7 to 15 digits
+  const regex = /^\+?[0-9]{7,15}$/;
+  return regex.test(phone.replace(/[\s\-\(\)]/g, ''));
+}
+
+module.exports = { isPhone };

package/src/string.js

@@ -0,0 +1,73 @@
+/**
+ * Returns true if the string contains only alphabetic characters.
+ * @param {string} value - The value to check.
+ * @returns {boolean}
+ */
+function isAlpha(value) {
+  if (typeof value !== 'string') return false;
+  if (value.length === 0) return false;
+  return /^[a-zA-Z]+$/.test(value);
+}
+
+/**
+ * Returns true if the string contains only alphanumeric characters.
+ * @param {string} value - The value to check.
+ * @returns {boolean}
+ */
+function isAlphaNumeric(value) {
+  if (typeof value !== 'string') return false;
+  if (value.length === 0) return false;
+  return /^[a-zA-Z0-9]+$/.test(value);
+}
+
+/**
+ * Returns true for "", null, and undefined.
+ * @param {any} value - The value to check.
+ * @returns {boolean}
+ */
+function isEmpty(value) {
+  return value === "" || value === null || value === undefined;
+}
+
+/**
+ * Checks if string length is at least `len`.
+ * @param {string} str 
+ * @param {number} len 
+ * @returns {boolean}
+ */
+function minLength(str, len) {
+  if (typeof str !== 'string' || typeof len !== 'number') return false;
+  return str.length >= len;
+}
+
+/**
+ * Checks if string length is at most `len`.
+ * @param {string} str 
+ * @param {number} len 
+ * @returns {boolean}
+ */
+function maxLength(str, len) {
+  if (typeof str !== 'string' || typeof len !== 'number') return false;
+  return str.length <= len;
+}
+
+/**
+ * Checks if string length is between `min` and `max` (inclusive).
+ * @param {string} str 
+ * @param {number} min 
+ * @param {number} max 
+ * @returns {boolean}
+ */
+function betweenLength(str, min, max) {
+  if (typeof str !== 'string' || typeof min !== 'number' || typeof max !== 'number') return false;
+  return str.length >= min && str.length <= max;
+}
+
+module.exports = {
+  isAlpha,
+  isAlphaNumeric,
+  isEmpty,
+  minLength,
+  maxLength,
+  betweenLength
+};

package/src/url.js

@@ -0,0 +1,16 @@
+/**
+ * Validates http and https URLs.
+ * @param {string} url - The URL to validate.
+ * @returns {boolean} True if valid, false otherwise.
+ */
+function isURL(url) {
+  if (typeof url !== 'string') return false;
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+  } catch (e) {
+    return false;
+  }
+}
+
+module.exports = { isURL };

package/src/username.js

@@ -0,0 +1,12 @@
+/**
+ * Validates a username (3-20 chars, letters, numbers, underscore only).
+ * @param {string} username - The username to validate.
+ * @returns {boolean} True if valid, false otherwise.
+ */
+function isUsername(username) {
+  if (typeof username !== 'string') return false;
+  const regex = /^[a-zA-Z0-9_]{3,20}$/;
+  return regex.test(username);
+}
+
+module.exports = { isUsername };

package/src/uuid.js

@@ -0,0 +1,12 @@
+/**
+ * Checks if a string is a valid UUID v4.
+ * @param {string} str - The string to check.
+ * @returns {boolean}
+ */
+function isUUID(str) {
+  if (typeof str !== 'string') return false;
+  const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return regex.test(str);
+}
+
+module.exports = { isUUID };