@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/channel.js

@@ -0,0 +1,282 @@
+import { __webpack_require__ } from "../js/runtime.js";
+import "../js/4101.js";
+import { createConsumer } from "../vendor/actioncable/index.js";
+import { default as connection_monitor } from "../vendor/actioncable/connection_monitor.js";
+import { getSentryClient } from "./widget/sentry.js";
+import { default as WidgetObject } from "./widget_object.js";
+import { resolveFormCtaBookerIntent } from "./form_cta_booker_intent.js";
+import { ButtonsFormsTriggeringTracer } from "./meetings/tracing/buttons_forms_triggering_tracer.js";
+import { QUALIFIED_FORM_EVENTS } from "./qualified_form/constants.js";
+import "./telemetry/index.js";
+import { once } from "../src/promises.js";
+import { buildTraceParent, getTelemetryCtx } from "./telemetry/telemetry.js";
+
+const isNil = __webpack_require__("11655");
+var isNil_default = /*#__PURE__*/__webpack_require__.n(isNil);
+const omitBy = __webpack_require__("35270");
+var omitBy_default = /*#__PURE__*/__webpack_require__.n(omitBy);
+const tiny_emitter = __webpack_require__("47441");
+
+
+
+
+
+
+
+
+
+
+
+
+const INIT_MEETING_LINK_CONVERSATION = "initMeetingLinkConversation";
+class Channel extends WidgetObject {
+    cleanup() {
+        this.disconnect();
+        super.cleanup();
+    }
+    // Override. TODO: this feels like a footgun.
+    get emitter() {
+        return this._emitter;
+    }
+    get cable() {
+        return this._cable;
+    }
+    resetWhenConnected() {
+        var _this_whenConnected;
+        (_this_whenConnected = this.whenConnected) == null ? void 0 : _this_whenConnected.cancel();
+        this.whenConnected = once(this._emitter, "connected", "disconnecting");
+        this.whenConnected.catch((reason)=>{
+            // Prevent `Uncaught (in promise)` error from leaking into dev console
+            if (reason !== "delay_connect" && reason !== "unauthorized") throw reason;
+        });
+    }
+    connect() {
+        var _this_config_staleThresholdSeconds;
+        // TODO: Return promise.resolve if already connected?
+        // Set stale threshold before creating consumer. Default 6 (was hardcoded prior to INF-1108).
+        // The previous hardcoded value of 6s was likely a bug - should be >= 2x the ping interval to
+        // allow for missed pings (ANYCABLE_PING_INTERVAL=4s in manhattan, so 2x = 8s, not 6s).
+        connection_monitor.staleThreshold = (_this_config_staleThresholdSeconds = this.config.staleThresholdSeconds) != null ? _this_config_staleThresholdSeconds : 6;
+        const params = this.widget.connectionParams, url = this.config.wsHost + "?" + new URLSearchParams(omitBy_default()(params, (isNil_default()))).toString();
+        this._cable = createConsumer(url);
+        this.subscription = this._cable.subscriptions.create({
+            channel: "Visitors::WidgetChannel"
+        }, {
+            connected: this.onConnected,
+            disconnecting: this.onDisconnecting,
+            ping: this.onPing,
+            received: this.onReceived
+        });
+        this.liveViewSubscription = this._cable.subscriptions.create({
+            channel: "CoBrowse::VisitorChannel"
+        }, {
+            received: this.onReceivedLiveView
+        });
+        return this.whenConnected;
+    }
+    disconnect() {
+        var _this_whenConnected;
+        (_this_whenConnected = this.whenConnected) == null ? void 0 : _this_whenConnected.cancel();
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+            this.subscription = null;
+        }
+        if (this.liveViewSubscription) {
+            this.liveViewSubscription.unsubscribe();
+            this.liveViewSubscription = null;
+        }
+        if (this._cable) {
+            this._cable.disconnect();
+            this._cable = null;
+        }
+        this.onDisconnected();
+        // When forcefully disconnecting, the presumption is that the visitor's
+        // session will end, and reconnecting will require the widget to be fully
+        // reinitialized. Reset the widgetId so that it's handled a like a new
+        // widget.
+        this.widget.resetWidgetId();
+    }
+    startEmitter() {
+        this.messages.forEach((message)=>this.handleMessage(message));
+        this.emittingMessages = true;
+    }
+    async send(data) {
+        var _this_subscription;
+        const telemetryCtx = getTelemetryCtx();
+        await this.whenConnected;
+        if (telemetryCtx) {
+            if (!data) {
+                data = {};
+            }
+            data.traceparent = buildTraceParent(telemetryCtx);
+        }
+        (_this_subscription = this.subscription) == null ? void 0 : _this_subscription.send(data);
+    }
+    async perform(action, data) {
+        var _this_subscription;
+        const telemetryCtx = getTelemetryCtx();
+        if (telemetryCtx) {
+            if (!data) {
+                data = {};
+            }
+            data.traceparent = buildTraceParent(telemetryCtx);
+        }
+        await this.whenConnected;
+        (_this_subscription = this.subscription) == null ? void 0 : _this_subscription.perform(action, data);
+    }
+    sendLiveView(data) {
+        var _this_liveViewSubscription;
+        (_this_liveViewSubscription = this.liveViewSubscription) == null ? void 0 : _this_liveViewSubscription.send(data);
+    }
+    on(event, callback, ctx) {
+        return this._emitter.on(event, callback, ctx);
+    }
+    once(event, callback, ctx) {
+        return this._emitter.once(event, callback, ctx);
+    }
+    off(event, callback) {
+        return this._emitter.off(event, callback);
+    }
+    emit(event) {
+        for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+            args[_key - 1] = arguments[_key];
+        }
+        return this._emitter.emit(event, ...args);
+    }
+    // Can't think of a better name
+    pingPong(emitMessage, awaitMessage, obj, cb) {
+        this._emitter.emit(emitMessage, obj);
+        return this.once(awaitMessage, cb);
+    }
+    // Not a real event handler but one spot for logic after either client-side or remote disconnect.
+    onDisconnected() {
+        this.resetWhenConnected();
+        this._emitter.emit("disconnected");
+    }
+    handleMessage(message) {
+        const singleEvents = [
+            "refresh",
+            "sessionEnded",
+            "idleTooLong"
+        ];
+        if (singleEvents.indexOf(message.event) > -1) {
+            this._emitter.emit(message.event);
+        } else {
+            // @ts-expect-error TS does not realize you can concat a non-array to an array and it will be inserted
+            [].concat(message).forEach((message)=>{
+                ButtonsFormsTriggeringTracer.finishFormOrButtonSpan(message);
+                // Same message, unsampled: resolves the pre-offer SLI for an armed
+                // form/CTA trigger. No-ops when nothing is armed.
+                resolveFormCtaBookerIntent(message);
+                if (message.event === "redirect" && message.payload.url) {
+                    var _this_offerScript;
+                    if (message.payload.isQualifiedForm && ((_this_offerScript = this.offerScript) == null ? void 0 : _this_offerScript.hasActiveForm)) {
+                        this._emitter.emit("qualifiedFormRedirect", message.payload);
+                    } else {
+                        this._emitter.emit(message.event);
+                        window.location.href = message.payload.url;
+                    }
+                } else if (message.event === "endLoadingState") {
+                    this._emitter.emit(message.event);
+                } else if (message.event === "personalizeWebsite") {
+                    this._emitter.emit(message.event, message.payload);
+                } else if (message.event === "initOffers") {
+                    const { payload: offers } = message;
+                    if (offers.length > 0) {
+                        this.widget.initializeOffers().then(()=>{
+                            this._emitter.emit(message.event, offers);
+                        });
+                    }
+                } else if (message.event === "getQualifiedFormConfig") {
+                    this._emitter.emit(message.event, message.payload);
+                } else if (message.event === "showExperienceEnd") {
+                    this._emitter.emit(message.event, message.payload);
+                } else if (message.event === INIT_MEETING_LINK_CONVERSATION) {
+                    this._emitter.emit(message.event, message.payload);
+                } else if (message.event === "widgetEvent") {
+                    this._emitter.emit(message.event, message.payload.event_name);
+                } else if (QUALIFIED_FORM_EVENTS.includes(message.event)) {
+                    this._emitter.emit(message.event, message.payload);
+                } else if (message.event === "syncScriptState") {
+                    this._emitter.emit(message.event, message.payload);
+                } else if (message.event.endsWith(":ack") || message.event.endsWith(":response")) {
+                    this._emitter.emit(message.event, message.payload);
+                } else {
+                    // Regular flow
+                    if (message.event === "initState") {
+                        if (message.payload.useNewMessengerStyling == null) {
+                            var _getSentryClient;
+                            (_getSentryClient = getSentryClient({
+                                project: "multimodal"
+                            })) == null ? void 0 : _getSentryClient.captureException(new Error("initState received with null useNewMessengerStyling"));
+                        }
+                        // Emit standalone initState for Telemetry recording
+                        this.initStateReceived = true;
+                        this._emitter.emit("initState");
+                    } else if (message.event === "elementMessage") {
+                        // Emit conversation messages for form offers
+                        this._emitter.emit("elementMessage", message.payload);
+                    } else if (message.event === "callEnded") {
+                        this._emitter.emit("callEnded", message.payload);
+                    }
+                    // Check that the multimodal object has been instantiated instead of FF check
+                    if (this.widget.multimodal) {
+                        // Messages are being relayed to the iframe when not applicable to the multimodal v2
+                        this._emitter.emit("multimodal", message);
+                    } else {
+                        this._emitter.emit("received", message.event, message.payload);
+                    }
+                }
+            });
+        }
+    }
+    constructor(injectionProps){
+        super(injectionProps), // Private - Subscription events
+        this.onConnected = ()=>{
+            if (this.hasConnectedBefore) {
+                var _this_subscription;
+                (_this_subscription = this.subscription) == null ? void 0 : _this_subscription.send({
+                    event: "reconnected"
+                });
+                this._emitter.emit("reconnected");
+            }
+            this.hasConnectedBefore = true;
+            this._emitter.emit("connected");
+        }, // This fires on remote disconnects only
+        this.onDisconnecting = (info)=>{
+            if (info && info.reason) {
+                if (info.reason === "invalid_version") {
+                    this._emitter.emit("refresh");
+                }
+                this._emitter.emit("disconnecting", info.reason);
+            }
+            this.onDisconnected();
+        }, this.onPing = ()=>{
+            this._emitter.emit("ping");
+        }, this.onReceived = (message)=>{
+            if (this.emittingMessages) {
+                this.handleMessage(message);
+            } else {
+                this.messages.push(message);
+            }
+        }, this.onReceivedLiveView = (message)=>{
+            this.widget.initializePageMirror().then(()=>{
+                this._emitter.emit("receivedLiveView", message);
+            });
+        };
+        this._emitter = new tiny_emitter.TinyEmitter();
+        this._cable = null;
+        this.emittingMessages = false;
+        this.messages = [];
+        this.hasConnectedBefore = false;
+        this.initStateReceived = false;
+        this.subscription = null;
+        this.liveViewSubscription = null;
+        this.resetWhenConnected();
+    }
+}
+/* export default */ const channel = (Channel);
+
+var channel_INIT_MEETING_LINK_CONVERSATION = /* unused export */ undefined;
+export { channel_INIT_MEETING_LINK_CONVERSATION as INIT_MEETING_LINK_CONVERSATION };
+export default channel;

