@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/local_state/debug_state/hubspot_form_flow.js

@@ -0,0 +1,19 @@
+import { AbstractDebugFlow } from "./abstract_debug_flow.js";
+
+
+class HubspotFormFlow extends AbstractDebugFlow {
+    constructor(...args){
+        super(...args), this.name = "HubSpot Form Experience", this.steps = [
+            "widget:hasMeetingBookerExperienceBuilder",
+            "widget:hubspot:hbsptFound",
+            "debug:formSubmitCapture",
+            "widget:hubspot:onFormSubmit",
+            "visitor:setFormExperienceDataWithExpiry",
+            "widget:hubspot:onFormSubmitted",
+            "tracker:showExperienceForForm",
+            "widget:formExperienceDataFound"
+        ];
+    }
+}
+
+export { HubspotFormFlow };

package/widget/local_state/debug_state/hubspot_v4_form_flow.js

@@ -0,0 +1,19 @@
+import { AbstractDebugFlow } from "./abstract_debug_flow.js";
+
+
+class HubspotV4FormFlow extends AbstractDebugFlow {
+    constructor(...args){
+        super(...args), this.name = "HubSpot V4 Form Experience", this.steps = [
+            "widget:hasMeetingBookerExperienceBuilder",
+            "widget:hubspotV4:HubSpotFormsV4Found",
+            "widget:hubspotV4:initComplete",
+            "debug:formSubmitCapture",
+            "widget:hubspotV4:onSubmissionSuccess",
+            "visitor:setFormExperienceDataWithExpiry",
+            "tracker:showExperienceForForm",
+            "widget:formExperienceDataFound"
+        ];
+    }
+}
+
+export { HubspotV4FormFlow };

package/widget/local_state/debug_state/marketo_form_flow.js

@@ -0,0 +1,20 @@
+import { AbstractDebugFlow } from "./abstract_debug_flow.js";
+
+
+class MarketoFormFlow extends AbstractDebugFlow {
+    constructor(...args){
+        super(...args), this.name = "Marketo Form Experience", this.steps = [
+            "widget:hasMeetingBookerExperienceBuilder",
+            "widget:marketo:MktoForms2Found",
+            "widget:marketo:configuredFormFound",
+            "debug:formSubmitCapture",
+            "widget:marketo:onSubmit",
+            "visitor:setFormExperienceDataWithExpiry",
+            "widget:marketo:onSuccess",
+            "tracker:showExperienceForForm",
+            "widget:formExperienceDataFound"
+        ];
+    }
+}
+
+export { MarketoFormFlow };

package/widget/local_state/debug_state/pardot_form_flow.js

@@ -0,0 +1,18 @@
+import { AbstractDebugFlow } from "./abstract_debug_flow.js";
+
+
+class PardotFormFlow extends AbstractDebugFlow {
+    constructor(...args){
+        super(...args), this.name = "Pardot Form Experience", this.steps = [
+            "api:initPardotForm",
+            "api:initPardotFormThankYou",
+            "api:saveFormData",
+            "api:parsePardotForm",
+            "api:parsePardotFormForLandingPage",
+            "visitor:setFormExperienceDataWithExpiry",
+            "api:showExperienceForForm"
+        ];
+    }
+}
+
+export { PardotFormFlow };

package/widget/local_state/debug_state.js

