@i-giann/open-meteo-wrapper 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,673 @@
+import { useCallback as B, useEffect as q, useMemo as Q } from "react";
+import { create as $ } from "zustand";
+import { produce as z } from "immer";
+function V(e, a) {
+  let t;
+  try {
+    t = e();
+  } catch {
+    return;
+  }
+  return {
+    getItem: (u) => {
+      var r;
+      const s = (d) => d === null ? null : JSON.parse(d, void 0), i = (r = t.getItem(u)) != null ? r : null;
+      return i instanceof Promise ? i.then(s) : s(i);
+    },
+    setItem: (u, r) => t.setItem(
+      u,
+      JSON.stringify(r, void 0)
+    ),
+    removeItem: (u) => t.removeItem(u)
+  };
+}
+const x = (e) => (a) => {
+  try {
+    const t = e(a);
+    return t instanceof Promise ? t : {
+      then(o) {
+        return x(o)(t);
+      },
+      catch(o) {
+        return this;
+      }
+    };
+  } catch (t) {
+    return {
+      then(o) {
+        return this;
+      },
+      catch(o) {
+        return x(o)(t);
+      }
+    };
+  }
+}, X = (e, a) => (t, o, u) => {
+  let r = {
+    storage: V(() => localStorage),
+    partialize: (c) => c,
+    version: 0,
+    merge: (c, T) => ({
+      ...T,
+      ...c
+    }),
+    ...a
+  }, s = !1;
+  const i = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set();
+  let m = r.storage;
+  if (!m)
+    return e(
+      (...c) => {
+        console.warn(
+          `[zustand persist middleware] Unable to update item '${r.name}', the given storage is currently unavailable.`
+        ), t(...c);
+      },
+      o,
+      u
+    );
+  const g = () => {
+    const c = r.partialize({ ...o() });
+    return m.setItem(r.name, {
+      state: c,
+      version: r.version
+    });
+  }, p = u.setState;
+  u.setState = (c, T) => {
+    p(c, T), g();
+  };
+  const l = e(
+    (...c) => {
+      t(...c), g();
+    },
+    o,
+    u
+  );
+  u.getInitialState = () => l;
+  let v;
+  const L = () => {
+    var c, T;
+    if (!m) return;
+    s = !1, i.forEach((R) => {
+      var y;
+      return R((y = o()) != null ? y : l);
+    });
+    const N = ((T = r.onRehydrateStorage) == null ? void 0 : T.call(r, (c = o()) != null ? c : l)) || void 0;
+    return x(m.getItem.bind(m))(r.name).then((R) => {
+      if (R)
+        if (typeof R.version == "number" && R.version !== r.version) {
+          if (r.migrate) {
+            const y = r.migrate(
+              R.state,
+              R.version
+            );
+            return y instanceof Promise ? y.then((D) => [!0, D]) : [!0, y];
+          }
+          console.error(
+            "State loaded from storage couldn't be migrated since no migrate function was provided"
+          );
+        } else
+          return [!1, R.state];
+      return [!1, void 0];
+    }).then((R) => {
+      var y;
+      const [D, U] = R;
+      if (v = r.merge(
+        U,
+        (y = o()) != null ? y : l
+      ), t(v, !0), D)
+        return g();
+    }).then(() => {
+      N == null || N(v, void 0), v = o(), s = !0, d.forEach((R) => R(v));
+    }).catch((R) => {
+      N == null || N(void 0, R);
+    });
+  };
+  return u.persist = {
+    setOptions: (c) => {
+      r = {
+        ...r,
+        ...c
+      }, c.storage && (m = c.storage);
+    },
+    clearStorage: () => {
+      m == null || m.removeItem(r.name);
+    },
+    getOptions: () => r,
+    rehydrate: () => L(),
+    hasHydrated: () => s,
+    onHydrate: (c) => (i.add(c), () => {
+      i.delete(c);
+    }),
+    onFinishHydration: (c) => (d.add(c), () => {
+      d.delete(c);
+    })
+  }, r.skipHydration || L(), v || l;
+}, ee = X;
+var I = /* @__PURE__ */ ((e) => (e.SUCCESS = "success", e.ERROR = "error", e.WARNING = "warning", e.INFO = "info", e))(I || {}), w = /* @__PURE__ */ ((e) => (e.NETWORK_ERROR = "network_error", e.API_ERROR = "api_error", e.DATA_ERROR = "data_error", e.UNKNOWN_ERROR = "unknown_error", e))(w || {}), k = /* @__PURE__ */ ((e) => (e.Temperature = "temperature_2m", e.RelativeHumidity = "relative_humidity_2m", e.DewPoint = "dew_point_2m", e.ApparentTemperature = "apparent_temperature", e.PrecipitationProbability = "precipitation_probability", e.Precipitation = "precipitation", e.Rain = "rain", e.Snowfall = "snowfall", e.SnowDepth = "snow_depth", e.WeatherCode = "weather_code", e.PressureMsl = "pressure_msl", e.CloudCover = "cloud_cover", e.Visibility = "visibility", e.WindSpeed = "wind_speed_10m", e.WindDirection = "wind_direction_10m", e.UvIndex = "uv_index", e.IsDay = "is_day", e))(k || {}), G = /* @__PURE__ */ ((e) => (e.TemperatureMax = "temperature_2m_max", e.TemperatureMin = "temperature_2m_min", e.Sunrise = "sunrise", e.Sunset = "sunset", e.DaylightDuration = "daylight_duration", e))(G || {}), E = /* @__PURE__ */ ((e) => (e.UNKNOWN = "Desconocido", e.LOW = "Bajo", e.MODERATE = "Moderado", e.HIGH = "Alto", e))(E || {}), h = /* @__PURE__ */ ((e) => (e.clear_sky = "Cielo despejado", e.mainly_clear = "Mayormente despejado", e.partly_cloudy = "Parcialmente nublado", e.overcast = "Mayormente nublado", e.fog = "Niebla", e.depositing_rime_fog = "Niebla con escarcha", e.drizzle_light = "Llovizna ligera", e.drizzle_moderate = "Llovizna moderada", e.drizzle_dense = "Llovizna densa", e.freezing_drizzle_light = "Llovizna helada ligera", e.freezing_drizzle_dense = "Llovizna helada densa", e.rain_slight = "Lluvia ligera", e.rain_moderate = "Lluvia moderada", e.rain_heavy = "Lluvia intensa", e.freezing_rain_light = "Lluvia helada ligera", e.freezing_rain_heavy = "Lluvia helada intensa", e.snowfall_slight = "Nevada ligera", e.snowfall_moderate = "Nevada moderada", e.snowfall_heavy = "Nevada intensa", e.snow_grains = "Precipitación de granos de nieve", e.rain_showers_slight = "Chubascos ligeros", e.rain_showers_moderate = "Chubascos moderados", e.rain_showers_violent = "Chubascos violentos", e.snow_showers_slight = "Chubascos de nieve ligeros", e.snow_showers_heavy = "Chubascos de nieve intensos", e.thunderstorm = "Tormenta", e))(h || {});
+const te = "https://api.open-meteo.com/v1/forecast", A = {
+  /** Zona horaria por defecto para las consultas */
+  DEFAULT_TIMEZONE: "America/Sao_Paulo",
+  /** Parámetros meteorológicos por hora solicitados por defecto */
+  DEFAULT_HOURLY_PARAMS: [
+    k.Temperature,
+    k.WeatherCode
+  ],
+  /** Parámetros meteorológicos diarios solicitados por defecto */
+  DEFAULT_DAILY_PARAMS: [
+    G.TemperatureMax,
+    G.TemperatureMin
+  ],
+  /** Número de días pasados a incluir por defecto */
+  DEFAULT_PAST_DAYS: 0,
+  /** Número de días de pronóstico a incluir por defecto */
+  DEFAULT_FORECAST_DAYS: 7,
+  /** Duración del caché en milisegundos (10 minutos) */
+  DEFAULT_CACHE_DURATION: 10 * 60 * 1e3,
+  /** Timeout para las solicitudes HTTP en milisegundos */
+  REQUEST_TIMEOUT: 1e4
+}, H = {
+  /** Descripciones de recomendaciones por nivel de riesgo UV */
+  DESCRIPTIONS: {
+    [E.UNKNOWN]: "No se puede determinar el riesgo de exposición",
+    [E.LOW]: "Puedes disfrutar de estar afuera con seguridad",
+    [E.MODERATE]: "Busca sombra durante las horas del mediodía. Ponte una remera, utiliza protector solar y un sombrero.",
+    [E.HIGH]: "Evita estar afuera durante las horas del mediodía. Asegúrate de buscar sombra. La remera, el protector solar y el sombrero son imprescindibles."
+  }
+}, re = {
+  // Cielo despejado y parcialmente nublado
+  0: h.clear_sky,
+  1: h.mainly_clear,
+  2: h.partly_cloudy,
+  3: h.overcast,
+  // Niebla
+  45: h.fog,
+  48: h.depositing_rime_fog,
+  // Llovizna
+  51: h.drizzle_light,
+  53: h.drizzle_moderate,
+  55: h.drizzle_dense,
+  56: h.freezing_drizzle_light,
+  57: h.freezing_drizzle_dense,
+  // Lluvia
+  61: h.rain_slight,
+  63: h.rain_moderate,
+  65: h.rain_heavy,
+  66: h.freezing_rain_light,
+  67: h.freezing_rain_heavy,
+  // Nieve
+  71: h.snowfall_slight,
+  73: h.snowfall_moderate,
+  75: h.snowfall_heavy,
+  77: h.snow_grains,
+  // Chubascos
+  80: h.rain_showers_slight,
+  81: h.rain_showers_moderate,
+  82: h.rain_showers_violent,
+  85: h.snow_showers_slight,
+  86: h.snow_showers_heavy,
+  // Tormentas
+  95: h.thunderstorm
+}, f = {
+  // Tiempo
+  time: "iso8601",
+  hour: "iso8601",
+  // Temperatura
+  temperature_2m: "ºC",
+  temperature_2m_max: "ºC",
+  temperature_2m_min: "ºC",
+  dew_point_2m: "ºC",
+  apparent_temperature: "ºC",
+  // Humedad y precipitación
+  relative_humidity_2m: "%",
+  precipitation_probability: "%",
+  precipitation: "mm",
+  rain: "mm",
+  snowfall: "cm",
+  snow_depth: "m",
+  // Presión y viento
+  pressure_msl: "hPa",
+  wind_speed_10m: "km/h",
+  wind_direction_10m: "°",
+  // Cielo y visibilidad
+  cloud_cover: "%",
+  visibility: "km",
+  weather_code: "wmo code",
+  // Sol y UV
+  sunrise: "iso8601",
+  sunset: "iso8601",
+  daylight_duration: "h",
+  is_day: "flag"
+};
+class ae {
+  async fetchRaw({
+    latitude: a,
+    longitude: t,
+    hourly: o = A.DEFAULT_HOURLY_PARAMS,
+    daily: u = A.DEFAULT_DAILY_PARAMS,
+    timezone: r = A.DEFAULT_TIMEZONE,
+    past_days: s = A.DEFAULT_PAST_DAYS,
+    forecast_days: i = A.DEFAULT_FORECAST_DAYS
+  }) {
+    try {
+      const d = new URL(te), m = new URLSearchParams({
+        latitude: a.toString(),
+        longitude: t.toString(),
+        hourly: o.join(","),
+        daily: u.join(","),
+        timezone: r,
+        past_days: s.toString(),
+        forecast_days: i.toString()
+      });
+      d.search = m.toString();
+      const g = new AbortController(), p = setTimeout(() => g.abort(), A.REQUEST_TIMEOUT), l = await fetch(d.toString(), {
+        signal: g.signal
+      });
+      return clearTimeout(p), l.ok ? await l.json() : l.status >= 500 ? this.buildError({
+        error: "Debido a un problema en el servidor, no podemos obtener la información del clima.",
+        info: "Por favor, inténtalo de nuevo más tarde.",
+        status: l.status,
+        errorType: w.API_ERROR
+      }) : l.status >= 400 ? l.status === 408 ? this.buildError({
+        error: "La solicitud ha tardado demasiado tiempo en completarse.",
+        status: 408,
+        info: "Revisa tu conexión a internet e intenta de nuevo.",
+        type: I.WARNING,
+        errorType: w.NETWORK_ERROR
+      }) : this.buildError({
+        error: "No pudimos obtener la información del clima.",
+        info: "Verifica que la ubicación ingresada sea correcta e inténtalo de nuevo.",
+        status: l.status,
+        type: I.WARNING,
+        errorType: w.API_ERROR
+      }) : this.buildError({
+        error: "Ocurrió un error al obtener los datos del clima.",
+        status: l.status,
+        errorType: w.UNKNOWN_ERROR
+      });
+    } catch (d) {
+      return d instanceof DOMException && d.name === "AbortError" ? this.buildError({
+        error: "La solicitud ha tardado demasiado tiempo en completarse.",
+        status: 408,
+        info: "Revisa tu conexión a internet e intenta de nuevo.",
+        type: I.WARNING,
+        errorType: w.NETWORK_ERROR
+      }) : this.buildError({
+        error: "Ocurrió un error inesperado al obtener los datos meteorológicos.",
+        type: I.ERROR,
+        status: 0,
+        errorType: w.UNKNOWN_ERROR
+      });
+    }
+  }
+  buildError({ error: a, info: t, status: o, type: u, errorType: r }) {
+    return {
+      error: a || "Error desconocido.",
+      info: t,
+      status: o || 0,
+      type: u || I.ERROR,
+      errorType: r || w.UNKNOWN_ERROR
+    };
+  }
+}
+const ne = (e) => e < 0 ? E.UNKNOWN : e <= 2 ? E.LOW : e <= 7 ? E.MODERATE : E.HIGH, oe = (e) => e < 0 ? H.DESCRIPTIONS[E.UNKNOWN] : e <= 2 ? H.DESCRIPTIONS[E.LOW] : e <= 7 ? H.DESCRIPTIONS[E.MODERATE] : H.DESCRIPTIONS[E.HIGH];
+class ie {
+  adapt(a, t, o) {
+    const u = t, r = u + 1, s = t + o + 1, i = this.processWeatherData(
+      a,
+      u,
+      r
+    ), d = i.length > 0 ? i[0] : {};
+    return {
+      pastDay: this.processWeatherData(a, 0, u),
+      currentDay: d,
+      forecast: this.processWeatherData(a, r, s),
+      timezone: a.timezone,
+      latitude: a.latitude,
+      longitude: a.longitude
+    };
+  }
+  processWeatherData(a, t, o) {
+    const { daily: u } = a, r = [], {
+      time: s,
+      temperature_2m_max: i,
+      temperature_2m_min: d,
+      sunrise: m,
+      sunset: g,
+      daylight_duration: p
+    } = u;
+    for (let l = t; l < o; l++) {
+      const v = {};
+      s != null && s[l] && (v.day = { value: new Date(s[l]), unit: f.time }), (i == null ? void 0 : i[l]) !== void 0 && (v.temperatureMax = {
+        value: i[l],
+        unit: f.temperature_2m_max
+      }), (d == null ? void 0 : d[l]) !== void 0 && (v.temperatureMin = {
+        value: d[l],
+        unit: f.temperature_2m_min
+      }), m != null && m[l] && (v.sunrise = {
+        value: new Date(m[l]),
+        unit: f.sunrise
+      }), g != null && g[l] && (v.sunset = { value: new Date(g[l]), unit: f.sunset }), (p == null ? void 0 : p[l]) !== void 0 && (v.daylightDuration = {
+        value: p[l] / 3600,
+        unit: f.daylight_duration
+      }), v.hourly = this.getHourlyData(a, l), r.push(v);
+    }
+    return r;
+  }
+  getHourlyData(a, t) {
+    const { hourly: o, daily: u } = a, {
+      time: r,
+      temperature_2m: s,
+      relative_humidity_2m: i,
+      dew_point_2m: d,
+      apparent_temperature: m,
+      precipitation_probability: g,
+      precipitation: p,
+      rain: l,
+      snowfall: v,
+      snow_depth: L,
+      weather_code: c,
+      pressure_msl: T,
+      cloud_cover: N,
+      visibility: R,
+      wind_direction_10m: y,
+      wind_speed_10m: D,
+      uv_index: U,
+      is_day: C
+    } = o, b = a.timezone || "UTC";
+    let F, M, P;
+    const W = u.time[t];
+    if (typeof W == "string" && /^\d{4}-\d{2}-\d{2}$/.test(W)) {
+      const S = W.split("-").map(Number);
+      F = S[0], M = S[1] - 1, P = S[2];
+    } else {
+      const S = new Date(W);
+      F = Number(
+        S.toLocaleString("en", { timeZone: b, year: "numeric" })
+      ), M = Number(S.toLocaleString("en", { timeZone: b, month: "numeric" })) - 1, P = Number(
+        S.toLocaleString("en", { timeZone: b, day: "numeric" })
+      );
+    }
+    const Y = [];
+    for (let S = 0; S < 24; S++) {
+      let K = -1;
+      for (let n = 0; n < r.length; n++) {
+        const _ = new Date(r[n]), O = Number(
+          _.toLocaleString("en", { timeZone: b, year: "numeric" })
+        ), j = Number(
+          _.toLocaleString("en", { timeZone: b, month: "numeric" })
+        ) - 1, Z = Number(
+          _.toLocaleString("en", { timeZone: b, day: "numeric" })
+        ), J = Number(
+          _.toLocaleString("en", {
+            timeZone: b,
+            hour: "numeric",
+            hour12: !1
+          })
+        );
+        if (O === F && j === M && Z === P && J === S) {
+          K = n;
+          break;
+        }
+      }
+      if (K !== -1) {
+        const n = K, _ = {};
+        if (_.hour = { value: new Date(r[n]), unit: f.hour }, (s == null ? void 0 : s[n]) !== void 0 && (_.temperature = {
+          value: s[n],
+          unit: f.temperature_2m
+        }), (i == null ? void 0 : i[n]) !== void 0 && (_.relativeHumidity = {
+          value: i[n],
+          unit: f.relative_humidity_2m
+        }), (d == null ? void 0 : d[n]) !== void 0 && (_.dewPoint = {
+          value: d[n],
+          unit: f.dew_point_2m
+        }), (m == null ? void 0 : m[n]) !== void 0 && (_.apparentTemperature = {
+          value: m[n],
+          unit: f.apparent_temperature
+        }), (g == null ? void 0 : g[n]) !== void 0 && (_.precipitationProbability = {
+          value: g[n],
+          unit: f.precipitation_probability
+        }), (p == null ? void 0 : p[n]) !== void 0 && (_.precipitation = {
+          value: p[n],
+          unit: f.precipitation
+        }), (l == null ? void 0 : l[n]) !== void 0 && (_.rain = { value: l[n], unit: f.rain }), (v == null ? void 0 : v[n]) !== void 0 && (_.snowfall = { value: v[n], unit: f.snowfall }), (L == null ? void 0 : L[n]) !== void 0 && (_.snowDepth = { value: L[n], unit: f.snow_depth }), (c == null ? void 0 : c[n]) !== void 0) {
+          _.weatherCode = {
+            value: c[n],
+            unit: f.weather_code
+          };
+          const O = re[c[n]];
+          O && (_.weatherDescription = { value: O, unit: "text" });
+        }
+        if ((T == null ? void 0 : T[n]) !== void 0 && (_.pressureMsl = {
+          value: T[n],
+          unit: f.pressure_msl
+        }), (N == null ? void 0 : N[n]) !== void 0 && (_.cloudCover = {
+          value: N[n],
+          unit: f.cloud_cover
+        }), (R == null ? void 0 : R[n]) !== void 0 && (_.visibility = {
+          value: R[n] / 1e3,
+          unit: f.visibility
+        }), ((D == null ? void 0 : D[n]) !== void 0 || (y == null ? void 0 : y[n]) !== void 0) && (_.wind = {
+          speed: {
+            value: (D == null ? void 0 : D[n]) || 0,
+            unit: f.wind_speed_10m
+          }
+        }, (y == null ? void 0 : y[n]) !== void 0 && (_.wind.direction = {
+          value: y[n],
+          unit: f.wind_direction_10m
+        })), (U == null ? void 0 : U[n]) !== void 0) {
+          const O = U[n];
+          _.uv = {
+            value: O,
+            riskLevel: ne(O),
+            description: oe(O),
+            unit: "index"
+          };
+        }
+        (C == null ? void 0 : C[n]) !== void 0 && (_.isDay = { value: C[n], unit: f.is_day }), Y.push(_);
+      } else {
+        const n = new Date(
+          Date.UTC(F, M, P, S, 0, 0, 0)
+        );
+        Y.push({ hour: { value: n, unit: f.hour } });
+      }
+    }
+    return Y;
+  }
+}
+const se = async (e, a) => {
+  const {
+    latitude: t,
+    longitude: o,
+    hourly: u = A.DEFAULT_HOURLY_PARAMS,
+    daily: r = A.DEFAULT_DAILY_PARAMS,
+    timezone: s = A.DEFAULT_TIMEZONE,
+    past_days: i = A.DEFAULT_PAST_DAYS,
+    forecast_days: d = A.DEFAULT_FORECAST_DAYS
+  } = e, m = (a == null ? void 0 : a.client) || new ae(), g = (a == null ? void 0 : a.adapter) || new ie(), p = await m.fetchRaw({
+    latitude: t,
+    longitude: o,
+    hourly: u,
+    daily: r,
+    timezone: s,
+    past_days: i,
+    forecast_days: d
+  });
+  return "error" in p ? p : g.adapt(
+    p,
+    i || 0,
+    d || 0
+  );
+};
+let ue = (e) => se(e);
+function le(e, a) {
+  return JSON.stringify(e) === JSON.stringify(a);
+}
+const de = $()(
+  ee(
+    (e, a) => ({
+      data: null,
+      loading: !1,
+      error: null,
+      autoRefresh: !0,
+      fetchParams: null,
+      // Variables de caché
+      lastFetchTime: null,
+      cacheDuration: 10 * 60 * 1e3,
+      // 10 minutos por defecto
+      /**
+       * Realiza la solicitud para obtener datos meteorológicos.
+       * Si los parámetros y el caché lo permiten, reutiliza los datos existentes.
+       * Si no, realiza una nueva consulta y actualiza el estado.
+       */
+      fetchWeather: async (t) => {
+        const o = a(), u = Date.now();
+        if (!(o.fetchParams && le(o.fetchParams, t) && o.data && o.lastFetchTime !== null && u - o.lastFetchTime < o.cacheDuration)) {
+          e(
+            z((s) => {
+              s.loading = !0, s.error = null, s.fetchParams = t;
+            })
+          );
+          try {
+            const s = await ue(t);
+            if ("error" in s) {
+              e(
+                z((i) => {
+                  i.error = s, i.loading = !1;
+                })
+              );
+              return;
+            }
+            e(
+              z((i) => {
+                i.data = s, i.loading = !1, i.error = null, i.lastFetchTime = Date.now();
+              })
+            );
+          } catch (s) {
+            const i = s instanceof Error ? s.message : "Error desconocido.";
+            e(
+              z((d) => {
+                d.error = {
+                  error: i,
+                  type: I.WARNING,
+                  errorType: w.UNKNOWN_ERROR,
+                  status: 0
+                }, d.loading = !1;
+              })
+            );
+          }
+        }
+      },
+      /** Indica si está en proceso de carga */
+      isLoading: () => a().loading,
+      /** Indica si se ha producido algún error */
+      hasError: () => a().error !== null,
+      /** Devuelve el error actual */
+      getError: () => a().error,
+      /** Limpia el error actual */
+      clearError: () => e(
+        z((t) => {
+          t.error = null;
+        })
+      ),
+      /**
+       * Activa o desactiva la actualización automática.
+       * Si se activa, programa la actualización para la próxima medianoche local.
+       */
+      setAutoRefresh: (t) => {
+        e({ autoRefresh: t }), t && a().scheduleAutoRefresh();
+      },
+      /**
+       * Programa una actualización automática de datos para la medianoche local
+       * en la zona horaria de los datos obtenidos, y vuelve a programarla
+       * cada vez que se llega a esa hora.
+       */
+      scheduleAutoRefresh: () => {
+        const { data: t, fetchParams: o } = a();
+        if (!t || !t.timezone || !o) return;
+        const u = (/* @__PURE__ */ new Date()).toLocaleString("es-ES", {
+          timeZone: t.timezone
+        }), r = new Date(u), s = new Date(r);
+        s.setHours(24, 0, 0, 0);
+        const i = s.getTime() - r.getTime();
+        setTimeout(async () => {
+          await a().fetchWeather(o), a().scheduleAutoRefresh();
+        }, i);
+      },
+      /** Devuelve todos los datos meteorológicos */
+      getAllWeatherData: () => a().data,
+      getCurrentDayWeather: () => {
+        var t;
+        return ((t = a().data) == null ? void 0 : t.currentDay) || null;
+      },
+      getPastDayWeather: () => {
+        var t;
+        return ((t = a().data) == null ? void 0 : t.pastDay) || null;
+      },
+      getForecastWeather: () => {
+        var t;
+        return ((t = a().data) == null ? void 0 : t.forecast) || null;
+      },
+      /**
+       * Devuelve los datos meteorológicos de la hora actual.
+       * Busca la hora local actual en el array de horas del día.
+       */
+      getCurrentHourWeather() {
+        var i, d;
+        const { data: t } = a();
+        if (!t) return null;
+        const o = t.timezone, u = (/* @__PURE__ */ new Date()).toLocaleString("en", {
+          timeZone: o
+        }), r = new Date(u);
+        return ((d = (i = t.currentDay) == null ? void 0 : i.hourly) == null ? void 0 : d.find((m) => m.hour ? new Date(m.hour.value).getHours() === r.getHours() : null)) || null;
+      }
+    }),
+    {
+      name: "weather-store",
+      partialize: (e) => ({
+        data: e.data,
+        fetchParams: e.fetchParams,
+        lastFetchTime: e.lastFetchTime,
+        autoRefresh: e.autoRefresh
+      })
+    }
+  )
+), _e = () => {
+  const e = de(), a = B(
+    async (o) => {
+      await e.fetchWeather(o);
+    },
+    [e.fetchWeather]
+  );
+  return q(() => {
+    e.autoRefresh && e.fetchParams && e.scheduleAutoRefresh();
+  }, [e.autoRefresh, e.fetchParams]), {
+    ...Q(
+      () => {
+        var o, u, r;
+        return {
+          // Datos meteorológicos principales
+          data: e.data,
+          currentDay: ((o = e.data) == null ? void 0 : o.currentDay) || null,
+          pastDays: ((u = e.data) == null ? void 0 : u.pastDay) || null,
+          forecast: ((r = e.data) == null ? void 0 : r.forecast) || null,
+          currentHour: e.getCurrentHourWeather(),
+          // Estado
+          isLoading: e.loading,
+          error: e.error
+        };
+      },
+      [e.data, e.loading, e.error]
+    ),
+    /** Acción para solicitar datos meteorológicos */
+    fetchWeather: a,
+    /** Activa o desactiva la actualización automática */
+    setAutoRefresh: e.setAutoRefresh,
+    /** Limpia el error actual */
+    clearError: e.clearError
+  };
+};
+export {
+  se as fetchWeather,
+  _e as useWeather,
+  de as useWeatherStore
+};

