@fifthbell/brokaw 0.1.39

package/dist/components/live-program/events.js

@@ -0,0 +1,167 @@
+const SUPPORTED_LANGUAGE_SET = new Set(['en', 'es', 'it']);
+const eventCacheByKey = new Map();
+let activeCacheKey = '__default__';
+function normalizeLanguageToken(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim().toLowerCase();
+    if (!trimmed) {
+        return null;
+    }
+    const normalized = trimmed.split('-')[0];
+    if (!SUPPORTED_LANGUAGE_SET.has(normalized)) {
+        return null;
+    }
+    return normalized;
+}
+function normalizeAllowedLanguages(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const deduped = new Set();
+    for (const item of value) {
+        const normalized = normalizeLanguageToken(item);
+        if (normalized) {
+            deduped.add(normalized);
+        }
+    }
+    return [...deduped];
+}
+function getEventLanguage(event) {
+    const eventRecord = event;
+    const direct = normalizeLanguageToken(eventRecord.language) ?? normalizeLanguageToken(eventRecord.lang) ?? normalizeLanguageToken(eventRecord.locale);
+    if (direct) {
+        return direct;
+    }
+    for (const post of event.posts || []) {
+        const postRecord = post;
+        const postLanguage = normalizeLanguageToken(postRecord.language) ?? normalizeLanguageToken(postRecord.lang) ?? normalizeLanguageToken(postRecord.locale);
+        if (postLanguage) {
+            return postLanguage;
+        }
+    }
+    return null;
+}
+function filterEventsByLanguage(events, allowedLanguages) {
+    if (allowedLanguages.length === 0) {
+        return events;
+    }
+    const allowed = new Set(allowedLanguages);
+    return events.filter((event) => {
+        const eventLanguage = getEventLanguage(event);
+        if (!eventLanguage) {
+            return true;
+        }
+        return allowed.has(eventLanguage);
+    });
+}
+function buildCacheKey(language, allowedLanguages) {
+    const languagePart = language ?? 'any';
+    const allowedPart = allowedLanguages.length > 0 ? [...allowedLanguages].sort().join(',') : 'all';
+    return `${languagePart}__${allowedPart}`;
+}
+export async function fetchEvents(options = {}) {
+    const allowedLanguages = normalizeAllowedLanguages(options.allowedLanguages);
+    const preferredLanguage = normalizeLanguageToken(options.language);
+    const cacheKey = buildCacheKey(preferredLanguage ?? undefined, allowedLanguages);
+    const eventsApiUrl = new URL('https://api.monitor.gaulatti.com/events');
+    if (preferredLanguage) {
+        eventsApiUrl.searchParams.set('language', preferredLanguage);
+    }
+    const response = await fetch(eventsApiUrl.toString());
+    if (!response.ok) {
+        throw new Error(`Failed to fetch events: ${response.status}`);
+    }
+    const data = await response.json();
+    const newEvents = filterEventsByLanguage(data.events || [], allowedLanguages);
+    const previousCacheEntry = eventCacheByKey.get(cacheKey);
+    const previousEvents = previousCacheEntry?.events ?? null;
+    let nextEvents;
+    if (previousEvents && previousEvents.length > 0) {
+        const eventMap = new Map();
+        previousEvents.forEach((event) => {
+            eventMap.set(event.uuid, event);
+        });
+        newEvents.forEach((newEvent) => {
+            const existingEvent = eventMap.get(newEvent.uuid);
+            if (!existingEvent) {
+                eventMap.set(newEvent.uuid, newEvent);
+                return;
+            }
+            const postMap = new Map();
+            existingEvent.posts.forEach((post) => {
+                postMap.set(post.uuid, post);
+            });
+            newEvent.posts.forEach((post) => {
+                postMap.set(post.uuid, post);
+            });
+            eventMap.set(newEvent.uuid, {
+                ...existingEvent,
+                title: newEvent.title,
+                summary: newEvent.summary,
+                status: newEvent.status,
+                updated_at: newEvent.updated_at,
+                posts_count: newEvent.posts_count,
+                posts: Array.from(postMap.values()).sort((a, b) => b.relevance - a.relevance)
+            });
+        });
+        nextEvents = Array.from(eventMap.values()).sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
+    }
+    else {
+        nextEvents = newEvents;
+    }
+    const nextFetchTime = new Date();
+    eventCacheByKey.set(cacheKey, {
+        events: nextEvents,
+        lastFetchTime: nextFetchTime
+    });
+    activeCacheKey = cacheKey;
+    return nextEvents;
+}
+export function getCachedEvents() {
+    return eventCacheByKey.get(activeCacheKey)?.events ?? null;
+}
+export function getLastFetchTime() {
+    return eventCacheByKey.get(activeCacheKey)?.lastFetchTime ?? null;
+}
+export function clearCachedEvents() {
+    eventCacheByKey.clear();
+    activeCacheKey = '__default__';
+}
+export function hasEventChanges(oldEvents, newEvents) {
+    if (oldEvents.length !== newEvents.length) {
+        return true;
+    }
+    const oldMap = new Map(oldEvents.map((event) => [event.uuid, event]));
+    const newMap = new Map(newEvents.map((event) => [event.uuid, event]));
+    for (const uuid of newMap.keys()) {
+        if (!oldMap.has(uuid)) {
+            return true;
+        }
+    }
+    for (const uuid of oldMap.keys()) {
+        if (!newMap.has(uuid)) {
+            return true;
+        }
+    }
+    for (const [uuid, newEvent] of newMap.entries()) {
+        const oldEvent = oldMap.get(uuid);
+        if (!oldEvent) {
+            continue;
+        }
+        if (oldEvent.title !== newEvent.title ||
+            oldEvent.status !== newEvent.status ||
+            oldEvent.posts_count !== newEvent.posts_count ||
+            oldEvent.posts.length !== newEvent.posts.length) {
+            return true;
+        }
+        const oldPostMap = new Map(oldEvent.posts.map((post) => [post.uuid, post]));
+        for (const post of newEvent.posts) {
+            if (!oldPostMap.has(post.uuid)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

package/dist/components/live-program/hooks/useSSE.d.ts

@@ -0,0 +1,11 @@
+interface UseSSEOptions {
+    url: string;
+    onMessage?: (data: any) => void;
+    reconnectInterval?: number;
+    enabled?: boolean;
+}
+export declare function useSSE({ url, onMessage, reconnectInterval, enabled }: UseSSEOptions): {
+    isConnected: boolean;
+    error: Error | null;
+};
+export {};

package/dist/components/live-program/hooks/useSSE.js

@@ -0,0 +1,67 @@
+import { useEffect, useRef, useState } from 'react';
+export function useSSE({ url, onMessage, reconnectInterval = 3000, enabled = true }) {
+    const [isConnected, setIsConnected] = useState(false);
+    const [error, setError] = useState(null);
+    const onMessageRef = useRef(onMessage);
+    useEffect(() => {
+        onMessageRef.current = onMessage;
+    }, [onMessage]);
+    useEffect(() => {
+        if (!enabled) {
+            setIsConnected(false);
+            setError(null);
+            return;
+        }
+        let disposed = false;
+        let eventSource = null;
+        let reconnectTimer = null;
+        const connect = () => {
+            if (disposed) {
+                return;
+            }
+            try {
+                eventSource = new EventSource(url);
+                eventSource.onopen = () => {
+                    if (disposed) {
+                        return;
+                    }
+                    setIsConnected(true);
+                    setError(null);
+                };
+                eventSource.onmessage = (event) => {
+                    try {
+                        const data = JSON.parse(event.data);
+                        onMessageRef.current?.(data);
+                    }
+                    catch (err) {
+                        console.error('Failed to parse SSE data:', err);
+                    }
+                };
+                eventSource.onerror = () => {
+                    setIsConnected(false);
+                    setError(new Error('SSE connection error'));
+                    eventSource?.close();
+                    eventSource = null;
+                    if (!disposed) {
+                        reconnectTimer = window.setTimeout(connect, reconnectInterval);
+                    }
+                };
+            }
+            catch (err) {
+                setError(err);
+                if (!disposed) {
+                    reconnectTimer = window.setTimeout(connect, reconnectInterval);
+                }
+            }
+        };
+        connect();
+        return () => {
+            disposed = true;
+            if (reconnectTimer !== null) {
+                window.clearTimeout(reconnectTimer);
+            }
+            eventSource?.close();
+        };
+    }, [enabled, url, reconnectInterval]);
+    return { isConnected, error };
+}

package/dist/components/live-program/i18n.d.ts

@@ -0,0 +1,4 @@
+export type SupportedLanguage = 'en' | 'es' | 'it';
+export declare function t(key: string, language: SupportedLanguage, replacements?: Record<string, string | number>): string;
+export declare const LANGUAGE_ROTATION: SupportedLanguage[];
+export declare function getNextLanguageIndex(currentIndex: number): number;

package/dist/components/live-program/i18n.js

@@ -0,0 +1,290 @@
+const translations = {
+    'segment.articles': {
+        en: 'News Articles',
+        es: 'Artículos',
+        it: 'Articoli'
+    },
+    'segment.weather': {
+        en: 'Weather',
+        es: 'Clima',
+        it: 'Meteo'
+    },
+    'segment.earthquakes': {
+        en: 'Earthquakes',
+        es: 'Terremotos',
+        it: 'Terremoti'
+    },
+    'segment.markets': {
+        en: 'Markets',
+        es: 'Mercados',
+        it: 'Mercati'
+    },
+    'articles.noArticles': {
+        en: 'No articles available',
+        es: 'No hay artículos disponibles',
+        it: 'Nessun articolo disponibile'
+    },
+    'weather.header': {
+        en: 'WEATHER',
+        es: 'CLIMA',
+        it: 'METEO'
+    },
+    'weather.loading': {
+        en: 'Loading weather data...',
+        es: 'Cargando datos del clima...',
+        it: 'Caricamento dati meteo...'
+    },
+    'weather.high': {
+        en: 'High',
+        es: 'Máx',
+        it: 'Max'
+    },
+    'weather.low': {
+        en: 'Low',
+        es: 'Mín',
+        it: 'Min'
+    },
+    'earthquakes.header': {
+        en: 'RECENT EARTHQUAKES',
+        es: 'TERREMOTOS RECIENTES',
+        it: 'TERREMOTI RECENTI'
+    },
+    'earthquakes.subtitle': {
+        en: 'Last 24 Hours • Magnitude 4.5+',
+        es: 'Últimas 24 horas • Magnitud 4.5+',
+        it: 'Ultime 24 ore • Magnitudo 4.5+'
+    },
+    'earthquakes.noData': {
+        en: 'No significant earthquakes in the last 24 hours',
+        es: 'No hay terremotos significativos en las últimas 24 horas',
+        it: 'Nessun terremoto significativo nelle ultime 24 ore'
+    },
+    'earthquakes.loading': {
+        en: 'Loading earthquake data...',
+        es: 'Cargando datos de terremotos...',
+        it: 'Caricamento dati terremoti...'
+    },
+    'earthquakes.depth': {
+        en: 'km deep',
+        es: 'km de profundidad',
+        it: 'km di profondità'
+    },
+    'earthquakes.timeAgo.justNow': {
+        en: 'Just now',
+        es: 'Justo ahora',
+        it: 'Proprio ora'
+    },
+    'earthquakes.timeAgo.minuteAgo': {
+        en: '1 minute ago',
+        es: 'Hace 1 minuto',
+        it: '1 minuto fa'
+    },
+    'earthquakes.timeAgo.minutesAgo': {
+        en: '{count} minutes ago',
+        es: 'Hace {count} minutos',
+        it: '{count} minuti fa'
+    },
+    'earthquakes.timeAgo.hourAgo': {
+        en: '1 hour ago',
+        es: 'Hace 1 hora',
+        it: '1 ora fa'
+    },
+    'earthquakes.timeAgo.hoursAgo': {
+        en: '{count} hours ago',
+        es: 'Hace {count} horas',
+        it: '{count} ore fa'
+    },
+    'earthquakes.timeAgo.dayAgo': {
+        en: '1 day ago',
+        es: 'Hace 1 día',
+        it: '1 giorno fa'
+    },
+    'earthquakes.timeAgo.daysAgo': {
+        en: '{count} days ago',
+        es: 'Hace {count} días',
+        it: '{count} giorni fa'
+    },
+    'markets.header': {
+        en: 'MARKETS',
+        es: 'MERCADOS',
+        it: 'MERCATI'
+    },
+    'markets.subtitle': {
+        en: 'Most Traded',
+        es: 'Más Negociados',
+        it: 'Più Scambiati'
+    },
+    'markets.loading': {
+        en: 'Loading market data...',
+        es: 'Cargando datos del mercado...',
+        it: 'Caricamento dati di mercato...'
+    },
+    'markets.lastUpdate': {
+        en: 'Last update: {time}',
+        es: 'Última actualización: {time}',
+        it: 'Ultimo aggiornamento: {time}'
+    },
+    'city.NEW YORK': {
+        en: 'NEW YORK',
+        es: 'NUEVA YORK',
+        it: 'NEW YORK'
+    },
+    'city.LONDON': {
+        en: 'LONDON',
+        es: 'LONDRES',
+        it: 'LONDRA'
+    },
+    'city.TOKYO': {
+        en: 'TOKYO',
+        es: 'TOKIO',
+        it: 'TOKYO'
+    },
+    'city.SYDNEY': {
+        en: 'SYDNEY',
+        es: 'SÍDNEY',
+        it: 'SYDNEY'
+    },
+    'city.ROME': {
+        en: 'ROME',
+        es: 'ROMA',
+        it: 'ROMA'
+    },
+    'city.MADRID': {
+        en: 'MADRID',
+        es: 'MADRID',
+        it: 'MADRID'
+    },
+    'city.LIMA': {
+        en: 'LIMA',
+        es: 'LIMA',
+        it: 'LIMA'
+    },
+    'city.BERLIN': {
+        en: 'BERLIN',
+        es: 'BERLÍN',
+        it: 'BERLINO'
+    },
+    'city.LOS ANGELES': {
+        en: 'LOS ANGELES',
+        es: 'LOS ÁNGELES',
+        it: 'LOS ANGELES'
+    },
+    'city.MEXICO CITY': {
+        en: 'MEXICO CITY',
+        es: 'CIUDAD DE MÉXICO',
+        it: 'CITTÀ DEL MESSICO'
+    },
+    'city.SANTIAGO': {
+        en: 'SANTIAGO',
+        es: 'SANTIAGO',
+        it: 'SANTIAGO'
+    },
+    'city.BUENOS AIRES': {
+        en: 'BUENOS AIRES',
+        es: 'BUENOS AIRES',
+        it: 'BUENOS AIRES'
+    },
+    'city.SÃO PAULO': {
+        en: 'SÃO PAULO',
+        es: 'SÃO PAULO',
+        it: 'SAN PAOLO'
+    },
+    'city.HONOLULU': {
+        en: 'HONOLULU',
+        es: 'HONOLULU',
+        it: 'HONOLULU'
+    },
+    'city.BEIJING': {
+        en: 'BEIJING',
+        es: 'PEKÍN',
+        it: 'PECHINO'
+    },
+    'city.SINGAPORE': {
+        en: 'SINGAPORE',
+        es: 'SINGAPUR',
+        it: 'SINGAPORE'
+    },
+    'city.DELHI': {
+        en: 'DELHI',
+        es: 'DELHI',
+        it: 'DELHI'
+    },
+    'city.LAHORE': {
+        en: 'LAHORE',
+        es: 'LAHORE',
+        it: 'LAHORE'
+    },
+    'city.MOSCOW': {
+        en: 'MOSCOW',
+        es: 'MOSCÚ',
+        it: 'MOSCA'
+    },
+    'city.KYIV': {
+        en: 'KYIV',
+        es: 'KIEV',
+        it: 'KIEV'
+    },
+    'city.CAIRO': {
+        en: 'CAIRO',
+        es: 'EL CAIRO',
+        it: 'IL CAIRO'
+    },
+    'city.LAGOS': {
+        en: 'LAGOS',
+        es: 'LAGOS',
+        it: 'LAGOS'
+    },
+    'city.CAPE TOWN': {
+        en: 'CAPE TOWN',
+        es: 'CIUDAD DEL CABO',
+        it: 'CITTÀ DEL CAPO'
+    },
+    'city.NAIROBI': {
+        en: 'NAIROBI',
+        es: 'NAIROBI',
+        it: 'NAIROBI'
+    },
+    'city.CASABLANCA': {
+        en: 'CASABLANCA',
+        es: 'CASABLANCA',
+        it: 'CASABLANCA'
+    },
+    'region.North America': {
+        en: 'North America',
+        es: 'América del Norte',
+        it: 'Nord America'
+    },
+    'region.Europe': {
+        en: 'Europe',
+        es: 'Europa',
+        it: 'Europa'
+    },
+    'region.South America': {
+        en: 'South America',
+        es: 'América del Sur',
+        it: 'Sud America'
+    },
+    'region.Asia': {
+        en: 'Asia',
+        es: 'Asia',
+        it: 'Asia'
+    }
+};
+export function t(key, language, replacements) {
+    const translation = translations[key];
+    if (!translation) {
+        console.warn(`Translation missing for key: ${key}`);
+        return key;
+    }
+    let text = translation[language] || translation.en || key;
+    if (replacements) {
+        Object.entries(replacements).forEach(([placeholder, value]) => {
+            text = text.replace(`{${placeholder}}`, String(value));
+        });
+    }
+    return text;
+}
+export const LANGUAGE_ROTATION = ['en', 'es', 'en', 'it'];
+export function getNextLanguageIndex(currentIndex) {
+    return (currentIndex + 1) % LANGUAGE_ROTATION.length;
+}

package/dist/components/live-program/segments/ArticlesSegment.d.ts

@@ -0,0 +1,6 @@
+import { type NewsItem } from '../components/slides/ArticleSlide.js';
+import type { Segment } from './types.js';
+import { type SupportedLanguage } from '../i18n.js';
+export declare function fetchArticles(language?: SupportedLanguage): Promise<NewsItem[]>;
+export declare function createArticlesSegment(articles: NewsItem[], onDataUpdate?: (nextArticles: NewsItem[]) => void, language?: SupportedLanguage): Segment;
+export type { NewsItem };