@spudlabs/guardis 0.4.0

package/esm/src/helpers/strings.helpers.js

@@ -0,0 +1,47 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// MIT License
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+const CAPITALIZED_WORD_REGEXP = /\p{Lu}\p{Ll}+/u; // e.g. Apple
+const ACRONYM_REGEXP = /\p{Lu}+(?=(\p{Lu}\p{Ll})|\P{L}|\b)/u; // e.g. ID, URL, handles an acronym followed by a capitalized word e.g. HTMLElement
+const LOWERCASED_WORD_REGEXP = /(\p{Ll}+)/u; // e.g. apple
+const ANY_LETTERS = /\p{L}+/u; // will match any sequence of letters, including in languages without a concept of upper/lower case
+const DIGITS_REGEXP = /\p{N}+/u; // e.g. 123
+const WORD_OR_NUMBER_REGEXP = new RegExp(`${CAPITALIZED_WORD_REGEXP.source}|${ACRONYM_REGEXP.source}|${LOWERCASED_WORD_REGEXP.source}|${ANY_LETTERS.source}|${DIGITS_REGEXP.source}`, "gu");
+export function splitToWords(input) {
+    return input.match(WORD_OR_NUMBER_REGEXP) ?? [];
+}
+export function capitalizeWord(word) {
+    return word ? word[0].toUpperCase() + word.slice(1).toLowerCase() : word;
+}
+/**
+ * Converts a string into PascalCase.
+ *
+ * @example Usage
+ * ```ts
+ * import { toPascalCase } from "@std/text/to-pascal-case";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toPascalCase("deno is awesome"), "DenoIsAwesome");
+ * ```
+ *
+ * @param input The string that is going to be converted into PascalCase
+ * @returns The string as PascalCase
+ */
+export function toPascalCase(input) {
+    input = input.trim();
+    return splitToWords(input).map(capitalizeWord).join("");
+}

package/esm/src/introspect.d.ts

@@ -0,0 +1,36 @@
+import type { StandardSchemaV1 } from "../specs/standard-schema-spec.v1.js";
+import type { Context, Parser, Predicate, TypeGuard } from "./types.js";
+/** Base internal metadata attached to type guards */
+export type GuardMeta<T> = {
+    _: {
+        name: string | undefined;
+        parser: Parser<T>;
+    };
+};
+/** Extended metadata for guards with context-aware validation */
+export type GuardWithContext<T> = GuardMeta<T> & {
+    _: {
+        context: (value: unknown, ctx?: Context) => StandardSchemaV1.Result<T>;
+    };
+};
+/**
+ * Type guard that checks if a given guard object contains meta information.
+ *
+ * Specifically, it verifies that the guard has an underscore (`_`) property,
+ * which is an object containing a `name` (string or undefined) and a `parser` function.
+ */
+export declare const hasMeta: <T1>(guard: Predicate<T1> | TypeGuard<T1>) => guard is typeof guard & GuardMeta<T1>;
+/**
+ * Checks if a guard has a defined name for error messaging.
+ * Returns true only if the guard has meta and a truthy name string.
+ */
+export declare const hasName: <T1>(guard: Predicate<T1> | TypeGuard<T1>) => guard is typeof guard & GuardMeta<T1> & {
+    _: {
+        name: string;
+    };
+};
+/**
+ * Checks if a guard has context-aware validation support for path tracking.
+ */
+export declare const hasContext: <T1>(guard: Predicate<T1> | TypeGuard<T1>) => guard is typeof guard & GuardWithContext<T1>;
+//# sourceMappingURL=introspect.d.ts.map

package/esm/src/introspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"introspect.d.ts","sourceRoot":"","sources":["../../src/src/introspect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AAC5E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAExE,qDAAqD;AACrD,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IACzB,CAAC,EAAE;QACD,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;QACzB,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;KACnB,CAAC;CACH,CAAC;AAEF,iEAAiE;AACjE,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG;IAC/C,CAAC,EAAE;QACD,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,OAAO,KAAK,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;KACxE,CAAC;CACH,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAAI,EAAE,EACxB,OAAO,SAAS,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC,KACnC,KAAK,IAAI,OAAO,KAAK,GAAG,SAAS,CAAC,EAAE,CAItC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,OAAO,GAAI,EAAE,EACxB,OAAO,SAAS,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC,KACnC,KAAK,IAAI,OAAO,KAAK,GAAG,SAAS,CAAC,EAAE,CAAC,GAAG;IAAE,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CAE/D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,GAAI,EAAE,EAC3B,OAAO,SAAS,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC,KACnC,KAAK,IAAI,OAAO,KAAK,GAAG,gBAAgB,CAAC,EAAE,CAG7C,CAAC"}

