@temboplus/frontend-core 0.2.4 → 0.2.6

package/script/src/models/country/country.js

@@ -1,7 +1,77 @@
 "use strict";
+/**
+ * @fileoverview This file contains both the Country class and CountryService class.
+ *
+ * ARCHITECTURE NOTE: Country and CountryService Classes
+ * ======================================================
+ *
+ * These two classes have been intentionally placed in the same file to resolve
+ * a circular dependency issue. The original implementation had these in separate files:
+ *
+ * - Country class: Defines country properties and static accessors
+ * - CountryService class: Loads country data and provides instance methods
+ *
+ * The circular dependency occurred because:
+ * 1. Country needed CountryService to initialize its static properties
+ * 2. CountryService needed Country to create Country instances
+ *
+ * By combining both classes in a single file:
+ * - We ensure proper initialization order
+ * - All static properties are immediately available after import
+ * - The public API remains unchanged
+ *
+ * This approach also better encapsulates related functionality in a single module,
+ * making it easier to understand and maintain the country-related domain model.
+ * The addition of currency support through the getCurrency() method leverages
+ * the Currency model while maintaining a clean separation of concerns.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Country = void 0;
-const service_js_1 = require("./service.js");
+exports.CountryService = exports.Country = exports.SUB_REGION = exports.CONTINENT = void 0;
+const currency_js_1 = require("../currency/currency.js");
+const countries_js_1 = __importDefault(require("../../data/countries.js"));
+/**
+ * Enum for continents
+ */
+var CONTINENT;
+(function (CONTINENT) {
+    CONTINENT["AFRICA"] = "Africa";
+    CONTINENT["ANTARCTICA"] = "Antarctica";
+    CONTINENT["ASIA"] = "Asia";
+    CONTINENT["EUROPE"] = "Europe";
+    CONTINENT["NORTH_AMERICA"] = "North America";
+    CONTINENT["OCEANIA"] = "Oceania";
+    CONTINENT["SOUTH_AMERICA"] = "South America";
+})(CONTINENT || (exports.CONTINENT = CONTINENT = {}));
+/**
+ * Enum for sub-regions
+ */
+var SUB_REGION;
+(function (SUB_REGION) {
+    SUB_REGION["AUSTRALIA_AND_NEW_ZEALAND"] = "Australia and New Zealand";
+    SUB_REGION["CARIBBEAN"] = "Caribbean";
+    SUB_REGION["CENTRAL_AMERICA"] = "Central America";
+    SUB_REGION["CENTRAL_ASIA"] = "Central Asia";
+    SUB_REGION["EASTERN_AFRICA"] = "Eastern Africa";
+    SUB_REGION["EASTERN_ASIA"] = "Eastern Asia";
+    SUB_REGION["EASTERN_EUROPE"] = "Eastern Europe";
+    SUB_REGION["MELANESIA"] = "Melanesia";
+    SUB_REGION["MICRONESIA"] = "Micronesia";
+    SUB_REGION["MIDDLE_AFRICA"] = "Middle Africa";
+    SUB_REGION["NORTHERN_AFRICA"] = "Northern Africa";
+    SUB_REGION["NORTHERN_AMERICA"] = "Northern America";
+    SUB_REGION["NORTHERN_EUROPE"] = "Northern Europe";
+    SUB_REGION["POLYNESIA"] = "Polynesia";
+    SUB_REGION["SOUTH_EASTERN_ASIA"] = "South-eastern Asia";
+    SUB_REGION["SOUTHERN_AFRICA"] = "Southern Africa";
+    SUB_REGION["SOUTHERN_ASIA"] = "Southern Asia";
+    SUB_REGION["SOUTHERN_EUROPE"] = "Southern Europe";
+    SUB_REGION["WESTERN_AFRICA"] = "Western Africa";
+    SUB_REGION["WESTERN_ASIA"] = "Western Asia";
+    SUB_REGION["WESTERN_EUROPE"] = "Western Europe";
+})(SUB_REGION || (exports.SUB_REGION = SUB_REGION = {}));
 /**
  * Represents a country with essential details.
  * @class Country
@@ -9,36 +79,130 @@ const service_js_1 = require("./service.js");
 class Country {
     /**
      * Creates a new Country instance.
-     * @param {string} _name - The full name of the country
-     * @param {string} _code - The ISO country code
+     * @param {string} _name - The common name of the country
+     * @param {string} _iso2 - The ISO-2 country code
+     * @param {string} _nameOfficial - The official name of the country
+     * @param {string} _iso3 - The ISO-3 country code
+     * @param {string} _flagEmoji - The flag emoji of the country
+     * @param {CONTINENT} _continent - The continent where the country is located
+     * @param {SUB_REGION} _region - The region within the continent where the country is located
+     * @param {string | null} _currencyCode - The ISO currency code used in the country
      */
