medos-sdk 1.1.10 → 1.1.12

package/dist/react/ThemeProvider.js

@@ -2,20 +2,59 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import React, { createContext, useMemo } from "react";
 import { defaultTheme, themes } from "../core/theme/themes";
 import { mergeTheme, generateCssVariablesObject } from "../core/theme/utils";
+import { MedosClient } from "../client/MedosClient";
 const ThemeContext = createContext(undefined);
-export function MedosThemeProvider({ children, theme, cssVariablePrefix = "medos", }) {
-    const resolvedTheme = useMemo(() => {
-        if (!theme) {
-            return defaultTheme;
+export function MedosThemeProvider({ children, theme, cssVariablePrefix = "medos", onThemeError, }) {
+    const [apiTheme, setApiTheme] = React.useState(null);
+    React.useEffect(() => {
+        if (theme !== undefined) {
+            return;
         }
-        if (typeof theme === "string") {
-            return themes[theme] || defaultTheme;
+        let isMounted = true;
+        const fetchThemeFromApi = async () => {
+            try {
+                const fetchedTheme = await MedosClient.fetchTheme();
+                if (isMounted) {
+                    if (fetchedTheme &&
+                        (fetchedTheme === "default" || fetchedTheme === "modern")) {
+                        setApiTheme(fetchedTheme);
+                    }
+                    else {
+                        setApiTheme(null);
+                    }
+                }
+            }
+            catch (error) {
+                if (isMounted) {
+                    if (onThemeError) {
+                        onThemeError(error);
+                    }
+                    else {
+                        console.warn("Failed to fetch theme from API, using default theme:", error);
+                    }
+                }
+            }
+        };
+        fetchThemeFromApi();
+        return () => {
+            isMounted = false;
+        };
+    }, [theme, onThemeError]);
+    const resolvedTheme = useMemo(() => {
+        if (theme !== undefined) {
+            if (typeof theme === "string") {
+                return themes[theme] || defaultTheme;
+            }
+            if ("name" in theme && "colors" in theme && "typography" in theme) {
+                return theme;
+            }
+            return mergeTheme(theme);
         }
-        if ("name" in theme && "colors" in theme && "typography" in theme) {
-            return theme;
+        if (apiTheme) {
+            return themes[apiTheme] || defaultTheme;
         }
-        return mergeTheme(theme);
-    }, [theme]);
+        return defaultTheme;
+    }, [theme, apiTheme]);
     const cssVars = useMemo(() => generateCssVariablesObject(resolvedTheme, cssVariablePrefix), [resolvedTheme, cssVariablePrefix]);
     const contextValue = useMemo(() => ({
         theme: resolvedTheme,

package/dist/react/index.d.ts

@@ -3,6 +3,6 @@ export { MedosThemeProvider } from "./ThemeProvider";
 export type { MedosThemeProviderProps } from "./ThemeProvider";
 export { useTheme, useThemeContext, useCssVar } from "./hooks/useTheme";
 export { AppointmentCalender } from "../components/appointment-booking";
-export type { AppointmentCalenderProps } from "../components/appointment-booking";
-export { EnquiryForm } from "../components/EnquiryForm";
-export type { EnquiryFormProps } from "../components/EnquiryForm";
+export type { AppointmentCalenderProps } from "../components/appointment-booking/types";
+export { EnquiryForm } from "../components/enquiry-form";
+export type { EnquiryFormProps } from "../components/types/enquiry";

package/dist/react/index.js

@@ -2,4 +2,4 @@ export * from "../core";
 export { MedosThemeProvider } from "./ThemeProvider";
 export { useTheme, useThemeContext, useCssVar } from "./hooks/useTheme";
 export { AppointmentCalender } from "../components/appointment-booking";
-export { EnquiryForm } from "../components/EnquiryForm";
+export { EnquiryForm } from "../components/enquiry-form";

package/dist/services/AppointmentService.d.ts

@@ -11,6 +11,7 @@ export type Slot = {
     [key: string]: any;
 };
 type PatientPayload = {
+    id?: number;
     firstName: string;
     lastName: string;
     email?: string;
@@ -18,6 +19,8 @@ type PatientPayload = {
     phoneNumber: string;
     age?: number;
     gender?: "MALE" | "FEMALE" | "OTHER";
+    dob?: string;
+    bloodGroup?: string;
 };
 type PatientAddressPayload = {
     addressLine1: string;
@@ -26,6 +29,11 @@ type PatientAddressPayload = {
     country: string;
     zipcode: string;
     landmark?: string;
+    addressLine2?: string;
+    completeAddress?: string;
+    countryCode?: string;
+    phoneNumber?: string;
+    patientId?: number;
 };
 type BookAppointmentPayload = {
     workspaceId?: string | number;
@@ -35,13 +43,79 @@ type BookAppointmentPayload = {
     appointmentDate: string;
     fromDateTimeTs: string;
     toDateTimeTs: string;
-    consultationCharge?: string;
+    consultationCharge?: string | number;
     type?: "CONSULTATION" | string;
     source?: string;
+    bookingType?: "PACKAGE_PURCHASE" | "ONE_TIME_APPOINTMENT" | "USE_ACTIVE_PACKAGE";
+    paymentMode?: "CASH" | "CARD" | string;
+    packageConfigId?: number;
+    patientPackageId?: number;
+    packageAmount?: number;
     patientPayload: PatientPayload;
     patientAddress: PatientAddressPayload;
     attachments?: File[];
 };
+export type UnifiedBookAppointmentPayload = {
+    workspaceId: number;
+    workspaceAddressId: number;
+    doctorId: number;
+    mode: "ONLINE" | "OFFLINE";
+    appointmentDate: string;
+    fromDateTimeTs: string;
+    toDateTimeTs: string;
+    bookingType: "PACKAGE_PURCHASE" | "ONE_TIME_APPOINTMENT" | "USE_ACTIVE_PACKAGE";
+    consultationCharge: number;
+    packageConfigId?: number;
+    patientPackageId?: number;
+    packageAmount?: number;
+    paymentMode: "CASH" | "CARD" | string;
+    type: "CONSULTATION" | string;
+    source: string;
+    patientPayload: {
+        id?: number;
+        firstName: string;
+        lastName: string;
+        email: string;
+        countryCode: string;
+        phoneNumber: string;
+        dob: string;
+        age: number;
+        gender: "MALE" | "FEMALE" | "OTHER";
+        bloodGroup: string;
+    };
+    patientAddress: {
+        completeAddress: string;
+        addressLine1: string;
+        addressLine2?: string;
+        city: string;
+        state: string;
+        country: string;
+        zipcode: string;
+        landmark?: string;
+        countryCode: string;
+        phoneNumber: string;
+        patientId: number;
+    };
+};
+export type AppointmentResponse = {
+    id: number;
+    patientName: string;
+    patientEmail: string;
+    patientPhone: string;
+    doctorId: number;
+    addressId: number;
+    appointmentDate: string;
+    startTime: string;
+    endTime: string;
+    status: string;
+    consultationCharge: number;
+    paymentMode: string;
+    type: string;
+    mode: string;
+    notes?: string;
+    createdAt: string;
+    [key: string]: any;
+};
 type AppointmentPayload = {
     workspaceId?: string | number;
     workspaceAddressId: string | number;
@@ -78,8 +152,12 @@ type AddressesResponse = {
     addresses: AddressItem[];
 };
 declare const AppointmentService: {
+    arePackagesConfigured(): Promise<boolean>;
     getAddresses(): Promise<AddressesResponse>;
     fetchSlots(workspaceId: number, addressId: number, doctorId: number, appointmentDate: string): Promise<Slot[]>;
-    createAppointment(payload: BookAppointmentPayload): Promise<any>;
+    transformToUnifiedPayload(payload: BookAppointmentPayload): UnifiedBookAppointmentPayload;
+    createLegacyAppointment(payload: BookAppointmentPayload): Promise<AppointmentResponse>;
+    createAppointment(payload: BookAppointmentPayload): Promise<AppointmentResponse>;
+    createUnifiedAppointment(payload: BookAppointmentPayload): Promise<AppointmentResponse>;
 };
 export { AppointmentService, AppointmentPayload, BookAppointmentPayload, PatientPayload, PatientAddressPayload, AddressesResponse, AddressItem, };

package/dist/services/AppointmentService.js

@@ -1,5 +1,17 @@
 import { MedosClient } from "../client/MedosClient";
+import { mapBloodGroupToApi } from "../components/constants/options";
+import { WorkspaceService } from "./WorkspaceService";
 const AppointmentService = {
+    async arePackagesConfigured() {
+        try {
+            const workspace = await WorkspaceService.fetchWorkspace();
+            return workspace.arePackagesConfigured === true;
+        }
+        catch (error) {
+            console.warn("Failed to check package configuration, defaulting to legacy endpoint:", error);
+            return false;
+        }
+    },
     async getAddresses() {
         const client = await MedosClient.ensureInitialized();
         const res = await client.get("/workspaces");
@@ -73,16 +85,99 @@ const AppointmentService = {
         }
         return [];
     },
-    async createAppointment(payload) {
+    transformToUnifiedPayload(payload) {
+        const bookingType = payload.bookingType || "ONE_TIME_APPOINTMENT";
+        if (bookingType === "PACKAGE_PURCHASE" ||
+            bookingType === "USE_ACTIVE_PACKAGE") {
+            if (!payload.packageConfigId) {
+                throw new Error("packageConfigId is required when bookingType is PACKAGE_PURCHASE");
+            }
+            if (!payload.packageAmount) {
+                throw new Error("packageAmount is required when bookingType is PACKAGE_PURCHASE");
+            }
+        }
+        let consultationCharge;
+        if (bookingType === "PACKAGE_PURCHASE" ||
+            bookingType === "USE_ACTIVE_PACKAGE") {
+            consultationCharge = 0;
+        }
+        else {
+            consultationCharge =
+                typeof payload.consultationCharge === "string"
+                    ? Number.parseFloat(payload.consultationCharge) || 0
+                    : payload.consultationCharge || 0;
+        }
+        const completeAddress = [
+            payload.patientAddress.addressLine1,
+            payload.patientAddress.addressLine2,
+            payload.patientAddress.city,
+            payload.patientAddress.state,
+            payload.patientAddress.country,
+            payload.patientAddress.zipcode,
+        ]
+            .filter(Boolean)
+            .join(", ");
+        const unifiedPayload = {
+            workspaceId: Number(payload.workspaceId || 0),
+            workspaceAddressId: Number(payload.workspaceAddressId),
+            doctorId: Number(payload.doctorId),
+            mode: (payload.mode || "OFFLINE"),
+            appointmentDate: payload.appointmentDate,
+            fromDateTimeTs: payload.fromDateTimeTs,
+            toDateTimeTs: payload.toDateTimeTs,
+            bookingType,
+            consultationCharge,
+            paymentMode: payload.paymentMode || "CASH",
+            type: payload.type || "CONSULTATION",
+            source: payload.source || "SDK_POWERED_WEBSITE",
+            patientPayload: {
+                id: payload.patientPayload.id,
+                firstName: payload.patientPayload.firstName,
+                lastName: payload.patientPayload.lastName,
+                email: payload.patientPayload.email || "",
+                countryCode: payload.patientPayload.countryCode,
+                phoneNumber: payload.patientPayload.phoneNumber,
+                dob: payload.patientPayload.dob || "",
+                age: payload.patientPayload.age || 0,
+                gender: (payload.patientPayload.gender || "OTHER"),
+                bloodGroup: payload.patientPayload.bloodGroup
+                    ? mapBloodGroupToApi(payload.patientPayload.bloodGroup)
+                    : "UNKNOWN",
+            },
+            patientAddress: {
+                completeAddress,
+                addressLine1: payload.patientAddress.addressLine1,
+                addressLine2: payload.patientAddress.addressLine2,
+                city: payload.patientAddress.city,
+                state: payload.patientAddress.state,
+                country: payload.patientAddress.country,
+                zipcode: payload.patientAddress.zipcode,
+                landmark: payload.patientAddress.landmark,
+                countryCode: payload.patientAddress.countryCode || "",
+                phoneNumber: payload.patientAddress.phoneNumber || "",
+                patientId: payload.patientAddress.patientId || 0,
+            },
+        };
+        if (bookingType === "PACKAGE_PURCHASE" ||
+            bookingType === "USE_ACTIVE_PACKAGE") {
+            unifiedPayload.packageConfigId = payload.packageConfigId;
+            unifiedPayload.packageAmount = payload.packageAmount;
+        }
+        if (payload.patientPackageId) {
+            unifiedPayload.patientPackageId = payload.patientPackageId;
+        }
+        return unifiedPayload;
+    },
+    async createLegacyAppointment(payload) {
         const client = await MedosClient.ensureInitialized();
-        const appointmentData = {
+        const legacyPayload = {
             workspaceAddressId: payload.workspaceAddressId,
             doctorId: payload.doctorId,
             mode: payload.mode || "OFFLINE",
             appointmentDate: payload.appointmentDate,
             fromDateTimeTs: payload.fromDateTimeTs,
             toDateTimeTs: payload.toDateTimeTs,
-            consultationCharge: payload.consultationCharge || "0",
+            consultationCharge: payload.consultationCharge,
             type: payload.type || "CONSULTATION",
             source: payload.source || "SDK_POWERED_WEBSITE",
             patientPayload: payload.patientPayload,
@@ -90,7 +185,7 @@ const AppointmentService = {
         };
         if (payload.attachments && payload.attachments.length > 0) {
             const formData = new FormData();
-            const payloadString = JSON.stringify(appointmentData);
+            const payloadString = JSON.stringify(legacyPayload);
             formData.append("payload", payloadString);
             payload.attachments.forEach((file) => {
                 formData.append("attachments", file);
@@ -99,7 +194,38 @@ const AppointmentService = {
             return res.data;
         }
         else {
-            const res = await client.post("/appointments/book-appointment", appointmentData, {
+            const res = await client.post("/appointments/book-appointment", legacyPayload, {
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+            return res.data;
+        }
+    },
+    async createAppointment(payload) {
+        const packagesConfigured = await this.arePackagesConfigured();
+        if (packagesConfigured) {
+            return this.createUnifiedAppointment(payload);
+        }
+        else {
+            return this.createLegacyAppointment(payload);
+        }
+    },
+    async createUnifiedAppointment(payload) {
+        const client = await MedosClient.ensureInitialized();
+        const unifiedPayload = this.transformToUnifiedPayload(payload);
+        if (payload.attachments && payload.attachments.length > 0) {
+            const formData = new FormData();
+            const payloadString = JSON.stringify(unifiedPayload);
+            formData.append("payload", payloadString);
+            payload.attachments.forEach((file) => {
+                formData.append("attachments", file);
+            });
+            const res = await client.post("/appointments/book-appointment-unified", formData);
+            return res.data;
+        }
+        else {
+            const res = await client.post("/appointments/book-appointment-unified", unifiedPayload, {
                 headers: {
                     "Content-Type": "application/json",
                 },

package/dist/services/AuthService.js

@@ -1,5 +1,5 @@
 import axios from "axios";
-import { API_BASE_URL } from "../constants";
+import { API_BASE_URL } from "../components";
 let sessionToken = null;
 const AuthService = {
     async init(apiKey) {

package/dist/services/WorkspaceService.d.ts

@@ -1,9 +1,64 @@
-interface WorkspaceResponse {
+import { ThemeName } from "../core/theme/themes";
+interface Address {
+    id: number;
+    createdAt: string;
+    deleted: boolean;
+    createdAtEpoch: number;
+    completeAddress: string;
+    addressLine1: string;
+    addressLine2: string;
+    city: string;
+    state: string;
+    country: string;
+    zipcode: string;
+    landmark: string;
+    phoneNumber: string;
+    latitude: number;
+    longitude: number;
+    userId: number;
+}
+interface ConsultationType {
+    fee: number;
+    currency: string;
+    type: string;
+}
+interface User {
     id: number;
-    name?: string;
+    createdAt: string;
+    lastUpdatedAt: string;
+    deleted: boolean;
+    createdAtEpoch: number;
+    lastUpdatedAtEpoch: number;
+    firstName: string;
+    lastName: string;
+    email: string;
+    gender: string;
+    countryCode: string;
+    phoneNumber: string;
+    platform: string;
+    isKycCompleted: boolean;
+}
+interface Doctor {
+    consultationTypes: ConsultationType[];
+    user: User;
+}
+interface AddressDoctor {
+    address: Address;
+    doctors: Doctor[];
+    doctorCount: number;
+}
+interface WorkspaceResponse {
+    totalDoctors: number;
+    totalAddresses: number;
+    addressDoctors: AddressDoctor[];
+    workspaceId: number;
+    theme?: ThemeName;
+    arePackagesConfigured?: boolean;
     [key: string]: any;
 }
 declare const WorkspaceService: {
     fetchWorkspace(): Promise<WorkspaceResponse>;
+    fetchTheme(): Promise<ThemeName | undefined>;
 };
-export { WorkspaceService, WorkspaceResponse };
+export { WorkspaceService };
+export type { WorkspaceResponse, Address, ConsultationType, User, Doctor, AddressDoctor, };

package/dist/services/WorkspaceService.js

@@ -4,7 +4,7 @@ const WorkspaceService = {
         try {
             const client = await MedosClient.ensureInitialized();
             const res = await client.get("/workspaces");
-            if (!res.data || typeof res.data.id !== "number") {
+            if (!res.data || typeof res.data.workspaceId !== "number") {
                 throw new Error("Invalid workspace response");
             }
             return res.data;
@@ -13,5 +13,14 @@ const WorkspaceService = {
             throw new Error(`Failed to fetch workspace: ${error.message}`);
         }
     },
+    async fetchTheme() {
+        try {
+            const workspace = await this.fetchWorkspace();
+            return workspace.theme;
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch workspace theme: ${error.message}`);
+        }
+    },
 };
 export { WorkspaceService };

package/dist/vanilla/AppointmentCalendarWidget.d.ts

@@ -25,6 +25,7 @@ declare class AppointmentCalendarWidget {
     private loadSlots;
     private canProceedFromMergedStep;
     private updateSubmitButtonState;
+    private updatePatientDetailsButtonState;
     private sendOtp;
     private verifyOtp;
     private submitAppointment;
@@ -35,18 +36,27 @@ declare class AppointmentCalendarWidget {
     private render;
     private initializeCustomComponents;
     private renderStep;
-    private renderStep0;
-    private renderStep1;
-    private renderStep2;
-    private renderStep3;
-    private renderStep4;
-    private renderSuccessIcon;
+    private renderPhoneVerificationStep;
+    private renderBookingOptionStep;
+    private renderPackageExplorerStep;
+    private renderLocationDoctorStep;
+    private renderNewAppointmentStep;
+    private renderPatientSelectionStep;
+    private renderPatientDetailsStep;
+    private renderAppointmentSummaryStep;
+    private renderSuccessStep;
     private formatDate;
     private formatTime;
     private calculateDuration;
-    private renderStep5;
     private attachEventListeners;
+    private getPlaceholderPatients;
     private escapeHtml;
+    private isValidDateOfBirth;
+    private isValidBloodGroup;
+    private safeMapBloodGroupToApi;
+    private safeFormatDateOfBirth;
+    private getDateOfBirthErrorMessage;
+    private displayFieldValidationError;
     destroy(): void;
 }
 export declare function initAppointmentCalendar(options: AppointmentCalendarWidgetOptions): AppointmentCalendarWidget;