@@ -0,0 +1,362 @@
+import { __webpack_require__ } from "../../js/runtime.js";
+import { DOMReady } from "../../src/dom.js";
+import { CustomFormFlow } from "./debug_state/custom_form_flow.js";
+import { HubspotFormFlow } from "./debug_state/hubspot_form_flow.js";
+import { HubspotV4FormFlow } from "./debug_state/hubspot_v4_form_flow.js";
+import { MarketoFormFlow } from "./debug_state/marketo_form_flow.js";
+import { PardotFormFlow } from "./debug_state/pardot_form_flow.js";
+import { AbstractLocalState } from "./abstract_local_state.js";
+import "../utils/native_globals.js";
+
+/* provided dependency */ var __nativeWindowAddEventListener = __webpack_require__(68034).zh;
+
+
+
+
+
+
+
+const LOG_PREFIX = "[Qualified Debug]";
+// Persisted state for "q_debug" query parameter
+class DebugState extends AbstractLocalState {
+    set channel(chan) {
+        this._channel = chan;
+    }
+    get channel() {
+        if (this._channel) return this._channel;
+        throw new Error("Channel not set from upstream");
+    }
+    logEvent(key, status, data, message) {
+        if (!this.isDebugging) return;
+        try {
+            console.log(LOG_PREFIX, message != null ? message : getDefaultDebugMessage(key, status), data); // eslint-disable-line no-console
+            const event = {
+                timestamp: Date.now(),
+                key,
+                status,
+                data,
+                message
+            };
+            this.events.push(event);
+            this.updateStateAtKey("events", this.events);
+            this.eventsMap[key] = event;
+        } catch (error) {
+            console.error(LOG_PREFIX, "Error logging event", error); // eslint-disable-line no-console
+        }
+    }
+    initElements() {
+        // TODO: Maybe extract these to a dialog provider if this gets reused
+        // Create dialog element
+        const dialogEl = document.createElement("dialog");
+        dialogEl.id = "qualified-debug-dialog";
+        dialogEl.innerHTML = "\n      <div>Debug Output</div>\n      <button id=archive-session>Archive Session</button>\n      <pre></pre>\n      <button id=close-debug>Close</button>\n      <style>#qualified-debug-dialog::backdrop { background-color: #000a; }</style>\n    ";
+        Object.assign(dialogEl.style, {
+            textAlign: "left"
+        });
+        dialogEl.addEventListener("click", (e)=>{
+            if (e.target.matches("#close-debug")) {
+                dialogEl.close();
+            }
+        });
+        dialogEl.addEventListener("click", (e)=>{
+            if (e.target.matches("#archive-session")) {
+                this.channel.send({
+                    event: "archiveSession"
+                });
+                dialogEl.close();
+            }
+        });
+        document.body.appendChild(dialogEl);
+        // Create button element
+        const buttonEl = document.createElement("button");
+        buttonEl.textContent = "Debug Output";
+        Object.assign(buttonEl.style, {
+            position: "fixed",
+            bottom: "0",
+            left: "0",
+            zIndex: "" + 2 ** 31,
+            padding: "10px"
+        });
+        buttonEl.addEventListener("click", ()=>{
+            dialogEl.querySelector("pre").textContent = this.flowOutput();
+            dialogEl.showModal();
+        });
+        document.body.appendChild(buttonEl);
+    }
+    flowOutput(flowName) {
+        const flow = this.flows.find((flow)=>flow.name === flowName);
+        if (flow) {
+            return flow.textOutput;
+        }
+        return this.flows.map((flow)=>flow.textOutput).join("\n\n======\n\n");
+    }
+    constructor(){
+        var _ref;
+        var _this_persistedState, _this_persistedState1;
+        super(), this.KEY = "__q_local_form_debug", this.TTL = 30 * 60 * 1000 // 30 minutes
+        , this.flows = [], this.events = [], this.eventsMap = {}, this.isDebugging = new URLSearchParams(document.location.search).has("q_debug") || !!((_this_persistedState = this.persistedState) == null ? void 0 : _this_persistedState.isDebugging);
+        this.updateStateAtKey("isDebugging", this.isDebugging);
+        if (!this.isDebugging) return;
+        this.flows = [
+            new CustomFormFlow(this.eventsMap),
+            new MarketoFormFlow(this.eventsMap),
+            new HubspotFormFlow(this.eventsMap),
+            new HubspotV4FormFlow(this.eventsMap),
+            new PardotFormFlow(this.eventsMap)
+        ];
+        this.events = (_ref = (_this_persistedState1 = this.persistedState) == null ? void 0 : _this_persistedState1.events) != null ? _ref : [];
+        this.events.forEach((event)=>{
+            this.eventsMap[event.key] = event;
+        });
+        __nativeWindowAddEventListener("submit", ()=>{
+            this.logEvent("debug:formSubmitCapture", "success");
+        }, {
+            capture: true
+        });
+        DOMReady().then(()=>this.initElements());
+    }
+}
+// There are generally two categories of events:
+//
+// For events that denote whether or not something occurred, define "missing" and "success" messages.
+// `  shouldOccur: {
+// `    missing: "This event should have occurred, but it did not.",
+// `    success: "This event occurred successfully.",
+// `  },
+// Successful occurrences are logged as "success", otherwise the "missing" message is used downstream if something expects this event.
+// `  debugState.logEvent("shouldOccur", "success");
+// `  debugState.logEvent("shouldOccur", "success", { maybeData }, "A more specific message!");
+// Any "error" occurrences should be logged with more specific messages.
+// `  debugState.logEvent("shouldOccur", "error", { maybeData }, "This event occurrred, but something went wrong!");
+//
+//
+// For events that denote whether an expected condition was satisfied, define "error" and "success" messages.
+// `  shouldSatisfyCondition: {
+// `    error: "This event occurred, but something went wrong and the condition was not satisfied.",
+// `    success: "This event occurred and the condition was satisfied.",
+// `  },
+// Satisfied conditions are logged as "success", and "error" otherwise.
+// `  debugState.logEvent("shouldSatisfyCondition", "success");
+// `  debugState.logEvent("shouldSatisfyCondition", "success", { maybeData }, "A more specific message!");
+// `  debugState.logEvent("shouldSatisfyCondition", "error");
+// `  debugState.logEvent("shouldSatisfyCondition", "error", { maybeData }, "Something else went wrong!");
+//
+// TODO: More explicitly type these events. Or move the interpretation to downstream consumers.
+const DEBUG_EVENTS = {
+    debug: {
+        formSubmitCapture: {
+            missing: 'Form "submit" event was not detected',
+            success: 'Form "submit" event was detected'
+        }
+    },
+    api: {
+        identify: {
+            missing: '"identify" was not called',
+            success: '"identify" was called successfully'
+        },
+        initPardotForm: {
+            missing: '"initPardotForm" was not called',
+            success: '"initPardotForm" was called successfully'
+        },
+        initPardotFormThankYou: {
+            missing: '"initPardotFormThankYou" was not called',
+            success: '"initPardotFormThankYou" was called successfully'
+        },
+        pardotFormSubmitted: {
+            missing: '"pardotFormSubmitted" was not called',
+            success: '"pardotFormSubmitted" was called successfully'
+        },
+        parsePardotForm: {
+            missing: '"parsePardotForm" was not called',
+            success: '"parsePardotForm" was called successfully'
+        },
+        parsePardotFormForLandingPage: {
+            missing: '"parsePardotFormForLandingPage" was not called',
+            success: '"parsePardotFormForLandingPage" was called successfully'
+        },
+        registerForm: {
+            missing: '"registerForm" was not called',
+            success: '"registerForm" was called successfully'
+        },
+        saveFormData: {
+            missing: '"saveFormData" was not called',
+            success: '"saveFormData" was called successfully'
+        },
+        saveSmartFormData: {
+            missing: '"saveSmartFormData" was not called',
+            success: '"saveSmartFormData" was called successfully'
+        },
+        sendSmartFormData: {
+            missing: '"sendSmartFormData" was not called',
+            success: '"sendSmartFormData" was called successfully'
+        },
+        showExperience: {
+            missing: '"showExperience" was not called',
+            success: '"showExperience" was called successfully'
+        },
+        showExperienceForForm: {
+            missing: '"showExperienceForForm" was not called',
+            success: '"showExperienceForForm" was called successfully'
+        },
+        showForm: {
+            missing: '"showForm" was not called',
+            success: '"showForm" was called successfully'
+        },
+        showFormExperience: {
+            missing: '"showFormExperience" was not called',
+            success: '"showFormExperience" was called successfully'
+        },
+        submitEmbeddedForm: {
+            missing: '"submitEmbeddedForm" was not called',
+            success: '"submitEmbeddedForm" was called successfully'
+        }
+    },
+    tracker: {
+        showExperienceForForm: {
+            missing: '"showExperienceForForm" was not called',
+            success: '"showExperienceForForm" was called successfully'
+        }
+    },
+    visitor: {
+        setFormExperienceDataWithExpiry: {
+            missing: '"setFormExperienceDataWithExpiry" was not called',
+            success: '"setFormExperienceDataWithExpiry" was called successfully'
+        }
+    },
+    widget: {
+        initFormExperience: {
+            missing: '"initFormExperience" was not called',
+            success: '"initFormExperience" was called successfully'
+        },
+        hasMeetingBookerExperienceBuilder: {
+            error: '"meeting_booker_experience_builder" flag is not enabled',
+            success: '"meeting_booker_experience_builder" flag is enabled'
+        },
+        hasSmartForms: {
+            error: '"smart_forms" flag is not enabled',
+            success: '"smart_forms" flag is enabled'
+        },
+        formExperienceDataFound: {
+            missing: "No form experience data was found from previous page.",
+            success: "Form experience data was found from previous page. Triggering form experience.",
+            error: "Error while finding form experience data from previous page."
+        },
+        hubspot: {
+            hbsptFound: {
+                error: '"window.hbspt" is undefined. This is only necessary when attempting to configure a HubSpot Smart Form. Otherwise, you can safely ignore this log.',
+                success: '"window.hbspt" is defined. Initializing HubSpot Smart Form now.'
+            },
+            initHubspotFormsComplete: {
+                missing: 'HubSpot forms setup using "window.hbspt" did not complete.',
+                success: 'HubSpot forms setup using "window.hbspt" has completed.'
+            },
+            onFormSubmit: {
+                missing: '"onFormSubmit" event was not detected',
+                success: '"onFormSubmit" event was detected'
+            },
+            onFormSubmitted: {
+                missing: '"onFormSubmitted" event was not detected',
+                success: '"onFormSubmitted" event was detected'
+            },
+            window: {
+                error: "Unable to access content window"
+            }
+        },
+        hubspotV4: {
+            HubSpotFormsV4Found: {
+                error: '"window.HubSpotFormsV4" is undefined. This is only necessary when attempting to configure a HubSpot V4 Smart Form. Otherwise, you can safely ignore this log.',
+                success: '"window.HubSpotFormsV4" is defined. Initializing HubSpot V4 Smart Form now.'
+            },
+            initComplete: {
+                error: "HubSpot V4 forms setup did not complete.",
+                success: "HubSpot V4 forms setup has completed."
+            },
+            onSubmissionSuccess: {
+                error: "Error processing HubSpot V4 form submission.",
+                success: '"hs-form-event:on-submission:success" event was processed successfully.'
+            },
+            pollTimeout: {
+                error: '"window.HubSpotFormsV4" was not found after 30s of polling. The HubSpot V4 script may not be loading on this page.'
+            },
+            window: {
+                error: "Unable to access content window for HubSpot V4"
+            }
+        },
+        marketo: {
+            MktoForms2Found: {
+                error: '"window.MktoForms2" is undefined. This is only necessary when attempting to configure a Marketo Smart Form. Otherwise, you can safely ignore this log.',
+                success: '"window.MktoForms2" is defined. Initializing Marketo Smart Forms now.'
+            },
+            configuredFormFound: {
+                missing: "No configured Marketo form was found.",
+                success: "Found Marketo form in configurations."
+            },
+            configuredFormSetup: {
+                missing: "No Marketo form was set up.",
+                success: "Marketo form has been set up."
+            },
+            initMarketoFormsComplete: {
+                missing: 'Marketo forms setup using "window.MktoForms" did not complete.',
+                success: 'Marketo forms setup using "window.MktoForms" has completed.'
+            },
+            onSubmit: {
+                missing: '"mktoForm.onSubmit" was not called',
+                success: '"mktoForm.onSubmit" was called successfully'
+            },
+            onSuccess: {
+                missing: '"mktoForm.onSuccess" was not called',
+                success: '"mktoForm.onSuccess" was called successfully'
+            },
+            showExperienceForForm: {
+                missing: "Redirecting after Marketo form submission. Showing form experience after redirect.",
+                success: "No redirection from Marketo form. Showing form experience."
+            },
+            redirectEvent: {
+                missing: "Marketo form did not redirect.",
+                success: "Marketo form is redirecting."
+            }
+        },
+        qualifiedForms: {
+            initQualifiedForms: {
+                success: "Embedded Qualified Form custom element was registered",
+                error: "Embedded Qualified Form custom element was not registered"
+            }
+        },
+        multimodal: {
+            gate: {
+                success: "Checked multimodal gate conditions"
+            },
+            hostReady: {
+                success: "Multimodal host created and shadow root attached"
+            },
+            shadowRegistered: {
+                success: "Registered shadow root with stylesLoader"
+            },
+            globalStyleInjected: {
+                success: "Injected global styles element into shadow root"
+            },
+            loadStart: {
+                success: "Starting dynamic import for multimodal module"
+            },
+            loadDone: {
+                success: "Dynamic import resolved for multimodal module"
+            },
+            loadError: {
+                error: "Dynamic import failed for multimodal module"
+            },
+            initCalled: {
+                success: "Called multimodal.init()"
+            }
+        }
+    }
+};
+function getDefaultDebugMessage(key, status) {
+    var _defaultMessages_status;
+    const defaultMessages = key.split(":").reduce((acc, curr)=>{
+        // @ts-expect-error - This traversal should work, by definition of DebugEventKey
+        return acc[curr];
+    }, DEBUG_EVENTS);
+    return (_defaultMessages_status = defaultMessages[status]) != null ? _defaultMessages_status : "Undefined message for " + key + ":" + status;
+}
+
+export { DebugState, getDefaultDebugMessage };

