medos-sdk 1.1.9 → 1.1.11

package/dist/components/appointment-booking/hooks/useAppointmentFlow.js

@@ -0,0 +1,318 @@
+import { useCallback } from "react";
+import { AppointmentService } from "../../../services/AppointmentService";
+import { PatientService } from "../../../services/PatientService";
+import { validatePhoneNumber, validateCountryCode, } from "../../../components/validation";
+import { formatDateToISO, parsePatientName } from "../../../components/utils";
+export const useAppointmentFlow = (state, dispatch, onError) => {
+    const goBack = useCallback(() => {
+        if (state.step === 2) {
+            dispatch({ type: "SET_OTP_SENT", payload: false });
+            dispatch({ type: "SET_OTP_CODE", payload: "" });
+            dispatch({ type: "SET_OTP_VERIFIED", payload: false });
+            dispatch({ type: "SET_STEP", payload: 1 });
+        }
+        else if (state.step === 3) {
+            dispatch({ type: "SET_STEP", payload: 2 });
+        }
+        else if (state.step === 4) {
+            if (state.verifiedPatients && state.verifiedPatients.length > 0) {
+                dispatch({ type: "SET_STEP", payload: 3 });
+            }
+            else {
+                dispatch({ type: "SET_STEP", payload: 2 });
+            }
+        }
+        else {
+            dispatch({ type: "SET_STEP", payload: Math.max(0, state.step - 1) });
+        }
+    }, [state.step, state.verifiedPatients, dispatch]);
+    const handleDateChange = useCallback(async (date) => {
+        dispatch({ type: "SET_SELECTED_DATE", payload: date });
+        if (!state.workspaceId ||
+            !state.selectedAddress ||
+            !state.selectedDoctor) {
+            dispatch({ type: "SET_SLOTS", payload: [] });
+            return;
+        }
+        let mounted = true;
+        dispatch({ type: "SET_LOADING", payload: true });
+        dispatch({ type: "SET_ERROR", payload: null });
+        try {
+            const dateStr = formatDateToISO(date);
+            const fetchedSlots = await AppointmentService.fetchSlots(state.workspaceId, state.selectedAddress, state.selectedDoctor, dateStr);
+            if (mounted) {
+                dispatch({ type: "SET_SLOTS", payload: fetchedSlots || [] });
+            }
+        }
+        catch (e) {
+            if (mounted) {
+                const msg = e.message || "Failed to load slots";
+                dispatch({ type: "SET_ERROR", payload: msg });
+                onError?.(e);
+            }
+        }
+        finally {
+            if (mounted)
+                dispatch({ type: "SET_LOADING", payload: false });
+        }
+        return () => {
+            mounted = false;
+        };
+    }, [
+        state.workspaceId,
+        state.selectedAddress,
+        state.selectedDoctor,
+        dispatch,
+        onError,
+    ]);
+    const sendOtp = useCallback(async () => {
+        dispatch({ type: "SET_ERROR", payload: null });
+        if (!state.countryCode) {
+            dispatch({ type: "SET_ERROR", payload: "Please enter country code." });
+            return;
+        }
+        if (!validateCountryCode(state.countryCode)) {
+            dispatch({
+                type: "SET_ERROR",
+                payload: "Please enter a valid country code (e.g., +91, +1).",
+            });
+            return;
+        }
+        if (!state.patientPhone) {
+            dispatch({ type: "SET_ERROR", payload: "Please enter phone number." });
+            return;
+        }
+        if (!validatePhoneNumber(state.patientPhone)) {
+            dispatch({
+                type: "SET_ERROR",
+                payload: "Please enter a valid phone number (7-15 digits).",
+            });
+            return;
+        }
+        dispatch({ type: "SET_OTP_SENDING", payload: true });
+        try {
+            await PatientService.sendPhoneVerificationOtp({
+                countryCode: state.countryCode,
+                phoneNumber: state.patientPhone,
+            });
+            dispatch({ type: "SET_OTP_SENT", payload: true });
+            dispatch({ type: "SET_ERROR", payload: null });
+        }
+        catch (e) {
+            const msg = e.message || "Failed to send OTP";
+            dispatch({ type: "SET_ERROR", payload: msg });
+            onError?.(e);
+        }
+        finally {
+            dispatch({ type: "SET_OTP_SENDING", payload: false });
+        }
+    }, [state.countryCode, state.patientPhone, dispatch, onError]);
+    const verifyOtp = useCallback(async () => {
+        dispatch({ type: "SET_ERROR", payload: null });
+        if (!state.countryCode || !state.patientPhone || !state.otpCode) {
+            dispatch({
+                type: "SET_ERROR",
+                payload: "Please enter all required fields.",
+            });
+            return;
+        }
+        if (state.otpCode.length !== 6) {
+            dispatch({
+                type: "SET_ERROR",
+                payload: "Please enter a 6-digit OTP code.",
+            });
+            return;
+        }
+        dispatch({ type: "SET_OTP_VERIFYING", payload: true });
+        try {
+            const response = await PatientService.verifyPhoneVerificationOtp({
+                countryCode: state.countryCode,
+                phoneNumber: state.patientPhone,
+                otpCode: state.otpCode,
+            });
+            dispatch({ type: "SET_OTP_VERIFIED", payload: true });
+            dispatch({ type: "SET_ERROR", payload: null });
+            const sessionPacksDetails = response.sessionPacksDetails;
+            if (sessionPacksDetails?.associatedPatients &&
+                sessionPacksDetails.associatedPatients.length > 0) {
+                dispatch({
+                    type: "SET_VERIFIED_PATIENTS",
+                    payload: sessionPacksDetails.associatedPatients,
+                });
+            }
+            else if (response.patients && response.patients.length > 0) {
+                dispatch({ type: "SET_VERIFIED_PATIENTS", payload: response.patients });
+            }
+            else {
+                dispatch({ type: "SET_VERIFIED_PATIENTS", payload: [] });
+            }
+            if (sessionPacksDetails?.activeSessionPackResponses &&
+                sessionPacksDetails.activeSessionPackResponses.length > 0) {
+                const userSessionPacks = sessionPacksDetails.activeSessionPackResponses.map((pack) => ({
+                    id: pack.id,
+                    name: pack.packageName || pack.name,
+                    description: pack.description,
+                    totalSessions: pack.totalSessions,
+                    remainingSessions: pack.remainingSessions,
+                    expiryDate: pack.expiryDate,
+                    purchaseDate: pack.purchaseDate,
+                    doctorId: pack.doctorId,
+                    doctorName: pack.doctorName,
+                    allowedConsultationModes: pack.allowedConsultationModes,
+                }));
+                dispatch({ type: "SET_USER_SESSION_PACKS", payload: userSessionPacks });
+            }
+            else {
+                dispatch({ type: "SET_USER_SESSION_PACKS", payload: [] });
+            }
+            if (sessionPacksDetails?.allSessionPackResponses &&
+                sessionPacksDetails.allSessionPackResponses.length > 0) {
+                const availablePackages = sessionPacksDetails.allSessionPackResponses.map((pack) => ({
+                    id: pack.id,
+                    name: pack.packageName,
+                    description: pack.description,
+                    totalSessions: pack.totalSessions,
+                    sessions: pack.totalSessions,
+                    price: pack.packagePrice,
+                    discountedPrice: pack.discountedPrice,
+                    discount: pack.discount,
+                    discountType: pack.discountType,
+                    currency: "INR",
+                    validityDays: pack.validityDays,
+                    allowedConsultationModes: pack.allowedConsultationModes,
+                    allowedDoctors: pack.allowedDoctors,
+                    applicableOnline: pack.allowedConsultationModes?.includes("ONLINE"),
+                    applicableOffline: pack.allowedConsultationModes?.includes("OFFLINE"),
+                }));
+                dispatch({
+                    type: "SET_AVAILABLE_PACKAGES",
+                    payload: availablePackages,
+                });
+            }
+            else {
+                dispatch({ type: "SET_AVAILABLE_PACKAGES", payload: [] });
+            }
+        }
+        catch (e) {
+            const msg = e.message || "Invalid OTP code";
+            dispatch({ type: "SET_ERROR", payload: msg });
+            onError?.(e);
+        }
+        finally {
+            dispatch({ type: "SET_OTP_VERIFYING", payload: false });
+        }
+    }, [state.countryCode, state.patientPhone, state.otpCode, dispatch, onError]);
+    const submitAppointment = useCallback(async () => {
+        dispatch({ type: "SET_ERROR", payload: null });
+        if (!state.selectedDoctor ||
+            !state.selectedSlot ||
+            !state.workspaceId ||
+            !state.selectedAddress) {
+            dispatch({
+                type: "SET_ERROR",
+                payload: "Please ensure all required fields are complete.",
+            });
+            return;
+        }
+        if (!state.otpVerified) {
+            dispatch({
+                type: "SET_ERROR",
+                payload: "Please verify your phone number first.",
+            });
+            return;
+        }
+        if (!state.patientName || !state.patientAge || !state.patientGender) {
+            dispatch({
+                type: "SET_ERROR",
+                payload: "Please fill in all patient details.",
+            });
+            return;
+        }
+        if (!state.patientAddress ||
+            !state.patientCity ||
+            !state.patientState ||
+            !state.patientCountry ||
+            !state.patientZipcode) {
+            dispatch({
+                type: "SET_ERROR",
+                payload: "Please fill in all address fields.",
+            });
+            return;
+        }
+        dispatch({ type: "SET_LOADING", payload: true });
+        try {
+            const { firstName, lastName } = parsePatientName(state.patientName);
+            const appointmentDate = formatDateToISO(state.selectedDate);
+            const patientPayload = {
+                firstName,
+                lastName,
+                countryCode: state.countryCode,
+                phoneNumber: state.patientPhone,
+                age: Number.parseInt(state.patientAge, 10),
+                gender: state.patientGender.toUpperCase(),
+            };
+            if (state.patientEmail) {
+                patientPayload.email = state.patientEmail;
+            }
+            if (state.bloodGroup) {
+                patientPayload.bloodGroup = state.bloodGroup;
+            }
+            if (state.useExistingPatient && state.selectedPatient) {
+                patientPayload.id = state.selectedPatient.id;
+            }
+            const appointmentPayload = {
+                workspaceId: state.workspaceId,
+                workspaceAddressId: state.selectedAddress,
+                doctorId: state.selectedDoctor,
+                mode: state.consultationMode,
+                appointmentDate: appointmentDate,
+                fromDateTimeTs: state.selectedSlot.start,
+                toDateTimeTs: state.selectedSlot.end,
+                consultationCharge: state.consultationCharge || "0",
+                type: "CONSULTATION",
+                source: "SDK_POWERED_WEBSITE",
+                bookingType: state.bookingType,
+                paymentMode: state.paymentMode,
+                patientPayload,
+                patientAddress: {
+                    addressLine1: state.patientAddress,
+                    addressLine2: "",
+                    city: state.patientCity,
+                    state: state.patientState,
+                    country: state.patientCountry,
+                    zipcode: state.patientZipcode,
+                    landmark: state.patientLandmark || undefined,
+                    countryCode: state.countryCode,
+                    phoneNumber: state.patientPhone,
+                    patientId: state.selectedPatient?.id || 0,
+                },
+            };
+            if (state.packageConfigId) {
+                appointmentPayload.packageConfigId = state.packageConfigId;
+            }
+            if (state.patientPackageId) {
+                appointmentPayload.patientPackageId = state.patientPackageId;
+            }
+            if (state.packageAmount) {
+                appointmentPayload.packageAmount = state.packageAmount;
+            }
+            await AppointmentService.createAppointment(appointmentPayload);
+            dispatch({ type: "SET_STEP", payload: 7 });
+        }
+        catch (e) {
+            const msg = e.message || "Failed to create appointment";
+            dispatch({ type: "SET_ERROR", payload: msg });
+            onError?.(e);
+        }
+        finally {
+            dispatch({ type: "SET_LOADING", payload: false });
+        }
+    }, [state, dispatch, onError]);
+    return {
+        goBack,
+        handleDateChange,
+        sendOtp,
+        verifyOtp,
+        submitAppointment,
+    };
+};

