@temboplus/frontend-core 0.1.0

package/esm/src/models/phone_number/antd_validator.js

@@ -0,0 +1,90 @@
+import { PhoneNumber } from "./phone_number.js";
+/**
+ * Validates a Tanzanian phone number according to specified format rules.
+ * This validator is designed for Ant Design Form components and performs the following validations:
+ * 1. Required field validation (if specified in rules)
+ * 2. Format validation for valid Tanzanian phone numbers using TZ_PHONE_NUMBER_REGEX
+ *
+ * The validator accepts phone numbers in the following formats:
+ * Format 1: With prefix
+ * - Starting with 255, 0, or +255
+ * - Followed by valid operator codes:
+ *   • Vodacom: 74, 75, 76, 78, 79
+ *   • Tigo: 65, 67, 71
+ *   • Airtel: 68, 69, 77
+ *   • Halotel: 61, 62
+ * - Followed by 7 digits
+ *
+ * Format 2: Without prefix
+ * - Starting directly with operator code (listed above)
+ * - Followed by 7 digits
+ *
+ * @param {RuleObject} rule - Ant Design rule object containing validation rules
+ * @param {string | null | undefined} value - The phone number to validate
+ * @returns {Promise<void>} Resolves if validation passes, rejects with Error if validation fails
+ * @throws {Error} Throws an error with a descriptive message for validation failures:
+ *  - "Phone number is required." - When field is required but empty/null/undefined
+ *  - "Invalid phone number format." - When value doesn't match expected TZ phone number format
+ *
+ * @example
+ * // Usage in Ant Design form rules:
+ * const rules = [
+ *   {
+ *     required: true,
+ *     validator: PHONENUMBER_VALIDATOR
+ *   }
+ * ];
+ *
+ * // Valid inputs:
+ * // "+255742345678" -> International format with plus (Vodacom)
+ * // "255652345678"  -> International format without plus (Tigo)
+ * // "0712345678"    -> Local format with leading zero (Tigo)
+ * // "652345678"     -> Local format without prefix (Tigo)
+ *
+ * // Invalid inputs:
+ * // "+255722345678" -> Invalid operator code (72)
+ * // "652345"        -> Too short
+ * // "6523456789"    -> Too long
+ * // "abc65234567"   -> Non-numeric characters
+ * // ""              -> Empty when required
+ * // undefined       -> Missing when required
+ * // null           -> Null when required
+ *
+ * @notes
+ * The validator uses TZ_PHONE_NUMBER_REGEX which matches:
+ * ^(?:255|0|\+255)(74|75|76|78|79|68|69|71|65|67|77|62|61)\d{7}$|^(?:74|75|76|78|79|68|69|71|65|67|77|62|61)\d{7}$
+ *
+ * This breaks down to:
+ * ^                   -> Start of string
+ * (?:255|0|\+255)    -> Country code group: 255, 0, or +255
+ * (                   -> Start operator code group
+ *   74|75|76|78|79   -> Vodacom prefixes
+ *   |68|69|71        -> Tigo prefixes
+ *   |65|67|77        -> Airtel prefixes
+ *   |62|61           -> Halotel prefixes
+ * )                   -> End operator code group
+ * \d{7}              -> Exactly 7 digits
+ * $                   -> End of string
+ * |                   -> OR
+ * ^                   -> Start of string (alternative format)
+ * (same operator codes as above)
+ * \d{7}              -> Exactly 7 digits
+ * $                   -> End of string
+ */
+export const TZ_PHONE_NUMBER_REGEX = /^(?:255|0|\+255)(74|75|76|78|79|68|69|71|65|67|77|62|61)\d{7}$|^(?:74|75|76|78|79|68|69|71|65|67|77|62|61)\d{7}$/;
+export const PHONENUMBER_VALIDATOR = (rule, value) => {
+    const phoneString = value?.toString().trim();
+    // If field is empty/undefined/null
+    if (!phoneString) {
+        // Only throw if the field is required
+        if (rule.required) {
+            return Promise.reject(new Error("Phone number is required."));
+        }
+        // If field is not required and empty, validation passes
+        return Promise.resolve(undefined);
+    }
+    const phone = PhoneNumber.from(phoneString);
+    if (phone)
+        return Promise.resolve(phone);
+    return Promise.reject(new Error("Invalid phone number format."));
+};

