@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/multimodal_v2/utils/slide_zoom.js

@@ -0,0 +1,114 @@
+// Computes the inline style that zooms an on-screen media element (the demo video) IN toward a
+// focal point — centering the zoom on that point, not the middle of the media — without changing
+// the element's size on screen.
+//
+// It shows a window of the media (1/scale of the box) centered on the focal point, clamped so the
+// window never runs past the media's edges, and blows that window up to refill the box. So the
+// content the cursor is pointing at is what gets magnified and centered, and the footprint is
+// unchanged. `clip-path` clips the (translated, scaled) content back to the box.
+//
+// Because the focal point pans toward center, the on-screen position of the target moves — call
+// `slideZoomFocus` to find where it lands so the cursor can follow it. Pass null to reset.
+// Default/fallback magnification, used when we point without a bounding box (e.g. a bare focal
+// point) so there's nothing to size the zoom from. When we DO have a box, zoomScaleForBox picks the
+// scale adaptively instead — see below.
+const SLIDE_ZOOM_SCALE = 1.3;
+// Exported so the spotlight overlay can fade in/out on the same timing as the zoom.
+const SLIDE_ZOOM_TRANSITION_MS = 450;
+// Adaptive-zoom bounds. The zoomed viewport shows a 1/scale-sized window of the frame, so a big box
+// must use a gentle scale to stay in frame while a small box can be magnified hard.
+const ZOOM_MIN_SCALE = 1; // never zoom OUT; a near-full-frame box just isn't magnified
+const ZOOM_MAX_SCALE = 2; // cap so a tiny target doesn't blow up into a blurry mess
+// The box's larger side should fill at most this fraction of the zoomed viewport, leaving a margin
+// so the traced rectangle (which is padded outward a little) still sits inside the frame.
+const ZOOM_TARGET_FILL = 0.8;
+// Pick a magnification for a target bounding box (normalized [0,1] corners): the smaller the box,
+// the more we zoom; a wide/tall box gets little or no zoom so the whole thing stays visible. Uses the
+// box's LARGER dimension (the zoom is uniform, so the wider side is the binding constraint) and keeps
+// it at ZOOM_TARGET_FILL of the 1/scale window: scale = ZOOM_TARGET_FILL / size, clamped to bounds.
+function zoomScaleForBox(box) {
+    const largestSide = Math.max(Math.abs(box.x2 - box.x1), Math.abs(box.y2 - box.y1));
+    if (largestSide <= 0) return ZOOM_MAX_SCALE; // degenerate/point target: magnify fully
+    const fitScale = ZOOM_TARGET_FILL / largestSide;
+    return Math.min(ZOOM_MAX_SCALE, Math.max(ZOOM_MIN_SCALE, fitScale));
+}
+// Match the media's corner rounding so the clip doesn't square off the corners mid-zoom.
+const SLIDE_ZOOM_CORNER_RADIUS = "8px";
+// A smooth ease-out settle (easeOutQuint): the zoom moves off quickly then glides to a gentle stop,
+// rather than the browser's flatter, more mechanical default `ease-in-out`. Same curve in and out so
+// zooming back looks as smooth as zooming in.
+const SLIDE_ZOOM_EASING = "cubic-bezier(0.22, 1, 0.36, 1)";
+const TRANSITION = "transform " + SLIDE_ZOOM_TRANSITION_MS + "ms " + SLIDE_ZOOM_EASING + ", " + ("clip-path " + SLIDE_ZOOM_TRANSITION_MS + "ms " + SLIDE_ZOOM_EASING);
+const clamp01 = (v)=>Math.min(1, Math.max(0, v));
+// Top-left of the shown window (as a fraction of the box) for one axis: the window is 1/scale of
+// the box, centered on the focal point, clamped to stay within [0, 1].
+function windowOrigin(focal, scale) {
+    const windowSize = 1 / scale;
+    return Math.min(Math.max(focal - windowSize / 2, 0), 1 - windowSize);
+}
+// Where an arbitrary point lands (fraction of the box) after zooming toward `focal` — the same
+// mapping the media applies, so overlays (cursor, bounding box) can be placed on the zoomed content.
+// The window origin is set by the focal point, so every point shares one origin (unlike calling
+// slideZoomFocus per point, which would recompute the origin from each point).
+function slideZoomPoint(focal, point, scale) {
+    if (scale === void 0) scale = SLIDE_ZOOM_SCALE;
+    return {
+        x: scale * (clamp01(point.x) - windowOrigin(clamp01(focal.x), scale)),
+        y: scale * (clamp01(point.y) - windowOrigin(clamp01(focal.y), scale))
+    };
+}
+// Where the focal point lands (fraction of the box) after the zoom, so the cursor can be placed on
+// it. Centered when the window isn't clamped; pulled toward the edge when it is.
+function slideZoomFocus(focal, scale) {
+    if (scale === void 0) scale = SLIDE_ZOOM_SCALE;
+    return slideZoomPoint(focal, focal, scale);
+}
+// Recover an element's natural (un-zoomed) viewport rect from its measured rect while a slideZoom
+// transform is applied. slideZoomStyle scales the element by `scale` about its top-left and shifts
+// it by the window origin, so `measured` is the natural rect pushed through that transform; this
+// inverts it. Used when a new point arrives mid-zoom: getBoundingClientRect then reflects the
+// still-applied (and mid-transition) zoom, so the natural box can't be read from the DOM directly.
+function unzoomRect(rect, focal) {
+    var _focal_scale;
+    const s = (_focal_scale = focal.scale) != null ? _focal_scale : SLIDE_ZOOM_SCALE;
+    const wx = windowOrigin(clamp01(focal.x), s);
+    const wy = windowOrigin(clamp01(focal.y), s);
+    return {
+        left: rect.left + wx * rect.width,
+        top: rect.top + wy * rect.height,
+        width: rect.width / s,
+        height: rect.height / s
+    };
+}
+function slideZoomStyle(focal) {
+    var _focal_scale;
+    if (!focal) {
+        return {
+            transform: "translate(0%, 0%) scale(1)",
+            transformOrigin: "0 0",
+            clipPath: "inset(0 round " + SLIDE_ZOOM_CORNER_RADIUS + ")",
+            transition: TRANSITION
+        };
+    }
+    const s = (_focal_scale = focal.scale) != null ? _focal_scale : SLIDE_ZOOM_SCALE;
+    const fx = clamp01(focal.x);
+    const fy = clamp01(focal.y);
+    const wx = windowOrigin(fx, s);
+    const wy = windowOrigin(fy, s);
+    const pct = (v)=>"" + (v * 100).toFixed(3) + "%";
+    return {
+        transformOrigin: "0 0",
+        // Show the window [w, w + 1/s] scaled up to fill the box: scale about the top-left, then shift
+        // the window's origin to 0. translate() percentages are relative to the element's own box.
+        transform: "translate(" + pct(-s * wx) + ", " + pct(-s * wy) + ") scale(" + s + ")",
+        // Clip (in pre-transform space) to that same window so the scaled content fills exactly the box.
+        clipPath: "inset(" + pct(wy) + " " + pct(1 - wx - 1 / s) + " " + pct(1 - wy - 1 / s) + " " + pct(wx) + " " + ("round " + SLIDE_ZOOM_CORNER_RADIUS + ")"),
+        transition: TRANSITION
+    };
+}
+
+var slide_zoom_SLIDE_ZOOM_TRANSITION_MS = /* unused export */ undefined;
+var slide_zoom_ZOOM_MAX_SCALE = /* unused export */ undefined;
+var slide_zoom_ZOOM_MIN_SCALE = /* unused export */ undefined;
+var slide_zoom_ZOOM_TARGET_FILL = /* unused export */ undefined;
+export { SLIDE_ZOOM_SCALE, slideZoomFocus, slideZoomPoint, slideZoomStyle, slide_zoom_SLIDE_ZOOM_TRANSITION_MS as SLIDE_ZOOM_TRANSITION_MS, slide_zoom_ZOOM_MAX_SCALE as ZOOM_MAX_SCALE, slide_zoom_ZOOM_MIN_SCALE as ZOOM_MIN_SCALE, slide_zoom_ZOOM_TARGET_FILL as ZOOM_TARGET_FILL, unzoomRect, zoomScaleForBox };