package/dist/components/appointment-booking/hooks/useAppointmentState.d.ts

@@ -0,0 +1,9 @@
+import { AppointmentState, AppointmentAction } from "../types";
+export declare const useAppointmentState: () => {
+    state: AppointmentState;
+    dispatch: import("react").Dispatch<AppointmentAction>;
+    setStep: (step: number) => void;
+    setError: (error: string | null) => void;
+    setLoading: (loading: boolean) => void;
+    resetForm: () => void;
+};

package/dist/components/appointment-booking/hooks/useAppointmentState.js

@@ -0,0 +1,125 @@
+import { useReducer, useCallback } from "react";
+import { INITIAL_STATE } from "../types";
+const appointmentReducer = (state, action) => {
+    switch (action.type) {
+        case "SET_STEP":
+            return { ...state, step: action.payload };
+        case "SET_LOADING":
+            return { ...state, loading: action.payload };
+        case "SET_ERROR":
+            return { ...state, error: action.payload };
+        case "SET_WORKSPACE": {
+            const doctorMap = {};
+            action.payload.addresses.forEach((addr) => {
+                doctorMap[addr.id] = addr.doctors || [];
+            });
+            return {
+                ...state,
+                workspaceId: action.payload.id,
+                addresses: action.payload.addresses,
+                addressDoctorsMap: doctorMap,
+            };
+        }
+        case "SET_SELECTED_ADDRESS":
+            return { ...state, selectedAddress: action.payload };
+        case "SET_SELECTED_DOCTOR":
+            return { ...state, selectedDoctor: action.payload };
+        case "SET_SELECTED_DATE":
+            return { ...state, selectedDate: action.payload, selectedSlot: null };
+        case "SET_SLOTS":
+            return { ...state, slots: action.payload };
+        case "SET_SELECTED_SLOT":
+            return { ...state, selectedSlot: action.payload };
+        case "SET_CONSULTATION_MODE":
+            return { ...state, consultationMode: action.payload };
+        case "SET_CONSULTATION_CHARGE":
+            return { ...state, consultationCharge: action.payload };
+        case "SET_PATIENT_NAME":
+            return { ...state, patientName: action.payload };
+        case "SET_PATIENT_AGE":
+            return { ...state, patientAge: action.payload };
+        case "SET_PATIENT_EMAIL":
+            return { ...state, patientEmail: action.payload };
+        case "SET_PATIENT_GENDER":
+            return { ...state, patientGender: action.payload };
+        case "SET_BLOOD_GROUP":
+            return { ...state, bloodGroup: action.payload };
+        case "SET_PATIENT_ADDRESS":
+            return { ...state, patientAddress: action.payload };
+        case "SET_PATIENT_CITY":
+            return { ...state, patientCity: action.payload };
+        case "SET_PATIENT_STATE":
+            return { ...state, patientState: action.payload };
+        case "SET_PATIENT_COUNTRY":
+            return { ...state, patientCountry: action.payload };
+        case "SET_PATIENT_ZIPCODE":
+            return { ...state, patientZipcode: action.payload };
+        case "SET_PATIENT_LANDMARK":
+            return { ...state, patientLandmark: action.payload };
+        case "SET_COUNTRY_CODE":
+            return { ...state, countryCode: action.payload };
+        case "SET_PATIENT_PHONE":
+            return { ...state, patientPhone: action.payload };
+        case "SET_OTP_CODE":
+            return { ...state, otpCode: action.payload };
+        case "SET_OTP_SENT":
+            return { ...state, otpSent: action.payload };
+        case "SET_OTP_VERIFIED":
+            return { ...state, otpVerified: action.payload };
+        case "SET_OTP_SENDING":
+            return { ...state, otpSending: action.payload };
+        case "SET_OTP_VERIFYING":
+            return { ...state, otpVerifying: action.payload };
+        case "SET_VERIFIED_PATIENTS":
+            return { ...state, verifiedPatients: action.payload };
+        case "SET_SELECTED_PATIENT":
+            return { ...state, selectedPatient: action.payload };
+        case "SET_USE_EXISTING_PATIENT":
+            return { ...state, useExistingPatient: action.payload };
+        case "SET_USER_SESSION_PACKS":
+            return { ...state, userSessionPacks: action.payload };
+        case "SET_AVAILABLE_PACKAGES":
+            return { ...state, availablePackages: action.payload };
+        case "SET_SELECTED_SESSION_PACK":
+            return { ...state, selectedSessionPack: action.payload };
+        case "SET_SELECTED_NEW_PACKAGE":
+            return { ...state, selectedNewPackage: action.payload };
+        case "SET_BOOKING_OPTION_TYPE":
+            return { ...state, bookingOptionType: action.payload };
+        case "SET_SHOW_PACKAGE_EXPLORER":
+            return { ...state, showPackageExplorer: action.payload };
+        case "SET_PACKAGES_LOADING":
+            return { ...state, packagesLoading: action.payload };
+        case "SET_BOOKING_TYPE":
+            return { ...state, bookingType: action.payload };
+        case "SET_PAYMENT_MODE":
+            return { ...state, paymentMode: action.payload };
+        case "SET_PACKAGE_CONFIG_ID":
+            return { ...state, packageConfigId: action.payload };
+        case "SET_PATIENT_PACKAGE_ID":
+            return { ...state, patientPackageId: action.payload };
+        case "SET_PACKAGE_AMOUNT":
+            return { ...state, packageAmount: action.payload };
+        case "SET_PATIENT_DOB":
+            return { ...state, patientDob: action.payload };
+        case "RESET_FORM":
+            return INITIAL_STATE;
+        default:
+            return state;
+    }
+};
+export const useAppointmentState = () => {
+    const [state, dispatch] = useReducer(appointmentReducer, INITIAL_STATE);
+    const setStep = useCallback((step) => dispatch({ type: "SET_STEP", payload: step }), []);
+    const setError = useCallback((error) => dispatch({ type: "SET_ERROR", payload: error }), []);
+    const setLoading = useCallback((loading) => dispatch({ type: "SET_LOADING", payload: loading }), []);
+    const resetForm = useCallback(() => dispatch({ type: "RESET_FORM" }), []);
+    return {
+        state,
+        dispatch,
+        setStep,
+        setError,
+        setLoading,
+        resetForm,
+    };
+};

