pager-widget 1.0.3 → 1.0.4

package/out/widgetConfigStore2.js

@@ -0,0 +1,569 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useWidgetInitializer = exports.useWidgetData = exports.widgetFetchStore2 = void 0;
+exports.widgetHasData = widgetHasData;
+exports.postWidgetRequest = postWidgetRequest;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const store_1 = require("@xstate/store");
+const react_1 = require("@xstate/store/react");
+const widgetStateHandler_1 = require("./widgetStateHandler");
+function widgetHasData(widget) {
+    return 'data' in widget;
+}
+exports.widgetFetchStore2 = (0, store_1.createStore)({
+    context: {
+        widget: { status: 'NOT_STARTED' },
+    },
+    on: {
+        exitConversation: (context) => {
+            if (context.widget.status === 'ALLOW_MESSAGE') {
+                (0, widgetStateHandler_1.setWidgetLocalState)({
+                    widget_id: context.widget.data.id,
+                    user_state: 'SESSION_EXITED',
+                    events: [{ type: 'SESSION_EXITED' }],
+                });
+                return {
+                    widget: {
+                        status: 'SESSION_EXITED',
+                        config: context.widget.config,
+                        data: context.widget.data,
+                    },
+                };
+            }
+        },
+        processMessage: (context) => {
+            if (context.widget.status === 'FORM_SUBMITTED' ||
+                context.widget.status === 'NO_CONSENT_NEEDED' ||
+                context.widget.status === 'FORM_INPUT_NEEDED') {
+                if (context.widget.data.source_id !== 'new_user' ||
+                    !context.widget.data.source_id.includes('browser')) {
+                    (0, widgetStateHandler_1.setWidgetLocalState)({
+                        widget_id: context.widget.data.id,
+                        user_state: 'ALLOW_MESSAGE',
+                        events: [{ type: 'ALLOW_MESSAGE' }],
+                    });
+                    return {
+                        widget: {
+                            status: 'ALLOW_MESSAGE',
+                            config: context.widget.config,
+                            data: context.widget.data,
+                            form_data: context.widget.status === 'FORM_SUBMITTED'
+                                ? context.widget.form_data
+                                : null,
+                        },
+                    };
+                }
+            }
+        },
+        formSubmitted: (context, event) => {
+            console.log(context, 'form submitted context');
+            if (context.widget.status === 'FORM_INPUT_NEEDED') {
+                return {
+                    widget: {
+                        status: 'FORM_SUBMITTED',
+                        config: context.widget.config,
+                        data: {
+                            ...context.widget.data,
+                            source_id: event.source_id,
+                        },
+                        form_data: context.widget.form_data,
+                    },
+                };
+            }
+        },
+        processFormSubmission: (context, event, enqueueAction) => {
+            if (context.widget.status === 'FORM_INPUT_NEEDED') {
+                const endpoint = context.widget.config.endpoint;
+                const widget_id = context.widget.config.widget_id;
+                const workspace = context.widget.data.workspace;
+                const config = context.widget.config;
+                const form_data = context.widget.form_data;
+                enqueueAction.effect(async () => {
+                    try {
+                        const result = await postWidgetRequest(endpoint, widget_id, workspace, event.submissionPayload);
+                        console.log('CONTEXT', context);
+                        (0, widgetStateHandler_1.setWidgetLocalState)({
+                            widget_id: config.widget_id,
+                            user_state: 'FORM_SUBMITTED',
+                            events: {
+                                type: 'FORM_SUBMITTED',
+                                submissionPayload: event.submissionPayload,
+                                form_data: form_data,
+                            },
+                        });
+                        exports.widgetFetchStore2.trigger.formSubmitted({
+                            source_id: result.source_id,
+                            submissionPayload: event.submissionPayload,
+                        });
+                    }
+                    catch (error) {
+                        console.error('Form submission failed:', error);
+                    }
+                });
+            }
+        },
+        loaded: (_context, event) => {
+            return {
+                widget: {
+                    status: 'WIDGET_LOADED',
+                    config: event.config,
+                    data: event.data,
+                    form_data: event.form_data,
+                },
+            };
+        },
+        setConfig: (context, event, enqueueAction) => {
+            enqueueAction.effect(() => {
+                exports.widgetFetchStore2.trigger.setFetchConfig({
+                    widget_id: event.config.widget_id,
+                    endpoint: event.config.endpoint,
+                });
+            });
+            if (context.widget.status === 'NOT_STARTED') {
+                return {
+                    widget: {
+                        status: 'WIDGET_LOADING',
+                        config: event.config,
+                    },
+                };
+            }
+        },
+        shouldShowForm: (context, event) => {
+            if (context.widget.status === 'CONSENT_GIVEN') {
+                if (context.widget.data.source_id.includes('browser') &&
+                    context.widget.data.lead_form_id == null) {
+                    return {
+                        widget: {
+                            status: 'ALLOW_MESSAGE',
+                            config: context.widget.config,
+                            data: context.widget.data,
+                            form_data: context.widget.form_data,
+                        },
+                    };
+                }
+                if (context.widget.data.source_id.includes('browser') &&
+                    context.widget.form_data) {
+                    console.log('check here..');
+                    (0, widgetStateHandler_1.setWidgetLocalState)({
+                        widget_id: context.widget.data.id,
+                        user_state: 'FORM_INPUT_NEEDED',
+                        events: {
+                            type: 'FORM_INPUT_NEEDED',
+                            form_data: context.widget.form_data,
+                        },
+                    });
+                    return {
+                        widget: {
+                            status: 'FORM_INPUT_NEEDED',
+                            config: context.widget.config,
+                            browser_data: event.browser_data,
+                            data: context.widget.data,
+                            form_data: context.widget.form_data,
+                        },
+                    };
+                }
+            }
+            if (context.widget.status === 'WIDGET_LOADED') {
+                if (context.widget.data.source_id.includes('browser') &&
+                    context.widget.data.lead_form_id === null) {
+                    return {
+                        widget: {
+                            status: 'ALLOW_MESSAGE',
+                            data: context.widget.data,
+                            config: context.widget.config,
+                            form_data: context.widget.form_data,
+                        },
+                    };
+                }
+                if (context.widget.data.source_id.includes('browser') &&
+                    context.widget.form_data) {
+                    // console.log("check here also")
+                    (0, widgetStateHandler_1.setWidgetLocalState)({
+                        widget_id: context.widget.data.id,
+                        user_state: 'FORM_INPUT_NEEDED',
+                        events: {
+                            type: 'FORM_INPUT_NEEDED',
+                            form_data: context.widget.form_data,
+                        },
+                    });
+                    return {
+                        widget: {
+                            status: 'FORM_INPUT_NEEDED',
+                            config: context.widget.config,
+                            data: context.widget.data,
+                            form_data: context.widget.form_data,
+                        },
+                    };
+                }
+            }
+        },
+        consentGiven: (context, event) => {
+            if (context.widget.status === 'CONSENT_NEEDED') {
+                (0, widgetStateHandler_1.setWidgetLocalState)({
+                    widget_id: context.widget?.data?.id,
+                    user_state: 'CONSENT_GIVEN',
+                    events: {
+                        type: 'CONSENT_GIVEN',
+                        submissionPayload: event.submissionPayload,
+                    },
+                });
+                return {
+                    widget: {
+                        status: 'CONSENT_GIVEN',
+                        data: {
+                            ...context.widget.data,
+                            source_id: event.source_id,
+                        },
+                        config: context.widget.config,
+                        browser_data: event.submissionPayload,
+                        form_data: context.widget.form_data,
+                    },
+                };
+            }
+        },
+        processConsent: (context, event, enqueueAction) => {
+            if (context.widget.status === 'CONSENT_NEEDED') {
+                const endpoint = context.widget.config.endpoint;
+                const widget_id = context.widget.data.id;
+                const workspace = context.widget.data.workspace;
+                if (event.consentState === 'DENIED') {
+                    return {
+                        widget: {
+                            status: 'CONSENT_DENIED',
+                            config: context.widget.config,
+                            data: context.widget.data,
+                        },
+                    };
+                }
+                else if (event.consentState === 'GIVEN') {
+                    enqueueAction.effect(async () => {
+                        // await postWidget(
+                        //     endpoint,
+                        //     widget_id,
+                        //     workspace,
+                        //     event.submissionPayload
+                        // ).then(async (res) => {
+                        //     const { source_id } = await res?.json()
+                        //     const submissionPayload =
+                        //         event.submissionPayload as SubmissionPayloadT
+                        //     widgetFetchStore2.trigger.consentGiven({
+                        //         source_id,
+                        //         submissionPayload,
+                        //     })
+                        // })
+                        try {
+                            const result = await postWidgetRequest(endpoint, widget_id, workspace, event?.submissionPayload);
+                            exports.widgetFetchStore2.trigger.consentGiven({
+                                source_id: result.source_id,
+                                submissionPayload: event?.submissionPayload,
+                                current_conversation_id: 'event?.current_conversation_id',
+                            });
+                        }
+                        catch (error) {
+                            console.error('consent submission failed:', error);
+                        }
+                    });
+                }
+            }
+        },
+        setWidgetError: (context, event) => {
+            if (
+            // context.widget.status === 'NOT_STARTED' ||
+            context.widget.status === 'WIDGET_LOADING') {
+                return {
+                    widget: {
+                        status: 'INVALID_STATE',
+                        config: context.widget.config,
+                        error: event.error,
+                    },
+                };
+            }
+        },
+        setFormData: (context, event) => {
+            console.log(event.form_data, 'form data111');
+            if (context.widget.status === 'FORM_INPUT_NEEDED') {
+                (0, widgetStateHandler_1.setWidgetLocalState)({
+                    widget_id: context.widget.data.id,
+                    user_state: 'FORM_INPUT_NEEDED',
+                    events: {
+                        type: 'FORM_INPUT_NEEDED',
+                        form_data: event.form_data,
+                    },
+                });
+                return {
+                    widget: {
+                        status: 'FORM_INPUT_NEEDED',
+                        config: context.widget.config,
+                        form_data: event.form_data,
+                        data: context.widget.data,
+                    },
+                };
+            }
+            if (context.widget.status === 'CONSENT_NEEDED') {
+                return {
+                    widget: {
+                        status: 'CONSENT_NEEDED',
+                        config: context.widget.config,
+                        form_data: event.form_data,
+                        data: context.widget.data,
+                        consent: {
+                            consent_display_data: event.consent_data,
+                        },
+                    },
+                };
+            }
+        },
+        setWidgetData: (context, event, enqueueAction) => {
+            if (context.widget.status === 'WIDGET_LOADING') {
+                const data = event.data;
+                if (data.user_consent === true &&
+                    data?.source_id === 'new_user') {
+                    const endpoint = context.widget.config.endpoint;
+                    const widget_id = data.id;
+                    const workspace = data.workspace;
+                    enqueueAction.effect(async () => {
+                        const result = await getformName(endpoint, workspace, widget_id);
+                        exports.widgetFetchStore2.trigger.setFormData({
+                            form_data: result,
+                            consent_data: data.consent_data,
+                        });
+                    });
+                    console.log('check consent needed');
+                    return {
+                        widget: {
+                            status: 'CONSENT_NEEDED',
+                            config: context.widget.config,
+                            data: event.data,
+                            consent: data?.consent_data,
+                        },
+                    };
+                }
+                else if (data?.user_consent === false &&
+                    data?.lead_form_id !== null) {
+                    const endpoint = context.widget.config.endpoint;
+                    const widget_id = data.id;
+                    const workspace = data.workspace;
+                    enqueueAction.effect(async () => {
+                        const result = await getformName(endpoint, workspace, widget_id);
+                        exports.widgetFetchStore2.trigger.setFormData({
+                            form_data: result,
+                            consent_data: data.consent_data,
+                        });
+                    });
+                    return {
+                        widget: {
+                            status: 'FORM_INPUT_NEEDED',
+                            config: context.widget.config,
+                            data: event.data,
+                        },
+                    };
+                }
+                else if (data?.user_consent === false) {
+                    return {
+                        widget: {
+                            status: 'NO_CONSENT_NEEDED',
+                            config: context.widget.config,
+                            data: event.data,
+                        },
+                    };
+                }
+                else if (data?.user_consent === true &&
+                    data.source_id.includes('browser')) {
+                    const config = context.widget.config;
+                    const endpoint = context.widget.config.endpoint;
+                    const widget_id = data.id;
+                    const workspace = data.workspace;
+                    enqueueAction.effect(async () => {
+                        const result = await getformName(endpoint, workspace, widget_id);
+                        exports.widgetFetchStore2.trigger.loaded({
+                            config: config,
+                            data: event.data,
+                            form_data: result,
+                        });
+                    });
+                }
+                else if (data?.source_id !== 'new_user' ||
+                    !data?.source_id.includes('browser')) {
+                    return {
+                        widget: {
+                            status: 'FORM_SUBMITTED',
+                            config: context.widget.config,
+                            data: data,
+                            form_data: event.form_data,
+                        },
+                    };
+                }
+                // return {
+                //     widget: {
+                //         status: 'WIDGET_LOADING',
+                //         config: context.widget.config,
+                //         data: event.data,
+                //     } as WidgetStoreV2,
+                // }
+            }
+        },
+        setFetchConfig: (_, event, enqueueAction) => {
+            const widgetId = event.widget_id;
+            const endpoint = event.endpoint;
+            enqueueAction.effect(async () => {
+                const result = await fetchWidget(endpoint, widgetId);
+                // ✅ First, check if result has an error before accessing result.data
+                if (result.status === 'error') {
+                    exports.widgetFetchStore2.trigger.setWidgetError({
+                        error: result.error,
+                    });
+                    return;
+                }
+                // ✅ Safe to access result.data now
+                const form_data = await getformName(endpoint, result.data.workspace, result.data.id);
+                exports.widgetFetchStore2.trigger.setWidgetData({
+                    data: result.data,
+                    form_data: form_data,
+                });
+            });
+        },
+        // setFetchConfig: (_, event: WidgetT, enqueueAction) => {
+        //     const widgetId = event.widget_id
+        //     const endpoint = event.endpoint
+        //     enqueueAction.effect(async () => {
+        //         const result = await fetchWidget(endpoint, widgetId)
+        //         const form_data = await getformName(
+        //             endpoint,
+        //             result.data.workspace,
+        //             result.data.id
+        //         )
+        //         if (result.status === 'error') {
+        //             widgetFetchStore2.trigger.setWidgetError({
+        //                 error: result.error,
+        //             })
+        //             return
+        //         }
+        //         widgetFetchStore2.trigger.setWidgetData({
+        //             data: result.data,
+        //             form_data: form_data,
+        //         })
+        //     })
+        // },
+    },
+});
+const useWidgetData = () => (0, react_1.useSelector)(exports.widgetFetchStore2, (state) => {
+    return state.context.widget;
+});
+exports.useWidgetData = useWidgetData;
+const useWidgetInitializer = (config, debug = false) => {
+    console.log(config, 'use initializer', config);
+    // useEffect(() => {
+    // config = {
+    //     endpoint: "https://dev.pagergpt.ai/wgt-hook",
+    //     widget_id: "d79b9a58-0028-45a6-b61e-06cfaffab781"
+    // }
+    console.log(config, 'use initializer', config);
+    exports.widgetFetchStore2.trigger.setConfig({ config });
+    if (debug) {
+        exports.widgetFetchStore2.inspect((inspectionEvent) => {
+            console.log('INSPECTION:: ', inspectionEvent);
+        });
+    }
+    // }, [])
+};
+exports.useWidgetInitializer = useWidgetInitializer;
+const Result = {
+    ok: (a) => {
+        return {
+            status: 'success',
+            data: a,
+        };
+    },
+    err: (error) => {
+        return {
+            status: 'error',
+            error: error,
+        };
+    },
+};
+const fetchWidget = async (endpoint, widgetId) => {
+    try {
+        const response = await fetch(`${endpoint}/public/${widgetId}`, {
+            credentials: 'include',
+        });
+        if (response.ok) {
+            const data = await response.json();
+            const x = Result.ok(data);
+            return x;
+        }
+        else if (response.status === 404) {
+            return Result.err('Given widget does not exist');
+        }
+        else {
+            return Result.err('Somethig went wrong');
+        }
+    }
+    catch (_) {
+        console.error('Fetch error:', _);
+        return Result.err('Fetch error');
+    }
+};
+const getformName = async (endpoint, workspace, widgetId) => {
+    try {
+        const response = await fetch(`${endpoint}/public/${workspace}/${widgetId}/form`);
+        if (response.ok) {
+            const data = await response.json();
+            return data.form_data;
+        }
+        else {
+            return Result.err('Something went wrong');
+        }
+    }
+    catch (error) {
+        console.error('Fetch error:', error);
+        return Result.err('Fetch error');
+    }
+};
+async function postWidgetRequest(endpoint, widgetId, workspace, submissionPayload) {
+    console.log('post widget', endpoint, workspace, widgetId);
+    const url = `${endpoint}/${workspace}/${widgetId}/lead`;
+    const response = await fetch(url, {
+        method: 'POST',
+        credentials: 'include',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(submissionPayload),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`POST failed: ${response.status} - ${errorText}`);
+    }
+    const data = await response.json();
+    if (!data || typeof data.source_id !== 'string') {
+        throw new Error('Invalid response format: source_id missing');
+    }
+    return data;
+}
+// const postWidget = async (
+//     endpoint: string,
+//     widgetId: string,
+//     workspace: string,
+//     submissionPayload:any
+// ) => {
+//     try {
+//         const response = await fetch(
+//             `${endpoint}/${workspace}/${widgetId}/lead`,
+//             {
+//                 method: 'POST',
+//                 credentials: 'include',
+//                 headers: {
+//                     'Content-Type': 'application/json',
+//                 },
+//                 body: JSON.stringify(submissionPayload),
+//             }
+//         )
+//         if (response.ok) {
+//             return response
+//         } else {
+//             throw new Error(`HTTP error! status: ${response.status}`)
+//         }
+//     } catch (error) {
+//         console.error('Error posting widget:', error)
+//     }
+// }

package/out/widgetControlstore.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useWidgetToggle = exports.widgetControlStore = void 0;
+const store_1 = require("@xstate/store");
+const react_1 = require("@xstate/store/react");
+exports.widgetControlStore = (0, store_1.createStore)({
+    context: {
+        widgetToggleState: 'Open',
+        widgetConfig: null,
+    },
+    on: {
+        toggleWidget: (context, event) => ({
+            ...context,
+            widgetToggleState: event.toggleState,
+        }),
+        setConfig: (context, event) => ({
+            ...context,
+            widgetConfig: event.config,
+        }),
+    },
+});
+const useWidgetToggle = () => (0, react_1.useSelector)(exports.widgetControlStore, (state) => state.context.widgetToggleState);
+exports.useWidgetToggle = useWidgetToggle;