package/widget/multimodal_v2/utils/theme_styles.js

@@ -0,0 +1,137 @@
+import { ButtonStyle as types_ButtonStyle, ButtonShape as types_ButtonShape } from "../types.js";
+
+
+const LIGHTEN_AMOUNT = 0.6;
+function normalizeHex(hex) {
+    let h = hex.replace("#", "");
+    if (h.length === 3) {
+        h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+    }
+    return h;
+}
+/**
+ * Darken a hex color by the given fraction (0–1).
+ * Accepts both 3-digit (#rgb) and 6-digit (#rrggbb) hex strings.
+ * Multiplies each RGB channel by (1 − amount).
+ */ function darkenHex(hex, amount) {
+    if (amount === void 0) amount = 0.15;
+    const h = normalizeHex(hex);
+    const mix = (offset)=>Math.max(0, Math.round(parseInt(h.substring(offset, offset + 2), 16) * (1 - amount)));
+    return "#" + [
+        mix(0),
+        mix(2),
+        mix(4)
+    ].map((c)=>c.toString(16).padStart(2, "0")).join("");
+}
+/**
+ * Lighten a hex color by mixing it toward white by the given fraction (0–1).
+ * Accepts both 3-digit (#rgb) and 6-digit (#rrggbb) hex strings.
+ */ function lightenHex(hex, amount) {
+    if (amount === void 0) amount = LIGHTEN_AMOUNT;
+    const h = normalizeHex(hex);
+    const mix = (offset)=>{
+        const channel = parseInt(h.substring(offset, offset + 2), 16);
+        return Math.min(255, Math.round(channel + (255 - channel) * amount));
+    };
+    return "#" + [
+        mix(0),
+        mix(2),
+        mix(4)
+    ].map((c)=>c.toString(16).padStart(2, "0")).join("");
+}
+function hexToRgba(hex, alpha) {
+    const h = normalizeHex(hex);
+    const r = parseInt(h.substring(0, 2), 16);
+    const g = parseInt(h.substring(2, 4), 16);
+    const b = parseInt(h.substring(4, 6), 16);
+    return "rgba(" + r + ", " + g + ", " + b + ", " + alpha + ")";
+}
+function createThemeCss(theme) {
+    const buttonStyles = getButtonStyles(theme);
+    return "\n    :root, :host {\n      --q-primary-color: " + theme.primaryColor + ";\n      --q-lighter-primary-color: " + lightenHex(theme.primaryColor) + ";\n      --q-text-color: " + theme.textColor + ";\n      --q-button-background-color: " + buttonStyles.backgroundColor + ";\n      --q-button-hover-background-color: " + buttonStyles.hoverBackgroundColor + ";\n      --q-button-background-layer: " + buttonStyles.backgroundLayer + ";\n      --q-button-hover-background-layer: " + buttonStyles.hoverBackgroundLayer + ";\n      --q-button-text-color: " + buttonStyles.textColor + ";\n      --q-button-hover-text-color: " + buttonStyles.hoverTextColor + ";\n      --q-button-border-color: " + buttonStyles.borderColor + ";\n      --q-button-hover-border-color: " + buttonStyles.hoverBorderColor + ";\n      --q-button-border-radius: " + buttonStyles.borderRadius + ";\n      --q-control-border-radius: " + buttonStyles.controlBorderRadius + ";\n    }\n  ";
+}
+/**
+ * Apply theme CSS custom properties directly on an element via style.setProperty().
+ *
+ * Used in split-css mode where adoptedStyleSheets and <style> injection are blocked
+ * by strict CSP (style-src 'self'). CSS custom properties set on an element are
+ * inherited through shadow DOM boundaries, so setting them on the shadow host
+ * makes them available inside the shadow root.
+ */ function applyThemeCssVars(element, theme) {
+    const buttonStyles = getButtonStyles(theme);
+    element.style.setProperty("--q-primary-color", theme.primaryColor);
+    element.style.setProperty("--q-lighter-primary-color", lightenHex(theme.primaryColor));
+    element.style.setProperty("--q-text-color", theme.textColor);
+    element.style.setProperty("--q-button-background-color", buttonStyles.backgroundColor);
+    element.style.setProperty("--q-button-hover-background-color", buttonStyles.hoverBackgroundColor);
+    element.style.setProperty("--q-button-background-layer", buttonStyles.backgroundLayer);
+    element.style.setProperty("--q-button-hover-background-layer", buttonStyles.hoverBackgroundLayer);
+    element.style.setProperty("--q-button-text-color", buttonStyles.textColor);
+    element.style.setProperty("--q-button-hover-text-color", buttonStyles.hoverTextColor);
+    element.style.setProperty("--q-button-border-color", buttonStyles.borderColor);
+    element.style.setProperty("--q-button-hover-border-color", buttonStyles.hoverBorderColor);
+    element.style.setProperty("--q-button-border-radius", buttonStyles.borderRadius);
+    element.style.setProperty("--q-control-border-radius", buttonStyles.controlBorderRadius);
+}
+function getButtonStyles(theme) {
+    var _theme_buttonPrimaryColor, _theme_buttonTextColor, _theme_buttonBorderRadiusPx;
+    // When "Use theme colors" is enabled, buttons inherit global theme colors.
+    // Otherwise, use button-specific colors (with theme colors as fallback).
+    const primary = theme.buttonsUseThemeColors ? theme.primaryColor : (_theme_buttonPrimaryColor = theme.buttonPrimaryColor) != null ? _theme_buttonPrimaryColor : theme.primaryColor;
+    const text = theme.buttonsUseThemeColors ? theme.textColor : (_theme_buttonTextColor = theme.buttonTextColor) != null ? _theme_buttonTextColor : theme.textColor;
+    const radius = theme.buttonShape === types_ButtonShape.Pill ? "999px" : "" + ((_theme_buttonBorderRadiusPx = theme.buttonBorderRadiusPx) != null ? _theme_buttonBorderRadiusPx : 4) + "px";
+    // Pill is a shape for a button with a word in it. Applied to a grid of calendar
+    // cells it turns day numbers into circles and time slots into lozenges, so those
+    // surfaces get a squared-off stand-in and every other configured radius through
+    // unchanged.
+    const controlRadius = theme.buttonShape === types_ButtonShape.Pill ? "8px" : radius;
+    switch(theme.buttonStyle){
+        case types_ButtonStyle.Outline:
+            return {
+                backgroundColor: "transparent",
+                hoverBackgroundColor: "" + primary + "10",
+                // White layer behind the gradient so Outline/Shade tints read consistently
+                // over any page background.
+                backgroundLayer: "#ffffff",
+                hoverBackgroundLayer: "#ffffff",
+                textColor: primary,
+                hoverTextColor: primary,
+                borderColor: primary,
+                hoverBorderColor: primary,
+                borderRadius: radius,
+                controlBorderRadius: controlRadius
+            };
+        case types_ButtonStyle.Shade:
+            return {
+                backgroundColor: "" + primary + "20",
+                hoverBackgroundColor: "" + primary + "40",
+                backgroundLayer: "#ffffff",
+                hoverBackgroundLayer: "#ffffff",
+                textColor: primary,
+                hoverTextColor: primary,
+                borderColor: "transparent",
+                hoverBorderColor: "transparent",
+                borderRadius: radius,
+                controlBorderRadius: controlRadius
+            };
+        case types_ButtonStyle.Solid:
+        default:
+            return {
+                backgroundColor: primary,
+                hoverBackgroundColor: darkenHex(primary),
+                // Solid buttons use the button color as the backdrop so no white edge
+                // peeks through the rounded-corner gap.
+                backgroundLayer: primary,
+                hoverBackgroundLayer: darkenHex(primary),
+                textColor: text,
+                hoverTextColor: text,
+                borderColor: primary,
+                hoverBorderColor: darkenHex(primary),
+                borderRadius: radius,
+                controlBorderRadius: controlRadius
+            };
+    }
+}
+
+var theme_styles_lightenHex = /* unused export */ undefined;
+export { applyThemeCssVars, createThemeCss, hexToRgba, theme_styles_lightenHex as lightenHex };

