@devtravelcode/widget-native 1.0.0

package/dist/modules/search-form/hotel/HotelResults.js

@@ -0,0 +1,333 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect, useMemo, useRef } from "react";
+import { View, Text, FlatList, TouchableOpacity, ActivityIndicator, StyleSheet, } from "react-native";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+import Svg, { Path, Polygon, Line } from "react-native-svg";
+import HotelsSkeleton from "./HotelsSkeleton";
+import HotelList from "./components/HotelList";
+import HotelEmptyState from "./components/HotelEmptyState";
+import HotelMap, { pinsFromOffers } from "./components/HotelMap";
+import ProvidersLoader from "../flight/flight-results/ProvidersLoader";
+import Pagination from "../Pagination";
+import { HotelFilters, QUICK_FILTERS } from "./hotel-filters";
+import { Colors, Spacing, FontSize, BorderRadius } from "../../../theme/colors";
+const HotelResults = ({ offers, allHotels, loading, isStreaming = false, isPageLoading = false, error, translations, lang, searchParams = null, total = 0, offset = 0, limit = 20, fetchPage, filterSearch, currency = "USD", headerComponent, }) => {
+    const insets = useSafeAreaInsets();
+    const [hasSearched, setHasSearched] = useState(false);
+    const [localOffers, setLocalOffers] = useState(offers ?? []);
+    const [isMapOpen, setIsMapOpen] = useState(false);
+    const listRef = useRef(null);
+    const prevLoadingRef = useRef(false);
+    const headerHeightRef = useRef(0);
+    const [isFiltersOpen, setIsFiltersOpen] = useState(false);
+    const [activeFilters, setActiveFilters] = useState([]);
+    const [popupValues, setPopupValues] = useState(null);
+    const loadingInitial = loading && localOffers.length === 0;
+    const loadingRefetch = isPageLoading;
+    useEffect(() => {
+        if (loading && searchParams) {
+            setHasSearched(true);
+        }
+    }, [loading, searchParams]);
+    useEffect(() => {
+        const isSearchStarting = (loading || isStreaming) && !prevLoadingRef.current;
+        if (isSearchStarting) {
+            const scrollOffset = headerHeightRef.current > 0 ? headerHeightRef.current - 120 : 400;
+            setTimeout(() => {
+                listRef.current?.scrollToOffset({ offset: scrollOffset, animated: true });
+            }, 300);
+        }
+        prevLoadingRef.current = loading || isStreaming;
+    }, [loading, isStreaming]);
+    useEffect(() => {
+        if (offers && offers.length > 0) {
+            setLocalOffers(offers);
+        }
+        else if (!loading && !isStreaming && !isPageLoading && offers?.length === 0) {
+            setLocalOffers([]);
+        }
+    }, [offers, loading, isStreaming, isPageLoading]);
+    useEffect(() => {
+        if (loading && searchParams && !isPageLoading) {
+            setActiveFilters([]);
+            setPopupValues(null);
+        }
+    }, [loading, searchParams, isPageLoading]);
+    const derivedValuesFromQuickFilters = (filters = activeFilters) => {
+        const boardDef = QUICK_FILTERS.find((f) => f.type === "boards" && filters.includes(f.key));
+        const boards = boardDef?.value || null;
+        const payDef = QUICK_FILTERS.find((f) => f.type === "payments" && filters.includes(f.key));
+        const payments = payDef?.value || null;
+        const starDef = QUICK_FILTERS.find((f) => f.type === "starFrom" && filters.includes(f.key));
+        let starRating = [];
+        if (starDef) {
+            const from = starDef.value;
+            starRating = Array.from({ length: 5 - from + 1 }, (_, i) => from + i);
+        }
+        return { boards, payments, starRating };
+    };
+    const mapPins = useMemo(() => {
+        if (!allHotels || allHotels.length === 0)
+            return [];
+        return pinsFromOffers(allHotels, currency);
+    }, [allHotels, currency]);
+    const hasResults = localOffers.length > 0;
+    const showMapButton = hasResults && mapPins.length > 0 && !loadingInitial;
+    const isEmptyResult = hasSearched && !loadingInitial && !loadingRefetch && !loading && !isStreaming && localOffers.length === 0;
+    const isErrorState = !!error && hasSearched && !loadingInitial && !loadingRefetch;
+    const buildFilterRequest = (quickFilters, popup) => {
+        if (!searchParams)
+            return null;
+        const quickValues = derivedValuesFromQuickFilters(quickFilters);
+        const popupStars = popup?.starRating;
+        const finalFilter = {
+            ...(popup?.minPrice !== undefined && popup.minPrice > 0
+                ? { minPrice: popup.minPrice }
+                : {}),
+            ...(popup?.maxPrice !== undefined && popup.maxPrice !== 1000
+                ? { maxPrice: popup.maxPrice }
+                : {}),
+            ...(popupStars?.length ? { starRating: popupStars } : {}),
+            ...(!popupStars?.length && quickValues.starRating.length
+                ? { starRating: quickValues.starRating }
+                : {}),
+            ...(quickValues.boards
+                ? { boards: [quickValues.boards] }
+                : popup?.boards
+                    ? { boards: Array.isArray(popup.boards) ? popup.boards : [popup.boards] }
+                    : {}),
+            ...(quickValues.payments
+                ? { payments: quickValues.payments }
+                : popup?.payments
+                    ? { payments: popup.payments }
+                    : {}),
+        };
+        return {
+            ...searchParams,
+            offset: 0,
+            limit: 20,
+            ...(Object.keys(finalFilter).length ? { filter: finalFilter } : {}),
+        };
+    };
+    const handleQuickFilter = (key) => {
+        const def = QUICK_FILTERS.find((f) => f.key === key);
+        if (!def)
+            return;
+        setActiveFilters((prev) => {
+            let next = [...prev];
+            const isActive = next.includes(key);
+            if (def.type === "boards") {
+                next = next.filter((k) => {
+                    const f = QUICK_FILTERS.find((q) => q.key === k);
+                    return f?.type !== "boards";
+                });
+            }
+            if (def.type === "payments") {
+                next = next.filter((k) => {
+                    const f = QUICK_FILTERS.find((q) => q.key === k);
+                    return f?.type !== "payments";
+                });
+            }
+            if (def.type === "starFrom") {
+                next = next.filter((k) => {
+                    const f = QUICK_FILTERS.find((q) => q.key === k);
+                    return f?.type !== "starFrom";
+                });
+            }
+            if (isActive) {
+                next = next.filter((k) => k !== key);
+            }
+            else {
+                next.push(key);
+            }
+            let updatedPopupValues = popupValues;
+            if (popupValues) {
+                updatedPopupValues = { ...popupValues };
+                if (def.type === "starFrom")
+                    delete updatedPopupValues.starRating;
+                if (def.type === "boards")
+                    delete updatedPopupValues.boards;
+                if (def.type === "payments")
+                    delete updatedPopupValues.payments;
+                if (Object.keys(updatedPopupValues).length === 0)
+                    updatedPopupValues = null;
+            }
+            setPopupValues(updatedPopupValues);
+            if (hasSearched && searchParams && filterSearch) {
+                const requestBody = buildFilterRequest(next, updatedPopupValues);
+                if (requestBody) {
+                    filterSearch(requestBody);
+                }
+            }
+            return next;
+        });
+    };
+    const handleApplyAdvancedFilters = async (sid, filterValues) => {
+        if (!filterValues || !searchParams || !filterSearch)
+            return;
+        setPopupValues(filterValues);
+        const nextFilters = [];
+        if (filterValues.boards) {
+            const boardDef = QUICK_FILTERS.find((f) => f.type === "boards" && f.value === filterValues.boards);
+            if (boardDef)
+                nextFilters.push(boardDef.key);
+        }
+        if (filterValues.payments) {
+            const payDef = QUICK_FILTERS.find((f) => f.type === "payments" && f.value === filterValues.payments);
+            if (payDef)
+                nextFilters.push(payDef.key);
+        }
+        setActiveFilters(nextFilters);
+        const minPrice = filterValues.minPrice ?? 0;
+        const maxPrice = filterValues.maxPrice === 1000 ? undefined : filterValues.maxPrice;
+        const filterObj = {
+            ...(minPrice > 0 ? { minPrice } : {}),
+            ...(maxPrice !== undefined ? { maxPrice } : {}),
+            ...(filterValues.starRating?.length ? { starRating: filterValues.starRating } : {}),
+            ...(filterValues.boards ? { boards: [filterValues.boards] } : {}),
+            ...(filterValues.payments ? { payments: filterValues.payments } : {}),
+        };
+        const requestBody = {
+            ...searchParams,
+            offset: 0,
+            limit: 20,
+            ...(Object.keys(filterObj).length ? { filter: filterObj } : {}),
+        };
+        filterSearch(requestBody);
+    };
+    const handleGlobalReset = () => {
+        setActiveFilters([]);
+        setPopupValues(null);
+        if (!searchParams || !filterSearch)
+            return;
+        const requestBody = {
+            ...searchParams,
+            offset: 0,
+            limit: 20,
+        };
+        filterSearch(requestBody);
+    };
+    const popupExternalValues = useMemo(() => {
+        const quickValues = derivedValuesFromQuickFilters();
+        return { ...quickValues, ...popupValues };
+    }, [activeFilters, popupValues]);
+    const currentPage = Math.floor(offset / limit) + 1;
+    const totalPages = Math.ceil(total / limit);
+    const handlePageChange = (page) => {
+        fetchPage?.(page);
+    };
+    const handleToggleDescription = (index) => {
+        const updated = [...localOffers];
+        updated[index] = {
+            ...updated[index],
+            showFullDescription: !updated[index].showFullDescription,
+        };
+        setLocalOffers(updated);
+    };
+    const renderHeader = () => (_jsxs(View, { onLayout: (e) => { headerHeightRef.current = e.nativeEvent.layout.height; }, children: [headerComponent, !loadingInitial && hasSearched && (_jsxs(View, { style: styles.topInfoBlock, children: [_jsxs(Text, { style: styles.totalCountText, children: [translations["results_found"] || "Found", " ", isErrorState ? 0 : total || 0, " ", lang === "ru"
+                                ? total === 1
+                                    ? translations["hotel_singular"]
+                                    : total && total < 5
+                                        ? translations["hotel_few"]
+                                        : translations["hotel_many"]
+                                : total === 1
+                                    ? translations["hotel_singular"] || "hotel"
+                                    : translations["hotel_many"] || "hotels"] }), !isStreaming &&
+                        (total > 1 || activeFilters.length > 0 || popupValues !== null) && (_jsx(HotelFilters, { translations: translations, activeFilters: activeFilters, onQuickFilter: handleQuickFilter, onOpenPopup: () => setIsFiltersOpen(true), isPopupOpen: isFiltersOpen, onClosePopup: () => setIsFiltersOpen(false), onApplyFilters: handleApplyAdvancedFilters, onReset: handleGlobalReset, externalValues: popupExternalValues, sessionId: "hotel_session", filters: [
+                            "minprice",
+                            "maxprice",
+                            "price",
+                            "starRating",
+                            "boards",
+                            "payments",
+                        ] }))] })), (loadingInitial || isStreaming) && (_jsx(ProvidersLoader, { active: loading || isStreaming, type: "hotels", translations: translations })), loadingInitial && !isStreaming && _jsx(HotelsSkeleton, { translations: translations }), (isErrorState || isEmptyResult) && !loadingInitial && !loadingRefetch && (_jsx(HotelEmptyState, { translations: translations }))] }));
+    const renderFooter = () => {
+        if (totalPages <= 1 || !hasResults || loadingInitial)
+            return null;
+        return (_jsx(View, { style: styles.paginationWrapper, children: _jsx(Pagination, { currentPage: currentPage, totalPages: totalPages, onPageChange: handlePageChange }) }));
+    };
+    return (_jsxs(View, { style: styles.container, children: [loadingRefetch && (_jsxs(View, { style: styles.overlayLoader, children: [_jsx(ActivityIndicator, { size: "large", color: Colors.primary }), _jsx(Text, { style: styles.overlayText, children: translations["loading"] || "Loading..." })] })), _jsx(FlatList, { ref: listRef, data: !loadingInitial && hasResults && !isErrorState ? localOffers : [], renderItem: ({ item, index }) => (_jsx(HotelList, { offers: [item], translations: translations, lang: lang, onToggleDescription: () => handleToggleDescription(index) })), keyExtractor: (item, index) => String(item.id || item.propertyId || index), ListHeaderComponent: renderHeader(), ListFooterComponent: renderFooter(), contentContainerStyle: styles.listContent, showsVerticalScrollIndicator: false, removeClippedSubviews: true, maxToRenderPerBatch: 10, windowSize: 5 }), showMapButton && (_jsxs(TouchableOpacity, { style: styles.mapButton, onPress: () => setIsMapOpen(true), activeOpacity: 0.8, children: [_jsxs(Svg, { width: 18, height: 18, viewBox: "0 0 24 24", fill: "none", stroke: Colors.white, strokeWidth: 2, strokeLinecap: "round", strokeLinejoin: "round", children: [_jsx(Polygon, { points: "1 6 1 22 8 18 16 22 23 18 23 2 16 6 8 2 1 6" }), _jsx(Line, { x1: 8, y1: 2, x2: 8, y2: 18 }), _jsx(Line, { x1: 16, y1: 6, x2: 16, y2: 22 })] }), _jsx(Text, { style: styles.mapButtonText, children: translations["map_button"] || "Map" })] })), isMapOpen && (_jsxs(View, { style: StyleSheet.absoluteFill, children: [_jsx(HotelMap, { pins: mapPins, allHotels: allHotels || [], streamCompleted: !isStreaming && !loading, loading: loading || isStreaming, translations: translations, lang: lang, searchParams: searchParams, onHotelSelect: (hotelId) => {
+                        }, onRefreshSearch: () => {
+                            if (searchParams && filterSearch) {
+                                filterSearch(searchParams);
+                            }
+                        } }), _jsx(TouchableOpacity, { style: [styles.mapCloseButton, { top: insets.top }], onPress: () => setIsMapOpen(false), activeOpacity: 0.7, children: _jsx(Svg, { width: 16, height: 16, viewBox: "0 0 24 24", fill: "none", children: _jsx(Path, { d: "M18.3 5.71a1 1 0 00-1.41 0L12 10.59 7.11 5.7A1 1 0 105.7 7.11L10.59 12 5.7 16.89a1 1 0 101.41 1.41L12 13.41l4.89 4.89a1 1 0 001.41-1.41L13.41 12l4.89-4.89a1 1 0 000-1.4z", fill: Colors.text }) }) })] }))] }));
+};
+const styles = StyleSheet.create({
+    container: {
+        flex: 1,
+        position: "relative",
+    },
+    overlayLoader: {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        backgroundColor: "rgba(255,255,255,0.7)",
+        zIndex: 10,
+        justifyContent: "center",
+        alignItems: "center",
+    },
+    overlayText: {
+        marginTop: Spacing.sm,
+        fontSize: FontSize.md,
+        color: Colors.textSecondary,
+    },
+    listContent: {
+        paddingBottom: Spacing.lg,
+    },
+    topInfoBlock: {
+        paddingHorizontal: Spacing.lg,
+        paddingVertical: Spacing.md,
+    },
+    totalCountText: {
+        fontSize: FontSize.xxl,
+        fontWeight: "600",
+        color: Colors.text,
+        marginBottom: Spacing.lg,
+    },
+    paginationWrapper: {
+        paddingVertical: Spacing.lg,
+        alignItems: "center",
+    },
+    mapButton: {
+        position: "absolute",
+        bottom: Spacing.xxl,
+        alignSelf: "center",
+        flexDirection: "row",
+        alignItems: "center",
+        gap: Spacing.xs,
+        backgroundColor: Colors.primary,
+        paddingVertical: Spacing.sm + 2,
+        paddingHorizontal: Spacing.lg,
+        borderRadius: BorderRadius.full,
+        elevation: 6,
+        shadowColor: Colors.black,
+        shadowOffset: { width: 0, height: 3 },
+        shadowOpacity: 0.25,
+        shadowRadius: 6,
+    },
+    mapButtonText: {
+        fontSize: FontSize.md,
+        fontWeight: "600",
+        color: Colors.white,
+    },
+    mapCloseButton: {
+        position: "absolute",
+        right: Spacing.md,
+        backgroundColor: Colors.surface,
+        width: 40,
+        height: 40,
+        borderRadius: 20,
+        justifyContent: "center",
+        alignItems: "center",
+        elevation: 6,
+        shadowColor: Colors.black,
+        shadowOffset: { width: 0, height: 2 },
+        shadowOpacity: 0.2,
+        shadowRadius: 4,
+        zIndex: 100,
+    },
+});
+export default HotelResults;

