medos-sdk 1.0.3 → 1.1.0

package/dist/core/theme/utils.js

@@ -0,0 +1,135 @@
+import { defaultTheme } from "./themes";
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+        if (source.hasOwnProperty(key)) {
+            const sourceValue = source[key];
+            const targetValue = result[key];
+            if (sourceValue &&
+                typeof sourceValue === "object" &&
+                !Array.isArray(sourceValue) &&
+                targetValue &&
+                typeof targetValue === "object" &&
+                !Array.isArray(targetValue)) {
+                result[key] = deepMerge(targetValue, sourceValue);
+            }
+            else if (sourceValue !== undefined) {
+                result[key] = sourceValue;
+            }
+        }
+    }
+    return result;
+}
+export function mergeTheme(partialTheme) {
+    if (!partialTheme) {
+        return defaultTheme;
+    }
+    return deepMerge(defaultTheme, partialTheme);
+}
+function getCssVarName(prefix, category, key) {
+    return `--${prefix}-${category}-${key
+        .replace(/([A-Z])/g, "-$1")
+        .toLowerCase()}`;
+}
+export function generateCssVariables(theme, prefix = "medos") {
+    const vars = [];
+    Object.entries(theme.colors).forEach(([key, value]) => {
+        vars.push(`${getCssVarName(prefix, "color", key)}: ${value};`);
+    });
+    Object.entries(theme.typography).forEach(([key, value]) => {
+        vars.push(`${getCssVarName(prefix, "typography", key)}: ${value};`);
+    });
+    Object.entries(theme.spacing).forEach(([key, value]) => {
+        vars.push(`${getCssVarName(prefix, "spacing", key)}: ${value};`);
+    });
+    Object.entries(theme.shadows).forEach(([key, value]) => {
+        vars.push(`${getCssVarName(prefix, "shadow", key)}: ${value};`);
+    });
+    Object.entries(theme.radii).forEach(([key, value]) => {
+        vars.push(`${getCssVarName(prefix, "radius", key)}: ${value};`);
+    });
+    Object.entries(theme.transitions).forEach(([key, value]) => {
+        vars.push(`${getCssVarName(prefix, "transition", key)}: ${value};`);
+    });
+    return vars.join("\n  ");
+}
+export function generateCssVariablesObject(theme, prefix = "medos") {
+    const vars = {};
+    Object.entries(theme.colors).forEach(([key, value]) => {
+        vars[getCssVarName(prefix, "color", key)] = value;
+    });
+    Object.entries(theme.typography).forEach(([key, value]) => {
+        vars[getCssVarName(prefix, "typography", key)] = value;
+    });
+    Object.entries(theme.spacing).forEach(([key, value]) => {
+        vars[getCssVarName(prefix, "spacing", key)] = value;
+    });
+    Object.entries(theme.shadows).forEach(([key, value]) => {
+        vars[getCssVarName(prefix, "shadow", key)] = value;
+    });
+    Object.entries(theme.radii).forEach(([key, value]) => {
+        vars[getCssVarName(prefix, "radius", key)] = value;
+    });
+    Object.entries(theme.transitions).forEach(([key, value]) => {
+        vars[getCssVarName(prefix, "transition", key)] = value;
+    });
+    return vars;
+}
+export function getCssVar(prefix, category, key, fallback) {
+    const varName = getCssVarName(prefix, category, key);
+    return fallback ? `var(${varName}, ${fallback})` : `var(${varName})`;
+}
+export function injectCssVariables(theme, containerId, prefix = "medos") {
+    if (typeof document === "undefined") {
+        return;
+    }
+    const container = document.getElementById(containerId);
+    if (!container) {
+        console.warn(`Container with id "${containerId}" not found`);
+        return;
+    }
+    const cssVars = generateCssVariablesObject(theme, prefix);
+    Object.entries(cssVars).forEach(([key, value]) => {
+        container.style.setProperty(key, value);
+    });
+}
+export function createThemeStyleTag(theme, prefix = "medos", selector = ":root") {
+    if (typeof document === "undefined") {
+        return null;
+    }
+    const styleId = `${prefix}-theme-vars`;
+    const existingStyle = document.getElementById(styleId);
+    if (existingStyle) {
+        existingStyle.remove();
+    }
+    const styleElement = document.createElement("style");
+    styleElement.id = styleId;
+    styleElement.innerHTML = `
+    ${selector} {
+      ${generateCssVariables(theme, prefix)}
+    }
+  `;
+    document.head.appendChild(styleElement);
+    return styleElement;
+}
+export function validateTheme(theme) {
+    const errors = [];
+    if (!theme || typeof theme !== "object") {
+        errors.push("Theme must be an object");
+        return errors;
+    }
+    const requiredProps = [
+        "colors",
+        "typography",
+        "spacing",
+        "shadows",
+        "radii",
+        "transitions",
+    ];
+    requiredProps.forEach((prop) => {
+        if (!theme[prop] || typeof theme[prop] !== "object") {
+            errors.push(`Theme.${prop} is required and must be an object`);
+        }
+    });
+    return errors;
+}