package/widget/multimodal_v2/utils/url_observer.js

@@ -0,0 +1,52 @@
+import { __webpack_require__ } from "../../../js/runtime.js";
+import { normalizeToBaseUrl } from "../../../src/url-utils.js";
+import "../../utils/native_globals.js";
+
+/* provided dependency */ var __nativeWindowAddEventListener = __webpack_require__(68034).zh;
+/* provided dependency */ var __nativeWindowRemoveEventListener = __webpack_require__(68034).kZ;
+
+class UrlObserver {
+    start() {
+        // Set initial URL
+        this.notifyUrlChange();
+        // Listen to popstate for browser back/forward navigation
+        const handleUrlChange = ()=>this.notifyUrlChange();
+        __nativeWindowAddEventListener("popstate", handleUrlChange);
+        this.cleanupCallbacks.push(()=>__nativeWindowRemoveEventListener("popstate", handleUrlChange));
+        // Wrap history APIs to track SPA navigations
+        const self = this;
+        window.history.pushState = function() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            self.originalPushState.apply(this, args);
+            handleUrlChange();
+        };
+        window.history.replaceState = function() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            self.originalReplaceState.apply(this, args);
+            handleUrlChange();
+        };
+        this.cleanupCallbacks.push(()=>{
+            window.history.pushState = self.originalPushState;
+            window.history.replaceState = self.originalReplaceState;
+        });
+    }
+    stop() {
+        this.cleanupCallbacks.forEach((cb)=>cb());
+        this.cleanupCallbacks = [];
+    }
+    notifyUrlChange() {
+        this.cb(normalizeToBaseUrl(window.location.href));
+    }
+    constructor(cb){
+        this.cb = cb;
+        this.cleanupCallbacks = [];
+        this.originalPushState = window.history.pushState;
+        this.originalReplaceState = window.history.replaceState;
+    }
+}
+
+export { UrlObserver };

