@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/api_handler/api_handler.js

@@ -0,0 +1,730 @@
+import { __webpack_require__ } from "../../js/runtime.js";
+import { createForm } from "../../src/embedded_forms/QualifiedEmbeddedForm.js";
+import { tryGet } from "../../src/utils.js";
+import { default as DebugModeState } from "../debug_mode_state.js";
+import { armFormCtaBookerIntent } from "../form_cta_booker_intent.js";
+import { QualifiedFormApi } from "../qualified_form/qualified_form_api.js";
+import "../telemetry/index.js";
+import { widgetBootstrap } from "../widget_bootstrap.js";
+import { PARDOT_EMAIL_SELECTOR, default as base_api_handler } from "./base_api_handler.js";
+import "../utils/native_globals.js";
+import { parseQueryParams } from "../../src/query_params.js";
+import { _extends } from "../../js/4101.js";
+import { withTelemetryCtx } from "../telemetry/telemetry.js";
+
+/* provided dependency */ var __nativeWindowAddEventListener = __webpack_require__(68034).zh;
+
+
+
+
+
+
+
+
+
+
+const START_CALL_STATES = [
+    "open",
+    "maximized",
+    "minimized"
+];
+/**
+ * Allowed API verbs that can be triggered via URL query parameters.
+ * Each key is the verb name (the query param will be `q_<verb>`).
+ * An optional `schema` defines how to parse the param value into typed options.
+ */ const ALLOWED_URL_VERBS = {
+    showExperience: {
+        dict: false,
+        params: [
+            {
+                name: "botApiName",
+                type: "string"
+            }
+        ]
+    },
+    pardotFormSubmitted: {
+        dict: false,
+        params: [
+            {
+                name: "botApiName",
+                type: "string"
+            }
+        ]
+    },
+    startCall: {
+        dict: true,
+        params: [
+            {
+                name: "state",
+                type: "enum",
+                allowed: START_CALL_STATES,
+                // `q_startCall` used to carry the deprecated `maximized` boolean in this
+                // slot, so those URLs keep working.
+                aliases: {
+                    "1": "maximized",
+                    true: "maximized",
+                    "0": "open",
+                    false: "open"
+                }
+            }
+        ]
+    },
+    startChat: {
+        dict: true,
+        params: [
+            {
+                name: "initialMessage",
+                type: "string"
+            },
+            {
+                name: "position",
+                type: "enum",
+                allowed: [
+                    "pinned",
+                    "floating"
+                ]
+            }
+        ]
+    }
+};
+class ApiHandler extends base_api_handler {
+    markReady() {
+        super.markReady();
+        this.executeUrlApiCalls();
+        // Listen for messages coming from iframes
+        __nativeWindowAddEventListener("message", (param)=>{
+            let { data, origin, source } = param;
+            if ((data == null ? void 0 : data.source) === "qualified" && (data == null ? void 0 : data.token) === this.widget.config.token && Array.isArray(data.args) && this.widget.isAllowedOrigin(origin) && data.args[0] !== "initialize") {
+                this.execute(...data.args);
+                source == null ? void 0 : source.postMessage({
+                    source: "qualified",
+                    token: this.widget.config.token,
+                    message: "done",
+                    verb: ((data == null ? void 0 : data.args) || [
+                        null
+                    ])[0]
+                }, {
+                    targetOrigin: origin
+                });
+            }
+        });
+    }
+    executeUrlApiCalls() {
+        // Execute querystring API calls of format q_<verb>[=<key>:<value>[;<key>:<value>]]
+        const params = new URLSearchParams(document.location.search);
+        for (const [verb, schema] of Object.entries(ALLOWED_URL_VERBS)){
+            const param = "q_" + verb;
+            if (params.has(param)) {
+                const value = params.get(param);
+                const result = parseQueryParams(value, schema);
+                if (Array.isArray(result)) {
+                    this.execute(verb, ...result);
+                } else {
+                    this.execute(verb, result);
+                }
+            }
+        }
+    }
+    constructor(injectionProps){
+        super(injectionProps, {
+            initialize: (teamToken, teamConfig)=>{
+                withTelemetryCtx({
+                    traceId: widgetBootstrap.traceId,
+                    parentSpan: widgetBootstrap.initSpan,
+                    telemetry: widgetBootstrap.telemetry
+                }, ()=>{
+                    this.widget.init(teamToken, teamConfig);
+                });
+                this.getIdentityQueue = [];
+            },
+            teardown: ()=>{
+                this.widget.onTeardown();
+            },
+            open: ()=>{
+                this.widget.initialized.then(()=>this.widget.open());
+            },
+            // For Pardot forms on landing pages
+            initPardotForm: (formActionUrl)=>{
+                __nativeWindowAddEventListener("submit", (e)=>{
+                    if (e.target instanceof HTMLFormElement && e.target.id && (e.target.id === "pardot-form" || e.target.matches('form[action="' + formActionUrl + '"]'))) {
+                        const emailInput = e.target.querySelector(PARDOT_EMAIL_SELECTOR);
+                        const email = emailInput == null ? void 0 : emailInput.value;
+                        if (email) {
+                            const formElement = e.target;
+                            const formData = Object.fromEntries(new FormData(formElement));
+                            this.execute("parsePardotFormForLandingPage", formElement.outerHTML, formData, email, formActionUrl);
+                            this.execute("emitFormFill", "pardot");
+                        }
+                    }
+                });
+                this.widget.debugState.logEvent("api:initPardotForm", "success", {
+                    isLandingPage: true,
+                    formActionUrl
+                });
+            },
+            // For Pardot forms on landing pages
+            initPardotFormThankYou: (formActionUrl)=>{
+                // No implementation needed for Pardot forms on landing pages
+                this.widget.debugState.logEvent("api:initPardotFormThankYou", "success", {
+                    isLandingPage: true,
+                    formActionUrl
+                });
+            },
+            pardotFormSubmitted: (botApiName)=>{
+                if (botApiName === void 0) botApiName = "default";
+                if (this.tracker.initialized) {
+                    this.widget.initialized.then(()=>this.tracker.handlePardotFormSubmitted(botApiName));
+                } else {
+                    this.tracker.setInitializationParams({
+                        bot_api_name: botApiName
+                    });
+                }
+                this.widget.debugState.logEvent("api:saveFormData", "success", {
+                    botApiName
+                });
+            },
+            // This handler is for getting the field name - value pairs from Pardot forms
+            // that have the "no wait" feature enabled.
+            parsePardotForm: (form, formData, email)=>{
+                if (!form || !formData) {
+                    this.widget.debugState.logEvent("api:parsePardotForm", "error", {
+                        form,
+                        formData,
+                        email
+                    }, "Failed to parse Pardot form. Form: " + form + ", formData: " + formData);
+                    return;
+                }
+                const tempElement = document.createElement("div");
+                tempElement.innerHTML = form;
+                const receivedFormElement = tempElement.querySelector("form");
+                const values = this.widget.excludeLongFieldValue(formData, "pardot", receivedFormElement);
+                // TODO: This is a safety check to avoid the edge cases where the the parsing in excludeLongFieldValue fails to get the correct data.
+                //  If that happens, we avoid polluting the already saved email and send a debuglog.
+                //  When we are very certain the parsing works for all the cases, we can remove this check.
+                if (!!values && values.email === email) {
+                    this.visitor.setFormData(values);
+                    this.widget.debugState.logEvent("api:parsePardotForm", "success", {
+                        email
+                    });
+                } else {
+                    this.widget.debugState.logEvent("api:parsePardotForm", "error", {
+                        incomingEmail: values.email,
+                        correctEmail: email
+                    }, "Failed to parse and get the correct field values from the Pardot form. Got " + values.email + ", while the correct email is " + email);
+                }
+            },
+            // This handler is for getting the field name - value pairs from Pardot forms
+            // that have the "no wait" feature enabled.
+            parsePardotFormForLandingPage: (form, formData, email, formActionUrl)=>{
+                if (!form || !formData) {
+                    this.widget.debugState.logEvent("api:parsePardotFormForLandingPage", "error", {
+                        form,
+                        formData,
+                        email,
+                        formActionUrl
+                    }, "Failed to parse Pardot form. Form: " + form + ", formData: " + formData);
+                    return;
+                }
+                const tempElement = document.createElement("div");
+                tempElement.innerHTML = form;
+                const receivedFormElement = tempElement.querySelector("form");
+                const values = this.widget.excludeLongFieldValue(formData, "pardot", receivedFormElement);
+                // TODO: This is a safety check to avoid the edge cases where the the parsing in excludeLongFieldValue fails to get the correct data.
+                //  If that happens, we avoid polluting the already saved email and send a debuglog.
+                //  When we are very certain the parsing works for all the cases, we can remove this check.
+                if (!!values && values.email === email) {
+                    this.visitor.setFormExperienceDataWithExpiry({
+                        formType: "pardot",
+                        formData: _extends({}, values, {
+                            formActionUrl,
+                            formEmail: email
+                        })
+                    }, 5000);
+                    this.widget.debugState.logEvent("api:parsePardotFormForLandingPage", "success", {
+                        email
+                    });
+                } else {
+                    this.widget.debugState.logEvent("api:parsePardotFormForLandingPage", "error", {
+                        incomingEmail: values.email,
+                        correctEmail: email
+                    }, "Failed to parse and get the correct field values from the Pardot form on landing page. Got " + values.email + ", while the correct email is " + email);
+                    this.visitor.setFormExperienceDataWithExpiry({
+                        formType: "pardot",
+                        formData: {
+                            formActionUrl,
+                            formEmail: email
+                        }
+                    }, 5000);
+                }
+            },
+            saveFormData: (fieldValues)=>{
+                this.visitor.setFormData(fieldValues);
+                if (fieldValues.email) {
+                    this.widget.debugState.logEvent("api:saveFormData", "success", {
+                        fieldValues
+                    });
+                } else {
+                    this.widget.debugState.logEvent("api:saveFormData", "error", {}, '"saveFormData" was called but no email was provided.');
+                }
+            },
+            // Note: Old implementation of saving form data
+            saveSmartFormData: (fieldValues, botApiName)=>{
+                if (botApiName === void 0) botApiName = "default";
+                this.visitor.setSmartFormData(fieldValues, botApiName);
+                this.widget.debugState.logEvent("api:saveSmartFormData", "success", {
+                    fieldValues,
+                    botApiName
+                });
+            },
+            sendSmartFormData: (fieldValues, botApiName)=>{
+                if (botApiName === void 0) botApiName = "default";
+                this.widget.initialized.then(()=>this.tracker.handleSmartFormSubmitted(fieldValues, botApiName));
+                this.widget.debugState.logEvent("api:sendSmartFormData", "success", {
+                    fieldValues,
+                    botApiName
+                });
+            },
+            showExperience: (botApiName, startCollapsed, showLoadingState)=>{
+                if (startCollapsed === void 0) startCollapsed = false;
+                if (showLoadingState === void 0) showLoadingState = true;
+                const initialClientState = startCollapsed ? "collapsed" : "expanded";
+                if (showLoadingState) {
+                    if (this.tracker.config.hasMeetingBookerExperienceBuilder) {
+                        this.experienceAdapter.showLightboxLoading();
+                    } else if (!startCollapsed) {
+                        this.widget.initialized.then(()=>{
+                            this.experienceAdapter.showMessengerLoading();
+                        });
+                    }
+                }
+                if (this.tracker.initialized) {
+                    this.widget.initialized.then(()=>this.tracker.showExperience(botApiName, initialClientState));
+                } else {
+                    this.tracker.setInitializationParams({
+                        bot_api_name: botApiName,
+                        bot_initial_client_state: initialClientState
+                    });
+                }
+                this.widget.debugState.logEvent("api:showExperience", "success", {
+                    botApiName,
+                    startCollapsed,
+                    hasMeetingBookerExperienceBuilder: this.tracker.config.hasMeetingBookerExperienceBuilder
+                });
+            },
+            /**
+       *
+       * @param {HTMLFormElement | string} formElementOrSelector Form to trigger to a Form Experience or String containing a css selector that uniquely identifies the form
+       * @param {FieldMappingsObject} fieldMappings Mapping of visitor field API names to names of fields on the form
+       * @param {(FieldValuesObject) => void} altSubmitCallback Function to run using the field values, existence prevents actual form submit
+       */ registerForm: (formElementOrSelector, fieldMappings, altSubmitCallback)=>{
+                if (fieldMappings === void 0) fieldMappings = {};
+                if (altSubmitCallback === void 0) altSubmitCallback = null;
+                this.widget.initialized.then(()=>{
+                    __nativeWindowAddEventListener("submit", (e)=>{
+                        let formElement = null;
+                        if (typeof formElementOrSelector === "string") {
+                            formElement = document.querySelector(formElementOrSelector);
+                        } else if (formElementOrSelector instanceof HTMLFormElement) {
+                            formElement = formElementOrSelector;
+                        }
+                        if (e.target !== formElement) return;
+                        const formData = new FormData(e.target);
+                        const fieldValues = Object.entries(fieldMappings).reduce((acc, param)=>{
+                            let [fieldApiName, formFieldName] = param;
+                            acc[fieldApiName] = formData.get(formFieldName);
+                            return acc;
+                        }, {});
+                        this.visitor.setFormData(fieldValues);
+                        if (altSubmitCallback) {
+                            // TODO(eslint): Explain why preventDefault() is needed. This comment was added as part of the enforce-comment eslint rule
+                            e.preventDefault();
+                            // TODO(eslint): Explain why stopPropagation() is needed. This comment was added as part of the enforce-comment eslint rule
+                            e.stopPropagation();
+                            try {
+                                altSubmitCallback(fieldValues);
+                            } catch (error) {
+                                console.error("Qualified: Error running altSubmitCallback", error); // eslint-disable-line no-console
+                            }
+                        }
+                    }, {
+                        capture: true
+                    });
+                });
+                this.widget.debugState.logEvent("api:registerForm", "success", {
+                    formElementOrSelector: formElementOrSelector.toString(),
+                    fieldMappings
+                });
+            },
+            showForm: async (botApiName, clientConfig)=>{
+                var _tryGet;
+                if (!this.tracker.config.hasWebsiteEmbeddedForms) {
+                    this.widget.debugState.logEvent("api:showForm", "error", {
+                        botApiName,
+                        clientConfig
+                    }, "`showForm` was called but `website_embedded_forms` feature flag is not enabled");
+                    return;
+                }
+                const targetElements = document.querySelectorAll(clientConfig.target);
+                if (targetElements.length > 1) {
+                    this.widget.debugState.logEvent("api:showForm", "error", {
+                        botApiName,
+                        clientConfig
+                    }, "Found " + targetElements.length + " target elements for selector, but expected 1: `" + clientConfig.target + "`");
+                // Don't return early; continue with the first target element
+                }
+                const targetElement = targetElements[0];
+                if (!targetElement) {
+                    this.widget.debugState.logEvent("api:showForm", "error", {
+                        botApiName,
+                        clientConfig
+                    }, "Target element not found: `" + clientConfig.target + "`");
+                    return;
+                }
+                // Fetch the form config from the server, then render an embedded Qualified Form in the
+                // `clientConfig.target` element.
+                //
+                // If we want to render the form sooner, alternatively we can require the target element to
+                // have a `data-qualified-form-experience-api-name` attribute. The widget would need to
+                // query for all elements with this attribute when the DOM is ready, as well as whenever the
+                // DOM changes (e.g., when embedding a form inside a dialog), then start fetching each form
+                // config before the `showForm` API call.
+                const iframeManagerRef = (_tryGet = tryGet(()=>this.iframeManager)) != null ? _tryGet : null;
+                const qualifiedFormApi = new QualifiedFormApi({
+                    channel: this.channel,
+                    formApiName: botApiName,
+                    iframeManager: iframeManagerRef,
+                    source: (/* inlined export .QualifiedFormSource.EMBEDDED */"embedded")
+                });
+                const formConfigResponse = await qualifiedFormApi.getFormConfig();
+                if (formConfigResponse.success) {
+                    const serverConfig = formConfigResponse.qualifiedFormConfig;
+                    const form = await createForm(_extends({
+                        formExperienceApiName: botApiName
+                    }, clientConfig, {
+                        // Server config no longer provides these values, so we're using the client config values instead
+                        // emailInputLabelText: serverConfig.emailField?.label,
+                        // emailInputPlaceholderText: serverConfig.emailField?.placeholder,
+                        // successRedirectUrl: serverConfig.assetUrl,
+                        successRedirectUrl: undefined,
+                        // Force the url to be undefined because we want the qualified form to use the redirect node for redirecting
+                        validateBusinessEmail: serverConfig.validateBusinessEmail ? "true" : undefined
+                    }));
+                    targetElement.append(form);
+                } else {
+                    this.widget.debugState.logEvent("api:showForm", "error", {
+                        botApiName,
+                        clientConfig
+                    }, "Failed to get form config for form experience `" + botApiName + "`. Error: " + formConfigResponse.error);
+                }
+            },
+            showFormExperience: (botApiName, options)=>{
+                if (options === void 0) options = {
+                    formDestinations: null
+                };
+                var _this_visitor_formData, _this_visitor_smartFormData, _options_formDestinations;
+                const fieldValues = ((_this_visitor_formData = this.visitor.formData) == null ? void 0 : _this_visitor_formData.fieldValues) || ((_this_visitor_smartFormData = this.visitor.smartFormData) == null ? void 0 : _this_visitor_smartFormData.fieldValues);
+                if (!fieldValues) {
+                    this.widget.debugState.logEvent("api:showFormExperience", "error", {
+                        botApiName,
+                        formDestinations: options.formDestinations
+                    }, '"showFormExperience" was called but no form data was found. Not triggering the form experience.');
+                    return;
+                }
+                this.experienceAdapter.showLightboxLoading();
+                // Pre-offer SLI. Armed here, above the initialized/pre-init split, so one
+                // call covers both branches — they differ in how the experience is started,
+                // not in whether the visitor is now watching a spinner.
+                //
+                // Placed after the `fieldValues` guard on purpose: that path returns
+                // without showing the lightbox, so there is no wait to measure and arming
+                // would add a journey the visitor never experienced.
+                //
+                // `botApiName` is the experience the caller asked for, so unlike the other
+                // form arm sites this one has a real source for the dimension.
+                if (this.featureFlags.bookerJourneySLI) {
+                    armFormCtaBookerIntent("form:" + botApiName, botApiName);
+                }
+                if (DebugModeState.isInDebugMode()) {
+                    let formDestinationsLog;
+                    if (Array.isArray(options.formDestinations) && options.formDestinations.length > 0) {
+                        formDestinationsLog = " with the following form destination(s): " + options.formDestinations.join(", ");
+                    } else {
+                        formDestinationsLog = " with no form destinations provided";
+                    }
+                    DebugModeState.setApiMessage("showFormExperience", "Success", '"showFormExperience" was called successfully for ' + botApiName + formDestinationsLog + ".");
+                }
+                if (this.tracker.initialized) {
+                    this.widget.initialized.then(()=>this.tracker.showFormExperience(botApiName, options.formDestinations));
+                } else {
+                    const params = {
+                        bot_api_name: botApiName,
+                        form_destinations: options.formDestinations
+                    };
+                    if (fieldValues) {
+                        params.smart_form = {
+                            field_values: fieldValues
+                        };
+                    }
+                    this.tracker.setInitializationParams(params);
+                }
+                const formDestinationsString = ((_options_formDestinations = options.formDestinations) == null ? void 0 : _options_formDestinations.join(",")) || "none";
+                this.widget.debugState.logEvent("api:showFormExperience", "success", {
+                    botApiName,
+                    formDestinations: options.formDestinations
+                }, '"showFormExperience" was called successfully for ' + botApiName + " with form destinations [" + formDestinationsString + "]");
+            },
+            showExperienceForForm: (formType, formData, showOnRedirect)=>{
+                if (showOnRedirect === void 0) showOnRedirect = false;
+                var _formData_formActionUrl;
+                if (!this.widget.config.hasSmartForms) {
+                    this.widget.debugState.logEvent("api:showExperienceForForm", "error", {
+                        formType,
+                        formData,
+                        showOnRedirect
+                    }, '"showExperienceForForm" was called but "smart_forms" flag is not enabled');
+                    return;
+                }
+                const normalizedFormActionUrl = (_formData_formActionUrl = formData.formActionUrl) == null ? void 0 : _formData_formActionUrl.replace(/^https?:\/\//, "");
+                const formActionUrlCandidates = normalizedFormActionUrl ? [
+                    normalizedFormActionUrl,
+                    normalizedFormActionUrl.replace("/iframe/", "/"),
+                    normalizedFormActionUrl.startsWith("/") ? "" + window.location.host + normalizedFormActionUrl : undefined,
+                    normalizedFormActionUrl.startsWith("/") ? "" + window.location.host + normalizedFormActionUrl.replace("/iframe/", "/") : undefined
+                ].filter((formActionUrl)=>!!formActionUrl) : [];
+                const matchedFormActionUrl = formActionUrlCandidates.find((formActionUrl)=>this.widget.config.formBotTriggers.pardot.includes(formActionUrl));
+                if (normalizedFormActionUrl && !matchedFormActionUrl) {
+                    this.widget.debugState.logEvent("api:showExperienceForForm", "error", {
+                        formType,
+                        formData,
+                        showOnRedirect
+                    }, '"showExperienceForForm" was called but "formData.formActionUrl" is not in the list of configured triggers');
+                    return;
+                }
+                if (matchedFormActionUrl && matchedFormActionUrl !== normalizedFormActionUrl) {
+                    formData = _extends({}, formData, {
+                        formActionUrl: matchedFormActionUrl
+                    });
+                }
+                if (formType === "pardot") {
+                    var _this_visitor_formData, _this_visitor_formData_fieldValues, _this_visitor_formData1;
+                    formData = _extends({}, formData, (_this_visitor_formData = this.visitor.formData) == null ? void 0 : _this_visitor_formData.fieldValues);
+                    formData.formEmail = formData.formEmail || ((_this_visitor_formData1 = this.visitor.formData) == null ? void 0 : (_this_visitor_formData_fieldValues = _this_visitor_formData1.fieldValues) == null ? void 0 : _this_visitor_formData_fieldValues.email);
+                }
+                if (showOnRedirect) {
+                    // TODO: look into toggling a flag to prevent the cookie state from being read out before
+                    // redirect happens since there is still technically a race case here
+                    __nativeWindowAddEventListener("beforeunload", ()=>{
+                        // The Pardot iframe flow saves field values to both the formData cookie attribute
+                        // (via parsePardotForm) and formExperienceData (here). Since the field values have
+                        // already been merged into the local formData variable above, clear the redundant
+                        // formData to avoid exceeding the browser's 4096-byte cookie size limit.
+                        if (formType === "pardot") {
+                            this.visitor.clearFormData();
+                        }
+                        this.visitor.setFormExperienceDataWithExpiry({
+                            formType,
+                            formData
+                        });
+                    });
+                    window.postMessage({
+                        source: "qualified",
+                        token: this.widget.config.token,
+                        message: "done",
+                        verb: "showExperienceForForm"
+                    }, window.location.origin);
+                } else if (this.tracker.initialized) {
+                    this.experienceAdapter.showLightboxLoading();
+                    this.widget.initialized.then(()=>this.tracker.showExperienceForForm(formType, formData));
+                } else {
+                    var _formData_formActionUrl1;
+                    this.experienceAdapter.showLightboxLoading();
+                    // Pre-offer SLI: this is the submit moment just as much as the
+                    // initialized branch above is — the only difference is that the
+                    // experience starts from the page-view request rather than
+                    // `show_experience_for_form`, so `Tracker.showExperienceForForm`'s arm
+                    // site is never reached and the whole pre-initialization submit path
+                    // emitted nothing. The clock is honest here; this is not a replay.
+                    if (this.featureFlags.bookerJourneySLI) {
+                        armFormCtaBookerIntent("form:" + formType);
+                    }
+                    this.tracker.setInitializationParams({
+                        smart_form: {
+                            form_type: formType,
+                            field_values: {
+                                email: formData.formEmail
+                            },
+                            form_data: {
+                                form_email: formData.formEmail,
+                                form_action_url: (_formData_formActionUrl1 = formData.formActionUrl) == null ? void 0 : _formData_formActionUrl1.replace(/^https?:\/\//, ""),
+                                raw: formData,
+                                form_id: formData.formId
+                            }
+                        }
+                    });
+                }
+                this.widget.debugState.logEvent("api:showExperienceForForm", "success", {
+                    formType,
+                    formData,
+                    showOnRedirect
+                });
+            },
+            refreshVisitorState: ()=>{
+                this.visitor.refreshPersistedState();
+            },
+            getIdentity: (callback)=>{
+                this.getIdentityQueue.push(callback);
+                if (this.channel.initStateReceived) {
+                    this.tracker.getIdentity();
+                } else {
+                    this.channel.once("initState", this.tracker.getIdentity);
+                }
+                if (!this.subscribedToGetIdentity) {
+                    this.subscribedToGetIdentity = true;
+                    this.channel.emitter.on("received", (event, payload)=>{
+                        if (event === "getIdentity") {
+                            try {
+                                this.getIdentityQueue.forEach((queuedCallback)=>{
+                                    queuedCallback(payload);
+                                });
+                                this.getIdentityQueue = [];
+                            } catch (e) {
+                                console.error("Qualified: Error in the given getIdentity callback.", e); // eslint-disable-line no-console
+                            }
+                        }
+                    });
+                }
+            },
+            handleEvents: (handler)=>{
+                this.channel.emitter.on("received", (event, payload)=>{
+                    if (event === "conversationEvent") {
+                        try {
+                            handler(payload.name, payload.data);
+                            // TODO: Remove after enabling field_broadcasting_restriction FF (CORE-1102)
+                            this.widget.serverLog({
+                                message: "handleEvents event: " + payload.name,
+                                type: "log",
+                                extra: {
+                                    api_method: "handleEvents",
+                                    api_event: payload.name
+                                }
+                            });
+                        } catch (e) {
+                            console.error("Qualified: Error in event handler", e); // eslint-disable-line no-console
+                        }
+                    }
+                    if (event === "pageViewActivityEvent") {
+                        try {
+                            handler(payload.name, payload.data);
+                            // TODO: Remove after enabling field_broadcasting_restriction FF (CORE-1102)
+                            this.widget.serverLog({
+                                message: "handleEvents event: " + payload.name,
+                                type: "log",
+                                extra: {
+                                    api_method: "handleEvents",
+                                    api_event: payload.name
+                                }
+                            });
+                        } catch (e) {
+                            console.error("Qualified: Error in event handler", e); // eslint-disable-line no-console
+                        }
+                    }
+                });
+            },
+            handleMessengerEvents: (handler)=>{
+                this.experienceAdapter.addMessengerEventsListener(handler);
+            },
+            handleWidgetEvents: (handler)=>{
+                this.widget.addWidgetEventsListener(handler);
+            },
+            identify: (fieldValues)=>{
+                if (this.tracker.initialized) {
+                    this.tracker.setFieldValues(fieldValues);
+                } else {
+                    this.tracker.setInitializationParams({
+                        field_values: fieldValues
+                    });
+                }
+                this.widget.debugState.logEvent("api:identify", "success", {
+                    fieldValues
+                });
+            },
+            page: ()=>{
+                this.tracker.createPageView({
+                    singlePageApp: true,
+                    reconnecting: false,
+                    rebroadcast: false
+                });
+            },
+            endExperience: ()=>{
+                this.widget.endExperience();
+            },
+            setCookieConsent: (hasCookieConsent)=>{
+                if (hasCookieConsent === true || hasCookieConsent === false) {
+                    this.widget.setCookieConsent(hasCookieConsent);
+                    if (hasCookieConsent === true) {
+                        this.channel.send({
+                            event: "cookieConsentGiven",
+                            payload: {}
+                        });
+                    }
+                } else {
+                    console.error("Qualified: setCookieConsent must be called with a boolean value."); // eslint-disable-line no-console
+                }
+            },
+            emitFormFill: (formType)=>{
+                this.widget.initialized.then(()=>this.tracker.pageViewActivityEmitter.emitFormFill({
+                        formType
+                    }));
+            },
+            submitEmbeddedForm: (param)=>{
+                let { email, formExperienceApiName } = param;
+                if (this.tracker.config.hasWebsiteEmbeddedForms) {
+                    this.channel.send({
+                        event: "submitEmbeddedForm",
+                        payload: {
+                            bot_api_name: formExperienceApiName,
+                            email
+                        }
+                    });
+                    this.widget.debugState.logEvent("api:submitEmbeddedForm", "success", {
+                        formExperienceApiName
+                    });
+                } else {
+                    this.widget.debugState.logEvent("api:submitEmbeddedForm", "error", {
+                        formExperienceApiName
+                    }, "`submitEmbeddedForm` was called but `website_embedded_forms` feature flag is not enabled");
+                }
+            },
+            // Used by iframed widgets to log debug events to parent frame
+            logDebugEvent: (key, status, data, message)=>{
+                this.widget.debugState.logEvent(key, status, data, message);
+            },
+            setChatIsVisible: (chatIsVisible)=>{
+                this.experienceAdapter.setChatIsVisible(chatIsVisible);
+            },
+            startCall: async (options)=>{
+                // Voice FF is needed at least for this to work
+                if (!this.featureFlags.piperXAgentVoice) return;
+                try {
+                    const multimodal = await this.widget.multimodalReady;
+                    multimodal == null ? void 0 : multimodal.startCall(options);
+                } catch (unused) {
+                // multimodal failed to initialize — nothing to do
+                }
+            },
+            startChat: async (options)=>{
+                try {
+                    const multimodal = await this.widget.multimodalReady;
+                    multimodal == null ? void 0 : multimodal.startChat(options);
+                } catch (unused) {
+                // multimodal failed to initialize — nothing to do
+                }
+            }
+        }), this.getIdentityQueue = [];
+    }
+}
+
+
+var api_handler_START_CALL_STATES = /* unused export */ undefined;
+export { api_handler_START_CALL_STATES as START_CALL_STATES };
+export default ApiHandler;