@devtravelcode/widget-native 1.0.0

package/dist/modules/hooks/useHotelSearchSSE.js

@@ -0,0 +1,411 @@
+import { useState, useRef, useCallback } from "react";
+import { useApiToken } from "../../utils/getToken";
+import { fetchSSE, mergeHotels } from "../../utils/fetchSSE";
+const STREAM_URL = "https://api.travel-code.com/v1/search/hotels/stream";
+const CURRENCY_SIGNS = {
+    USD: "$", EUR: "€", GBP: "£", RUB: "₽", TRY: "₺",
+    AED: "د.إ", SAR: "﷼", KZT: "₸", JPY: "¥", CNY: "¥",
+};
+function getCurrencySign(code) {
+    return CURRENCY_SIGNS[code?.toUpperCase()] || code || "$";
+}
+function normalizeHotel(hotel, currency) {
+    if (!hotel)
+        return hotel;
+    return {
+        ...hotel,
+        nightlyPrice: hotel.nightlyPrice ?? hotel.price ?? null,
+        totalPrice: hotel.totalPrice ?? hotel.total ?? null,
+        currencySign: hotel.currencySign || getCurrencySign(currency),
+        ratings: {
+            ...hotel.ratings,
+            star: hotel.ratings?.star ?? hotel.starRating ?? 0,
+        },
+    };
+}
+function normalizeBatch(hotels, currencySign) {
+    return hotels.map((h) => normalizeHotel(h, currencySign));
+}
+export function useHotelSearchSSE() {
+    const token = useApiToken();
+    const [offers, setOffers] = useState([]);
+    const [allHotels, setAllHotels] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [isStreaming, setIsStreaming] = useState(false);
+    const [isPageLoading, setIsPageLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [total, setTotal] = useState(0);
+    const [offset, setOffset] = useState(0);
+    const [limit, setLimit] = useState(20);
+    const [cacheKey, setCacheKey] = useState(null);
+    const [streamCompleted, setStreamCompleted] = useState(false);
+    const [searchParams, setSearchParams] = useState(null);
+    const abortRef = useRef(null);
+    const allHotelsRef = useRef([]);
+    const hotelMapRef = useRef(new Map());
+    const currencySignRef = useRef("$");
+    const cleanup = () => {
+        if (abortRef.current) {
+            abortRef.current.abort();
+            abortRef.current = null;
+        }
+    };
+    const startSearch = useCallback((params) => {
+        cleanup();
+        const controller = new AbortController();
+        abortRef.current = controller;
+        setLoading(true);
+        setIsStreaming(true);
+        setStreamCompleted(false);
+        setError(null);
+        setOffers([]);
+        setAllHotels([]);
+        allHotelsRef.current = [];
+        hotelMapRef.current = new Map();
+        setTotal(0);
+        setOffset(params.offset ?? 0);
+        setLimit(params.limit ?? 20);
+        setSearchParams(params);
+        setCacheKey(null);
+        setIsPageLoading(false);
+        currencySignRef.current = params.currencySign || params.currency || "$";
+        const pageLimit = params.limit || 20;
+        const cs = currencySignRef.current;
+        fetchSSE({
+            url: STREAM_URL,
+            body: params,
+            token,
+            signal: controller.signal,
+            onEvent: (event, data) => {
+                if (controller.signal.aborted)
+                    return;
+                if (event === "connected") {
+                    setLoading(false);
+                    return;
+                }
+                if (event === "count") {
+                    setLoading(false);
+                    try {
+                        const payload = JSON.parse(data);
+                        if (typeof payload.count === "number") {
+                            setTotal(payload.count);
+                        }
+                    }
+                    catch { }
+                    return;
+                }
+                if (event === "hotels") {
+                    setLoading(false);
+                    try {
+                        const payload = JSON.parse(data);
+                        const batch = Array.isArray(payload.hotels) ? payload.hotels : [];
+                        if (batch.length > 0) {
+                            const normalized = normalizeBatch(batch, cs);
+                            const result = mergeHotels(hotelMapRef.current, normalized);
+                            hotelMapRef.current = result.merged;
+                            const all = Array.from(result.merged.values());
+                            allHotelsRef.current = all;
+                            setAllHotels(all);
+                            setOffers(all.slice(0, pageLimit));
+                            setTotal(all.length);
+                        }
+                    }
+                    catch { }
+                    return;
+                }
+                if (event === "completed") {
+                    setStreamCompleted(true);
+                    try {
+                        const payload = JSON.parse(data);
+                        if (payload.cacheKey) {
+                            setCacheKey(payload.cacheKey);
+                        }
+                        const finalHotels = normalizeBatch(Array.isArray(payload.hotels) ? payload.hotels : [], cs);
+                        const accumulated = Array.from(hotelMapRef.current.values());
+                        if (finalHotels.length > 0) {
+                            setOffers(finalHotels);
+                        }
+                        else if (accumulated.length > 0) {
+                            setOffers(accumulated.slice(0, pageLimit));
+                        }
+                        let mapData;
+                        if (finalHotels.length > 0 && accumulated.length > finalHotels.length) {
+                            const finalMap = new Map(finalHotels.map((h) => [String(h.id), h]));
+                            mapData = accumulated.map((h) => finalMap.get(String(h.id)) || h);
+                        }
+                        else {
+                            mapData = finalHotels.length > 0 ? finalHotels : accumulated;
+                        }
+                        allHotelsRef.current = mapData;
+                        setAllHotels(mapData);
+                        const effectiveTotal = mapData.length === 0
+                            ? 0
+                            : typeof payload.count === "number"
+                                ? payload.count
+                                : mapData.length;
+                        setTotal(effectiveTotal);
+                    }
+                    catch {
+                        const result = Array.from(hotelMapRef.current.values());
+                        allHotelsRef.current = result;
+                        setAllHotels(result);
+                        setOffers(result.slice(0, pageLimit));
+                        setTotal(result.length);
+                    }
+                    return;
+                }
+                if (event === "error") {
+                    try {
+                        const payload = JSON.parse(data);
+                        setError(payload.message || "Search error");
+                    }
+                    catch {
+                        setError("Search error");
+                    }
+                    return;
+                }
+            },
+            onError: (err) => {
+                if (err.name !== "AbortError") {
+                    setError(err.message || "Search failed");
+                }
+            },
+            onComplete: () => {
+                if (abortRef.current === controller) {
+                    setLoading(false);
+                    setIsStreaming(false);
+                }
+            },
+        });
+    }, [token]);
+    const filterSearch = useCallback((params) => {
+        cleanup();
+        const controller = new AbortController();
+        abortRef.current = controller;
+        const timeoutId = setTimeout(() => controller.abort(), 30000);
+        setIsPageLoading(true);
+        setStreamCompleted(false);
+        setError(null);
+        setOffset(params.offset ?? 0);
+        setLimit(params.limit ?? 20);
+        setSearchParams(params);
+        setCacheKey(null);
+        hotelMapRef.current = new Map();
+        currencySignRef.current = params.currencySign || params.currency || currencySignRef.current;
+        const pageLimit = params.limit || 20;
+        const cs = currencySignRef.current;
+        let gotCompleted = false;
+        fetchSSE({
+            url: STREAM_URL,
+            body: params,
+            token,
+            signal: controller.signal,
+            onEvent: (event, data) => {
+                if (controller.signal.aborted)
+                    return;
+                if (event === "connected")
+                    return;
+                if (event === "count") {
+                    try {
+                        const payload = JSON.parse(data);
+                        if (typeof payload.count === "number") {
+                            setTotal(payload.count);
+                        }
+                    }
+                    catch { }
+                    return;
+                }
+                if (event === "hotels") {
+                    try {
+                        const payload = JSON.parse(data);
+                        const batch = Array.isArray(payload.hotels) ? payload.hotels : [];
+                        for (const hotel of batch) {
+                            const normalized = normalizeHotel(hotel, cs);
+                            hotelMapRef.current.set(String(normalized.id), normalized);
+                        }
+                    }
+                    catch { }
+                    return;
+                }
+                if (event === "completed") {
+                    gotCompleted = true;
+                    setStreamCompleted(true);
+                    try {
+                        const payload = JSON.parse(data);
+                        if (payload.cacheKey) {
+                            setCacheKey(payload.cacheKey);
+                        }
+                        const finalHotels = normalizeBatch(Array.isArray(payload.hotels) ? payload.hotels : [], cs);
+                        const accumulated = Array.from(hotelMapRef.current.values());
+                        if (finalHotels.length > 0) {
+                            setOffers(finalHotels);
+                        }
+                        else if (accumulated.length > 0) {
+                            setOffers(accumulated.slice(0, pageLimit));
+                        }
+                        else {
+                            setOffers([]);
+                        }
+                        let mapData;
+                        if (finalHotels.length > 0 && accumulated.length > finalHotels.length) {
+                            const finalMap = new Map(finalHotels.map((h) => [String(h.id), h]));
+                            mapData = accumulated.map((h) => finalMap.get(String(h.id)) || h);
+                        }
+                        else {
+                            mapData = finalHotels.length > 0 ? finalHotels : accumulated;
+                        }
+                        allHotelsRef.current = mapData;
+                        setAllHotels(mapData);
+                        const effectiveTotal = mapData.length === 0
+                            ? 0
+                            : typeof payload.count === "number"
+                                ? payload.count
+                                : mapData.length;
+                        setTotal(effectiveTotal);
+                    }
+                    catch {
+                        const result = Array.from(hotelMapRef.current.values());
+                        allHotelsRef.current = result;
+                        setAllHotels(result);
+                        setOffers(result.slice(0, pageLimit));
+                        setTotal(result.length);
+                    }
+                    setOffset(0);
+                    return;
+                }
+                if (event === "error") {
+                    try {
+                        const payload = JSON.parse(data);
+                        setError(payload.message || "Filter search error");
+                    }
+                    catch {
+                        setError("Filter search error");
+                    }
+                    return;
+                }
+            },
+            onError: (err) => {
+                if (err.name !== "AbortError") {
+                    setError(err.message || "Filter search failed");
+                    setOffers([]);
+                    setAllHotels([]);
+                    allHotelsRef.current = [];
+                    setTotal(0);
+                }
+                else if (allHotelsRef.current.length === 0) {
+                    setOffers([]);
+                    setAllHotels([]);
+                    setTotal(0);
+                }
+            },
+            onComplete: () => {
+                clearTimeout(timeoutId);
+                if (!gotCompleted) {
+                    const accumulated = Array.from(hotelMapRef.current.values());
+                    if (accumulated.length > 0) {
+                        allHotelsRef.current = accumulated;
+                        setAllHotels(accumulated);
+                        setOffers(accumulated.slice(0, pageLimit));
+                        setTotal(accumulated.length);
+                        setOffset(0);
+                    }
+                    else {
+                        setOffers([]);
+                        setAllHotels([]);
+                        allHotelsRef.current = [];
+                        setTotal(0);
+                    }
+                }
+                if (abortRef.current === controller) {
+                    setIsPageLoading(false);
+                }
+            },
+        });
+    }, [token]);
+    const fetchPage = useCallback((page) => {
+        const newOffset = (page - 1) * limit;
+        setOffset(newOffset);
+        if (streamCompleted && allHotelsRef.current.length > 0) {
+            const pageData = allHotelsRef.current.slice(newOffset, newOffset + limit);
+            setOffers(pageData);
+            return;
+        }
+        if (!searchParams)
+            return;
+        setIsPageLoading(true);
+        const controller = new AbortController();
+        fetchSSE({
+            url: STREAM_URL,
+            body: { ...searchParams, offset: newOffset, limit },
+            token,
+            signal: controller.signal,
+            onEvent: (event, data) => {
+                const cs = currencySignRef.current;
+                if (event === "completed") {
+                    try {
+                        const payload = JSON.parse(data);
+                        const hotels = normalizeBatch(Array.isArray(payload.hotels) ? payload.hotels : [], cs);
+                        setOffers(hotels);
+                        if (typeof payload.count === "number")
+                            setTotal(payload.count);
+                        if (payload.cacheKey)
+                            setCacheKey(payload.cacheKey);
+                    }
+                    catch { }
+                }
+                if (event === "hotels") {
+                    try {
+                        const payload = JSON.parse(data);
+                        const batch = normalizeBatch(Array.isArray(payload.hotels) ? payload.hotels : [], cs);
+                        if (batch.length > 0)
+                            setOffers(batch);
+                    }
+                    catch { }
+                }
+            },
+            onError: (err) => {
+                if (err.name !== "AbortError") {
+                    setError(err.message || "Page fetch failed");
+                }
+            },
+            onComplete: () => {
+                setIsPageLoading(false);
+            },
+        });
+    }, [searchParams, limit, streamCompleted, token]);
+    const reset = useCallback(() => {
+        cleanup();
+        setOffers([]);
+        setAllHotels([]);
+        allHotelsRef.current = [];
+        hotelMapRef.current = new Map();
+        setLoading(false);
+        setIsStreaming(false);
+        setIsPageLoading(false);
+        setError(null);
+        setTotal(0);
+        setOffset(0);
+        setLimit(20);
+        setSearchParams(null);
+        setCacheKey(null);
+        setStreamCompleted(false);
+    }, []);
+    return {
+        offers,
+        allHotels,
+        loading,
+        isStreaming,
+        isPageLoading,
+        error,
+        total,
+        offset,
+        limit,
+        cacheKey,
+        streamCompleted,
+        searchParams,
+        startSearch,
+        filterSearch,
+        fetchPage,
+        reset,
+    };
+}

package/dist/modules/hooks/useSearchExpiration.d.ts

@@ -0,0 +1,6 @@
+export declare function useSearchExpiration(minutes?: number): {
+    isExpired: boolean;
+    startTimer: () => void;
+    ignore: () => void;
+    reset: () => void;
+};

package/dist/modules/hooks/useSearchExpiration.js

@@ -0,0 +1,35 @@
+import { useEffect, useRef, useState } from "react";
+export function useSearchExpiration(minutes = 30) {
+    const [isExpired, setIsExpired] = useState(false);
+    const lastSearchRef = useRef(null);
+    const startTimer = () => {
+        lastSearchRef.current = Date.now();
+        setIsExpired(false);
+    };
+    const ignore = () => {
+        lastSearchRef.current = Date.now();
+        setIsExpired(false);
+    };
+    const reset = () => {
+        lastSearchRef.current = null;
+        setIsExpired(false);
+    };
+    useEffect(() => {
+        const interval = setInterval(() => {
+            if (!lastSearchRef.current)
+                return;
+            const diff = Date.now() - lastSearchRef.current;
+            const limit = minutes * 60 * 1000;
+            if (diff >= limit) {
+                setIsExpired(true);
+            }
+        }, 15000);
+        return () => clearInterval(interval);
+    }, [minutes]);
+    return {
+        isExpired,
+        startTimer,
+        ignore,
+        reset,
+    };
+}

package/dist/modules/hooks/useTranslationsHub.d.ts

@@ -0,0 +1,5 @@
+export declare function getTranslationsHub(): Record<string, string>;
+export declare function useTranslationsHub(code: string, lang: string): {
+    loading: boolean;
+    error: string | null;
+};

package/dist/modules/hooks/useTranslationsHub.js

@@ -0,0 +1,48 @@
+import { useEffect, useState } from "react";
+import { useApiToken } from "../../utils/getToken";
+import { defaultTranslations } from "../../locales/widgetTranslations";
+let translationsHub = {};
+export function getTranslationsHub() {
+    return translationsHub;
+}
+export function useTranslationsHub(code, lang) {
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const token = useApiToken();
+    useEffect(() => {
+        if (!lang || !code)
+            return;
+        const local = defaultTranslations[lang] || defaultTranslations["en"];
+        translationsHub = local;
+        const controller = new AbortController();
+        async function fetchTranslations() {
+            setLoading(true);
+            setError(null);
+            try {
+                const res = await fetch(`https://api.travel-code.com/v1/data/vocabulary?code=${code}&lang=${lang}`, {
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${token}`,
+                    },
+                    signal: controller.signal,
+                });
+                if (!res.ok)
+                    throw new Error(`Error ${res.status}`);
+                const data = await res.json();
+                translationsHub = data;
+            }
+            catch (err) {
+                if (err.name !== "AbortError") {
+                    console.warn("Failed to update translations:", err);
+                    setError(err.message || "Translation load error");
+                }
+            }
+            finally {
+                setLoading(false);
+            }
+        }
+        fetchTranslations();
+        return () => controller.abort();
+    }, [code, lang, token]);
+    return { loading, error };
+}

package/dist/modules/navbar/Navbar.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+type NavbarProps = {
+    activeTab?: string;
+    onTabChange?: (tab: string) => void;
+    translations: Record<string, string>;
+};
+export declare const Navbar: React.FC<NavbarProps>;
+export default Navbar;

package/dist/modules/navbar/Navbar.js

@@ -0,0 +1,69 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { View, Text, TouchableOpacity, StyleSheet, } from "react-native";
+import { useWidget } from "../../context/WidgetContext";
+import { FlightIcon, HotelIcon } from "../../store";
+import { Colors, Spacing, BorderRadius, FontSize } from "../../theme/colors";
+export const Navbar = ({ activeTab = "flights", onTabChange, translations, }) => {
+    const { colors } = useWidget();
+    const visibleTabs = [
+        {
+            key: "flights",
+            label: translations["tab_flights"] || "Flights",
+            Icon: FlightIcon,
+        },
+        {
+            key: "hotels",
+            label: translations["tab_hotels"] || "Hotels",
+            Icon: HotelIcon,
+        },
+    ];
+    const primaryColor = colors.primary || Colors.primary;
+    return (_jsx(View, { style: styles.container, children: _jsx(View, { style: styles.tabsRow, children: visibleTabs.map(({ key, label, Icon }) => {
+                const isActive = activeTab === key;
+                return (_jsxs(TouchableOpacity, { activeOpacity: 0.7, onPress: () => onTabChange?.(key), style: [
+                        styles.tab,
+                        isActive
+                            ? [styles.tabActive, { backgroundColor: primaryColor }]
+                            : styles.tabInactive,
+                    ], children: [_jsx(Icon, { size: 18, color: isActive ? Colors.white : primaryColor }), _jsx(Text, { style: [
+                                styles.tabLabel,
+                                { color: isActive ? Colors.white : primaryColor },
+                            ], children: label })] }, key));
+            }) }) }));
+};
+const styles = StyleSheet.create({
+    container: {
+        backgroundColor: Colors.transparent,
+        paddingHorizontal: Spacing.lg,
+        paddingVertical: Spacing.md,
+        zIndex: 1,
+    },
+    tabsRow: {
+        flexDirection: "row",
+        alignItems: "center",
+        gap: 10,
+    },
+    tab: {
+        flexDirection: "row",
+        alignItems: "center",
+        justifyContent: "center",
+        paddingVertical: Spacing.md,
+        paddingHorizontal: Spacing.lg,
+        borderRadius: BorderRadius.lg,
+        gap: Spacing.sm,
+        shadowColor: Colors.black,
+        shadowOffset: { width: 0, height: 0 },
+        shadowOpacity: 0.05,
+        shadowRadius: 15,
+        elevation: 2,
+    },
+    tabActive: {},
+    tabInactive: {
+        backgroundColor: Colors.white,
+    },
+    tabLabel: {
+        fontSize: FontSize.lg,
+        fontWeight: "400",
+    },
+});
+export default Navbar;

package/dist/modules/search-form/AgeSelector.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+type AgeSelectorProps = {
+    label: string;
+    value: string;
+    onChange: (val: string) => void;
+    translations: Record<string, string>;
+};
+declare const AgeSelector: React.FC<AgeSelectorProps>;
+export default AgeSelector;