package/esm/src/models/phone_number/antdvalidator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"antdvalidator.test.d.ts","sourceRoot":"","sources":["../../../../src/src/models/phone_number/antdvalidator.test.ts"],"names":[],"mappings":""}

package/esm/src/models/phone_number/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./antd_validator.js";
+export * from "./phone_number.js";
+export * from "./telecom.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/src/models/phone_number/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/src/models/phone_number/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC"}

package/esm/src/models/phone_number/index.js

@@ -0,0 +1,3 @@
+export * from "./antd_validator.js";
+export * from "./phone_number.js";
+export * from "./telecom.js";

package/esm/src/models/phone_number/phone_number.d.ts

@@ -0,0 +1,117 @@
+/**
+ * @fileoverview
+ *
+ * # Tanzania Phone Number Management System
+ *
+ * ## Problem Statement
+ * Tanzania's phone number system requires specific validation and formatting rules:
+ *
+ * 1. Phone numbers can be entered in multiple formats:
+ *    - International format: "+255712345678"
+ *    - Local format with country code: "255712345678"
+ *    - Local format with leading zero: "0712345678"
+ *    - Compact format: "712345678"
+ *
+ * 2. Valid numbers must:
+ *    - Have exactly 9 digits after removing prefixes
+ *    - Start with a valid telecom provider prefix
+ *    - Contain only numeric characters
+ *
+ * 3. Each telecom provider has specific prefixes:
+ *    - Vodacom: 71, 74, 75, etc.
+ *    - Airtel: 68, 69, etc.
+ *    - Tigo: 65, 67, etc.
+ *
+ * ## Solution
+ * The PhoneNumber class provides:
+ * 1. Parsing and validation of different input formats
+ * 2. Standardized storage in compact format
+ * 3. Formatting options for display and API use
+ * 4. Telecom provider identification
+ */
+import { type Telecom } from "./telecom.js";
+/**
+ * Enumeration for various mobile number formats.
+ * @enum {string}
+ */
+export declare enum MobileNumberFormat {
+    s255 = "255",// Mobile numbers prefixed with 255
+    sp255 = "+255",// Mobile numbers prefixed with +255
+    s0 = "0",// Mobile numbers prefixed with 0
+    none = ""
+}
+/**
+ * Represents a TZ phone number
+ */
+export declare class PhoneNumber {
+    /**
+     * Stores the phone number in a compact format excluding country code and the initial '0'.
+     */
+    compactNumber: string;
+    /**
+     * Constructs a new `PhoneNumber` instance.
+     *
+     * @param compactNumber - The phone number in a compact format (e.g., "712345678").
+     */
+    constructor(compactNumber: string);
+    /**
+     * Formats the compact phone number with the specified `MobileNumberFormat`.
+     *
+     * @param format - The desired phone number format (e.g., `+255` or `255`).
+     * @returns The phone number formatted as a string.
+     */
+    getNumberWithFormat(format: MobileNumberFormat): string;
+    /**
+     * Returns the formatted label of the phone number using the `s255` format.
+     *
+     * @returns The phone number label in `255` format.
+     */
+    get label(): string;
+    /**
+     * Derives the telecom details associated with the phone number by checking its prefix.
+     *
+     * @returns The `Telecom` object that matches the phone number prefix.
+     */
+    get telecom(): Telecom;
+    /**
+     * Creates a `PhoneNumber` instance from a given string.
+     *
+     * @param s - The input phone number string in various formats (e.g., "+255712345678", "0712345678").
+     * @returns A `PhoneNumber` instance if valid, otherwise `undefined`.
+     */
+    static from(s: string): PhoneNumber | undefined;
+    /**
+     * Checks if a string can be constructed into a valid phone number object.
+     * @param {string | undefined} input - The string to validate as a phone number.
+     * @returns {boolean} - Returns true if the input can be constructed into a valid phone number object,
+     *                     false if the input is undefined, empty, or cannot be parsed.
+     */
+    static canConstruct(input?: string | null): boolean;
+    /**
+     * Checks if an unknown value contains valid data to construct a PhoneNumber instance.
+     * Validates the structural integrity of the phone number object.
+     *
+     * @param {unknown} obj - The value to validate.
+     * @returns {obj is PhoneNumber} Type predicate indicating if the value has a valid phone number structure.
+     *
+     * @example
+     * const maybePhone = JSON.parse(someData);
+     * if (PhoneNumber.is(maybePhone)) {
+     *   // maybePhone is typed as PhoneNumber
+     *   console.log(maybePhone.label);
+     * }
+     *
+     * @remarks
+     * Validates:
+     * - Has required compactNumber property
+     * - compactNumber is a 9-digit string
+     * - Prefix matches a valid telecom provider
+     */
+    static is(obj: unknown): obj is PhoneNumber;
+    /**
+     * Checks the validity of the phone number data
+     * @returns true if the phone number information is available and valid
+     */
+    validate(): boolean;
+}
+//# sourceMappingURL=phone_number.d.ts.map

