stringzy 3.0.0 → 4.1.0

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/isPalindrome.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Checks whether the given string is a palindrome.
+ *
+ * The check is case-insensitive and ignores all non-alphanumeric characters.
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if the input is a palindrome, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function isPalindrome(str: string): boolean;

package/dist/validations/isPalindrome.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPalindrome = isPalindrome;
+/**
+ * Checks whether the given string is a palindrome.
+ *
+ * The check is case-insensitive and ignores all non-alphanumeric characters.
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if the input is a palindrome, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ */
+function isPalindrome(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    const sanitized = str
+        .toLowerCase()
+        .replace(/[^a-z0-9]/gi, '');
+    return sanitized === sanitized.split('').reverse().join('');
+}

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/isSlug.d.ts

@@ -1 +1,28 @@
+/**
+ * Checks if a given string is a valid slug.
+ *
+ * A valid slug:
+ * - Contains only lowercase letters (`a-z`), numbers (`0-9`), and hyphens (`-`).
+ * - Does not start or end with a hyphen.
+ * - Does not contain consecutive hyphens.
+ * - Is not an empty string.
+ *
+ * @param {string} str - The string to validate as a slug.
+ * @returns {boolean} `true` if the string is a valid slug, otherwise `false`.
+ *
+ * @example
+ * isSlug("valid-slug-123"); // true
+ *
+ * @example
+ * isSlug("Invalid-Slug"); // false (uppercase letters)
+ *
+ * @example
+ * isSlug("-starts-with-hyphen"); // false
+ *
+ * @example
+ * isSlug("ends-with-hyphen-"); // false
+ *
+ * @example
+ * isSlug("double--hyphen"); // false
+ */
 export declare function isSlug(str: string): boolean;

package/dist/validations/isSlug.js

@@ -1,6 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSlug = isSlug;
+/**
+ * Checks if a given string is a valid slug.
+ *
+ * A valid slug:
+ * - Contains only lowercase letters (`a-z`), numbers (`0-9`), and hyphens (`-`).
+ * - Does not start or end with a hyphen.
+ * - Does not contain consecutive hyphens.
+ * - Is not an empty string.
+ *
+ * @param {string} str - The string to validate as a slug.
+ * @returns {boolean} `true` if the string is a valid slug, otherwise `false`.
+ *
+ * @example
+ * isSlug("valid-slug-123"); // true
+ *
+ * @example
+ * isSlug("Invalid-Slug"); // false (uppercase letters)
+ *
+ * @example
+ * isSlug("-starts-with-hyphen"); // false
+ *
+ * @example
+ * isSlug("ends-with-hyphen-"); // false
+ *
+ * @example
+ * isSlug("double--hyphen"); // false
+ */
 function isSlug(str) {
     if (typeof str !== 'string' || str.length === 0) {
         return false;

package/dist/validations/isTypeOf.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if a file name or URL string has a valid extension for a given type.
+ *
+ * @param {string} input - File name or URL.
+ * @param {string} type - The type category to validate.
+ * @returns {boolean}
+ * @throws error when input is not string or type is not defined
+ */
+export declare function isTypeOf(input: string, type: string): boolean;

package/dist/validations/isTypeOf.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTypeOf = isTypeOf;
+/**
+ * Checks if a file name or URL string has a valid extension for a given type.
+ *
+ * @param {string} input - File name or URL.
+ * @param {string} type - The type category to validate.
+ * @returns {boolean}
+ * @throws error when input is not string or type is not defined
+ */
+function isTypeOf(input, type) {
+    var _a;
+    if (typeof input !== "string" || typeof type !== "string")
+        return false;
+    // Gets the substring after the last (.), then converts to lowercase, removes (?) and (#)
+    // Example: "image.png?version=2#top", returns "png"
+    const extension = (_a = input.split(".").pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase().split("?")[0].split("#")[0];
+    if (!extension)
+        return false;
+    const typeMap = {
+        image: ["png", "jpg", "jpeg", "gif", "bmp", "svg", "webp", "ico"],
+        video: ["mp4", "webm", "avi", "mkv", "mov", "flv"],
+        audio: ["mp3", "wav", "ogg", "flac", "aac"],
+        document: ["pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "txt", "md"],
+        archive: ["zip", "rar", "tar", "gz", "7z"],
+    };
+    const allowed = typeMap[type.toLowerCase()];
+    return allowed ? allowed.includes(extension) : false;
+}

package/dist/validations/isURL.d.ts

@@ -1 +1,22 @@
+/**
+ * Checks if a given string is a valid URL.
+ *
+ * Uses the built-in `URL` constructor to attempt parsing the input string.
+ * Returns `true` if the string is a valid URL, otherwise `false`.
+ *
+ * @param {string} str - The string to validate as a URL.
+ * @returns {boolean} `true` if the string is a valid URL, otherwise `false`.
+ *
+ * @example
+ * isURL("https://www.example.com"); // true
+ *
+ * @example
+ * isURL("ftp://ftp.example.com/resource.txt"); // true
+ *
+ * @example
+ * isURL("not a url"); // false
+ *
+ * @example
+ * isURL("http:/invalid-url"); // false
+ */
 export declare function isURL(str: string): boolean;

package/dist/validations/isURL.js

@@ -1,6 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isURL = isURL;
+/**
+ * Checks if a given string is a valid URL.
+ *
+ * Uses the built-in `URL` constructor to attempt parsing the input string.
+ * Returns `true` if the string is a valid URL, otherwise `false`.
+ *
+ * @param {string} str - The string to validate as a URL.
+ * @returns {boolean} `true` if the string is a valid URL, otherwise `false`.
+ *
+ * @example
+ * isURL("https://www.example.com"); // true
+ *
+ * @example
+ * isURL("ftp://ftp.example.com/resource.txt"); // true
+ *
+ * @example
+ * isURL("not a url"); // false
+ *
+ * @example
+ * isURL("http:/invalid-url"); // false
+ */
 function isURL(str) {
     try {
         new URL(str);

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,12 +1,13 @@
 {
   "name": "stringzy",
-  "version": "3.0.0",
+  "version": "4.1.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
-    "test": "npm run build && node --test",
-    "prepublishOnly": "npm run build"
+    "test": " npm run build && node --test",
+    "prepublishOnly": "npm run build",
+    "format": "prettier --write ."
   },
   "author": "Samarth Ruia",
   "readmeFilename": "README.md",
@@ -44,7 +45,8 @@
     "url": "git+https://github.com/Samarth2190/stringzy.git"
   },
   "devDependencies": {
-    "@types/node": "^24.0.0",
+    "@types/node": "^24.5.2",
+    "prettier": "^3.6.2",
     "typescript": "^5.8.3"
   }
 }