@devtravelcode/widget-native 1.0.0

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

@@ -0,0 +1,21 @@
+export type Location = {
+    id: number | string;
+    code: string;
+    title: string;
+    titleEn: string;
+    isAirport?: boolean;
+    city?: {
+        id: number;
+        title: string;
+        titleEn: string;
+    };
+    country?: {
+        id: number;
+        title: string;
+        titleEn: string;
+    };
+};
+export declare function useAirportSearch(query: string): {
+    locations: Location[];
+    loading: boolean;
+};

package/dist/modules/hooks/useAirportSearch.js

@@ -0,0 +1,48 @@
+import { useState, useEffect } from "react";
+import { useApiToken } from "../../utils/getToken";
+const API_URL = "https://api.travel-code.com/v1/data/airports";
+export function useAirportSearch(query) {
+    const token = useApiToken();
+    const [locations, setLocations] = useState([]);
+    const [loading, setLoading] = useState(false);
+    useEffect(() => {
+        if (query.length < 2) {
+            setLocations([]);
+            return;
+        }
+        const controller = new AbortController();
+        const delay = setTimeout(() => {
+            setLoading(true);
+            fetch(`${API_URL}?search=${encodeURIComponent(query)}&scope=city,country&limit=20`, {
+                method: "GET",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+                signal: controller.signal,
+            })
+                .then((res) => {
+                if (!res.ok)
+                    throw new Error(`Ошибка ${res.status}`);
+                return res.json();
+            })
+                .then((data) => {
+                const validLocations = (Array.isArray(data) ? data : []).filter((loc) => loc.code);
+                setLocations(validLocations);
+            })
+                .catch((err) => {
+                if (err.name !== "AbortError") {
+                    console.error("Ошибка загрузки аэропортов:", err);
+                }
+            })
+                .finally(() => {
+                setLoading(false);
+            });
+        }, 800);
+        return () => {
+            clearTimeout(delay);
+            controller.abort();
+        };
+    }, [query]);
+    return { locations, loading };
+}

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

@@ -0,0 +1,7 @@
+export declare const useCarOffers: () => {
+    offers: any[];
+    loading: boolean;
+    error: string | null;
+    fetchOffers: (payload: any) => Promise<void>;
+    reset: () => void;
+};

package/dist/modules/hooks/useCarOffers.js

