@myrjfa/state 0.3.1

package/dist/lib/context/ChatContext.js

@@ -0,0 +1,445 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useRef, useState, } from "react";
+import { useAtomValue } from "jotai";
+import { getSocket } from "../actions/socket";
+import { chatApi, normalizeChatMessage, } from "../actions/chat";
+import { chatActorKey, isSameChatActor, } from "../models/chat";
+import { userAtom } from "../userAtom";
+const emptyContext = {
+    socket: null,
+    isConnected: false,
+    conversations: [],
+    activeConversation: null,
+    setActiveConversation: () => undefined,
+    messages: [],
+    setMessages: () => undefined,
+    typingUsers: new Map(),
+    onlineUsers: new Set(),
+    refreshConversations: async () => undefined,
+    sendMessage: async () => undefined,
+    createPoll: () => undefined,
+    votePoll: async () => null,
+    updatePoll: async () => null,
+    editMessage: () => undefined,
+    toggleMessageReaction: () => undefined,
+    deleteMessage: () => undefined,
+    markRead: () => undefined,
+    unreadNotificationCount: 0,
+    notifications: [],
+    clearNotifications: () => undefined,
+    eventRevision: 0,
+    paymentRevision: 0,
+};
+const ChatContext = createContext(emptyContext);
+export const useChatContext = () => useContext(ChatContext);
+export function ChatProvider({ children }) {
+    const user = useAtomValue(userAtom);
+    const actorId = user?._id || user?.id || "";
+    const accountType = user?.accountType || user?.role;
+    const actorModel = accountType === "host" ? "HostProfile" : "User";
+    const [isConnected, setIsConnected] = useState(false);
+    const [conversations, setConversations] = useState([]);
+    const [activeConversation, setActiveConversationState] = useState(null);
+    const activeConversationRef = useRef(null);
+    const [messages, setMessages] = useState([]);
+    const [typingUsers, setTypingUsers] = useState(new Map());
+    const [onlineUsers, setOnlineUsers] = useState(new Set());
+    const [unreadNotificationCount, setUnreadNotificationCount] = useState(0);
+    const [notifications, setNotifications] = useState([]);
+    const [eventRevision, setEventRevision] = useState(0);
+    const [paymentRevision, setPaymentRevision] = useState(0);
+    const socketRef = useRef(null);
+    const conversationListParamsRef = useRef({ filter: "all" });
+    const setActiveConversation = useCallback((conversation) => {
+        setActiveConversationState(conversation);
+        activeConversationRef.current = conversation;
+    }, []);
+    const refreshConversations = useCallback(async (params) => {
+        if (params)
+            conversationListParamsRef.current = params;
+        const data = await chatApi.getConversations(params || conversationListParamsRef.current);
+        setConversations(data);
+        const activeId = activeConversationRef.current?._id;
+        if (activeId) {
+            const refreshed = data.find((conversation) => conversation._id === activeId);
+            if (refreshed)
+                setActiveConversation(refreshed);
+        }
+    }, [setActiveConversation]);
+    const sendMessage = useCallback(async (conversationId, text, files, replyTo, options) => {
+        const trimmed = text.trim();
+        let media = [];
+        if (files?.length) {
+            const formData = new FormData();
+            files.forEach((file) => formData.append("files", file));
+            const upload = await chatApi.uploadFiles(formData);
+            media = upload?.data?.files || [];
+            if (!media.length)
+                throw new Error("Unable to upload attachments");
+        }
+        if (!trimmed && !media.length)
+            return;
+        const socket = socketRef.current;
+        if (socket?.connected) {
+            await new Promise((resolve, reject) => {
+                socket.emit("message:send", {
+                    conversationId,
+                    text: trimmed,
+                    replyTo,
+                    media,
+                    type: options?.type || (media.length ? "media" : "text"),
+                    mentions: options?.mentions || [],
+                }, (result) => {
+                    if (result?.success)
+                        resolve();
+                    else
+                        reject(new Error(result?.error?.message || "Unable to send message"));
+                });
+            });
+            return;
+        }
+        const message = await chatApi.sendMessage(conversationId, {
+            text: trimmed,
+            replyTo,
+            media,
+            type: options?.type || (media.length ? "media" : "text"),
+            mentions: options?.mentions || [],
+        });
+        if (message) {
+            setMessages((current) => current.some((item) => item._id === message._id)
+                ? current
+                : [...current, message]);
+            await refreshConversations();
+        }
+    }, [refreshConversations]);
+    const editMessage = useCallback(async (messageId, text) => {
+        if (socketRef.current?.connected) {
+            socketRef.current.emit("message:edit", { messageId, text });
+            return;
+        }
+        const message = await chatApi.editMessage(messageId, text);
+        if (message) {
+            setMessages((current) => current.map((item) => (item._id === message._id ? message : item)));
+        }
+    }, []);
+    const createPoll = useCallback(async (conversationId, question, options, allowMultiple) => {
+        const response = await chatApi.createPoll(conversationId, { question, options, allowMultiple });
+        if (response.data) {
+            const message = normalizeChatMessage(response.data);
+            setMessages((current) => current.some((item) => item._id === message._id) ? current : [...current, message]);
+            await refreshConversations();
+        }
+    }, [refreshConversations]);
+    const votePoll = useCallback(async (pollId, optionIndex) => {
+        const response = await chatApi.votePoll(pollId, optionIndex);
+        return response.data || null;
+    }, []);
+    const updatePoll = useCallback(async (pollId, data) => {
+        const response = await chatApi.updatePoll(pollId, data);
+        return response.data || null;
+    }, []);
+    const toggleMessageReaction = useCallback(async (messageId, emoji) => {
+        if (socketRef.current?.connected) {
+            socketRef.current.emit("message:react", {
+                messageId,
+                emoji: emoji || "",
+            });
+            return;
+        }
+        const message = await chatApi.addReaction(messageId, emoji || "");
+        if (message) {
+            setMessages((current) => current.map((item) => (item._id === message._id ? message : item)));
+        }
+    }, []);
+    const deleteMessage = useCallback(async (messageId) => {
+        if (socketRef.current?.connected) {
+            socketRef.current.emit("message:delete", { messageId });
+            return;
+        }
+        const message = await chatApi.deleteMessage(messageId);
+        if (message) {
+            setMessages((current) => current.map((item) => (item._id === message._id ? message : item)));
+        }
+    }, []);
+    const markRead = useCallback(async (conversationId, messageIds) => {
+        if (!messageIds.length || !actorId)
+            return;
+        const readAt = new Date().toISOString();
+        setMessages((current) => current.map((message) => message.conversationId === conversationId && messageIds.includes(message._id) &&
+            !message.readBy.some((receipt) => isSameChatActor(receipt, { actorId, actorModel }))
+            ? {
+                ...message,
+                readBy: [
+                    ...message.readBy,
+                    { actorId, actorModel, readAt },
+                ],
+            }
+            : message));
+        setConversations((current) => current.map((conversation) => conversation._id === conversationId
+            ? {
+                ...conversation,
+                participants: conversation.participants.map((participant) => isSameChatActor(participant, { actorId, actorModel })
+                    ? {
+                        ...participant,
+                        unreadCount: Math.max(0, participant.unreadCount - messageIds.length),
+                    }
+                    : participant),
+                preference: {
+                    ...conversation.preference,
+                    markedUnreadAt: null,
+                },
+            }
+            : conversation));
+        if (socketRef.current?.connected) {
+            socketRef.current.emit("message:read", {
+                conversationId,
+                messageIds,
+            });
+            return;
+        }
+        await chatApi.markRead(conversationId, messageIds);
+        await refreshConversations();
+    }, [actorId, actorModel, refreshConversations]);
+    const clearNotifications = useCallback(() => {
+        setNotifications([]);
+        setUnreadNotificationCount(0);
+    }, []);
+    useEffect(() => {
+        const socket = socketRef.current;
+        const conversationId = activeConversation?._id;
+        if (!socket || !conversationId || conversationId.startsWith("draft_")) {
+            return;
+        }
+        socket.emit("conversation:join", { conversationId });
+        return () => {
+            socket.emit("conversation:leave", { conversationId });
+        };
+    }, [activeConversation?._id]);
+    useEffect(() => {
+        if (!user || !actorId || accountType === "staff") {
+            setIsConnected(false);
+            setConversations([]);
+            return;
+        }
+        const socket = getSocket();
+        socketRef.current = socket;
+        const onConnect = () => {
+            setIsConnected(true);
+            void refreshConversations();
+            const activeId = activeConversationRef.current?._id;
+            if (activeId && !activeId.startsWith("draft_")) {
+                socket.emit("conversation:join", { conversationId: activeId });
+            }
+        };
+        const onDisconnect = () => {
+            setIsConnected(false);
+            setOnlineUsers(new Set());
+            setTypingUsers(new Map());
+        };
+        const onNewMessage = (payload) => {
+            const message = normalizeChatMessage(payload.message);
+            if (activeConversationRef.current?._id === payload.conversationId) {
+                setMessages((current) => current.some((item) => item._id === message._id)
+                    ? current
+                    : [...current, message]);
+            }
+            if (!isSameChatActor({ actorId: message.senderId, actorModel: message.senderModel }, { actorId, actorModel })) {
+                socketRef.current?.emit("message:delivered", { messageId: message._id });
+            }
+            void refreshConversations();
+        };
+        const onDelivered = ({ messageId, actorId: deliveredActorId, actorModel: deliveredActorModel, deliveredAt, }) => {
+            setMessages((current) => current.map((message) => message._id === messageId && !(message.deliveredTo || []).some((receipt) => isSameChatActor(receipt, {
+                actorId: deliveredActorId,
+                actorModel: deliveredActorModel,
+            }))
+                ? {
+                    ...message,
+                    deliveredTo: [
+                        ...(message.deliveredTo || []),
+                        {
+                            actorId: deliveredActorId,
+                            actorModel: deliveredActorModel,
+                            deliveredAt,
+                        },
+                    ],
+                }
+                : message));
+        };
+        const onUpdatedMessage = ({ message: rawMessage }) => {
+            const message = normalizeChatMessage(rawMessage);
+            setMessages((current) => current.map((item) => (item._id === message._id ? message : item)));
+        };
+        const onRead = ({ conversationId, actorId: readerId, actorModel: readerModel, messageIds, readAt, }) => {
+            const readMessageIds = new Set(messageIds);
+            setMessages((current) => current.map((message) => message.conversationId === conversationId &&
+                readMessageIds.has(message._id) &&
+                !message.readBy.some((receipt) => isSameChatActor(receipt, {
+                    actorId: readerId,
+                    actorModel: readerModel,
+                }))
+                ? {
+                    ...message,
+                    readBy: [
+                        ...message.readBy,
+                        { actorId: readerId, actorModel: readerModel, readAt },
+                    ],
+                    deliveredTo: (message.deliveredTo || []).some((receipt) => isSameChatActor(receipt, {
+                        actorId: readerId,
+                        actorModel: readerModel,
+                    }))
+                        ? message.deliveredTo
+                        : [
+                            ...(message.deliveredTo || []),
+                            {
+                                actorId: readerId,
+                                actorModel: readerModel,
+                                deliveredAt: readAt,
+                            },
+                        ],
+                }
+                : message));
+        };
+        const onTypingStart = ({ conversationId, actorId: typingActorId, actorModel: typingActorModel, }) => {
+            const typingActorKey = chatActorKey({
+                actorId: typingActorId,
+                actorModel: typingActorModel,
+            });
+            setTypingUsers((current) => {
+                const next = new Map(current);
+                const users = next.get(conversationId) || [];
+                if (!users.includes(typingActorKey)) {
+                    next.set(conversationId, [...users, typingActorKey]);
+                }
+                return next;
+            });
+        };
+        const onTypingStop = ({ conversationId, actorId: typingActorId, actorModel: typingActorModel, }) => {
+            const typingActorKey = chatActorKey({
+                actorId: typingActorId,
+                actorModel: typingActorModel,
+            });
+            setTypingUsers((current) => {
+                const next = new Map(current);
+                next.set(conversationId, (next.get(conversationId) || []).filter((item) => item !== typingActorKey));
+                return next;
+            });
+        };
+        const onPresenceOnline = ({ actorId: onlineId, actorModel: onlineModel, }) => {
+            setOnlineUsers((current) => new Set(current).add(chatActorKey({
+                actorId: onlineId,
+                actorModel: onlineModel,
+            })));
+        };
+        const onPresenceOffline = ({ actorId: offlineId, actorModel: offlineModel, }) => {
+            setOnlineUsers((current) => {
+                const next = new Set(current);
+                next.delete(chatActorKey({
+                    actorId: offlineId,
+                    actorModel: offlineModel,
+                }));
+                return next;
+            });
+        };
+        const onNotification = (notification) => {
+            setNotifications((current) => [notification, ...current].slice(0, 50));
+            setUnreadNotificationCount((current) => current + 1);
+        };
+        const onPreferenceUpdated = ({ conversationId, preference, }) => {
+            setConversations((current) => current.map((conversation) => conversation._id === conversationId
+                ? { ...conversation, preference }
+                : conversation));
+            if (activeConversationRef.current?._id === conversationId) {
+                setActiveConversation({
+                    ...activeConversationRef.current,
+                    preference,
+                });
+            }
+        };
+        const onConversationMetadataChanged = () => {
+            void refreshConversations();
+        };
+        const onConversationEventChanged = () => {
+            setEventRevision((current) => current + 1);
+        };
+        const onParticipantsChanged = () => {
+            void refreshConversations();
+        };
+        const onPaymentChanged = () => {
+            setPaymentRevision((current) => current + 1);
+            void refreshConversations();
+        };
+        socket.on("connect", onConnect);
+        socket.on("disconnect", onDisconnect);
+        socket.on("message:new", onNewMessage);
+        socket.on("message:delivered", onDelivered);
+        socket.on("message:updated", onUpdatedMessage);
+        socket.on("message:read", onRead);
+        socket.on("typing:start", onTypingStart);
+        socket.on("typing:stop", onTypingStop);
+        socket.on("presence:online", onPresenceOnline);
+        socket.on("presence:offline", onPresenceOffline);
+        socket.on("notification", onNotification);
+        socket.on("conversation:preference.updated", onPreferenceUpdated);
+        socket.on("message:pinned", onConversationMetadataChanged);
+        socket.on("message:unpinned", onConversationMetadataChanged);
+        socket.on("conversation:event.created", onConversationEventChanged);
+        socket.on("conversation:event.updated", onConversationEventChanged);
+        socket.on("conversation:event.deleted", onConversationEventChanged);
+        socket.on("conversation:event.rsvp", onConversationEventChanged);
+        socket.on("conversation:participants.updated", onParticipantsChanged);
+        socket.on("conversation:payment.updated", onPaymentChanged);
+        if (!socket.connected)
+            socket.connect();
+        else
+            onConnect();
+        return () => {
+            socket.off("connect", onConnect);
+            socket.off("disconnect", onDisconnect);
+            socket.off("message:new", onNewMessage);
+            socket.off("message:delivered", onDelivered);
+            socket.off("message:updated", onUpdatedMessage);
+            socket.off("message:read", onRead);
+            socket.off("typing:start", onTypingStart);
+            socket.off("typing:stop", onTypingStop);
+            socket.off("presence:online", onPresenceOnline);
+            socket.off("presence:offline", onPresenceOffline);
+            socket.off("notification", onNotification);
+            socket.off("conversation:preference.updated", onPreferenceUpdated);
+            socket.off("message:pinned", onConversationMetadataChanged);
+            socket.off("message:unpinned", onConversationMetadataChanged);
+            socket.off("conversation:event.created", onConversationEventChanged);
+            socket.off("conversation:event.updated", onConversationEventChanged);
+            socket.off("conversation:event.deleted", onConversationEventChanged);
+            socket.off("conversation:event.rsvp", onConversationEventChanged);
+            socket.off("conversation:participants.updated", onParticipantsChanged);
+            socket.off("conversation:payment.updated", onPaymentChanged);
+        };
+    }, [accountType, actorId, actorModel, refreshConversations]);
+    return (_jsx(ChatContext.Provider, { value: {
+            socket: socketRef.current,
+            isConnected,
+            conversations,
+            activeConversation,
+            setActiveConversation,
+            messages,
+            setMessages,
+            typingUsers,
+            onlineUsers,
+            refreshConversations,
+            sendMessage,
+            editMessage,
+            toggleMessageReaction,
+            deleteMessage,
+            markRead,
+            createPoll,
+            votePoll,
+            updatePoll,
+            unreadNotificationCount,
+            notifications,
+            clearNotifications,
+            eventRevision,
+            paymentRevision,
+        }, children: children }));
+}

