@mharj/openweathermap 0.0.7 → 0.1.0

package/dist/index.js

@@ -1,8 +1,942 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./OpenWeatherV2"), exports);
-tslib_1.__exportStar(require("./types"), exports);
-tslib_1.__exportStar(require("./lib"), exports);
-tslib_1.__exportStar(require("./interfaces"), exports);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CountryCodeList: () => CountryCodeList,
+  CountryCodeSchema: () => CountryCodeSchema,
+  OpenWeatherV2: () => OpenWeatherV2,
+  assertWeatherDataV2: () => assertWeatherDataV2,
+  fetchErrorWrapper: () => fetchErrorWrapper,
+  getWeatherV2Description: () => getWeatherV2Description,
+  iconSchema: () => iconSchema,
+  isWeatherDataV2: () => isWeatherDataV2,
+  langCodeSchema: () => langCodeSchema,
+  langCodes: () => langCodes,
+  weatherDataV2Schema: () => weatherDataV2Schema,
+  weatherIdGroup: () => weatherIdGroup,
+  weatherIdSchema: () => weatherIdSchema
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/types/v2/Icon.ts
+var import_zod = require("zod");
+var dayIconList = ["01d", "02d", "03d", "04d", "09d", "10d", "11d", "13d", "50d"];
+var dayIconListSchema = import_zod.z.enum(dayIconList);
+var nightIconList = ["01n", "02n", "03n", "04n", "09n", "10n", "11n", "13n", "50n"];
+var nightIconListSchema = import_zod.z.enum(nightIconList);
+var iconSchema = import_zod.z.union([dayIconListSchema, nightIconListSchema]);
+
+// src/types/v2/weatherIdGroup.ts
+var import_result_option = require("@luolapeikko/result-option");
+var import_zod2 = require("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"
+  }
+];
+var weatherIdSchema = import_zod2.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;
+});
+function getWeatherV2Description(id) {
+  return (0, import_result_option.undefinedOptionWrap)(weatherIdGroup.find((x) => x.id === id)?.description);
+}
+
+// src/types/v2/index.ts
+var import_zod4 = require("zod");
+
+// src/types/v2/Language.ts
+var import_zod3 = require("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"
+];
+var langCodeSchema = import_zod3.z.enum(langCodes);
+
+// src/types/v2/index.ts
+var coordSchema = import_zod4.z.object({
+  lon: import_zod4.z.number(),
+  lat: import_zod4.z.number()
+});
+var weatherSchema = import_zod4.z.object({
+  description: import_zod4.z.string(),
+  icon: iconSchema,
+  id: weatherIdSchema,
+  main: import_zod4.z.string()
+});
+var mainSchema = import_zod4.z.object({
+  grnd_level: import_zod4.z.number().optional(),
+  humidity: import_zod4.z.number(),
+  pressure: import_zod4.z.number(),
+  sea_level: import_zod4.z.number().optional(),
+  temp: import_zod4.z.number(),
+  temp_max: import_zod4.z.number(),
+  temp_min: import_zod4.z.number()
+});
+var windSchema = import_zod4.z.object({
+  speed: import_zod4.z.number(),
+  deg: import_zod4.z.number()
+});
+var rainSchema = import_zod4.z.object({
+  "1h": import_zod4.z.number().optional(),
+  "3h": import_zod4.z.number().optional()
+});
+var snowSchema = import_zod4.z.object({
+  "1h": import_zod4.z.number().optional(),
+  "3h": import_zod4.z.number().optional()
+});
+var sysSchema = import_zod4.z.object({
+  country: import_zod4.z.string(),
+  id: import_zod4.z.number().optional(),
+  message: import_zod4.z.number().optional(),
+  sunrise: import_zod4.z.number(),
+  sunset: import_zod4.z.number(),
+  type: import_zod4.z.number().optional()
+});
+var weatherDataV2Schema = import_zod4.z.object({
+  base: import_zod4.z.string(),
+  clouds: import_zod4.z.object({
+    all: import_zod4.z.number()
+  }),
+  cod: import_zod4.z.number(),
+  coord: coordSchema,
+  dt: import_zod4.z.number(),
+  id: import_zod4.z.number(),
+  main: mainSchema,
+  name: import_zod4.z.string(),
+  rain: rainSchema.optional(),
+  snow: snowSchema.optional(),
+  sys: sysSchema,
+  timezone: import_zod4.z.number(),
+  visibility: import_zod4.z.number(),
+  weather: import_zod4.z.array(weatherSchema),
+  wind: windSchema
+});
+function isWeatherDataV2(data) {
+  return weatherDataV2Schema.safeParse(data).success;
+}
+function assertWeatherDataV2(data) {
+  weatherDataV2Schema.parse(data);
+}
+
+// src/types/ISO3166-Countries.ts
+var import_zod5 = require("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"
+];
+var CountryCodeSchema = import_zod5.z.enum(CountryCodeList);
+
+// src/OpenWeatherV2.ts
+var import_result_option2 = require("@luolapeikko/result-option");
+
+// 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 = (0, import_result_option2.safeAsyncResultBuilder)(fetch);
+function toParams(data) {
+  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;
+}
+function isOpenWeatherError(data) {
+  return typeof data === "object" && data !== null && "cod" in data && "message" in data;
+}
+var defaultCommonOptions = {
+  lang: "en",
+  units: "standard"
+};
+function buildOpts(opts) {
+  return Object.assign({}, defaultCommonOptions, opts);
+}
+var 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);
+}
+var defaultImplementation = {
+  dataWeatherApi: async (params) => {
+    const logUrl = buildLogUrl(params);
+    const result = await fetchResult(buildUrl(params));
+    if (!result.isOk) {
+      return (0, import_result_option2.Err)(result.err());
+    }
+    const res = result.ok();
+    if (!res.ok) {
+      if (isJson(res)) {
+        const data2 = await res.json();
+        if (isOpenWeatherError(data2)) {
+          return (0, import_result_option2.Err)(new TypeError(`OpenWeatherV2 error: ${data2.message} from ${logUrl}`));
+        }
+      }
+      return (0, import_result_option2.Err)(new TypeError(`OpenWeatherV2 http error: ${res.status} ${res.statusText} from ${logUrl}`));
+    }
+    if (!isJson(res)) {
+      return (0, import_result_option2.Err)(new TypeError(`OpenWeatherV2 response is not json payload from ${logUrl}`));
+    }
+    const jsonResult = await (0, import_result_option2.safeAsyncResult)(res.json());
+    if (!jsonResult.isOk) {
+      return (0, import_result_option2.Err)(jsonResult.err());
+    }
+    const data = jsonResult.ok();
+    assertWeatherDataV2(data);
+    return (0, import_result_option2.Ok)(data);
+  }
+};
+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, import_result_option2.Ok)(cacheEntry);
+    } catch (err) {
+      return (0, import_result_option2.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, import_result_option2.Ok)(cacheEntry);
+    } catch (err) {
+      return (0, import_result_option2.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, import_result_option2.Ok)(cacheEntry);
+    } catch (err) {
+      return (0, import_result_option2.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;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CountryCodeList,
+  CountryCodeSchema,
+  OpenWeatherV2,
+  assertWeatherDataV2,
+  fetchErrorWrapper,
+  getWeatherV2Description,
+  iconSchema,
+  isWeatherDataV2,
+  langCodeSchema,
+  langCodes,
+  weatherDataV2Schema,
+  weatherIdGroup,
+  weatherIdSchema
+});
 //# sourceMappingURL=index.js.map