country-codes-library 1.1.3 → 2.0.0

package/dist/utils.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCountryByCode2 = getCountryByCode2;
+exports.getCountryByCode3 = getCountryByCode3;
+exports.getCountryByName = getCountryByName;
+exports.getCountriesByCurrency = getCountriesByCurrency;
+exports.getCountriesByCallingCode = getCountriesByCallingCode;
+exports.searchCountries = searchCountries;
+exports.convertCountryCode = convertCountryCode;
+exports.getCallingCode = getCallingCode;
+exports.getCurrencyCode = getCurrencyCode;
+exports.getCurrencySymbol = getCurrencySymbol;
+exports.getAllCurrencies = getAllCurrencies;
+exports.getAllCallingCodes = getAllCallingCodes;
+const countryData_1 = require("./countryData");
+/**
+ * Get country information by 2-letter ISO code
+ * @param code - ISO 3166-1 alpha-2 code (e.g., "US", "GB", "CN")
+ * @returns Country object or null if not found
+ * @example
+ * ```ts
+ * const country = getCountryByCode2("US");
+ * // Returns: { name: "UnitedStates", code2: "US", code3: "USA", ... }
+ * ```
+ */
+function getCountryByCode2(code) {
+    const upperCode = code.toUpperCase();
+    for (const country of (0, countryData_1.getAllCountries)()) {
+        if (country.code2.toUpperCase() === upperCode) {
+            return country;
+        }
+    }
+    return null;
+}
+/**
+ * Get country information by 3-letter ISO code
+ * @param code - ISO 3166-1 alpha-3 code (e.g., "USA", "GBR", "CHN")
+ * @returns Country object or null if not found
+ * @example
+ * ```ts
+ * const country = getCountryByCode3("USA");
+ * // Returns: { name: "UnitedStates", code2: "US", code3: "USA", ... }
+ * ```
+ */
+function getCountryByCode3(code) {
+    const upperCode = code.toUpperCase();
+    for (const country of (0, countryData_1.getAllCountries)()) {
+        if (country.code3.toUpperCase() === upperCode) {
+            return country;
+        }
+    }
+    return null;
+}
+/**
+ * Get country information by name
+ * @param name - Country name (e.g., "UnitedStates", "United States")
+ * @returns Country object or null if not found
+ * @example
+ * ```ts
+ * const country = getCountryByName("UnitedStates");
+ * // Returns: { name: "UnitedStates", code2: "US", code3: "USA", ... }
+ * ```
+ */
+function getCountryByName(name) {
+    // Try exact match first
+    if (countryData_1.CountryData[name]) {
+        return countryData_1.CountryData[name];
+    }
+    // Try case-insensitive match
+    const lowerName = name.toLowerCase().replace(/\s+/g, '');
+    for (const countryName in countryData_1.CountryData) {
+        if (countryName.toLowerCase().replace(/\s+/g, '') === lowerName) {
+            return countryData_1.CountryData[countryName];
+        }
+    }
+    return null;
+}
+/**
+ * Get all countries that use a specific currency
+ * @param currencyCode - ISO 4217 currency code (e.g., "USD", "EUR")
+ * @returns Array of countries using the currency
+ * @example
+ * ```ts
+ * const countries = getCountriesByCurrency("EUR");
+ * // Returns array of European countries using Euro
+ * ```
+ */
+function getCountriesByCurrency(currencyCode) {
+    const upperCurrency = currencyCode.toUpperCase();
+    return (0, countryData_1.getAllCountries)().filter(country => country.currencyCode.toUpperCase() === upperCurrency);
+}
+/**
+ * Get all countries with a specific calling code
+ * @param callingCode - International calling code (e.g., "+1", "+44")
+ * @returns Array of countries with the calling code
+ * @example
+ * ```ts
+ * const countries = getCountriesByCallingCode("+1");
+ * // Returns: [USA, Canada, and other +1 countries]
+ * ```
+ */
+function getCountriesByCallingCode(callingCode) {
+    // Normalize calling code (add + if missing)
+    const normalizedCode = callingCode.startsWith('+') ? callingCode : `+${callingCode}`;
+    return (0, countryData_1.getAllCountries)().filter(country => country.callingCode === normalizedCode);
+}
+/**
+ * Search countries by name (supports partial matching)
+ * @param query - Search query
+ * @param options - Search options
+ * @returns Array of matching countries
+ * @example
+ * ```ts
+ * const results = searchCountries("united");
+ * // Returns: [UnitedStates, UnitedKingdom, UnitedArabEmirates]
+ * ```
+ */
+function searchCountries(query, options = {}) {
+    const { caseSensitive = false, exactMatch = false } = options;
+    const searchQuery = caseSensitive ? query : query.toLowerCase();
+    return (0, countryData_1.getAllCountries)().filter(country => {
+        const countryName = caseSensitive ? country.name : country.name.toLowerCase();
+        if (exactMatch) {
+            return countryName === searchQuery;
+        }
+        return countryName.includes(searchQuery);
+    });
+}
+/**
+ * Convert between 2-letter and 3-letter country codes
+ * @param code - Country code to convert
+ * @param targetFormat - Target format ('code2' or 'code3')
+ * @returns Converted code or null if not found
+ * @example
+ * ```ts
+ * convertCountryCode("US", "code3"); // Returns: "USA"
+ * convertCountryCode("GBR", "code2"); // Returns: "GB"
+ * ```
+ */
+function convertCountryCode(code, targetFormat) {
+    // Try as 2-letter code first
+    let country = getCountryByCode2(code);
+    // If not found, try as 3-letter code
+    if (!country) {
+        country = getCountryByCode3(code);
+    }
+    if (!country) {
+        return null;
+    }
+    return targetFormat === 'code2' ? country.code2 : country.code3;
+}
+/**
+ * Get calling code for a country
+ * @param countryIdentifier - Country name, code2, or code3
+ * @returns Calling code or null if not found
+ * @example
+ * ```ts
+ * getCallingCode("US"); // Returns: "+1"
+ * getCallingCode("UnitedStates"); // Returns: "+1"
+ * ```
+ */
+function getCallingCode(countryIdentifier) {
+    let country = getCountryByName(countryIdentifier);
+    if (!country) {
+        country = getCountryByCode2(countryIdentifier);
+    }
+    if (!country) {
+        country = getCountryByCode3(countryIdentifier);
+    }
+    return country ? country.callingCode : null;
+}
+/**
+ * Get currency code for a country
+ * @param countryIdentifier - Country name, code2, or code3
+ * @returns Currency code or null if not found
+ * @example
+ * ```ts
+ * getCurrencyCode("US"); // Returns: "USD"
+ * getCurrencyCode("Germany"); // Returns: "EUR"
+ * ```
+ */
+function getCurrencyCode(countryIdentifier) {
+    let country = getCountryByName(countryIdentifier);
+    if (!country) {
+        country = getCountryByCode2(countryIdentifier);
+    }
+    if (!country) {
+        country = getCountryByCode3(countryIdentifier);
+    }
+    return country ? country.currencyCode : null;
+}
+/**
+ * Get currency symbol for a country
+ * @param countryIdentifier - Country name, code2, or code3
+ * @returns Currency symbol or null if not found
+ * @example
+ * ```ts
+ * getCurrencySymbol("US"); // Returns: "$"
+ * getCurrencySymbol("Japan"); // Returns: "¥"
+ * ```
+ */
+function getCurrencySymbol(countryIdentifier) {
+    let country = getCountryByName(countryIdentifier);
+    if (!country) {
+        country = getCountryByCode2(countryIdentifier);
+    }
+    if (!country) {
+        country = getCountryByCode3(countryIdentifier);
+    }
+    return country ? country.currencySymbol : null;
+}
+/**
+ * Get all unique currencies used worldwide
+ * @returns Array of unique currency codes
+ */
+function getAllCurrencies() {
+    const currencies = new Set();
+    (0, countryData_1.getAllCountries)().forEach(country => {
+        if (country.currencyCode) {
+            currencies.add(country.currencyCode);
+        }
+    });
+    return Array.from(currencies).sort();
+}
+/**
+ * Get all unique calling codes
+ * @returns Array of unique calling codes
+ */
+function getAllCallingCodes() {
+    const codes = new Set();
+    (0, countryData_1.getAllCountries)().forEach(country => {
+        if (country.callingCode && country.callingCode !== '+0') {
+            codes.add(country.callingCode);
+        }
+    });
+    return Array.from(codes).sort((a, b) => {
+        const numA = parseInt(a.replace('+', ''));
+        const numB = parseInt(b.replace('+', ''));
+        return numA - numB;
+    });
+}