package/dist/modules/search-form/hotel/HotelSearchForm.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { useSearchExpiration } from "../../hooks/useSearchExpiration";
+type HotelSearchFormProps = {
+    translations: Record<string, string>;
+    fetchHotelOffers: (params: any) => Promise<void>;
+    loading?: boolean;
+    onSearchParamsChange?: (params: Record<string, any>) => void;
+    isPreview: boolean;
+    expiration?: ReturnType<typeof useSearchExpiration>;
+    hasSearched?: boolean;
+};
+declare const HotelSearchForm: React.FC<HotelSearchFormProps>;
+export default HotelSearchForm;

package/dist/modules/search-form/hotel/HotelSearchForm.js

@@ -0,0 +1,130 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { View, Text, TouchableOpacity, StyleSheet, ScrollView, ActivityIndicator, } from "react-native";
+import { format, addDays, differenceInCalendarDays, parseISO } from "date-fns";
+import DatePicker from "../flight/DatePicker";
+import NationalityInput from "../NationalityInput";
+import { useWidget } from "../../../context/WidgetContext";
+import HotelLocation from "./HotelLocation";
+import GuestSelector from "./GuestSelector";
+import SearchExpiredPopup from "../../search-form/SearchExpiredPopup";
+import { useSearchExpiration } from "../../hooks/useSearchExpiration";
+import { useDefaultHotelLocation } from "../../hooks/useDefaultHotelLocation";
+import { useDetectNationality } from "../../hooks/useDetectNationality";
+import { Colors } from "../../../theme/colors";
+import { formStyles } from "../../../theme/formStyles";
+const HotelSearchForm = ({ translations, fetchHotelOffers, loading, onSearchParamsChange, isPreview, expiration, hasSearched = false, }) => {
+    const { lang, currency, config, colors } = useWidget();
+    const today = new Date();
+    const defaultCheckin = format(addDays(today, 3), "yyyy-MM-dd");
+    const defaultCheckout = format(addDays(today, 5), "yyyy-MM-dd");
+    const [location, setLocation] = useState(null);
+    const [dates, setDates] = useState([
+        defaultCheckin,
+        defaultCheckout,
+    ]);
+    const [nationality, setNationality] = useState("");
+    const [rooms, setRooms] = useState([{ adults: 2, children: 0 }]);
+    const [formErrors, setFormErrors] = useState({
+        location: "",
+        date: "",
+        nationality: "",
+    });
+    const detectedNationality = useDetectNationality();
+    useEffect(() => {
+        if (!nationality && detectedNationality) {
+            setNationality(detectedNationality);
+        }
+    }, [detectedNationality]);
+    const localExpiration = useSearchExpiration(30);
+    const { isExpired: isSearchExpired, startTimer, ignore: closeSearchPopup, } = expiration || localExpiration;
+    const refreshSearch = () => {
+        startTimer();
+        closeSearchPopup();
+        handleSearch();
+    };
+    const defaultLocationId = config?.defaults?.hotels?.city || null;
+    const { defaultItem, loadingDefault } = useDefaultHotelLocation(defaultLocationId, lang);
+    useEffect(() => {
+        if (defaultItem && defaultItem.id) {
+            setLocation({ id: defaultItem.id });
+        }
+    }, [defaultItem]);
+    const handleSearch = async () => {
+        if (isPreview)
+            return;
+        const dayDiff = differenceInCalendarDays(parseISO(dates[1]), parseISO(dates[0]));
+        const errors = {
+            location: !location?.id
+                ? translations["hotel_form_error_location"] ||
+                    "Select a city or hotel"
+                : "",
+            date: !dates[0]
+                ? translations["hotel_form_error_date"] || "Select stay dates"
+                : dayDiff > 27
+                    ? translations["hotel_form_error_max_nights"] ||
+                        "Stay cannot exceed 28 days"
+                    : "",
+            nationality: !nationality
+                ? translations["hotel_form_error_nationality"] ||
+                    "Specify nationality"
+                : "",
+        };
+        setFormErrors(errors);
+        if (Object.values(errors).some((e) => e))
+            return;
+        const params = {
+            countryCode: nationality,
+            guests: rooms,
+            offset: 0,
+            limit: 20,
+            location: Number(location?.id),
+            checkin: format(parseISO(dates[0]), "dd.MM.yyyy"),
+            checkout: format(parseISO(dates[1]), "dd.MM.yyyy"),
+            lang,
+        };
+        await fetchHotelOffers(params);
+        startTimer();
+        if (onSearchParamsChange)
+            onSearchParamsChange(params);
+    };
+    return (_jsxs(ScrollView, { style: styles.container, showsVerticalScrollIndicator: false, keyboardShouldPersistTaps: "handled", children: [_jsxs(View, { style: [
+                    formStyles.formCard,
+                    { backgroundColor: colors.form || Colors.surface },
+                ], children: [_jsxs(View, { children: [_jsx(HotelLocation, { label: translations["hotel_form_city"] || "City or hotel", value: location?.id || "", onChange: (val) => {
+                                    setLocation(val);
+                                    if (formErrors.location)
+                                        setFormErrors((prev) => ({ ...prev, location: "" }));
+                                }, translations: translations, lang: lang, defaultItem: defaultItem }), formErrors.location ? (_jsx(Text, { style: formStyles.errorText, children: formErrors.location })) : null] }), _jsxs(View, { children: [_jsx(DatePicker, { value: dates, onChange: (val) => {
+                                    setDates(val);
+                                    if (formErrors.date)
+                                        setFormErrors((prev) => ({ ...prev, date: "" }));
+                                    if (val[0] && val[1]) {
+                                        const diff = differenceInCalendarDays(parseISO(val[1]), parseISO(val[0]));
+                                        if (diff > 27) {
+                                            setFormErrors((prev) => ({
+                                                ...prev,
+                                                date: translations["hotel_form_error_max_nights"] ||
+                                                    "Stay cannot exceed 28 days",
+                                            }));
+                                        }
+                                        else {
+                                            setFormErrors((prev) => ({ ...prev, date: "" }));
+                                        }
+                                    }
+                                }, lang: lang, translations: translations, mode: "hotel" }), formErrors.date ? (_jsx(Text, { style: formStyles.errorText, children: formErrors.date })) : null] }), _jsxs(View, { children: [_jsx(NationalityInput, { label: translations["hotel_form_nationality"] || "Nationality", value: nationality, onChange: (val) => {
+                                    setNationality(val);
+                                    if (formErrors.nationality)
+                                        setFormErrors((prev) => ({ ...prev, nationality: "" }));
+                                }, translations: translations, defaultNationality: detectedNationality, defaultNationalities: config?.nationalities || null, lang: lang }), formErrors.nationality ? (_jsx(Text, { style: formStyles.errorText, children: formErrors.nationality })) : null] }), _jsx(GuestSelector, { translations: translations, onChange: setRooms }), _jsx(TouchableOpacity, { style: [
+                            formStyles.searchButton,
+                            { backgroundColor: colors.primary || Colors.primary },
+                            (loading || loadingDefault) && formStyles.searchButtonDisabled,
+                        ], onPress: handleSearch, disabled: loading || loadingDefault, activeOpacity: 0.8, children: loading || loadingDefault ? (_jsxs(View, { style: formStyles.searchButtonContent, children: [_jsx(ActivityIndicator, { size: "small", color: Colors.textOnPrimary }), _jsx(Text, { style: formStyles.searchButtonText, children: translations["hotel_form_searching"] || "Searching..." })] })) : (_jsx(Text, { style: formStyles.searchButtonText, children: translations["hotel_form_search"] || "Search hotels" })) })] }), !isPreview && hasSearched && (_jsx(SearchExpiredPopup, { isOpen: isSearchExpired, onRefresh: refreshSearch, onClose: closeSearchPopup, translations: translations, type: "hotel" }))] }));
+};
+const styles = StyleSheet.create({
+    container: {
+        flex: 1,
+    },
+});
+export default HotelSearchForm;

