@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/booker_outcome_tracker.js

@@ -0,0 +1,329 @@
+import { __webpack_require__ } from "../js/runtime.js";
+import "./utils/native_globals.js";
+import { _extends } from "../js/4101.js";
+
+/* provided dependency */ var booker_outcome_tracker_setTimeout = __webpack_require__(68034).pS;
+/* provided dependency */ var __nativeWindowAddEventListener = __webpack_require__(68034).zh;
+/* provided dependency */ var __nativeDocumentAddEventListener = __webpack_require__(68034).Qj;
+/* provided dependency */ var booker_outcome_tracker_clearTimeout = __webpack_require__(68034).Kj;
+/* provided dependency */ var __nativeWindowRemoveEventListener = __webpack_require__(68034).kZ;
+/* provided dependency */ var __nativeDocumentRemoveEventListener = __webpack_require__(68034).LA;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Booker SLI classification — two ORTHOGONAL axes; do not conflate them:
+//
+//   pathway_origin — how/where the visitor reached the offer. SERVER-CANONICAL:
+//     values MUST match Ruby `Telemetry::Attributes::PathwayOrigin` (derived from
+//     conversation_type + offer.source + live_booker) so this client SLI
+//     reconciles with the server `book_calendar_event` log.
+//   surface — which client app rendered the booker (ours; failure-localization).
+//     NOT "where the visitor was" — that's pathway_origin.
+//
+//   pathway_origin | conversation_type             | surface                | this SLI?
+//   ---------------|-------------------------------|------------------------|----------
+//   chat           | chat (source != auto_respond) | legacy                 | yes
+//   ai_agent       | chat (source == auto_respond) | multimodal             | yes
+//   form           | element                       | legacy | multimodal     | yes (each app's lightbox)
+//   meeting_link   | meeting_link[_routed]         | standalone             | not yet (convergence)
+//   live_booking   | live_booking                  | (live_booker)          | no (rep-side)
+//
+// web_extension composes slot links in Gmail; the prospect self-books on the
+// standalone page (flagged `web_extension_offer` server-side) — not a surface here.
+// ─────────────────────────────────────────────────────────────────────────────
+const BOOKER_OUTCOME = {
+    SHOWN: "shown",
+    FAILED: "failed",
+    ABANDONED: "abandoned"
+};
+// Mirror of Ruby `Telemetry::Attributes::PathwayOrigin` — values MUST stay
+// identical so the SLI reconciles with `book_calendar_event`. The client only
+// derives chat/form/ai_agent; meeting_link/live_booking belong to surfaces this
+// SLI does not emit (standalone, live booker) and are kept for the shared vocabulary.
+const BOOKER_PATHWAY_ORIGIN = {
+    CHAT: "chat",
+    FORM: "form",
+    AI_AGENT: "ai_agent",
+    MEETING_LINK: "meeting_link",
+    LIVE_BOOKING: "live_booking"
+};
+// Which client app rendered the booker (NOT where the visitor was — that is
+// pathway_origin). `legacy` = the classic React widget runtime (in-chat messenger
+// + its form/CTA lightbox); `multimodal` = the Preact multimodal widget;
+// `standalone` = the meeting-link page, which emits this vocabulary through its
+// own `StandaloneBookerSli` rather than through this tracker.
+const BOOKER_SURFACE = {
+    LEGACY: "legacy",
+    MULTIMODAL: "multimodal",
+    STANDALONE: "standalone"
+};
+// Client-observed pipeline stage this SLI reports on, stamped on the same
+// `@meeting_stage` facet as the server meeting logs. Distinct from the server's
+// `available_slots` ("calendar computed") - this is the client "booker rendered
+// to the visitor" step.
+const BOOKER_SHOWN_MEETING_STAGE = "booker_shown";
+// Standalone booker uses a 90s watchdog; mirror it for the embedded surfaces.
+const BOOKER_LOAD_TIMEOUT_MS = 90000;
+/**
+ * Mirror of Ruby `PathwayOrigin::CONVERSATION_TYPE_MAP`. Kept as a map rather
+ * than a chain of conditionals so a missing entry is visible against the server's
+ * own table instead of silently falling through to the default.
+ */ const CONVERSATION_TYPE_TO_PATHWAY = {
+    chat: BOOKER_PATHWAY_ORIGIN.CHAT,
+    element: BOOKER_PATHWAY_ORIGIN.FORM,
+    meeting_link: BOOKER_PATHWAY_ORIGIN.MEETING_LINK,
+    meeting_link_routed: BOOKER_PATHWAY_ORIGIN.MEETING_LINK
+};
+/**
+ * Derives the canonical `pathway_origin` tag from socket-serialized values,
+ * normalized defensively for enum casing.
+ *
+ * Follows the server's precedence exactly (`PathwayOrigin.derive`): conversation
+ * type decides first, and `auto_respond` only promotes to `ai_agent` when that
+ * type is `chat`. Checking the offer source first — as this did — reported
+ * `ai_agent` for an `auto_respond` offer in a `meeting_link` conversation, where
+ * the server says `meeting_link`.
+ *
+ * `meeting_link` / `meeting_link_routed` are unreachable from today's callers:
+ * `StandaloneMeetingBooker` renders `LightboxEntry` without a `serverLog`, so the
+ * widget tracker no-ops there and standalone emits through `StandaloneBookerSli`
+ * with the pathway passed as a literal. They are mapped anyway because this
+ * function is specified to mirror the Ruby enum — see the file header — and a
+ * partial mirror is the bug it just had for `element`: a type the server
+ * recognises, silently relabelled `chat` here. Completeness is the contract,
+ * independent of which entries anything currently reaches.
+ *
+ * One deliberate divergence: the server returns `nil` for an unrecognised type
+ * ("never assert a pathway we can't determine"); this returns `chat`, because the
+ * tracker needs a value to emit at all and dropping the event loses more than a
+ * slightly wrong tag on a conversation type that does not exist yet.
+ */ function bookerPathwayOrigin(conversationType, offerSource) {
+    var _CONVERSATION_TYPE_TO_PATHWAY__toLowerCase;
+    const origin = (_CONVERSATION_TYPE_TO_PATHWAY__toLowerCase = CONVERSATION_TYPE_TO_PATHWAY[(conversationType != null ? conversationType : "").toLowerCase()]) != null ? _CONVERSATION_TYPE_TO_PATHWAY__toLowerCase : BOOKER_PATHWAY_ORIGIN.CHAT;
+    if (origin === BOOKER_PATHWAY_ORIGIN.CHAT && (offerSource != null ? offerSource : "").toLowerCase() === "auto_respond") {
+        return BOOKER_PATHWAY_ORIGIN.AI_AGENT;
+    }
+    return origin;
+}
+// One terminal outcome per offer, enforced across tracker instances: a booker
+// component can mount more than once for the same offer (e.g. a remount in the
+// legacy lightbox), and each mount arms its own tracker. Dedupe by offer id so
+// the SLI counts each offer once regardless of how many trackers see it.
+const emittedOfferIds = new Set();
+/** Test-only: clears the cross-instance dedupe set between cases. */ function resetEmittedBookerOutcomes() {
+    emittedOfferIds.clear();
+}
+class BookerOutcomeTracker {
+    arm(offerMessageId, pathwayOrigin, conversationType) {
+        this.safely(()=>{
+            // Re-arming (offer -> offer without an intervening dispose) must cancel the
+            // previous offer's watchdog and listener first; otherwise the stale timer
+            // fires against the new offer's id and emits a premature `failed`.
+            this.teardown();
+            this.offerMessageId = offerMessageId;
+            this.pathwayOrigin = pathwayOrigin;
+            this.conversationType = conversationType;
+            // `undefined`, not 0, when there is no clock: 0 is a legitimate
+            // `performance.now()` reading, so falling back to it made an unmeasurable
+            // arm indistinguishable from one at page load. `timing()` then computed
+            // `now() - 0` — time since navigation start, not since arm (claude).
+            this.armedAtMs = typeof performance !== "undefined" ? performance.now() : undefined;
+            this.resolved = false;
+            // Seeded from the current state, not just from later transitions: an offer
+            // that arrives while the tab is already backgrounded never fires
+            // `visibilitychange`, so without this its whole wait would be timed as if
+            // the visitor had been watching.
+            this.armedWhileHidden = !this.documentVisible();
+            this.hiddenAtMs = undefined;
+            this.returnedFromHidden = false;
+            this.timeoutId = booker_outcome_tracker_setTimeout(this.handleTimeout, this.timeoutMs);
+            if (typeof window !== "undefined") {
+                __nativeWindowAddEventListener("pagehide", this.handlePagehide);
+            }
+            if (typeof document !== "undefined") {
+                __nativeDocumentAddEventListener("visibilitychange", this.handleVisibilityChange);
+            }
+        });
+    }
+    markShown() {
+        this.safely(()=>this.resolve(BOOKER_OUTCOME.SHOWN));
+    }
+    dispose() {
+        this.safely(()=>{
+            this.teardown();
+            this.offerMessageId = null;
+        });
+    }
+    documentVisible() {
+        if (typeof document === "undefined") return true;
+        return document.visibilityState === "visible";
+    }
+    nowMs() {
+        return typeof performance !== "undefined" ? performance.now() : 0;
+    }
+    // This tracker is pure observability; a fault here must never disrupt the
+    // booker it instruments. Every public entry point and event handler runs
+    // through this guard, so a broken transport (or an exotic browser API) drops
+    // one SLI datapoint instead of throwing into the booker's render/init path.
+    safely(fn) {
+        try {
+            fn();
+        } catch (unused) {
+        // Intentionally swallowed: losing a datapoint is strictly preferable to
+        // breaking the meeting booker.
+        }
+    }
+    resolve(outcome) {
+        if (this.resolved || !this.offerMessageId) return;
+        this.resolved = true;
+        // Tear down before emitting so a throwing transport cannot leak the pending
+        // timeout or the pagehide listener.
+        this.teardown();
+        this.emit(outcome);
+    }
+    emit(outcome) {
+        if (!this.offerMessageId) return;
+        if (emittedOfferIds.has(this.offerMessageId)) return;
+        emittedOfferIds.add(this.offerMessageId);
+        this.log(_extends({
+            type: "log",
+            message: "booker_outcome",
+            extra: _extends({
+                meeting_stage: BOOKER_SHOWN_MEETING_STAGE,
+                outcome,
+                surface: this.surface,
+                pathway_origin: this.pathwayOrigin,
+                conversation_type: this.conversationType,
+                offer_message_id: this.offerMessageId
+            }, this.timing(outcome))
+        }, outcome === BOOKER_OUTCOME.ABANDONED ? {
+            fireAndForget: true
+        } : {}));
+    }
+    /**
+   * Elapsed time from arm, or nothing when it cannot be trusted.
+   *
+   * Withheld rather than clamped: an absent value is honest about not knowing,
+   * whereas a capped one invents a number that looks like a real measurement.
+   * Mirrors `StandaloneBookerSli#timing`, which has always done this — the guard
+   * was simply never applied to this tracker, though the same reasoning already
+   * gates `failed` in `handleTimeout`.
+   *
+   * The outcome itself is never withheld; only the timing is.
+   *
+   * What the number means depends on the outcome, so the rule does too.
+   *
+   * `abandoned` measures the wait before giving up, so its clock stops at the
+   * first hidden transition. Browsers fire `visibilitychange:hidden` before
+   * `pagehide` on a navigation, so a blanket "was ever hidden" rule would discard
+   * every abandoned timing — including the ones where that transition *was* the
+   * visitor leaving, which is the number this outcome exists to report.
+   *
+   * `shown` and `failed` measure time to render, so they need the tab visible
+   * throughout. Applying the same clock-stop here would report a paint time from
+   * before the paint, which matches no real event.
+   *
+   * A backgrounded visitor is never penalised by any of this: the booker still
+   * resolves `shown` when it renders, and `handleTimeout` refuses to fire while
+   * hidden, so not seeing the UI never becomes a failure. Only the timing is
+   * withheld.
+   */ timing(outcome) {
+        if (typeof performance === "undefined") return {};
+        // No visible baseline: the offer arrived to an already-backgrounded tab, so
+        // there is no point at which the visitor started waiting.
+        if (this.armedWhileHidden) return {};
+        // `abandoned` measures how long the visitor waited before giving up, so the
+        // clock stops when they stopped watching. On a navigation that transition is
+        // the departure itself, which is the number this outcome exists to report.
+        if (outcome === BOOKER_OUTCOME.ABANDONED) {
+            var _this_hiddenAtMs;
+            // Hidden, returned, then left: they waited across two intervals with idle
+            // time between, and the tracker cannot subtract the middle out.
+            if (this.returnedFromHidden) return {};
+            return this.elapsedTo((_this_hiddenAtMs = this.hiddenAtMs) != null ? _this_hiddenAtMs : this.nowMs());
+        }
+        // `shown` and `failed` measure time to render, which is only meaningful if
+        // the visitor was watching for all of it. Stopping the clock at a hidden
+        // transition here would report a paint time from before the paint happened —
+        // a number matching no real event.
+        if (this.hiddenAtMs !== undefined || !this.documentVisible()) return {};
+        return this.elapsedTo(this.nowMs());
+    }
+    elapsedTo(endMs) {
+        if (this.armedAtMs === undefined) return {};
+        const elapsed = Math.round(endMs - this.armedAtMs);
+        return Number.isFinite(elapsed) && elapsed >= 0 ? {
+            timing: elapsed
+        } : {};
+    }
+    teardown() {
+        if (this.timeoutId !== undefined) {
+            booker_outcome_tracker_clearTimeout(this.timeoutId);
+            this.timeoutId = undefined;
+        }
+        if (typeof window !== "undefined") {
+            __nativeWindowRemoveEventListener("pagehide", this.handlePagehide);
+        }
+        if (typeof document !== "undefined") {
+            __nativeDocumentRemoveEventListener("visibilitychange", this.handleVisibilityChange);
+        }
+    }
+    constructor({ surface, log, timeoutMs = BOOKER_LOAD_TIMEOUT_MS }){
+        this.offerMessageId = null;
+        this.pathwayOrigin = BOOKER_PATHWAY_ORIGIN.CHAT;
+        this.conversationType = "chat";
+        this.resolved = false;
+        // Visibility state for the timing guard. Three fields rather than one boolean
+        // because "the tab went hidden" has two very different meanings: the visitor
+        // left (the hidden transition IS the departure, and the elapsed time up to it
+        // is exactly what we want to report) or the visitor tab-switched and came back
+        // (the elapsed time now spans an interval they were not watching, and we
+        // cannot subtract it out).
+        this.armedWhileHidden = false;
+        this.returnedFromHidden = false;
+        this.handleTimeout = ()=>{
+            this.safely(()=>{
+                // Only count a load timeout as a failure when the page is actually visible;
+                // a timeout that fires in a hidden tab is not an honest "didn't show".
+                if (typeof document !== "undefined" && document.visibilityState !== "visible") return;
+                this.resolve(BOOKER_OUTCOME.FAILED);
+            });
+        };
+        // Records visibility transitions for the timing guard only. This deliberately
+        // does NOT resolve an outcome: `visibilitychange:hidden` fires on plain tab
+        // switches, so treating it as abandonment would be a false positive.
+        // Abandonment stays on `pagehide` below; this only decides whether, and up to
+        // what moment, the measurement can be trusted.
+        this.handleVisibilityChange = ()=>{
+            this.safely(()=>{
+                if (!this.documentVisible()) {
+                    var // First hidden transition only — that is when the visitor stopped
+                    // watching. A later one is irrelevant because returning already
+                    // invalidated the measurement.
+                    _this_hiddenAtMs;
+                    (_this_hiddenAtMs = this.hiddenAtMs) != null ? _this_hiddenAtMs : this.hiddenAtMs = this.nowMs();
+                } else if (this.hiddenAtMs !== undefined) {
+                    this.returnedFromHidden = true;
+                }
+            });
+        };
+        // Drive abandonment from `pagehide` (fires reliably on tab close, navigation,
+        // refresh) but skip bfcache transitions (`persisted`) — the page can be
+        // restored, so the visitor has not abandoned. We deliberately ignore
+        // `visibilitychange:hidden`, which fires on plain tab switches too.
+        this.handlePagehide = (event)=>{
+            this.safely(()=>{
+                if (event.persisted) return;
+                this.resolve(BOOKER_OUTCOME.ABANDONED);
+            });
+        };
+        this.surface = surface;
+        this.log = log;
+        this.timeoutMs = timeoutMs;
+    }
+}
+
+var booker_outcome_tracker_BOOKER_LOAD_TIMEOUT_MS = /* unused export */ undefined;
+var booker_outcome_tracker_BOOKER_OUTCOME = /* unused export */ undefined;
+var booker_outcome_tracker_BOOKER_SHOWN_MEETING_STAGE = /* unused export */ undefined;
+var booker_outcome_tracker_resetEmittedBookerOutcomes = /* unused export */ undefined;
+export { BOOKER_PATHWAY_ORIGIN, BOOKER_SURFACE, BookerOutcomeTracker, bookerPathwayOrigin, booker_outcome_tracker_BOOKER_LOAD_TIMEOUT_MS as BOOKER_LOAD_TIMEOUT_MS, booker_outcome_tracker_BOOKER_OUTCOME as BOOKER_OUTCOME, booker_outcome_tracker_BOOKER_SHOWN_MEETING_STAGE as BOOKER_SHOWN_MEETING_STAGE, booker_outcome_tracker_resetEmittedBookerOutcomes as resetEmittedBookerOutcomes };