package/esm/src/introspect.js

@@ -0,0 +1,25 @@
+/**
+ * Type guard that checks if a given guard object contains meta information.
+ *
+ * Specifically, it verifies that the guard has an underscore (`_`) property,
+ * which is an object containing a `name` (string or undefined) and a `parser` function.
+ */
+export const hasMeta = (guard) => {
+    return "_" in guard && !!guard._ &&
+        typeof guard._ === "object" && "parser" in guard._ &&
+        typeof guard._.parser === "function";
+};
+/**
+ * Checks if a guard has a defined name for error messaging.
+ * Returns true only if the guard has meta and a truthy name string.
+ */
+export const hasName = (guard) => {
+    return hasMeta(guard) && typeof guard._.name === "string" && guard._.name.length > 0;
+};
+/**
+ * Checks if a guard has context-aware validation support for path tracking.
+ */
+export const hasContext = (guard) => {
+    return hasMeta(guard) && "context" in guard._ &&
+        typeof guard._.context === "function";
+};

package/esm/src/modules/async.d.ts

@@ -0,0 +1,27 @@
+import type { TypeGuard } from "../types.js";
+/**
+ * Returns true if input is an async function.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export declare const isAsyncFunction: TypeGuard<(...args: unknown[]) => Promise<unknown>>;
+/**
+ * Returns true if input is a Promise.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export declare const isPromise: TypeGuard<Promise<unknown>>;
+/**
+ * Returns true if input is Promise-like (i.e. has a `then` method).
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export declare const isPromiseLike: TypeGuard<PromiseLike<unknown>>;
+/**
+ * Returns true if input is thenable (i.e. has a `then` method).
+ * Alias for isPromiseLike.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export declare const isThenable: TypeGuard<PromiseLike<unknown>>;
+//# sourceMappingURL=async.d.ts.map

package/esm/src/modules/async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../../../src/src/modules/async.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAS/E,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC,CAGjD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,SAAS,CAAC,WAAW,CAAC,OAAO,CAAC,CAazD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,iCAAgB,CAAC"}

package/esm/src/modules/async.js

@@ -0,0 +1,38 @@
+import { createTypeGuard } from "../guard.js";
+/**
+ * Returns true if input is an async function.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isAsyncFunction = createTypeGuard("async function", (t) => {
+    return typeof t === "function" && t.constructor.name === "AsyncFunction"
+        ? t
+        : null;
+});
+/**
+ * Returns true if input is a Promise.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isPromise = createTypeGuard("Promise", (t) => (t instanceof Promise ? t : null));
+/**
+ * Returns true if input is Promise-like (i.e. has a `then` method).
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isPromiseLike = createTypeGuard("PromiseLike", (t) => {
+    if (t &&
+        typeof t === "object" &&
+        "then" in t &&
+        typeof t.then === "function") {
+        return t;
+    }
+    return null;
+});
+/**
+ * Returns true if input is thenable (i.e. has a `then` method).
+ * Alias for isPromiseLike.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isThenable = isPromiseLike; // alias

package/esm/src/modules/http.branded.d.ts

@@ -0,0 +1,42 @@
+import type { Brand } from "../brand.js";
+import type { TypeGuard } from "../types.js";
+/**
+ * Represents a branded type for an IPv4 address.
+ * This type ensures that a string is explicitly marked as an "IPv4"
+ * to provide additional type safety and clarity in the codebase.
+ */
+export type IPv4 = Brand<string, "IPv4">;
+/**
+ * Determines if a given string is a valid IPv4 address.
+ *
+ * This function extends the `isString` validator to include additional checks
+ * for IPv4 addresses. It ensures that the input string:
+ * - Matches the `ipv4Regex` pattern.
+ * - Each octet is between 0 and 255.
+ */
+export declare const isIpv4: TypeGuard<IPv4>;
+/**
+ * Represents a branded type for an IPv6 address.
+ * This type ensures that a string is explicitly marked as an "IPv6"
+ */
+export type IPv6 = Brand<string, "IPv6">;
+/**
+ * Determines if a given string is a valid IPv6 address.
+ *
+ * This function extends the `isString` validator to include additional checks
+ * for IPv6 addresses. It ensures that the input string:
+ * - Has a length of 45 characters or less.
+ * - Matches the `ipv6Regex` pattern.
+ */
+export declare const isIpv6: TypeGuard<IPv6>;
+/**
+ * Represents a branded type for an IP address, which can be either
+ * an IPv4 or IPv6 address.
+ */
+export type IPAddress = IPv4 | IPv6;
+/**
+ * Type guard that checks if a value is either a valid IPv4 or IPv6 address.
+ */
+export declare const isIpAddress: TypeGuard<IPAddress>;
+export { isNativeURL, isRequest, isResponse } from "./http.js";
+//# sourceMappingURL=http.branded.d.ts.map