package/widget/local_state/trace_state.js

@@ -0,0 +1,20 @@
+import { AbstractLocalState } from "./abstract_local_state.js";
+
+
+// Persisted state for "q_trace" query parameter
+class TraceState extends AbstractLocalState {
+    setIsTracing(value, trace) {
+        this.isTracing = value;
+        this.traceValue = trace;
+        this.updateStateAtKey("isTracing", value);
+        this.updateStateAtKey("traceValue", trace);
+    }
+    constructor(...args){
+        var _ref;
+        var _this_persistedState, _this_persistedState1, _this_persistedState2;
+        super(...args), this.KEY = "__q_local_trace", this.TTL = 30 * 60 * 1000 // 30 minutes
+        , this.isTracing = (_ref = (_this_persistedState = this.persistedState) == null ? void 0 : _this_persistedState.isTracing) != null ? _ref : false, this.traceValue = ((_this_persistedState1 = this.persistedState) == null ? void 0 : _this_persistedState1.isTracing) ? (_this_persistedState2 = this.persistedState) == null ? void 0 : _this_persistedState2.traceValue : null;
+    }
+}
+
+export { TraceState };

package/widget/location_provider.js

@@ -0,0 +1,9 @@
+class LocationProvider {
+    get hostname() {
+        // console.log(`[LocationProvider] hostname=${window.location.hostname}`);
+        return window.location.hostname;
+    }
+}
+/* export default */ const location_provider = (LocationProvider);
+
+export default location_provider;