package/dist/enquiry-form/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./validation";
+export * from "./provider";
+export * from "./serialization";

package/dist/enquiry-form/index.js

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./validation";
+export * from "./provider";
+export * from "./serialization";

package/dist/enquiry-form/provider.d.ts

@@ -0,0 +1,3 @@
+import { Enquiry, EnquirySubmission } from "./types";
+export declare const submitEnquiry: (payload: EnquirySubmission) => Promise<Enquiry>;
+export declare const getEnquiry: (enquiryId: string) => Promise<Enquiry>;

package/dist/enquiry-form/provider.js

@@ -0,0 +1,9 @@
+import { MedosClient } from "../client/MedosClient";
+export const submitEnquiry = async (payload) => {
+    const response = await MedosClient.client.post("/enquiries", payload);
+    return response.data;
+};
+export const getEnquiry = async (enquiryId) => {
+    const response = await MedosClient.client.get(`/enquiries/${enquiryId}`);
+    return response.data;
+};

package/dist/enquiry-form/serialization.d.ts

@@ -0,0 +1,4 @@
+import { Enquiry } from "./types";
+export declare const serializeEnquiry: (enquiry: Enquiry) => string;
+export declare const deserializeEnquiry: (jsonString: string) => Enquiry;
+export declare const roundTripEnquiry: (enquiry: Enquiry) => Enquiry;

package/dist/enquiry-form/serialization.js

@@ -0,0 +1,57 @@
+export const serializeEnquiry = (enquiry) => {
+    if (!enquiry) {
+        throw new Error("Cannot serialize null or undefined enquiry");
+    }
+    try {
+        return JSON.stringify(enquiry);
+    }
+    catch (error) {
+        throw new Error(`Failed to serialize enquiry: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+export const deserializeEnquiry = (jsonString) => {
+    if (!jsonString || typeof jsonString !== "string") {
+        throw new Error("Cannot deserialize null, undefined, or non-string value");
+    }
+    try {
+        const parsed = JSON.parse(jsonString);
+        if (typeof parsed !== "object" || parsed === null) {
+            throw new Error("Deserialized value is not an object");
+        }
+        const requiredFields = [
+            "patientName",
+            "patientEmail",
+            "countryCode",
+            "patientPhone",
+            "inquirySubject",
+            "inquiryMessage",
+            "preferredContactMethod",
+        ];
+        for (const field of requiredFields) {
+            if (!(field in parsed)) {
+                throw new Error(`Missing required field: ${field}`);
+            }
+        }
+        const validContactMethods = ["PHONE", "EMAIL", "BOTH"];
+        if (!validContactMethods.includes(parsed.preferredContactMethod)) {
+            throw new Error(`Invalid preferredContactMethod: ${parsed.preferredContactMethod}`);
+        }
+        if (parsed.status !== undefined && parsed.status !== null) {
+            const validStatuses = ["PENDING", "RESPONDED", "CLOSED"];
+            if (!validStatuses.includes(parsed.status)) {
+                throw new Error(`Invalid status: ${parsed.status}`);
+            }
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON: ${error.message}`);
+        }
+        throw error;
+    }
+};
+export const roundTripEnquiry = (enquiry) => {
+    const serialized = serializeEnquiry(enquiry);
+    return deserializeEnquiry(serialized);
+};

