weather.ts 1.0.0

package/dist/index.js

@@ -0,0 +1,401 @@
+// src/core/errors.ts
+var OpenMeteoError = class extends Error {
+  constructor(message, status, url, reason) {
+    super(message);
+    this.message = message;
+    this.status = status;
+    this.url = url;
+    this.reason = reason;
+    this.name = "OpenMeteoError";
+  }
+};
+
+// src/core/config.ts
+var globalConfig = {
+  userAgent: "weather.ts/1.0.0",
+  retries: 3
+};
+function setConfig(config) {
+  globalConfig = { ...globalConfig, ...config };
+}
+function getConfig() {
+  return globalConfig;
+}
+
+// src/helpers/transformers.ts
+function groupTimeSeries(data) {
+  if (!data || !Array.isArray(data.time)) {
+    return [];
+  }
+  const times = data.time;
+  const keys = Object.keys(data).filter(
+    (key) => key !== "time" && !key.endsWith("_units") && Array.isArray(data[key])
+  );
+  return times.map((time, index) => {
+    const entry = { time };
+    for (const key of keys) {
+      if (data[key].length > index) {
+        entry[key] = data[key][index];
+      } else {
+        entry[key] = null;
+      }
+    }
+    return entry;
+  });
+}
+function formatDate(date) {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+// src/helpers/params.ts
+function sanitizeParams(params) {
+  const sanitized = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (value instanceof Date) {
+      sanitized[key] = formatDate(value);
+    } else if (Array.isArray(value)) {
+      sanitized[key] = value.map((v) => v instanceof Date ? formatDate(v) : String(v)).join(",");
+    } else {
+      sanitized[key] = String(value);
+    }
+  }
+  return sanitized;
+}
+
+// src/core/fetcher.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function openMeteoFetch(url, options = {}) {
+  const globalConfig2 = getConfig();
+  const {
+    params,
+    userAgent = globalConfig2.userAgent,
+    retries = globalConfig2.retries,
+    ...init
+  } = options;
+  const sanitizedParams = params ? sanitizeParams(params) : {};
+  const searchParams = new URLSearchParams(sanitizedParams);
+  const queryString = searchParams.toString();
+  const finalUrl = queryString ? `${url}?${queryString}` : url;
+  const headers = new Headers(init.headers);
+  const isBrowser = typeof window !== "undefined";
+  if (userAgent && !isBrowser) {
+    headers.set("User-Agent", userAgent);
+  }
+  let lastError;
+  const maxAttempts = retries || 0;
+  for (let attempt = 0; attempt <= maxAttempts; attempt++) {
+    try {
+      const response = await fetch(finalUrl, { ...init, headers });
+      if (response.ok) {
+        return await response.json();
+      }
+      const status = response.status;
+      let reason;
+      const contentType = response.headers.get("content-type");
+      try {
+        if (contentType && contentType.includes("application/json")) {
+          const errorData = await response.json();
+          reason = errorData.reason || errorData.message;
+        } else {
+          reason = await response.text();
+          if (reason && reason.length > 200) {
+            reason = reason.substring(0, 200) + "...";
+          }
+        }
+      } catch {
+      }
+      const error = new OpenMeteoError(
+        `Open-Meteo API Error: ${status}${reason ? ` - ${reason}` : ""}`,
+        status,
+        finalUrl,
+        reason
+      );
+      if (attempt < maxAttempts && (status === 429 || status >= 500)) {
+        const backoff = Math.pow(2, attempt) * 500;
+        await sleep(backoff);
+        continue;
+      }
+      throw error;
+    } catch (err) {
+      if (err instanceof OpenMeteoError) throw err;
+      lastError = err;
+      if (attempt < maxAttempts) {
+        const backoff = Math.pow(2, attempt) * 500;
+        await sleep(backoff);
+        continue;
+      }
+    }
+  }
+  throw new OpenMeteoError(
+    `Network error or max retries reached: ${lastError?.message || "Unknown error"}`,
+    void 0,
+    finalUrl
+  );
+}
+
+// src/helpers/module-factory.ts
+function createModule(baseUrl) {
+  return async (params, options = {}) => {
+    return openMeteoFetch(baseUrl, { ...options, params });
+  };
+}
+
+// src/modules/forecast/index.ts
+var forecast = createModule(
+  "https://api.open-meteo.com/v1/forecast"
+);
+
+// src/modules/air-quality/index.ts
+var airQuality = createModule(
+  "https://air-quality-api.open-meteo.com/v1/air-quality"
+);
+
+// src/modules/geocoding/index.ts
+var geocodingSearch = createModule("https://geocoding-api.open-meteo.com/v1/search");
+var geocodingGet = createModule("https://geocoding-api.open-meteo.com/v1/get");
+
+// src/modules/historical/index.ts
+var historical = createModule(
+  "https://archive-api.open-meteo.com/v1/archive"
+);
+
+// src/modules/elevation/index.ts
+var elevation = createModule(
+  "https://api.open-meteo.com/v1/elevation"
+);
+
+// src/modules/marine/index.ts
+var marine = createModule(
+  "https://marine-api.open-meteo.com/v1/marine"
+);
+
+// src/modules/flood/index.ts
+var flood = createModule(
+  "https://flood-api.open-meteo.com/v1/flood"
+);
+
+// src/modules/ensemble/index.ts
+var ensemble = createModule(
+  "https://ensemble-api.open-meteo.com/v1/ensemble"
+);
+
+// src/modules/climate/index.ts
+var climate = createModule(
+  "https://climate-api.open-meteo.com/v1/climate"
+);
+
+// src/modules/seasonal/index.ts
+var seasonal = createModule(
+  "https://seasonal-api.open-meteo.com/v1/seasonal"
+);
+
+// src/core/client.ts
+var OpenMeteoClient = class {
+  constructor(config = {}) {
+    this.config = {
+      userAgent: "weather.ts/1.0.0",
+      retries: 3,
+      ...config
+    };
+  }
+  getOptions(options = {}) {
+    return {
+      userAgent: this.config.userAgent,
+      retries: this.config.retries,
+      ...options
+    };
+  }
+  async forecast(params, options) {
+    return forecast(params, this.getOptions(options));
+  }
+  async airQuality(params, options) {
+    return airQuality(params, this.getOptions(options));
+  }
+  async geocodingSearch(params, options) {
+    return geocodingSearch(params, this.getOptions(options));
+  }
+  async geocodingGet(params, options) {
+    return geocodingGet(params, this.getOptions(options));
+  }
+  async historical(params, options) {
+    return historical(params, this.getOptions(options));
+  }
+  async elevation(params, options) {
+    return elevation(params, this.getOptions(options));
+  }
+  async marine(params, options) {
+    return marine(params, this.getOptions(options));
+  }
+  async flood(params, options) {
+    return flood(params, this.getOptions(options));
+  }
+  async ensemble(params, options) {
+    return ensemble(params, this.getOptions(options));
+  }
+  async climate(params, options) {
+    return climate(params, this.getOptions(options));
+  }
+  async seasonal(params, options) {
+    return seasonal(params, this.getOptions(options));
+  }
+};
+
+// src/helpers/wmoCode.ts
+function translateWmoCode(code) {
+  switch (code) {
+    case 0:
+      return "Clear sky";
+    case 1:
+      return "Mainly clear";
+    case 2:
+      return "Partly cloudy";
+    case 3:
+      return "Overcast";
+    case 45:
+      return "Fog";
+    case 48:
+      return "Depositing rime fog";
+    case 51:
+      return "Light drizzle";
+    case 53:
+      return "Moderate drizzle";
+    case 55:
+      return "Dense drizzle";
+    case 56:
+      return "Light freezing drizzle";
+    case 57:
+      return "Dense freezing drizzle";
+    case 61:
+      return "Slight rain";
+    case 63:
+      return "Moderate rain";
+    case 65:
+      return "Heavy rain";
+    case 66:
+      return "Light freezing rain";
+    case 67:
+      return "Heavy freezing rain";
+    case 71:
+      return "Slight snow fall";
+    case 73:
+      return "Moderate snow fall";
+    case 75:
+      return "Heavy snow fall";
+    case 77:
+      return "Snow grains";
+    case 80:
+      return "Slight rain showers";
+    case 81:
+      return "Moderate rain showers";
+    case 82:
+      return "Violent rain showers";
+    case 85:
+      return "Slight snow showers";
+    case 86:
+      return "Heavy snow showers";
+    case 95:
+      return "Thunderstorm";
+    case 96:
+      return "Thunderstorm with slight hail";
+    case 99:
+      return "Thunderstorm with heavy hail";
+    default:
+      return "Unknown";
+  }
+}
+function getWmoCodeIdentifier(code) {
+  switch (code) {
+    case 0:
+      return "sunny";
+    case 1:
+    case 2:
+      return "partlyCloudy";
+    case 3:
+      return "cloudy";
+    case 45:
+    case 48:
+      return "fog";
+    case 51:
+    case 53:
+    case 55:
+    case 56:
+    case 57:
+      return "drizzle";
+    case 61:
+    case 63:
+    case 65:
+    case 66:
+    case 67:
+    case 80:
+    case 81:
+    case 82:
+      return "rainy";
+    case 71:
+    case 73:
+    case 75:
+    case 77:
+    case 85:
+    case 86:
+      return "snowy";
+    case 95:
+    case 96:
+    case 99:
+      return "thunderstorm";
+    default:
+      return "unknown";
+  }
+}
+
+// src/helpers/enrichers.ts
+var WMO_CODE_KEYS = [
+  "weathercode",
+  "weather_code",
+  "daily_weather_code",
+  "hourly_weather_code"
+];
+function enrichWmoCodes(data) {
+  const enriched = { ...data };
+  for (const key of Object.keys(data)) {
+    if (WMO_CODE_KEYS.includes(key) && Array.isArray(data[key])) {
+      enriched[`${key}_description`] = data[key].map(
+        (code) => translateWmoCode(code)
+      );
+      enriched[`${key}_identifier`] = data[key].map(
+        (code) => getWmoCodeIdentifier(code)
+      );
+    } else if (WMO_CODE_KEYS.includes(key) && typeof data[key] === "number") {
+      enriched[`${key}_description`] = translateWmoCode(data[key]);
+      enriched[`${key}_identifier`] = getWmoCodeIdentifier(data[key]);
+    }
+  }
+  return enriched;
+}
+export {
+  OpenMeteoClient,
+  OpenMeteoError,
+  airQuality,
+  climate,
+  elevation,
+  enrichWmoCodes,
+  ensemble,
+  flood,
+  forecast,
+  formatDate,
+  geocodingGet,
+  geocodingSearch,
+  getConfig,
+  getWmoCodeIdentifier,
+  groupTimeSeries,
+  historical,
+  marine,
+  openMeteoFetch,
+  seasonal,
+  setConfig,
+  translateWmoCode
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "weather.ts",
+  "version": "1.0.0",
+  "description": "The perfectest library for weather.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsup src/index.ts --watch",
+    "build": "tsup src/index.ts --format esm --dts",
+    "format": "prettier --write .",
+    "prepublishOnly": "npm run format && npm run build"
+  },
+  "keywords": [
+    "meteo",
+    "weather",
+    "wrapper",
+    "api",
+    "open-meteo"
+  ],
+  "author": "adouche-js",
+  "license": "LGPL-3.0-or-later",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "prettier": "^3.8.3",
+    "tsup": "^8.5.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}