stringzy 2.2.1 → 4.0.0

package/dist/transformations/splitChunks.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitChunks = splitChunks;
+/**
+ * Creates chunks of string based on a given chunk size
+ * @param text - Input string
+ * @param Number - Size of the chunk. Must be a positive integer. Defaults to 1.
+ * @returns An array of all the chunks created from the string based on the specified chunk size.
+ * @throws Error if input text is not a string or chunk size is not a positive integer.
+ */
+function splitChunks(text, chunkSize = 1) {
+    if (typeof text !== 'string') {
+        throw new Error('Input text must be a string');
+    }
+    if (typeof chunkSize !== 'number' || !Number.isInteger(chunkSize) || chunkSize < 1) {
+        throw new Error('chunkSize must be a natural number (1, 2, 3, ...)');
+    }
+    const len = text.length;
+    const chunks = [];
+    for (let i = 0; i < len; i += chunkSize) {
+        chunks.push(text.slice(i, i + chunkSize));
+    }
+    return chunks;
+}

package/dist/transformations/titleCase.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Converts a string to Title Case, capitalizing the first letter of each word.
+ *
+ * The conversion process includes:
+ * - Trimming whitespace from both ends.
+ * - Converting the entire string to lowercase.
+ * - Replacing non-word characters and underscores with spaces.
+ * - Collapsing multiple spaces into a single space.
+ * - Capitalizing the first character of each word.
+ * - Preserving spaces between words.
+ *
+ * If the input is `null` or `undefined`, it returns an empty string.
+ *
+ * @param {string} text - The input string to convert.
+ * @returns {string} The Title Case formatted string.
+ *
+ * @example
+ * titleCase("hello world"); // "Hello World"
+ *
+ * @example
+ * titleCase("convert_to-title.case!"); // "Convert To Title Case"
+ *
+ * @example
+ * titleCase("  multiple   spaces here "); // "Multiple Spaces Here"
+ */
+export declare function titleCase(text: string): string;

package/dist/transformations/titleCase.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.titleCase = titleCase;
+/**
+ * Converts a string to Title Case, capitalizing the first letter of each word.
+ *
+ * The conversion process includes:
+ * - Trimming whitespace from both ends.
+ * - Converting the entire string to lowercase.
+ * - Replacing non-word characters and underscores with spaces.
+ * - Collapsing multiple spaces into a single space.
+ * - Capitalizing the first character of each word.
+ * - Preserving spaces between words.
+ *
+ * If the input is `null` or `undefined`, it returns an empty string.
+ *
+ * @param {string} text - The input string to convert.
+ * @returns {string} The Title Case formatted string.
+ *
+ * @example
+ * titleCase("hello world"); // "Hello World"
+ *
+ * @example
+ * titleCase("convert_to-title.case!"); // "Convert To Title Case"
+ *
+ * @example
+ * titleCase("  multiple   spaces here "); // "Multiple Spaces Here"
+ */
+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, ' ');
+}

package/dist/transformations/toSlug.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Converts a string into a URL-friendly slug.
+ *
+ * The conversion process includes:
+ * - Converting the string to lowercase.
+ * - Trimming whitespace from both ends.
+ * - Replacing one or more whitespace characters with a single hyphen (`-`).
+ * - Removing all characters except word characters (letters, digits, and underscores) and hyphens.
+ *
+ * Throws an error if the input is not a string.
+ *
+ * @param {string} text - The input string to convert into a slug.
+ * @returns {string} The URL-friendly slug string.
+ * @throws {Error} If the input is not a string.
+ *
+ * @example
+ * toSlug("Hello World!"); // "hello-world"
+ *
+ * @example
+ * toSlug("  This is a test --- "); // "this-is-a-test"
+ *
+ * @example
+ * toSlug("Clean_URL--Slug123"); // "clean_url--slug123"
+ */
+export declare function toSlug(text: string): string;

