@devtravelcode/widget-native 1.0.0

package/dist/modules/hooks/useHotelDetails.js

@@ -0,0 +1,80 @@
+import { useState, useCallback } from "react";
+import { useApiToken } from "../../utils/getToken";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+const CACHE_KEY = "hotelDetailsCache";
+const CACHE_TTL = 1000 * 60 * 60;
+export const useHotelDetails = (searchParams) => {
+    const token = useApiToken();
+    const [loading, setLoading] = useState(false);
+    const [hotelData, setHotelData] = useState(null);
+    const [error, setError] = useState(null);
+    const readCache = async () => {
+        try {
+            const raw = await AsyncStorage.getItem(CACHE_KEY);
+            const cache = JSON.parse(raw || "{}");
+            for (const key in cache) {
+                if (Date.now() - cache[key]._ts > CACHE_TTL) {
+                    delete cache[key];
+                }
+            }
+            return cache;
+        }
+        catch {
+            return {};
+        }
+    };
+    const writeCache = async (cache) => AsyncStorage.setItem(CACHE_KEY, JSON.stringify(cache));
+    const clearCache = () => AsyncStorage.removeItem(CACHE_KEY);
+    const fetchHotelDetails = useCallback(async (hotelId) => {
+        if (!searchParams)
+            return null;
+        setLoading(true);
+        setError(null);
+        const cache = await readCache();
+        const cachedEntry = cache[hotelId];
+        if (cachedEntry && Object.keys(cachedEntry).length > 1) {
+            const cached = cachedEntry;
+            console.log("[useHotelDetails] cached data for", hotelId, ":", JSON.stringify(cached, null, 2));
+            await new Promise((res) => setTimeout(res, 300));
+            setHotelData(cached);
+            setLoading(false);
+            return cached;
+        }
+        try {
+            const response = await fetch("https://api.travel-code.com/v1/search/hotels/list", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify({
+                    ...searchParams,
+                    id: [hotelId],
+                }),
+            });
+            const data = await response.json();
+            console.log("[useHotelDetails] /list response:", JSON.stringify(data, null, 2));
+            const hotel = data?.hotels?.[0] || data?.data?.[0] || null;
+            if (!hotel) {
+                setError("Failed to load hotel data");
+                setHotelData(null);
+                return null;
+            }
+            setHotelData(hotel);
+            await writeCache({
+                ...cache,
+                [hotelId]: { ...hotel, _ts: Date.now() },
+            });
+            return hotel;
+        }
+        catch (err) {
+            console.error("Hotel details error:", err);
+            setError("Request error");
+            return null;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [searchParams, token]);
+    return { hotelData, loading, error, fetchHotelDetails, clearCache };
+};

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

@@ -0,0 +1,5 @@
+export declare function useHotelLocations(query: string): {
+    results: any[];
+    loading: boolean;
+    fetchLocations: (term: string) => Promise<void>;
+};

package/dist/modules/hooks/useHotelLocations.js

@@ -0,0 +1,42 @@
+import { useState, useEffect } from "react";
+import { useApiToken } from "../../utils/getToken";
+const API_URL = "https://api.travel-code.com/v1/data/hotel-locations";
+export function useHotelLocations(query) {
+    const token = useApiToken();
+    const [results, setResults] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const fetchLocations = async (term) => {
+        try {
+            setLoading(true);
+            const res = await fetch(`${API_URL}?search=${encodeURIComponent(term)}`, {
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+            });
+            if (!res.ok)
+                throw new Error(`Ошибка ${res.status}`);
+            const data = await res.json();
+            setResults(data.items || []);
+        }
+        catch (err) {
+            console.warn("⚠️ Ошибка загрузки локаций:", err);
+            setResults([]);
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    useEffect(() => {
+        if (!query || query.length < 2) {
+            setResults([]);
+            setLoading(false);
+            return;
+        }
+        const debounced = setTimeout(() => {
+            fetchLocations(query);
+        }, 400);
+        return () => clearTimeout(debounced);
+    }, [query]);
+    return { results, loading, fetchLocations };
+}

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

@@ -0,0 +1,12 @@
+export type HotelPin = {
+    id: string;
+    latitude: number;
+    longitude: number;
+    total: number | null;
+    soldOut: boolean;
+};
+export declare const useHotelMapData: (params: Record<string, any>, shouldFetch?: boolean) => {
+    pins: HotelPin[];
+    loading: boolean;
+    fetchFailed: boolean;
+};

package/dist/modules/hooks/useHotelMapData.js

@@ -0,0 +1,78 @@
+import { useState, useEffect, useRef, useCallback } from "react";
+import { useApiToken } from "../../utils/getToken";
+const API_BASE = "https://api.travel-code.com/v1/search/hotels/map";
+export const useHotelMapData = (params, shouldFetch = true) => {
+    const token = useApiToken();
+    const [pins, setPins] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [fetchFailed, setFetchFailed] = useState(false);
+    const lastParamsRef = useRef("");
+    const fetchPins = useCallback(async () => {
+        console.log("%c[useHotelMapData] 🚀 СТАРТ ЗАПРОСА", "color:#fff;background:#43a047;padding:3px 6px;border-radius:4px", { params });
+        setLoading(true);
+        setFetchFailed(false);
+        try {
+            const response = await fetch(API_BASE, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify(params),
+            });
+            console.log("%c[useHotelMapData] 📥 ОТВЕТ ПОЛУЧЕН", "color:#fff;background:#5e35b1;padding:3px 6px;border-radius:4px", { status: response.status });
+            if (!response.ok)
+                throw new Error(`Ошибка ${response.status}`);
+            const result = await response.json();
+            console.log("%c[useHotelMapData] 🟢 pins:", "color:#fff;background:#00897b;padding:3px 6px;border-radius:4px", result?.data?.length);
+            if (result?.data?.length) {
+                const formatted = result.data
+                    .filter((item) => {
+                    const lat = parseFloat(item.latitude);
+                    const lng = parseFloat(item.longitude);
+                    return lat && lng && lat !== 0 && lng !== 0;
+                })
+                    .map((item) => ({
+                    id: String(item.propertyId),
+                    latitude: parseFloat(item.latitude),
+                    longitude: parseFloat(item.longitude),
+                    total: typeof item.total === "number" ? item.total : null,
+                    soldOut: item.soldOut === true ||
+                        item.total === null,
+                }));
+                setPins(formatted);
+            }
+            else {
+                console.log("%c[useHotelMapData] ⚠️ Нет данных", "color:#fb8c00");
+                setPins([]);
+            }
+        }
+        catch (err) {
+            console.error("%c[useHotelMapData] 🔥 ОШИБКА", "background:red;color:white", err);
+            setFetchFailed(true);
+        }
+        finally {
+            console.log("%c[useHotelMapData] ⏹ ЗАПРОС ЗАВЕРШЕН", "color:#fff;background:#6d4c41;padding:3px 6px;border-radius:4px");
+            setLoading(false);
+        }
+    }, [params, token]);
+    useEffect(() => {
+        console.log("%c[useHotelMapData] EFFECT TRIGGERED", "color:#fff;background:#1e88e5;padding:3px 6px;border-radius:4px", { params, shouldFetch });
+        if (!shouldFetch) {
+            console.log("%c[useHotelMapData] ❌ shouldFetch = false → запрос НЕ отправлен", "color:#ef5350");
+            return;
+        }
+        if (!params || Object.keys(params).length === 0) {
+            console.log("%c[useHotelMapData] ❌ Пустые params → запрос НЕ отправлен", "color:#ef5350");
+            return;
+        }
+        const key = JSON.stringify(params);
+        if (key === lastParamsRef.current) {
+            console.log("%c[useHotelMapData] 🔁 Те же params → запрос пропущен", "color:#ffa726");
+            return;
+        }
+        lastParamsRef.current = key;
+        fetchPins();
+    }, [params, shouldFetch, fetchPins]);
+    return { pins, loading, fetchFailed };
+};

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

@@ -0,0 +1,11 @@
+export declare const useHotelOffers: () => {
+    offers: any[];
+    loading: boolean;
+    error: string | null;
+    total: number;
+    offset: number;
+    limit: number;
+    fetchHotelOffers: (params: any) => Promise<void>;
+    fetchPage: (page: number, baseParams: Record<string, any>) => Promise<void>;
+    reset: () => void;
+};

package/dist/modules/hooks/useHotelOffers.js

@@ -0,0 +1,122 @@
+import { useState, useRef } from "react";
+import { useApiToken } from "../../utils/getToken";
+const POLL_INTERVAL = 1000;
+const POLL_TIMEOUT = 180000;
+export const useHotelOffers = () => {
+    const token = useApiToken();
+    const [offers, setOffers] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [total, setTotal] = useState(0);
+    const [offset, setOffset] = useState(0);
+    const [limit, setLimit] = useState(20);
+    const pollTimer = useRef(null);
+    const applyResult = (data, params) => {
+        setOffers(Array.isArray(data?.data) ? data.data : []);
+        setTotal(Number(data?.count || 0));
+        setOffset(params.offset ?? 0);
+        setLimit(params.limit ?? 20);
+    };
+    const reset = () => {
+        if (pollTimer.current) {
+            clearTimeout(pollTimer.current);
+        }
+        setOffers([]);
+        setLoading(false);
+        setError(null);
+        setTotal(0);
+        setOffset(0);
+        setLimit(20);
+    };
+    const pollTask = async (taskId, params) => {
+        const start = Date.now();
+        return new Promise((resolve, reject) => {
+            const check = async () => {
+                try {
+                    const pollBody = {
+                        ...params,
+                        taskId,
+                    };
+                    const response = await fetch("https://api.travel-code.com/v1/search/hotels/task", {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                            Authorization: `Bearer ${token}`,
+                        },
+                        body: JSON.stringify(pollBody),
+                    });
+                    if (!response.ok) {
+                        reject(new Error("Ошибка при запросе /task"));
+                        return;
+                    }
+                    const json = await response.json();
+                    if (json.status === "done" && json.data) {
+                        applyResult(json, params);
+                        resolve();
+                        return;
+                    }
+                    if (json.status === "lost" || json.status === "timeout") {
+                        reject(new Error("Поиск завершился со статусом lost/timeout"));
+                        return;
+                    }
+                    if (Date.now() - start > POLL_TIMEOUT) {
+                        reject(new Error("Истекло время ожидания taskId"));
+                        return;
+                    }
+                    pollTimer.current = setTimeout(check, POLL_INTERVAL);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            };
+            check();
+        });
+    };
+    const fetchHotelOffers = async (params) => {
+        try {
+            setLoading(true);
+            setError(null);
+            const response = await fetch("https://api.travel-code.com/v1/search/hotels", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify(params),
+            });
+            if (!response.ok)
+                throw new Error("Ошибка при запуске поиска отелей");
+            const json = await response.json();
+            if (json.data) {
+                applyResult(json, params);
+                return;
+            }
+            if (json.taskId) {
+                await pollTask(json.taskId, params);
+                return;
+            }
+            throw new Error("Неизвестный формат ответа от API");
+        }
+        catch (err) {
+            setError(err.message);
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    const fetchPage = async (page, baseParams) => {
+        const newOffset = (page - 1) * limit;
+        await fetchHotelOffers({ ...baseParams, offset: newOffset, limit });
+    };
+    return {
+        offers,
+        loading,
+        error,
+        total,
+        offset,
+        limit,
+        fetchHotelOffers,
+        fetchPage,
+        reset
+    };
+};

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

@@ -0,0 +1,18 @@
+export declare function useHotelSearchSSE(): {
+    offers: any[];
+    allHotels: any[];
+    loading: boolean;
+    isStreaming: boolean;
+    isPageLoading: boolean;
+    error: string | null;
+    total: number;
+    offset: number;
+    limit: number;
+    cacheKey: string | null;
+    streamCompleted: boolean;
+    searchParams: Record<string, any> | null;
+    startSearch: (params: Record<string, any>) => void;
+    filterSearch: (params: Record<string, any>) => void;
+    fetchPage: (page: number) => void;
+    reset: () => void;
+};