stringzy 4.0.0 → 4.1.0

package/dist/transformations/stringCombinations.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Generates all unique combinations (subsequences) of a given string,
+ * including the empty string.
+ *
+ * Handles duplicate characters by ensuring only unique combinations are returned.
+ * The order of combinations in the output array is not guaranteed.
+ *
+ * @param {string} str - The input string to generate combinations from.
+ * @returns {string[]} An array containing all unique combinations of the string.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * stringCombinations("ab");
+ * // ["", "a", "b", "ab"]
+ *
+ * @example
+ * stringCombinations("abc");
+ * // ["", "a", "b", "c", "ab", "ac", "bc", "abc"]
+ *
+ * @example
+ * stringCombinations("aab");
+ * // ["", "a", "b", "aa", "ab", "aab"]
+ *
+ * @example
+ * stringCombinations("");
+ * // [""]
+ */
+export declare function stringCombinations(str: string): string[];

package/dist/transformations/stringCombinations.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringCombinations = stringCombinations;
+/**
+ * Generates all unique combinations (subsequences) of a given string,
+ * including the empty string.
+ *
+ * Handles duplicate characters by ensuring only unique combinations are returned.
+ * The order of combinations in the output array is not guaranteed.
+ *
+ * @param {string} str - The input string to generate combinations from.
+ * @returns {string[]} An array containing all unique combinations of the string.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * stringCombinations("ab");
+ * // ["", "a", "b", "ab"]
+ *
+ * @example
+ * stringCombinations("abc");
+ * // ["", "a", "b", "c", "ab", "ac", "bc", "abc"]
+ *
+ * @example
+ * stringCombinations("aab");
+ * // ["", "a", "b", "aa", "ab", "aab"]
+ *
+ * @example
+ * stringCombinations("");
+ * // [""]
+ */
+function stringCombinations(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    const results = new Set();
+    function backtrack(start, path) {
+        results.add(path);
+        for (let i = start; i < str.length; i++) {
+            backtrack(i + 1, path + str[i]);
+        }
+    }
+    backtrack(0, '');
+    return Array.from(results);
+}

package/dist/transformations/stringPermutations.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Generates all unique permutations of a given string.
+ *
+ * Handles repeated characters by ensuring only unique permutations
+ * are included in the result. The order of permutations is not guaranteed.
+ *
+ * @param {string} str - The input string to generate permutations for.
+ * @returns {string[]} An array of unique permutations of the input string.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * stringPermutations("ab");
+ * // ["ab", "ba"]
+ *
+ * @example
+ * stringPermutations("abc");
+ * // ["abc", "acb", "bac", "bca", "cab", "cba"]
+ *
+ * @example
+ * stringPermutations("aab");
+ * // ["aab", "aba", "baa"]
+ *
+ * @example
+ * stringPermutations("");
+ * // [""]
+ *
+ * @example
+ * stringPermutations("a");
+ * // ["a"]
+ */
+export declare function stringPermutations(str: string): string[];

package/dist/transformations/stringPermutations.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringPermutations = stringPermutations;
+/**
+ * Generates all unique permutations of a given string.
+ *
+ * Handles repeated characters by ensuring only unique permutations
+ * are included in the result. The order of permutations is not guaranteed.
+ *
+ * @param {string} str - The input string to generate permutations for.
+ * @returns {string[]} An array of unique permutations of the input string.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * stringPermutations("ab");
+ * // ["ab", "ba"]
+ *
+ * @example
+ * stringPermutations("abc");
+ * // ["abc", "acb", "bac", "bca", "cab", "cba"]
+ *
+ * @example
+ * stringPermutations("aab");
+ * // ["aab", "aba", "baa"]
+ *
+ * @example
+ * stringPermutations("");
+ * // [""]
+ *
+ * @example
+ * stringPermutations("a");
+ * // ["a"]
+ */
+function stringPermutations(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    if (str.length === 0)
+        return [''];
+    const results = new Set();
+    const permute = (prefix, remaining) => {
+        if (remaining.length === 0) {
+            results.add(prefix);
+        }
+        else {
+            for (let i = 0; i < remaining.length; i++) {
+                permute(prefix + remaining[i], remaining.slice(0, i) + remaining.slice(i + 1));
+            }
+        }
+    };
+    permute('', str);
+    return Array.from(results);
+}

