@temboplus/frontend-core 0.2.1 → 0.2.3

package/script/src/models/phone_number/global/service.js

@@ -0,0 +1,485 @@
+"use strict";
+/**
+ * @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
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalPhoneNumberService = exports.SharedDialCodeError = exports.PhoneNumberType = void 0;
+const country_js_1 = require("../../country/country.js");
+const phone_number_js_1 = require("./phone_number.js");
+const phone_patterns_js_1 = __importDefault(require("../../../data/phone_patterns.js"));
+const format_js_1 = require("../format.js");
+/**
+ * Phone number pattern type
+ */
+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 || (exports.PhoneNumberType = PhoneNumberType = {}));
+/**
+ * Error thrown when a phone number has an ambiguous country due to shared dial code
+ */
+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;
+    }
+}
+exports.SharedDialCodeError = SharedDialCodeError;
+/**
+ * Service for managing global phone number operations
+ */
+class GlobalPhoneNumberService {
+    /**
+     * Private constructor to enforce singleton pattern
+     */
+    constructor() {
+        Object.defineProperty(this, "countryMetadata", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        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(phone_patterns_js_1.default));
+            // Extract shared country codes
+            this.sharedCountryCodes = data._shared_country_codes || {};
+            const countries = Object.entries(data)
+                .filter(([key]) => !key.startsWith("_"))
+                .reduce((result, [key, value]) => {
+                result[key] = value;
+                return result;
+            }, {});
+            this.countryMetadata = countries;
+            this.initialized = true;
+        }
+        catch (error) {
+            console.error("Failed to initialize GlobalPhoneNumberService:", error);
+        }
+    }
+    /**
+     * Gets the metadata for a specific country
+     *
+     * @param {string} countryCode - The ISO country code
+     * @returns {CountryMetadata | undefined} The country metadata or undefined if not found
+     */
+    getCountryMetadata(countryCode) {
+        return this.countryMetadata[countryCode];
+    }
+    /**
+     * Gets all country metadata
+     *
+     * @returns {CountryMetadataMap} All country metadata
+     */
+    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();
+        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();
+        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) {
+        for (const [countryCode, metadata] of Object.entries(this.countryMetadata)) {
+            if (metadata.code.toString() === dialCode) {
+                return countryCode;
+            }
+        }
+        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 dialCode = numberWithoutPlus.substring(0, i);
+            // Check if any country has this dial code
+            let countryFound = false;
+            for (const [_, metadata] of Object.entries(this.countryMetadata)) {
+                if (metadata.code.toString() === dialCode) {
+                    countryFound = true;
+                    break;
+                }
+            }
+            if (countryFound) {
+                const nationalNumber = numberWithoutPlus.substring(dialCode.length);
+                const isShared = this.isSharedDialCode(dialCode);
+                const possibleCountries = isShared
+                    ? this.sharedCountryCodes[dialCode]
+                    : [this.getCountryForDialCode(dialCode) ?? ""];
+                return {
+                    dialCode,
+                    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_js_1.Country.fromCode(countryCode);
+            if (country)
+                possibleCountries.push(country);
+        }
+        return possibleCountries;
+    }
+    /**
+     * Determines the most likely type of a phone number
+     *
+     * @param {string} 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;
+        }
+        const metadata = this.countryMetadata[countryCode];
+        if (!metadata || !metadata.patterns) {
+            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 {string} 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;
+        }
+        const metadata = this.countryMetadata[countryCode];
+        if (!metadata || !metadata.patterns) {
+            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
+     *
+     * @param {string} phoneNumber - The phone number to format
+     * @param {PhoneNumberFormat} format - The desired format
+     * @returns {string} The formatted phone number
+     */
+    formatNumber(phoneNumber, format = format_js_1.PhoneNumberFormat.INTERNATIONAL) {
+        const phone = phone_number_js_1.PhoneNumber.from(phoneNumber);
+        if (!phone)
+            return phoneNumber;
+        return phone.getWithFormat(format);
+    }
+    /**
+     * Creates a PhoneNumber from an international format string
+     *
+     * @param {string} phoneNumber - The phone number in international format
+     * @returns {PhoneNumber | undefined} The parsed phone number or undefined if invalid
+     */
+    parsePhoneNumber(phoneNumber) {
+        return phone_number_js_1.PhoneNumber.from(phoneNumber);
+    }
+    /**
+     * Creates a PhoneNumber from a phone number with explicit country
+     *
+     * @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_js_1.Country.fromCode(country)
+            : country;
+        if (!countryObj)
+            return undefined;
+        return phone_number_js_1.PhoneNumber.fromWithCountry(phoneNumber, countryObj);
+    }
+    /**
+     * Extracts the information needed for dialing from one country to another
+     *
+     * @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 || !phone_number_js_1.PhoneNumber.is(phoneNumber)) {
+            return "";
+        }
+        // Simple implementation that always uses international format
+        // A production version would handle local dialing formats
+        return phoneNumber.getWithFormat(format_js_1.PhoneNumberFormat.INTERNATIONAL);
+    }
+    /**
+     * Cleans a phone number by removing all non-digit characters except the leading plus
+     *
+     * @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
+     *
+     * @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_js_1.Country.fromCode(countryCode) : undefined;
+            return [country, dialCodeInfo.nationalNumber];
+        }
+    }
+    /**
+     * Gets a list of commonly used examples of valid phone numbers for a country
+     *
+     * @param {string} countryCode - The ISO country code
+     * @returns {string[]} Array of example phone numbers
+     */
+    getExampleNumbers(countryCode) {
+        const metadata = this.countryMetadata[countryCode];
+        if (!metadata)
+            return [];
+        const dialCode = metadata.code;
+        const examples = [];
+        // Since landline and mobile patterns are required, we can always generate examples
+        // Landline example
+        examples.push(`+${dialCode}${this.generateExampleFromPattern(metadata.patterns.landline)}`);
+        // Mobile example
+        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
+     *
+     * @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
+     *
+     * @param {string} phoneNumber - The phone number to validate
+     * @param {string} 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_js_1.Country.fromCode(countryCode);
+        if (!country)
+            return false;
+        const phone = phone_number_js_1.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
+        if (this.sharedCountryCodes[dialCode]?.length > 0) {
+            return true;
+        }
+        // Check if any country has this dial code
+        for (const metadata of Object.values(this.countryMetadata)) {
+            if (metadata.code.toString() === dialCode) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.GlobalPhoneNumberService = GlobalPhoneNumberService;

package/script/src/models/phone_number/global/service.test.d.ts.map

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

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

@@ -1,4 +1,6 @@
-export * from "./antd_validator.js";
-export * from "./phone_number.js";
-export * from "./network_operator.js";
+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/script/src/models/phone_number/index.d.ts.map

@@ -1 +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,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/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/script/src/models/phone_number/index.js

@@ -14,6 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./antd_validator.js"), exports);
-__exportStar(require("./phone_number.js"), exports);
-__exportStar(require("./network_operator.js"), exports);
+__exportStar(require("./tz/antd_validator.js"), exports);
+__exportStar(require("./tz/phone_number.js"), exports);
+__exportStar(require("./tz/network_operator.js"), exports);
+__exportStar(require("./global/phone_number.js"), exports);
+__exportStar(require("./format.js"), exports);

package/script/src/models/phone_number/{antd_validator.d.ts → tz/antd_validator.d.ts}

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

package/script/src/models/phone_number/tz/antd_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"antd_validator.d.ts","sourceRoot":"","sources":["../../../../../src/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/script/src/models/phone_number/{antd_validator.js → tz/antd_validator.js}

@@ -86,7 +86,7 @@ const PHONENUMBER_VALIDATOR = (rule, value) => {
         // If field is not required and empty, validation passes
         return Promise.resolve(undefined);
     }
-    const phone = phone_number_js_1.PhoneNumber.from(phoneString);
+    const phone = phone_number_js_1.TZPhoneNumber.from(phoneString);
     if (phone)
         return Promise.resolve(phone);
     return Promise.reject(new Error("Invalid phone number format."));

package/script/src/models/phone_number/tz/antdvalidator.test.d.ts.map

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

package/script/src/models/phone_number/tz/network_operator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network_operator.d.ts","sourceRoot":"","sources":["../../../../../src/src/models/phone_number/tz/network_operator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,eAAe;IACzB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,OAAO,YAAY;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,iDAAiD;IACjD,EAAE,EAAE,eAAe,CAAC;IAEpB,+DAA+D;IAC/D,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAE/B,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAC;IAEpB,wDAAwD;IACxD,kBAAkB,EAAE,MAAM,CAAC;IAE3B,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAC1C,eAAe,EACf,mBAAmB,CA8BpB,CAAC"}