package/dist/transformations/toSlug.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSlug = toSlug;
+/**
+ * Converts a string into a URL-friendly slug.
+ *
+ * The conversion process includes:
+ * - Converting the string to lowercase.
+ * - Trimming whitespace from both ends.
+ * - Replacing one or more whitespace characters with a single hyphen (`-`).
+ * - Removing all characters except word characters (letters, digits, and underscores) and hyphens.
+ *
+ * Throws an error if the input is not a string.
+ *
+ * @param {string} text - The input string to convert into a slug.
+ * @returns {string} The URL-friendly slug string.
+ * @throws {Error} If the input is not a string.
+ *
+ * @example
+ * toSlug("Hello World!"); // "hello-world"
+ *
+ * @example
+ * toSlug("  This is a test --- "); // "this-is-a-test"
+ *
+ * @example
+ * toSlug("Clean_URL--Slug123"); // "clean_url--slug123"
+ */
+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, '');
+}

package/dist/transformations/truncateText.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Truncates a string to a specified maximum length and appends a suffix if truncated.
+ *
+ * If the text length is less than or equal to `maxLength`, the original text is returned.
+ * Otherwise, the text is cut off so that the total length including the suffix does not exceed `maxLength`.
+ *
+ * Throws a `TypeError` if input types are invalid or if `maxLength` is negative.
+ *
+ * @param {string} text - The input string to truncate.
+ * @param {number} maxLength - The maximum allowed length of the returned string including suffix.
+ * @param {string} [suffix='...'] - The string to append if truncation occurs.
+ * @returns {string} The truncated string with suffix if applicable.
+ * @throws {TypeError} If `text` is not a string.
+ * @throws {Error} If `maxLength` is not a non-negative number.
+ * @throws {TypeError} If `suffix` is not a string.
+ *
+ * @example
+ * truncateText("Hello World", 8); // "Hello..."
+ *
+ * @example
+ * truncateText("Short text", 20); // "Short text"
+ *
+ * @example
+ * truncateText("Custom suffix example", 10, "---"); // "Custom---"
+ */
+export declare function truncateText(text: string, maxLength: number, suffix?: string): string;