package/esm/src/models/phone_number/phone_number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phone_number.d.ts","sourceRoot":"","sources":["../../../../src/src/models/phone_number/phone_number.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAE,KAAK,OAAO,EAAkB,MAAM,cAAc,CAAC;AAE5D;;;GAGG;AACH,oBAAY,kBAAkB;IAC5B,IAAI,QAAQ,CAAE,mCAAmC;IACjD,KAAK,SAAS,CAAE,oCAAoC;IACpD,EAAE,MAAM,CAAE,iCAAiC;IAC3C,IAAI,KAAK;CACV;AAED;;GAEG;AACH,qBAAa,WAAW;IACtB;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;gBACS,aAAa,EAAE,MAAM;IAIjC;;;;;OAKG;IACH,mBAAmB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM;IAIvD;;;;OAIG;IACH,IAAI,KAAK,IAAI,MAAM,CAElB;IAED;;;;OAIG;IACH,IAAI,OAAO,IAAI,OAAO,CAMrB;IAED;;;;;OAKG;WACW,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAqCtD;;;;;OAKG;WACW,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO;IAW1D;;;;;;;;;;;;;;;;;;;OAmBG;WACW,EAAE,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,WAAW;IAYlD;;;OAGG;IACI,QAAQ,IAAI,OAAO;CAO3B"}

package/esm/src/models/phone_number/phone_number.js