package/widget/composite_experience_adapter.js

@@ -0,0 +1,101 @@
+// Import is type-only to avoid pulling the multimodal store graph into the
+// bundle at module-eval time; RootStore only exists once multimodal_v2 loads.
+/**
+ * Wraps a `primary` ExperienceAdapter (the V1Adapter / legacy iframe) with a
+ * V2Adapter used only as an events bridge onto the multimodal RootStore.
+ *
+ * In the V1-adapter bundles the legacy iframe is hidden while multimodal renders
+ * the live UI, so messenger-event handlers registered on the V1Adapter alone
+ * never fire for multimodal transitions. This composite registers each handler
+ * on both layers so events fire from whichever presentation layer is active.
+ *
+ * Events (`addMessengerEventsListener`) fan out to BOTH layers — each self-guards
+ * so only the active layer fires, giving handlers a single stream. Messenger
+ * verbs and getters are visible-behavior actions that must target exactly ONE
+ * layer: the presentation layer that currently owns the session. That owner
+ * flips both directions mid-session (e.g. another tab switches the shared
+ * session), so routing is driven by a dynamic `multimodalOwns` signal fed from
+ * `MultimodalChannel` via `Widget.setMultimodalOwnsSession`. Lightbox verbs
+ * always go to `primary` because the hybrid gather still renders in the iframe.
+ *
+ * The bridge is only a valid messenger target once it has been bound to the
+ * RootStore, so messenger routing also requires `bridgeBound`. Until multimodal
+ * both owns the session AND the bridge is bound, messenger verbs fall through
+ * to `primary`.
+ */ class CompositeExperienceAdapter {
+    /** Bind the events bridge to the multimodal RootStore once it exists. */ bindEventsBridge(rootStore) {
+        this.eventsBridge.bindRootStore(rootStore);
+        this.bridgeBound = true;
+    }
+    /**
+   * Record which presentation layer owns the session. Fed from
+   * `MultimodalChannel` on every initState (both transition directions).
+   */ setMultimodalOwnsSession(owns) {
+        // Legacy ownership implies the multimodal RootStore may be torn down; force
+        // a fresh bind before the bridge can receive visible-behavior actions again.
+        if (!owns) this.bridgeBound = false;
+        this.multimodalOwns = owns;
+    }
+    /**
+   * The layer that should receive messenger verbs and getter reads: the bound
+   * bridge when multimodal owns the session, otherwise the primary.
+   */ get target() {
+        return this.multimodalOwns && this.bridgeBound ? this.eventsBridge : this.primary;
+    }
+    dispose() {
+        this.primary.dispose();
+        this.eventsBridge.dispose();
+    }
+    // Events: registered on both layers (each self-guards against firing while inactive).
+    addMessengerEventsListener(handler) {
+        this.primary.addMessengerEventsListener(handler);
+        this.eventsBridge.addMessengerEventsListener(handler);
+    }
+    // Lightbox verbs always go to primary; the hybrid gather still lives in the iframe.
+    showLightboxLoading() {
+        this.primary.showLightboxLoading();
+    }
+    showInlineLoading(uuid) {
+        this.primary.showInlineLoading(uuid);
+    }
+    closeLightbox() {
+        this.primary.closeLightbox();
+    }
+    // Visible-behavior verbs + getters: routed to the current session owner.
+    showMessengerLoading() {
+        this.target.showMessengerLoading();
+    }
+    openMessenger() {
+        this.target.openMessenger();
+    }
+    setChatIsVisible(visible) {
+        this.target.setChatIsVisible(visible);
+    }
+    get apMessagesCount() {
+        return this.target.apMessagesCount;
+    }
+    get autoRespondPounceCount() {
+        return this.target.autoRespondPounceCount;
+    }
+    get visitorResponded() {
+        return this.target.visitorResponded;
+    }
+    get userResponded() {
+        return this.target.userResponded;
+    }
+    get originalDocumentTitle() {
+        return this.target.originalDocumentTitle;
+    }
+    constructor(primary, eventsBridge){
+        // Multimodal (bridge) owns the session per the latest MultimodalChannel
+        // initState; flips both directions. Starts false so the legacy iframe owns
+        // until proven otherwise.
+        this.multimodalOwns = false;
+        // The bridge is only a valid routing target after bindEventsBridge() runs.
+        this.bridgeBound = false;
+        this.primary = primary;
+        this.eventsBridge = eventsBridge;
+    }
+}
+
+export { CompositeExperienceAdapter };