stringzy 1.1.2 → 2.0.0

package/README.md

@@ -5,15 +5,16 @@
 ![License](https://img.shields.io/npm/l/stringzy)
 ![Bundle Size](https://img.shields.io/bundlephobia/min/stringzy)
 
-**A lightweight, zero-dependency NPM Package for elegant string manipulations. It provides a range of text utilities for JavaScript and Node.js applications.**
+**A lightweight, zero-dependency NPM Package for elegant string manipulations. It provides a comprehensive range of text utilities for JavaScript and Node.js applications including transformations, validations, analysis, and formatting.**
 
 ## ✨ Features
 
-- 💪 **Powerful** - Transform strings with minimal code
+- 💪 **Powerful** - Transform, validate, analyze, and format strings with minimal code
 - 🪶 **Lightweight** - Zero dependencies, tiny footprint
-- 🧩 **Modular** - Import only what you need
+- 🧩 **Modular** - Import only what you need with organized namespaces
 - 🚀 **Fast** - Optimized for performance
 - ✅ **Tested** - Reliable and robust
+- 🎯 **Comprehensive** - 4 specialized modules for all string needs
 
 ## 📦 Installation
 
@@ -32,18 +33,56 @@ pnpm add stringzy
 
 ```javascript
 // Import the entire library
-import * as stringzy from 'stringzy';
+import stringzy from 'stringzy';
 
 // Or import specific functions
-import { truncateText, toSlug } from 'stringzy';
+import { toUpperCase, isEmail, wordCount, formatPhone } from 'stringzy';
+
+// Or import by namespace
+import { transform, validate, analyze, format } from 'stringzy';
 
 // Transform your strings
 const slug = stringzy.toSlug('Hello World!'); // 'hello-world'
+const isValid = stringzy.validate.isEmail('user@example.com'); // true
+const count = stringzy.analyze.wordCount('Hello world'); // 2
 ```
 
+## 📋 Table of Contents
+
+###  Transformations
+- [truncateText](#truncatetext) - Truncates text to a specified maximum length
+- [toSlug](#toslug) - Converts a string to a URL-friendly slug
+- [capitalizeWords](#capitalizewords) - Capitalizes the first letter of each word
+- [removeSpecialChars](#removespecialchars) - Removes special characters from a string
+- [camelCase](#camelCase) - Converts the given string to Camel Case
+- [pascaslCase](#pascalCase) - Converts the given string to Pascal Case
+- [snakeCase](#snakeCase) - Converts the given string to Snake Case   
+- [kebabCase](#kebabCase) - Converts the given string to Kebab Case
+- [titleCase](#titleCase) - Converts the given string to Title Case
+- [constantCase](#constantCase) - Converts the given string to Constant Case
+
+###  Validations
+- [isURL](#isurl) - Checks if a string is a valid URL
+- [isEmail](#isemail) - Checks if a string is a valid email address
+- [isEmpty](#isempty) - Checks if a string is empty or contains only whitespace
+
+###  Analysis
+- [wordCount](#wordcount) - Counts the number of words in a string
+- [characterCount](#charactercount) - Counts the number of characters in a string
+- [characterFrequency](#characterfrequency) - Analyzes character frequency in a string
+
+###  Formatting
+- [capitalize](#capitalize) - Capitalizes the first letter of each word
+- [formatNumber](#formatnumber) - Formats a number string with thousand separators
+- [formatPhone](#formatphone) - Formats a phone number string to standard format
+
 ## 📋 API Reference
 
-### `truncateText(text, maxLength, suffix = '...')`
+### 🔄 Transformations
+
+Functions for transforming and manipulating strings.
+
+#### <a id="truncatetext"></a>`truncateText(text, maxLength, suffix = '...')`
 
 Truncates text to a specified maximum length, adding a suffix if truncated.
 
@@ -66,7 +105,7 @@ truncateText('Short', 10);
 | maxLength | number | required | Maximum length of the output string (excluding suffix) |
 | suffix | string | '...' | String to append if truncation occurs |
 
-### `toSlug(text)`
+#### <a id="toslug"></a>`toSlug(text)`
 
 Converts a string to a URL-friendly slug.
 
@@ -87,7 +126,7 @@ toSlug('Special $#@! characters');
 |-----------|------|---------|-------------|
 | text | string | required | The input string to convert to a slug |
 
-### `capitalizeWords(text)`
+#### <a id="capitalizewords"></a>`capitalizeWords(text)`
 
 Capitalizes the first letter of each word in a string.
 
@@ -108,7 +147,7 @@ capitalizeWords('already Capitalized');
 |-----------|------|---------|-------------|
 | text | string | required | The input string to capitalize |
 
-### `removeSpecialChars(text, replacement = '')`
+#### <a id="removespecialchars"></a>`removeSpecialChars(text, replacement = '')`
 
 Removes special characters from a string, optionally replacing them.
 
@@ -130,50 +169,368 @@ removeSpecialChars('Phone: (123) 456-7890', '-');
 | text | string | required | The input string to process |
 | replacement | string | '' | String to replace special characters with |
 
+#### <a id="camelCase"></a>`camelCase(text)`
+
+Converts the given string to Camel Case.
+
+```javascript
+import { camelCase } from 'stringzy';
+
+camelCase('hello world'); // 'helloWorld'
+camelCase('this is a test'); // 'thisIsATest' 
+``` 
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| text | string | required | The input string to convert to Camel Case |
+
+
+#### <a id="pascalCase"></a>`pascalCase(text)`
+Converts the given string to Pascal Case.
+
+```javascript
+import { pascalCase } from 'stringzy';
+
+
+pascalCase('hello world'); // 'HelloWorld'
+pascalCase('this is a test'); // 'ThisIsATest'
+```
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| text | string | required | The input string to convert to Pascal Case |
+
+#### <a id="snakeCase"></a>`snakeCase(text)`
+
+Converts the given string to Snake Case.
+
+```javascript 
+import { snakeCase } from 'stringzy';
+snakeCase('hello world'); // 'hello_world'
+snakeCase('this is a test'); // 'this_is_a_test'
+```
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| text | string | required | The input string to convert to Snake Case |
+
+
+
+
+#### <a id="kebabCase"></a>`kebabCase(text)`
+
+Converts the given string to Kebab Case.
+
+```javascript
+import { kebabCase } from 'stringzy';
+
+
+kebabCase('hello world'); // 'hello-world'
+kebabCase('this is a test'); // 'this-is-a-test'
+``` 
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| text | string | required | The input string to convert to Kebab Case |
+
+
+
+#### <a id="titleCase"></a>`titleCase(text)`
+
+Converts the given string to Title Case.
+
+```javascript
+import { titleCase } from 'stringzy';
+
+
+titleCase('hello world'); // 'Hello World'
+titleCase('this is a test'); // 'This Is A Test'
+```
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| text | string | required | The input string to convert to Title Case |
+
+#### <a id="constantCase"></a>`constantCase(text)`
+Converts the given string to Constant Case.
+
+```javascript
+import { constantCase } from 'stringzy';
+
+
+constantCase('hello world'); // 'HELLO_WORLD'
+constantCase('this is a test'); // 'THIS_IS_A_TEST'
+
+```
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| text | string | required | The input string to convert to Constant Case |
+
+---
+
+### ✅ Validations
+
+Functions for validating string formats and content.
+
+#### <a id="isurl"></a>`isURL(text)`
+
+Checks if a string is a valid URL.
+
+```javascript
+isURL('https://example.com'); // true
+isURL('not-a-url'); // false
+```
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| text | string | required | The input string to validate as URL |
+
+#### <a id="isemail"></a>`isEmail(text)`
+
+Checks if a string is a valid email address.
+
+```javascript
+isEmail('user@example.com'); // true
+isEmail('invalid-email'); // false
+```
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| text | string | required | The input string to validate as email |
+
+#### <a id="isempty"></a>`isEmpty(text)`
+
+Checks if a string is empty or contains only whitespace.
+
+```javascript
+isEmpty('   '); // true
+isEmpty('hello'); // false
+```
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| text | string | required | The input string to check for emptiness |
+
+---
+
+
+### 📊 Analysis
+
+Functions for analyzing string content and structure.
+
+#### <a id="wordcount"></a>`wordCount(text)`
+
+Counts the number of words in a string.
+
+```javascript
+wordCount('Hello world'); // 2
+wordCount(''); // 0
+```
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| text | string | required | The input string to count words in |
+
+#### <a id="charactercount"></a>`characterCount(text)`
+
+Counts the number of characters in a string.
+
+```javascript
+characterCount('Hello'); // 5
+```
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| text | string | required | The input string to count characters in |
+
+#### <a id="characterfrequency"></a>`characterFrequency(text)`
+
+Analyzes character frequency in a string (excluding spaces).
+
+```javascript
+characterFrequency('hello'); // { h: 1, e: 1, l: 2, o: 1 }
+```
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| text | string | required | The input string to analyze character frequency |
+
+---
+
+### 🎨 Formatting
+
+Functions for formatting strings into specific patterns.
+
+#### <a id="capitalize"></a>`capitalize(text)`
+
+Capitalizes the first letter of each word.
+
+```javascript
+capitalize('hello world'); // 'Hello World'
+capitalize('javaScript programming'); // 'Javascript Programming'
+```
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| text | string | required | The input string to capitalize |
+
+#### <a id="formatnumber"></a>`formatNumber(number, separator = ',')`
+
+Formats a number string with thousand separators.
+
+```javascript
+formatNumber('1234567'); // '1,234,567'
+formatNumber('1234567', '.'); // '1.234.567'
+```
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| number | string\|number | required | The number to format |
+| separator | string | ',' | The separator to use for thousands |
+
+#### <a id="formatphone"></a>`formatPhone(phone, format = 'us')`
+
+Formats a phone number string to standard format.
+
+```javascript
+formatPhone('1234567890'); // '(123) 456-7890'
+formatPhone('11234567890', 'international'); // '+1 (123) 456-7890'
+```
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| phone | string | required | The phone number string to format |
+| format | string | 'us' | Format type: 'us' or 'international' |
+
+## 🔧 Usage Patterns
+
+### Individual Function Imports
+```javascript
+import { isEmail, wordCount, capitalize } from 'stringzy';
+
+const email = 'user@example.com';
+if (isEmail(email)) {
+  console.log('Valid email!');
+}
+```
+
+### Namespace Imports
+```javascript
+import { validate, analyze, format } from 'stringzy';
+
+// Organized by functionality
+const emailValid = validate.isEmail('test@example.com');
+const words = analyze.wordCount('Hello world');
+const formatted = format.capitalize('hello world');
+```
+
+### Default Import (All Functions)
+```javascript
+import stringzy from 'stringzy';
+
+// Access any function
+stringzy.toUpperCase('hello');
+stringzy.validate.isEmail('test@example.com');
+stringzy.analyze.wordCount('Hello world');
+stringzy.format.capitalize('hello world');
+```
+
 ## 🛠️ Usage Examples
 
 ### In a React component
 
 ```jsx
 import React from 'react';
-import { truncateText, capitalizeWords } from 'stringzy';
+import { truncate, capitalize, wordCount, isEmpty } from 'stringzy';
 
 function ArticlePreview({ title, content }) {
+  const displayTitle = isEmpty(title) ? 'Untitled' : capitalize(title);
+  const previewText = truncate(content, 150);
+  const readingTime = Math.ceil(wordCount(content) / 200);
+
   return (
     <div className="article-preview">
-      <h2>{capitalizeWords(title)}</h2>
-      <p>{truncateText(content, 150)}</p>
+      <h2>{displayTitle}</h2>
+      <p>{previewText}</p>
+      <small>{readingTime} min read</small>
     </div>
   );
 }
 ```
 
-### In a Node.js application
+### Form Validation
 
 ```javascript
-const { toSlug } = require('stringzy');
+import { validate } from 'stringzy';
+
+function validateForm(formData) {
+  const errors = {};
+  
+  if (!validate.isEmail(formData.email)) {
+    errors.email = 'Please enter a valid email address';
+  }
+  
+  if (!validate.isURL(formData.website)) {
+    errors.website = 'Please enter a valid URL';
+  }
+  
+  if (validate.isEmpty(formData.name)) {
+    errors.name = 'Name is required';
+  }
+  
+  return errors;
+}
+```
+
+### Content Analysis Dashboard
 
-function createPermalink(title) {
-  const timestamp = Date.now();
-  const slug = toSlug(title);
-  return `${timestamp}-${slug}`;
+```javascript
+import { analyze } from 'stringzy';
+
+function getContentStats(text) {
+  return {
+    words: analyze.wordCount(text),
+    characters: analyze.characterCount(text),
+    frequency: analyze.characterFrequency(text),
+    readingTime: Math.ceil(analyze.wordCount(text) / 200)
+  };
 }
+```
+
+### Data Formatting
 
-const permalink = createPermalink('New Blog Post Title!');
-// Returns something like: '1620000000000-new-blog-post-title'
+```javascript
+import { format } from 'stringzy';
+
+function formatUserData(userData) {
+  return {
+    name: format.capitalize(userData.name),
+    phone: format.formatPhone(userData.phone),
+    revenue: format.formatNumber(userData.revenue)
+  };
+}
 ```
 
 ## 🔄 TypeScript Support
 
-The package includes TypeScript type definitions.
+The package includes TypeScript type definitions for all functions.
 
 ```typescript
-import { truncateText } from 'stringzy';
+import { validate, analyze, format } from 'stringzy';
 
 // TypeScript will provide proper type checking
-const truncated: string = truncateText('Hello, world!', 5);
+const isValid: boolean = validate.isEmail('test@example.com');
+const count: number = analyze.wordCount('Hello world');
+const formatted: string = format.capitalize('hello world');
 ```
 
+## 🏗️ Architecture
+
+stringzy is organized into four specialized modules:
+
+- **`transformations.js`** - Core string transformations
+- **`validations.js`** - String validation utilities  
+- **`analysis.js`** - String analysis and metrics
+- **`formatting.js`** - String formatting functions
+
+Each module can be imported individually or accessed through the main entry point.
+
 ## 🤝 Contributing
 
 Contributions are welcome! Please feel free to submit a Pull Request.
@@ -191,7 +548,7 @@ This project is licensed under the MIT License - see the LICENSE file for detail
 ## 🙏 Acknowledgments
 
 - Thank you to all contributors and users of this package!
-- Inspired by the need for simple yet powerful string manipulation utilities.
+- Inspired by the need for comprehensive yet simple string manipulation utilities.
 
 ---
 

package/analysis.js

@@ -0,0 +1,21 @@
+
+export function wordCount(str) {
+  if (!str.trim()) return 0;
+  return str.trim().split(/\s+/).length;
+}
+
+
+export function characterCount(str) {
+    
+  return str.length;
+}
+
+export function characterFrequency(str) {
+  const frequency = {};
+  for (const char of str.toLowerCase()) {
+    if (char !== ' ') { // Exclude spaces for cleaner analysis
+      frequency[char] = (frequency[char] || 0) + 1;
+    }
+  }
+  return frequency;
+}

package/changelog.txt

@@ -0,0 +1,74 @@
+CHANGELOG
+
+All notable changes to the `stringzy` package will be documented in this file.
+
+=============================================================================
+Version 2.0.0 - 2025-05-22
+-----------------------------------------------------------------------------
+
+ADDED:
+- Added a dynamic list of APIs in README
+- Divided the package into 4 modules-transformations, validations, formatting and analysis
+- Added many new APIs 
+  - `camelCase`: Converts a string to camel case
+  - `kebabCase`: Converts a string to kebab case
+  - `snakeCase`: Converts a string to snake case
+  - `titleCase`: Converts a string to title case
+  - `constantCase`: Converts a string to constant case
+  - `pascalCase`: Converts a string to pascal case
+  - `isURL`: Validates if a string is a valid URL
+  - `isEmail`: Validates if a string is a valid email address
+  - `isEmpty`: Checks if a string is empty or contains only whitespace
+  - `wordCount`: Counts the number of words in a string
+  - `characterCount`: Counts the number of characters in a string
+  - `characterFrequency`: Calculates the frequency of each character in a string
+  - `capitalize`: Capitalizes the entire string
+  - `formatNumber`: Formats a number with commas as thousands separators
+  - `formatPhone`: Formats a phone number to a standard format
+
+=============================================================================
+
+Version 1.1.2 - 2025-05-15
+-----------------------------------------------------------------------------
+
+ADDED:
+- Improved documentation with comprehensive README
+- Enhanced examples for all utility functions
+
+FIXED:
+- Resolved documentation rendering issues on npm website
+
+=============================================================================
+
+Version 1.1.1 - 2025-05-15
+-----------------------------------------------------------------------------
+
+CHANGED:
+- Updated package metadata
+
+FIXED:
+- Minor bug fixes in string handling edge cases
+
+=============================================================================
+
+Version 1.1.0 - 2025-05-15
+-----------------------------------------------------------------------------
+
+ADDED:
+- Added extensive API documentation
+
+CHANGED:
+- Improved performance for `toSlug` function
+- Enhanced error handling across all utility functions
+
+=============================================================================
+
+Version 1.0.0 - 2025-05-14
+-----------------------------------------------------------------------------
+
+ADDED:
+- Initial release with four core utility functions:
+  - `truncateText`: Truncates text to a specified length with optional suffix
+  - `toSlug`: Converts text to URL-friendly slug format
+  - `capitalizeWords`: Capitalizes the first letter of each word
+  - `removeSpecialChars`: Removes special characters from text with optional replacement

package/formatting.js

@@ -0,0 +1,37 @@
+
+export function capitalize(str) {
+  return str
+    .split(' ')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join(' ');
+}
+
+
+export function formatNumber(num, separator = ',') {
+  const numStr = num.toString();
+  return numStr.replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+}
+
+
+export function formatPhone(phone, format = 'us') {
+  const digits = phone.replace(/\D/g, '');
+  
+  if (format === 'us' && digits.length === 10) {
+    return `(${digits.slice(0, 3)}) ${digits.slice(3, 6)}-${digits.slice(6)}`;
+  } else if (format === 'international' && digits.length >= 10) {
+    const countryCode = digits.slice(0, -10);
+    const areaCode = digits.slice(-10, -7);
+    const firstPart = digits.slice(-7, -4);
+    const lastPart = digits.slice(-4);
+    return `+${countryCode} (${areaCode}) ${firstPart}-${lastPart}`;
+  }
+  else if (format === 'indian') {
+    if (digits.length === 10) {
+      return `+91-${digits.slice(0, 5)}-${digits.slice(5)}`;
+    } else if (digits.length === 12 && digits.startsWith('91')) {
+      return `+91-${digits.slice(2, 7)}-${digits.slice(7)}`;
+    }
+  }
+  
+  return phone;
+}

package/index.js

@@ -1,49 +1,67 @@
-export function truncateText(text, maxLength, suffix = '...') {
-    if (typeof text !== 'string') {
-        throw new Error("Input text must be a string.");
-    }
-    if (typeof maxLength !== 'number' || maxLength < 0) {
-        throw new Error("maxLength must be a non-negative number.");
-    }
-    if (typeof suffix !== 'string') {
-        throw new Error("Suffix must be a string.");
-    }
-
-    if (text.length <= maxLength) {
-        return text;
-    }
-
-    const adjustedLength = maxLength - suffix.length;
-    return text.slice(0, adjustedLength > 0 ? adjustedLength : 0) + suffix;
-}
-  
+/**
+ * index.js
+ * Main entry point for the srtingzy package
+ * 
+ * This file serves as the public API for the entire library,
+ * organizing and exporting all functionality in a structured way.
+ * 
+ * @module stringzy
+ * @author Samarth Ruia
+ * @version 2.0.0
+ */
 
-  export function toSlug(text) {
-    if (typeof text !== "string") {
-      throw new Error("Invalid argument. Expected a string.");
-    }
-    return text
-      .toLowerCase()
-      .trim()
-      .replace(/[\s]+/g, "-")
-      .replace(/[^\w-]+/g, "");
-  }
-  
+import * as transformations from './transformations.js';
+import * as validations from './validations.js';
+import * as analysis from './analysis.js';
+import * as formatting from './formatting.js';
+
+
+export const {
+  truncateText,
+  toSlug,
+  capitalizeWords,
+  removeSpecialChars,
+  camelCase,
+  pascalCase,
+  snakeCase,
+  kebabCase,
+  titleCase,
+  constantCase,
+} = transformations;
+
+export const {
+  isURL,
+  isEmail,
+  isEmpty
+} = validations;
 
-  export function capitalizeWords(text) {
-    if (typeof text !== "string") {
-      throw new Error("Invalid argument. Expected a string.");
-    }
-    return text.replace(/\b\w/g, (char) => char.toUpperCase());
-  }
+export const {
+  wordCount,
+  characterCount,
+  characterFrequency
+} = analysis;
+
+export const {
+  capitalize,
+  formatNumber,
+  formatPhone
+} = formatting;
+
+export const transform = transformations;
+export const validate = validations;
+export const analyze = analysis;
+export const format = formatting;
+
+
+export default {
+  ...transformations, 
+  ...validations,
+  ...analysis,
+  ...formatting,
   
-  export function removeSpecialChars(text, replacement = '') {
-    if (typeof text !== "string") {
-        throw new Error("Invalid argument. Expected a string.");
-    }
-    if (typeof replacement !== "string") {
-        throw new Error("Replacement must be a string.");
-    }
-    return text.replace(/[^\w\s]/gi, replacement);
-}
-  
+  transform: transformations,
+  validate: validations,
+  analyze: analysis,
+  format: formatting,
+
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stringzy",
-  "version": "1.1.2",
+  "version": "2.0.0",
   "main": "index.js",
   "type": "module",
   "scripts": {
@@ -14,12 +14,17 @@
     "string",
     "string-manipulation",
     "text-formatting",
-    "cli",
+    "dev-tools",
     "text-utils",
     "stringify",
+    "string-tools",
+    "string-manipulation-library",
+    "utility-library",
+    "ReactJS",
     "stringer",
     "string",
     "text",
+    "best",
     "manipulation",
     "utilities",
     "javascript",

package/transformations.js

@@ -0,0 +1,128 @@
+export function truncateText(text, maxLength, suffix = '...') {
+    if (typeof text !== 'string') {
+        throw new Error("Input text must be a string.");
+    }
+    if (typeof maxLength !== 'number' || maxLength < 0) {
+        throw new Error("maxLength must be a non-negative number.");
+    }
+    if (typeof suffix !== 'string') {
+        throw new Error("Suffix must be a string.");
+    }
+
+    if (text.length <= maxLength) {
+        return text;
+    }
+
+    const adjustedLength = maxLength - suffix.length;
+    return text.slice(0, adjustedLength > 0 ? adjustedLength : 0) + suffix;
+}
+  
+
+  export function toSlug(text) {
+    if (typeof text !== "string") {
+      throw new Error("Invalid argument. Expected a string.");
+    }
+    return text
+      .toLowerCase()
+      .trim()
+      .replace(/[\s]+/g, "-")
+      .replace(/[^\w-]+/g, "");
+  }
+  
+
+  export function capitalizeWords(text) {
+    if (typeof text !== "string") {
+      throw new Error("Invalid argument. Expected a string.");
+    }
+    return text.replace(/\b\w/g, (char) => char.toUpperCase());
+  }
+  
+  export function removeSpecialChars(text, replacement = '') {
+    if (typeof text !== "string") {
+        throw new Error("Invalid argument. Expected a string.");
+    }
+    if (typeof replacement !== "string") {
+        throw new Error("Replacement must be a string.");
+    }
+    return text.replace(/[^\w\s]/gi, replacement);
+}
+  
+
+export function camelCase(text) {
+  if (text == null) return '';
+  
+  return text
+    .trim()
+    .toLowerCase()
+    .replace(/[^\w\s]/g, ' ')
+    .replace(/_/g, ' ')
+    .replace(/\s+/g, ' ')
+    .replace(/\s(.)/g, (_, character) => character.toUpperCase())
+    .replace(/^(.)/, (_, character) => character.toLowerCase());
+}
+
+
+export function pascalCase(text) {
+  if (text == null) return '';
+  
+  return text
+    .trim()
+    .toLowerCase()
+    .replace(/[^\w\s]/g, ' ')
+    .replace(/_/g, ' ')
+    .replace(/\s+/g, ' ')
+    .replace(/(^|\s)(.)/g, (_, prefix, character) => character.toUpperCase())
+    .replace(/\s/g, '');
+}
+
+
+export function snakeCase(text) {
+  if (text == null) return '';
+  
+  return text
+    .trim()
+    .replace(/[\s-]+/g, '_')
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    .replace(/[^\w_]/g, '_')
+    .toLowerCase()
+    .replace(/_+/g, '_')
+    .replace(/^_+|_+$/g, '');
+}
+
+
+export function kebabCase(text) {
+  if (text == null) return '';
+  
+  return text
+    .trim()
+    .replace(/[\s_]+/g, '-')
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/[^\w-]/g, '-')
+    .toLowerCase()
+    .replace(/-+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+export function titleCase(text) {
+  if (text == null) return '';
+  
+  return text
+    .trim()
+    .toLowerCase()
+    .replace(/([^\w\s]|_)/g, ' ')
+    .replace(/\s+/g, ' ')
+    .replace(/(^|\s)(.)/g, (_, prefix, character) => prefix + character.toUpperCase())
+    .replace(/\s/g, ' ');
+}
+export function constantCase(text) {
+  if (text == null) return '';
+  
+  return text
+    .trim()
+    .replace(/[\s-]+/g, '_')
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    .replace(/[^\w_]/g, '_')
+    .toUpperCase()
+    .replace(/_+/g, '_')
+    .replace(/^_+|_+$/g, '');
+}

package/validations.js

@@ -0,0 +1,19 @@
+export function isURL(str) {
+  try {
+    new URL(str);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+
+export function isEmail(str) {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(str);
+}
+
+
+export function isEmpty(str) {
+  return str.trim().length === 0;
+}