package/dist/validations/index.d.ts

@@ -7,6 +7,13 @@ export { isURL } from './isURL';
 export { isIPv4 } from './isIPv4';
 export { isHexColor } from './isHexColor';
 export { isPalindrome } from './isPalindrome';
+export { isLowerCase } from './isLowerCase';
+export { isUpperCase } from './isUpperCase';
+export { isAlphabetic } from './isAlphabetic';
+export { isAlphaNumeric } from './isAlphaNumeric';
+export { isAnagram } from './isAnagram';
+export { isPanagram } from './isPanagram';
+export { isMacAddress } from './isMacAddress';
 import { isCoordinates } from './isCoordinates';
 import { isDate } from './isDate';
 import { isEmail } from './isEmail';
@@ -16,6 +23,13 @@ import { isURL } from './isURL';
 import { isIPv4 } from './isIPv4';
 import { isHexColor } from './isHexColor';
 import { isPalindrome } from './isPalindrome';
+import { isLowerCase } from './isLowerCase';
+import { isUpperCase } from './isUpperCase';
+import { isAlphabetic } from './isAlphabetic';
+import { isAlphaNumeric } from './isAlphaNumeric';
+import { isAnagram } from './isAnagram';
+import { isPanagram } from './isPanagram';
+import { isMacAddress } from './isMacAddress';
 export declare const validations: {
     isCoordinates: typeof isCoordinates;
     isDate: typeof isDate;
@@ -26,4 +40,11 @@ export declare const validations: {
     isIPv4: typeof isIPv4;
     isHexColor: typeof isHexColor;
     isPalindrome: typeof isPalindrome;
+    isLowerCase: typeof isLowerCase;
+    isUpperCase: typeof isUpperCase;
+    isAlphabetic: typeof isAlphabetic;
+    isAlphaNumeric: typeof isAlphaNumeric;
+    isAnagram: typeof isAnagram;
+    isPanagram: typeof isPanagram;
+    isMacAddress: typeof isMacAddress;
 };

package/dist/validations/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validations = exports.isPalindrome = exports.isHexColor = exports.isIPv4 = exports.isURL = exports.isSlug = exports.isEmpty = exports.isEmail = exports.isDate = exports.isCoordinates = void 0;
+exports.validations = exports.isMacAddress = exports.isPanagram = exports.isAnagram = exports.isAlphaNumeric = exports.isAlphabetic = exports.isUpperCase = exports.isLowerCase = exports.isPalindrome = exports.isHexColor = exports.isIPv4 = exports.isURL = exports.isSlug = exports.isEmpty = exports.isEmail = exports.isDate = exports.isCoordinates = void 0;
 var isCoordinates_1 = require("./isCoordinates");
 Object.defineProperty(exports, "isCoordinates", { enumerable: true, get: function () { return isCoordinates_1.isCoordinates; } });
 var isDate_1 = require("./isDate");
@@ -19,6 +19,20 @@ var isHexColor_1 = require("./isHexColor");
 Object.defineProperty(exports, "isHexColor", { enumerable: true, get: function () { return isHexColor_1.isHexColor; } });
 var isPalindrome_1 = require("./isPalindrome");
 Object.defineProperty(exports, "isPalindrome", { enumerable: true, get: function () { return isPalindrome_1.isPalindrome; } });
+var isLowerCase_1 = require("./isLowerCase");
+Object.defineProperty(exports, "isLowerCase", { enumerable: true, get: function () { return isLowerCase_1.isLowerCase; } });
+var isUpperCase_1 = require("./isUpperCase");
+Object.defineProperty(exports, "isUpperCase", { enumerable: true, get: function () { return isUpperCase_1.isUpperCase; } });
+var isAlphabetic_1 = require("./isAlphabetic");
+Object.defineProperty(exports, "isAlphabetic", { enumerable: true, get: function () { return isAlphabetic_1.isAlphabetic; } });
+var isAlphaNumeric_1 = require("./isAlphaNumeric");
+Object.defineProperty(exports, "isAlphaNumeric", { enumerable: true, get: function () { return isAlphaNumeric_1.isAlphaNumeric; } });
+var isAnagram_1 = require("./isAnagram");
+Object.defineProperty(exports, "isAnagram", { enumerable: true, get: function () { return isAnagram_1.isAnagram; } });
+var isPanagram_1 = require("./isPanagram");
+Object.defineProperty(exports, "isPanagram", { enumerable: true, get: function () { return isPanagram_1.isPanagram; } });
+var isMacAddress_1 = require("./isMacAddress");
+Object.defineProperty(exports, "isMacAddress", { enumerable: true, get: function () { return isMacAddress_1.isMacAddress; } });
 const isCoordinates_2 = require("./isCoordinates");
 const isDate_2 = require("./isDate");
 const isEmail_2 = require("./isEmail");
@@ -28,6 +42,13 @@ const isURL_2 = require("./isURL");
 const isIPv4_2 = require("./isIPv4");
 const isHexColor_2 = require("./isHexColor");
 const isPalindrome_2 = require("./isPalindrome");
+const isLowerCase_2 = require("./isLowerCase");
+const isUpperCase_2 = require("./isUpperCase");
+const isAlphabetic_2 = require("./isAlphabetic");
+const isAlphaNumeric_2 = require("./isAlphaNumeric");
+const isAnagram_2 = require("./isAnagram");
+const isPanagram_2 = require("./isPanagram");
+const isMacAddress_2 = require("./isMacAddress");
 exports.validations = {
     isCoordinates: isCoordinates_2.isCoordinates,
     isDate: isDate_2.isDate,
@@ -37,5 +58,12 @@ exports.validations = {
     isURL: isURL_2.isURL,
     isIPv4: isIPv4_2.isIPv4,
     isHexColor: isHexColor_2.isHexColor,
-    isPalindrome: isPalindrome_2.isPalindrome
+    isPalindrome: isPalindrome_2.isPalindrome,
+    isLowerCase: isLowerCase_2.isLowerCase,
+    isUpperCase: isUpperCase_2.isUpperCase,
+    isAlphabetic: isAlphabetic_2.isAlphabetic,
+    isAlphaNumeric: isAlphaNumeric_2.isAlphaNumeric,
+    isAnagram: isAnagram_2.isAnagram,
+    isPanagram: isPanagram_2.isPanagram,
+    isMacAddress: isMacAddress_2.isMacAddress
 };

package/dist/validations/isAlphaNumeric.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Checks whether the given string is alphanumeric.
+ *
+ * The check ensures that the string contains only
+ * letters (a-z, A-Z) and digits (0-9).
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if the input is alphanumeric, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function isAlphaNumeric(str: string): boolean;

package/dist/validations/isAlphaNumeric.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAlphaNumeric = isAlphaNumeric;
+/**
+ * Checks whether the given string is alphanumeric.
+ *
+ * The check ensures that the string contains only
+ * letters (a-z, A-Z) and digits (0-9).
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if the input is alphanumeric, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ */
+function isAlphaNumeric(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    if (str.length === 0) {
+        return false;
+    }
+    return /^[a-z0-9]+$/i.test(str);
+}

package/dist/validations/isAlphabetic.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks whether a given string contains only alphabetic characters (A-Z, a-z).
+ *
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if the input contains only alphabetic characters, otherwise false.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function isAlphabetic(str: string): boolean;

package/dist/validations/isAlphabetic.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAlphabetic = isAlphabetic;
+/**
+ * Checks whether a given string contains only alphabetic characters (A-Z, a-z).
+ *
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if the input contains only alphabetic characters, otherwise false.
+ * @throws {TypeError} If the input is not a string.
+ */
+function isAlphabetic(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    // empty string is not considered alphabetic
+    if (str === '')
+        return false;
+    // Regular expression to match only alphabetic characters
+    return /^[A-Za-z]+$/.test(str);
+}

package/dist/validations/isAnagram.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Checks whether two strings are anagrams of each other.
+ *
+ * Rules:
+ * - Comparison is case-insensitive.
+ * - Spaces and punctuation are ignored.
+ *
+ * @param {string} str1 - The first input string.
+ * @param {string} str2 - The second input string.
+ * @returns {boolean} True if the inputs are anagrams, otherwise false.
+ * @throws {TypeError} If either input is not a string.
+ */
+export declare function isAnagram(str1: string, str2: string): boolean;

package/dist/validations/isAnagram.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAnagram = isAnagram;
+/**
+ * Checks whether two strings are anagrams of each other.
+ *
+ * Rules:
+ * - Comparison is case-insensitive.
+ * - Spaces and punctuation are ignored.
+ *
+ * @param {string} str1 - The first input string.
+ * @param {string} str2 - The second input string.
+ * @returns {boolean} True if the inputs are anagrams, otherwise false.
+ * @throws {TypeError} If either input is not a string.
+ */
+function isAnagram(str1, str2) {
+    if (typeof str1 !== 'string' || typeof str2 !== 'string') {
+        throw new TypeError('Both inputs must be strings');
+    }
+    // Normalize: lowercase, remove spaces & punctuation
+    const normalize = (str) => str.toLowerCase().replace(/[^a-z0-9]/g, '').split('').sort().join('');
+    return normalize(str1) === normalize(str2);
+}

package/dist/validations/isLowerCase.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Checks whether the given string contains only lowercase alphabetic characters.
+ *
+ * - At least one alphabetic character must be present.
+ * - Digits, spaces, and special characters are ignored.
+ * - If any uppercase alphabetic character is found, it returns false.
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if all alphabetic characters are lowercase and at least one exists, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function isLowerCase(str: string): boolean;

package/dist/validations/isLowerCase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLowerCase = isLowerCase;
+/**
+ * Checks whether the given string contains only lowercase alphabetic characters.
+ *
+ * - At least one alphabetic character must be present.
+ * - Digits, spaces, and special characters are ignored.
+ * - If any uppercase alphabetic character is found, it returns false.
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if all alphabetic characters are lowercase and at least one exists, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ */
+function isLowerCase(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    if (str.length === 0) {
+        return false;
+    }
+    let hasLetter = false;
+    for (const char of str) {
+        if (/[A-Z]/.test(char)) {
+            return false;
+        }
+        if (/[a-z]/.test(char)) {
+            hasLetter = true;
+        }
+    }
+    return hasLetter;
+}

package/dist/validations/isMacAddress.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Checks if a given string is a valid MAC address.
+ *
+ * Valid MAC addresses consist of six pairs of hexadecimal digits (0-9, A-F)
+ * separated either by colons (:) or hyphens (-). Example formats:
+ * - "00:1A:2B:3C:4D:5E"
+ * - "00-1A-2B-3C-4D-5E"
+ *
+ * Mixed or missing separators, invalid hex characters, or incorrect lengths
+ * are not allowed.
+ *
+ * @param {string} str - The string to validate as a MAC address.
+ * @returns {boolean} `true` if the string is a valid MAC address, otherwise `false`.
+ *
+ * @example
+ * isMacAddress("00:1A:2B:3C:4D:5E"); // true
+ *
+ * @example
+ * isMacAddress("00-1A-2B-3C-4D-5E"); // true
+ *
+ * @example
+ * isMacAddress("001A:2B:3C:4D:5E"); // false (wrong length)
+ *
+ * @example
+ * isMacAddress("00:1G:2B:3C:4D:5E"); // false (invalid hex digit 'G')
+ */
+export declare function isMacAddress(str: string): boolean;

package/dist/validations/isMacAddress.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMacAddress = isMacAddress;
+/**
+ * Checks if a given string is a valid MAC address.
+ *
+ * Valid MAC addresses consist of six pairs of hexadecimal digits (0-9, A-F)
+ * separated either by colons (:) or hyphens (-). Example formats:
+ * - "00:1A:2B:3C:4D:5E"
+ * - "00-1A-2B-3C-4D-5E"
+ *
+ * Mixed or missing separators, invalid hex characters, or incorrect lengths
+ * are not allowed.
+ *
+ * @param {string} str - The string to validate as a MAC address.
+ * @returns {boolean} `true` if the string is a valid MAC address, otherwise `false`.
+ *
+ * @example
+ * isMacAddress("00:1A:2B:3C:4D:5E"); // true
+ *
+ * @example
+ * isMacAddress("00-1A-2B-3C-4D-5E"); // true
+ *
+ * @example
+ * isMacAddress("001A:2B:3C:4D:5E"); // false (wrong length)
+ *
+ * @example
+ * isMacAddress("00:1G:2B:3C:4D:5E"); // false (invalid hex digit 'G')
+ */
+function isMacAddress(str) {
+    const macRegex = /^([0-9A-Fa-f]{2}([:-])){5}([0-9A-Fa-f]{2})$/;
+    // Check regex first
+    if (!macRegex.test(str))
+        return false;
+    // Ensure all separators are the same (either all ':' or all '-')
+    const separator = str[2];
+    const expectedSeparator = separator === ':' ? ':' : '-';
+    for (let i = 2; i < str.length; i += 3) {
+        if (str[i] !== expectedSeparator)
+            return false;
+    }
+    return true;
+}

package/dist/validations/isPanagram.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Checks if a given string is a pangram (contains every letter of the English alphabet at least once).
+ *
+ * The check is case-insensitive, and non-alphabetic characters (numbers, punctuation, spaces)
+ * are ignored. An empty string is not considered a pangram.
+ *
+ * @param {string} str - The input string to validate.
+ * @returns {boolean} True if the string is a pangram, otherwise false.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * isPangram("The quick brown fox jumps over the lazy dog."); // true
+ *
+ * @example
+ * isPangram("This is not a pangram."); // false
+ *
+ * @example
+ * isPangram("Abcdefghijklmnopqrstuvwxyz"); // true
+ */
+export declare function isPanagram(str: string): boolean;

package/dist/validations/isPanagram.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPanagram = isPanagram;
+/**
+ * Checks if a given string is a pangram (contains every letter of the English alphabet at least once).
+ *
+ * The check is case-insensitive, and non-alphabetic characters (numbers, punctuation, spaces)
+ * are ignored. An empty string is not considered a pangram.
+ *
+ * @param {string} str - The input string to validate.
+ * @returns {boolean} True if the string is a pangram, otherwise false.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * isPangram("The quick brown fox jumps over the lazy dog."); // true
+ *
+ * @example
+ * isPangram("This is not a pangram."); // false
+ *
+ * @example
+ * isPangram("Abcdefghijklmnopqrstuvwxyz"); // true
+ */
+function isPanagram(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    if (str === '')
+        return false;
+    // Normalize string: lowercase and remove non-letters
+    const normalized = str.toLowerCase().replace(/[^a-z]/g, '');
+    // Create a set of unique letters
+    const uniqueLetters = new Set(normalized);
+    // Pangram if it has all 26 letters
+    return uniqueLetters.size === 26;
+}

package/dist/validations/isUpperCase.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Checks whether the given string contains only uppercase alphabetic characters.
+ *
+ * - At least one alphabetic character must be present.
+ * - Digits, spaces, and special characters are ignored.
+ * - If any lowercase alphabetic character is found, it returns false.
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if all alphabetic characters are uppercase and at least one exists, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function isUpperCase(str: string): boolean;

package/dist/validations/isUpperCase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUpperCase = isUpperCase;
+/**
+ * Checks whether the given string contains only uppercase alphabetic characters.
+ *
+ * - At least one alphabetic character must be present.
+ * - Digits, spaces, and special characters are ignored.
+ * - If any lowercase alphabetic character is found, it returns false.
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if all alphabetic characters are uppercase and at least one exists, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ */
+function isUpperCase(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    if (str.length === 0) {
+        return false;
+    }
+    let hasLetter = false;
+    for (const char of str) {
+        if (/[a-z]/.test(char)) {
+            return false;
+        }
+        if (/[A-Z]/.test(char)) {
+            hasLetter = true;
+        }
+    }
+    return hasLetter;
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "stringzy",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
-    "test": "npm run build && node --test",
+    "test": " npm run build && node --test",
     "prepublishOnly": "npm run build",
     "format": "prettier --write ."
   },
@@ -45,7 +45,7 @@
     "url": "git+https://github.com/Samarth2190/stringzy.git"
   },
   "devDependencies": {
-    "@types/node": "^24.0.4",
+    "@types/node": "^24.5.2",
     "prettier": "^3.6.2",
     "typescript": "^5.8.3"
   }