package/esm/src/modules/http.branded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.branded.d.ts","sourceRoot":"","sources":["../../../src/src/modules/http.branded.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C;;;;GAIG;AACH,MAAM,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEzC;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,EAAc,SAAS,CAAC,IAAI,CAAC,CAAC;AAEjD;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEzC;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,EAAc,SAAS,CAAC,IAAI,CAAC,CAAC;AAEjD;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,IAAI,CAAC;AAEpC;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,CAAC,SAAS,CAAqB,CAAC;AAEnE,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC"}

package/esm/src/modules/http.branded.js

@@ -0,0 +1,24 @@
+import { isIpv4 as _isIpv4, isIpv6 as _isIpv6 } from "./http.js";
+/**
+ * Determines if a given string is a valid IPv4 address.
+ *
+ * This function extends the `isString` validator to include additional checks
+ * for IPv4 addresses. It ensures that the input string:
+ * - Matches the `ipv4Regex` pattern.
+ * - Each octet is between 0 and 255.
+ */
+export const isIpv4 = _isIpv4;
+/**
+ * Determines if a given string is a valid IPv6 address.
+ *
+ * This function extends the `isString` validator to include additional checks
+ * for IPv6 addresses. It ensures that the input string:
+ * - Has a length of 45 characters or less.
+ * - Matches the `ipv6Regex` pattern.
+ */
+export const isIpv6 = _isIpv6;
+/**
+ * Type guard that checks if a value is either a valid IPv4 or IPv6 address.
+ */
+export const isIpAddress = isIpv4.or(isIpv6);
+export { isNativeURL, isRequest, isResponse } from "./http.js";

package/esm/src/modules/http.d.ts

@@ -0,0 +1,46 @@
+import type { TypeGuard } from "../types.js";
+/**
+ * Returns true if input is an instance of the native URL
+ * class.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export declare const isNativeURL: TypeGuard<URL>;
+/**
+ * Returns true if input is an instance of the native Request
+ * class.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export declare const isRequest: TypeGuard<Request>;
+/**
+ * Returns true if input is an instance of the native Response
+ * class.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export declare const isResponse: TypeGuard<Response>;
+/**
+ * Determines if a given string is a valid IPv4 address.
+ *
+ * This function extends the `isString` validator to include additional checks
+ * for IPv4 addresses. It ensures that the input string:
+ * - Matches the `ipv4Regex` pattern.
+ * - Each octet is between 0 and 255.
+ */
+export declare const isIpv4: TypeGuard<string>;
+/**
+ * Determines if a given string is a valid IPv6 address.
+ *
+ * This function extends the `isString` validator to include additional checks
+ * for IPv6 addresses. It ensures that the input string:
+ * - Has a length of 45 characters or less.
+ * - Matches the `ipv6Regex` pattern.
+ */
+export declare const isIpv6: TypeGuard<string>;
+/**
+ * Type guard that checks if a given string is either a valid IPv4 or IPv6 address.
+ * Combines the `isIpv4` and `isIpv6` type guards using a logical OR operation.
+ */
+export declare const isIpAddress: TypeGuard<string>;
+//# sourceMappingURL=http.d.ts.map