package/widget/multimodal_v2/utils/voice_onset_detector.js

@@ -0,0 +1,127 @@
+import { __webpack_require__ } from "../../../js/runtime.js";
+import "../../utils/native_globals.js";
+
+/* provided dependency */ var requestAnimationFrame = __webpack_require__(68034).gj;
+/* provided dependency */ var cancelAnimationFrame = __webpack_require__(68034).pP;
+const NOISE_FLOOR_ALPHA = 0.02; // slow rolling average of quiet samples
+const OPEN_MARGIN = 0.03; // rise this far above floor => active
+const CLOSE_MARGIN = 0.015; // fall within this of floor => inactive (hysteresis gap)
+const MIN_FLOOR = 0.005;
+// Silence must persist this long before we declare a fall (offset). Natural intra-utterance /
+// intra-answer pauses (between words and sentences) are typically shorter than this, so they no
+// longer fragment one speech run into many onset/offset cycles; a real end-of-turn or the
+// multi-second gap while a tool call executes comfortably exceeds it. This keeps a bot answer's
+// `onBotOnset` anchored on the *start* of its final speaking run rather than drifting to its last
+// sentence, and steadies the mic `t0` against transient dips. Rise (onset) stays immediate.
+const DEFAULT_HANGOVER_MS = 350;
+// Read a full time-domain frame from the node and compute its RMS. The buffer
+// must be sized to the node's fftSize (getByteTimeDomainData fills fftSize
+// samples); a smaller buffer would only read part of the waveform frame. We
+// cache the buffer on the channel and only reallocate when fftSize changes, to
+// avoid a per-frame allocation. The node's own fftSize is never mutated.
+function rms(analyser, ch) {
+    const size = analyser.fftSize;
+    let { buf } = ch;
+    if (!buf || buf.length !== size) {
+        buf = new Uint8Array(size);
+        ch.buf = buf;
+    }
+    analyser.getByteTimeDomainData(buf);
+    let sum = 0;
+    for(let i = 0; i < buf.length; i++){
+        const s = (buf[i] - 128) / 128;
+        sum += s * s;
+    }
+    return Math.sqrt(sum / buf.length);
+}
+/**
+ * Standalone, framework-agnostic DSP module that samples mic/bot AnalyserNodes
+ * on a requestAnimationFrame loop and fires onset/offset callbacks based on a
+ * rolling noise-floor estimate with hysteresis. Observation-only: this class
+ * must never throw into the call, so the sampling loop is fully try/caught.
+ */ class VoiceOnsetDetector {
+    start() {
+        if (!this.stopped) return;
+        this.stopped = false;
+        this.tick();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.rafId !== null) {
+            this.cancelRaf(this.rafId);
+            this.rafId = null;
+        }
+    }
+    step(node, ch, ts, onRise, onFall) {
+        const level = rms(node, ch);
+        if (!ch.active) {
+            // While quiet, keep a rolling noise-floor estimate.
+            ch.noiseFloor = Math.max(MIN_FLOOR, ch.noiseFloor * (1 - NOISE_FLOOR_ALPHA) + level * NOISE_FLOOR_ALPHA);
+            if (level > ch.noiseFloor + OPEN_MARGIN) {
+                ch.active = true;
+                ch.pendingSilenceSince = null;
+                onRise(ts);
+            }
+        } else if (level < ch.noiseFloor + CLOSE_MARGIN) {
+            // Below the close threshold: don't fall immediately. Only declare the offset once the
+            // silence has persisted for hangoverMs, so brief intra-run pauses don't split the run.
+            if (ch.pendingSilenceSince === null) {
+                ch.pendingSilenceSince = ts;
+            } else if (ts - ch.pendingSilenceSince >= this.hangoverMs) {
+                ch.active = false;
+                // Report the offset at the moment it went quiet, not hangoverMs later, so `t0`/onset
+                // timing is unaffected by the debounce.
+                const fellAt = ch.pendingSilenceSince;
+                ch.pendingSilenceSince = null;
+                onFall(fellAt);
+            }
+        } else {
+            // Bounced back above the close threshold within the hangover window: still one run.
+            ch.pendingSilenceSince = null;
+        }
+    }
+    constructor(opts){
+        var _opts_now, _opts_raf, _opts_cancelRaf, _opts_hangoverMs;
+        this.rafId = null;
+        this.stopped = true;
+        this.mic = {
+            active: false,
+            noiseFloor: MIN_FLOOR,
+            buf: null,
+            pendingSilenceSince: null
+        };
+        this.bot = {
+            active: false,
+            noiseFloor: MIN_FLOOR,
+            buf: null,
+            pendingSilenceSince: null
+        };
+        this.tick = ()=>{
+            if (this.stopped) return;
+            try {
+                const micNode = this.getMic();
+                const botNode = this.getBot();
+                const ts = this.now();
+                if (micNode) {
+                    this.step(micNode, this.mic, ts, this.cb.onMicActive, this.cb.onMicQuiet);
+                }
+                if (botNode) {
+                    this.step(botNode, this.bot, ts, this.cb.onBotOnset, this.cb.onBotSilence);
+                }
+            } catch (unused) {
+            // Observation-only: never let a sampling error affect the call.
+            }
+            if (this.stopped) return;
+            this.rafId = this.raf(this.tick);
+        };
+        this.getMic = opts.getMicAnalyser;
+        this.getBot = opts.getBotAnalyser;
+        this.cb = opts.callbacks;
+        this.now = (_opts_now = opts.now) != null ? _opts_now : ()=>performance.now();
+        this.raf = (_opts_raf = opts.raf) != null ? _opts_raf : (cb)=>requestAnimationFrame(cb);
+        this.cancelRaf = (_opts_cancelRaf = opts.cancelRaf) != null ? _opts_cancelRaf : (id)=>cancelAnimationFrame(id);
+        this.hangoverMs = (_opts_hangoverMs = opts.hangoverMs) != null ? _opts_hangoverMs : DEFAULT_HANGOVER_MS;
+    }
+}
+
+export { VoiceOnsetDetector };