package/dist/services/adapters/OpenMeteoAdapter.d.ts

@@ -0,0 +1,10 @@
+import { WeatherData } from "../../types/apiTypes";
+import { StructureWeatherData } from "../../types/weatherTypes";
+export interface IWeatherAdapter {
+    adapt(raw: WeatherData, pastDays: number, forecastDays: number): StructureWeatherData;
+}
+export declare class OpenMeteoAdapter implements IWeatherAdapter {
+    adapt(raw: WeatherData, pastDays: number, forecastDays: number): StructureWeatherData;
+    private processWeatherData;
+    private getHourlyData;
+}

package/dist/services/api/OpenMeteoClient.d.ts

@@ -0,0 +1,9 @@
+import { FetchWeatherProps, FetchError } from "../../types/weatherTypes";
+import { WeatherData } from "../../types/apiTypes";
+export interface IWeatherApiClient {
+    fetchRaw(params: FetchWeatherProps): Promise<WeatherData | FetchError>;
+}
+export declare class OpenMeteoClient implements IWeatherApiClient {
+    fetchRaw({ latitude, longitude, hourly, daily, timezone, past_days, forecast_days, }: FetchWeatherProps): Promise<WeatherData | FetchError>;
+    private buildError;
+}

package/dist/services/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./weatherService";
+export * from "./api/OpenMeteoClient";
+export * from "./adapters/OpenMeteoAdapter";