package/esm/src/modules/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../../src/src/modules/http.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,CAAC,GAAG,CAGtC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,SAAS,CAAC,OAAO,CAGxC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,SAAS,CAAC,QAAQ,CAG1C,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,EAAE,SAAS,CAAC,MAAM,CAiBpC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,EAAE,SAAS,CAAC,MAAM,CAKpC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,CAAC,MAAM,CAAqB,CAAC"}

package/esm/src/modules/http.js

@@ -0,0 +1,59 @@
+import { createTypeGuard } from "../guard.js";
+import { IPV4_REGEX, IPV6_REGEX } from "../helpers/http.helpers.js";
+/**
+ * Returns true if input is an instance of the native URL
+ * class.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isNativeURL = createTypeGuard("URL", (t) => t instanceof URL ? t : null);
+/**
+ * Returns true if input is an instance of the native Request
+ * class.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isRequest = createTypeGuard("Request", (t) => t instanceof Request ? t : null);
+/**
+ * Returns true if input is an instance of the native Response
+ * class.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isResponse = createTypeGuard("Response", (t) => t instanceof Response ? t : null);
+/**
+ * Determines if a given string is a valid IPv4 address.
+ *
+ * This function extends the `isString` validator to include additional checks
+ * for IPv4 addresses. It ensures that the input string:
+ * - Matches the `ipv4Regex` pattern.
+ * - Each octet is between 0 and 255.
+ */
+export const isIpv4 = createTypeGuard("IPv4", (v) => {
+    if (typeof v !== "string" || v.length > 15)
+        return null; // Max IPv4 length is 15 characters
+    const match = v.match(IPV4_REGEX);
+    if (match && match.slice(1).every((octet) => {
+        const num = parseInt(octet, 10);
+        return num >= 0 && num <= 255 && octet === num.toString();
+    })) {
+        return v;
+    }
+    return null;
+});
+/**
+ * Determines if a given string is a valid IPv6 address.
+ *
+ * This function extends the `isString` validator to include additional checks
+ * for IPv6 addresses. It ensures that the input string:
+ * - Has a length of 45 characters or less.
+ * - Matches the `ipv6Regex` pattern.
+ */
+export const isIpv6 = createTypeGuard("IPv6", (v) => {
+    return typeof v === "string" && v.length <= 45 && IPV6_REGEX.test(v) ? v : null;
+});
+/**
+ * Type guard that checks if a given string is either a valid IPv4 or IPv6 address.
+ * Combines the `isIpv4` and `isIpv6` type guards using a logical OR operation.
+ */
+export const isIpAddress = isIpv4.or(isIpv6);

package/esm/src/modules/strings.branded.d.ts