package/dist/transformations/truncateText.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncateText = truncateText;
+/**
+ * Truncates a string to a specified maximum length and appends a suffix if truncated.
+ *
+ * If the text length is less than or equal to `maxLength`, the original text is returned.
+ * Otherwise, the text is cut off so that the total length including the suffix does not exceed `maxLength`.
+ *
+ * Throws a `TypeError` if input types are invalid or if `maxLength` is negative.
+ *
+ * @param {string} text - The input string to truncate.
+ * @param {number} maxLength - The maximum allowed length of the returned string including suffix.
+ * @param {string} [suffix='...'] - The string to append if truncation occurs.
+ * @returns {string} The truncated string with suffix if applicable.
+ * @throws {TypeError} If `text` is not a string.
+ * @throws {Error} If `maxLength` is not a non-negative number.
+ * @throws {TypeError} If `suffix` is not a string.
+ *
+ * @example
+ * truncateText("Hello World", 8); // "Hello..."
+ *
+ * @example
+ * truncateText("Short text", 20); // "Short text"
+ *
+ * @example
+ * truncateText("Custom suffix example", 10, "---"); // "Custom---"
+ */
+function truncateText(text, maxLength, suffix = '...') {
+    if (typeof text !== 'string') {
+        throw new TypeError('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 TypeError('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;
+}

package/dist/validations/index.d.ts

@@ -0,0 +1,29 @@
+export { isCoordinates } from './isCoordinates';
+export { isDate } from './isDate';
+export { isEmail } from './isEmail';
+export { isEmpty } from './isEmpty';
+export { isSlug } from './isSlug';
+export { isURL } from './isURL';
+export { isIPv4 } from './isIPv4';
+export { isHexColor } from './isHexColor';
+export { isPalindrome } from './isPalindrome';
+import { isCoordinates } from './isCoordinates';
+import { isDate } from './isDate';
+import { isEmail } from './isEmail';
+import { isEmpty } from './isEmpty';
+import { isSlug } from './isSlug';
+import { isURL } from './isURL';
+import { isIPv4 } from './isIPv4';
+import { isHexColor } from './isHexColor';
+import { isPalindrome } from './isPalindrome';
+export declare const validations: {
+    isCoordinates: typeof isCoordinates;
+    isDate: typeof isDate;
+    isEmail: typeof isEmail;
+    isEmpty: typeof isEmpty;
+    isSlug: typeof isSlug;
+    isURL: typeof isURL;
+    isIPv4: typeof isIPv4;
+    isHexColor: typeof isHexColor;
+    isPalindrome: typeof isPalindrome;
+};

package/dist/validations/index.js

@@ -0,0 +1,41 @@
+"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;
+var isCoordinates_1 = require("./isCoordinates");
+Object.defineProperty(exports, "isCoordinates", { enumerable: true, get: function () { return isCoordinates_1.isCoordinates; } });
+var isDate_1 = require("./isDate");
+Object.defineProperty(exports, "isDate", { enumerable: true, get: function () { return isDate_1.isDate; } });
+var isEmail_1 = require("./isEmail");
+Object.defineProperty(exports, "isEmail", { enumerable: true, get: function () { return isEmail_1.isEmail; } });
+var isEmpty_1 = require("./isEmpty");
+Object.defineProperty(exports, "isEmpty", { enumerable: true, get: function () { return isEmpty_1.isEmpty; } });
+var isSlug_1 = require("./isSlug");
+Object.defineProperty(exports, "isSlug", { enumerable: true, get: function () { return isSlug_1.isSlug; } });
+var isURL_1 = require("./isURL");
+Object.defineProperty(exports, "isURL", { enumerable: true, get: function () { return isURL_1.isURL; } });
+var isIPv4_1 = require("./isIPv4");
+Object.defineProperty(exports, "isIPv4", { enumerable: true, get: function () { return isIPv4_1.isIPv4; } });
+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; } });
+const isCoordinates_2 = require("./isCoordinates");
+const isDate_2 = require("./isDate");
+const isEmail_2 = require("./isEmail");
+const isEmpty_2 = require("./isEmpty");
+const isSlug_2 = require("./isSlug");
+const isURL_2 = require("./isURL");
+const isIPv4_2 = require("./isIPv4");
+const isHexColor_2 = require("./isHexColor");
+const isPalindrome_2 = require("./isPalindrome");
+exports.validations = {
+    isCoordinates: isCoordinates_2.isCoordinates,
+    isDate: isDate_2.isDate,
+    isEmail: isEmail_2.isEmail,
+    isEmpty: isEmpty_2.isEmpty,
+    isSlug: isSlug_2.isSlug,
+    isURL: isURL_2.isURL,
+    isIPv4: isIPv4_2.isIPv4,
+    isHexColor: isHexColor_2.isHexColor,
+    isPalindrome: isPalindrome_2.isPalindrome
+};

package/dist/validations/isCoordinates.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if given latitude and longitude are valid coordinates.
+ *
+ * @param {number} lat - The latitude to check.
+ * @param {number} long - The longitude to check.
+ * @returns {boolean} True if both latitude and longitude are valid, false otherwise.
+ */
+export declare function isCoordinates(lat: number, long: number): boolean;

package/dist/validations/isCoordinates.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Checks if given latitude and longitude are valid coordinates.
+ *
+ * @param {number} lat - The latitude to check.
+ * @param {number} long - The longitude to check.
+ * @returns {boolean} True if both latitude and longitude are valid, false otherwise.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCoordinates = isCoordinates;
+function isCoordinates(lat, long) {
+    return isLatitude(lat) && isLongitude(long);
+}
+function isLatitude(num) {
+    return Number.isFinite(num) && Math.abs(num) <= 90;
+}
+function isLongitude(num) {
+    return Number.isFinite(num) && Math.abs(num) <= 180;
+}

package/dist/validations/isDate.d.ts

