country-data-filter 1.0.10 → 1.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "country-data-filter",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "A package to filter country data",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -28,6 +28,7 @@
     "src/*.js",
     "src/index.js",
     "src/index.d.ts",
+    "src/functions/*.js",
     "src/countries/*.js"
   ]
 }

package/src/country-data.js

@@ -1,4 +1,4 @@
-import { LK } from "./countries/LK";
+import { LK } from "./countries/LK/LK";
 
 export const countryData = {
   LK: LK,

package/src/functions/getCountryDistrictsCitiesByProvince.js

@@ -0,0 +1,52 @@
+import { countryData } from "../country-data";
+
+// Function to get a countryCode and list of districts and city names by province name
+export function getCountryDistrictsCitiesByProvinceFunction(provinceName) {
+  // Check if the input is valid
+  if (typeof provinceName !== "string" || provinceName.trim() === "") {
+    return {
+      error: "Invalid input: Province name must be a non-empty string.",
+    };
+  }
+
+  let countryCode = "";
+  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()) {
+        const districtsArray = province.districts;
+        for (const districtKey in districtsArray) {
+          const district = districtsArray[districtKey];
+          const citiesArray = district.cities.map((city) => ({
+            name: city.name,
+          }));
+
+          // Set the country code
+          countryCode = countryKey;
+
+          // Add district name
+          districts.push(district.name);
+
+          // Add city names
+          citiesArray.forEach((city) => cities.push(city.name));
+        }
+
+        // Return result once a matching province is found
+        return {
+          countryCode,
+          districts,
+          cities,
+        };
+      }
+    }
+  }
+
+  // If no matching province was found
+  return {
+    error: `Provided province name "${provinceName}" does not exist.`,
+  };
+}

package/src/functions/getCountryProvinceCityByDistrict.js

@@ -0,0 +1,49 @@
+import { countryData } from "../country-data";
+
+// Function to get a countryCode, provinceName, and list of city names by district name
+export function getCountryProvinceCityByDistrictFunction(districtName) {
+  // Check if the input is valid
+  if (typeof districtName !== "string" || districtName.trim() === "") {
+    return {
+      error: "Invalid input: District name must be a non-empty string.",
+    };
+  }
+
+  let countryCode = "";
+  let province = "";
+  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 city names
+          district.cities.forEach((city) => {
+            cities.push(city.name);
+          });
+
+          // Set the country code
+          countryCode = countryKey;
+
+          // Set the province name
+          province = selectedProvince.name;
+
+          // Return the result
+          return {
+            countryCode,
+            province,
+            cities,
+          };
+        }
+      }
+    }
+  }
+
+  // If no matching district was found
+  return {
+    error: `Provided district name "${districtName}" does not exist.`,
+  };
+}

package/src/functions/getCountryProvinceDistrictByCity.js

@@ -0,0 +1,50 @@
+import { countryData } from "../country-data";
+
+// Function to get a countryCode, provinceName, and districtName by cityName
+export function getCountryProvinceDistrictByCityFunction(cityName) {
+  // Check if the input is valid
+  if (typeof cityName !== "string" || cityName.trim() === "") {
+    return {
+      error: "Invalid input: city name must be a non-empty string.",
+    };
+  }
+
+  let countryCode = "";
+  let province = "";
+  let district = "";
+
+  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 selectedDistrict = selectedProvince.districts[districtKey];
+        for (const cityKey in selectedDistrict.cities) {
+          const selectedCity = selectedDistrict.cities[cityKey];
+          if (selectedCity.name.toLowerCase() === cityName.toLowerCase()) {
+            // Set the country code
+            countryCode = countryKey;
+
+            // Set the province name
+            province = selectedProvince.name;
+
+            // Set the district name
+            district = selectedDistrict.name;
+
+            // Return the result
+            return {
+              countryCode,
+              province,
+              district,
+            };
+          }
+        }
+      }
+    }
+  }
+
+  // If no matching district was found
+  return {
+    error: `Provided city name "${cityName}" does not exist.`,
+  };
+}

package/src/functions/getProvincesDistrictsCitiesByCountry.js