@@ -0,0 +1,185 @@
+/**
+ * This module provides type guards for common string patterns.
+ */
+import type { Brand } from "../brand.js";
+import type { TypeGuard } from "../types.js";
+/**
+ * Represents a branded type for an email address.
+ * This type ensures that a string is explicitly marked as an "Email"
+ * to provide additional type safety and clarity in the codebase.
+ */
+export type Email = Brand<string, "Email">;
+/**
+ * Type guard for validating whether a given value is a valid email string. Uses a
+ * branded type to ensure type safety and distinguish it from other strings.
+ *
+ * Uses the `EMAIL_REGEX` to test if the input is a string that matches the email format.
+ *
+ * @param t - The value to test for email validity.
+ * @returns Boolean indicating whether the input is a valid email.
+ */
+export declare const isEmail: TypeGuard<Email>;
+/**
+ * Represents a branded type for an International Phone number.
+ * This type ensures that a string is explicitly marked as an "InternationalPhone"
+ * to provide additional type safety and clarity in the codebase.
+ */
+export type InternationalPhone = Brand<string, "InternationalPhone">;
+/**
+ * Type guard for validating whether a given value is a valid international phone number string.
+ * Uses a branded type to ensure type safety and distinguish it from other strings.
+ *
+ * Uses the `INT_PHONE_REGEX` to test if the input is a string that matches the international phone number format.
+ *
+ * @param t - The value to test for international phone number validity.
+ * @returns Boolean indicating whether the input is a valid international phone number.
+ */
+export declare const isInternationalPhone: TypeGuard<InternationalPhone>;
+/**
+ * Represents a branded type for a US Phone number.
+ * This type ensures that a string is explicitly marked as a "USPhone"
+ * to provide additional type safety and clarity in the codebase.
+ */
+export type USPhone = Brand<string, "USPhone">;
+/**
+ * Type guard for validating whether a given value is a valid US phone number string.
+ * Uses a branded type to ensure type safety and distinguish it from other strings.
+ *
+ * Uses the `US_PHONE_REGEX` to test if the input is a string that matches the US phone number format.
+ *
+ * @param t - The value to test for US phone number validity.
+ * @returns Boolean indicating whether the input is a valid US phone number.
+ */
+export declare const isUSPhone: TypeGuard<USPhone>;
+/**
+ * Represents a branded type for a phone number.
+ * This type ensures that a string is explicitly marked as a "PhoneNumber"
+ * to provide additional type safety and clarity in the codebase.
+ */
+export type PhoneNumber = USPhone | InternationalPhone;
+/**
+ * Type guard for validating whether a given value is a valid phone number string,
+ * either in international or US format. Uses a branded type to ensure type safety
+ * and distinguish it from other strings.
+ *
+ * Uses both `INT_PHONE_REGEX` and `US_PHONE_REGEX` to test if the input is a string
+ * that matches either format.
+ *
+ * @param t - The value to test for phone number validity.
+ * @returns Boolean indicating whether the input is a valid phone number.
+ */
+export declare const isPhoneNumber: TypeGuard<PhoneNumber>;
+/**
+ * Represents a branded type for a UUIDv4.
+ * This type ensures that a string is explicitly marked as a "UUIDv4"
+ * to provide additional type safety and clarity in the codebase.
+ */
+export type UUIDv4 = Brand<string, "UUIDv4">;
+/**
+ * Type guard for validating whether a given value is a valid UUIDv4 string.
+ * Uses a branded type to ensure type safety and distinguish it from other strings.
+ *
+ * Uses a regex pattern to test if the input is a string that matches the UUIDv4 format.
+ *
+ * @param t - The value to test for UUIDv4 validity.
+ * @returns Boolean indicating whether the input is a valid UUIDv4.
+ */
+export declare const isUUIDv4: TypeGuard<UUIDv4>;
+/**
+ * Represents a branded type for a UUIDv7.
+ * This type ensures that a string is explicitly marked as a "UUIDv7"
+ * to provide additional type safety and clarity in the codebase.
+ */
+export type UUIDv7 = Brand<string, "UUIDv7">;
+/**
+ * Type guard for validating whether a given value is a valid UUIDv7 string.
+ * Uses a branded type to ensure type safety and distinguish it from other strings.
+ *
+ * Uses a regex pattern to test if the input is a string that matches the UUIDv7 format.
+ *
+ * @param t - The value to test for UUIDv7 validity.
+ * @returns Boolean indicating whether the input is a valid UUIDv7.
+ */
+export declare const isUUIDv7: TypeGuard<UUIDv7>;
+/**
+ * Represents a branded type for a comma-delimited string.
+ * This type ensures that a string is explicitly marked as a "CommaDelimitedString"
+ * to provide additional type safety and clarity in the codebase.
+ */
+export type CommaDelimitedString = Brand<string, "CommaDelimitedString">;
+/**
+ * Type guard for validating whether a given value is a valid comma-delimited string.
+ * Uses a branded type to ensure type safety and distinguish it from other strings.
+ *
+ * Uses a regex pattern to test if the input is a string that matches the comma-delimited format.
+ *
+ * @param t - The value to test for comma-delimited string validity.
+ * @returns Boolean indicating whether the input is a valid comma-delimited string.
+ */
+export declare const isCommaDelimited: TypeGuard<CommaDelimitedString>;
+/**
+ * Represents a branded type for a period-delimited string.
+ * This type ensures that a string is explicitly marked as a "PeriodDelimitedString"
+ * to provide additional type safety and clarity in the codebase.
+ */
+export type PeriodDelimitedString = Brand<string, "PeriodDelimitedString">;
+/**
+ * Type guard for validating whether a given value is a valid period-delimited string.
+ * Uses a branded type to ensure type safety and distinguish it from other strings.
+ *
+ * Uses a regex pattern to test if the input is a string that matches the period-delimited format.
+ *
+ * @param t - The value to test for period-delimited string validity.
+ * @returns Boolean indicating whether the input is a valid period-delimited string.
+ */
+export declare const isPeriodDelimited: TypeGuard<PeriodDelimitedString>;
+/**
+ * Represents a branded type for a comma-delimited string of integers.
+ * This type ensures that a string is explicitly marked as a "CommaDelimitedIntegers"
+ * to provide additional type safety and clarity in the codebase.
+ */
+export type CommaDelimitedIntegers = Brand<string, "CommaDelimitedIntegers">;
+/**
+ * A type guard function that checks if a given string matches the pattern of a comma-delimited
+ * string of integers.
+ *
+ * - Matches one or more integers (positive or negative) separated by commas.
+ * - Does not allow empty values between commas.
+ * - Does not allow any whitespace (between digits or after commas).
+ * - Does not match empty strings.
+ *
+ * @param t - The value to test for comma-delimited integers validity.
+ * @returns Boolean indicating whether the input is a valid comma-delimited string of integers.
+ *
+ * @example
+ * - Valid: "1,2,3", "123,456,789", "-1,2,-3"
+ * - Invalid: "1,,3", "1, 2, 3", "1 2,3", "", "1.5,2"
+ */
+export declare const isCommaDelimitedIntegers: TypeGuard<CommaDelimitedIntegers>;
+/**
+ * Represents a branded type for a comma-delimited string of numbers.
+ * This type ensures that a string is explicitly marked as a "CommaDelimitedNumbers"
+ * to provide additional type safety and clarity in the codebase.
+ */
+export type CommaDelimitedNumbers = Brand<string, "CommaDelimitedNumbers">;
+/**
+ * A type guard function that checks if a given string matches the pattern of a comma-delimited
+ * string of numbers.
+ *
+ * - Matches one or more numbers (integers, floats, decimals, or percentages) separated by commas.
+ * - Supports positive and negative numbers.
+ * - Supports decimal values (e.g., "1.5", "3.14159").
+ * - Supports percentage values (e.g., "50%", "12.5%").
+ * - Does not allow empty values between commas.
+ * - Does not allow any whitespace (between digits or after commas).
+ * - Does not match empty strings.
+ *
+ * @param t - The value to test for comma-delimited numbers validity.
+ * @returns Boolean indicating whether the input is a valid comma-delimited string of numbers.
+ *
+ * @example
+ * - Valid: "1,2,3", "1.5,2.5,3.5", "-1.5,2,3.14", "50%,75%,100%", "1.5%,2,3%"
+ * - Invalid: "1,,3", "1, 2, 3", "1 2,3", "", "1..5,2", "1.5.5,2"
+ */
+export declare const isCommaDelimitedNumbers: TypeGuard<CommaDelimitedNumbers>;
+//# sourceMappingURL=strings.branded.d.ts.map