package/dist/enquiry-form/types.d.ts

@@ -0,0 +1,38 @@
+export interface Enquiry {
+    id?: string;
+    patientName: string;
+    patientEmail: string;
+    countryCode: string;
+    patientPhone: string;
+    inquirySubject: string;
+    inquiryMessage: string;
+    preferredContactMethod: "PHONE" | "EMAIL" | "BOTH";
+    createdAt?: string;
+    status?: "PENDING" | "RESPONDED" | "CLOSED";
+}
+export interface EnquiryFormState {
+    step: number;
+    loading: boolean;
+    error: string | null;
+    patientName: string;
+    patientEmail: string;
+    countryCode: string;
+    patientPhone: string;
+    inquirySubject: string;
+    inquiryMessage: string;
+    preferredContactMethod: "PHONE" | "EMAIL" | "BOTH";
+    submitted: boolean;
+}
+export interface EnquirySubmission {
+    patientName: string;
+    patientEmail: string;
+    countryCode: string;
+    patientPhone: string;
+    inquirySubject: string;
+    inquiryMessage: string;
+    preferredContactMethod: "PHONE" | "EMAIL" | "BOTH";
+}
+export interface ValidationResult {
+    isValid: boolean;
+    error?: string;
+}

package/dist/enquiry-form/types.js

@@ -0,0 +1 @@
+export {};

package/dist/enquiry-form/validation.d.ts

@@ -0,0 +1,6 @@
+export declare const validateName: (name: string) => boolean;
+export declare const validateEmail: (email: string) => boolean;
+export declare const validatePhoneNumber: (phone: string) => boolean;
+export declare const validateSubject: (subject: string) => boolean;
+export declare const validateMessage: (message: string) => boolean;
+export declare const validateCountryCode: (code: string) => boolean;

package/dist/enquiry-form/validation.js

@@ -0,0 +1,21 @@
+export const validateName = (name) => {
+    return name.trim().length > 0;
+};
+export const validateEmail = (email) => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+};
+export const validatePhoneNumber = (phone) => {
+    const cleaned = phone.replace(/\D/g, "");
+    return cleaned.length >= 7 && cleaned.length <= 15;
+};
+export const validateSubject = (subject) => {
+    return subject.trim().length > 0;
+};
+export const validateMessage = (message) => {
+    const trimmed = message.trim();
+    return trimmed.length > 0 && trimmed.length <= 1000;
+};
+export const validateCountryCode = (code) => {
+    return /^\+[1-9]\d{0,3}$/.test(code);
+};

package/dist/index.d.ts

@@ -1,7 +1,16 @@
 export { MedosClient } from "./client/MedosClient";
+export * from "./core/theme";
+export { MedosThemeProvider } from "./react/ThemeProvider";
+export type { MedosThemeProviderProps } from "./react/ThemeProvider";
+export { defaultTheme, modernTheme } from "./core/theme/themes";
+export { useTheme, useThemeContext, useCssVar } from "./react/hooks/useTheme";
 export { AppointmentCalender } from "./components/AppointmentCalender";
+export { EnquiryForm } from "./components/EnquiryForm";
+export type { EnquiryFormProps } from "./components/EnquiryForm";
 export * from "./appointments/provider";
 export * from "./appointments/types";
 export * from "./appointment-calendar/provider";
 export * from "./appointment-calendar/types";