package/dist/lib/data/adventureDummyData.d.ts

@@ -0,0 +1,3 @@
+import { TileProps } from "../models/tile";
+export declare const adventureDummyData: TileProps[];
+//# sourceMappingURL=adventureDummyData.d.ts.map

package/dist/lib/data/adventureDummyData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adventureDummyData.d.ts","sourceRoot":"","sources":["../../../src/lib/data/adventureDummyData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,eAAO,MAAM,kBAAkB,EAAE,SAAS,EAqJzC,CAAC"}

package/dist/lib/data/adventureDummyData.js

@@ -0,0 +1,138 @@
+export const adventureDummyData = [
+    {
+        slug: "rishikesh-river-rafting-grade4",
+        image: "https://images.pexels.com/photos/1497582/pexels-photo-1497582.jpeg",
+        title: "Rishikesh Grade 4 River Rafting",
+        description: "Conquer the mighty Ganges on a thrilling Grade 4 rafting run through rapids like Golf Course and The Wall.",
+        location: "Rishikesh, Uttarakhand",
+        date: new Date("2025-03-01"),
+        rating: 4.8,
+        price: 850,
+        currency: "INR",
+        tileType: "adventures",
+        duration: 3,
+        host: {
+            name: "Himalayan Rush",
+            image: "https://images.pexels.com/photos/1722198/pexels-photo-1722198.jpeg",
+        },
+    },
+    {
+        slug: "bir-billing-paragliding",
+        image: "https://images.pexels.com/photos/1365425/pexels-photo-1365425.jpeg",
+        title: "Bir Billing Paragliding",
+        description: "Soar above the Kangra Valley from the world's second-highest paragliding site. Tandem flight with certified pilot.",
+        location: "Bir, Himachal Pradesh",
+        date: new Date("2025-04-10"),
+        rating: 4.9,
+        price: 2500,
+        currency: "INR",
+        tileType: "adventures",
+        duration: 2,
+        host: {
+            name: "Sky Riders India",
+            image: "https://images.pexels.com/photos/733872/pexels-photo-733872.jpeg",
+        },
+    },
+    {
+        slug: "kedarkantha-winter-trek",
+        image: "https://images.pexels.com/photos/618833/pexels-photo-618833.jpeg",
+        title: "Kedarkantha Summit Trek",
+        description: "Trek through oak and rhododendron forests to a 12,500 ft snow-covered peak. Camping under the stars included.",
+        location: "Sankri, Uttarakhand",
+        date: new Date("2025-01-15"),
+        rating: 4.7,
+        price: 6500,
+        currency: "INR",
+        tileType: "adventures",
+        duration: 36,
+        host: {
+            name: "Trek The Himalayas",
+            image: "https://images.pexels.com/photos/1681010/pexels-photo-1681010.jpeg",
+        },
+    },
+    {
+        slug: "scuba-diving-andaman",
+        image: "https://images.pexels.com/photos/3231384/pexels-photo-3231384.jpeg",
+        title: "Scuba Diving – Andaman",
+        description: "Discover vibrant coral reefs and exotic marine life at Neil Island. Intro dive for beginners with PADI instructors.",
+        location: "Neil Island, Andaman",
+        date: new Date("2025-02-20"),
+        rating: 4.6,
+        price: 3200,
+        currency: "INR",
+        tileType: "adventures",
+        duration: 3,
+        host: {
+            name: "Andaman Divers",
+            image: "https://images.pexels.com/photos/415829/pexels-photo-415829.jpeg",
+        },
+    },
+    {
+        slug: "bungee-jumping-rishikesh",
+        image: "https://images.pexels.com/photos/1271619/pexels-photo-1271619.jpeg",
+        title: "83m Bungee Jump – Rishikesh",
+        description: "Leap from India's highest fixed bungee platform into the gorge below. Safety briefing and gear provided.",
+        location: "Rishikesh, Uttarakhand",
+        date: new Date("2025-03-05"),
+        rating: 4.5,
+        price: 3550,
+        currency: "INR",
+        tileType: "adventures",
+        duration: 1,
+        host: {
+            name: "Jumping Heights",
+            image: "https://images.pexels.com/photos/2379005/pexels-photo-2379005.jpeg",
+        },
+    },
+    {
+        slug: "rann-of-kutch-camping",
+        image: "https://images.pexels.com/photos/2422265/pexels-photo-2422265.jpeg",
+        title: "Rann of Kutch Desert Camp",
+        description: "Spend nights under a blanket of stars on the white salt desert. Guided cultural tour and folk music included.",
+        location: "Bhuj, Gujarat",
+        date: new Date("2025-11-20"),
+        rating: 4.4,
+        price: 4200,
+        currency: "INR",
+        tileType: "adventures",
+        duration: 20,
+        host: {
+            name: "Desert Trails",
+            image: "https://images.pexels.com/photos/774909/pexels-photo-774909.jpeg",
+        },
+    },
+    {
+        slug: "rock-climbing-hampi",
+        image: "https://images.pexels.com/photos/209841/pexels-photo-209841.jpeg",
+        title: "Rock Climbing – Hampi Boulders",
+        description: "Scale Hampi's iconic granite boulders with certified instructors. Suitable for beginners to intermediate climbers.",
+        location: "Hampi, Karnataka",
+        date: new Date("2025-01-25"),
+        rating: 4.3,
+        price: 1200,
+        currency: "INR",
+        tileType: "adventures",
+        duration: 4,
+        host: {
+            name: "Hampi Climbers",
+            image: "https://images.pexels.com/photos/697509/pexels-photo-697509.jpeg",
+        },
+    },
+    {
+        slug: "kaziranga-jungle-safari",
+        image: "https://images.pexels.com/photos/247431/pexels-photo-247431.jpeg",
+        title: "Kaziranga Elephant Safari",
+        description: "Spot the one-horned rhino on an early morning elephant safari through UNESCO-listed Kaziranga National Park.",
+        location: "Kaziranga, Assam",
+        date: new Date("2025-02-10"),
+        rating: 4.8,
+        price: 1800,
+        currency: "INR",
+        tileType: "adventures",
+        duration: 2,
+        host: {
+            name: "Wild Assam",
+            image: "https://images.pexels.com/photos/1545743/pexels-photo-1545743.jpeg",
+        },
+    },
+];