package/widget/marketo_visitor.js

@@ -0,0 +1,39 @@
+import { __webpack_require__ } from "../js/runtime.js";
+import { api } from "../js/4101.js";
+import "./utils/native_globals.js";
+
+/* provided dependency */ var marketo_visitor_setInterval = __webpack_require__(68034).LK;
+/* provided dependency */ var marketo_visitor_clearInterval = __webpack_require__(68034).wm;
+
+const timeout = 1000;
+class MarketoVisitor {
+    async getToken() {
+        return new Promise((resolve)=>{
+            // Marketo's Munchkin tracking sets a cookie with the form:
+            // id:123-ABC-789&token:_mch-localhost-1585090488855-75516
+            const getCookiedToken = ()=>api.get("_mkto_trk");
+            if (getCookiedToken()) {
+                // cookie exists already
+                resolve(getCookiedToken());
+            } else if (window.Munchkin) {
+                // munchkin tracking exists but cookie isn't set yet
+                const startTime = Date.now();
+                const intervalId = marketo_visitor_setInterval(()=>{
+                    if (getCookiedToken()) {
+                        marketo_visitor_clearInterval(intervalId);
+                        resolve(getCookiedToken());
+                    } else if (Date.now() - startTime > timeout) {
+                        marketo_visitor_clearInterval(intervalId);
+                        resolve(undefined);
+                    }
+                }, 200);
+            } else {
+                // no cookie or tracking
+                resolve(undefined);
+            }
+        });
+    }
+}
+/* export default */ const marketo_visitor = (MarketoVisitor);
+
+export default marketo_visitor;