+export * from "./enquiry-form/provider";
+export * from "./enquiry-form/types";
 export { PatientService, SendPhoneVerificationOtpPayload, VerifyPhoneVerificationOtpPayload, } from "./services/PatientService";

package/dist/index.js

@@ -1,7 +1,14 @@
 export { MedosClient } from "./client/MedosClient";
+export * from "./core/theme";
+export { MedosThemeProvider } from "./react/ThemeProvider";
+export { defaultTheme, modernTheme } from "./core/theme/themes";
+export { useTheme, useThemeContext, useCssVar } from "./react/hooks/useTheme";
 export { AppointmentCalender } from "./components/AppointmentCalender";
+export { EnquiryForm } from "./components/EnquiryForm";
 export * from "./appointments/provider";
 export * from "./appointments/types";
 export * from "./appointment-calendar/provider";
 export * from "./appointment-calendar/types";
+export * from "./enquiry-form/provider";
+export * from "./enquiry-form/types";
 export { PatientService, } from "./services/PatientService";

package/dist/react/ThemeProvider.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import { MedosTheme, PartialTheme } from "../core/theme/types";
+import { ThemeName } from "../core/theme/themes";
+interface ThemeContextValue {
+    theme: MedosTheme;
+    cssVars: Record<string, string>;
+    prefix: string;
+}
+export interface MedosThemeProviderProps {
+    children: React.ReactNode;
+    theme?: ThemeName | MedosTheme | PartialTheme;
+    cssVariablePrefix?: string;
+}
+export declare function MedosThemeProvider({ children, theme, cssVariablePrefix, }: MedosThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useThemeContext(): ThemeContextValue;
+export declare function useTheme(): MedosTheme;
+export declare function useCssVar(category: string, key: string, fallback?: string): string;
+export {};

package/dist/react/ThemeProvider.js

@@ -0,0 +1,45 @@
+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";
+const ThemeContext = createContext(undefined);
+export function MedosThemeProvider({ children, theme, cssVariablePrefix = "medos", }) {
+    const resolvedTheme = useMemo(() => {
+        if (!theme) {
+            return defaultTheme;
+        }
+        if (typeof theme === "string") {
+            return themes[theme] || defaultTheme;
+        }
+        if ("name" in theme && "colors" in theme && "typography" in theme) {
+            return theme;
+        }
+        return mergeTheme(theme);
+    }, [theme]);
+    const cssVars = useMemo(() => generateCssVariablesObject(resolvedTheme, cssVariablePrefix), [resolvedTheme, cssVariablePrefix]);
+    const contextValue = useMemo(() => ({
+        theme: resolvedTheme,
+        cssVars,
+        prefix: cssVariablePrefix,
+    }), [resolvedTheme, cssVars, cssVariablePrefix]);
+    return (_jsx(ThemeContext.Provider, { value: contextValue, children: _jsx("div", { style: cssVars, children: children }) }));
+}
+export function useThemeContext() {
+    const context = React.useContext(ThemeContext);
+    if (!context) {
+        throw new Error("useThemeContext must be used within a MedosThemeProvider");
+    }
+    return context;
+}
+export function useTheme() {
+    const context = React.useContext(ThemeContext);
+    return context?.theme || defaultTheme;
+}
+export function useCssVar(category, key, fallback) {
+    const context = React.useContext(ThemeContext);
+    const prefix = context?.prefix || "medos";
+    const varName = `--${prefix}-${category}-${key
+        .replace(/([A-Z])/g, "-$1")
+        .toLowerCase()}`;
+    return fallback ? `var(${varName}, ${fallback})` : `var(${varName})`;
+}

package/dist/react/hooks/useTheme.d.ts

@@ -0,0 +1 @@
+export { useTheme, useThemeContext, useCssVar } from "../ThemeProvider";

package/dist/react/hooks/useTheme.js

@@ -0,0 +1 @@
+export { useTheme, useThemeContext, useCssVar } from "../ThemeProvider";

package/dist/react/index.d.ts

@@ -1,2 +1,7 @@
 export * from "../core";
+export { MedosThemeProvider } from "./ThemeProvider";
+export type { MedosThemeProviderProps } from "./ThemeProvider";
+export { useTheme, useThemeContext, useCssVar } from "./hooks/useTheme";
 export { AppointmentCalender } from "../components/AppointmentCalender";
+export { EnquiryForm } from "../components/EnquiryForm";
+export type { EnquiryFormProps } from "../components/EnquiryForm";

package/dist/react/index.js

@@ -1,2 +1,5 @@
 export * from "../core";
+export { MedosThemeProvider } from "./ThemeProvider";
+export { useTheme, useThemeContext, useCssVar } from "./hooks/useTheme";
 export { AppointmentCalender } from "../components/AppointmentCalender";
+export { EnquiryForm } from "../components/EnquiryForm";

package/dist/services/EnquiryService.d.ts

@@ -0,0 +1,5 @@
+import { EnquirySubmission } from "../enquiry-form/types";
+declare const EnquiryService: {
+    submitEnquiry(payload: EnquirySubmission): Promise<any>;
+};
+export { EnquiryService };

package/dist/services/EnquiryService.js

@@ -0,0 +1,30 @@
+import { MedosClient } from "../client/MedosClient";
+const EnquiryService = {
+    async submitEnquiry(payload) {
+        try {
+            const client = await MedosClient.ensureInitialized();
+            const enquiryData = {
+                patientName: payload.patientName,
+                patientEmail: payload.patientEmail,
+                countryCode: payload.countryCode,
+                patientPhone: payload.patientPhone,
+                inquirySubject: payload.inquirySubject,
+                inquiryMessage: payload.inquiryMessage,
+                preferredContactMethod: payload.preferredContactMethod,
+            };
+            const res = await client.post("/enquiries/submit", enquiryData, {
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+            return res.data;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to submit enquiry: ${error.message}`);
+            }
+            throw new Error("Failed to submit enquiry: Unknown error");
+        }
+    },
+};
+export { EnquiryService };

package/dist/vanilla/AppointmentCalendarWidget.js

@@ -26,13 +26,11 @@ class AppointmentCalendarWidget {
         if (this.options.apiKey) {
             await MedosClient.init({
                 apiKey: this.options.apiKey,
-                baseURL: this.options.baseURL,
             });
         }
         else if (this.options.sessionToken) {
             await MedosClient.initWithSession({
                 sessionToken: this.options.sessionToken,
-                baseURL: this.options.baseURL,
             });
         }
         else {

package/dist/vanilla/EnquiryFormWidget.d.ts

@@ -0,0 +1,35 @@
+import { EnquirySubmission } from "../enquiry-form/types";
+interface EnquiryFormWidgetOptions {
+    containerId: string;
+    apiKey?: string;
+    sessionToken?: string;
+    baseURL?: string;
+    onError?: (err: Error) => void;
+    onSuccess?: (enquiry: EnquirySubmission) => void;
+}
+declare class EnquiryFormWidget {
+    private container;
+    private options;
+    private mounted;
+    private state;
+    constructor(container: HTMLElement | string, options: EnquiryFormWidgetOptions);
+    private init;
+    private validateContactStep;
+    private validateInquiryStep;
+    private goToNext;
+    private goBack;
+    private submitEnquiry;
+    private resetForm;
+    private setState;
+    private render;
+    private renderStep;
+    private renderStep0;
+    private renderStep1;
+    private renderStep2;
+    private renderStep3;
+    private attachEventListeners;
+    private escapeHtml;
+    destroy(): void;
+}
+export declare function initEnquiryForm(options: EnquiryFormWidgetOptions): EnquiryFormWidget;
+export { EnquiryFormWidget };