@temboplus/frontend-core 0.2.1 → 0.2.3

package/esm/src/models/country/country.js

@@ -0,0 +1,165 @@
+import { CountryService } from "./service.js";
+/**
+ * Represents a country with essential details.
+ * @class Country
+ */
+export class Country {
+    /**
+     * Creates a new Country instance.
+     * @param {string} _name - The full name of the country
+     * @param {string} _code - The ISO country code
+     */
+    constructor(_name, _code) {
+        Object.defineProperty(this, "_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: _name
+        });
+        Object.defineProperty(this, "_code", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: _code
+        });
+    }
+    /**
+     * Gets the full name of the country.
+     * @returns {string} The full name of the country
+     */
+    get name() {
+        return this._name;
+    }
+    /**
+     * Gets the ISO code of the country.
+     * @returns {string} The ISO code of the country
+     */
+    get code() {
+        return this._code;
+    }
+    /**
+     * Creates a string representation of the country.
+     * @returns {string} String representation of the country
+     */
+    toString() {
+        return `${this.name} (${this.code})`;
+    }
+    /**
+     * Retrieves a country by its ISO code.
+     * @param {string} code The ISO code of the country.
+     * @returns {Country | undefined} The country corresponding to the ISO code or `undefined` if not found.
+     */
+    static fromCode(code) {
+        return CountryService.getInstance().fromCode(code);
+    }
+    /**
+     * 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.
+     */
+    static fromName(countryName) {
+        return CountryService.getInstance().fromName(countryName);
+    }
+    /**
+     * Returns all available countries.
+     * @returns {Country[]} Array of all countries
+     */
+    static 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
+     */
+    static isValidCode(code) {
+        if (!code)
+            return false;
+        const country = Country.fromCode(code);
+        return !!country;
+    }
+    /**
+     * Validates if a given country name is valid
+     * @param countryName The country name to validate
+     * @returns True if the country name is valid
+     */
+    static isValidName(countryName) {
+        if (!countryName)
+            return false;
+        const country = Country.fromName(countryName);
+        return !!country;
+    }
+    /**
+     * Checks the validity of the country data
+     * @returns true if the country information is available and valid
+     */
+    validate() {
+        try {
+            return (Country.fromName(this._name) !== undefined &&
+                Country.fromCode(this._code) !== undefined);
+        }
+        catch (_) {
+            return false;
+        }
+    }
+    /**
+     * Attempts to create a Country instance from a country name or ISO code
+     * @param input The country name or ISO code
+     * @returns A Country instance if valid input, undefined otherwise
+     */
+    static from(input) {
+        if (Country.canConstruct(input)) {
+            const country1 = Country.fromName(input);
+            if (country1)
+                return country1;
+            const country2 = Country.fromCode(input);
+            if (country2)
+                return country2;
+        }
+        return undefined;
+    }
+    /**
+     * Validates if the input can be used to construct a valid Country instance
+     * @param input The country name or ISO code to validate
+     * @returns True if input can construct a valid country, false otherwise
+     */
+    static canConstruct(input) {
+        if (!input || typeof input !== "string")
+            return false;
+        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;
+    }
+    /**
+     * Checks if an unknown value is a Country instance
+     * @param obj The value to validate
+     * @returns Type predicate indicating if the value is a valid Country
+     */
+    static is(obj) {
+        if (!obj || typeof obj !== "object")
+            return false;
+        const maybeCountry = obj;
+        // Check private properties exist with correct types
+        if (typeof maybeCountry._name !== "string")
+            return false;
+        if (typeof maybeCountry._code !== "string")
+            return false;
+        // Validate against known countries
+        const countryFromCode = Country.from(maybeCountry._code);
+        const countryFromName = Country.from(maybeCountry._name);
+        return Boolean(countryFromCode &&
+            countryFromName &&
+            countryFromCode.code === countryFromName.code);
+    }
+}
+// Initialize static properties by applying the references from CountryService
+(function setupStaticReferences() {
+    const staticRefs = CountryService.getInstance().getStaticReferences();
+    staticRefs.forEach((country, key) => {
+        // deno-lint-ignore no-explicit-any
+        Country[key] = country;
+    });
+})();

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

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

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

@@ -0,0 +1,3 @@
+export * from "./country.js";
+export * from "./service.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/src/models/country/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA"}

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

@@ -0,0 +1,2 @@
+export * from "./country.js";
+export * from "./service.js";

package/esm/src/models/country/service.d.ts

