stringzy 2.2.1 → 4.0.0

package/dist/validations/isIPv4.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Checks if a given string is a valid IPv4 address.
+ *
+ * Valid IPv4 addresses consist of four decimal numbers (0-255) separated by dots.
+ * Leading zeros are not allowed (e.g., "01" is invalid).
+ *
+ * @param {string} str - The string to validate as an IPv4 address.
+ * @returns {boolean} `true` if the string is a valid IPv4 address, otherwise `false`.
+ *
+ * @example
+ * isIPv4("192.168.1.1"); // true
+ *
+ * @example
+ * isIPv4("255.255.255.255"); // true
+ *
+ * @example
+ * isIPv4("256.100.50.0"); // false (256 is out of range)
+ *
+ * @example
+ * isIPv4("192.168.1"); // false (not enough parts)
+ */
+export declare function isIPv4(str: string): boolean;

package/dist/validations/isIPv4.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIPv4 = isIPv4;
+/**
+ * Checks if a given string is a valid IPv4 address.
+ *
+ * Valid IPv4 addresses consist of four decimal numbers (0-255) separated by dots.
+ * Leading zeros are not allowed (e.g., "01" is invalid).
+ *
+ * @param {string} str - The string to validate as an IPv4 address.
+ * @returns {boolean} `true` if the string is a valid IPv4 address, otherwise `false`.
+ *
+ * @example
+ * isIPv4("192.168.1.1"); // true
+ *
+ * @example
+ * isIPv4("255.255.255.255"); // true
+ *
+ * @example
+ * isIPv4("256.100.50.0"); // false (256 is out of range)
+ *
+ * @example
+ * isIPv4("192.168.1"); // false (not enough parts)
+ */
+function isIPv4(str) {
+    const parts = str.split('.');
+    if (parts.length !== 4)
+        return false;
+    return parts.every((part) => {
+        const num = parseInt(part, 10);
+        return !isNaN(num) && num >= 0 && num <= 255 && part === num.toString();
+    });
+}

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

@@ -0,0 +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

@@ -0,0 +1,37 @@
+"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;
+    }
+    const slugRegex = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+    return slugRegex.test(str);
+}

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

@@ -0,0 +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

@@ -0,0 +1,33 @@
+"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);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "stringzy",
-  "version": "2.2.1",
-  "main": "index.js",
-  "type": "module",
+  "version": "4.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc",
+    "test": "npm run build && node --test",
+    "prepublishOnly": "npm run build",
+    "format": "prettier --write ."
   },
   "author": "Samarth Ruia",
   "readmeFilename": "README.md",
@@ -40,5 +43,10 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Samarth2190/stringzy.git"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.4",
+    "prettier": "^3.6.2",
+    "typescript": "^5.8.3"
   }
 }

package/analysis.js

@@ -1,21 +0,0 @@
-
-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/formatting.js

@@ -1,37 +0,0 @@
-
-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,75 +0,0 @@
-/**
- * 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.2.1
- */
-
-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,
-  removeWords,
-  initials,
-  removeDuplicates
-} = transformations;
-
-export const {
-  isURL,
-  isEmail,
-  isEmpty,
-  isDate,
-} = validations;
-
-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,
-  
-  transform: transformations,
-  validate: validations,
-  analyze: analysis,
-  format: formatting,
-
-  transform,
-  validate,
-  analyze,
-  format,
-};

package/transformations.js

@@ -1,190 +0,0 @@
-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, '');
-}
-
-export function removeWords(str, wordsToRemove) {
-      if (str === null || str === undefined) {
-    throw new Error('Input string cannot be null or undefined');
-  }
-  if (typeof str !== 'string') {
-    throw new Error('First parameter must be a string');
-  }
-  if (wordsToRemove === null || wordsToRemove === undefined) {
-    throw new Error('Words to remove cannot be null or undefined');
-  }
-  if (typeof wordsToRemove !== 'string' && !Array.isArray(wordsToRemove)) {
-    throw new Error('Second parameter must be a string or an array of strings');
-  }
-    if (str === '') {
-    return '';
-  }
-  const wordsArray = Array.isArray(wordsToRemove) ? wordsToRemove : [wordsToRemove];
-  const regex = new RegExp(`\\b(${wordsArray.join('|')})\\b`, 'gi');
-  return str.replace(regex, '').replace(/\s+/g, ' ').trim();
-}
-
-export function initials(text, limit) {
-  if (typeof text !== "string") {
-    throw new Error("Input must be a string");
-  }
-
-  if (limit !== undefined && (typeof limit !== "number" || isNaN(limit))) {
-    throw new Error("Limit must be a valid number");
-  }
-
-  if (limit < 0) {
-    throw new Error("Limit must be a non-negative number");
-  }
-
-  const words = text
-    .trim()
-    .split(/\s+/)
-    .filter((word) => word.length > 0);
-
-  if (words.length === 0) return "";
-
-  const initialsArray = words
-    .map((word) => word.charAt(0))
-    .slice(0, limit ?? words.length);
-
-  return initialsArray.join("");
-}
-
-export function removeDuplicates(text) {
-  if (typeof text !== "string") {
-    throw new Error("Input must be a string");
-  }
-
-  const wordSet = new Set();
-
-  text.split(" ").forEach((word) => {
-    wordSet.add(word);
-  });
-
-  return Array.from(wordSet).join(" ");
-}

package/validations.js

@@ -1,80 +0,0 @@
-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;
-}
-
-
-
-export function isDate(input) {
-
-  //console.log("True")
-
-  
-  
-  if (typeof input !== "string") return false;
-
-  const formats = [
-    {
-      // Format: YYYY-MM-DD 
-      regex: /^\d{4}-\d{2}-\d{2}$/,
-      split: (s) => s.split("-").map(Number),
-      order: ["Y", "M", "D"],
-    },
-      {
-      // Format: MM-DD-YYYY 
-      regex: /^\d{2}-\d{2}-\d{4}$/,
-      split: (s) => s.split("-").map(Number),
-      order: ["M", "D", "Y"],
-   },
-    {
-      // Format: DD-MM-YYYY 
-      regex: /^\d{2}-\d{2}-\d{4}$/,
-      split: (s) => s.split("-").map(Number),
-      order: ["D", "M", "Y"],
-    },
-    {
-      // Format: DD/MM/YYYY 
-      regex: /^\d{2}\/\d{2}\/\d{4}$/,
-      split: (s) => s.split("/").map(Number),
-      order: ["D", "M", "Y"],
-    },
-    {
-      // Format: YYYY/MM/DD 
-      regex: /^\d{4}\/\d{2}\/\d{2}$/,
-      split: (s) => s.split("/").map(Number),
-      order: ["Y", "M", "D"],
-    },
-  ];
-
-  for (const format of formats) {
-    if (format.regex.test(input)) {
-      const parts = format.split(input);
-      const dateParts = {};
-      format.order.forEach((key, i) => {
-        dateParts[key] = parts[i];
-      });
-
-      const { Y, M, D } = dateParts;
-      const date = new Date(Y, M - 1, D); // JS months are 0-indexed
-      return date.getFullYear() === Y && date.getMonth() === M -1  && date.getDate() === D;
-    }
-  }
-
-  return false;
-}
-