@@ -0,0 +1,18 @@
+export declare enum DateFormats {
+    YYYYMMDD = "YYYYMMDD",
+    MMDDYYYY = "MMDDYYYY",
+    DDMMYYYY = "DDMMYYYY"
+}
+declare const VALID_SEPARATORS: readonly [".", "-", "/"];
+type ValidSeparators = (typeof VALID_SEPARATORS)[number];
+/**
+ * Takes a date and a format and returns whether or not the date matches the specified format.
+ * Optionally takes a separator that can be used instead of the default hyphen.
+ *
+ * Only accepts 2 digit month/day and 4 digit year
+ * @example 01-01-2000 -> True
+ * @example 01-1-2000 -> False
+ * @example 01-01-00 -> False
+ */
+export declare function isDate(input: string, format: DateFormats, separator?: ValidSeparators): boolean;
+export {};

package/dist/validations/isDate.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateFormats = void 0;
+exports.isDate = isDate;
+var DateFormats;
+(function (DateFormats) {
+    DateFormats["YYYYMMDD"] = "YYYYMMDD";
+    DateFormats["MMDDYYYY"] = "MMDDYYYY";
+    DateFormats["DDMMYYYY"] = "DDMMYYYY";
+})(DateFormats || (exports.DateFormats = DateFormats = {}));
+const VALID_SEPARATORS = ['.', '-', '/'];
+/**
+ * Takes a date and a format and returns whether or not the date matches the specified format.
+ * Optionally takes a separator that can be used instead of the default hyphen.
+ *
+ * Only accepts 2 digit month/day and 4 digit year
+ * @example 01-01-2000 -> True
+ * @example 01-1-2000 -> False
+ * @example 01-01-00 -> False
+ */
+function isDate(input, format, separator = '-') {
+    if (typeof input !== 'string')
+        return false;
+    if (input.length !== 10)
+        return false;
+    // Ensure separator is supported
+    if (![...VALID_SEPARATORS].includes(separator))
+        return false;
+    const formats = [
+        {
+            // Format: YYYY-MM-DD
+            format: DateFormats.YYYYMMDD,
+            regex: new RegExp(`^\\d{4}${separator}\\d{2}${separator}\\d{2}$`),
+            order: ['Y', 'M', 'D'],
+        },
+        {
+            // Format: MM-DD-YYYY
+            format: DateFormats.MMDDYYYY,
+            regex: new RegExp(`^\d{2}${separator}\d{2}${separator}\d{4}$/`),
+            order: ['M', 'D', 'Y'],
+        },
+        {
+            // Format: DD-MM-YYYY
+            format: DateFormats.DDMMYYYY,
+            regex: new RegExp(`^\d{2}${separator}\d{2}${separator}\d{4}$`),
+            order: ['D', 'M', 'Y'],
+        },
+    ];
+    const targetFormat = formats.find((f) => f.format === format);
+    const parts = input.split(separator).map(Number);
+    const dateParts = {};
+    targetFormat === null || targetFormat === void 0 ? void 0 : targetFormat.order.forEach((k, i) => {
+        dateParts[k] = parts[i];
+    });
+    const { Y, M, D } = dateParts;
+    const checkDate = new Date(Y, M - 1, D); // Months are 0 indexed
+    if (checkDate.toString() === 'Invalid Date')
+        return false;
+    const isValid = checkDate.getFullYear() === Y && checkDate.getMonth() === M - 1 && checkDate.getDate() === D;
+    return isValid;
+}

package/dist/validations/isEmail.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Checks if a given string is a valid email address.
+ *
+ * Uses a regular expression to verify the format: it must contain
+ * one "@" symbol, no spaces, and at least one dot after the "@"
+ * (e.g., "example@domain.com").
+ *
+ * @param {string} str - The string to be checked.
+ * @returns {boolean} True if the string is a valid email address, false otherwise.
+ */
+export declare function isEmail(str: string, opts?: {
+    smtpUTF8?: boolean;
+}): boolean;