@@ -0,0 +1,75 @@
+import { Country } from "./country.js";
+/**
+ * Service for managing country data.
+ * @class CountryService
+ */
+export declare class CountryService {
+    private static instance;
+    private countryList;
+    private codeRecord;
+    private nameRecord;
+    private fullNameRecord;
+    private staticReferences;
+    private constructor();
+    /**
+     * Gets the singleton instance of CountryService.
+     * Creates the instance if it doesn't exist.
+     * @static
+     * @returns {CountryService} The singleton instance
+     */
+    static getInstance(): CountryService;
+    /**
+     * Initializes the service with country data.
+     * Should be called once when your application starts.
+     */
+    private initialize;
+    /**
+     * Gets all countries.
+     * @returns {Country[]} Array of all countries
+     */
+    getAll(): Country[];
+    /**
+     * Gets all countries as a record.
+     * @returns {Record<string, Country>} Record of country codes and country objects
+     */
+    getAllAsRecord(): Record<string, Country>;
+    /**
+     * Gets static country references to be used by the Country class.
+     * @returns {Map<string, Country>} Map of static references
+     */
+    getStaticReferences(): Map<string, Country>;
+    /**
+     * Gets the full name record mapping.
+     * @returns {Record<string, Country>} Record of uppercase full name keys to country objects
+     */
+    getFullNameRecord(): Record<string, Country>;
+    /**
+     * Retrieves a country by its ISO code.
+     * @param {string} code The ISO code of the country.
+     * @returns {Country | undefined} The country corresponding to the ISO code or `undefined` if not found.
+     */
+    fromCode(code: string): Country | undefined;
+    /**
+     * 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: string): Country | undefined;
+    /**
+     * 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: string, limit?: number): Country[];
+    /**
+     * 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: Country, country2: Country): boolean;
+}
+//# sourceMappingURL=service.d.ts.map

package/esm/src/models/country/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../src/src/models/country/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC;;;GAGG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAiB;IACxC,OAAO,CAAC,WAAW,CAAiB;IACpC,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,cAAc,CAA+B;IAGrD,OAAO,CAAC,gBAAgB,CAAmC;IAE3D,OAAO;IAEP;;;;;OAKG;IACH,MAAM,CAAC,WAAW,IAAI,cAAc;IAQpC;;;OAGG;IACH,OAAO,CAAC,UAAU;IA2JlB;;;OAGG;IACH,MAAM,IAAI,OAAO,EAAE;IAInB;;;OAGG;IACH,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAIzC;;;OAGG;IACH,mBAAmB,IAAI,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC;IAI3C;;;OAGG;IACH,iBAAiB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAI5C;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAI3C;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAqBlD;;;;;OAKG;IACH,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,GAAE,MAAW,GAAG,OAAO,EAAE;IAczD;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO;CAMvD"}

package/esm/src/models/country/service.js

@@ -0,0 +1,267 @@
+import { Country } from "./country.js";
+import file from "../../data/countries.js";
+/**
+ * Service for managing country data.
+ * @class CountryService
+ */
+export 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, "nameRecord", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "fullNameRecord", {
+            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;
+    }
+    /**
+     * Initializes the service with country data.
+     * Should be called once when your application starts.
+     */
+    initialize() {
+        try {
+            const data = JSON.parse(JSON.stringify(file));
+            const countries = Object.values(data).map((c) => new Country(c.name, c.code));
+            const code_record = {};
+            const name_record = {};
+            const fullname_record = {};
+            countries.forEach((country) => {
+                // Populate code record
+                code_record[country.code] = country;
+                // Add to record by name
+                name_record[country.name.toUpperCase()] = country;
+                // Generate uppercase full name with underscores
+                const fullNameKey = country.name
+                    .toUpperCase()
+                    .replace(/\s+/g, "_")
+                    .replace(/[-(),.']/g, "")
+                    .replace(/&/g, "AND");
+                fullname_record[fullNameKey] = country;
+                // Save references for static access
+                this.staticReferences.set(country.code.toUpperCase(), country);
+                this.staticReferences.set(fullNameKey, country);
+            });
+            // Ensure specific mappings are available
+            if (code_record["US"]) {
+                fullname_record["UNITED_STATES"] = code_record["US"];
+                this.staticReferences.set("UNITED_STATES", code_record["US"]);
+            }
+            // Add specific country mappings
+            // Cocos Islands
+            if (code_record["CC"]) {
+                fullname_record["COCOS_ISLANDS"] = code_record["CC"];
+                this.staticReferences.set("COCOS_ISLANDS", code_record["CC"]);
+            }
+            // Democratic Republic of Congo
+            if (code_record["CD"]) {
+                fullname_record["DEMOCRATIC_REPUBLIC_OF_CONGO"] = code_record["CD"];
+                this.staticReferences.set("DEMOCRATIC_REPUBLIC_OF_CONGO", code_record["CD"]);
+            }
+            // Cote d'Ivoire
+            if (code_record["CI"]) {
+                fullname_record["COTE_DIVOIRE"] = code_record["CI"];
+                this.staticReferences.set("COTE_DIVOIRE", code_record["CI"]);
+            }
+            // Falkland Islands
+            if (code_record["FK"]) {
+                fullname_record["FALKLAND_ISLANDS"] = code_record["FK"];
+                this.staticReferences.set("FALKLAND_ISLANDS", code_record["FK"]);
+            }
+            // Holy See (Vatican)
+            if (code_record["VA"]) {
+                fullname_record["HOLY_SEE"] = code_record["VA"];
+                this.staticReferences.set("HOLY_SEE", code_record["VA"]);
+            }
+            // Iran
+            if (code_record["IR"]) {
+                fullname_record["IRAN"] = code_record["IR"];
+                this.staticReferences.set("IRAN", code_record["IR"]);
+            }
+            // North Korea
+            if (code_record["KP"]) {
+                fullname_record["NORTH_KOREA"] = code_record["KP"];
+                this.staticReferences.set("NORTH_KOREA", code_record["KP"]);
+            }
+            // South Korea
+            if (code_record["KR"]) {
+                fullname_record["SOUTH_KOREA"] = code_record["KR"];
+                this.staticReferences.set("SOUTH_KOREA", code_record["KR"]);
+            }
+            // Lao People's Democratic Republic
+            if (code_record["LA"]) {
+                fullname_record["LAO"] = code_record["LA"];
+                this.staticReferences.set("LAO", code_record["LA"]);
+            }
+            // Palestine
+            if (code_record["PS"]) {
+                fullname_record["PALESTINE"] = code_record["PS"];
+                this.staticReferences.set("PALESTINE", code_record["PS"]);
+            }
+            // Macedonia
+            if (code_record["MK"]) {
+                fullname_record["MACEDONIA"] = code_record["MK"];
+                this.staticReferences.set("MACEDONIA", code_record["MK"]);
+            }
+            // Micronesia
+            if (code_record["FM"]) {
+                fullname_record["MICRONESIA"] = code_record["FM"];
+                this.staticReferences.set("MICRONESIA", code_record["FM"]);
+            }
+            // Moldova
+            if (code_record["MD"]) {
+                fullname_record["MOLDOVA"] = code_record["MD"];
+                this.staticReferences.set("MOLDOVA", code_record["MD"]);
+            }
+            // Taiwan
+            if (code_record["TW"]) {
+                fullname_record["TAIWAN"] = code_record["TW"];
+                this.staticReferences.set("TAIWAN", code_record["TW"]);
+            }
+            // Tanzania
+            if (code_record["TZ"]) {
+                fullname_record["TANZANIA"] = code_record["TZ"];
+                this.staticReferences.set("TANZANIA", code_record["TZ"]);
+            }
+            // US Virgin Islands
+            if (code_record["VI"]) {
+                fullname_record["VIRGIN_ISLANDS_US"] = code_record["VI"];
+                this.staticReferences.set("VIRGIN_ISLANDS_US", code_record["VI"]);
+            }
+            // British Virgin Islands
+            if (code_record["VG"]) {
+                fullname_record["VIRGIN_ISLANDS_BRITISH"] = code_record["VG"];
+                this.staticReferences.set("VIRGIN_ISLANDS_BRITISH", code_record["VG"]);
+            }
+            this.codeRecord = code_record;
+            this.nameRecord = name_record;
+            this.fullNameRecord = fullname_record;
+            this.countryList = countries;
+        }
+        catch (error) {
+            console.error("Failed to initialize CountryService:", error);
+        }
+    }
+    /**
+     * Gets all countries.
+     * @returns {Country[]} Array of all countries
+     */
+    getAll() {
+        return this.countryList;
+    }
+    /**
+     * Gets all countries as a record.
+     * @returns {Record<string, Country>} Record of country codes and country objects
+     */
+    getAllAsRecord() {
+        return this.codeRecord;
+    }
+    /**
+     * Gets static country references to be used by the Country class.
+     * @returns {Map<string, Country>} Map of static references
+     */
+    getStaticReferences() {
+        return this.staticReferences;
+    }
+    /**
+     * Gets the full name record mapping.
+     * @returns {Record<string, Country>} Record of uppercase full name keys to country objects
+     */
+    getFullNameRecord() {
+        return this.fullNameRecord;
+    }
+    /**
+     * Retrieves a country by its ISO code.
+     * @param {string} code The ISO 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 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) {
+        // First try direct lookup in name record
+        const directMatch = this.nameRecord[countryName.toUpperCase()];
+        if (directMatch)
+            return directMatch;
+        // Then try full name record
+        const fullNameKey = countryName
+            .toUpperCase()
+            .replace(/\s+/g, "_")
+            .replace(/[-(),.']/g, "")
+            .replace(/&/g, "AND");
+        const fullNameMatch = this.fullNameRecord[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.code.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);
+    }
+}