package/dist/components/appointment-booking/hooks/useInitializeAddresses.d.ts

@@ -0,0 +1 @@
+export declare const useInitializeAddresses: (dispatch: React.Dispatch<any>, onError?: (error: Error) => void) => void;

package/dist/components/appointment-booking/hooks/useInitializeAddresses.js

@@ -0,0 +1,55 @@
+import { useEffect } from "react";
+import { AppointmentService } from "../../../services/AppointmentService";
+export const useInitializeAddresses = (dispatch, onError) => {
+    useEffect(() => {
+        let mounted = true;
+        (async () => {
+            dispatch({ type: "SET_LOADING", payload: true });
+            dispatch({ type: "SET_ERROR", payload: null });
+            try {
+                const response = await AppointmentService.getAddresses();
+                if (!mounted)
+                    return;
+                if (response.workspaceId && response.addresses?.length > 0) {
+                    dispatch({
+                        type: "SET_WORKSPACE",
+                        payload: {
+                            id: response.workspaceId,
+                            addresses: response.addresses,
+                        },
+                    });
+                    if (response.addresses.length === 1) {
+                        const address = response.addresses[0];
+                        dispatch({ type: "SET_SELECTED_ADDRESS", payload: address.id });
+                        if (address.doctors?.length === 1) {
+                            dispatch({
+                                type: "SET_SELECTED_DOCTOR",
+                                payload: address.doctors[0].id,
+                            });
+                        }
+                    }
+                }
+                else {
+                    dispatch({
+                        type: "SET_ERROR",
+                        payload: "No addresses or doctors available.",
+                    });
+                }
+            }
+            catch (e) {
+                if (!mounted)
+                    return;
+                const msg = e.message || "Failed to load addresses";
+                dispatch({ type: "SET_ERROR", payload: msg });
+                onError?.(e);
+            }
+            finally {
+                if (mounted)
+                    dispatch({ type: "SET_LOADING", payload: false });
+            }
+        })();
+        return () => {
+            mounted = false;
+        };
+    }, [dispatch, onError]);
+};

package/dist/components/appointment-booking/index.d.ts

@@ -0,0 +1,5 @@
+export { AppointmentCalender } from "./AppointmentCalender";
+export type { AppointmentCalenderProps } from "./AppointmentCalender";
+export { useAppointmentState, useAppointmentFlow, useInitializeAddresses, } from "./hooks";
+export type { AppointmentState, AppointmentAction } from "./types";
+export { INITIAL_STATE } from "./types";

package/dist/components/appointment-booking/index.js

@@ -0,0 +1,3 @@
+export { AppointmentCalender } from "./AppointmentCalender";
+export { useAppointmentState, useAppointmentFlow, useInitializeAddresses, } from "./hooks";
+export { INITIAL_STATE } from "./types";