-    constructor(_name, _code) {
+    constructor(_name, _iso2, _nameOfficial = "", _iso3, _flagEmoji = "", _continent = CONTINENT.EUROPE, _region = SUB_REGION.NORTHERN_EUROPE, _currencyCode = null) {
         Object.defineProperty(this, "_name", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: _name
         });
-        Object.defineProperty(this, "_code", {
+        Object.defineProperty(this, "_iso2", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: _iso2
+        });
+        Object.defineProperty(this, "_nameOfficial", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: _nameOfficial
+        });
+        Object.defineProperty(this, "_iso3", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: _iso3
+        });
+        Object.defineProperty(this, "_flagEmoji", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: _flagEmoji
+        });
+        Object.defineProperty(this, "_continent", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: _code
+            value: _continent
+        });
+        Object.defineProperty(this, "_region", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: _region
+        });
+        Object.defineProperty(this, "_currencyCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: _currencyCode
         });
     }
     /**
-     * Gets the full name of the country.
-     * @returns {string} The full name of the country
+     * Gets the common name of the country.
+     * @returns {string} The common name of the country
      */
     get name() {
         return this._name;
     }
     /**
-     * Gets the ISO code of the country.
-     * @returns {string} The ISO code of the country
+     * Gets the ISO-2 code of the country.
+     * @returns {ISO2CountryCode} The ISO-2 code of the country
      */
     get code() {
-        return this._code;
+        return this._iso2;
+    }
+    /**
+     * Gets the official name of the country.
+     * @returns {string} The official name of the country
+     */
+    get nameOfficial() {
+        return this._nameOfficial;
+    }
+    /**
+     * Gets the ISO-3 code of the country.
+     * @returns {ISO3CountryCode} The ISO-3 code of the country
+     */
+    get iso3() {
+        return this._iso3;
+    }
+    /**
+     * Gets the flag emoji of the country.
+     * @returns {string} The flag emoji of the country
+     */
+    get flagEmoji() {
+        return this._flagEmoji;
+    }
+    /**
+     * Gets the continent where the country is located.
+     * @returns {CONTINENT} The continent where the country is located
+     */
+    get continent() {
+        return this._continent;
+    }
+    /**
+     * Gets the region within the continent where the country is located.
+     * @returns {SUB_REGION} The region within the continent where the country is located
+     */
+    get region() {
+        return this._region;
+    }
+    /**
+     * Gets the ISO currency code used in the country.
+     * @returns {string | null} The ISO currency code of the country, or null if not available
+     */
+    get currencyCode() {
+        return this._currencyCode;
+    }
+    /**
+     * Gets the Currency instance for this country.
+     * @returns {Currency | undefined} The Currency instance or undefined if no currency is assigned
+     */
+    getCurrency() {
+        if (!this._currencyCode) {
+            return undefined;
+        }
+        return currency_js_1.Currency.fromCode(this._currencyCode);
     }
     /**
      * Creates a string representation of the country.
@@ -48,12 +212,27 @@ class Country {
         return `${this.name} (${this.code})`;
     }
     /**
-     * Retrieves a country by its ISO code.
-     * @param {string} code The ISO code of the country.
+     * Creates a detailed string representation of the country including the flag.
+     * @returns {string} Detailed string representation of the country
+     */
+    toDetailedString() {
+        return `${this.flagEmoji} ${this.name} (${this.code}, ${this.iso3})`;
+    }
+    /**
+     * Retrieves a country by its ISO-2 or ISO-3 code.
+     * @param {CountryCode} code The ISO-2 or ISO-3 code of the country.
      * @returns {Country | undefined} The country corresponding to the ISO code or `undefined` if not found.
      */
     static fromCode(code) {
-        return service_js_1.CountryService.getInstance().fromCode(code);
+        return CountryService.getInstance().fromCode(code);
+    }
+    /**
+     * Retrieves a country by its ISO-3 code.
+     * @param {ISO3CountryCode} iso3 The ISO-3 code of the country.
+     * @returns {Country | undefined} The country corresponding to the ISO-3 code or `undefined` if not found.
+     */
+    static fromIso3(iso3) {
+        return CountryService.getInstance().fromIso3(iso3);
     }
     /**
      * Retrieves a country by its name.
@@ -61,25 +240,44 @@ class Country {
      * @returns {Country | undefined} The country corresponding to the name or `undefined` if not found.
      */
     static fromName(countryName) {
-        return service_js_1.CountryService.getInstance().fromName(countryName);
+        return CountryService.getInstance().fromName(countryName);
     }
     /**
      * Returns all available countries.
      * @returns {Country[]} Array of all countries
      */
     static getAll() {
-        return service_js_1.CountryService.getInstance().getAll();
+        return CountryService.getInstance().getAll();
     }
     /**
-     * Validates if a given ISO country code is valid
-     * @param code The country code to validate
-     * @returns True if the country code is valid
+     * Returns countries from a specific continent.
+     * @param {CONTINENT} continent The continent enum value
+     * @returns {Country[]} Array of countries in the specified continent
      */
