country-data-filter 1.0.14 → 1.0.16

package/README.md

@@ -0,0 +1,105 @@
+Country Data Filter
+country-data-filter is an npm package designed to provide detailed country data, including provinces, districts, cities, and postal codes. This package is useful for applications that need to access and filter geographical information.
+
+Installation
+You can install the package via npm:
+
+bash
+Copy code
+npm install country-data-filter
+Usage
+Importing the Package
+In your JavaScript or TypeScript project, you can import the functions provided by the package.
+
+JavaScript
+javascript
+Copy code
+const { 
+  getProvincesDistrictsCitiesByCountryFunction, 
+  getCountryProvinceCityByDistrict, 
+  getCountryDistrictsCitiesByProvince, 
+  listFunctions 
+} = require('country-data-filter');
+TypeScript
+typescript
+Copy code
+import { 
+  getProvincesDistrictsCitiesByCountryFunction, 
+  getCountryProvinceCityByDistrict, 
+  getCountryDistrictsCitiesByProvince, 
+  listFunctions 
+} from 'country-data-filter';
+Functions
+getProvincesDistrictsCitiesByCountryFunction(code)
+Returns a list of provinces, districts, and cities for a given country code.
+
+Parameters:
+
+code (string): The country code (e.g., 'LK' for Sri Lanka).
+Returns:
+
+An object containing sorted arrays of provinces, districts, and cities, or an error message if the country code is invalid.
+Example:
+
+javascript
+Copy code
+const result = getProvincesDistrictsCitiesByCountryFunction('LK');
+console.log(result);
+getCountryProvinceCityByDistrict(districtName)
+Returns the country code, province, and cities for a given district name.
+
+Parameters:
+
+districtName (string): The name of the district.
+Returns:
+
+An object containing the country code, province name, and list of cities, or an error message if the district name is invalid.
+Example:
+
+javascript
+Copy code
+const result = getCountryProvinceCityByDistrict('Matara');
+console.log(result);
+getCountryDistrictsCitiesByProvince(provinceName)
+Returns the list of districts and cities for a given province name.
+
+Parameters:
+
+provinceName (string): The name of the province.
+Returns:
+
+An object containing the list of districts and cities, or an error message if the province name is invalid.
+Example:
+
+javascript
+Copy code
+const result = getCountryDistrictsCitiesByProvince('Southern');
+console.log(result);
+listFunctions()
+Returns a list of all available functions in the package.
+
+Returns:
+
+An object containing the function names and their references.
+Example:
+
+javascript
+Copy code
+const functions = listFunctions();
+console.log(functions);
+Data Structure
+The data for countries, provinces, districts, and cities is stored in JavaScript objects. Each country object contains provinces, and each province object contains districts and cities.
+
+Contributing
+If you want to contribute to this project, please follow these steps:
+
+Fork the repository.
+Create a new branch for your changes.
+Make your changes and add tests if applicable.
+Submit a pull request with a clear description of your changes.
+License
+This project is licensed under the MIT License. See the LICENSE file for details.
+
+Contact
+For any questions or support, please contact knnadeera1@gmail.com.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "country-data-filter",
-  "version": "1.0.14",
+  "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.`,
+  };
+}