@@ -0,0 +1,231 @@
+/**
+ * @fileoverview
+ *
+ * # Tanzania Phone Number Management System
+ *
+ * ## Problem Statement
+ * Tanzania's phone number system requires specific validation and formatting rules:
+ *
+ * 1. Phone numbers can be entered in multiple formats:
+ *    - International format: "+255712345678"
+ *    - Local format with country code: "255712345678"
+ *    - Local format with leading zero: "0712345678"
+ *    - Compact format: "712345678"
+ *
+ * 2. Valid numbers must:
+ *    - Have exactly 9 digits after removing prefixes
+ *    - Start with a valid telecom provider prefix
+ *    - Contain only numeric characters
+ *
+ * 3. Each telecom provider has specific prefixes:
+ *    - Vodacom: 71, 74, 75, etc.
+ *    - Airtel: 68, 69, etc.
+ *    - Tigo: 65, 67, etc.
+ *
+ * ## Solution
+ * The PhoneNumber class provides:
+ * 1. Parsing and validation of different input formats
+ * 2. Standardized storage in compact format
+ * 3. Formatting options for display and API use
+ * 4. Telecom provider identification
+ */
+import { telecomDetails } from "./telecom.js";
+/**
+ * Enumeration for various mobile number formats.
+ * @enum {string}
+ */
+export var MobileNumberFormat;
+(function (MobileNumberFormat) {
+    MobileNumberFormat["s255"] = "255";
+    MobileNumberFormat["sp255"] = "+255";
+    MobileNumberFormat["s0"] = "0";
+    MobileNumberFormat["none"] = "";
+})(MobileNumberFormat || (MobileNumberFormat = {}));
+/**
+ * Represents a TZ phone number
+ */
+export class PhoneNumber {
+    /**
+     * Constructs a new `PhoneNumber` instance.
+     *
+     * @param compactNumber - The phone number in a compact format (e.g., "712345678").
+     */
+    constructor(compactNumber) {
+        /**
+         * Stores the phone number in a compact format excluding country code and the initial '0'.
+         */
+        Object.defineProperty(this, "compactNumber", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.compactNumber = compactNumber;
+    }
+    /**
+     * Formats the compact phone number with the specified `MobileNumberFormat`.
+     *
+     * @param format - The desired phone number format (e.g., `+255` or `255`).
+     * @returns The phone number formatted as a string.
+     */
+    getNumberWithFormat(format) {
+        return `${format}${this.compactNumber}`;
+    }
+    /**
+     * Returns the formatted label of the phone number using the `s255` format.
+     *
+     * @returns The phone number label in `255` format.
+     */
+    get label() {
+        return this.getNumberWithFormat(MobileNumberFormat.s255);
+    }
+    /**
+     * Derives the telecom details associated with the phone number by checking its prefix.
+     *
+     * @returns The `Telecom` object that matches the phone number prefix.
+     */
+    get telecom() {
+        const id = this.compactNumber.substring(0, 2);
+        const result = Object.values(telecomDetails).find((e) => e.prefixes.includes(id));
+        return result;
+    }
+    /**
+     * Creates a `PhoneNumber` instance from a given string.
+     *
+     * @param s - The input phone number string in various formats (e.g., "+255712345678", "0712345678").
+     * @returns A `PhoneNumber` instance if valid, otherwise `undefined`.
+     */
+    static from(s) {
+        try {
+            const number = removeSpaces(s.trim());
+            if (number.length === 0)
+                return;
+            const isOnlyDigits = isOnlyDigitsOrPlus(number);
+            if (!isOnlyDigits)
+                return;
+            let compactNumber;
+            // Extract the compact number by removing country or local dialing prefixes.
+            if (number.startsWith("+255")) {
+                compactNumber = number.substring(4);
+            }
+            else if (number.startsWith("255")) {
+                compactNumber = number.substring(3);
+            }
+            else if (number.startsWith("0")) {
+                compactNumber = number.substring(1);
+            }
+            else {
+                compactNumber = number;
+            }
+            // Validate that the compact number length is correct.
+            if (compactNumber.length !== 9)
+                return;
+            // Check if the compact number matches any telecom provider prefix.
+            const id = compactNumber.substring(0, 2);
+            const telecom = Object.values(telecomDetails).find((e) => e.prefixes.includes(id));
+            if (!telecom)
+                return;
+            return new PhoneNumber(compactNumber);
+        }
+        catch (_) {
+            return;
+        }
+    }
+    /**
+     * Checks if a string can be constructed into a valid phone number object.
+     * @param {string | undefined} input - The string to validate as a phone number.
+     * @returns {boolean} - Returns true if the input can be constructed into a valid phone number object,
+     *                     false if the input is undefined, empty, or cannot be parsed.
+     */
+    static canConstruct(input) {
+        if (!input || typeof input !== "string")
+            return false;
+        const text = removeSpaces(input.trim());
+        if (text.length === 0)
+            return false;
+        const phone = PhoneNumber.from(text);
+        return phone !== undefined;
+    }
+    /**
+     * Checks if an unknown value contains valid data to construct a PhoneNumber instance.
+     * Validates the structural integrity of the phone number object.
+     *
+     * @param {unknown} obj - The value to validate.
+     * @returns {obj is PhoneNumber} Type predicate indicating if the value has a valid phone number structure.
+     *
+     * @example
+     * const maybePhone = JSON.parse(someData);
+     * if (PhoneNumber.is(maybePhone)) {
+     *   // maybePhone is typed as PhoneNumber
+     *   console.log(maybePhone.label);
+     * }
+     *
+     * @remarks
+     * Validates:
+     * - Has required compactNumber property
+     * - compactNumber is a 9-digit string
+     * - Prefix matches a valid telecom provider
+     */
+    static is(obj) {
+        if (!obj || typeof obj !== "object")
+            return false;
+        const maybePhone = obj;
+        // Check if compactNumber exists and is string
+        if (typeof maybePhone.compactNumber !== "string")
+            return false;
+        const compactNumber = maybePhone.compactNumber;
+        return PhoneNumber.canConstruct(compactNumber);
+    }
+    /**
+     * Checks the validity of the phone number data
+     * @returns true if the phone number information is available and valid
+     */
+    validate() {
+        try {
+            return PhoneNumber.canConstruct(this.compactNumber);
+        }
+        catch (_) {
+            return false;
+        }
+    }
+}
+/**
+ * Removes all whitespace characters from the given string.
+ *
+ * This function replaces all occurrences of spaces, tabs, and other
+ * whitespace characters (including multiple spaces) in the input string
+ * with an empty string, effectively removing them.
+ *
+ * @param {string} input - The input string from which spaces should be removed.
+ * @returns {string} A new string with all whitespace characters removed.
+ *
+ * @example
+ * removeSpaces("  Hello   World  ");    // Returns: "HelloWorld"
+ * removeSpaces("NoSpacesHere");         // Returns: "NoSpacesHere"
+ * removeSpaces("   ");                  // Returns: ""
+ */
+function removeSpaces(input) {
+    return input.replace(/\s+/g, "");
+}
+/**
+ * Checks if a given string contains only digits or a `+` prefix followed by digits.
+ *
+ * This function validates that the input string:
+ * - Can optionally start with a `+` sign.
+ * - Must have one or more digits after the optional `+`.
+ * - Does not contain any other characters besides digits and the `+` prefix.
+ *
+ * @param {string} input - The input string to validate.
+ * @returns {boolean} `true` if the string contains only digits or a `+` prefix followed by digits; otherwise, `false`.
+ *
+ * @example
+ * isOnlyDigitsOrPlus("12345");    // Returns: true
+ * isOnlyDigitsOrPlus("+12345");   // Returns: true
+ * isOnlyDigitsOrPlus("123a45");   // Returns: false
+ * isOnlyDigitsOrPlus("+");        // Returns: false
+ * isOnlyDigitsOrPlus("");         // Returns: false
+ */
+function isOnlyDigitsOrPlus(input) {
+    const digitWithPlusRegex = /^\+?\d+$/;
+    return digitWithPlusRegex.test(input);
+}

package/esm/src/models/phone_number/phone_number.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phone_number.test.d.ts","sourceRoot":"","sources":["../../../../src/src/models/phone_number/phone_number.test.ts"],"names":[],"mappings":""}

package/esm/src/models/phone_number/telecom.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Enumeration for telecom identifiers.
+ * @enum {string}
+ */
+export declare enum TelecomID {
+    vodacom = "vodacom",
+    airtel = "airtel",
+    tigo = "tigo",
+    halotel = "halotel"
+}
+/**
+ * Interface representing a telecom provider.
+ */
+export interface Telecom {
+    id: TelecomID;
+    prefixes: string[];
+    label: string;
+    company: string;
+    color: string;
+}
+/**
+ * Details for each telecom provider including prefixes and branding information.
+ */
+export declare const telecomDetails: Record<TelecomID, Telecom>;
+//# sourceMappingURL=telecom.d.ts.map

package/esm/src/models/phone_number/telecom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telecom.d.ts","sourceRoot":"","sources":["../../../../src/src/models/phone_number/telecom.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,SAAS;IACnB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,OAAO,YAAY;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,SAAS,CAAC;IACd,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CA6BrD,CAAC"}

package/esm/src/models/phone_number/telecom.js

@@ -0,0 +1,44 @@
+/**
+ * Enumeration for telecom identifiers.
+ * @enum {string}
+ */
+export var TelecomID;
+(function (TelecomID) {
+    TelecomID["vodacom"] = "vodacom";
+    TelecomID["airtel"] = "airtel";
+    TelecomID["tigo"] = "tigo";
+    TelecomID["halotel"] = "halotel";
+})(TelecomID || (TelecomID = {}));
+/**
+ * Details for each telecom provider including prefixes and branding information.
+ */
+export const telecomDetails = {
+    vodacom: {
+        id: TelecomID.vodacom,
+        prefixes: ["74", "75", "76"],
+        label: "Vodacom",
+        company: "M-Pesa",
+        color: "red",
+    },
+    airtel: {
+        id: TelecomID.airtel,
+        prefixes: ["78", "79", "68", "69"],
+        label: "Airtel",
+        company: "Airtel-Money",
+        color: "volcano",
+    },
+    tigo: {
+        id: TelecomID.tigo,
+        prefixes: ["71", "65", "67", "77"],
+        label: "Tigo",
+        company: "Tigo-Pesa",
+        color: "blue",
+    },
+    halotel: {
+        id: TelecomID.halotel,
+        prefixes: ["62", "61"],
+        label: "Halotel",
+        company: "Halo-Pesa",
+        color: "orange",
+    },
+};

package/esm/src/utils/id.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Generates a unique UUID (version 4).
+ * @returns {string} - A randomly generated UUID string.
+ */
+export declare function generateUniqueUUID(): string;
+/**
+ * Generates a UUID (version 5) based on the input string and a predefined namespace.
+ * @param {string} data - The input string to generate the UUID from.
+ * @returns {string} - A UUID string generated from the input string.
+ */
+export declare function generateUuidBasedOn(data: string): string;
+//# sourceMappingURL=id.d.ts.map

package/esm/src/utils/id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id.d.ts","sourceRoot":"","sources":["../../../src/src/utils/id.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAKD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD"}

package/esm/src/utils/id.js

@@ -0,0 +1,19 @@
+import { v4 as uuidv4 } from "uuid";
+import { v5 as uuidv5 } from "uuid";
+/**
+ * Generates a unique UUID (version 4).
+ * @returns {string} - A randomly generated UUID string.
+ */
+export function generateUniqueUUID() {
+    return uuidv4();
+}
+// Predefined namespace
+const NAMESPACE = uuidv5.DNS;
+/**
+ * Generates a UUID (version 5) based on the input string and a predefined namespace.
+ * @param {string} data - The input string to generate the UUID from.
+ * @returns {string} - A UUID string generated from the input string.
+ */
+export function generateUuidBasedOn(data) {
+    return uuidv5(data, NAMESPACE);
+}

package/esm/src/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./id.js";
+export * from "./time.js";
+export * from "./text.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/src/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC"}