@@ -0,0 +1,35 @@
+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];
+  if (country) {
+    // Return an array of province names
+    const provinces = Object.values(country.provinces).map(
+      (province) => province.name
+    );
+
+    const districts = [];
+    const cities = [];
+
+    const districtArray = Object.values(country.provinces).flatMap(
+      (province) => province.districts
+    );
+
+    districtArray.forEach((districtObject) => {
+      // Each item in the array is an object with district names as keys
+      Object.keys(districtObject).forEach((key) => {
+        const district = districtObject[key];
+        // Push the district name to the array
+        districts.push(district.name);
+        district.cities.forEach((city) => cities.push(city.name));
+      });
+    });
+
+    // Return an array of provinces, districts, cities names by country code
+    return { provinces, districts, cities };
+  }
+  return {
+    error: `Provided country code "${code}" does not exist.`,
+  };
+}

package/src/index.d.ts

@@ -1,22 +1,10 @@
-export function getProvincesByCountry(code: string): string[];
-export function getDistrictsByProvince(
-  countryCode: string,
-  provinceName: string
-): string[];
-export function getCityByDistrict(
-  countryCode: string,
-  provinceName: string,
-  districtName: string
-): any;
+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 listFunctions(): {
-  getProvincesByCountry: (code: string) => string[];
-  getDistrictsByProvince: (
-    countryCode: string,
-    provinceName: string
-  ) => string[];
-  getCityByDistrict: (
-    countryCode: string,
-    provinceName: string,
-    districtName: string
-  ) => any;
+  getProvincesDistrictsCitiesByCountry: (code: string) => any;
+  getCountryDistrictsCitiesByProvince: (provinceName: string) => any;
+  getCountryProvinceCityByDistrict: (districtName: string) => any;
+  getCountryProvinceDistrictByCity: (cityName: string) => any;
 };

package/src/index.js

@@ -1,42 +1,33 @@
-import { countryData } from "./country-data.js";
+import { getCountryDistrictsCitiesByProvinceFunction } from "./functions/getCountryDistrictsCitiesByProvince.js";
+import { getCountryProvinceCityByDistrictFunction } from "./functions/getCountryProvinceCityByDistrict.js";
+import { getCountryProvinceDistrictByCityFunction } from "./functions/getCountryProvinceDistrictByCity.js";
+import { getProvincesDistrictsCitiesByCountryFunction } from "./functions/getProvincesDistrictsCitiesByCountry.js";
 
-// Function to get the list of province names by country code
-export function getProvincesByCountry(code) {
-  const country = countryData[code];
-  if (country) {
-    // Return an array of province names
-    return Object.values(country.province).map((province) => province.name);
-  }
-  return [];
+// 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 district names by country code and province name
-export function getDistrictsByProvince(countryCode, provinceName) {
-  const country = countryData[countryCode];
-  if (country && country.province[provinceName.toLowerCase()]) {
-    // Return an array of district names
-    return Object.values(country.province[provinceName].districts).map(
-      (district) => district.name
-    );
-  }
-  return [];
+// 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 city details by country code, province name, and district name
-export function getCityByDistrict(countryCode, provinceName, districtName) {
-  const country = countryData[countryCode];
-  const province = country.province[provinceName.toLowerCase()];
-  if (province && province.districts[districtName.toLowerCase()]) {
-    return province.districts[districtName];
-  }
-  return null;
+// Function to get a countryCode, provinceName, and list of city names by district name
+export function getCountryProvinceCityByDistrict(districtName) {
+  return getCountryProvinceCityByDistrictFunction(districtName);
+}
+
+export function getCountryProvinceDistrictByCity(cityName) {
+  return getCountryProvinceDistrictByCityFunction(cityName);
 }
 
 // Function to list all available functions
 export function listFunctions() {
   return {
-    getProvincesByCountry,
-    getDistrictsByProvince,
-    getCityByDistrict,
+    getProvincesDistrictsCitiesByCountry,
+    getCountryDistrictsCitiesByProvince,
+    getCountryProvinceCityByDistrict,
+    getCountryProvinceDistrictByCity,
   };
 }

package/src/countries/LK.js

@@ -1,18 +0,0 @@
-export const LK = {
-  name: "Sri Lanka",
-  province: {
-    southern: {
-      name: "Southern",
-      districts: {
-        matara: {
-          name: "Matara",
-          cities: [{ name: "Weligama", postalCode: 85700 }],
-        },
-        galle: {
-          name: "Galle",
-          cities: [{ name: "Galle", postalCode: 80000 }],
-        },
-      },
-    },
-  },
-};