package/widget/page_mirror.js

@@ -0,0 +1,89 @@
+import { isDomainMatch } from "../src/iframes.js";
+import { ChangeType } from "../src/mirror/constants.js";
+import { default as Shipper } from "../src/mirror/Shipper.js";
+import { Location } from "../src/mirror/shipper/observers.js";
+import { default as WidgetObject } from "./widget_object.js";
+
+
+
+
+
+
+class PageMirror extends WidgetObject {
+    cleanup() {
+        this.shipper.dispose();
+        this.widget.stopShipper();
+        super.cleanup();
+    }
+    recreateShipper() {
+        this.shipper.dispose();
+        this.shipper = new Shipper(window, document, this.sendMessage);
+    }
+    static getLastLocation(message) {
+        let lastLocation;
+        // message[2] is an array of changes
+        message[2].forEach((change)=>{
+            if (change[0] === ChangeType.Location) {
+                // change[1][1] is document.location.href
+                lastLocation = change[1][1];
+            }
+        });
+        return lastLocation;
+    }
+    refreshDisableLiveView(lastLocation) {
+        this.disableLiveView = !!this.denylistedVisitorStreamDomains.length && isDomainMatch(this.denylistedVisitorStreamDomains, lastLocation, true);
+    }
+    constructor(injectionProps, denylistedVisitorStreamDomains){
+        super(injectionProps), this.disableLiveView = false, this.onReceived = (message)=>{
+            if (message.start && (/* inlined export .ProtocolVersion */1) <= message.start) {
+                if (this.shipper.started) {
+                    this.shipper.sendKeyframe();
+                    this.widget.requestKeyframe();
+                } else {
+                    this.shipper.start();
+                    this.widget.startShipper();
+                }
+            }
+        }, this.onCableDisconnected = ()=>{
+            this.recreateShipper();
+            this.widget.stopShipper();
+        }, this.sendMessage = (message)=>{
+            var _this_featureFlags;
+            if ((_this_featureFlags = this.featureFlags) == null ? void 0 : _this_featureFlags.liveViewBlockListSpa) {
+                this.refreshLocationState();
+                this.refreshDisableLiveView(this.currentLocation);
+            } else {
+                const lastLocation = PageMirror.getLastLocation(message);
+                if (lastLocation) this.refreshDisableLiveView(lastLocation);
+            }
+            if (this.disableLiveView) {
+                // Send empty array of new and deleted DOM nodes
+                message[3] = [];
+                message[4] = [];
+            }
+            this.channel.sendLiveView({
+                m: message
+            });
+        }, this.onMessageFromWidget = (iframe, message)=>{
+            this.shipper.onNestedShipperMessage(iframe, message);
+        }, this.refreshLocationState = ()=>{
+            const currentWindowLocation = this.shipper.window.location.href;
+            if (currentWindowLocation !== this.currentLocation) {
+                this.currentLocation = currentWindowLocation;
+                // Trigger the location observer's callback
+                const locationObserver = this.shipper.helpers.find((observer)=>observer instanceof Location);
+                if (locationObserver) {
+                    locationObserver.onLocationChange();
+                }
+            }
+        };
+        this.shipper = new Shipper(window, document, this.sendMessage);
+        this.channel.on("receivedLiveView", this.onReceived);
+        this.channel.on("disconnected", this.onCableDisconnected);
+        this.denylistedVisitorStreamDomains = denylistedVisitorStreamDomains;
+        this.currentLocation = this.shipper.window.location.href;
+    }
+}
+
+
+export default PageMirror;