package/widget/meetings/tracing/buttons_forms_triggering_tracer.js

@@ -0,0 +1,124 @@
+import "../../telemetry/index.js";
+import { getSentryClient } from "../../widget/sentry.js";
+import { ButtonsTriggeringSpans } from "./spans/button_spans.js";
+import { FormsTriggeringSpans } from "./spans/form_spans.js";
+import { tracingStore as tracing_store_tracingStore } from "../../telemetry/tracing_store.js";
+
+
+
+
+
+class ButtonsFormsTriggeringTracer {
+    static startButtonClickSpan() {
+        tracing_store_tracingStore.startSpan(ButtonsTriggeringSpans.BUTTON_CLICK);
+        tracing_store_tracingStore.startSpan(ButtonsTriggeringSpans.WAIT_FOR_LIGHTBOX_LOADING_SPINNER, {
+            parentSpan: ButtonsTriggeringSpans.BUTTON_CLICK
+        });
+    }
+    static startSubmitFormSpan(attributes) {
+        tracing_store_tracingStore.startSpan(FormsTriggeringSpans.SUBMIT_FORM, {
+            attributes
+        });
+    }
+    static finishFormOrButtonSpan(message) {
+        const attributes = this.extractAttributesIfFormsOrButtonsResponse(message);
+        if (attributes) {
+            /**
+       * Buttons can be very fast and not have enough time to show the loading spinner,
+       * so we remove the loading spinner span since for this execution no loading spinner was necessary.
+       */ tracing_store_tracingStore.cancelSpan(ButtonsTriggeringSpans.WAIT_FOR_LIGHTBOX_LOADING_SPINNER);
+            tracing_store_tracingStore.finishSpans([
+                FormsTriggeringSpans.SUBMIT_FORM,
+                ButtonsTriggeringSpans.BUTTON_CLICK
+            ], {
+                attributes
+            });
+        }
+    }
+    static finishWaitForLightboxLoadingSpinnerSpan() {
+        tracing_store_tracingStore.finishSpan(ButtonsTriggeringSpans.WAIT_FOR_LIGHTBOX_LOADING_SPINNER);
+    }
+    static nonEmptyUniqueValues(values) {
+        const uniqueValues = Array.from(new Set(values));
+        return uniqueValues.filter((value)=>value !== undefined).filter((value)=>value !== null).filter((value)=>value !== "");
+    }
+    static setExperienceResultType(attributes, result) {
+        attributes["app.experience_result_type"] = result;
+    }
+    static updateExperienceResultType(param) {
+        let { attributes, widgetInitAfterButtonOrForm, fallbackToDefaultForButtonOrForm, messages = [] } = param;
+        if (widgetInitAfterButtonOrForm) {
+            this.setExperienceResultType(attributes, "widget");
+        } else if (fallbackToDefaultForButtonOrForm) {
+            this.setExperienceResultType(attributes, "fallback_to_default");
+        } else {
+            const messageTypes = this.nonEmptyUniqueValues(messages.map((msg)=>msg.type));
+            if (messageTypes.length > 0) {
+                attributes["message.types"] = messageTypes;
+                if (!attributes["app.experience_result_type"]) {
+                    const isQualificationQuestions = messageTypes.includes("lightbox_gather");
+                    const isMeetingBooker = messageTypes.includes("calendar_event_offer");
+                    if (isQualificationQuestions) {
+                        this.setExperienceResultType(attributes, "qualification_questions");
+                    } else if (isMeetingBooker) {
+                        this.setExperienceResultType(attributes, "meeting_booker");
+                    } else {
+                        this.setExperienceResultType(attributes, "unknown");
+                    }
+                }
+            }
+        }
+    }
+    static extractAttributesIfFormsOrButtonsResponse(message) {
+        let attributes;
+        try {
+            var _message_payload_messages, _message_payload, _message_payload_conversations, _message_payload1, _message_payload2;
+            const hasMessages = (((_message_payload = message.payload) == null ? void 0 : (_message_payload_messages = _message_payload.messages) == null ? void 0 : _message_payload_messages.length) || 0) > 0;
+            const hasConversations = (((_message_payload1 = message.payload) == null ? void 0 : (_message_payload_conversations = _message_payload1.conversations) == null ? void 0 : _message_payload_conversations.length) || 0) > 0;
+            /**
+       * This indicates a full-screen meeting booker or qualification questions were shown.
+       */ const fullscreenMBOrQQ = message.event === "initElementConversation" && hasMessages;
+            /**
+       * This indicates the same as above, but when the return was async (maybe if experience has
+       * pushes after routing for a meeting).
+       */ const asyncFullscreenMBOrQQ = message.event === "elementMessage";
+            /**
+       * This indicates a conversation (widget) as a result of a form submission or button trigger.
+       */ const lastConversation = hasConversations && message.payload.conversations[message.payload.conversations.length - 1];
+            const widgetInitAfterButtonOrForm = message.event === "initState" && [
+                "smart_cta",
+                "form"
+            ].includes(lastConversation == null ? void 0 : lastConversation.triggeredByBotType);
+            const fallbackToDefaultForButtonOrForm = message.event === "closeLightbox" && ((_message_payload2 = message.payload) == null ? void 0 : _message_payload2.fallbackToDefault) === true;
+            if (fullscreenMBOrQQ || asyncFullscreenMBOrQQ || widgetInitAfterButtonOrForm || fallbackToDefaultForButtonOrForm) {
+                attributes = {};
+                this.updateExperienceResultType({
+                    attributes,
+                    widgetInitAfterButtonOrForm,
+                    fallbackToDefaultForButtonOrForm
+                });
+                if (hasMessages) {
+                    const { messages = [] } = message.payload || {};
+                    this.updateExperienceResultType({
+                        attributes,
+                        messages
+                    });
+                    const uniqueEventTypes = this.nonEmptyUniqueValues(messages.map((msg)=>msg.eventType));
+                    if (uniqueEventTypes.length > 0) {
+                        attributes["message.event_types"] = uniqueEventTypes;
+                    }
+                    const uniqueConversationIds = this.nonEmptyUniqueValues(messages.map((msg)=>msg.conversationId));
+                    if (uniqueConversationIds.length > 0) {
+                        attributes["conversation.ids"] = uniqueConversationIds;
+                    }
+                }
+            }
+        } catch (e) {
+            var _getSentryClient;
+            (_getSentryClient = getSentryClient()) == null ? void 0 : _getSentryClient.captureException(e);
+        }
+        return attributes;
+    }
+}
+
+export { ButtonsFormsTriggeringTracer };

package/widget/meetings/tracing/spans/button_spans.js

@@ -0,0 +1,18 @@
+const ButtonsTriggeringSpans = {
+    /**
+   * This span involves triggering a button and getting a response (either conversation or full-screen meeting booker).
+   * Ignores loading state.
+   */ BUTTON_CLICK: {
+        name: "Visitor: Button Click",
+        samplingProbability: 1.0
+    },
+    /**
+   * When triggering an experience via buttons, we may show the lightbox loading spinner if the process takes too long.
+   * See Messenger.jsx#useMeetingProgressBar for more details.
+   */ WAIT_FOR_LIGHTBOX_LOADING_SPINNER: {
+        name: "System: Wait for lightbox loading spinner",
+        samplingProbability: 1.0
+    }
+};
+
+export { ButtonsTriggeringSpans };

package/widget/meetings/tracing/spans/form_spans.js

@@ -0,0 +1,11 @@
+const FormsTriggeringSpans = {
+    /**
+   * This span involves triggering a form experiences and getting a response (either conversation or full-screen meeting booker).
+   * Ignores loading state.
+   */ SUBMIT_FORM: {
+        name: "Visitor: Submit Form",
+        samplingProbability: 1.0
+    }
+};
+
+export { FormsTriggeringSpans };