@mharj/openweathermap 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,967 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _luolapeikko_result_option = require("@luolapeikko/result-option");
+let zod = require("zod");
+
+//#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 = zod.z.enum([
+	"01d",
+	"02d",
+	"03d",
+	"04d",
+	"09d",
+	"10d",
+	"11d",
+	"13d",
+	"50d"
+]);
+/**
+* @internal
+*/
+const nightIconListSchema = zod.z.enum([
+	"01n",
+	"02n",
+	"03n",
+	"04n",
+	"09n",
+	"10n",
+	"11n",
+	"13n",
+	"50n"
+]);
+/**
+* @internal
+*/
+const iconSchema = zod.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"
+	}
+];
+/**
+* Weather id schema
+* @internal
+*/
+const weatherIdSchema = zod.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 _luolapeikko_result_option.Option.fromNullish(weatherIdGroup.find((x) => x.id === id)?.description);
+}
+
+//#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"
+];
+const langCodeSchema = zod.z.enum(langCodes);
+
+//#endregion
+//#region src/types/v2/index.ts
+const coordSchema = zod.z.object({
+	lon: zod.z.number(),
+	lat: zod.z.number()
+});
+const weatherSchema = zod.z.object({
+	description: zod.z.string(),
+	icon: iconSchema,
+	id: weatherIdSchema,
+	main: zod.z.string()
+});
+const mainSchema = zod.z.object({
+	grnd_level: zod.z.number().optional(),
+	humidity: zod.z.number(),
+	pressure: zod.z.number(),
+	sea_level: zod.z.number().optional(),
+	temp: zod.z.number(),
+	temp_max: zod.z.number(),
+	temp_min: zod.z.number()
+});
+const windSchema = zod.z.object({
+	speed: zod.z.number(),
+	deg: zod.z.number()
+});
+const rainSchema = zod.z.object({
+	"1h": zod.z.number().optional(),
+	"3h": zod.z.number().optional()
+});
+const snowSchema = zod.z.object({
+	"1h": zod.z.number().optional(),
+	"3h": zod.z.number().optional()
+});
+const sysSchema = zod.z.object({
+	country: zod.z.string(),
+	id: zod.z.number().optional(),
+	message: zod.z.number().optional(),
+	sunrise: zod.z.number(),
+	sunset: zod.z.number(),
+	type: zod.z.number().optional()
+});
+/**
+* @internal
+*/
+const weatherDataV2Schema = zod.z.object({
+	base: zod.z.string(),
+	clouds: zod.z.object({ all: zod.z.number() }),
+	cod: zod.z.number(),
+	coord: coordSchema,
+	dt: zod.z.number(),
+	id: zod.z.number(),
+	main: mainSchema,
+	name: zod.z.string(),
+	rain: rainSchema.optional(),
+	snow: snowSchema.optional(),
+	sys: sysSchema,
+	timezone: zod.z.number(),
+	visibility: zod.z.number(),
+	weather: zod.z.array(weatherSchema),
+	wind: windSchema
+});
+function isWeatherDataV2(data) {
+	return weatherDataV2Schema.safeParse(data).success;
+}
+function assertWeatherDataV2(data) {
+	weatherDataV2Schema.parse(data);
+}
+
+//#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"
+];
+/**
+* @internal
+*/
+const CountryCodeSchema = zod.z.enum(CountryCodeList);
+
+//#endregion
+//#region src/OpenWeatherV2.ts
+const fetchResult = _luolapeikko_result_option.Result.wrapAsyncFn(fetch);
+function toParams(data) {
+	return Object.entries(data).reduce((acc, [key, value]) => {
+		acc[key] = String(value);
+		return acc;
+	}, {});
+}
+function isJson(response) {
+	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;
+}
+const defaultCommonOptions = {
+	lang: "en",
+	units: "standard"
+};
+function buildOpts(opts) {
+	return Object.assign({}, defaultCommonOptions, opts);
+}
+const basePath = "https://api.openweathermap.org/data/2.5/weather";
+function buildUrl(params) {
+	return `${basePath}?${params.toString()}`;
+}
+function buildLogUrl(params) {
+	const logParams = new URLSearchParams(params);
+	logParams.set("appid", "***");
+	return buildUrl(logParams);
+}
+const defaultImplementation = { dataWeatherApi: async (params) => {
+	const logUrl = buildLogUrl(params);
+	const result = await fetchResult(buildUrl(params));
+	if (!result.isOk) return (0, _luolapeikko_result_option.Err)(result.err());
+	const res = result.ok();
+	if (!res.ok) {
+		if (isJson(res)) {
+			const data = await res.json();
+			if (isOpenWeatherError(data)) return (0, _luolapeikko_result_option.Err)(/* @__PURE__ */ new TypeError(`OpenWeatherV2 error: ${data.message} from ${logUrl}`));
+		}
+		return (0, _luolapeikko_result_option.Err)(/* @__PURE__ */ new TypeError(`OpenWeatherV2 http error: ${res.status} ${res.statusText} from ${logUrl}`));
+	}
+	if (!isJson(res)) return (0, _luolapeikko_result_option.Err)(/* @__PURE__ */ new TypeError(`OpenWeatherV2 response is not json payload from ${logUrl}`));
+	const jsonResult = await _luolapeikko_result_option.Result.safeAsyncCall(() => res.json());
+	if (!jsonResult.isOk) return (0, _luolapeikko_result_option.Err)(jsonResult.err());
+	const data = jsonResult.ok();
+	assertWeatherDataV2(data);
+	return (0, _luolapeikko_result_option.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 (0, _luolapeikko_result_option.Ok)(cacheEntry);
+		} catch (err) {
+			return (0, _luolapeikko_result_option.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 (0, _luolapeikko_result_option.Ok)(cacheEntry);
+		} catch (err) {
+			return (0, _luolapeikko_result_option.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 (0, _luolapeikko_result_option.Ok)(cacheEntry);
+		} catch (err) {
+			return (0, _luolapeikko_result_option.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
+exports.CountryCodeList = CountryCodeList;
+exports.CountryCodeSchema = CountryCodeSchema;
+exports.OpenWeatherV2 = OpenWeatherV2;
+exports.assertWeatherDataV2 = assertWeatherDataV2;
+exports.fetchErrorWrapper = fetchErrorWrapper;
+exports.getWeatherV2Description = getWeatherV2Description;
+exports.iconSchema = iconSchema;
+exports.isWeatherDataV2 = isWeatherDataV2;
+exports.langCodeSchema = langCodeSchema;
+exports.langCodes = langCodes;
+exports.weatherDataV2Schema = weatherDataV2Schema;
+exports.weatherIdGroup = weatherIdGroup;
+exports.weatherIdSchema = weatherIdSchema;
+//# sourceMappingURL=index.cjs.map