package/widget/capture_widget_exceptions.js

@@ -0,0 +1,150 @@
+import { getSentryClient } from "./widget/sentry.js";
+import { createPropertyDecorator } from "../src/decorators.js";
+
+
+
+const handleErrorFn = (options, target, propertyKey, widget)=>(error)=>{
+        try {
+            var _getSentryClient;
+            // Cannot act on falsy errors
+            if (!error) return;
+            (_getSentryClient = getSentryClient()) == null ? void 0 : _getSentryClient.captureException(error);
+            if (options == null ? void 0 : options.sendToServer) {
+                const context = (options == null ? void 0 : options.context) || target.constructor.name + "#" + propertyKey;
+                const normalizedError = normalizeError(error);
+                const extra = {
+                    context
+                };
+                if (typeof normalizedError.stack === "string") {
+                    extra.stack = normalizedError.stack;
+                }
+                widget.serverLog({
+                    message: normalizedError.message,
+                    type: "both",
+                    extra
+                });
+            }
+        } catch (e) {
+            // Wrap in a try/catch to prevent error-handling code from causing regressions
+            console.warn("Qualified: An unexpected issue occurred in captureWidgetExceptions", e); // eslint-disable-line no-console
+        }
+        // Rethrow unless explicitly told not to
+        if ((options == null ? void 0 : options.rethrow) !== false) {
+            throw error;
+        }
+    };
+/**
+ * Creates a decorator that wraps a method with exception capturing functionality.
+ * @param {CaptureWidgetExceptionsOptions | undefined} options - Configuration options for exception capturing
+ * @param {any} target - The prototype of the class (for instance methods) or the constructor (for static methods)
+ * @param {string} propertyKey - The name of the method being decorated
+ * @param {WidgetPropertyDescriptor} descriptor - The property descriptor for the method
+ * @returns {PropertyDescriptor} A modified property descriptor with error capturing logic
+ */ const captureWidgetExceptions = createPropertyDecorator((options, target, propertyKey, descriptor)=>{
+    const originalMethod = descriptor.value;
+    descriptor.value = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        const handleError = handleErrorFn(options, target, propertyKey, this.widget);
+        try {
+            const result = originalMethod.apply(this, args);
+            // If the original method was an async function, it'll return a thenable:
+            if (result && typeof result.catch === "function") {
+                return result.catch(handleError);
+            }
+            return result;
+        } catch (error) {
+            handleError(error);
+        }
+    };
+    return descriptor;
+});
+/**
+ * This function handles different error formats and converts them into
+ * a standardized object with a 'message' property and an optional 'stack' property.
+ * @param {unknown} error - The error to be normalized. Can be a string, Error object,
+ *                          an object with a 'message' property, or any other type.
+ * @returns {{ message: string; stack?: string }} An object with the following properties:
+ *   - message: A string representation of the error message.
+ *   - stack: (Optional) The error stack trace, if available.
+ * @example
+ * // 1) String error:
+ * normalizeError("err msg") => { message: "err msg" }
+ *
+ * // 2) Error object:
+ * normalizeError(new Error("err msg")) => { message: "err msg", stack: "<STACK_TRACE_HERE>" }
+ *
+ * // 3) Plain object - attempts JSON.stringify first:
+ * normalizeError({ abc: 123 }) => { message: '{"abc":123}' }
+ *
+ * // 4) Non-stringify-able objects (e.g. circular objects) - falls back to String():
+ * const circular = { self: {} }
+ * circular.self = circular
+ * normalizeError(circular) => { message: "[object Object]" }
+ *
+ * // 5) Everything else - uses String():
+ * normalizeError(42) => { message: "42" }
+ */ function normalizeError(error) {
+    // Cannot act on falsy errors
+    if (!error) return {
+        message: "Unknown error"
+    };
+    if (typeof error === "string") {
+        return {
+            message: error
+        };
+    } else if (error instanceof Error) {
+        return {
+            message: error.message,
+            stack: error.stack
+        };
+    } else if (error && typeof error === "object") {
+        try {
+            return {
+                message: JSON.stringify(error)
+            };
+        } catch (unused) {
+        /* NOOP - Fall back to String(error) */ }
+    }
+    return {
+        message: String(error)
+    };
+}
+/**
+ * A function that wraps a class with exception capturing functionality.
+ * It adds error logging to all methods of the provided class.
+ * Applied at runtime, because not all instances of a given class
+ * require exception capturing.
+ *
+ * @template T - A type that extends a constructor function
+ * @param {T} BaseClass - The class to be wrapped with exception capturing
+ * @param {Widget} widget - The widget instance required to use captureWidgetExceptions
+ * @param {CaptureWidgetExceptionsOptions} options - Configuration options for exception capturing
+ * @returns {T} A new class that extends BaseClass with added error capturing
+ */ function withCaptureExceptions(BaseClass, widget, options) {
+    if (options === void 0) options = {};
+    return class extends BaseClass {
+        constructor(...args){
+            super(...args);
+            this.widget = widget;
+            try {
+                const methodNames = Object.getOwnPropertyNames(BaseClass.prototype);
+                methodNames.forEach((methodName)=>{
+                    if (methodName !== "constructor" && typeof this[methodName] === "function") {
+                        const originalMethod = this[methodName];
+                        this[methodName] = captureWidgetExceptions(options)(this, methodName, {
+                            value: originalMethod
+                        }).value;
+                    }
+                });
+            } catch (e) {
+                // Wrap in a try/catch to prevent error-handling code from causing regressions
+                console.warn("Qualified: An unexpected issue occurred in withCaptureExceptions", e); // eslint-disable-line no-console
+            }
+        }
+    };
+}
+
+var capture_widget_exceptions_normalizeError = /* unused export */ undefined;
+export { captureWidgetExceptions, capture_widget_exceptions_normalizeError as normalizeError, withCaptureExceptions };