@temboplus/afloat 0.1.78 → 0.1.79

package/esm/deps/jsr.io/@temboplus/frontend-core/0.2.21/src/models/phone_number/global/service.js

@@ -1,498 +0,0 @@
-/**
- * @fileoverview
- *
- * # Global Phone Number Service
- *
- * ## Features
- * 1. Loads and maintains phone number metadata from patterns database
- * 2. Validates phone numbers against country-specific patterns
- * 3. Provides utility functions for phone number operations
- * 4. Follows singleton pattern for efficient resource usage
- */
-import { Country } from "../../country/country.js";
-import { PhoneNumber } from "./phone_number.js";
-import phonePatterns from "../../../data/phone_patterns.js";
-import { PhoneNumberFormat } from "../format.js";
-/**
- * Phone number pattern type
- */
-export var PhoneNumberType;
-(function (PhoneNumberType) {
-    PhoneNumberType["LANDLINE"] = "landline";
-    PhoneNumberType["MOBILE"] = "mobile";
-    PhoneNumberType["TOLL_FREE"] = "toll_free";
-    PhoneNumberType["PREMIUM_RATE"] = "premium_rate";
-    PhoneNumberType["SHARED_COST"] = "shared_cost";
-    PhoneNumberType["EMERGENCY"] = "emergency";
-    PhoneNumberType["SPECIAL_SERVICES"] = "special_services";
-    PhoneNumberType["VOIP"] = "voip";
-    PhoneNumberType["PERSONAL"] = "personal";
-    PhoneNumberType["UNKNOWN"] = "unknown";
-})(PhoneNumberType || (PhoneNumberType = {}));
-/**
- * Error thrown when a phone number has an ambiguous country due to shared dial code
- */
-export class SharedDialCodeError extends Error {
-    /**
-     * Creates a new SharedDialCodeError
-     *
-     * @param dialCode - The shared dial code
-     * @param countries - Countries that share this dial code
-     */
-    constructor(dialCode, countries) {
-        const message = `Dial code +${dialCode} is shared by multiple countries: ${countries.join(", ")}. Please use 'fromWithCountry' with a specific country.`;
-        super(message);
-        /** The dial code that's shared */
-        Object.defineProperty(this, "dialCode", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** List of country codes that share this dial code */
-        Object.defineProperty(this, "countries", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = "SharedDialCodeError";
-        this.dialCode = dialCode;
-        this.countries = countries;
-    }
-}
-/**
- * Service for managing global phone number operations
- */
-export class GlobalPhoneNumberService {
-    /**
-     * Private constructor to enforce singleton pattern
-     */
-    constructor() {
-        // Use Map for countryMetadata
-        Object.defineProperty(this, "countryMetadata", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        }); // <--- CHANGED
-        Object.defineProperty(this, "sharedCountryCodes", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-        Object.defineProperty(this, "initialized", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-    }
-    /**
-     * Gets the singleton instance of GlobalPhoneNumberService
-     * Creates the instance if it doesn't exist
-     *
-     * @returns {GlobalPhoneNumberService} The singleton instance
-     */
-    static getInstance() {
-        if (!GlobalPhoneNumberService.instance) {
-            GlobalPhoneNumberService.instance = new GlobalPhoneNumberService();
-            GlobalPhoneNumberService.instance.initialize();
-        }
-        return GlobalPhoneNumberService.instance;
-    }
-    /**
-     * Initializes the service with phone patterns data
-     * Should be called once when the service is first used
-     */
-    initialize() {
-        try {
-            if (this.initialized)
-                return;
-            // Parse the phone patterns data
-            const data = JSON.parse(JSON.stringify(phonePatterns));
-            // Extract shared country codes
-            this.sharedCountryCodes = data._shared_country_codes || {};
-            // Populate the countryMetadata Map
-            const countriesMap = new Map(); // <--- CHANGED
-            Object.entries(data)
-                .filter(([key]) => !key.startsWith("_"))
-                .forEach(([key, value]) => {
-                countriesMap.set(key, value); // <--- CHANGED (using .set())
-            });
-            this.countryMetadata = countriesMap; // <--- CHANGED
-            this.initialized = true;
-        }
-        catch (error) {
-            console.error("Failed to initialize GlobalPhoneNumberService:", error);
-        }
-    }
-    /**
-     * Gets the metadata for a specific country
-     *
-     * @param {ISO2CountryCode} countryCode - The ISO country code
-     * @returns {CountryMetadata | undefined} The country metadata or undefined if not found
-     */
-    getCountryMetadata(countryCode) {
-        return this.countryMetadata.get(countryCode); // <--- CHANGED (using .get())
-    }
-    /**
-     * Gets all country metadata
-     *
-     * @returns {CountryMetadataMap} All country metadata (as a Map)
-     */
-    getAllCountryMetadata() {
-        return this.countryMetadata;
-    }
-    /**
-     * Gets all the countries that share a specific dial code
-     *
-     * @param {string | number} dialCode - The dial code to check
-     * @returns {string[]} Array of ISO country codes that share this dial code
-     */
-    getCountriesWithDialCode(dialCode) {
-        const dialCodeStr = dialCode.toString();
-        // sharedCountryCodes remains an object, access is unchanged
-        return this.sharedCountryCodes[dialCodeStr] || [];
-    }
-    /**
-     * Checks if a dial code is shared between multiple countries
-     *
-     * @param {string | number} dialCode - The dial code to check
-     * @returns {boolean} True if the dial code is shared, false otherwise
-     */
-    isSharedDialCode(dialCode) {
-        const dialCodeStr = dialCode.toString();
-        // sharedCountryCodes remains an object, access is unchanged
-        const countries = this.sharedCountryCodes[dialCodeStr];
-        return countries !== undefined && countries.length > 1;
-    }
-    /**
-     * Finds the country code associated with a given dial code
-     *
-     * @param dialCode - The dial code to look up
-     * @returns The country code or undefined if not found
-     */
-    getCountryForDialCode(dialCode) {
-        // Iterate over Map entries
-        for (const [countryCode, metadata] of this.countryMetadata.entries()) { // <--- CHANGED (using .entries())
-            if (metadata.code.toString() === dialCode) {
-                return countryCode; // No need for type assertion here
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Extracts dial code information from a phone number
-     *
-     * @param phoneNumber - The phone number in international format (with +)
-     * @returns Dial code information or undefined if not found
-     */
-    extractDialCode(phoneNumber) {
-        const cleaned = this.cleanPhoneNumber(phoneNumber);
-        if (!cleaned.startsWith("+"))
-            return undefined;
-        const numberWithoutPlus = cleaned.substring(1);
-        // Try to find the dial code by checking prefixes of increasing length
-        for (let i = 3; i >= 1; i--) {
-            if (numberWithoutPlus.length <= i)
-                continue;
-            const potentialDialCode = numberWithoutPlus.substring(0, i); // Renamed for clarity
-            // Check if any country has this dial code by iterating Map values
-            let countryFound = false;
-            for (const metadata of this.countryMetadata.values()) { // <--- CHANGED (using .values())
-                if (metadata.code.toString() === potentialDialCode) {
-                    countryFound = true;
-                    break;
-                }
-            }
-            if (countryFound) {
-                const nationalNumber = numberWithoutPlus.substring(potentialDialCode.length);
-                const isShared = this.isSharedDialCode(potentialDialCode);
-                // Use the existing methods which now work with the Map internally
-                const possibleCountries = isShared
-                    ? this.sharedCountryCodes[potentialDialCode] // Access shared codes directly
-                    : this.getCountryForDialCode(potentialDialCode) ? [this.getCountryForDialCode(potentialDialCode)] : [];
-                return {
-                    dialCode: potentialDialCode,
-                    isShared,
-                    nationalNumber,
-                    possibleCountries,
-                };
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Gets the countries that might be associated with a phone number
-     *
-     * @param {string} phoneNumber - The phone number in international format
-     * @returns {Country[]} Array of possible countries for this phone number
-     */
-    getPossibleCountries(phoneNumber) {
-        const cleanedNumber = this.cleanPhoneNumber(phoneNumber);
-        if (!cleanedNumber.startsWith("+"))
-            return [];
-        const dialCodeInfo = this.extractDialCode(cleanedNumber);
-        if (!dialCodeInfo)
-            return [];
-        const possibleCountries = [];
-        for (const countryCode of dialCodeInfo.possibleCountries) {
-            const country = Country.fromCode(countryCode);
-            if (country)
-                possibleCountries.push(country);
-        }
-        return possibleCountries;
-    }
-    /**
-     * Determines the most likely type of a phone number
-     *
-     * @param {ISO2CountryCode} countryCode - ISO country code
-     * @param {string} nationalNumber - The national number to check
-     * @returns {PhoneNumberType} The type of the phone number
-     */
-    getNumberType(countryCode, nationalNumber) {
-        if (!countryCode || !nationalNumber) {
-            return PhoneNumberType.UNKNOWN;
-        }
-        // Use .get() to retrieve metadata
-        const metadata = this.countryMetadata.get(countryCode); // <--- CHANGED (using .get())
-        // Check if metadata exists after .get()
-        if (!metadata || !metadata.patterns) { // <--- ADDED Check for undefined
-            return PhoneNumberType.UNKNOWN;
-        }
-        // Verify that required patterns exist
-        if (!metadata.patterns.landline || !metadata.patterns.mobile) {
-            console.error(`Country ${countryCode} is missing required patterns for landline or mobile`);
-            return PhoneNumberType.UNKNOWN;
-        }
-        // Check each type of pattern
-        for (const [type, pattern] of Object.entries(metadata.patterns)) {
-            if (!pattern)
-                continue;
-            try {
-                const regex = new RegExp(pattern);
-                if (regex.test(nationalNumber)) {
-                    return type;
-                }
-            }
-            catch (e) {
-                console.error(`Invalid regex pattern for ${countryCode}.${type}:`, e);
-            }
-        }
-        return PhoneNumberType.UNKNOWN;
-    }
-    /**
-     * Validates a phone number against country-specific patterns
-     *
-     * @param {ISO2CountryCode} countryCode - ISO country code
-     * @param {string} nationalNumber - The national number to validate
-     * @returns {boolean} True if the phone number is valid, false otherwise
-     */
-    validatePattern(countryCode, nationalNumber) {
-        if (!countryCode || !nationalNumber) {
-            return false;
-        }
-        // Use .get() to retrieve metadata
-        const metadata = this.countryMetadata.get(countryCode); // <--- CHANGED (using .get())
-        // Check if metadata exists after .get()
-        if (!metadata || !metadata.patterns) { // <--- ADDED Check for undefined
-            return false;
-        }
-        // Verify that required patterns exist
-        if (!metadata.patterns.landline || !metadata.patterns.mobile) {
-            console.error(`Country ${countryCode} is missing required patterns for landline or mobile`);
-            return false;
-        }
-        // Check if the number matches any of the patterns for this country
-        for (const [type, pattern] of Object.entries(metadata.patterns)) {
-            if (!pattern)
-                continue;
-            try {
-                const regex = new RegExp(pattern);
-                if (regex.test(nationalNumber)) {
-                    return true;
-                }
-            }
-            catch (e) {
-                console.error(`Invalid regex pattern for ${countryCode}.${type}:`, e);
-            }
-        }
-        return false;
-    }
-    /**
-     * Formats a phone number according to the country's formatting rules
-     * (No changes needed in this method's logic)
-     *
-     * @param {string} phoneNumber - The phone number to format
-     * @param {PhoneNumberFormat} format - The desired format
-     * @returns {string} The formatted phone number
-     */
-    formatNumber(phoneNumber, format = PhoneNumberFormat.INTERNATIONAL) {
-        const phone = PhoneNumber.from(phoneNumber);
-        if (!phone)
-            return phoneNumber;
-        return phone.getWithFormat(format);
-    }
-    /**
-     * Creates a PhoneNumber from an international format string
-     * (No changes needed in this method's logic)
-     *
-     * @param {string} phoneNumber - The phone number in international format
-     * @returns {PhoneNumber | undefined} The parsed phone number or undefined if invalid
-     */
-    parsePhoneNumber(phoneNumber) {
-        return PhoneNumber.from(phoneNumber);
-    }
-    /**
-     * Creates a PhoneNumber from a phone number with explicit country
-     * (No changes needed in this method's logic)
-     *
-     * @param {string} phoneNumber - The phone number in any format
-     * @param {Country | string} country - The country or country code
-     * @returns {PhoneNumber | undefined} The parsed phone number or undefined if invalid
-     */
-    parsePhoneNumberWithCountry(phoneNumber, country) {
-        const countryObj = typeof country === "string"
-            ? Country.fromCode(country)
-            : country;
-        if (!countryObj)
-            return undefined;
-        return PhoneNumber.fromWithCountry(phoneNumber, countryObj);
-    }
-    /**
-     * Extracts the information needed for dialing from one country to another
-     * (No changes needed in this method's logic)
-     *
-     * @param {string} fromCountry - ISO code of the country dialing from
-     * @param {PhoneNumber} phoneNumber - The phone number to dial
-     * @returns {string} The appropriately formatted dialing string
-     */
-    getDialingString(fromCountry, phoneNumber) {
-        if (!fromCountry || !phoneNumber || !PhoneNumber.is(phoneNumber)) {
-            return "";
-        }
-        // Simple implementation that always uses international format
-        // A production version would handle local dialing formats
-        return phoneNumber.getWithFormat(PhoneNumberFormat.INTERNATIONAL);
-    }
-    /**
-     * Cleans a phone number by removing all non-digit characters except the leading plus
-     * (No changes needed in this method's logic)
-     *
-     * @param {string} phoneNumber - The phone number to clean
-     * @returns {string} The cleaned phone number
-     */
-    cleanPhoneNumber(phoneNumber) {
-        if (!phoneNumber)
-            return "";
-        // Preserve the leading +
-        const hasPlus = phoneNumber.trim().startsWith("+");
-        // Remove all non-digit characters
-        const digitsOnly = phoneNumber.replace(/\D/g, "");
-        // Add the plus back if it was present
-        return hasPlus ? `+${digitsOnly}` : digitsOnly;
-    }
-    /**
-     * Extracts the country and national number from an international phone number
-     * (No changes needed in this method's logic - relies on extractDialCode which was updated)
-     *
-     * @param {string} phoneNumber - The phone number in international format
-     * @returns {[Country | undefined, string]} The country and national number
-     */
-    extractParts(phoneNumber) {
-        const cleaned = this.cleanPhoneNumber(phoneNumber);
-        if (!cleaned.startsWith("+"))
-            return [undefined, cleaned];
-        const dialCodeInfo = this.extractDialCode(cleaned);
-        if (!dialCodeInfo)
-            return [undefined, cleaned.substring(1)];
-        if (dialCodeInfo.isShared) {
-            // For shared dial codes, we return undefined for the country
-            return [undefined, dialCodeInfo.nationalNumber];
-        }
-        else {
-            // For non-shared dial codes, we return the country
-            const countryCode = dialCodeInfo.possibleCountries[0];
-            const country = countryCode ? Country.fromCode(countryCode) : undefined;
-            return [country, dialCodeInfo.nationalNumber];
-        }
-    }
-    /**
-     * Gets a list of commonly used examples of valid phone numbers for a country
-     *
-     * @param {ISO2CountryCode} countryCode - The ISO country code
-     * @returns {string[]} Array of example phone numbers
-     */
-    getExampleNumbers(countryCode) {
-        // Use .get() to retrieve metadata
-        const metadata = this.countryMetadata.get(countryCode); // <--- CHANGED (using .get())
-        if (!metadata)
-            return []; // <--- ADDED Check for undefined
-        const dialCode = metadata.code;
-        const examples = [];
-        // Ensure patterns exist before trying to generate examples
-        if (metadata.patterns.landline) {
-            examples.push(`+${dialCode}${this.generateExampleFromPattern(metadata.patterns.landline)}`);
-        }
-        if (metadata.patterns.mobile) {
-            examples.push(`+${dialCode}${this.generateExampleFromPattern(metadata.patterns.mobile)}`);
-        }
-        return examples;
-    }
-    /**
-     * Generates an example phone number that would match a given pattern
-     * This is a simple implementation that handles basic patterns
-     * (No changes needed in this method's logic)
-     *
-     * @param pattern - The regex pattern
-     * @returns A string that would match the pattern
-     */
-    generateExampleFromPattern(pattern) {
-        // Very basic implementation - a real one would be more sophisticated
-        // but this handles simple patterns like "^[2-8]\\d{7}$"
-        // Find basic digit patterns like \d{7}
-        const digitMatch = pattern.match(/\\d\{(\d+)\}/);
-        const digitCount = digitMatch ? parseInt(digitMatch[1]) : 8;
-        // Find range patterns like [2-8]
-        const rangeMatch = pattern.match(/\[(\d)-(\d)\]/);
-        const firstDigit = rangeMatch ? rangeMatch[1] : "5";
-        // Combine them
-        return `${firstDigit}${"0".repeat(digitCount - 1)}`;
-    }
-    /**
-     * Checks if a phone number is valid for a specific country
-     * (No changes needed in this method's logic)
-     *
-     * @param {string} phoneNumber - The phone number to validate
-     * @param {ISO2CountryCode} countryCode - The ISO country code
-     * @returns {boolean} True if the phone number is valid for the country, false otherwise
-     */
-    isValidForCountry(phoneNumber, countryCode) {
-        const country = Country.fromCode(countryCode);
-        if (!country)
-            return false;
-        const phone = PhoneNumber.fromWithCountry(phoneNumber, country);
-        return phone !== undefined;
-    }
-    /**
-     * Checks if a given dial code exists in our database
-     *
-     * @param dialCode - The dial code to check
-     * @returns True if the dial code exists, false otherwise
-     */
-    hasDialCode(dialCode) {
-        // Check if it's a shared dial code (access unchanged)
-        if (this.sharedCountryCodes[dialCode]?.length > 0) {
-            return true;
-        }
-        // Check if any country has this dial code by iterating Map values
-        for (const metadata of this.countryMetadata.values()) { // <--- CHANGED (using .values())
-            if (metadata.code.toString() === dialCode) {
-                return true;
-            }
-        }
-        return false;
-    }
-}

package/esm/deps/jsr.io/@temboplus/frontend-core/0.2.21/src/models/phone_number/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./tz/antd_validator.js";
-export * from "./tz/phone_number.js";
-export * from "./tz/network_operator.js";
-export * from "./global/phone_number.js";
-export * from "./format.js";
-//# sourceMappingURL=index.d.ts.map

package/esm/deps/jsr.io/@temboplus/frontend-core/0.2.21/src/models/phone_number/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@temboplus/frontend-core/0.2.21/src/models/phone_number/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,aAAa,CAAA"}

package/esm/deps/jsr.io/@temboplus/frontend-core/0.2.21/src/models/phone_number/index.js

@@ -1,5 +0,0 @@
-export * from "./tz/antd_validator.js";
-export * from "./tz/phone_number.js";
-export * from "./tz/network_operator.js";
-export * from "./global/phone_number.js";
-export * from "./format.js";

package/esm/deps/jsr.io/@temboplus/frontend-core/0.2.21/src/models/phone_number/tz/antd_validator.d.ts

@@ -1,77 +0,0 @@
-import type { RuleObject } from "antd/es/form";
-import { TZPhoneNumber } 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 declare const TZ_PHONE_NUMBER_REGEX: RegExp;
-export declare const PHONENUMBER_VALIDATOR: (rule: RuleObject, value: string | null | undefined) => Promise<TZPhoneNumber | undefined>;
-//# sourceMappingURL=antd_validator.d.ts.map

package/esm/deps/jsr.io/@temboplus/frontend-core/0.2.21/src/models/phone_number/tz/antd_validator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"antd_validator.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/deps/jsr.io/@temboplus/frontend-core/0.2.21/src/models/phone_number/tz/antd_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,eAAO,MAAM,qBAAqB,QACkF,CAAC;AAErH,eAAO,MAAM,qBAAqB,SAC1B,UAAU,SACT,MAAM,GAAG,IAAI,GAAG,SAAS,KAC/B,OAAO,CAAC,aAAa,GAAG,SAAS,CAiBnC,CAAC"}

package/esm/deps/jsr.io/@temboplus/frontend-core/0.2.21/src/models/phone_number/tz/antd_validator.js

@@ -1,90 +0,0 @@
-import { TZPhoneNumber } 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 = TZPhoneNumber.from(phoneString);
-    if (phone)
-        return Promise.resolve(phone);
-    return Promise.reject(new Error("Invalid phone number format."));
-};