package/dist/validations/isEmail.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * Checks if a given string is a valid email address.
+ *
+ * Uses a regular expression to verify the format: it must contain
+ * one "@" symbol, no spaces, and at least one dot after the "@"
+ * (e.g., "example@domain.com").
+ *
+ * @param {string} str - The string to be checked.
+ * @returns {boolean} True if the string is a valid email address, false otherwise.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmail = isEmail;
+function isEmail(str, opts) {
+    if (typeof str !== 'string')
+        return false;
+    if (!str)
+        return false;
+    // Enable SMTPUTF8 by default; set opts.smtpUTF8=false to enforce ASCII-only
+    const smtpUTF8 = (opts === null || opts === void 0 ? void 0 : opts.smtpUTF8) !== false;
+    // Quick overall length guard
+    if (str.length > 254)
+        return false;
+    // Find the separator '@' by scanning from right to left and skipping those inside quotes
+    let inQuote = false;
+    let atIndex = -1;
+    for (let i = str.length - 1; i >= 0; i--) {
+        const ch = str[i];
+        if (ch === '"') {
+            // toggle quote state if this quote is not escaped by a backslash
+            const prev = str[i - 1];
+            if (prev !== '\\')
+                inQuote = !inQuote;
+            continue;
+        }
+        if (ch === '@' && !inQuote) {
+            atIndex = i;
+            break;
+        }
+    }
+    if (inQuote)
+        return false; // unbalanced quotes
+    if (atIndex <= 0 || atIndex === str.length - 1)
+        return false;
+    const local = str.slice(0, atIndex);
+    const domain = str.slice(atIndex + 1);
+    // Local-part length limit (64 octets)
+    if (local.length > 64)
+        return false;
+    // Validate local part as dot-separated of atoms or quoted-strings
+    // Validate local with a robust FSM that supports nested unescaped quotes inside quoted strings
+    const isAsciiAtext = (ch) => /[A-Za-z0-9!#$%&'*+\/=?^_`{|}~-]/.test(ch);
+    const isUnicodeAtext = (ch) => {
+        if (!smtpUTF8)
+            return false;
+        // Disallow obvious separators and specials used by the parser
+        if (ch === '.' || ch === ' ' || ch === '"' || ch === '\\' || ch === '@')
+            return false;
+        // Disallow whitespace/control
+        if (/\s/u.test(ch))
+            return false;
+        // Allow Unicode Letters, Marks, Numbers and Symbols (e.g., emoji)
+        return /[\p{L}\p{N}\p{M}\p{S}]/u.test(ch);
+    };
+    let lastWasDot = false; // disallow consecutive or leading/trailing dots anywhere
+    let inQ = false; // inside a quoted token
+    let qDepth = 0; // quote nesting depth (>=1 when inside outer quotes)
+    let escQ = false; // backslash escape inside quotes
+    let needDotAfterQuoted = false; // require a dot right after a quoted token if not at end
+    for (let i = 0; i < local.length; i++) {
+        const c = local[i];
+        // If we just closed a quoted token, the very next char must be a dot
+        if (!inQ && needDotAfterQuoted) {
+            if (c !== '.')
+                return false;
+            needDotAfterQuoted = false;
+            lastWasDot = true;
+            continue;
+        }
+        if (inQ) {
+            if (escQ) {
+                // After a backslash, allow any non-newline character (broader under SMTPUTF8)
+                if (/\r|\n/.test(c))
+                    return false;
+                escQ = false;
+                continue;
+            }
+            if (c === '\\') {
+                escQ = true;
+                continue;
+            }
+            if (c === '"') {
+                // Support nested unescaped quotes within a quoted token.
+                // Only close the quoted token when depth returns to 0 and we're at end-of-local
+                // or the next character is a dot (separator between tokens).
+                if (qDepth > 1) {
+                    qDepth -= 1;
+                    lastWasDot = false;
+                    continue;
+                }
+                // qDepth === 1: decide whether to close or to start nesting
+                if (i + 1 === local.length || local[i + 1] === '.') {
+                    // this quote closes the quoted token
+                    inQ = false;
+                    qDepth = 0;
+                    // require a dot if not at end
+                    if (i + 1 < local.length)
+                        needDotAfterQuoted = true;
+                    lastWasDot = false;
+                    continue;
+                }
+                else {
+                    // start a nested quote level
+                    qDepth += 1; // becomes 2
+                    lastWasDot = false;
+                    continue;
+                }
+            }
+            // Inside quotes: allow ASCII VCHAR and space by default; with SMTPUTF8 allow any char except control newlines
+            if (smtpUTF8) {
+                if (/\r|\n/.test(c))
+                    return false;
+            }
+            else {
+                const code = c.charCodeAt(0);
+                if (code < 0x20 || code > 0x7E)
+                    return false;
+            }
+            // Dots inside quoted string are allowed freely
+            continue;
+        }
+        // outside quotes
+        if (c === '"') {
+            // quotes can only start at token boundaries (start or right after a dot)
+            if (i > 0 && !lastWasDot)
+                return false;
+            inQ = true;
+            qDepth = 1;
+            escQ = false;
+            lastWasDot = false;
+            continue;
+        }
+        if (c === '.') {
+            if (i === 0 || lastWasDot)
+                return false; // leading or consecutive dot
+            lastWasDot = true;
+            continue;
+        }
+        if (c === ' ')
+            return false; // no spaces outside quotes
+        // must be atext outside quotes
+        if (!(isAsciiAtext(c) || isUnicodeAtext(c)))
+            return false;
+        lastWasDot = false;
+    }
+    if (inQ || qDepth !== 0 || escQ)
+        return false; // unbalanced quotes or dangling escape
+    if (lastWasDot)
+        return false; // trailing dot
+    // Validate domain
+    const labelRe = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?$/;
+    const ipv4Re = /^(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$/;
+    const ipv6Re = /^IPv6:(?:[A-Fa-f0-9:]+)$/; // coarse check; detailed covered by overall tests
+    if (domain.startsWith('[') && domain.endsWith(']')) {
+        const literal = domain.slice(1, -1);
+        if (ipv4Re.test(literal))
+            return true;
+        if (ipv6Re.test(literal))
+            return true; // accept canonical IPv6 forms used in tests
+        return false;
+    }
+    const parts = domain.split('.');
+    if (parts.some(p => p.length === 0))
+        return false;
+    for (const p of parts) {
+        if (!labelRe.test(p))
+            return false;
+    }
+    return true;
+}

package/dist/validations/isEmpty.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Checks whether a given string is empty or consists only of whitespace.
+ *
+ * Trims the input string and returns true if the resulting length is 0,
+ * indicating that the string is either empty or contains only whitespace characters.
+ *
+ * @param {string} str - The string to check.
+ * @returns {boolean} True if the string is empty or whitespace only, false otherwise.
+ */
+export declare function isEmpty(str: string): boolean;

package/dist/validations/isEmpty.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Checks whether a given string is empty or consists only of whitespace.
+ *
+ * Trims the input string and returns true if the resulting length is 0,
+ * indicating that the string is either empty or contains only whitespace characters.
+ *
+ * @param {string} str - The string to check.
+ * @returns {boolean} True if the string is empty or whitespace only, false otherwise.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmpty = isEmpty;
+function isEmpty(str) {
+    return str.trim().length === 0;
+}

package/dist/validations/isHexColor.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks if the input string is a valid hex color (e.g., "#fff", "#ffffff", "fff", "ffffff").
+ *
+ * @param color - The string to validate.
+ * @returns True if the string is a valid hex color, false otherwise.
+ */
+export declare function isHexColor(text: string): boolean;

package/dist/validations/isHexColor.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHexColor = isHexColor;
+/**
+ * Checks if the input string is a valid hex color (e.g., "#fff", "#ffffff", "fff", "ffffff").
+ *
+ * @param color - The string to validate.
+ * @returns True if the string is a valid hex color, false otherwise.
+ */
+function isHexColor(text) {
+    if (typeof text !== 'string' || text.length === 0) {
+        return false;
+    }
+    return /^#?([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/.test(text.trim());
+}