@@ -0,0 +1,47 @@
+import { useState } from "react";
+export const useCarOffers = () => {
+    const [offers, setOffers] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const reset = () => {
+        setOffers([]);
+        setLoading(false);
+        setError(null);
+    };
+    const fetchOffers = async (payload) => {
+        setLoading(true);
+        setError(null);
+        try {
+            const response = await fetch("https://api.travelhub.by/discovercars/request", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    endpoint: "/v1/offers",
+                    method: "POST",
+                    data: payload,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`Ошибка DiscoverCars API: ${response.status} ${response.statusText}`);
+            }
+            const json = await response.json();
+            console.log("✅ Ответ DiscoverCars API:", json);
+            if (Array.isArray(json.data)) {
+                setOffers(json.data);
+            }
+            else {
+                console.warn("⚠️ Неверный формат ответа:", json);
+                setOffers([]);
+            }
+        }
+        catch (err) {
+            console.error("❌ Ошибка при загрузке офферов:", err);
+            setError(err.message);
+            setOffers([]);
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    return { offers, loading, error, fetchOffers, reset };
+};

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

@@ -0,0 +1,4 @@
+export declare function useCountriesByCodes(codes: string[] | null | undefined): {
+    countries: any[] | null;
+    loading: boolean;
+};

package/dist/modules/hooks/useCountriesByCodes.js

@@ -0,0 +1,60 @@
+import { useEffect, useState, useRef } from "react";
+import { useApiToken } from "../../utils/getToken";
+const FLAG_BASE = "https://cdn.travel-code.com/images/remaster/flags";
+export function useCountriesByCodes(codes) {
+    const [countries, setCountries] = useState(null);
+    const [loading, setLoading] = useState(false);
+    const token = useApiToken();
+    const cacheRef = useRef({});
+    const codesKey = codes ? JSON.stringify(codes) : "";
+    useEffect(() => {
+        if (!codes || codes.length === 0) {
+            setCountries((prev) => (prev === null ? prev : null));
+            return;
+        }
+        const notCached = codes.filter((c) => !cacheRef.current[c]);
+        if (notCached.length === 0) {
+            const result = codes.map((c) => cacheRef.current[c]);
+            setCountries((prev) => {
+                if (prev && prev.length === result.length && prev.every((c, i) => c === result[i])) {
+                    return prev;
+                }
+                return result;
+            });
+            return;
+        }
+        const load = async () => {
+            setLoading(true);
+            try {
+                const joined = notCached.join(",");
+                const res = await fetch(`https://api.travel-code.com/v1/data/countries?filter[countryCodes]=${joined}`, {
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${token}`,
+                    },
+                });
+                const data = await res.json();
+                if (Array.isArray(data)) {
+                    data.forEach((c) => {
+                        cacheRef.current[c.code] = {
+                            code: c.code,
+                            title: c.title,
+                            titleEn: c.titleEn,
+                            flag: `${FLAG_BASE}/${c.code}.svg`,
+                        };
+                    });
+                    setCountries(codes.map((c) => cacheRef.current[c]));
+                }
+            }
+            catch (e) {
+                console.error("Ошибка загрузки countries:", e);
+                setCountries(null);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        load();
+    }, [codesKey, token]);
+    return { countries, loading };
+}

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

@@ -0,0 +1,11 @@
+export type ApiCountry = {
+    id: number;
+    code: string;
+    title: string;
+    titleEn: string;
+};
+export declare function useCountriesSearch(query: string): {
+    results: ApiCountry[];
+    loading: boolean;
+    error: string | null;
+};

package/dist/modules/hooks/useCountriesSearch.js

@@ -0,0 +1,55 @@
+import { useState, useEffect, useRef } from "react";
+import { useApiToken } from "../../utils/getToken";
+const API_URL = "https://api.travel-code.com/v1/data/countries";
+export function useCountriesSearch(query) {
+    const token = useApiToken();
+    const [results, setResults] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const cacheRef = useRef({});
+    const controllerRef = useRef(null);
+    useEffect(() => {
+        if (!query || query.trim().length < 2) {
+            setResults([]);
+            return;
+        }
+        if (cacheRef.current[query]) {
+            setResults(cacheRef.current[query]);
+            return;
+        }
+        const fetchCountries = async () => {
+            setLoading(true);
+            setError(null);
+            if (controllerRef.current)
+                controllerRef.current.abort();
+            controllerRef.current = new AbortController();
+            try {
+                const res = await fetch(`${API_URL}?search=${encodeURIComponent(query)}`, {
+                    method: "GET",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${token}`,
+                    },
+                    signal: controllerRef.current.signal,
+                });
+                if (!res.ok)
+                    throw new Error(`Ошибка ${res.status}`);
+                const data = await res.json();
+                cacheRef.current[query] = data;
+                setResults(data);
+            }
+            catch (err) {
+                if (err.name !== "AbortError") {
+                    setError("Ошибка загрузки стран");
+                    console.error(err);
+                }
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        const timeout = setTimeout(fetchCountries, 400);
+        return () => clearTimeout(timeout);
+    }, [query]);
+    return { results, loading, error };
+}

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

@@ -0,0 +1,7 @@
+export declare function useDefaultHotelLocation(defaultId?: string | null, lang?: "ru" | "en"): {
+    defaultItem: {
+        id: string;
+        name: string;
+    } | null;
+    loadingDefault: boolean;
+};

package/dist/modules/hooks/useDefaultHotelLocation.js

@@ -0,0 +1,44 @@
+import { useState, useEffect } from "react";
+import { useApiToken } from "../../utils/getToken";
+const API_URL = "https://api.travel-code.com/v1/data/hotel-location?id=";
+export function useDefaultHotelLocation(defaultId, lang = "ru") {
+    const token = useApiToken();
+    const [defaultItem, setDefaultItem] = useState(null);
+    const [loadingDefault, setLoadingDefault] = useState(false);
+    useEffect(() => {
+        if (!defaultId)
+            return;
+        const load = async () => {
+            try {
+                setLoadingDefault(true);
+                const res = await fetch(`${API_URL}${defaultId}`, {
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${token}`,
+                    },
+                });
+                if (!res.ok)
+                    return;
+                const data = await res.json();
+                const result = data?.result;
+                if (result) {
+                    const name = lang === "en"
+                        ? result.nameEn || result.name || ""
+                        : result.nameRu || result.name || "";
+                    setDefaultItem({
+                        id: String(defaultId),
+                        name,
+                    });
+                }
+            }
+            catch (err) {
+                console.warn("Ошибка загрузки default локации:", err);
+            }
+            finally {
+                setLoadingDefault(false);
+            }
+        };
+        load();
+    }, [defaultId, lang, token]);
+    return { defaultItem, loadingDefault };
+}

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

@@ -0,0 +1 @@
+export declare const useDetectNationality: () => string;

package/dist/modules/hooks/useDetectNationality.js

@@ -0,0 +1,20 @@
+import { useState, useEffect } from "react";
+export const useDetectNationality = () => {
+    const [code, setCode] = useState("");
+    useEffect(() => {
+        const detect = async () => {
+            try {
+                const res = await fetch("https://ipwho.is/");
+                const data = await res.json();
+                if (data?.success !== false && data.country_code) {
+                    setCode(data.country_code);
+                }
+            }
+            catch (e) {
+                console.warn("IP detect failed:", e);
+            }
+        };
+        detect();
+    }, []);
+    return code;
+};

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

@@ -0,0 +1,20 @@
+export declare function useFlightSearch(): {
+    results: any[];
+    filtersData: any;
+    airlinesData: Record<string, string>;
+    dictionaries: any;
+    currencySign: any;
+    loading: boolean;
+    isFiltering: boolean;
+    error: string | null;
+    status: string;
+    sessionId: string | null;
+    total: number;
+    limit: number;
+    offset: number;
+    isPageLoading: boolean;
+    startSearch: (params: any) => Promise<any>;
+    applyFilters: (sid: string | null, filters?: Record<string, any>, page?: number) => Promise<void>;
+    fetchPage: (page: number) => Promise<void>;
+    reset: () => void;
+};

package/dist/modules/hooks/useFlightSearch.js

@@ -0,0 +1,243 @@
+import { useState, useCallback, useRef } from "react";
+import { useApiToken } from "../../utils/getToken";
+const API_BASE = "https://api.travel-code.com/v1/search/flights";
+const MAX_POLL_ATTEMPTS = 50;
+const POLL_INTERVAL = 1200;
+export function useFlightSearch() {
+    const token = useApiToken();
+    const [results, setResults] = useState([]);
+    const [filtersData, setFiltersData] = useState(null);
+    const [airlinesData, setAirlinesData] = useState({});
+    const [loading, setLoading] = useState(false);
+    const [isFiltering, setIsFiltering] = useState(false);
+    const [error, setError] = useState(null);
+    const [status, setStatus] = useState("idle");
+    const [sessionId, setSessionId] = useState(null);
+    const [dictionaries, setDictionaries] = useState(null);
+    const [currencySign, setCurrencySign] = useState(null);
+    const [total, setTotal] = useState(0);
+    const [limit, setLimit] = useState(25);
+    const [offset, setOffset] = useState(0);
+    const [activeFilters, setActiveFilters] = useState({});
+    const [isPageLoading, setIsPageLoading] = useState(false);
+    const prevTotalRef = useRef(0);
+    const pollingRef = useRef(false);
+    const startSearch = useCallback(async (params) => {
+        setLoading(true);
+        setIsFiltering(false);
+        setError(null);
+        setResults([]);
+        setFiltersData(null);
+        setAirlinesData({});
+        setStatus("pending");
+        setTotal(0);
+        prevTotalRef.current = 0;
+        pollingRef.current = true;
+        try {
+            console.log("[FlightSearch] TOKEN:", token ? `${token.substring(0, 8)}...` : "EMPTY!");
+            console.log("[FlightSearch] POST params:", JSON.stringify(params));
+            const initRes = await fetch(API_BASE, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify(params),
+            });
+            console.log("[FlightSearch] Init response status:", initRes.status);
+            const initData = await initRes.json();
+            console.log("[FlightSearch] Init response:", JSON.stringify(initData).substring(0, 500));
+            const cacheId = initData.cacheId;
+            if (!cacheId) {
+                console.error("[FlightSearch] No cacheId! Full response:", JSON.stringify(initData));
+                setError(initData.message || "Не удалось начать поиск");
+                setStatus("failed");
+                return;
+            }
+            setSessionId(cacheId);
+            let attempt = 0;
+            while (pollingRef.current && attempt < MAX_POLL_ATTEMPTS) {
+                attempt++;
+                const res = await fetch(`${API_BASE}/${cacheId}?embedded=filters,airlines,dictionaries`, {
+                    headers: {
+                        Authorization: `Bearer ${token}`,
+                    },
+                });
+                const data = await res.json();
+                console.log(`[FlightSearch] Poll #${attempt}: status=${data.status}, items=${data.items?.length || 0}, total=${data.total}`);
+                setStatus(data.status || "unknown");
+                if (Array.isArray(data.items))
+                    setResults(data.items);
+                if (data.filters)
+                    setFiltersData(data.filters);
+                if (data.airlines)
+                    setAirlinesData(data.airlines);
+                if (data.dictionaries)
+                    setDictionaries(data.dictionaries);
+                if (data.currencySign)
+                    setCurrencySign(data.currencySign);
+                if (typeof data.total === "number")
+                    setTotal(data.total);
+                if (typeof data.limit === "number")
+                    setLimit(data.limit);
+                if (typeof data.offset === "number")
+                    setOffset(data.offset);
+                if (data.status === "failed") {
+                    setError("Ошибка поиска: сервер вернул статус failed");
+                    setStatus("failed");
+                    break;
+                }
+                if (["success_partially", "success"].includes(data.status))
+                    break;
+                await new Promise((r) => setTimeout(r, POLL_INTERVAL));
+            }
+            if (attempt >= MAX_POLL_ATTEMPTS) {
+                setError(`Превышено количество запросов (${MAX_POLL_ATTEMPTS})`);
+                setStatus("timeout");
+            }
+            return cacheId;
+        }
+        catch (err) {
+            console.error("Ошибка поиска:", err);
+            setError(err.message || "Ошибка при поиске");
+            setStatus("failed");
+        }
+        finally {
+            setLoading(false);
+            pollingRef.current = false;
+        }
+    }, [token]);
+    const reset = () => {
+        pollingRef.current = false;
+        setResults([]);
+        setFiltersData(null);
+        setAirlinesData({});
+        setDictionaries(null);
+        setCurrencySign(null);
+        setLoading(false);
+        setIsFiltering(false);
+        setError(null);
+        setStatus("idle");
+        setSessionId(null);
+        setTotal(0);
+        setLimit(25);
+        setOffset(0);
+        setActiveFilters({});
+        setIsPageLoading(false);
+    };
+    const applyFilters = useCallback(async (sid, filters = {}, page = 1) => {
+        if (!sid)
+            return;
+        setIsFiltering(true);
+        setActiveFilters(filters);
+        try {
+            const newOffset = (page - 1) * limit;
+            const query = new URLSearchParams();
+            Object.entries(filters).forEach(([key, value]) => {
+                if (value !== undefined && value !== null && value !== "") {
+                    if (Array.isArray(value)) {
+                        value.forEach((v) => query.append(`filter[${key}][]`, String(v)));
+                    }
+                    else {
+                        query.append(`filter[${key}]`, String(value));
+                    }
+                }
+            });
+            query.append("limit", String(limit));
+            query.append("offset", String(newOffset));
+            const res = await fetch(`${API_BASE}/${sid}?${query.toString()}&embedded=filters,airlines,dictionaries`, {
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+            });
+            const data = await res.json();
+            if (data.status === "failed") {
+                setError("Ошибка фильтрации: сервер вернул статус failed");
+                setStatus("failed");
+                return;
+            }
+            setResults(data.items || []);
+            if (data.filters)
+                setFiltersData(data.filters);
+            if (data.airlines)
+                setAirlinesData(data.airlines);
+            if (data.dictionaries)
+                setDictionaries(data.dictionaries);
+            if (data.currencySign)
+                setCurrencySign(data.currencySign);
+            if (typeof data.total === "number")
+                setTotal(data.total);
+            if (typeof data.limit === "number")
+                setLimit(data.limit);
+            if (typeof data.offset === "number")
+                setOffset(data.offset);
+        }
+        catch (err) {
+            console.error("Ошибка фильтрации:", err);
+            setError(err.message || "Ошибка при фильтрации");
+        }
+        finally {
+            setIsFiltering(false);
+        }
+    }, [limit, token]);
+    const fetchPage = useCallback(async (page) => {
+        if (!sessionId)
+            return;
+        const newOffset = (page - 1) * limit;
+        setIsPageLoading(true);
+        try {
+            const query = new URLSearchParams();
+            Object.entries(activeFilters).forEach(([key, value]) => {
+                if (value !== undefined && value !== null && value !== "") {
+                    if (Array.isArray(value)) {
+                        value.forEach((v) => query.append(`filter[${key}][]`, String(v)));
+                    }
+                    else {
+                        query.append(`filter[${key}]`, String(value));
+                    }
+                }
+            });
+            query.append("limit", String(limit));
+            query.append("offset", String(newOffset));
+            const res = await fetch(`${API_BASE}/${sessionId}?${query.toString()}&embedded=airlines`, { headers: { Authorization: `Bearer ${token}` } });
+            const data = await res.json();
+            if (Array.isArray(data.items))
+                setResults(data.items);
+            if (typeof data.total === "number")
+                setTotal(data.total);
+            if (typeof data.limit === "number")
+                setLimit(data.limit);
+            if (typeof data.offset === "number")
+                setOffset(data.offset);
+            if (data.airlines)
+                setAirlinesData(data.airlines);
+        }
+        catch (err) {
+            console.error("Ошибка пагинации:", err);
+            setError(err.message || "Ошибка при загрузке страницы");
+        }
+        finally {
+            setIsPageLoading(false);
+        }
+    }, [sessionId, limit, activeFilters, token]);
+    return {
+        results,
+        filtersData,
+        airlinesData,
+        dictionaries,
+        currencySign,
+        loading,
+        isFiltering,
+        error,
+        status,
+        sessionId,
+        total,
+        limit,
+        offset,
+        isPageLoading,
+        startSearch,
+        applyFilters,
+        fetchPage,
+        reset,
+    };
+}

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

@@ -0,0 +1,7 @@
+export declare const useHotelDetails: (searchParams?: Record<string, any>) => {
+    hotelData: any;
+    loading: boolean;
+    error: string | null;
+    fetchHotelDetails: (hotelId: number) => Promise<any>;
+    clearCache: () => Promise<void>;
+};