package/dist/validators.d.ts

@@ -0,0 +1,94 @@
+import { PhoneValidationResult } from './types';
+/**
+ * Validate if a string is a valid ISO 3166-1 alpha-2 country code
+ * @param code - The code to validate
+ * @returns true if valid, false otherwise
+ * @example
+ * ```ts
+ * isValidCountryCode2("US"); // true
+ * isValidCountryCode2("XX"); // false
+ * ```
+ */
+export declare function isValidCountryCode2(code: string): boolean;
+/**
+ * Validate if a string is a valid ISO 3166-1 alpha-3 country code
+ * @param code - The code to validate
+ * @returns true if valid, false otherwise
+ * @example
+ * ```ts
+ * isValidCountryCode3("USA"); // true
+ * isValidCountryCode3("XXX"); // false
+ * ```
+ */
+export declare function isValidCountryCode3(code: string): boolean;
+/**
+ * Validate if a string is a valid country code (2-letter or 3-letter)
+ * @param code - The code to validate
+ * @returns true if valid, false otherwise
+ * @example
+ * ```ts
+ * isValidCountryCode("US"); // true
+ * isValidCountryCode("USA"); // true
+ * isValidCountryCode("INVALID"); // false
+ * ```
+ */
+export declare function isValidCountryCode(code: string): boolean;
+/**
+ * Validate if a string is a valid country name
+ * @param name - The country name to validate
+ * @returns true if valid, false otherwise
+ * @example
+ * ```ts
+ * isValidCountryName("UnitedStates"); // true
+ * isValidCountryName("United States"); // true (case-insensitive)
+ * isValidCountryName("Atlantis"); // false
+ * ```
+ */
+export declare function isValidCountryName(name: string): boolean;
+/**
+ * Validate if a currency code is valid (ISO 4217)
+ * @param currencyCode - The currency code to validate
+ * @returns true if valid, false otherwise
+ * @example
+ * ```ts
+ * isValidCurrencyCode("USD"); // true
+ * isValidCurrencyCode("EUR"); // true
+ * isValidCurrencyCode("XXX"); // false (not used by any country)
+ * ```
+ */
+export declare function isValidCurrencyCode(currencyCode: string): boolean;
+/**
+ * Validate if a calling code is valid
+ * @param callingCode - The calling code to validate (with or without +)
+ * @returns true if valid, false otherwise
+ * @example
+ * ```ts
+ * isValidCallingCode("+1"); // true
+ * isValidCallingCode("44"); // true
+ * isValidCallingCode("+999"); // false
+ * ```
+ */
+export declare function isValidCallingCode(callingCode: string): boolean;
+/**
+ * Basic phone number validation for a specific country
+ * @param phoneNumber - The phone number to validate
+ * @param countryIdentifier - Country name, code2, or code3
+ * @returns Validation result object
+ * @example
+ * ```ts
+ * validatePhoneNumber("2025551234", "US");
+ * // Returns: { isValid: true, formatted: "+1-202-555-1234", countryCode: "+1" }
+ * ```
+ */
+export declare function validatePhoneNumber(phoneNumber: string, countryIdentifier: string): PhoneValidationResult;
+/**
+ * Parse a phone number and detect the country
+ * @param phoneNumber - The phone number to parse (with calling code)
+ * @returns Validation result with detected country
+ * @example
+ * ```ts
+ * parsePhoneNumber("+1-202-555-1234");
+ * // Returns: { isValid: true, formatted: "+1-2025551234", countryCode: "+1" }
+ * ```
+ */
+export declare function parsePhoneNumber(phoneNumber: string): PhoneValidationResult;