package/widget/page_view_activity_emitter.js

@@ -0,0 +1,71 @@
+import { default as WidgetObject } from "./widget_object.js";
+import { _extends } from "../js/4101.js";
+
+
+
+var page_view_activity_emitter_PersonalizationActivity = /*#__PURE__*/ (/* unused pure expression or super */ null && (function(PersonalizationActivity) {
+    PersonalizationActivity["Click"] = "click";
+    PersonalizationActivity["ExperimentArmApplied"] = "experiment_arm_applied";
+    PersonalizationActivity["ExperimentArmFallback"] = "experiment_arm_fallback";
+    PersonalizationActivity["InView"] = "in_view";
+    return PersonalizationActivity;
+}(page_view_activity_emitter_PersonalizationActivity || {})));
+var page_view_activity_emitter_OfferActivity = /*#__PURE__*/ (/* unused pure expression or super */ null && (function(OfferActivity) {
+    OfferActivity["OfferShown"] = "offer_shown";
+    OfferActivity["OfferDismiss"] = "offer_dismiss";
+    OfferActivity["OfferClick"] = "offer_click";
+    OfferActivity["OfferLanded"] = "offer_landed";
+    OfferActivity["OfferPrivacyDisclosureShown"] = "offer_privacy_disclosure_shown";
+    OfferActivity["OfferPrivacyDisclosureConsented"] = "offer_privacy_disclosure_consented";
+    return OfferActivity;
+}({})));
+var page_view_activity_emitter_FormActivity = /*#__PURE__*/ (/* unused pure expression or super */ null && (function(FormActivity) {
+    FormActivity["FormFill"] = "form_fill";
+    return FormActivity;
+}(page_view_activity_emitter_FormActivity || {})));
+class PageViewActivityEmitter extends WidgetObject {
+    createEmitter(type) {
+        return (payload)=>{
+            this.emitPageViewActivity({
+                type,
+                payload
+            });
+        };
+    }
+    emitPageViewActivity(param) {
+        let { type, payload } = param;
+        if (!this.hasPageViewActivityTracking) {
+            return;
+        }
+        // Wait for the tracker to be initialized before sending the event to ensure that the page view is created
+        this.tracker.afterInit(()=>{
+            this.channel.perform("record_page_view_activity", _extends({
+                activity_type: type
+            }, this.underscorePayload(payload)));
+            this.widget.serverLog({
+                message: "Page view activity emitted with type: " + type,
+                fireAndForget: true
+            });
+        });
+    }
+    constructor(injectionProps){
+        var _this_config_hasPageViewActivityTracking;
+        super(injectionProps), // Personalization activities
+        this.emitPersonalizationInView = this.createEmitter("in_view"), this.emitPersonalizationApplied = this.createEmitter("experiment_arm_applied"), this.emitPersonalizationFallback = this.createEmitter("experiment_arm_fallback"), this.emitPersonalizationClick = this.createEmitter("click"), // Offer activities
+        this.emitOfferDismiss = this.createEmitter("offer_dismiss"), this.emitOfferClick = this.createEmitter("offer_click"), this.emitOfferLanded = this.createEmitter("offer_landed"), this.emitOfferShown = this.createEmitter("offer_shown"), // Privacy disclosure activities
+        this.emitPrivacyDisclosureShown = this.createEmitter("offer_privacy_disclosure_shown"), this.emitPrivacyDisclosureConsented = this.createEmitter("offer_privacy_disclosure_consented"), // Form activities
+        this.emitFormFill = this.createEmitter("form_fill"), this.underscorePayload = (payload)=>Object.fromEntries(Object.entries(payload).map((param)=>{
+                let [k, v] = param;
+                return [
+                    k.replace(/([a-z\d])([A-Z]+)/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase(),
+                    v
+                ];
+            }));
+        this.hasPageViewActivityTracking = (_this_config_hasPageViewActivityTracking = this.config.hasPageViewActivityTracking) != null ? _this_config_hasPageViewActivityTracking : false;
+    }
+}
+/* export default */ const page_view_activity_emitter = (PageViewActivityEmitter);
+
+var widget_page_view_activity_emitter_OfferActivity = /* unused export */ undefined;
+export { widget_page_view_activity_emitter_OfferActivity as OfferActivity };
+export default page_view_activity_emitter;