package/esm/src/utils/index.js

@@ -0,0 +1,3 @@
+export * from "./id.js";
+export * from "./time.js";
+export * from "./text.js";

package/esm/src/utils/text.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Capitalizes the first letter of a string and converts the rest of the string to lowercase.
+ * @param {string} str - The input string.
+ * @returns {string} - The formatted string with the first letter capitalized.
+ */
+export declare function capitalizeFirstLetter(str: string): string;
+/**
+ * Combines a first name and a last name into a full name.
+ * @param {string} firstName - The first name.
+ * @param {string} lastName - The last name.
+ * @returns {string} - The full name formatted as "FirstName LastName".
+ */
+export declare function getFullName(firstName: string, lastName: string): string;
+/**
+ * Generates a URL-friendly slug from a given text.
+ * @param {string} text - The input string.
+ * @returns {string} - The generated slug with lowercase alphanumeric characters and hyphens.
+ */
+export declare function generateSlug(text: string): string;
+/**
+ * Abbreviates a full name into a first name and the initial of the last name.
+ * @param {string} fullName - The input full name.
+ * @returns {string} - The abbreviated name in the format "FirstName L.".
+ */
+export declare function abbreviateName(fullName: string): string;
+/**
+ * Extracts the initials from a full name.
+ * @param {string} fullName - The input full name.
+ * @returns {string} - The initials in uppercase format.
+ */
+export declare function getInitialsFrom(fullName: string): string;
+//# sourceMappingURL=text.d.ts.map

package/esm/src/utils/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/src/utils/text.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CASzD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOjD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAYvD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAcxD"}