@mharj/openweathermap 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -1,903 +1,954 @@
-// src/types/v2/Icon.ts
+import { Err, Ok, Option, Result } from "@luolapeikko/result-option";
 import { z } from "zod";
-var dayIconList = ["01d", "02d", "03d", "04d", "09d", "10d", "11d", "13d", "50d"];
-var dayIconListSchema = z.enum(dayIconList);
-var nightIconList = ["01n", "02n", "03n", "04n", "09n", "10n", "11n", "13n", "50n"];
-var nightIconListSchema = z.enum(nightIconList);
-var iconSchema = z.union([dayIconListSchema, nightIconListSchema]);
 
-// src/types/v2/weatherIdGroup.ts
-import { undefinedOptionWrap } from "@luolapeikko/result-option";
-import { z as z2 } from "zod";
-var weatherIdGroup = [
-  {
-    id: 200,
-    group: "thunderstorm",
-    description: "thunderstorm_with_light_rain"
-  },
-  {
-    id: 201,
-    group: "thunderstorm",
-    description: "thunderstorm_with_rain"
-  },
-  {
-    id: 202,
-    group: "thunderstorm",
-    description: "thunderstorm_with_heavy_rain"
-  },
-  {
-    id: 210,
-    group: "thunderstorm",
-    description: "light_thunderstorm"
-  },
-  {
-    id: 211,
-    group: "thunderstorm",
-    description: "thunderstorm"
-  },
-  {
-    id: 212,
-    group: "thunderstorm",
-    description: "heavy_thunderstorm"
-  },
-  {
-    id: 221,
-    group: "thunderstorm",
-    description: "ragged_thunderstorm"
-  },
-  {
-    id: 230,
-    group: "thunderstorm",
-    description: "thunderstorm_with_light_drizzle"
-  },
-  {
-    id: 231,
-    group: "thunderstorm",
-    description: "thunderstorm_with_drizzle"
-  },
-  {
-    id: 232,
-    group: "thunderstorm",
-    description: "thunderstorm_with_heavy_drizzle"
-  },
-  {
-    id: 300,
-    group: "drizzle",
-    description: "light_intensity_drizzle"
-  },
-  {
-    id: 301,
-    group: "drizzle",
-    description: "drizzle"
-  },
-  {
-    id: 302,
-    group: "drizzle",
-    description: "heavy_intensity_drizzle"
-  },
-  {
-    id: 310,
-    group: "drizzle",
-    description: "light_intensity_drizzle_rain"
-  },
-  {
-    id: 311,
-    group: "drizzle",
-    description: "drizzle_rain"
-  },
-  {
-    id: 312,
-    group: "drizzle",
-    description: "heavy_intensity_drizzle_rain"
-  },
-  {
-    id: 313,
-    group: "drizzle",
-    description: "shower_rain_and_drizzle"
-  },
-  {
-    id: 314,
-    group: "drizzle",
-    description: "heavy_shower_rain_and_drizzle"
-  },
-  {
-    id: 321,
-    group: "drizzle",
-    description: "shower_drizzle"
-  },
-  {
-    id: 500,
-    group: "rain",
-    description: "light_rain"
-  },
-  {
-    id: 501,
-    group: "rain",
-    description: "moderate_rain"
-  },
-  {
-    id: 502,
-    group: "rain",
-    description: "heavy_intensity_rain"
-  },
-  {
-    id: 503,
-    group: "rain",
-    description: "very_heavy_rain"
-  },
-  {
-    id: 504,
-    group: "rain",
-    description: "extreme_rain"
-  },
-  {
-    id: 511,
-    group: "rain",
-    description: "freezing_rain"
-  },
-  {
-    id: 520,
-    group: "rain",
-    description: "light_intensity_shower_rain"
-  },
-  {
-    id: 521,
-    group: "rain",
-    description: "shower_rain"
-  },
-  {
-    id: 522,
-    group: "rain",
-    description: "heavy_intensity_shower_rain"
-  },
-  {
-    id: 531,
-    group: "rain",
-    description: "ragged_shower_rain"
-  },
-  {
-    id: 600,
-    group: "snow",
-    description: "light_snow"
-  },
-  {
-    id: 601,
-    group: "snow",
-    description: "snow"
-  },
-  {
-    id: 602,
-    group: "snow",
-    description: "heavy_snow"
-  },
-  {
-    id: 611,
-    group: "snow",
-    description: "sleet"
-  },
-  {
-    id: 612,
-    group: "snow",
-    description: "light_shower_sleet"
-  },
-  {
-    id: 613,
-    group: "snow",
-    description: "shower_sleet"
-  },
-  {
-    id: 615,
-    group: "snow",
-    description: "light_rain_and_snow"
-  },
-  {
-    id: 616,
-    group: "snow",
-    description: "rain_and_snow"
-  },
-  {
-    id: 620,
-    group: "snow",
-    description: "light_shower_snow"
-  },
-  {
-    id: 621,
-    group: "snow",
-    description: "shower_snow"
-  },
-  {
-    id: 622,
-    group: "snow",
-    description: "heavy_shower_snow"
-  },
-  {
-    id: 701,
-    group: "atmosphere",
-    description: "mist"
-  },
-  {
-    id: 711,
-    group: "atmosphere",
-    description: "smoke"
-  },
-  {
-    id: 721,
-    group: "atmosphere",
-    description: "haze"
-  },
-  {
-    id: 731,
-    group: "atmosphere",
-    description: "sand_dust_whirls"
-  },
-  {
-    id: 741,
-    group: "atmosphere",
-    description: "fog"
-  },
-  {
-    id: 751,
-    group: "atmosphere",
-    description: "sand"
-  },
-  {
-    id: 761,
-    group: "atmosphere",
-    description: "dust"
-  },
-  {
-    id: 762,
-    group: "atmosphere",
-    description: "volcanic_ash"
-  },
-  {
-    id: 771,
-    group: "atmosphere",
-    description: "squalls"
-  },
-  {
-    id: 781,
-    group: "atmosphere",
-    description: "tornado"
-  },
-  {
-    id: 800,
-    group: "clear",
-    description: "clear_sky"
-  },
-  {
-    id: 801,
-    group: "clouds",
-    description: "few_clouds_11-25_percent"
-  },
-  {
-    id: 802,
-    group: "clouds",
-    description: "scattered_clouds_25-50_percent"
-  },
-  {
-    id: 803,
-    group: "clouds",
-    description: "broken_clouds_51-84_percent"
-  },
-  {
-    id: 804,
-    group: "clouds",
-    description: "overcast_clouds_85-100_percent"
-  }
+//#region src/lib/fetchUtils.ts
+/**
+* Ensures that the error is a DOMException or TypeError.
+* @internal
+*/
+function fetchErrorWrapper(err) {
+	if (err instanceof DOMException || err instanceof TypeError) return err;
+	else return /* @__PURE__ */ new TypeError(`Unknown error: ${String(err)}`);
+}
+
+//#endregion
+//#region src/types/v2/Icon.ts
+/**
+* @internal
+*/
+const dayIconListSchema = z.enum([
+	"01d",
+	"02d",
+	"03d",
+	"04d",
+	"09d",
+	"10d",
+	"11d",
+	"13d",
+	"50d"
+]);
+/**
+* @internal
+*/
+const nightIconListSchema = z.enum([
+	"01n",
+	"02n",
+	"03n",
+	"04n",
+	"09n",
+	"10n",
+	"11n",
+	"13n",
+	"50n"
+]);
+/**
+* @internal
+*/
+const iconSchema = z.union([dayIconListSchema, nightIconListSchema]);
+
+//#endregion
+//#region src/types/v2/weatherIdGroup.ts
+/**
+* This is a list of weather ids, groups and descriptions from OpenWeatherMap API
+*/
+const weatherIdGroup = [
+	{
+		id: 200,
+		group: "thunderstorm",
+		description: "thunderstorm_with_light_rain"
+	},
+	{
+		id: 201,
+		group: "thunderstorm",
+		description: "thunderstorm_with_rain"
+	},
+	{
+		id: 202,
+		group: "thunderstorm",
+		description: "thunderstorm_with_heavy_rain"
+	},
+	{
+		id: 210,
+		group: "thunderstorm",
+		description: "light_thunderstorm"
+	},
+	{
+		id: 211,
+		group: "thunderstorm",
+		description: "thunderstorm"
+	},
+	{
+		id: 212,
+		group: "thunderstorm",
+		description: "heavy_thunderstorm"
+	},
+	{
+		id: 221,
+		group: "thunderstorm",
+		description: "ragged_thunderstorm"
+	},
+	{
+		id: 230,
+		group: "thunderstorm",
+		description: "thunderstorm_with_light_drizzle"
+	},
+	{
+		id: 231,
+		group: "thunderstorm",
+		description: "thunderstorm_with_drizzle"
+	},
+	{
+		id: 232,
+		group: "thunderstorm",
+		description: "thunderstorm_with_heavy_drizzle"
+	},
+	{
+		id: 300,
+		group: "drizzle",
+		description: "light_intensity_drizzle"
+	},
+	{
+		id: 301,
+		group: "drizzle",
+		description: "drizzle"
+	},
+	{
+		id: 302,
+		group: "drizzle",
+		description: "heavy_intensity_drizzle"
+	},
+	{
+		id: 310,
+		group: "drizzle",
+		description: "light_intensity_drizzle_rain"
+	},
+	{
+		id: 311,
+		group: "drizzle",
+		description: "drizzle_rain"
+	},
+	{
+		id: 312,
+		group: "drizzle",
+		description: "heavy_intensity_drizzle_rain"
+	},
+	{
+		id: 313,
+		group: "drizzle",
+		description: "shower_rain_and_drizzle"
+	},
+	{
+		id: 314,
+		group: "drizzle",
+		description: "heavy_shower_rain_and_drizzle"
+	},
+	{
+		id: 321,
+		group: "drizzle",
+		description: "shower_drizzle"
+	},
+	{
+		id: 500,
+		group: "rain",
+		description: "light_rain"
+	},
+	{
+		id: 501,
+		group: "rain",
+		description: "moderate_rain"
+	},
+	{
+		id: 502,
+		group: "rain",
+		description: "heavy_intensity_rain"
+	},
+	{
+		id: 503,
+		group: "rain",
+		description: "very_heavy_rain"
+	},
+	{
+		id: 504,
+		group: "rain",
+		description: "extreme_rain"
+	},
+	{
+		id: 511,
+		group: "rain",
+		description: "freezing_rain"
+	},
+	{
+		id: 520,
+		group: "rain",
+		description: "light_intensity_shower_rain"
+	},
+	{
+		id: 521,
+		group: "rain",
+		description: "shower_rain"
+	},
+	{
+		id: 522,
+		group: "rain",
+		description: "heavy_intensity_shower_rain"
+	},
+	{
+		id: 531,
+		group: "rain",
+		description: "ragged_shower_rain"
+	},
+	{
+		id: 600,
+		group: "snow",
+		description: "light_snow"
+	},
+	{
+		id: 601,
+		group: "snow",
+		description: "snow"
+	},
+	{
+		id: 602,
+		group: "snow",
+		description: "heavy_snow"
+	},
+	{
+		id: 611,
+		group: "snow",
+		description: "sleet"
+	},
+	{
+		id: 612,
+		group: "snow",
+		description: "light_shower_sleet"
+	},
+	{
+		id: 613,
+		group: "snow",
+		description: "shower_sleet"
+	},
+	{
+		id: 615,
+		group: "snow",
+		description: "light_rain_and_snow"
+	},
+	{
+		id: 616,
+		group: "snow",
+		description: "rain_and_snow"
+	},
+	{
+		id: 620,
+		group: "snow",
+		description: "light_shower_snow"
+	},
+	{
+		id: 621,
+		group: "snow",
+		description: "shower_snow"
+	},
+	{
+		id: 622,
+		group: "snow",
+		description: "heavy_shower_snow"
+	},
+	{
+		id: 701,
+		group: "atmosphere",
+		description: "mist"
+	},
+	{
+		id: 711,
+		group: "atmosphere",
+		description: "smoke"
+	},
+	{
+		id: 721,
+		group: "atmosphere",
+		description: "haze"
+	},
+	{
+		id: 731,
+		group: "atmosphere",
+		description: "sand_dust_whirls"
+	},
+	{
+		id: 741,
+		group: "atmosphere",
+		description: "fog"
+	},
+	{
+		id: 751,
+		group: "atmosphere",
+		description: "sand"
+	},
+	{
+		id: 761,
+		group: "atmosphere",
+		description: "dust"
+	},
+	{
+		id: 762,
+		group: "atmosphere",
+		description: "volcanic_ash"
+	},
+	{
+		id: 771,
+		group: "atmosphere",
+		description: "squalls"
+	},
+	{
+		id: 781,
+		group: "atmosphere",
+		description: "tornado"
+	},
+	{
+		id: 800,
+		group: "clear",
+		description: "clear_sky"
+	},
+	{
+		id: 801,
+		group: "clouds",
+		description: "few_clouds_11-25_percent"
+	},
+	{
+		id: 802,
+		group: "clouds",
+		description: "scattered_clouds_25-50_percent"
+	},
+	{
+		id: 803,
+		group: "clouds",
+		description: "broken_clouds_51-84_percent"
+	},
+	{
+		id: 804,
+		group: "clouds",
+		description: "overcast_clouds_85-100_percent"
+	}
 ];
-var weatherIdSchema = z2.custom((val) => {
-  if (typeof val !== "number") {
-    return { message: "Expected a number", success: false };
-  }
-  if (!weatherIdGroup.find((x) => x.id === val)) {
-    return { message: "Expected a valid weather id", success: false };
-  }
-  return val;
+/**
+* Weather id schema
+* @internal
+*/
+const weatherIdSchema = z.custom((val) => {
+	if (typeof val !== "number") return {
+		message: "Expected a number",
+		success: false
+	};
+	if (!weatherIdGroup.find((x) => x.id === val)) return {
+		message: "Expected a valid weather id",
+		success: false
+	};
+	return val;
 });
+/**
+* get weather description key from weather id
+* @param id - weather id
+* @returns {Option<WeatherDescription>}  option for weather description key
+* @example
+* const weatherComponent = ({data}) => {
+*   const key = getWeatherV2Description(data.weather[0]?.id).unwrapOr('unknown');
+*   return (
+*     <div>
+*       {t(`weather:${key}`}
+*     </div>
+*   );
+* }
+*/
 function getWeatherV2Description(id) {
-  return undefinedOptionWrap(weatherIdGroup.find((x) => x.id === id)?.description);
+	return Option.fromNullish(weatherIdGroup.find((x) => x.id === id)?.description);
 }
 
-// src/types/v2/index.ts
-import { z as z4 } from "zod";
-
-// src/types/v2/Language.ts
-import { z as z3 } from "zod";
-var langCodes = [
-  "af",
-  "al",
-  "ar",
-  "az",
-  "bg",
-  "ca",
-  "cz",
-  "da",
-  "de",
-  "el",
-  "en",
-  "eu",
-  "fa",
-  "fi",
-  "fr",
-  "gl",
-  "he",
-  "hi",
-  "hr",
-  "hu",
-  "id",
-  "it",
-  "ja",
-  "kr",
-  "la",
-  "lt",
-  "mk",
-  "no",
-  "nl",
-  "pl",
-  "pt",
-  "pt",
-  "ro",
-  "ru",
-  "sv",
-  "sk",
-  "sl",
-  "sp",
-  "sr",
-  "th",
-  "tr",
-  "ua",
-  "vi",
-  "zh_cn",
-  "zh_tw",
-  "zu"
+//#endregion
+//#region src/types/v2/Language.ts
+const langCodes = [
+	"af",
+	"al",
+	"ar",
+	"az",
+	"bg",
+	"ca",
+	"cz",
+	"da",
+	"de",
+	"el",
+	"en",
+	"eu",
+	"fa",
+	"fi",
+	"fr",
+	"gl",
+	"he",
+	"hi",
+	"hr",
+	"hu",
+	"id",
+	"it",
+	"ja",
+	"kr",
+	"la",
+	"lt",
+	"mk",
+	"no",
+	"nl",
+	"pl",
+	"pt",
+	"pt",
+	"ro",
+	"ru",
+	"sv",
+	"sk",
+	"sl",
+	"sp",
+	"sr",
+	"th",
+	"tr",
+	"ua",
+	"vi",
+	"zh_cn",
+	"zh_tw",
+	"zu"
 ];
-var langCodeSchema = z3.enum(langCodes);
+const langCodeSchema = z.enum(langCodes);
 
-// src/types/v2/index.ts
-var coordSchema = z4.object({
-  lon: z4.number(),
-  lat: z4.number()
+//#endregion
+//#region src/types/v2/index.ts
+const coordSchema = z.object({
+	lon: z.number(),
+	lat: z.number()
 });
-var weatherSchema = z4.object({
-  description: z4.string(),
-  icon: iconSchema,
-  id: weatherIdSchema,
-  main: z4.string()
+const weatherSchema = z.object({
+	description: z.string(),
+	icon: iconSchema,
+	id: weatherIdSchema,
+	main: z.string()
 });
-var mainSchema = z4.object({
-  grnd_level: z4.number().optional(),
-  humidity: z4.number(),
-  pressure: z4.number(),
-  sea_level: z4.number().optional(),
-  temp: z4.number(),
-  temp_max: z4.number(),
-  temp_min: z4.number()
+const mainSchema = z.object({
+	grnd_level: z.number().optional(),
+	humidity: z.number(),
+	pressure: z.number(),
+	sea_level: z.number().optional(),
+	temp: z.number(),
+	temp_max: z.number(),
+	temp_min: z.number()
 });
-var windSchema = z4.object({
-  speed: z4.number(),
-  deg: z4.number()
+const windSchema = z.object({
+	speed: z.number(),
+	deg: z.number()
 });
-var rainSchema = z4.object({
-  "1h": z4.number().optional(),
-  "3h": z4.number().optional()
+const rainSchema = z.object({
+	"1h": z.number().optional(),
+	"3h": z.number().optional()
 });
-var snowSchema = z4.object({
-  "1h": z4.number().optional(),
-  "3h": z4.number().optional()
+const snowSchema = z.object({
+	"1h": z.number().optional(),
+	"3h": z.number().optional()
 });
-var sysSchema = z4.object({
-  country: z4.string(),
-  id: z4.number().optional(),
-  message: z4.number().optional(),
-  sunrise: z4.number(),
-  sunset: z4.number(),
-  type: z4.number().optional()
+const sysSchema = z.object({
+	country: z.string(),
+	id: z.number().optional(),
+	message: z.number().optional(),
+	sunrise: z.number(),
+	sunset: z.number(),
+	type: z.number().optional()
 });
-var weatherDataV2Schema = z4.object({
-  base: z4.string(),
-  clouds: z4.object({
-    all: z4.number()
-  }),
-  cod: z4.number(),
-  coord: coordSchema,
-  dt: z4.number(),
-  id: z4.number(),
-  main: mainSchema,
-  name: z4.string(),
-  rain: rainSchema.optional(),
-  snow: snowSchema.optional(),
-  sys: sysSchema,
-  timezone: z4.number(),
-  visibility: z4.number(),
-  weather: z4.array(weatherSchema),
-  wind: windSchema
+/**
+* @internal
+*/
+const weatherDataV2Schema = z.object({
+	base: z.string(),
+	clouds: z.object({ all: z.number() }),
+	cod: z.number(),
+	coord: coordSchema,
+	dt: z.number(),
+	id: z.number(),
+	main: mainSchema,
+	name: z.string(),
+	rain: rainSchema.optional(),
+	snow: snowSchema.optional(),
+	sys: sysSchema,
+	timezone: z.number(),
+	visibility: z.number(),
+	weather: z.array(weatherSchema),
+	wind: windSchema
 });
 function isWeatherDataV2(data) {
-  return weatherDataV2Schema.safeParse(data).success;
+	return weatherDataV2Schema.safeParse(data).success;
 }
 function assertWeatherDataV2(data) {
-  weatherDataV2Schema.parse(data);
+	weatherDataV2Schema.parse(data);
 }
 
-// src/types/ISO3166-Countries.ts
-import { z as z5 } from "zod";
-var CountryCodeList = [
-  "af",
-  "ax",
-  "al",
-  "dz",
-  "as",
-  "ad",
-  "ao",
-  "ai",
-  "aq",
-  "ag",
-  "ar",
-  "am",
-  "aw",
-  "au",
-  "at",
-  "az",
-  "bs",
-  "bh",
-  "bd",
-  "bb",
-  "by",
-  "be",
-  "bz",
-  "bj",
-  "bm",
-  "bt",
-  "bo",
-  "bq",
-  "ba",
-  "bw",
-  "bv",
-  "br",
-  "io",
-  "bn",
-  "bg",
-  "bf",
-  "bi",
-  "kh",
-  "cm",
-  "ca",
-  "cv",
-  "ky",
-  "cf",
-  "td",
-  "cl",
-  "cn",
-  "cx",
-  "cc",
-  "co",
-  "km",
-  "cg",
-  "cd",
-  "ck",
-  "cr",
-  "ci",
-  "hr",
-  "cu",
-  "cw",
-  "cy",
-  "cz",
-  "dk",
-  "dj",
-  "dm",
-  "do",
-  "ec",
-  "eg",
-  "sv",
-  "gq",
-  "er",
-  "ee",
-  "et",
-  "fk",
-  "fo",
-  "fj",
-  "fi",
-  "fr",
-  "gf",
-  "pf",
-  "tf",
-  "ga",
-  "gm",
-  "ge",
-  "de",
-  "gh",
-  "gi",
-  "gr",
-  "gl",
-  "gd",
-  "gp",
-  "gu",
-  "gt",
-  "gg",
-  "gn",
-  "gw",
-  "gy",
-  "ht",
-  "hm",
-  "va",
-  "hn",
-  "hk",
-  "hu",
-  "is",
-  "in",
-  "id",
-  "ir",
-  "iq",
-  "ie",
-  "im",
-  "il",
-  "it",
-  "jm",
-  "jp",
-  "je",
-  "jo",
-  "kz",
-  "ke",
-  "ki",
-  "kp",
-  "kr",
-  "kw",
-  "kg",
-  "la",
-  "lv",
-  "lb",
-  "ls",
-  "lr",
-  "ly",
-  "li",
-  "lt",
-  "lu",
-  "mo",
-  "mk",
-  "mg",
-  "mw",
-  "my",
-  "mv",
-  "ml",
-  "mt",
-  "mh",
-  "mq",
-  "mr",
-  "mu",
-  "yt",
-  "mx",
-  "fm",
-  "md",
-  "mc",
-  "mn",
-  "me",
-  "ms",
-  "ma",
-  "mz",
-  "mm",
-  "na",
-  "nr",
-  "np",
-  "nl",
-  "nc",
-  "nz",
-  "ni",
-  "ne",
-  "ng",
-  "nu",
-  "nf",
-  "mp",
-  "no",
-  "om",
-  "pk",
-  "pw",
-  "ps",
-  "pa",
-  "pg",
-  "py",
-  "pe",
-  "ph",
-  "pn",
-  "pl",
-  "pt",
-  "pr",
-  "qa",
-  "re",
-  "ro",
-  "ru",
-  "rw",
-  "bl",
-  "sh",
-  "kn",
-  "lc",
-  "mf",
-  "pm",
-  "vc",
-  "ws",
-  "sm",
-  "st",
-  "sa",
-  "sn",
-  "rs",
-  "sc",
-  "sl",
-  "sg",
-  "sx",
-  "sk",
-  "si",
-  "sb",
-  "so",
-  "za",
-  "gs",
-  "ss",
-  "es",
-  "lk",
-  "sd",
-  "sr",
-  "sj",
-  "sz",
-  "se",
-  "ch",
-  "sy",
-  "tw",
-  "tj",
-  "tz",
-  "th",
-  "tl",
-  "tg",
-  "tk",
-  "to",
-  "tt",
-  "tn",
-  "tr",
-  "tm",
-  "tc",
-  "tv",
-  "ug",
-  "ua",
-  "ae",
-  "gb",
-  "us",
-  "um",
-  "uy",
-  "uz",
-  "vu",
-  "ve",
-  "vn",
-  "vg",
-  "vi",
-  "wf",
-  "eh",
-  "ye",
-  "zm",
-  "zw"
+//#endregion
+//#region src/types/ISO3166-Countries.ts
+const CountryCodeList = [
+	"af",
+	"ax",
+	"al",
+	"dz",
+	"as",
+	"ad",
+	"ao",
+	"ai",
+	"aq",
+	"ag",
+	"ar",
+	"am",
+	"aw",
+	"au",
+	"at",
+	"az",
+	"bs",
+	"bh",
+	"bd",
+	"bb",
+	"by",
+	"be",
+	"bz",
+	"bj",
+	"bm",
+	"bt",
+	"bo",
+	"bq",
+	"ba",
+	"bw",
+	"bv",
+	"br",
+	"io",
+	"bn",
+	"bg",
+	"bf",
+	"bi",
+	"kh",
+	"cm",
+	"ca",
+	"cv",
+	"ky",
+	"cf",
+	"td",
+	"cl",
+	"cn",
+	"cx",
+	"cc",
+	"co",
+	"km",
+	"cg",
+	"cd",
+	"ck",
+	"cr",
+	"ci",
+	"hr",
+	"cu",
+	"cw",
+	"cy",
+	"cz",
+	"dk",
+	"dj",
+	"dm",
+	"do",
+	"ec",
+	"eg",
+	"sv",
+	"gq",
+	"er",
+	"ee",
+	"et",
+	"fk",
+	"fo",
+	"fj",
+	"fi",
+	"fr",
+	"gf",
+	"pf",
+	"tf",
+	"ga",
+	"gm",
+	"ge",
+	"de",
+	"gh",
+	"gi",
+	"gr",
+	"gl",
+	"gd",
+	"gp",
+	"gu",
+	"gt",
+	"gg",
+	"gn",
+	"gw",
+	"gy",
+	"ht",
+	"hm",
+	"va",
+	"hn",
+	"hk",
+	"hu",
+	"is",
+	"in",
+	"id",
+	"ir",
+	"iq",
+	"ie",
+	"im",
+	"il",
+	"it",
+	"jm",
+	"jp",
+	"je",
+	"jo",
+	"kz",
+	"ke",
+	"ki",
+	"kp",
+	"kr",
+	"kw",
+	"kg",
+	"la",
+	"lv",
+	"lb",
+	"ls",
+	"lr",
+	"ly",
+	"li",
+	"lt",
+	"lu",
+	"mo",
+	"mk",
+	"mg",
+	"mw",
+	"my",
+	"mv",
+	"ml",
+	"mt",
+	"mh",
+	"mq",
+	"mr",
+	"mu",
+	"yt",
+	"mx",
+	"fm",
+	"md",
+	"mc",
+	"mn",
+	"me",
+	"ms",
+	"ma",
+	"mz",
+	"mm",
+	"na",
+	"nr",
+	"np",
+	"nl",
+	"nc",
+	"nz",
+	"ni",
+	"ne",
+	"ng",
+	"nu",
+	"nf",
+	"mp",
+	"no",
+	"om",
+	"pk",
+	"pw",
+	"ps",
+	"pa",
+	"pg",
+	"py",
+	"pe",
+	"ph",
+	"pn",
+	"pl",
+	"pt",
+	"pr",
+	"qa",
+	"re",
+	"ro",
+	"ru",
+	"rw",
+	"bl",
+	"sh",
+	"kn",
+	"lc",
+	"mf",
+	"pm",
+	"vc",
+	"ws",
+	"sm",
+	"st",
+	"sa",
+	"sn",
+	"rs",
+	"sc",
+	"sl",
+	"sg",
+	"sx",
+	"sk",
+	"si",
+	"sb",
+	"so",
+	"za",
+	"gs",
+	"ss",
+	"es",
+	"lk",
+	"sd",
+	"sr",
+	"sj",
+	"sz",
+	"se",
+	"ch",
+	"sy",
+	"tw",
+	"tj",
+	"tz",
+	"th",
+	"tl",
+	"tg",
+	"tk",
+	"to",
+	"tt",
+	"tn",
+	"tr",
+	"tm",
+	"tc",
+	"tv",
+	"ug",
+	"ua",
+	"ae",
+	"gb",
+	"us",
+	"um",
+	"uy",
+	"uz",
+	"vu",
+	"ve",
+	"vn",
+	"vg",
+	"vi",
+	"wf",
+	"eh",
+	"ye",
+	"zm",
+	"zw"
 ];
-var CountryCodeSchema = z5.enum(CountryCodeList);
-
-// src/OpenWeatherV2.ts
-import { Err, Ok, safeAsyncResult, safeAsyncResultBuilder } from "@luolapeikko/result-option";
+/**
+* @internal
+*/
+const CountryCodeSchema = z.enum(CountryCodeList);
 
-// src/lib/fetchUtils.ts
-function fetchErrorWrapper(err) {
-  if (err instanceof DOMException || err instanceof TypeError) {
-    return err;
-  } else {
-    return new TypeError(`Unknown error: ${String(err)}`);
-  }
-}
-
-// src/OpenWeatherV2.ts
-var fetchResult = safeAsyncResultBuilder(fetch);
+//#endregion
+//#region src/OpenWeatherV2.ts
+const fetchResult = Result.wrapAsyncFn(fetch);
 function toParams(data) {
-  return Object.entries(data).reduce((acc, [key, value]) => {
-    acc[key] = String(value);
-    return acc;
-  }, {});
+	return Object.entries(data).reduce((acc, [key, value]) => {
+		acc[key] = String(value);
+		return acc;
+	}, {});
 }
 function isJson(response) {
-  const contentType = response.headers.get("content-type");
-  return contentType && contentType.startsWith("application/json") || false;
+	return response.headers.get("content-type")?.startsWith("application/json") ?? false;
 }
 function isOpenWeatherError(data) {
-  return typeof data === "object" && data !== null && "cod" in data && "message" in data;
+	return typeof data === "object" && data !== null && "cod" in data && "message" in data;
 }
-var defaultCommonOptions = {
-  lang: "en",
-  units: "standard"
+const defaultCommonOptions = {
+	lang: "en",
+	units: "standard"
 };
 function buildOpts(opts) {
-  return Object.assign({}, defaultCommonOptions, opts);
+	return Object.assign({}, defaultCommonOptions, opts);
 }
-var basePath = "https://api.openweathermap.org/data/2.5/weather";
+const basePath = "https://api.openweathermap.org/data/2.5/weather";
 function buildUrl(params) {
-  return `${basePath}?${params.toString()}`;
+	return `${basePath}?${params.toString()}`;
 }
 function buildLogUrl(params) {
-  const logParams = new URLSearchParams(params);
-  logParams.set("appid", "***");
-  return buildUrl(logParams);
+	const logParams = new URLSearchParams(params);
+	logParams.set("appid", "***");
+	return buildUrl(logParams);
 }
-var defaultImplementation = {
-  dataWeatherApi: async (params) => {
-    const logUrl = buildLogUrl(params);
-    const result = await fetchResult(buildUrl(params));
-    if (!result.isOk) {
-      return Err(result.err());
-    }
-    const res = result.ok();
-    if (!res.ok) {
-      if (isJson(res)) {
-        const data2 = await res.json();
-        if (isOpenWeatherError(data2)) {
-          return Err(new TypeError(`OpenWeatherV2 error: ${data2.message} from ${logUrl}`));
-        }
-      }
-      return Err(new TypeError(`OpenWeatherV2 http error: ${res.status} ${res.statusText} from ${logUrl}`));
-    }
-    if (!isJson(res)) {
-      return Err(new TypeError(`OpenWeatherV2 response is not json payload from ${logUrl}`));
-    }
-    const jsonResult = await safeAsyncResult(res.json());
-    if (!jsonResult.isOk) {
-      return Err(jsonResult.err());
-    }
-    const data = jsonResult.ok();
-    assertWeatherDataV2(data);
-    return Ok(data);
-  }
-};
+const defaultImplementation = { dataWeatherApi: async (params) => {
+	const logUrl = buildLogUrl(params);
+	const result = await fetchResult(buildUrl(params));
+	if (!result.isOk) return Err(result.err());
+	const res = result.ok();
+	if (!res.ok) {
+		if (isJson(res)) {
+			const data = await res.json();
+			if (isOpenWeatherError(data)) return Err(/* @__PURE__ */ new TypeError(`OpenWeatherV2 error: ${data.message} from ${logUrl}`));
+		}
+		return Err(/* @__PURE__ */ new TypeError(`OpenWeatherV2 http error: ${res.status} ${res.statusText} from ${logUrl}`));
+	}
+	if (!isJson(res)) return Err(/* @__PURE__ */ new TypeError(`OpenWeatherV2 response is not json payload from ${logUrl}`));
+	const jsonResult = await Result.safeAsyncCall(() => res.json());
+	if (!jsonResult.isOk) return Err(jsonResult.err());
+	const data = jsonResult.ok();
+	assertWeatherDataV2(data);
+	return Ok(data);
+} };
+/**
+* Open Weather V2 API
+* @example
+* const weather = new OpenWeatherV2('your-api-key');
+*
+* const cache = new ExpireCache<WeatherDataV2>(undefined, undefined, 900000); // data 15 minutes in cache
+* const weather = new OpenWeatherV2(() => Promise.resolve('your-api-key'), cache);
+*
+* const data: WeatherDataV2 = (await weather.getWeatherById(2643743)).unwrap(); // throws if error
+* const data: WeatherDataV2 | undefined = (await weather.getWeatherByCity('Helsinki', 'fi')).ok();
+*
+* const result: Result<WeatherDataV2> = await weather.getWeatherByLatLon(60.1699, 24.9384);
+* result.match({
+*  Ok: (data: WeatherDataV2) => console.log(data),
+*  Err: (err: DOMException | TypeError) => console.error(err),
+* });
+*
+* if(result.isOk) {
+*   const data: WeatherDataV2 = data.ok();
+* } else {
+*   const err: DOMException | TypeError = data.err();
+* }
+* @since v0.0.1
+*/
 var OpenWeatherV2 = class {
-  cache;
-  loadableApiKey;
-  apiHandler;
-  fetchPromiseMap = /* @__PURE__ */ new Map();
-  /**
-   * OpenWeatherV2 constructor
-   * @param {Loadable<string>} loadableApiKey - Loadable API key
-   * @param {ICacheOrAsync<WeatherDataV2>=} cache - optional async cache implementation
-   * @param {IOpenWeatherV2=} apiHandler - optional API handler implementation for mocking
-   */
-  constructor(loadableApiKey, cache, apiHandler = defaultImplementation) {
-    this.loadableApiKey = loadableApiKey;
-    this.cache = cache;
-    this.apiHandler = apiHandler;
-  }
-  /**
-   * get weather by Id
-   * @param {number} id       - Weather station ID
-   * @param {OpenWeatherV2CommonOptions=} currentOpts - Common options, example ```{lang: 'fi', units: 'metric'}```, defaults ```{lang: 'en', units: 'standard'}```
-   * @return {Promise<Result<WeatherDataV2, DOMException | TypeError>>} Weather data Result Promise
-   * @example
-   * const result: Result<WeatherDataV2, DOMException | TypeError> = await weather.getWeatherResultById(id: 564, {lang: 'fi'});
-   * if (result.isOk) {
-   *   const weatherData: WeatherDataV2 = result.ok();
-   * } else {
-   *   const error: DOMException | TypeError = result.err();
-   * }
-   */
-  async getWeatherById(id, currentOpts = {}) {
-    try {
-      const opts = buildOpts(currentOpts);
-      const cacheKey = this.buildBaseCacheKey(`id:${id}`, opts);
-      let cacheEntry = this.cache && await this.cache.get(cacheKey);
-      if (!cacheEntry) {
-        const params = await this.buildBaseParams(opts);
-        params.append("id", String(id));
-        cacheEntry = await this.handleFetch(cacheKey, params, opts);
-      }
-      return Ok(cacheEntry);
-    } catch (err) {
-      return Err(fetchErrorWrapper(err));
-    }
-  }
-  /**
-   * get weather with city name and optional country code
-   * @param {string} city       - City name
-   * @param {countryCode=} countryCode       - Optional Country code
-   * @param {OpenWeatherV2CommonOptions=} currentOpts - Common options, example ```{lang: 'fi', units: 'metric'}```, defaults ```{lang: 'en', units: 'standard'}```
-   * @return {Promise<Result<WeatherDataV2, DOMException | TypeError>>} Weather data Result Promise
-   * @example
-   * const result: Result<WeatherDataV2, DOMException | TypeError> = await weather.getWeatherByCity('Helsinki', 'fi', {lang: 'fi'});
-   * if (result.isOk) {
-   *   const weatherData: WeatherDataV2 = result.ok();
-   * } else {
-   *   const error: DOMException | TypeError = result.err();
-   * }
-   */
-  async getWeatherByCity(city, countryCode, currentOpts = {}) {
-    try {
-      const opts = buildOpts(currentOpts);
-      const cacheKey = this.buildBaseCacheKey(`q:${city}:${countryCode}`, opts);
-      let cacheEntry = this.cache && await this.cache.get(cacheKey);
-      if (!cacheEntry) {
-        const params = await this.buildBaseParams(opts);
-        params.append("q", countryCode ? `${city},${countryCode}` : city);
-        cacheEntry = await this.handleFetch(cacheKey, params, opts);
-      }
-      return Ok(cacheEntry);
-    } catch (err) {
-      return Err(fetchErrorWrapper(err));
-    }
-  }
-  /**
-   * get weather with latitude and longitude with Result
-   * @param {number} lat       - Latitude
-   * @param {number} lon       - Longitude
-   * @param {OpenWeatherV2CommonOptions=} currentOpts - Common options, example ```{lang: 'fi', units: 'metric'}```, defaults ```{lang: 'en', units: 'standard'}```
-   * @return {Promise<Result<WeatherDataV2, DOMException | TypeError>>} Weather data Result Promise
-   * @example
-   * const result: Result<WeatherDataV2, DOMException | TypeError> = await weather.getWeatherByLatLon(60.1699, 24.9384, {lang: 'fi'});
-   * if (result.isOk) {
-   *   const weatherData: WeatherDataV2 = result.ok();
-   * } else {
-   *   const error: DOMException | TypeError = result.err();
-   * }
-   */
-  async getWeatherByLatLon(lat, lon, currentOpts = {}) {
-    try {
-      const opts = buildOpts(currentOpts);
-      const cacheKey = this.buildBaseCacheKey(`latlon:${lat}:${lon}`, opts);
-      let cacheEntry = this.cache && await this.cache.get(cacheKey);
-      if (!cacheEntry) {
-        const params = await this.buildBaseParams(opts);
-        params.append("lat", String(lat));
-        params.append("lon", String(lon));
-        cacheEntry = await this.handleFetch(cacheKey, params, opts);
-      }
-      return Ok(cacheEntry);
-    } catch (err) {
-      return Err(fetchErrorWrapper(err));
-    }
-  }
-  async buildBaseParams(options) {
-    const apiKey = await (typeof this.loadableApiKey === "function" ? this.loadableApiKey() : this.loadableApiKey);
-    const params = new URLSearchParams(toParams(options));
-    params.append("appid", apiKey);
-    return params;
-  }
-  /**
-   * build base cache key
-   * @param main - main cache key prefix
-   * @param opts -  OpenWeatherV2CommonOptions
-   * @returns {string} cache key
-   */
-  buildBaseCacheKey(main, { lang, units }) {
-    return `${main}:${lang}:${units}`;
-  }
-  async handleFetch(cacheKey, params, opts) {
-    let promiseResult = this.fetchPromiseMap.get(cacheKey);
-    if (!promiseResult) {
-      promiseResult = this.apiHandler.dataWeatherApi(params);
-      this.fetchPromiseMap.set(cacheKey, promiseResult);
-      await promiseResult;
-      this.fetchPromiseMap.delete(cacheKey);
-    }
-    const dataApiResult = await promiseResult;
-    const data = dataApiResult.unwrap();
-    assertWeatherDataV2(data);
-    if (this.cache) {
-      await this.cache.set(cacheKey, data);
-      if (!cacheKey.startsWith("id:")) {
-        await this.cache.set(this.buildBaseCacheKey(`id:${data.id}`, opts), data);
-      }
-    }
-    return data;
-  }
-};
-export {
-  CountryCodeList,
-  CountryCodeSchema,
-  OpenWeatherV2,
-  assertWeatherDataV2,
-  fetchErrorWrapper,
-  getWeatherV2Description,
-  iconSchema,
-  isWeatherDataV2,
-  langCodeSchema,
-  langCodes,
-  weatherDataV2Schema,
-  weatherIdGroup,
-  weatherIdSchema
+	cache;
+	loadableApiKey;
+	apiHandler;
+	fetchPromiseMap = /* @__PURE__ */ new Map();
+	/**
+	* OpenWeatherV2 constructor
+	* @param {Loadable<string>} loadableApiKey - Loadable API key
+	* @param {ICacheOrAsync<WeatherDataV2>=} cache - optional async cache implementation
+	* @param {IOpenWeatherV2=} apiHandler - optional API handler implementation for mocking
+	*/
+	constructor(loadableApiKey, cache, apiHandler = defaultImplementation) {
+		this.loadableApiKey = loadableApiKey;
+		this.cache = cache;
+		this.apiHandler = apiHandler;
+	}
+	/**
+	* get weather by Id
+	* @param {number} id       - Weather station ID
+	* @param {OpenWeatherV2CommonOptions=} currentOpts - Common options, example ```{lang: 'fi', units: 'metric'}```, defaults ```{lang: 'en', units: 'standard'}```
+	* @return {Promise<Result<WeatherDataV2, DOMException | TypeError>>} Weather data Result Promise
+	* @example
+	* const result: Result<WeatherDataV2, DOMException | TypeError> = await weather.getWeatherResultById(id: 564, {lang: 'fi'});
+	* if (result.isOk) {
+	*   const weatherData: WeatherDataV2 = result.ok();
+	* } else {
+	*   const error: DOMException | TypeError = result.err();
+	* }
+	*/
+	async getWeatherById(id, currentOpts = {}) {
+		try {
+			const opts = buildOpts(currentOpts);
+			const cacheKey = this.buildBaseCacheKey(`id:${id}`, opts);
+			let cacheEntry = this.cache && await this.cache.get(cacheKey);
+			if (!cacheEntry) {
+				const params = await this.buildBaseParams(opts);
+				params.append("id", String(id));
+				cacheEntry = await this.handleFetch(cacheKey, params, opts);
+			}
+			return Ok(cacheEntry);
+		} catch (err) {
+			return Err(fetchErrorWrapper(err));
+		}
+	}
+	/**
+	* get weather with city name and optional country code
+	* @param {string} city       - City name
+	* @param {countryCode=} countryCode       - Optional Country code
+	* @param {OpenWeatherV2CommonOptions=} currentOpts - Common options, example ```{lang: 'fi', units: 'metric'}```, defaults ```{lang: 'en', units: 'standard'}```
+	* @return {Promise<Result<WeatherDataV2, DOMException | TypeError>>} Weather data Result Promise
+	* @example
+	* const result: Result<WeatherDataV2, DOMException | TypeError> = await weather.getWeatherByCity('Helsinki', 'fi', {lang: 'fi'});
+	* if (result.isOk) {
+	*   const weatherData: WeatherDataV2 = result.ok();
+	* } else {
+	*   const error: DOMException | TypeError = result.err();
+	* }
+	*/
+	async getWeatherByCity(city, countryCode, currentOpts = {}) {
+		try {
+			const opts = buildOpts(currentOpts);
+			const cacheKey = this.buildBaseCacheKey(`q:${city}:${countryCode}`, opts);
+			let cacheEntry = this.cache && await this.cache.get(cacheKey);
+			if (!cacheEntry) {
+				const params = await this.buildBaseParams(opts);
+				params.append("q", countryCode ? `${city},${countryCode}` : city);
+				cacheEntry = await this.handleFetch(cacheKey, params, opts);
+			}
+			return Ok(cacheEntry);
+		} catch (err) {
+			return Err(fetchErrorWrapper(err));
+		}
+	}
+	/**
+	* get weather with latitude and longitude with Result
+	* @param {number} lat       - Latitude
+	* @param {number} lon       - Longitude
+	* @param {OpenWeatherV2CommonOptions=} currentOpts - Common options, example ```{lang: 'fi', units: 'metric'}```, defaults ```{lang: 'en', units: 'standard'}```
+	* @return {Promise<Result<WeatherDataV2, DOMException | TypeError>>} Weather data Result Promise
+	* @example
+	* const result: Result<WeatherDataV2, DOMException | TypeError> = await weather.getWeatherByLatLon(60.1699, 24.9384, {lang: 'fi'});
+	* if (result.isOk) {
+	*   const weatherData: WeatherDataV2 = result.ok();
+	* } else {
+	*   const error: DOMException | TypeError = result.err();
+	* }
+	*/
+	async getWeatherByLatLon(lat, lon, currentOpts = {}) {
+		try {
+			const opts = buildOpts(currentOpts);
+			const cacheKey = this.buildBaseCacheKey(`latlon:${lat}:${lon}`, opts);
+			let cacheEntry = this.cache && await this.cache.get(cacheKey);
+			if (!cacheEntry) {
+				const params = await this.buildBaseParams(opts);
+				params.append("lat", String(lat));
+				params.append("lon", String(lon));
+				cacheEntry = await this.handleFetch(cacheKey, params, opts);
+			}
+			return Ok(cacheEntry);
+		} catch (err) {
+			return Err(fetchErrorWrapper(err));
+		}
+	}
+	async buildBaseParams(options) {
+		const apiKey = await (typeof this.loadableApiKey === "function" ? this.loadableApiKey() : this.loadableApiKey);
+		const params = new URLSearchParams(toParams(options));
+		params.append("appid", apiKey);
+		return params;
+	}
+	/**
+	* build base cache key
+	* @param main - main cache key prefix
+	* @param opts -  OpenWeatherV2CommonOptions
+	* @returns {string} cache key
+	*/
+	buildBaseCacheKey(main, { lang, units }) {
+		return `${main}:${lang}:${units}`;
+	}
+	async handleFetch(cacheKey, params, opts) {
+		let promiseResult = this.fetchPromiseMap.get(cacheKey);
+		if (!promiseResult) {
+			promiseResult = this.apiHandler.dataWeatherApi(params);
+			this.fetchPromiseMap.set(cacheKey, promiseResult);
+			await promiseResult;
+			this.fetchPromiseMap.delete(cacheKey);
+		}
+		const data = (await promiseResult).unwrap();
+		assertWeatherDataV2(data);
+		if (this.cache) {
+			await this.cache.set(cacheKey, data);
+			if (!cacheKey.startsWith("id:")) await this.cache.set(this.buildBaseCacheKey(`id:${data.id}`, opts), data);
+		}
+		return data;
+	}
 };
+
+//#endregion
+export { CountryCodeList, CountryCodeSchema, OpenWeatherV2, assertWeatherDataV2, fetchErrorWrapper, getWeatherV2Description, iconSchema, isWeatherDataV2, langCodeSchema, langCodes, weatherDataV2Schema, weatherIdGroup, weatherIdSchema };
 //# sourceMappingURL=index.mjs.map