country-data-filter 1.0.15 → 1.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "country-data-filter",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "description": "A package to filter country data",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/src/countries/LK/LK.js

@@ -27,6 +27,7 @@ import { vavuniya } from "./districts/vavuniya";
 export const LK = {
   name: "Sri Lanka",
   code: "LK",
+  countryCode: "+94",
   provinces: {
     southern: {
       name: "Southern Province",

package/src/functions/{getCountryProvinceDistrictByCity.js → getDataByCity.js}

@@ -1,7 +1,7 @@
 import { countryData } from "../country-data";
 
 // Function to get a countryCode, provinceName, and districtName by cityName
-export function getCountryProvinceDistrictByCityFunction(cityName) {
+export function getDataByCityFunction(cityName) {
   // Check if the input is valid
   if (typeof cityName !== "string" || cityName.trim() === "") {
     return {
@@ -9,9 +9,10 @@ export function getCountryProvinceDistrictByCityFunction(cityName) {
     };
   }
 
-  let countryCode = "";
-  let province = "";
-  let district = "";
+  const countries = [];
+  const provinces = [];
+  const districts = [];
+  const cities = [];
 
   for (const countryKey in countryData) {
     const country = countryData[countryKey];
@@ -23,27 +24,40 @@ export function getCountryProvinceDistrictByCityFunction(cityName) {
           const selectedCity = selectedDistrict.cities[cityKey];
           if (selectedCity.name.toLowerCase() === cityName.toLowerCase()) {
             // Set the country code
-            countryCode = countryKey;
+            countries.push({
+              code: country.code,
+              name: country.name,
+              countryCode: country.countryCode,
+            });
 
             // Set the province name
-            province = selectedProvince.name;
+            provinces.push(selectedProvince.name);
 
             // Set the district name
-            district = selectedDistrict.name;
+            districts.push(selectedDistrict.name);
+
+            // Set the city name
+            cities.push(selectedCity);
+
+            // Sort alphabetically
+            countries.sort();
+            provinces.sort();
+            districts.sort();
+            cities.sort();
 
             // Return the result
             return {
-              countryCode,
-              province,
-              district,
+              countries,
+              provinces,
+              districts,
+              cities,
             };
           }
         }
       }
     }
   }
-
-  // If no matching district was found
+  // // If no matching district was found
   return {
     error: `Provided city name "${cityName}" does not exist.`,
   };

package/src/functions/{getProvincesDistrictsCitiesByCountry.js → getDataByCountry.js}

@@ -1,17 +1,33 @@
 import { countryData } from "../country-data";
 
 // Function to get a list of province, district, and city names by country code
-export function getProvincesDistrictsCitiesByCountryFunction(code) {
-  const country = countryData[code];
+export function getDataByCountryFunction(countryCode) {
+  // Check if the input is valid
+  if (typeof countryCode !== "string" || countryCode.trim() === "") {
+    return {
+      error: "Invalid input: country code must be a non-empty string.",
+    };
+  }
+
+  const countries = [];
+  const districts = [];
+  const cities = [];
+
+  const country = countryData[countryCode];
+
   if (country) {
+    // Push the country name to the array
+    countries.push({
+      name: country.name,
+      code: country.code,
+      countryCode: country.countryCode,
+    });
+
     // Return an array of province names
     const provinces = Object.values(country.provinces)
       .map((province) => province.name)
       .sort();
 
-    const districts = [];
-    const cities = [];
-
     const districtArray = Object.values(country.provinces).flatMap(
       (province) => province.districts
     );
@@ -22,16 +38,17 @@ export function getProvincesDistrictsCitiesByCountryFunction(code) {
         const district = districtObject[key];
         // Push the district name to the array
         districts.push(district.name);
-        district.cities.forEach((city) => cities.push(city.name));
+        district.cities.forEach((city) => cities.push(city));
       });
     });
 
-    // Sort districts and cities alphabetically
+    // Sort alphabetically
+    countries.sort();
     districts.sort();
     cities.sort();
 
     // Return an array of provinces, districts, cities names by country code
-    return { provinces, districts, cities };
+    return { countries, provinces, districts, cities };
   }
   return {
     error: `Provided country code "${code}" does not exist.`,

package/src/functions/getDataByCountryCity.js

@@ -0,0 +1,80 @@
+import { countryData } from "../country-data";
+
+export function getDataByCountryCityFunction(countryCode, cityName) {
+  // Check if the input is valid
+  if (
+    (typeof countryCode !== "string" || countryCode.trim() === "") &&
+    (typeof cityName !== "string" || cityName.trim() === "")
+  ) {
+    return {
+      error:
+        "Invalid input: country code & city name must be a non-empty string.",
+    };
+  } else if (typeof countryCode !== "string" || countryCode.trim() === "") {
+    return {
+      error: "Invalid input: country code must be a non-empty string.",
+    };
+  } else if (typeof cityName !== "string" || cityName.trim() === "") {
+    return {
+      error: "Invalid input: city name must be a non-empty string.",
+    };
+  }
+
+  const countries = [];
+  const provinces = [];
+  const districts = [];
+  const cities = [];
+
+  const country = countryData[countryCode];
+  if (country) {
+    // Push the country name to the array
+    countries.push({
+      name: country.name,
+      code: country.code,
+      countryCode: country.countryCode,
+    });
+
+    for (const provinceKey in country.provinces) {
+      const selectedProvince = country.provinces[provinceKey];
+      for (const districtKey in selectedProvince.districts) {
+        const district = selectedProvince.districts[districtKey];
+        for (const cityKey in district.cities) {
+          const selectedCity = district.cities[cityKey];
+          if (selectedCity.name.toLowerCase() === cityName.toLowerCase()) {
+            // Set the province name
+            provinces.push(selectedProvince.name);
+
+            // Set the district name
+            districts.push(district.name);
+
+            // Set the city name
+            cities.push(selectedCity);
+
+            // Sort alphabetically
+            countries.sort();
+            provinces.sort();
+            districts.sort();
+            cities.sort();
+
+            // Return the result
+            return {
+              countries,
+              provinces,
+              districts,
+              cities,
+            };
+          }
+        }
+      }
+    }
+    // If no matching city was found
+    return {
+      error: `Provided city name "${cityName}" does not exist.`,
+    };
+  }
+
+  // If no matching country was found
+  return {
+    error: `Provided country code "${countryCode}" does not exist.`,
+  };
+}

package/src/functions/getDataByCountryDIstrict.js

@@ -0,0 +1,86 @@
+import { countryData } from "../country-data";
+
+export function getDataByCountryDIstrictFunction(countryCode, districtName) {
+  // Check if the input is valid
+  if (
+    (typeof countryCode !== "string" || countryCode.trim() === "") &&
+    (typeof districtName !== "string" || districtName.trim() === "")
+  ) {
+    return {
+      error:
+        "Invalid input: country code & district name must be a non-empty string.",
+    };
+  } else if (typeof countryCode !== "string" || countryCode.trim() === "") {
+    return {
+      error: "Invalid input: country code must be a non-empty string.",
+    };
+  } else if (typeof districtName !== "string" || districtName.trim() === "") {
+    return {
+      error: "Invalid input: district name must be a non-empty string.",
+    };
+  }
+
+  const countries = [];
+  const provinces = [];
+  const districts = [];
+  const cities = [];
+
+  const country = countryData[countryCode];
+  if (country) {
+    // Push the country name to the array
+    countries.push({
+      name: country.name,
+      code: country.code,
+      countryCode: country.countryCode,
+    });
+
+    for (const provinceKey in country.provinces) {
+      const selectedProvince = country.provinces[provinceKey];
+      for (const districtKey in selectedProvince.districts) {
+        const district = selectedProvince.districts[districtKey];
+        if (district.name.toLowerCase() === districtName.toLowerCase()) {
+          // Add city names
+          district.cities.forEach((city) => {
+            cities.push(city);
+          });
+
+          // Set the country code
+          countries.push({
+            code: country.code,
+            name: country.name,
+            countryCode: country.countryCode,
+          });
+
+          // Set the province name
+          provinces.push(selectedProvince.name);
+
+          // Set the district name
+          districts.push(district.name);
+
+          // Sort alphabetically
+          countries.sort();
+          provinces.sort();
+          districts.sort();
+          cities.sort();
+
+          // Return the result
+          return {
+            countries,
+            provinces,
+            districts,
+            cities,
+          };
+        }
+      }
+      // If no matching district was found
+      return {
+        error: `Provided district name "${districtName}" does not exist.`,
+      };
+    }
+  }
+
+  // If no matching country was found
+  return {
+    error: `Provided country code "${countryCode}" does not exist.`,
+  };
+}

package/src/functions/getDataByCountryProvince.js

@@ -0,0 +1,79 @@
+import { countryData } from "../country-data";
+
+// Function to get a list of province, district, and city names by country code
+export function getDataByCountryProvinceFunction(countryCode, provinceName) {
+  // Check if the input is valid
+  if (
+    (typeof countryCode !== "string" || countryCode.trim() === "") &&
+    (typeof provinceName !== "string" || provinceName.trim() === "")
+  ) {
+    return {
+      error:
+        "Invalid input: country code & province name must be a non-empty string.",
+    };
+  } else if (typeof countryCode !== "string" || countryCode.trim() === "") {
+    return {
+      error: "Invalid input: country code must be a non-empty string.",
+    };
+  } else if (typeof provinceName !== "string" || provinceName.trim() === "") {
+    return {
+      error: "Invalid input: province name must be a non-empty string.",
+    };
+  }
+
+  const countries = [];
+  const provinces = [];
+  const districts = [];
+  const cities = [];
+
+  const country = countryData[countryCode];
+
+  if (country) {
+    countries.push({
+      name: country.name,
+      code: country.code,
+      countryCode: country.countryCode,
+    });
+
+    for (const provinceKey in country.provinces) {
+      const province = country.provinces[provinceKey];
+      if (province.name.toLowerCase() === provinceName.toLowerCase()) {
+        // Set the province name
+        provinces.push(province.name);
+        const districtsArray = province.districts;
+        for (const districtKey in districtsArray) {
+          const district = districtsArray[districtKey];
+          const citiesArray = district.cities.map((city) => ({
+            name: city,
+          }));
+
+          // Add district name
+          districts.push(district.name);
+
+          // Add city names
+          citiesArray.forEach((city) => cities.push(city));
+        }
+
+        // Sort alphabetically
+        countries.sort();
+        provinces.sort();
+        districts.sort();
+        cities.sort();
+
+        // Return result once a matching province is found
+        return {
+          countries,
+          provinces,
+          districts,
+          cities,
+        };
+      }
+    }
+    return {
+      error: `Provided province name "${provinceName}" does not exist.`,
+    };
+  }
+  return {
+    error: `Provided country code "${countryCode}" does not exist.`,
+  };
+}

package/src/functions/getDataByCountryProvinceDistrict.js

@@ -0,0 +1,92 @@
+import { countryData } from "../country-data";
+
+// Function to get a list of province, district, and city names by country code
+export function getDataByCountryProvinceDistrictFunction(
+  countryCode,
+  provinceName,
+  districtName
+) {
+  // Check if the input is valid
+  if (
+    (typeof countryCode !== "string" || countryCode.trim() === "") &&
+    (typeof provinceName !== "string" || provinceName.trim() === "") &&
+    (typeof districtName !== "string" || districtName.trim() === "")
+  ) {
+    return {
+      error:
+        "Invalid input: country code & province name & district name must be a non-empty string.",
+    };
+  } else if (typeof countryCode !== "string" || countryCode.trim() === "") {
+    return {
+      error: "Invalid input: country code must be a non-empty string.",
+    };
+  } else if (typeof provinceName !== "string" || provinceName.trim() === "") {
+    return {
+      error: "Invalid input: province name must be a non-empty string.",
+    };
+  } else if (typeof districtName !== "string" || districtName.trim() === "") {
+    return {
+      error: "Invalid input: district name must be a non-empty string.",
+    };
+  }
+
+  const countries = [];
+  const provinces = [];
+  const districts = [];
+  const cities = [];
+
+  const country = countryData[countryCode];
+
+  if (country) {
+    countries.push({
+      name: country.name,
+      code: country.code,
+      countryCode: country.countryCode,
+    });
+
+    for (const provinceKey in country.provinces) {
+      const province = country.provinces[provinceKey];
+      if (province.name.toLowerCase() === provinceName.toLowerCase()) {
+        // Set the province name
+        provinces.push(province.name);
+        const districtsArray = province.districts;
+        for (const districtKey in districtsArray) {
+          const district = districtsArray[districtKey];
+          if (district.name.toLowerCase() === districtName.toLowerCase()) {
+            const citiesArray = district.cities.map((city) => ({
+              name: city,
+            }));
+
+            // Add district name
+            districts.push(district.name);
+
+            // Add city names
+            citiesArray.forEach((city) => cities.push(city));
+            // Sort districts and cities alphabetically
+            countries.sort();
+            provinces.sort();
+            districts.sort();
+            cities.sort();
+
+            // Return result once a matching district is found
+            return {
+              countries,
+              provinces,
+              districts,
+              cities,
+            };
+          }
+        }
+        return {
+          error: `Provided district name "${districtName}" does not exist.`,
+        };
+      }
+    }
+    return {
+      error: `Provided province name "${provinceName}" does not exist.`,
+    };
+  }
+  return {
+    error: `Provided country code "${countryCode}" does not exist.`,
+  };
+}

package/src/functions/getDataByCountryProvinceDistrictCity.js

@@ -0,0 +1,107 @@
+import { countryData } from "../country-data";
+
+// Function to get a list of province, district, and city names by country code
+export function getDataByCountryProvinceDistrictCityFunction(
+  countryCode,
+  provinceName,
+  districtName,
+  cityName
+) {
+  // Check if the input is valid
+  if (
+    (typeof countryCode !== "string" || countryCode.trim() === "") &&
+    (typeof provinceName !== "string" || provinceName.trim() === "") &&
+    (typeof districtName !== "string" || districtName.trim() === "") &&
+    (typeof cityName !== "string" || cityName.trim() === "")
+  ) {
+    return {
+      error:
+        "Invalid input: country code & province name & district name must be a non-empty string.",
+    };
+  } else if (typeof countryCode !== "string" || countryCode.trim() === "") {
+    return {
+      error: "Invalid input: country code must be a non-empty string.",
+    };
+  } else if (typeof provinceName !== "string" || provinceName.trim() === "") {
+    return {
+      error: "Invalid input: province name must be a non-empty string.",
+    };
+  } else if (typeof districtName !== "string" || districtName.trim() === "") {
+    return {
+      error: "Invalid input: district name must be a non-empty string.",
+    };
+  } else if (typeof cityName !== "string" || cityName.trim() === "") {
+    return {
+      error: "Invalid input: city name must be a non-empty string.",
+    };
+  }
+
+  const countries = [];
+  const provinces = [];
+  const districts = [];
+  const cities = [];
+
+  const country = countryData[countryCode];
+
+  if (country) {
+    countries.push({
+      name: country.name,
+      code: country.code,
+      countryCode: country.countryCode,
+    });
+
+    for (const provinceKey in country.provinces) {
+      const province = country.provinces[provinceKey];
+      if (province.name.toLowerCase() === provinceName.toLowerCase()) {
+        // Set the province name
+        provinces.push(province.name);
+        const districtsArray = province.districts;
+        for (const districtKey in districtsArray) {
+          const district = districtsArray[districtKey];
+          if (district.name.toLowerCase() === districtName.toLowerCase()) {
+            const citiesArray = district.cities;
+
+            // Add district name
+            districts.push(district.name);
+
+            // Add city name
+            for (const cityKey in citiesArray) {
+                const city = citiesArray[cityKey];
+              if (
+                city.name.toLocaleLowerCase() === cityName.toLocaleLowerCase()
+              ) {
+                cities.push(city);
+
+                // Sort districts and cities alphabetically
+                countries.sort();
+                provinces.sort();
+                districts.sort();
+                cities.sort();
+
+                // Return result once a matching province is found
+                return {
+                  countries,
+                  provinces,
+                  districts,
+                  cities,
+                };
+              }
+            }
+            return {
+              error: `Provided city name "${cityName}" does not exist.`,
+            };
+          }
+        }
+        return {
+          error: `Provided district name "${districtName}" does not exist.`,
+        };
+      }
+    }
+    return {
+      error: `Provided province name "${provinceName}" does not exist.`,
+    };
+  }
+  return {
+    error: `Provided country code "${countryCode}" does not exist.`,
+  };
+}

package/src/functions/{getCountryProvinceCityByDistrict.js → getDataByDistrict.js}

@@ -1,7 +1,7 @@
 import { countryData } from "../country-data";
 
 // Function to get a countryCode, provinceName, and list of city names by district name
-export function getCountryProvinceCityByDistrictFunction(districtName) {
+export function getDataByDistrictFunction(districtName) {
   // Check if the input is valid
   if (typeof districtName !== "string" || districtName.trim() === "") {
     return {
@@ -9,8 +9,9 @@ export function getCountryProvinceCityByDistrictFunction(districtName) {
     };
   }
 
-  let countryCode = "";
-  let province = "";
+  const countries = [];
+  const provinces = [];
+  const districts = [];
   const cities = [];
 
   for (const countryKey in countryData) {
@@ -20,31 +21,41 @@ export function getCountryProvinceCityByDistrictFunction(districtName) {
       for (const districtKey in selectedProvince.districts) {
         const district = selectedProvince.districts[districtKey];
         if (district.name.toLowerCase() === districtName.toLowerCase()) {
+          // Add district name
+          districts.push(district.name);
+
           // Add city names
           district.cities.forEach((city) => {
-            cities.push(city.name);
+            cities.push(city);
           });
 
           // Set the country code
-          countryCode = countryKey;
+          countries.push({
+            code: country.code,
+            name: country.name,
+            countryCode: country.countryCode,
+          });
 
           // Set the province name
-          province = selectedProvince.name;
+          provinces.push(selectedProvince.name);
 
           // Sort districts and cities alphabetically
+          countries.sort();
+          provinces.sort();
+          districts.sort();
           cities.sort();
 
           // Return the result
           return {
-            countryCode,
-            province,
+            countries,
+            provinces,
+            districts,
             cities,
           };
         }
       }
     }
   }
-
   // If no matching district was found
   return {
     error: `Provided district name "${districtName}" does not exist.`,

package/src/functions/getDataByDistrictCity.js

@@ -0,0 +1,70 @@
+import { countryData } from "../country-data";
+
+// Function to get a countryCode, provinceName, and list of city names by district name
+export function getDataByDistrictCityFunction(districtName, cityName) {
+  // Check if the input is valid
+  if (typeof districtName !== "string" || districtName.trim() === "") {
+    return {
+      error: "Invalid input: District name must be a non-empty string.",
+    };
+  }
+
+  const countries = [];
+  const provinces = [];
+  const districts = [];
+  const cities = [];
+
+  for (const countryKey in countryData) {
+    const country = countryData[countryKey];
+    for (const provinceKey in country.provinces) {
+      const selectedProvince = country.provinces[provinceKey];
+      for (const districtKey in selectedProvince.districts) {
+        const district = selectedProvince.districts[districtKey];
+        if (district.name.toLowerCase() === districtName.toLowerCase()) {
+          // Add country name
+          countries.push({
+            code: country.code,
+            name: country.name,
+            countryCode: country.countryCode,
+          });
+
+          // Add province name
+          provinces.push(selectedProvince.name);
+
+          // Add district name
+          districts.push(district.name);
+
+          // Add city name
+          for (const cityKey in district.cities) {
+            const city = district.cities[cityKey];
+
+            if (city.name.toLowerCase() === cityName.toLowerCase()) {
+              cities.push(city);
+
+              // Sort districts and cities alphabetically
+              countries.sort();
+              provinces.sort();
+              districts.sort();
+              cities.sort();
+
+              // Return result once a matching province is found
+              return {
+                countries,
+                provinces,
+                districts,
+                cities,
+              };
+            }
+          }
+          return {
+            error: `Provided city name "${cityName}" does not exist.`,
+          };
+        }
+      }
+    }
+  }
+  //   If no matching district was found
+  return {
+    error: `Provided district name "${districtName}" does not exist.`,
+  };
+}

package/src/functions/getDataByEtherCountryProvinceDistrictCity.js

@@ -0,0 +1,90 @@
+import { countryData } from "../country-data";
+import { getDataByCityFunction } from "./getDataByCity";
+import { getDataByCountryFunction } from "./getDataByCountry";
+import { getDataByCountryCityFunction } from "./getDataByCountryCity";
+import { getDataByCountryDIstrictFunction } from "./getDataByCountryDIstrict";
+import { getDataByCountryProvinceFunction } from "./getDataByCountryProvince";
+import { getDataByCountryProvinceDistrictFunction } from "./getDataByCountryProvinceDistrict";
+import { getDataByCountryProvinceDistrictCityFunction } from "./getDataByCountryProvinceDistrictCity";
+import { getDataByDistrictFunction } from "./getDataByDistrict";
+import { getDataByDistrictCityFunction } from "./getDataByDistrictCity";
+import { getDataByProvinceFunction } from "./getDataByProvince";
+import { getDataByProvinceCityFunction } from "./getDataByProvinceCity";
+import { getDataByProvinceDistrictFunction } from "./getDataByProvinceDistrict";
+
+export function getDataByEtherCountryProvinceDistrictCityFunction(
+  countryCode,
+  province,
+  district,
+  city
+) {
+  // Check if the input is valid
+  if (
+    (typeof countryCode !== "string" || countryCode.trim() === "") &&
+    (typeof province !== "string" || province.trim() === "") &&
+    (typeof district !== "string" || district.trim() === "") &&
+    (typeof city !== "string" || city.trim() === "")
+  ) {
+    return {
+      error:
+        "Invalid input: country code & province name & district name must be a non-empty string.",
+    };
+  }
+
+  if (countryCode && !province && !district && !city) {
+    return getDataByCountryFunction(countryCode);
+  }
+
+  if (!countryCode && province && !district && !city) {
+    return getDataByProvinceFunction(province);
+  }
+
+  if (!countryCode && !province && district && !city) {
+    return getDataByDistrictFunction(district);
+  }
+
+  if (!countryCode && !province && !district && city) {
+    return getDataByCityFunction(city);
+  }
+
+  if (countryCode && province && !district && !city) {
+    return getDataByCountryProvinceFunction(countryCode, province);
+  }
+
+  if (countryCode && province && district && !city) {
+    return getDataByCountryProvinceDistrictFunction(
+      countryCode,
+      province,
+      district
+    );
+  }
+
+  if (countryCode && province && district && city) {
+    return getDataByCountryProvinceDistrictCityFunction(
+      countryCode,
+      province,
+      district,
+      city
+    );
+  }
+
+  if (countryCode && !province && district && !city) {
+    return getDataByCountryDIstrictFunction(countryCode, district);
+  }
+
+  if (countryCode && !province && !district && city) {
+    return getDataByCountryCityFunction(countryCode, city);
+  }
+
+  if (!countryCode && province && district && !city) {
+    return getDataByProvinceDistrictFunction(province, district);
+  }
+
+  if (!countryCode && province && !district && city) {
+    return getDataByProvinceCityFunction(province, city);
+  }
+
+  if (!countryCode && !province && district && city) {
+    return getDataByDistrictCityFunction(district, city);
+  }
+}

package/src/functions/{getCountryDistrictsCitiesByProvince.js → getDataByProvince.js}

@@ -1,7 +1,7 @@
 import { countryData } from "../country-data";
 
 // Function to get a countryCode and list of districts and city names by province name
-export function getCountryDistrictsCitiesByProvinceFunction(provinceName) {
+export function getDataByProvinceFunction(provinceName) {
   // Check if the input is valid
   if (typeof provinceName !== "string" || provinceName.trim() === "") {
     return {
@@ -9,7 +9,8 @@ export function getCountryDistrictsCitiesByProvinceFunction(provinceName) {
     };
   }
 
-  let countryCode = "";
+  const countries = [];
+  const provinces = [];
   const districts = [];
   const cities = [];
 
@@ -19,36 +20,46 @@ export function getCountryDistrictsCitiesByProvinceFunction(provinceName) {
       const province = country.provinces[provinceKey];
       if (province.name.toLowerCase() === provinceName.toLowerCase()) {
         const districtsArray = province.districts;
+
+        // Set the country code
+        countries.push({
+          code: country.code,
+          name: country.name,
+          countryCode: country.countryCode,
+        });
+
+        // Add province name
+        provinces.push(province.name);
+
         for (const districtKey in districtsArray) {
           const district = districtsArray[districtKey];
           const citiesArray = district.cities.map((city) => ({
-            name: city.name,
+            name: city,
           }));
 
-          // Set the country code
-          countryCode = countryKey;
-
           // Add district name
           districts.push(district.name);
 
           // Add city names
-          citiesArray.forEach((city) => cities.push(city.name));
+          citiesArray.forEach((city) => cities.push(city));
         }
 
         // Sort districts and cities alphabetically
+        countries.sort();
+        provinces.sort();
         districts.sort();
         cities.sort();
 
         // Return result once a matching province is found
         return {
-          countryCode,
+          countries,
+          provinces,
           districts,
           cities,
         };
       }
     }
   }
-
   // If no matching province was found
   return {
     error: `Provided province name "${provinceName}" does not exist.`,

package/src/functions/getDataByProvinceCity.js

@@ -0,0 +1,84 @@
+import { countryData } from "../country-data";
+
+// Function to get a countryCode and list of districts and city names by province name
+export function getDataByProvinceCityFunction(provinceName, cityName) {
+  // Check if the input is valid
+  if (
+    (typeof provinceName !== "string" || provinceName.trim() === "") &&
+    (typeof cityName !== "string" || cityName.trim() === "")
+  ) {
+    return {
+      error:
+        "Invalid input: Province name & city name must be a non-empty string.",
+    };
+  } else if (typeof provinceName !== "string" || provinceName.trim() === "") {
+    return {
+      error: "Invalid input: Province name must be a non-empty string.",
+    };
+  } else if (typeof cityName !== "string" || cityName.trim() === "") {
+    return {
+      error: "Invalid input: city name must be a non-empty string.",
+    };
+  }
+
+  const countries = [];
+  const provinces = [];
+  const districts = [];
+  const cities = [];
+
+  for (const countryKey in countryData) {
+    const country = countryData[countryKey];
+    for (const provinceKey in country.provinces) {
+      const province = country.provinces[provinceKey];
+
+      if (province.name.toLowerCase() === provinceName.toLowerCase()) {
+        // Set the country code
+        countries.push({
+          code: country.code,
+          name: country.name,
+          countryCode: country.countryCode,
+        });
+
+        // Add province name
+        provinces.push(province.name);
+        const districtsArray = province.districts;
+        for (const districtKey in districtsArray) {
+          const district = districtsArray[districtKey];
+          for (const cityKey in district.cities) {
+            const city = district.cities[cityKey];
+            if (city.name.toLowerCase() === cityName.toLowerCase()) {
+              // Add district name
+              districts.push(district.name);
+
+              // Add city names
+              cities.push(city.name);
+
+              // Sort districts and cities alphabetically
+              countries.sort();
+              provinces.sort();
+              districts.sort();
+              cities.sort();
+
+              // Return result once a matching province is found
+              return {
+                countries,
+                provinces,
+                districts,
+                cities,
+              };
+            }
+          }
+        }
+
+        // If no matching district was found
+        return {
+          error: `Provided district name "${cityName}" does not exist.`,
+        };
+      }
+    }
+    // If no matching province was found
+    return {
+      error: `Provided province name "${provinceName}" does not exist.`,
+    };
+  }
+}

package/src/functions/getDataByProvinceDistrict.js

@@ -0,0 +1,81 @@
+import { countryData } from "../country-data";
+
+// Function to get a countryCode and list of districts and city names by province name
+export function getDataByProvinceDistrictFunction(provinceName, districtName) {
+  // Check if the input is valid
+  if (
+    (typeof provinceName !== "string" || provinceName.trim() === "") &&
+    (typeof districtName !== "string" || districtName.trim() === "")
+  ) {
+    return {
+      error:
+        "Invalid input: Province name & district name must be a non-empty string.",
+    };
+  } else if (typeof provinceName !== "string" || provinceName.trim() === "") {
+    return {
+      error: "Invalid input: Province name must be a non-empty string.",
+    };
+  } else if (typeof districtName !== "string" || districtName.trim() === "") {
+    return {
+      error: "Invalid input: district name must be a non-empty string.",
+    };
+  }
+
+  const countries = [];
+  const provinces = [];
+  const districts = [];
+  const cities = [];
+
+  for (const countryKey in countryData) {
+    const country = countryData[countryKey];
+    for (const provinceKey in country.provinces) {
+      const province = country.provinces[provinceKey];
+      if (province.name.toLowerCase() === provinceName.toLowerCase()) {
+        // Set the country code
+        countries.push({
+          code: country.code,
+          name: country.name,
+          countryCode: country.countryCode,
+        });
+
+        // Set the province name
+        provinces.push(province.name);
+
+        const districtsArray = province.districts;
+        for (const districtKey in districtsArray) {
+          const district = districtsArray[districtKey];
+          if (district.name.toLowerCase() === districtName.toLowerCase()) {
+            // Add city names
+            district.cities.forEach((city) => cities.push(city));
+
+            // Set the district name
+            districts.push(district.name);
+
+            // Sort alphabetically
+            countries.sort();
+            provinces.sort();
+            districts.sort();
+            cities.sort();
+
+            // Return the result
+            return {
+              countries,
+              provinces,
+              districts,
+              cities,
+            };
+          }
+        }
+
+        // If no matching district was found
+        return {
+          error: `Provided district name "${districtName}" does not exist.`,
+        };
+      }
+    }
+    // If no matching province was found
+    return {
+      error: `Provided province name "${provinceName}" does not exist.`,
+    };
+  }
+}

package/src/index.d.ts

@@ -1,10 +1,68 @@
-export function getProvincesDistrictsCitiesByCountry(code: string): any;
-export function getCountryDistrictsCitiesByProvince(provinceName: string): any;
-export function getCountryProvinceCityByDistrict(districtName: string): any;
-export function getCountryProvinceDistrictByCity(cityName: string): any;
+export function getDataByCountry(country: string): any;
+export function getDataByProvince(provinceName: string): any;
+export function getDataByDistrict(districtName: string): any;
+export function getDataByCity(cityName: string): any;
+
+export function getDataByCountryProvince(
+  country: string,
+  province: string
+): any;
+export function getDataByCountryProvinceDistrict(
+  country: string,
+  province: string,
+  district: string
+): any;
+export function getDataByCountryProvinceDistrictCity(
+  country: string,
+  province: string,
+  district: string,
+  cityName: string
+): any;
+export function getDataByEtherCountryProvinceDistrictCity(
+  country: string | null | undefined,
+  province: string | null | undefined,
+  district: string | null | undefined,
+  cityName: string | null | undefined
+): any;
+export function getDataByCountryDistrict(
+  country: string,
+  district: string
+): any;
+export function getDataByCountryCity(country: string, city: string): any;
+export function getDataByProvinceDistrict(
+  province: string,
+  district: string
+): any;
+export function getDataByProvinceCity(province: string, city: string): any;
+export function getDataByDistrictCity(district: string, city: string): any;
+
 export function listFunctions(): {
-  getProvincesDistrictsCitiesByCountry: (code: string) => any;
-  getCountryDistrictsCitiesByProvince: (provinceName: string) => any;
-  getCountryProvinceCityByDistrict: (districtName: string) => any;
-  getCountryProvinceDistrictByCity: (cityName: string) => any;
+  getDataByCountry: (country: string) => any;
+  getDataByProvince: (provinceName: string) => any;
+  getDataByDistrict: (districtName: string) => any;
+  getDataByCity: (cityName: string) => any;
+
+  getDataByCountryProvince: (country: string, province: string) => any;
+  getDataByCountryProvinceDistrict: (
+    country: string,
+    province: string,
+    district: string
+  ) => any;
+  getDataByCountryProvinceDistrictCity: (
+    country: string,
+    province: string,
+    district: string,
+    cityName: string
+  ) => any;
+  getDataByEtherCountryProvinceDistrictCity: (
+    country: string | null | undefined,
+    province: string | null | undefined,
+    district: string | null | undefined,
+    cityName: string | null | undefined
+  ) => any;
+  getDataByCountryDistrict: (country: string, district: string) => any;
+  getDataByCountryCity: (country: string, city: string) => any;
+  getDataByProvinceDistrict: (province: string, district: string) => any;
+  getDataByProvinceCity: (province: string, city: string) => any;
+  getDataByDistrictCity: (district: string, city: string) => any;
 };

package/src/index.js

@@ -1,33 +1,112 @@
-import { getCountryDistrictsCitiesByProvinceFunction } from "./functions/getCountryDistrictsCitiesByProvince.js";
-import { getCountryProvinceCityByDistrictFunction } from "./functions/getCountryProvinceCityByDistrict.js";
-import { getCountryProvinceDistrictByCityFunction } from "./functions/getCountryProvinceDistrictByCity.js";
-import { getProvincesDistrictsCitiesByCountryFunction } from "./functions/getProvincesDistrictsCitiesByCountry.js";
+import { getDataByCityFunction } from "./functions/getDataByCity";
+import { getDataByCountryFunction } from "./functions/getDataByCountry";
+import { getDataByCountryCityFunction } from "./functions/getDataByCountryCity";
+import { getDataByCountryDIstrictFunction } from "./functions/getDataByCountryDIstrict";
+import { getDataByCountryProvinceFunction } from "./functions/getDataByCountryProvince";
+import { getDataByCountryProvinceDistrictFunction } from "./functions/getDataByCountryProvinceDistrict";
+import { getDataByCountryProvinceDistrictCityFunction } from "./functions/getDataByCountryProvinceDistrictCity";
+import { getDataByDistrictFunction } from "./functions/getDataByDistrict";
+import { getDataByDistrictCityFunction } from "./functions/getDataByDistrictCity";
+import { getDataByEtherCountryProvinceDistrictCityFunction } from "./functions/getDataByEtherCountryProvinceDistrictCity";
+import { getDataByProvinceFunction } from "./functions/getDataByProvince";
+import { getDataByProvinceCityFunction } from "./functions/getDataByProvinceCity";
+import { getDataByProvinceDistrictFunction } from "./functions/getDataByProvinceDistrict";
 
-// Function to get a list of province, district, and city names by country code
-export function getProvincesDistrictsCitiesByCountry(code) {
-  return getProvincesDistrictsCitiesByCountryFunction(code);
+// Function to get a list of provinces, districts, and city names by country code
+export function getDataByCountry(code) {
+  return getDataByCountryFunction(code);
 }
 
-// Function to get a countryCode and list of districts and city names by province name
-export function getCountryDistrictsCitiesByProvince(provinceName) {
-  return getCountryDistrictsCitiesByProvinceFunction(provinceName);
+// Function to get a countries and list of districts and city names by province name
+export function getDataByProvince(provinceName) {
+  return getDataByProvinceFunction(provinceName);
 }
 
-// Function to get a countryCode, provinceName, and list of city names by district name
-export function getCountryProvinceCityByDistrict(districtName) {
-  return getCountryProvinceCityByDistrictFunction(districtName);
+// Function to get a countries, provinces, and list of city names by district name
+export function getDataByDistrict(districtName) {
+  return getDataByDistrictFunction(districtName);
 }
 
-export function getCountryProvinceDistrictByCity(cityName) {
-  return getCountryProvinceDistrictByCityFunction(cityName);
+// Function to get a countries, provinces, and districts by city name
+export function getDataByCity(cityName) {
+  return getDataByCityFunction(cityName);
+}
+
+// Function to get a list of district, and city names by country code, province
+export function getDataByCountryProvince(country, province) {
+  return getDataByCountryProvinceFunction(country, province);
+}
+
+// Function to get a list of city names by country code, province, and district
+export function getDataByCountryProvinceDistrict(country, province, district) {
+  return getDataByCountryProvinceDistrictFunction(country, province, district);
+}
+
+// Function to get a selected city data by country code, province, district, and city
+export function getDataByCountryProvinceDistrictCity(
+  country,
+  province,
+  district,
+  city
+) {
+  return getDataByCountryProvinceDistrictCityFunction(
+    country,
+    province,
+    district,
+    city
+  );
+}
+
+// Function to get a selected data by ether country code, province, district, and city
+export function getDataByEtherCountryProvinceDistrictCity(
+  country,
+  province,
+  district,
+  city
+) {
+  return getDataByEtherCountryProvinceDistrictCityFunction(
+    country,
+    province,
+    district,
+    city
+  );
+}
+
+export function getDataByCountryDistrict(country, district) {
+  return getDataByCountryDIstrictFunction(country, district);
+}
+
+export function getDataByCountryCity(country, city) {
+  return getDataByCountryCityFunction(country, city);
+}
+
+export function getDataByProvinceDistrict(province, district) {
+  return getDataByProvinceDistrictFunction(province, district);
+}
+
+export function getDataByProvinceCity(province, city) {
+  return getDataByProvinceCityFunction(province, city);
+}
+
+export function getDataByDistrictCity(district, city) {
+  return getDataByDistrictCityFunction(district, city);
 }
 
 // Function to list all available functions
 export function listFunctions() {
   return {
-    getProvincesDistrictsCitiesByCountry,
-    getCountryDistrictsCitiesByProvince,
-    getCountryProvinceCityByDistrict,
-    getCountryProvinceDistrictByCity,
+    getDataByCountry,
+    getDataByProvince,
+    getDataByDistrict,
+    getDataByCity,
+    getDataByCountryProvince,
+    getDataByCountryProvinceDistrict,
+    getDataByCountryProvinceDistrictCity,
+    getDataByEtherCountryProvinceDistrictCity,
+    getDataByCountryDistrict,
+    getDataByCountryCity,
+    getDataByProvinceDistrict,
+    getDataByProvinceCity,
+    getDataByDistrictCity,
   };
 }