@screenly/edge-apps 0.0.1 → 0.0.3

package/dist/utils/weather.js

@@ -0,0 +1,272 @@
+/**
+ * Weather Utilities
+ * Functions for weather icon mapping and related utilities
+ */
+import { getSetting } from './settings.js';
+import { getMetadata } from './metadata.js';
+// Import weather icons
+import clearIcon from '../assets/images/icons/clear.svg';
+import clearNightIcon from '../assets/images/icons/clear-night.svg';
+import cloudyIcon from '../assets/images/icons/cloudy.svg';
+import drizzleIcon from '../assets/images/icons/drizzle.svg';
+import fewdropsIcon from '../assets/images/icons/fewdrops.svg';
+import fogIcon from '../assets/images/icons/fog.svg';
+import hazeIcon from '../assets/images/icons/haze.svg';
+import mostlyCloudyIcon from '../assets/images/icons/mostly-cloudy.svg';
+import mostlyCloudyNightIcon from '../assets/images/icons/mostly-cloudy-night.svg';
+import partiallyCloudyIcon from '../assets/images/icons/partially-cloudy.svg';
+import partiallyCloudyNightIcon from '../assets/images/icons/partially-cloudy-night.svg';
+import partlySunnyIcon from '../assets/images/icons/partlysunny.svg';
+import rainyIcon from '../assets/images/icons/rainy.svg';
+import rainNightIcon from '../assets/images/icons/rain-night.svg';
+import sleetIcon from '../assets/images/icons/sleet.svg';
+import sleetNightIcon from '../assets/images/icons/sleet-night.svg';
+import snowIcon from '../assets/images/icons/snow.svg';
+import thunderstormIcon from '../assets/images/icons/thunderstorm.svg';
+import thunderstormNightIcon from '../assets/images/icons/thunderstorm-night.svg';
+import windyIcon from '../assets/images/icons/windy.svg';
+import chancesleetIcon from '../assets/images/icons/chancesleet.svg';
+// Weather icon mapping
+export const WEATHER_ICONS = {
+    clear: clearIcon,
+    'clear-night': clearNightIcon,
+    cloudy: cloudyIcon,
+    drizzle: drizzleIcon,
+    fewdrops: fewdropsIcon,
+    fog: fogIcon,
+    haze: hazeIcon,
+    'mostly-cloudy': mostlyCloudyIcon,
+    'mostly-cloudy-night': mostlyCloudyNightIcon,
+    'partially-cloudy': partiallyCloudyIcon,
+    'partially-cloudy-night': partiallyCloudyNightIcon,
+    partlysunny: partlySunnyIcon,
+    rain: rainyIcon,
+    rainy: rainyIcon,
+    'rain-night': rainNightIcon,
+    sleet: sleetIcon,
+    'sleet-night': sleetNightIcon,
+    snow: snowIcon,
+    thunderstorm: thunderstormIcon,
+    'thunderstorm-night': thunderstormNightIcon,
+    windy: windyIcon,
+    chancesleet: chancesleetIcon,
+};
+/**
+ * Check if a given timestamp is during nighttime (8 PM - 5 AM) in the specified timezone
+ */
+export function isNightForTimestamp(dt, timeZone) {
+    const hour = Number(new Intl.DateTimeFormat('en-US', {
+        hour: 'numeric',
+        hour12: false,
+        timeZone,
+    }).format(new Date(dt * 1000)));
+    return hour <= 5 || hour >= 20;
+}
+/**
+ * Get weather icon key based on OpenWeatherMap weather condition ID and time of day
+ * @param id - OpenWeatherMap weather condition ID (e.g., 800 for clear sky)
+ * @param dt - Unix timestamp in seconds
+ * @param timeZone - IANA timezone string (e.g., 'America/New_York')
+ * @returns Icon key string (e.g., 'clear', 'clear-night', 'rain', etc.)
+ */
+export function getWeatherIconKey(id, dt, timeZone) {
+    let icon = 'clear';
+    const isNight = isNightForTimestamp(dt, timeZone);
+    if (id >= 200 && id <= 299) {
+        icon = 'thunderstorm';
+    }
+    else if (id >= 300 && id <= 399) {
+        icon = 'drizzle';
+    }
+    else if (id >= 500 && id <= 599) {
+        icon = 'rain';
+    }
+    else if (id >= 600 && id <= 699) {
+        icon = 'snow';
+    }
+    else if (id >= 700 && id <= 799) {
+        icon = 'haze';
+    }
+    else if (id === 800) {
+        icon = 'clear';
+    }
+    else if (id === 801) {
+        icon = 'partially-cloudy';
+    }
+    else if (id >= 802 && id <= 804) {
+        icon = 'mostly-cloudy';
+    }
+    const nightOverrides = {
+        clear: 'clear-night',
+        rain: 'rain-night',
+        'mostly-cloudy': 'mostly-cloudy-night',
+        'partially-cloudy': 'partially-cloudy-night',
+        thunderstorm: 'thunderstorm-night',
+        sleet: 'sleet-night',
+    };
+    return isNight && nightOverrides[icon] ? nightOverrides[icon] : icon;
+}
+/**
+ * Get the full URL path for a weather icon
+ * @param iconKey - Icon key from getWeatherIconKey (e.g., 'clear', 'rain-night')
+ * @param iconBase - Base path for weather icons (default: '/assets/images/icons')
+ * @returns Full URL path to the icon SVG file
+ */
+export function getWeatherIconUrl(iconKey, iconBase = '/assets/images/icons') {
+    const iconMap = {
+        chancesleet: `${iconBase}/chancesleet.svg`,
+        'clear-night': `${iconBase}/clear-night.svg`,
+        clear: `${iconBase}/clear.svg`,
+        cloudy: `${iconBase}/cloudy.svg`,
+        drizzle: `${iconBase}/drizzle.svg`,
+        fewdrops: `${iconBase}/fewdrops.svg`,
+        fog: `${iconBase}/fog.svg`,
+        haze: `${iconBase}/haze.svg`,
+        'mostly-cloudy-night': `${iconBase}/mostly-cloudy-night.svg`,
+        'mostly-cloudy': `${iconBase}/mostly-cloudy.svg`,
+        'partially-cloudy-night': `${iconBase}/partially-cloudy-night.svg`,
+        'partially-cloudy': `${iconBase}/partially-cloudy.svg`,
+        partlysunny: `${iconBase}/partlysunny.svg`,
+        'rain-night': `${iconBase}/rain-night.svg`,
+        rain: `${iconBase}/rainy.svg`,
+        'sleet-night': `${iconBase}/sleet-night.svg`,
+        sleet: `${iconBase}/sleet.svg`,
+        snow: `${iconBase}/snow.svg`,
+        thunderstorm: `${iconBase}/thunderstorm.svg`,
+        'thunderstorm-night': `${iconBase}/thunderstorm-night.svg`,
+        windy: `${iconBase}/windy.svg`,
+    };
+    return iconMap[iconKey] || iconMap.clear;
+}
+/**
+ * Get weather icon source (imported SVG) based on weather condition ID and time
+ * @param weatherId - OpenWeatherMap weather condition ID (e.g., 800 for clear sky)
+ * @param dt - Unix timestamp in seconds
+ * @param timeZone - IANA timezone string (e.g., 'America/New_York')
+ * @returns Icon source string (Vite-imported SVG path)
+ */
+export function getWeatherIcon(weatherId, dt, timeZone) {
+    const iconKey = getWeatherIconKey(weatherId, dt, timeZone);
+    return WEATHER_ICONS[iconKey] || WEATHER_ICONS['clear'];
+}
+// --- Shared weather data utilities ---
+/**
+ * Validate OpenWeatherMap API response
+ * Note: `cod` can be number (200) or string ("200") depending on the endpoint
+ */
+export function isValidWeatherResponse(data) {
+    const temp = data.main?.temp;
+    return ((data.cod === 200 || data.cod === '200') &&
+        typeof temp === 'number' &&
+        Number.isFinite(temp));
+}
+/**
+ * Fetch current weather data from OpenWeatherMap API
+ * Returns raw weather data that each app can map to its own interface
+ * @param lat - Latitude
+ * @param lng - Longitude
+ * @param tz - Timezone
+ * @param unit - Measurement unit ('metric' or 'imperial')
+ */
+export async function fetchCurrentWeatherData(lat, lng, tz, unit = 'metric') {
+    try {
+        const apiKey = getSetting('openweathermap_api_key');
+        if (!apiKey) {
+            return null;
+        }
+        const response = await fetch(`https://api.openweathermap.org/data/2.5/weather?lat=${lat}&lon=${lng}&units=${unit}&appid=${apiKey}`);
+        if (!response.ok) {
+            console.warn('Failed to get weather data: OpenWeatherMap API responded with', response.status, response.statusText);
+            return null;
+        }
+        const data = await response.json();
+        if (!isValidWeatherResponse(data)) {
+            return null;
+        }
+        const temperature = Math.round(data.main.temp);
+        const tempHigh = typeof data.main.temp_max === 'number' &&
+            Number.isFinite(data.main.temp_max)
+            ? Math.round(data.main.temp_max)
+            : temperature;
+        const tempLow = typeof data.main.temp_min === 'number' &&
+            Number.isFinite(data.main.temp_min)
+            ? Math.round(data.main.temp_min)
+            : temperature;
+        const weatherId = data.weather?.[0]?.id ?? null;
+        if (!weatherId) {
+            return null;
+        }
+        const dt = Math.floor(Date.now() / 1000);
+        const description = data.weather?.[0]?.description || '';
+        const iconSrc = getWeatherIcon(weatherId, dt, tz);
+        const iconAlt = description || 'Weather icon';
+        return {
+            temperature,
+            tempHigh,
+            tempLow,
+            weatherId,
+            description,
+            iconSrc,
+            iconAlt,
+            unit,
+        };
+    }
+    catch (error) {
+        console.warn('Failed to get weather data:', error);
+        return null;
+    }
+}
+/**
+ * Get city information including name and country code from OpenWeatherMap reverse geocoding
+ * @param lat - Latitude
+ * @param lng - Longitude
+ * @returns Object containing cityName and countryCode
+ */
+export async function getCityInfo(lat, lng) {
+    try {
+        const apiKey = getSetting('openweathermap_api_key');
+        if (!apiKey) {
+            // Fallback to location from metadata if no API key
+            return {
+                cityName: getMetadata().location || 'Unknown Location',
+                countryCode: '',
+            };
+        }
+        const response = await fetch(`https://api.openweathermap.org/geo/1.0/reverse?lat=${lat}&lon=${lng}&limit=1&appid=${apiKey}`);
+        if (!response.ok) {
+            console.warn('Failed to get city info: OpenWeatherMap API responded with', response.status, response.statusText);
+            return {
+                cityName: getMetadata().location || 'Unknown Location',
+                countryCode: '',
+            };
+        }
+        const data = await response.json();
+        if (Array.isArray(data) && data.length > 0) {
+            const { name, country } = data[0];
+            if (name && country) {
+                return {
+                    cityName: `${name}, ${country}`,
+                    countryCode: country,
+                };
+            }
+        }
+    }
+    catch (error) {
+        console.warn('Failed to get city info:', error);
+    }
+    // Fallback to location from metadata
+    return {
+        cityName: getMetadata().location || 'Unknown Location',
+        countryCode: '',
+    };
+}
+/**
+ * Get city name from coordinates using OpenWeatherMap reverse geocoding
+ * @param lat - Latitude
+ * @param lng - Longitude
+ * @returns City name in format "City, Country" or fallback location
+ */
+export async function getCityName(lat, lng) {
+    const { cityName } = await getCityInfo(lat, lng);
+    return cityName;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@screenly/edge-apps",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "A TypeScript library for interfacing with Screenly Edge Apps API",
   "type": "module",
   "main": "./dist/index.js",
@@ -51,6 +51,7 @@
     "src/assets"
   ],
   "scripts": {
+    "prepublishOnly": "bun run build",
     "prebuild": "bun run type-check",
     "build": "bun build:types && bun run copy:assets",
     "build:types": "tsc",
@@ -76,13 +77,16 @@
   },
   "dependencies": {
     "@photostructure/tz-lookup": "^11.5.0",
-    "dayjs": "^1.11.19",
     "@tailwindcss/vite": "^4.2.1",
     "country-locale-map": "^1.9.12",
+    "dayjs": "^1.11.19",
+    "jiti": "^2.6.1",
     "offline-geocode-city": "^1.0.2",
     "panic-overlay": "^1.0.51",
     "sharp": "^0.34.5",
-    "tailwindcss": "^4.2.1"
+    "tailwindcss": "^4.2.1",
+    "vite": "^7.3.1",
+    "yaml": "^2.8.2"
   },
   "peerDependencies": {
     "@playwright/test": "^1.58.0"
@@ -100,12 +104,9 @@
     "@types/sharp": "^0.32.0",
     "bun-types": "^1.3.10",
     "eslint": "^10.0.3",
-    "jiti": "^2.6.1",
     "jsdom": "^28.1.0",
     "prettier": "^3.8.1",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.57.0",
-    "vite": "^7.3.1",
-    "yaml": "^2.8.2"
+    "typescript-eslint": "^8.57.0"
   }
 }