package/dist/modules/search-form/hotel/HotelsSkeleton.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+type HotelSkeletonProps = {
+    translations: Record<string, string>;
+};
+declare const HotelSkeleton: React.FC<HotelSkeletonProps>;
+export default HotelSkeleton;

package/dist/modules/search-form/hotel/HotelsSkeleton.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { View, StyleSheet } from "react-native";
+import { Skeleton } from "../../../components/ui/Skeleton";
+import { Colors, Spacing, BorderRadius } from "../../../theme/colors";
+const HotelSkeletonCard = () => (_jsxs(View, { style: styles.card, children: [_jsx(Skeleton, { width: "100%", height: 180, borderRadius: 0 }), _jsxs(View, { style: styles.content, children: [_jsx(Skeleton, { width: "70%", height: 18 }), _jsx(View, { style: styles.spacerSm }), _jsx(Skeleton, { width: "40%", height: 12 }), _jsx(View, { style: styles.spacerMd }), _jsx(Skeleton, { width: "100%", height: 12 }), _jsx(View, { style: styles.spacerSm }), _jsx(Skeleton, { width: "80%", height: 12 })] }), _jsxs(View, { style: styles.priceSection, children: [_jsx(Skeleton, { width: "50%", height: 20 }), _jsx(View, { style: styles.spacerSm }), _jsx(Skeleton, { width: "35%", height: 12 }), _jsx(View, { style: styles.spacerMd }), _jsx(Skeleton, { width: "100%", height: 40, borderRadius: BorderRadius.md })] })] }));
+const HotelSkeleton = ({ translations }) => {
+    return (_jsx(View, { style: styles.container, children: [1, 2, 3, 4].map((i) => (_jsx(HotelSkeletonCard, {}, i))) }));
+};
+const styles = StyleSheet.create({
+    container: {
+        paddingVertical: Spacing.md,
+    },
+    card: {
+        backgroundColor: Colors.surface,
+        borderRadius: BorderRadius.lg,
+        marginHorizontal: Spacing.lg,
+        marginBottom: Spacing.md,
+        shadowColor: Colors.black,
+        shadowOffset: { width: 0, height: 2 },
+        shadowOpacity: 0.05,
+        shadowRadius: 4,
+        elevation: 2,
+        overflow: "hidden",
+    },
+    content: {
+        padding: Spacing.md,
+    },
+    priceSection: {
+        borderTopWidth: 1,
+        borderTopColor: Colors.borderLight,
+        padding: Spacing.md,
+    },
+    spacerSm: {
+        height: Spacing.sm,
+    },
+    spacerMd: {
+        height: Spacing.md,
+    },
+});
+export default HotelSkeleton;

package/dist/modules/search-form/hotel/PassengersPicker.d.ts

@@ -0,0 +1,2 @@
+declare const _default: null;
+export default _default;

package/dist/modules/search-form/hotel/PassengersPicker.js

@@ -0,0 +1 @@
+export default null;

package/dist/modules/search-form/hotel/components/HotelCard.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+type HotelCardProps = {
+    hotel: any;
+    index: number;
+    total: number;
+    translations: Record<string, string>;
+    lang: string;
+    onToggleDescription: () => void;
+};
+declare const HotelCard: React.FC<HotelCardProps>;
+export default HotelCard;