package/esm/src/modules/strings.branded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings.branded.d.ts","sourceRoot":"","sources":["../../../src/src/modules/strings.branded.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAc7C;;;;GAIG;AACH,MAAM,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,EAAe,SAAS,CAAC,KAAK,CAAC,CAAC;AAEpD;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,KAAK,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;AAErE;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,EAA4B,SAAS,CAAC,kBAAkB,CAAC,CAAC;AAE3F;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AAE/C;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,EAAiB,SAAS,CAAC,OAAO,CAAC,CAAC;AAE1D;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,kBAAkB,CAAC;AAEvD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,EAAqB,SAAS,CAAC,WAAW,CAAC,CAAC;AAEtE;;;;GAIG;AACH,MAAM,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;AAE7C;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,EAAgB,SAAS,CAAC,MAAM,CAAC,CAAC;AAEvD;;;;GAIG;AACH,MAAM,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;AAE7C;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,EAAgB,SAAS,CAAC,MAAM,CAAC,CAAC;AAEvD;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,KAAK,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;AAEzE;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,EAAwB,SAAS,CAAC,oBAAoB,CAAC,CAAC;AAErF;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,KAAK,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;AAE3E;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,EAAyB,SAAS,CAAC,qBAAqB,CAAC,CAAC;AAExF;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,KAAK,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;AAE7E;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,wBAAwB,EAAgC,SAAS,CAAC,sBAAsB,CAAC,CAAC;AAEvG;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,KAAK,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;AAE3E;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,uBAAuB,EAA+B,SAAS,CAAC,qBAAqB,CAAC,CAAC"}