package/dist/lib/data/adventureFormPage.d.ts

@@ -0,0 +1,28 @@
+import { createSinglePricing } from "../models/pricing";
+export type AdventureFormState = {
+    hostId: string;
+    title: string;
+    description: string;
+    activityType: string;
+    difficulty: string;
+    duration: string;
+    city: string;
+    state: string;
+    address: string;
+    meetingPoint: string;
+    pricing: ReturnType<typeof createSinglePricing>;
+    maxGroupSize: string;
+    minAge: string;
+    bestSeason: string;
+    safetyInfo: string;
+    highlightsRaw: string;
+    includedRaw: string;
+    excludedRaw: string;
+    gearRaw: string;
+    operatingHoursStart: string;
+    operatingHoursEnd: string;
+    status: string;
+};
+export declare function getDefaultAdventureFormState(): AdventureFormState;
+export declare function hydrateAdventureForm(adventure: any): AdventureFormState;
+//# sourceMappingURL=adventureFormPage.d.ts.map

package/dist/lib/data/adventureFormPage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adventureFormPage.d.ts","sourceRoot":"","sources":["../../../src/lib/data/adventureFormPage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;IAChD,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAgB,4BAA4B,IAAI,kBAAkB,CA8BjE;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,GAAG,GAAG,kBAAkB,CAyBvE"}