package/dist/validators.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidCountryCode2 = isValidCountryCode2;
+exports.isValidCountryCode3 = isValidCountryCode3;
+exports.isValidCountryCode = isValidCountryCode;
+exports.isValidCountryName = isValidCountryName;
+exports.isValidCurrencyCode = isValidCurrencyCode;
+exports.isValidCallingCode = isValidCallingCode;
+exports.validatePhoneNumber = validatePhoneNumber;
+exports.parsePhoneNumber = parsePhoneNumber;
+const utils_1 = require("./utils");
+/**
+ * Validate if a string is a valid ISO 3166-1 alpha-2 country code
+ * @param code - The code to validate
+ * @returns true if valid, false otherwise
+ * @example
+ * ```ts
+ * isValidCountryCode2("US"); // true
+ * isValidCountryCode2("XX"); // false
+ * ```
+ */
+function isValidCountryCode2(code) {
+    if (!code || typeof code !== 'string') {
+        return false;
+    }
+    if (code.length !== 2) {
+        return false;
+    }
+    return (0, utils_1.getCountryByCode2)(code) !== null;
+}
+/**
+ * Validate if a string is a valid ISO 3166-1 alpha-3 country code
+ * @param code - The code to validate
+ * @returns true if valid, false otherwise
+ * @example
+ * ```ts
+ * isValidCountryCode3("USA"); // true
+ * isValidCountryCode3("XXX"); // false
+ * ```
+ */
+function isValidCountryCode3(code) {
+    if (!code || typeof code !== 'string') {
+        return false;
+    }
+    if (code.length !== 3) {
+        return false;
+    }
+    return (0, utils_1.getCountryByCode3)(code) !== null;
+}
+/**
+ * Validate if a string is a valid country code (2-letter or 3-letter)
+ * @param code - The code to validate
+ * @returns true if valid, false otherwise
+ * @example
+ * ```ts
+ * isValidCountryCode("US"); // true
+ * isValidCountryCode("USA"); // true
+ * isValidCountryCode("INVALID"); // false
+ * ```
+ */
+function isValidCountryCode(code) {
+    if (!code || typeof code !== 'string') {
+        return false;
+    }
+    if (code.length === 2) {
+        return isValidCountryCode2(code);
+    }
+    if (code.length === 3) {
+        return isValidCountryCode3(code);
+    }
+    return false;
+}
+/**
+ * Validate if a string is a valid country name
+ * @param name - The country name to validate
+ * @returns true if valid, false otherwise
+ * @example
+ * ```ts
+ * isValidCountryName("UnitedStates"); // true
+ * isValidCountryName("United States"); // true (case-insensitive)
+ * isValidCountryName("Atlantis"); // false
+ * ```
+ */
+function isValidCountryName(name) {
+    if (!name || typeof name !== 'string') {
+        return false;
+    }
+    return (0, utils_1.getCountryByName)(name) !== null;
+}
+/**
+ * Validate if a currency code is valid (ISO 4217)
+ * @param currencyCode - The currency code to validate
+ * @returns true if valid, false otherwise
+ * @example
+ * ```ts
+ * isValidCurrencyCode("USD"); // true
+ * isValidCurrencyCode("EUR"); // true
+ * isValidCurrencyCode("XXX"); // false (not used by any country)
+ * ```
+ */
+function isValidCurrencyCode(currencyCode) {
+    if (!currencyCode || typeof currencyCode !== 'string') {
+        return false;
+    }
+    if (currencyCode.length !== 3) {
+        return false;
+    }
+    const { getAllCountries } = require('./countryData');
+    const countries = getAllCountries();
+    return countries.some((country) => country.currencyCode.toUpperCase() === currencyCode.toUpperCase());
+}
+/**
+ * Validate if a calling code is valid
+ * @param callingCode - The calling code to validate (with or without +)
+ * @returns true if valid, false otherwise
+ * @example
+ * ```ts
+ * isValidCallingCode("+1"); // true
+ * isValidCallingCode("44"); // true
+ * isValidCallingCode("+999"); // false
+ * ```
+ */
+function isValidCallingCode(callingCode) {
+    if (!callingCode || typeof callingCode !== 'string') {
+        return false;
+    }
+    const normalizedCode = callingCode.startsWith('+') ? callingCode : `+${callingCode}`;
+    const { getAllCountries } = require('./countryData');
+    const countries = getAllCountries();
+    return countries.some((country) => country.callingCode === normalizedCode);
+}
+/**
+ * Basic phone number validation for a specific country
+ * @param phoneNumber - The phone number to validate
+ * @param countryIdentifier - Country name, code2, or code3
+ * @returns Validation result object
+ * @example
+ * ```ts
+ * validatePhoneNumber("2025551234", "US");
+ * // Returns: { isValid: true, formatted: "+1-202-555-1234", countryCode: "+1" }
+ * ```
+ */
+function validatePhoneNumber(phoneNumber, countryIdentifier) {
+    if (!phoneNumber || typeof phoneNumber !== 'string') {
+        return {
+            isValid: false,
+            error: 'Phone number is required'
+        };
+    }
+    const callingCode = (0, utils_1.getCallingCode)(countryIdentifier);
+    if (!callingCode) {
+        return {
+            isValid: false,
+            error: 'Invalid country identifier'
+        };
+    }
+    // Remove all non-digit characters
+    const digits = phoneNumber.replace(/\D/g, '');
+    if (digits.length === 0) {
+        return {
+            isValid: false,
+            error: 'Phone number must contain digits'
+        };
+    }
+    // Basic length validation (most phone numbers are between 7-15 digits)
+    if (digits.length < 7 || digits.length > 15) {
+        return {
+            isValid: false,
+            error: 'Phone number length is invalid'
+        };
+    }
+    // Format: +[country code]-[number]
+    const formatted = `${callingCode}-${digits}`;
+    return {
+        isValid: true,
+        formatted,
+        countryCode: callingCode
+    };
+}
+/**
+ * Parse a phone number and detect the country
+ * @param phoneNumber - The phone number to parse (with calling code)
+ * @returns Validation result with detected country
+ * @example
+ * ```ts
+ * parsePhoneNumber("+1-202-555-1234");
+ * // Returns: { isValid: true, formatted: "+1-2025551234", countryCode: "+1" }
+ * ```
+ */
+function parsePhoneNumber(phoneNumber) {
+    if (!phoneNumber || typeof phoneNumber !== 'string') {
+        return {
+            isValid: false,
+            error: 'Phone number is required'
+        };
+    }
+    // Extract calling code if present
+    const match = phoneNumber.match(/^\+?(\d{1,3})/);
+    if (!match) {
+        return {
+            isValid: false,
+            error: 'Could not detect calling code'
+        };
+    }
+    const detectedCode = `+${match[1]}`;
+    if (!isValidCallingCode(detectedCode)) {
+        return {
+            isValid: false,
+            error: 'Invalid calling code'
+        };
+    }
+    // Remove all non-digit characters
+    const digits = phoneNumber.replace(/\D/g, '');
+    if (digits.length === 0) {
+        return {
+            isValid: false,
+            error: 'Phone number must contain digits'
+        };
+    }
+    return {
+        isValid: true,
+        formatted: `+${digits}`,
+        countryCode: detectedCode
+    };
+}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "country-codes-library",
-  "version": "1.1.3",
+  "version": "2.0.0",
   "description": "The Country Code Library provides a collection of two-letter and three-letter country codes according to the ISO 3166-1 standard, as well as it provides USA, China and Canada Province codes (State codes / adminstrative division codes). In addition, it includes telephone calling codes, currency codes, currency Symbols for countries across the world.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "test" : "jest"
   },
   "files": [
     "dist"
@@ -21,34 +22,39 @@
   },
   "homepage": "https://github.com/mohansenthil/countrycodes-node#readme",
   "devDependencies": {
+    "@types/jest": "^29.5.13",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
     "typescript": "^5.6.2"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
   "keywords": [
-    "telephone",
-    "calling",
-    "two digit",
-    "three digit",
-    "two-digit-country-code",
-    "three-digit-country-code",
-    "twolettercountrycode",
-    "countrycode",
-    "threelettercountrycode",
-    "USAStateCode",
-    "+2digitcode",
-    "+3digitcode",
-    "ISO-3166",
     "country-codes",
+    "iso-3166",
+    "country-data",
+    "calling-codes",
+    "phone-codes",
+    "currency-codes",
+    "currency-symbols",
+    "iso-4217",
+    "country-lookup",
+    "country-validation",
+    "phone-validation",
+    "country-search",
+    "reverse-lookup",
+    "country-info",
+    "typescript",
+    "usa-states",
+    "canada-provinces",
+    "china-provinces",
+    "administrative-divisions",
+    "international-codes",
+    "telephone-codes",
+    "country-utilities",
     "geography",
-    "canadaprovince",
-    "chinaprovince",
-    "proviencecode",
-    "provience",
-    "geocode",
-    "countrycodes",
-    "currencycodes",
-    "currencysymbols"
+    "localization",
+    "i18n"
   ]
 }