@gaulatti/giorgia 0.1.57

package/dist/components/live-program/segments/fetchLiveEvents.js

@@ -0,0 +1,76 @@
+function extractUpdatesFromAuburnaleEvent(updates) {
+    if (!updates || updates.length === 0)
+        return [];
+    return updates.map((u) => {
+        let text = '';
+        try {
+            const parsed = typeof u.content === 'string' ? JSON.parse(u.content) : u.content;
+            text = parsed?.root?.children?.[0]?.children?.[0]?.text || '';
+        }
+        catch {
+            text = String(u.content || '');
+        }
+        return {
+            timestamp: u.timestamp,
+            text: text || 'Update available',
+        };
+    });
+}
+async function fetchFromAuburnale(language) {
+    const baseUrl = typeof window !== 'undefined' ? `http://${window.location.hostname}:3000` : 'http://127.0.0.1:3000';
+    try {
+        const res = await fetch(`${baseUrl}/events?status=published&limit=1&sort=-eventDate&language=${language}`, {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (!res.ok)
+            return null;
+        const body = await res.json();
+        const items = body.data || [];
+        const event = items.find((e) => typeof e.sofascore_id === 'number' && e.sofascore_id > 0);
+        if (!event)
+            return null;
+        return {
+            category: event.categories?.[0]?.name || 'EVENT',
+            title: event.title,
+            excerpt: '',
+            image: event.featuredImage?.url || '',
+            alt: event.featuredImage?.alt || event.title,
+            url: `/${event.slug}`,
+            sofascore_id: event.sofascore_id,
+            updatedAt: event.eventDate || new Date().toISOString(),
+            updates: extractUpdatesFromAuburnaleEvent(event.updates),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function fetchLiveEvent(language = 'en') {
+    try {
+        const response = await fetch(`https://cdn.fifthbell.com/content/homepage-current-${language}.json?_=${Date.now()}`, { cache: 'no-store' });
+        if (!response.ok) {
+            return fetchFromAuburnale(language);
+        }
+        const data = await response.json();
+        const main = data.breakingNews?.main;
+        if (!main || !main.title) {
+            return fetchFromAuburnale(language);
+        }
+        return {
+            category: main.category || 'LIVE',
+            title: main.title,
+            excerpt: main.excerpt,
+            image: main.image || '',
+            alt: main.alt || main.title,
+            url: main.url || '/',
+            liveUrl: main.liveUrl,
+            sofascore_id: main.sofascore_id,
+            updatedAt: data.updatedAt || new Date().toISOString(),
+            updates: data.breakingNews?.updates || [],
+        };
+    }
+    catch (error) {
+        console.error('Error fetching live event:', error);
+        return fetchFromAuburnale(language);
+    }
+}

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

@@ -0,0 +1,8 @@
+export * from './types.js';
+export * from './usePlaylistEngine.js';
+export { createArticlesSegment, fetchArticles, type NewsItem } from './ArticlesSegment.js';
+export { createWeatherSegment, fetchWeatherData, type WeatherRegionData, type WeatherCityData } from './WeatherSegment.js';
+export { createEarthquakeSegment, fetchEarthquakes, type EarthquakeData } from './EarthquakeSegment.js';
+export * from './MarketsSegment.js';
+export { createLiveEventSegment } from './LiveEventSegment.js';
+export { fetchLiveEvent, type LiveEventData, type LiveEventUpdate } from './fetchLiveEvents.js';

package/dist/components/live-program/segments/index.js

@@ -0,0 +1,8 @@
+export * from './types.js';
+export * from './usePlaylistEngine.js';
+export { createArticlesSegment, fetchArticles } from './ArticlesSegment.js';
+export { createWeatherSegment, fetchWeatherData } from './WeatherSegment.js';
+export { createEarthquakeSegment, fetchEarthquakes } from './EarthquakeSegment.js';
+export * from './MarketsSegment.js';
+export { createLiveEventSegment } from './LiveEventSegment.js';
+export { fetchLiveEvent } from './fetchLiveEvents.js';

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

@@ -0,0 +1,23 @@
+import type React from 'react';
+export interface Segment {
+    id: string;
+    label: string;
+    itemCount: number;
+    durationMsPerItem: number;
+    render(itemIndex: number, progress: number): React.ReactNode;
+    onEnter?(): void;
+    onExit?(): void;
+    prefetch?(): Promise<void>;
+}
+export interface PlaylistState {
+    currentSegmentIndex: number;
+    currentItemIndex: number;
+    progress: number;
+    isPaused: boolean;
+}
+export interface PlaylistConfig {
+    segments: Segment[];
+    defaultDurationMs?: number;
+    updateIntervalMs?: number;
+    onPlaylistLoop?: () => void;
+}

package/dist/components/live-program/segments/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,9 @@
+import type { PlaylistConfig, PlaylistState, Segment } from './types.js';
+export declare function usePlaylistEngine(config: PlaylistConfig): {
+    state: PlaylistState;
+    currentSegment: Segment | null;
+    pause: () => void;
+    resume: () => void;
+    reset: () => void;
+    advanceToNext: () => void;
+};

package/dist/components/live-program/segments/usePlaylistEngine.js

@@ -0,0 +1,108 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+const DEFAULT_DURATION_MS = 10000;
+const DEFAULT_UPDATE_INTERVAL_MS = 100;
+export function usePlaylistEngine(config) {
+    const { segments, defaultDurationMs = DEFAULT_DURATION_MS, updateIntervalMs = DEFAULT_UPDATE_INTERVAL_MS, onPlaylistLoop } = config;
+    const [state, setState] = useState({
+        currentSegmentIndex: 0,
+        currentItemIndex: 0,
+        progress: 0,
+        isPaused: false
+    });
+    const prevSegmentIndexRef = useRef(0);
+    const getCurrentSegment = useCallback(() => {
+        if (segments.length === 0)
+            return null;
+        return segments[state.currentSegmentIndex] || null;
+    }, [segments, state.currentSegmentIndex]);
+    const pause = useCallback(() => {
+        setState((prev) => ({ ...prev, isPaused: true }));
+    }, []);
+    const resume = useCallback(() => {
+        setState((prev) => ({ ...prev, isPaused: false }));
+    }, []);
+    const reset = useCallback(() => {
+        setState({
+            currentSegmentIndex: 0,
+            currentItemIndex: 0,
+            progress: 0,
+            isPaused: false
+        });
+    }, []);
+    const calculateNextState = useCallback((prevState) => {
+        const currentSegment = segments[prevState.currentSegmentIndex];
+        if (!currentSegment) {
+            return prevState;
+        }
+        const nextItemIndex = prevState.currentItemIndex + 1;
+        if (nextItemIndex >= currentSegment.itemCount) {
+            const nextSegmentIndex = (prevState.currentSegmentIndex + 1) % segments.length;
+            return {
+                ...prevState,
+                currentSegmentIndex: nextSegmentIndex,
+                currentItemIndex: 0,
+                progress: 0
+            };
+        }
+        return {
+            ...prevState,
+            currentItemIndex: nextItemIndex,
+            progress: 0
+        };
+    }, [segments]);
+    const advanceToNext = useCallback(() => {
+        setState((prevState) => calculateNextState(prevState));
+    }, [calculateNextState]);
+    useEffect(() => {
+        const currentSegmentIndex = state.currentSegmentIndex;
+        const previousSegmentIndex = prevSegmentIndexRef.current;
+        if (currentSegmentIndex !== previousSegmentIndex) {
+            const previousSegment = segments[previousSegmentIndex];
+            previousSegment?.onExit?.();
+            const currentSegment = segments[currentSegmentIndex];
+            currentSegment?.onEnter?.();
+            const nextSegmentIndex = (currentSegmentIndex + 1) % segments.length;
+            const nextSegment = segments[nextSegmentIndex];
+            nextSegment?.prefetch?.().catch((error) => {
+                console.error(`[Playlist] Failed to prefetch ${nextSegment.label}:`, error);
+            });
+            if (currentSegmentIndex === 0 &&
+                previousSegmentIndex === segments.length - 1 &&
+                segments.length > 0) {
+                onPlaylistLoop?.();
+            }
+            prevSegmentIndexRef.current = currentSegmentIndex;
+        }
+    }, [state.currentSegmentIndex, segments, onPlaylistLoop]);
+    useEffect(() => {
+        if (state.isPaused || segments.length === 0) {
+            return;
+        }
+        const currentSegment = segments[state.currentSegmentIndex];
+        if (!currentSegment) {
+            return;
+        }
+        const duration = currentSegment.durationMsPerItem || defaultDurationMs;
+        const progressIncrement = (updateIntervalMs / duration) * 100;
+        const timer = setInterval(() => {
+            setState((prevState) => {
+                if (prevState.progress >= 100) {
+                    return calculateNextState(prevState);
+                }
+                return {
+                    ...prevState,
+                    progress: prevState.progress + progressIncrement
+                };
+            });
+        }, updateIntervalMs);
+        return () => clearInterval(timer);
+    }, [state.isPaused, state.currentSegmentIndex, segments, defaultDurationMs, updateIntervalMs, calculateNextState]);
+    return {
+        state,
+        currentSegment: getCurrentSegment(),
+        pause,
+        resume,
+        reset,
+        advanceToNext
+    };
+}

package/dist/components/live-program/utils/broadcastTime.d.ts

@@ -0,0 +1,12 @@
+export interface GlobalTimeOverride {
+    startTime: string;
+    startedAt: string;
+}
+interface ClockParts {
+    hours: number;
+    minutes: number;
+    seconds: number;
+}
+export declare function getOverrideClockParts(override: GlobalTimeOverride, now?: Date): ClockParts | null;
+export declare function formatClockParts(parts: ClockParts): string;
+export {};

package/dist/components/live-program/utils/broadcastTime.js

@@ -0,0 +1,33 @@
+function parseStartTime(startTime) {
+    const match = /^([01]\d|2[0-3]):([0-5]\d)$/.exec(startTime.trim());
+    if (!match) {
+        return null;
+    }
+    return {
+        hours: Number(match[1]),
+        minutes: Number(match[2]),
+        seconds: 0,
+    };
+}
+export function getOverrideClockParts(override, now = new Date()) {
+    const parsed = parseStartTime(override.startTime);
+    if (!parsed) {
+        return null;
+    }
+    const startedAtMillis = new Date(override.startedAt).getTime();
+    if (!Number.isFinite(startedAtMillis)) {
+        return null;
+    }
+    const startSeconds = parsed.hours * 3600 + parsed.minutes * 60;
+    const elapsedSeconds = Math.max(0, Math.floor((now.getTime() - startedAtMillis) / 1000));
+    const totalSeconds = (startSeconds + elapsedSeconds) % 86400;
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    return { hours, minutes, seconds };
+}
+export function formatClockParts(parts) {
+    const hours = String(parts.hours).padStart(2, '0');
+    const minutes = String(parts.minutes).padStart(2, '0');
+    return `${hours}:${minutes}`;
+}