package/dist/lib/data/adventureFormPage.js

@@ -0,0 +1,58 @@
+import { createSinglePricing } from "../models/pricing";
+export function getDefaultAdventureFormState() {
+    return {
+        hostId: "",
+        title: "",
+        description: "",
+        activityType: "trekking",
+        difficulty: "Moderate",
+        duration: "3",
+        city: "",
+        state: "",
+        address: "",
+        meetingPoint: "",
+        pricing: createSinglePricing({
+            currency: "INR",
+            finalBasePrice: 1500,
+            basePrice: 1500,
+            description: "Standard admission",
+        }),
+        maxGroupSize: "10",
+        minAge: "12",
+        bestSeason: "Year round",
+        safetyInfo: "",
+        highlightsRaw: "",
+        includedRaw: "",
+        excludedRaw: "",
+        gearRaw: "",
+        operatingHoursStart: "09:00",
+        operatingHoursEnd: "18:00",
+        status: "open",
+    };
+}
+export function hydrateAdventureForm(adventure) {
+    return {
+        hostId: typeof adventure.hostId === "string" ? adventure.hostId : adventure.hostId?.username || "",
+        title: adventure.title || "",
+        description: adventure.description || "",
+        activityType: adventure.activityType || "trekking",
+        difficulty: adventure.difficulty || "Moderate",
+        duration: String(adventure.duration || 3),
+        city: adventure.city || "",
+        state: adventure.state || "",
+        address: adventure.address || "",
+        meetingPoint: adventure.meetingPoint || "",
+        pricing: createSinglePricing(adventure?.pricing?.pricingStrategies?.[0] ?? { currency: "INR", finalBasePrice: 0 }),
+        maxGroupSize: String(adventure.maxGroupSize || 10),
+        minAge: String(adventure.minAge || 12),
+        bestSeason: adventure.bestSeason || "Year round",
+        safetyInfo: adventure.safetyInfo || "",
+        highlightsRaw: (adventure.highlights || []).join("\n"),
+        includedRaw: (adventure.included || []).join("\n"),
+        excludedRaw: (adventure.excluded || []).join("\n"),
+        gearRaw: (adventure.gear || []).join("\n"),
+        operatingHoursStart: adventure.operatingHours?.start || "09:00",
+        operatingHoursEnd: adventure.operatingHours?.end || "18:00",
+        status: adventure.status || "open",
+    };
+}