-    static isValidCode(code) {
-        if (!code)
-            return false;
-        const country = Country.fromCode(code);
-        return !!country;
+    static getByContinent(continent) {
+        return CountryService.getInstance().getByContinent(continent);
+    }
+    /**
+     * Returns countries from a specific region.
+     * @param {SUB_REGION} region The region enum value
+     * @returns {Country[]} Array of countries in the specified region
+     */
+    static getByRegion(region) {
+        return CountryService.getInstance().getByRegion(region);
+    }
+    /**
+     * Returns a list of all available continents.
+     * @returns {CONTINENT[]} Array of continent enum values
+     */
+    static getContinents() {
+        return Object.values(CONTINENT);
+    }
+    /**
+     * Returns a list of all available regions.
+     * @returns {SUB_REGION[]} Array of region enum values
+     */
+    static getRegions() {
+        return Object.values(SUB_REGION);
     }
     /**
      * Validates if a given country name is valid
@@ -99,7 +297,7 @@ class Country {
     validate() {
         try {
             return (Country.fromName(this._name) !== undefined &&
-                Country.fromCode(this._code) !== undefined);
+                Country.fromCode(this._iso2) !== undefined);
         }
         catch (_) {
             return false;
@@ -115,9 +313,14 @@ class Country {
             const country1 = Country.fromName(input);
             if (country1)
                 return country1;
+            // deno-lint-ignore no-explicit-any
             const country2 = Country.fromCode(input);
             if (country2)
                 return country2;
+            // deno-lint-ignore no-explicit-any
+            const country3 = Country.fromIso3(input);
+            if (country3)
+                return country3;
         }
         return undefined;
     }
@@ -132,9 +335,14 @@ class Country {
         const text = input.trim();
         if (text.length === 0)
             return false;
-        const countryFromCode = Country.fromCode(text);
         const countryFromName = Country.fromName(text);
-        return countryFromCode !== undefined || countryFromName !== undefined;
+        // deno-lint-ignore no-explicit-any
+        const countryFromCode = Country.fromCode(text);
+        // deno-lint-ignore no-explicit-any
+        const countryFromIso3 = Country.fromIso3(text);
+        return countryFromCode !== undefined ||
+            countryFromName !== undefined ||
+            countryFromIso3 !== undefined;
     }
     /**
      * Checks if an unknown value is a Country instance
@@ -145,13 +353,14 @@ class Country {
         if (!obj || typeof obj !== "object")
             return false;
         const maybeCountry = obj;
+        console.log(maybeCountry);
         // Check private properties exist with correct types
         if (typeof maybeCountry._name !== "string")
             return false;
-        if (typeof maybeCountry._code !== "string")
+        if (typeof maybeCountry._iso2 !== "string")
             return false;
         // Validate against known countries
-        const countryFromCode = Country.from(maybeCountry._code);
+        const countryFromCode = Country.from(maybeCountry._iso2);
         const countryFromName = Country.from(maybeCountry._name);
         return Boolean(countryFromCode &&
             countryFromName &&
@@ -159,11 +368,378 @@ class Country {
     }
 }
 exports.Country = Country;
+/**
+ * Service for managing country data.
+ * @class CountryService
+ */
+class CountryService {
+    constructor() {
+        Object.defineProperty(this, "countryList", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "codeRecord", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "iso3Record", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "nameRecord", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "continentRecord", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "regionRecord", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        // Static references for direct access through Country class
+        Object.defineProperty(this, "staticReferences", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    /**
+     * Gets the singleton instance of CountryService.
+     * Creates the instance if it doesn't exist.
+     * @static
+     * @returns {CountryService} The singleton instance
+     */
+    static getInstance() {
+        if (!CountryService.instance) {
+            CountryService.instance = new CountryService();
+            CountryService.instance.initialize();
+        }
+        return CountryService.instance;
+    }
+    /**
+     * Maps a string continent name to the CONTINENT enum
+     * @param continentName String continent name from JSON
+     * @returns The corresponding CONTINENT enum value
+     */
+    mapContinent(continentName) {
+        switch (continentName) {
+            case "Africa":
+                return CONTINENT.AFRICA;
+            case "Antarctica":
+                return CONTINENT.ANTARCTICA;
+            case "Asia":
+                return CONTINENT.ASIA;
+            case "Europe":
+                return CONTINENT.EUROPE;
+            case "North America":
+                return CONTINENT.NORTH_AMERICA;
+            case "Oceania":
+                return CONTINENT.OCEANIA;
+            case "South America":
+                return CONTINENT.SOUTH_AMERICA;
+            default:
+                return CONTINENT.EUROPE; // Default value
+        }
+    }
+    /**
+     * Maps a string region name to the SUB_REGION enum
+     * @param regionName String region name from JSON
+     * @returns The corresponding SUB_REGION enum value
+     */
+    mapRegion(regionName) {
+        switch (regionName) {
+            case "Australia and New Zealand":
+                return SUB_REGION.AUSTRALIA_AND_NEW_ZEALAND;
+            case "Caribbean":
+                return SUB_REGION.CARIBBEAN;
+            case "Central America":
+                return SUB_REGION.CENTRAL_AMERICA;
+            case "Central Asia":
+                return SUB_REGION.CENTRAL_ASIA;
+            case "Eastern Africa":
+                return SUB_REGION.EASTERN_AFRICA;
+            case "Eastern Asia":
+                return SUB_REGION.EASTERN_ASIA;
+            case "Eastern Europe":
+                return SUB_REGION.EASTERN_EUROPE;
+            case "Melanesia":
+                return SUB_REGION.MELANESIA;
+            case "Micronesia":
+                return SUB_REGION.MICRONESIA;
+            case "Middle Africa":
+                return SUB_REGION.MIDDLE_AFRICA;
+            case "Northern Africa":
+                return SUB_REGION.NORTHERN_AFRICA;
+            case "Northern America":
+                return SUB_REGION.NORTHERN_AMERICA;
+            case "Northern Europe":
+                return SUB_REGION.NORTHERN_EUROPE;
+            case "Polynesia":
+                return SUB_REGION.POLYNESIA;
+            case "South-eastern Asia":
+                return SUB_REGION.SOUTH_EASTERN_ASIA;
+            case "Southern Africa":
+                return SUB_REGION.SOUTHERN_AFRICA;
+            case "Southern Asia":
+                return SUB_REGION.SOUTHERN_ASIA;
+            case "Southern Europe":
+                return SUB_REGION.SOUTHERN_EUROPE;
+            case "Western Africa":
+                return SUB_REGION.WESTERN_AFRICA;
+            case "Western Asia":
+                return SUB_REGION.WESTERN_ASIA;
+            case "Western Europe":
+                return SUB_REGION.WESTERN_EUROPE;
+            default:
+                return SUB_REGION.NORTHERN_EUROPE; // Default value
+        }
+    }
+    /**
+     * Initializes the service with country data.
+     * Should be called once when your application starts.
+     */
+    initialize() {
+        try {
+            // Parse the JSON data
+            const data = JSON.parse(JSON.stringify(countries_js_1.default));
+            // deno-lint-ignore no-explicit-any
+            const countriesData = data.countries || [];
+            // Initialize continent and region records
+            Object.values(CONTINENT).forEach((continent) => {
+                this.continentRecord[continent] = [];
+            });
+            Object.values(SUB_REGION).forEach((region) => {
+                this.regionRecord[region] = [];
+            });
+            // Create Country instances from the data
+            const countries = countriesData.map((c) => {
+                const continent = this.mapContinent(c.continent);
+                const region = this.mapRegion(c.region);
+                return new Country(c.name, c.iso_2, c.name_official, c.iso_3, c.flag_emoji, continent, region, c.currency_iso_iso2);
+            });
+            const code_record = {};
+            const iso3_record = {};
+            const name_record = {};
+            countries.forEach((country) => {
+                // Populate code records
+                code_record[country.code] = country;
+                iso3_record[country.iso3] = country;
+                // Add to record by name
+                // Generate uppercase full name with underscores
+                const nameKey = country.name
+                    .toUpperCase()
+                    .replace(/\s+/g, "_")
+                    .replace(/[-(),.']/g, "")
+                    .replace(/&/g, "AND");
+                name_record[nameKey] = country;
+                // Group countries by continent
+                this.continentRecord[country.continent].push(country);
+                // Group countries by region
+                this.regionRecord[country.region].push(country);
+                this.staticReferences.set(country.code, country);
+                this.staticReferences.set(nameKey, country);
+            });
+            // Add specific country mappings for special cases
+            // Cocos Islands
+            if (code_record["CC"]) {
+                name_record["COCOS_ISLANDS"] = code_record["CC"];
+                this.staticReferences.set("COCOS_ISLANDS", code_record["CC"]);
+            }
+            // Cote d'Ivoire
+            if (code_record["CI"]) {
+                name_record["COTE_DIVOIRE"] = code_record["CI"];
+                this.staticReferences.set("COTE_DIVOIRE", code_record["CI"]);
+            }
+            // Macedonia (North Macedonia)
+            if (code_record["MK"]) {
+                name_record["MACEDONIA"] = code_record["MK"];
+                this.staticReferences.set("MACEDONIA", code_record["MK"]);
+            }
+            // US Virgin Islands
+            if (code_record["VI"]) {
+                name_record["VIRGIN_ISLANDS_US"] = code_record["VI"];
+                this.staticReferences.set("VIRGIN_ISLANDS_US", code_record["VI"]);
+            }
+            // British Virgin Islands
+            if (code_record["VG"]) {
+                name_record["VIRGIN_ISLANDS_BRITISH"] = code_record["VG"];
+                this.staticReferences.set("VIRGIN_ISLANDS_BRITISH", code_record["VG"]);
+            }
+            // Democratic Republic of the Congo
+            if (code_record["CD"]) {
+                name_record["DEMOCRATIC_REPUBLIC_OF_CONGO"] = code_record["CD"];
+                this.staticReferences.set("DEMOCRATIC_REPUBLIC_OF_CONGO", code_record["CD"]);
+            }
+            // Falkland Islands (Malvinas)
+            if (code_record["FK"]) {
+                name_record["FALKLAND_ISLANDS"] = code_record["FK"];
+                this.staticReferences.set("FALKLAND_ISLANDS", code_record["FK"]);
+            }
+            // Lao
+            if (code_record["LA"]) {
+                name_record["LAO"] = code_record["LA"];
+                this.staticReferences.set("LAO", code_record["LA"]);
+            }
+            this.codeRecord = code_record;
+            this.iso3Record = iso3_record;
+            this.nameRecord = name_record;
+            this.countryList = countries;
+            // Initialize static properties on Country class
+            this.initializeCountryStatics();
+        }
+        catch (error) {
+            console.error("Failed to initialize CountryService:", error);
+        }
+    }
+    /**
+     * Initialize the static properties on the Country class
+     */
+    initializeCountryStatics() {
+        // Initialize ISO-2 code properties
+        Object.entries(this.codeRecord).forEach(([code, country]) => {
+            // deno-lint-ignore no-explicit-any
+            Country[code.toUpperCase()] = country;
+        });
+        // Initialize full name properties
+        Object.entries(this.nameRecord).forEach(([fullName, country]) => {
+            // deno-lint-ignore no-explicit-any
+            Country[fullName] = country;
+        });
+    }
+    /**
+     * Gets all countries.
+     * @returns {Country[]} Array of all countries
+     */
+    getAll() {
+        return this.countryList;
+    }
+    /**
+     * Gets static country references to be used by the Country class.
+     * @returns {Map<string, Country>} Map of static references
+     */
+    getStaticReferences() {
+        return this.staticReferences;
+    }
+    /**
+     * Gets all countries as a record.
+     * @returns {Record<string, Country>} Record of country codes and country objects
+     */
+    getAllAsRecord() {
+        return this.codeRecord;
+    }
+    /**
+     * Gets all countries from a specific continent.
+     * @param {CONTINENT} continent The continent enum value
+     * @returns {Country[]} Array of countries in the specified continent
+     */
+    getByContinent(continent) {
+        return this.continentRecord[continent] || [];
+    }
+    /**
+     * Gets all countries from a specific region.
+     * @param {SUB_REGION} region The region enum value
+     * @returns {Country[]} Array of countries in the specified region
+     */
+    getByRegion(region) {
+        return this.regionRecord[region] || [];
+    }
+    /**
+     * Gets the full name record mapping.
+     * @returns {Record<string, Country>} Record of uppercase full name keys to country objects
+     */
+    getFullNameRecord() {
+        return this.nameRecord;
+    }
+    /**
+     * Retrieves a country by its ISO-2 code.
+     * @param {string} code The ISO-2 code of the country.
+     * @returns {Country | undefined} The country corresponding to the ISO code or `undefined` if not found.
+     */
+    fromCode(code) {
+        return this.codeRecord[code.toUpperCase()];
+    }
+    /**
+     * Retrieves a country by its ISO-3 code.
+     * @param {ISO3CountryCode} iso3 The ISO-3 code of the country.
+     * @returns {Country | undefined} The country corresponding to the ISO-3 code or `undefined` if not found.
+     */
+    fromIso3(iso3) {
+        return this.iso3Record[iso3.toUpperCase()];
+    }
+    /**
+     * Retrieves a country by its name.
+     * @param {string} countryName The name of the country.
+     * @returns {Country | undefined} The country corresponding to the name or `undefined` if not found.
+     */
+    fromName(countryName) {
+        const fullNameKey = countryName
+            .toUpperCase()
+            .replace(/\s+/g, "_")
+            .replace(/[-(),.']/g, "")
+            .replace(/&/g, "AND");
+        const fullNameMatch = this.nameRecord[fullNameKey];
+        if (fullNameMatch)
+            return fullNameMatch;
+        // If not found, try more lenient matching
+        return this.countryList.find((country) => country.name.toLowerCase() === countryName.toLowerCase());
+    }
+    /**
+     * Searches for countries that match the given search term.
+     * @param {string} searchTerm - The partial name or code to search for.
+     * @param {number} [limit=10] - Maximum number of results to return.
+     * @returns {Country[]} Array of matching countries, limited to specified count.
+     */
+    search(searchTerm, limit = 10) {
+        if (!searchTerm || typeof searchTerm !== "string")
+            return [];
+        const term = searchTerm.toLowerCase().trim();
+        if (term.length === 0)
+            return [];
+        const results = this.countryList.filter((country) => country.name.toLowerCase().includes(term) ||
+            country.nameOfficial.toLowerCase().includes(term) ||
+            country.code.toLowerCase().includes(term) ||
+            country.iso3.toLowerCase().includes(term));
+        return results.slice(0, limit);
+    }
+    /**
+     * Compares two Country instances for equality by checking their name and code
+     *
+     * @param {Country} country1 - First country to compare
+     * @param {Country} country2 - Second country to compare
+     * @returns {boolean} True if countries are equal, false otherwise
+     * @private
+     */
+    compare(country1, country2) {
+        return (country1.name === country2.name &&
+            country1.code === country2.code);
+    }
+}
+exports.CountryService = CountryService;
 // Initialize static properties by applying the references from CountryService
 (function setupStaticReferences() {
-    const staticRefs = service_js_1.CountryService.getInstance().getStaticReferences();
-    staticRefs.forEach((country, key) => {
-        // deno-lint-ignore no-explicit-any
-        Country[key] = country;
-    });
+    try {
+        const refs = CountryService.getInstance().getStaticReferences();
+        refs.forEach((country, key) => {
+            // deno-lint-ignore no-explicit-any
+            Country[key] = country;
+        });
+    }
+    catch (error) {
+        console.log("Failed to set up static references: ", error);
+    }
 })();