@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/multimodal_v2/components/helpers/RichText.js

@@ -0,0 +1,358 @@
+import { hooks_module_, hooks_module_A, jsxRuntime_module_u, hooks_module_T } from "../../../../js/multimodal_v2.js";
+import "../../styled-system/jsx/index.js";
+import { sanitizeHtml } from "../../utils/sanitize_html.js";
+import { styled as factory_styled } from "../../styled-system/jsx/factory.js";
+
+
+/** @jsxImportSource preact */ 
+
+
+const DEFAULT_TRANSFORMERS = {};
+/**
+ * The widget renders into a shadow root on the customer's page, so an anchor here navigates the
+ * top-level page. Cross-origin links would take the visitor off the site entirely and tear the
+ * widget down mid-conversation, so they open in a new tab instead.
+ *
+ * Same-origin links are deliberately left bare so the navigation interceptor can still soft-navigate
+ * them in place for co-browsing.
+ */ const EXTERNAL_LINK_TRANSFORMERS = {
+    a: (node)=>{
+        if (node.hasAttribute("target")) return;
+        if (!isCrossOriginHttpUrl(node.getAttribute("href"))) return;
+        node.setAttribute("target", "_blank");
+        node.setAttribute("rel", withRelTokens(node.getAttribute("rel")));
+    }
+};
+/**
+ * Renders sanitized HTML content with optional word-by-word animation.
+ *
+ * Note: This component uses useMemo instead of useComputed because it receives
+ * plain props (not signals) from parent components that iterate over message lists.
+ * The useEffect for animation handling is acceptable per DEVELOPMENT.md guidelines.
+ */ const RichText = (props)=>{
+    const { wrapperRef, processedHtml, animated, styled, paragraphSpacing } = useRichText(props);
+    return /*#__PURE__*/ jsxRuntime_module_u(Wrapper, {
+        ref: wrapperRef,
+        animated: animated,
+        styled: styled,
+        paragraphSpacing: paragraphSpacing,
+        dangerouslySetInnerHTML: {
+            __html: processedHtml
+        }
+    });
+};
+function useRichText(param) {
+    let { text, animated = false, styled = true, paragraphSpacing = false, elementTransformers = DEFAULT_TRANSFORMERS, onAnimationEnd } = param;
+    const wrapperRef = hooks_module_A(null);
+    // useMemo is acceptable here since props are plain values, not signals.
+    // The expensive DOM processing (sanitization + animation wrapping) benefits from memoization.
+    const processedHtml = hooks_module_T(()=>{
+        const sanitizeConfig = {
+            ADD_ATTR: [
+                "target",
+                "rel"
+            ],
+            AFTER_SANITIZE_ATTRIBUTES: (node)=>{
+                const tag = node.tagName.toLowerCase();
+                // Built-ins run first so a caller-supplied transformer can still override them.
+                const builtIn = EXTERNAL_LINK_TRANSFORMERS[tag];
+                builtIn == null ? void 0 : builtIn(node);
+                const fn = elementTransformers[tag];
+                fn == null ? void 0 : fn(node);
+            }
+        };
+        const sanitizedFragment = sanitizeHtml(text, sanitizeConfig);
+        if (animated) {
+            return processFragmentForAnimation(sanitizedFragment);
+        }
+        return processFragmentForSerialization(sanitizedFragment);
+    }, [
+        text,
+        animated,
+        elementTransformers
+    ]);
+    // useLayoutEffect ensures the animationend listener is attached before paint,
+    // preventing short animations (e.g. 5-10ms) from completing before the listener exists.
+    hooks_module_(()=>{
+        if (!onAnimationEnd || !wrapperRef.current) return;
+        if (!animated) {
+            onAnimationEnd();
+            return;
+        }
+        const elements = wrapperRef.current.querySelectorAll("[data-animated-word], [data-animated-element]");
+        if (elements.length === 0) {
+            onAnimationEnd();
+            return;
+        }
+        const lastElement = elements[elements.length - 1];
+        lastElement.addEventListener("animationend", onAnimationEnd);
+        return ()=>lastElement.removeEventListener("animationend", onAnimationEnd);
+    }, [
+        animated,
+        onAnimationEnd,
+        processedHtml
+    ]);
+    return {
+        wrapperRef,
+        processedHtml,
+        animated,
+        styled,
+        paragraphSpacing
+    };
+}
+const VOID_ELEMENTS = new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr"
+]);
+/**
+ * Serialize a DOM fragment to HTML string.
+ * Consumes the fragment (moves children out) - caller should not reuse it after this.
+ */ function processFragmentForSerialization(fragment) {
+    const div = document.createElement("div");
+    div.appendChild(fragment.cloneNode(true));
+    return div.innerHTML;
+}
+/**
+ * Process a sanitized DOM fragment and return HTML string with animation metadata.
+ * Iterates through the DOM once and builds a string - no DOM mutations.
+ */ function processFragmentForAnimation(fragment) {
+    const state = {
+        accumulatedDelay: 0,
+        result: ""
+    };
+    serializeNode(fragment, state);
+    return state.result;
+}
+function serializeNode(node, state) {
+    for (const child of node.childNodes){
+        if (child.nodeType === Node.TEXT_NODE) {
+            serializeTextNode(child.textContent || "", state);
+        } else if (child.nodeType === Node.ELEMENT_NODE) {
+            serializeElement(child, state);
+        }
+    }
+}
+function serializeTextNode(text, state) {
+    const words = text.match(/\S+\s*/g);
+    if (!(words == null ? void 0 : words.length)) {
+        // Whitespace-only, preserve as-is
+        state.result += escapeHtml(text);
+        return;
+    }
+    // Preserve leading whitespace
+    const firstWordStart = text.indexOf(words[0]);
+    if (firstWordStart > 0) {
+        state.result += escapeHtml(text.slice(0, firstWordStart));
+    }
+    for (const word of words){
+        const duration = word.length * WORD_ANIMATION_DURATION_PER_CHARACTER;
+        state.result += '<span data-animated-word="true" style="--animation-duration: ' + duration + "ms; --accumulated-delay: " + state.accumulatedDelay + 'ms">' + escapeHtml(word) + "</span>";
+        state.accumulatedDelay += duration;
+    }
+}
+function serializeElement(element, state) {
+    const tag = element.tagName.toLowerCase();
+    // Build opening tag
+    state.result += "<" + tag;
+    // Copy existing attributes
+    for(let i = 0; i < element.attributes.length; i++){
+        const attr = element.attributes[i];
+        state.result += " " + attr.name + '="' + escapeAttr(attr.value) + '"';
+    }
+    // Add animation CSS vars for special elements
+    if (ELEMENT_ANIMATION_DURATION_MAP[tag]) {
+        const duration = ELEMENT_ANIMATION_DURATION_MAP[tag](element);
+        state.result += ' data-animated-element="true" style="--animation-duration: ' + duration + "ms; --accumulated-delay: " + state.accumulatedDelay + 'ms"';
+        state.accumulatedDelay += duration;
+    }
+    state.result += ">";
+    // Void elements have no children or closing tag
+    if (VOID_ELEMENTS.has(tag)) {
+        return;
+    }
+    // Recursively process children
+    serializeNode(element, state);
+    // Closing tag
+    state.result += "</" + tag + ">";
+}
+function escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(value) {
+    return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/**
+ * Whether `href` points at a different origin over http(s).
+ *
+ * Resolved explicitly rather than read off the `href` IDL property, because these nodes live in a
+ * detached <template> whose base URL is not the page's. `document.baseURI` is the base the browser
+ * will actually use once the anchor is in the page, so a customer page carrying a cross-origin
+ * <base href> still classifies its relative links as external.
+ */ function isCrossOriginHttpUrl(href) {
+    if (!href) return false;
+    try {
+        const url = new URL(href, document.baseURI);
+        // mailto:/tel: hand off to another app and would strand an empty tab behind.
+        if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+        return url.origin !== window.location.origin;
+    } catch (unused) {
+        return false;
+    }
+}
+function withRelTokens(existing) {
+    const tokens = new Set((existing != null ? existing : "").split(/\s+/).filter(Boolean));
+    tokens.add("noopener");
+    tokens.add("noreferrer");
+    return [
+        ...tokens
+    ].join(" ");
+}
+// Compute custom animation duration for elements
+// The animation is the same it's a fade in of the entire element
+const ELEMENT_ANIMATION_DURATION_MAP = {
+    // Fade in the li::marker before starting animation of the li text
+    li: ()=>30
+};
+const WORD_ANIMATION_DURATION_PER_CHARACTER = 5;
+/**
+ * External-link glyph, reused from the icon in OpenedPositionSettings so the widget matches the
+ * rest of the app.
+ *
+ * Carried as a mask rather than a background image so the pseudo-element can be painted in
+ * currentColor and track whatever colour the link already has. Only the alpha channel is read, so
+ * the stroke colour baked into the markup here is arbitrary.
+ */ const EXTERNAL_LINK_ICON_URL = "url(\"data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12' fill='none' stroke='%23000' stroke-width='1.2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M8.5 1.5H10.5V3.5'/%3E%3Cpath d='M10.5 1.5L6.5 5.5'/%3E%3Cpath d='M5.5 2H3.75C2.7835 2 2 2.7835 2 3.75V8.25C2 9.2165 2.7835 10 3.75 10H8.25C9.2165 10 10 9.2165 10 8.25V6.5'/%3E%3C/svg%3E\")";
+const Wrapper = factory_styled("div", {
+    base: {
+        fontFamily: "$inter",
+        // Flags links that leave the page. Keyed off the rendered target rather than the built-in
+        // cross-origin rule, so it also covers call sites that set target="_blank" themselves.
+        // Kept out of the `styled` variant so the glyph is never left unpositioned on unstyled callers.
+        "& a[target='_blank']::after": {
+            // U+2060 WORD JOINER forbids a line break on either side of itself, keeping the glyph on the
+            // same line as the last word. Must stay a non-atomic inline: browsers offer a break
+            // opportunity beside an atomic inline whatever the surrounding characters ask for, so the
+            // 12px glyph and its 2px gap come from padding rather than a width.
+            content: '"\\2060"',
+            paddingInlineStart: "[14px]",
+            backgroundColor: "[currentColor]",
+            maskImage: EXTERNAL_LINK_ICON_URL,
+            maskRepeat: "no-repeat",
+            maskPosition: "[right center]",
+            maskSize: "[12px 12px]",
+            WebkitMaskImage: EXTERNAL_LINK_ICON_URL,
+            WebkitMaskRepeat: "no-repeat",
+            WebkitMaskPosition: "[right center]",
+            WebkitMaskSize: "[12px 12px]"
+        }
+    },
+    variants: {
+        styled: {
+            true: {
+                "& b, & strong": {
+                    fontWeight: "$bold"
+                },
+                "& a": {
+                    color: "[inherit]",
+                    fontSize: "14px",
+                    fontWeight: "[inherit]",
+                    lineHeight: "22px",
+                    textDecoration: "underline"
+                },
+                "& ol, & ul": {
+                    paddingBlock: "$sm"
+                },
+                "& table": {
+                    borderCollapse: "collapse",
+                    width: "[100%]",
+                    marginBlock: "$sm"
+                },
+                "& th, & td": {
+                    borderWidth: "1px",
+                    borderStyle: "solid",
+                    borderColor: "$gray.border",
+                    paddingBlock: "$xs",
+                    paddingInline: "$sm",
+                    textAlign: "left",
+                    verticalAlign: "top"
+                },
+                "& th": {
+                    fontWeight: "$bold"
+                }
+            }
+        },
+        paragraphSpacing: {
+            true: {
+                "& p + p": {
+                    marginTop: "$sm"
+                }
+            },
+            false: {}
+        },
+        animated: {
+            true: {
+                "& [data-animated-element]": {
+                    opacity: 0,
+                    animation: "q-fadeIn ease-out forwards",
+                    animationDuration: "var(--animation-duration)",
+                    animationDelay: "var(--accumulated-delay)"
+                },
+                "& span[data-animated-word]": {
+                    position: "relative",
+                    display: "inline-block",
+                    whiteSpace: "pre-wrap"
+                },
+                // The word joiner gluing on the external-link glyph is disregarded next to an atomic inline,
+                // so the word the glyph follows cannot be one. Matched at any depth because formatting is
+                // preserved through serialization, which nests that word inside e.g. a <strong>.
+                "& a[target='_blank'] span[data-animated-word]:last-child": {
+                    display: "inline"
+                },
+                // Apply styles to spans inside links (inline-block breaks inheritance)
+                "& a span[data-animated-word]": {
+                    color: "[inherit]",
+                    fontSize: "14px",
+                    fontWeight: "[inherit]",
+                    lineHeight: "22px",
+                    textDecoration: "underline"
+                },
+                "& b span[data-animated-word], & strong span[data-animated-word]": {
+                    fontWeight: "$bold"
+                },
+                "& span[data-animated-word]::after": {
+                    content: '""',
+                    position: "absolute",
+                    zIndex: 1,
+                    top: "[0]",
+                    right: "[0]",
+                    bottom: "[0]",
+                    left: "[0]",
+                    backgroundColor: "$white",
+                    animationName: "q-revealWord",
+                    animationDuration: "var(--animation-duration)",
+                    animationTimingFunction: "ease-out",
+                    animationFillMode: "forwards",
+                    animationDelay: "var(--accumulated-delay)",
+                    transformOrigin: "right",
+                    transform: "scaleX(1)"
+                }
+            },
+            false: {}
+        }
+    }
+});
+
+var RichText_ELEMENT_ANIMATION_DURATION_MAP = /* unused export */ undefined;
+export { RichText, RichText_ELEMENT_ANIMATION_DURATION_MAP as ELEMENT_ANIMATION_DURATION_MAP, WORD_ANIMATION_DURATION_PER_CHARACTER };

package/widget/multimodal_v2/components/helpers/ScreenReaderHeading.js

@@ -0,0 +1,17 @@
+import { jsxRuntime_module_u } from "../../../../js/multimodal_v2.js";
+import { VisuallyHidden } from "./VisuallyHidden.js";
+
+/** @jsxImportSource preact */ 
+
+const ScreenReaderHeading = (param)=>{
+    let { level, children } = param;
+    return /*#__PURE__*/ jsxRuntime_module_u(VisuallyHidden, {
+        children: /*#__PURE__*/ jsxRuntime_module_u("span", {
+            role: "heading",
+            "aria-level": level,
+            children: children
+        })
+    });
+};
+
+export { ScreenReaderHeading };

package/widget/multimodal_v2/components/helpers/Thumbnail.js

@@ -0,0 +1,190 @@
+import { jsxRuntime_module_u, hooks_module_y, hooks_module_A } from "../../../../js/multimodal_v2.js";
+import "../../styled-system/jsx/index.js";
+import { getCache } from "../../utils/multimodal_cache.js";
+import { styled } from "../../styled-system/jsx/factory.js";
+
+function _extends() {
+    _extends = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+
+
+
+
+const Thumbnail = (props)=>{
+    const { videoUrl, timestamp } = props, attributes = _object_without_properties_loose(props, [
+        "videoUrl",
+        "timestamp"
+    ]);
+    const canvasRef = useThumbnail({
+        videoUrl,
+        timestamp
+    });
+    return /*#__PURE__*/ jsxRuntime_module_u(ThumbnailCanvas, _extends({
+        ref: canvasRef,
+        role: "img"
+    }, attributes));
+};
+const VIDEO_CACHE_KEY = "components.helpers.useThumbnail.videos";
+function useThumbnail(param) {
+    let { videoUrl, timestamp } = param;
+    // Video elements are cached by url so repeated thumbnails of the same video
+    // reuse a single loaded element instead of re-downloading it each time. The
+    // captured frame itself is not cached — re-seeking a buffered video and
+    // grabbing a fresh bitmap is cheap, and avoids holding decoded pixels around.
+    const videoCache = getCache(VIDEO_CACHE_KEY, ()=>new Map());
+    const canvasRef = hooks_module_A(null);
+    hooks_module_y(()=>{
+        let cancelled = false;
+        const render = async ()=>{
+            try {
+                const bitmap = await captureFrame(videoCache, videoUrl, timestamp);
+                if (!cancelled && canvasRef.current) {
+                    paintBitmap(canvasRef.current, bitmap);
+                }
+                // Pixels are copied onto the canvas, so release the bitmap promptly.
+                bitmap.close();
+            } catch (unused) {
+            // Capture failed; nothing to paint.
+            }
+        };
+        void render();
+        return ()=>{
+            cancelled = true;
+        };
+    }, [
+        videoUrl,
+        timestamp,
+        videoCache
+    ]);
+    return canvasRef;
+}
+/**
+ * Captures a single frame at `timestamp` by seeking the cached video element
+ * and snapshotting it into an ImageBitmap. Seeks are serialized per video so
+ * concurrent captures of different timestamps don't clobber each other.
+ *
+ * Requires the video host to send CORS headers; otherwise the frame is tainted
+ * and drawing it to a canvas throws a SecurityError.
+ */ function captureFrame(videoCache, videoUrl, timestamp) {
+    const entry = getCachedVideo(videoCache, videoUrl);
+    const previous = entry.queue;
+    const capture = async ()=>{
+        // Wait for any in-flight capture so seeks stay serialized on the element.
+        await previous.catch(()=>undefined);
+        const video = await entry.ready;
+        await seekTo(video, timestamp);
+        // Snapshot the current frame; the bitmap is decoded pixels (no encoding).
+        return createImageBitmap(video);
+    };
+    // Claim the queue synchronously so the next capture waits for this one.
+    const result = capture();
+    entry.queue = result.catch(()=>undefined);
+    return result;
+}
+function getCachedVideo(videoCache, videoUrl) {
+    const existing = videoCache.get(videoUrl);
+    if (existing) return existing;
+    const load = async ()=>{
+        try {
+            return await loadVideo(videoUrl);
+        } catch (err) {
+            // Evict on failure so a later mount can retry loading the video.
+            videoCache.delete(videoUrl);
+            throw err;
+        }
+    };
+    const ready = load();
+    const entry = {
+        ready,
+        queue: ready
+    };
+    videoCache.set(videoUrl, entry);
+    return entry;
+}
+function loadVideo(videoUrl) {
+    return new Promise((resolve, reject)=>{
+        const video = document.createElement("video");
+        video.crossOrigin = "anonymous";
+        video.muted = true;
+        video.preload = "metadata";
+        video.addEventListener("loadedmetadata", ()=>resolve(video), {
+            once: true
+        });
+        video.addEventListener("error", ()=>{
+            var _video_error;
+            return reject((_video_error = video.error) != null ? _video_error : new Error("Failed to load video: " + videoUrl));
+        }, {
+            once: true
+        });
+        video.src = videoUrl;
+    });
+}
+function seekTo(video, timestamp) {
+    return new Promise((resolve, reject)=>{
+        // Clamp the requested time so we never seek past the final frame.
+        const target = Math.min(timestamp, Math.max(video.duration - 0.001, 0));
+        // Already positioned at the target frame (no "seeked" event would fire).
+        if (video.readyState >= video.HAVE_CURRENT_DATA && video.currentTime === target) {
+            resolve();
+            return;
+        }
+        const onSeeked = ()=>{
+            video.removeEventListener("error", onError);
+            resolve();
+        };
+        const onError = ()=>{
+            var _video_error;
+            video.removeEventListener("seeked", onSeeked);
+            reject((_video_error = video.error) != null ? _video_error : new Error("Failed to seek video"));
+        };
+        video.addEventListener("seeked", onSeeked, {
+            once: true
+        });
+        video.addEventListener("error", onError, {
+            once: true
+        });
+        video.currentTime = target;
+    });
+}
+/**
+ * Draws a cached frame onto the canvas. `drawImage` copies the pixels, so the
+ * bitmap stays intact and can be reused by other mounted thumbnails.
+ */ function paintBitmap(canvas, bitmap) {
+    canvas.width = bitmap.width;
+    canvas.height = bitmap.height;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return;
+    ctx.drawImage(bitmap, 0, 0);
+}
+const ThumbnailCanvas = styled("canvas", {
+    base: {
+        width: "[100%]",
+        height: "[100%]",
+        objectFit: "cover"
+    }
+});
+ThumbnailCanvas.displayName = "ThumbnailCanvas";
+
+export { Thumbnail };

package/widget/multimodal_v2/components/helpers/VisuallyHidden.js

@@ -0,0 +1,41 @@
+import { jsxRuntime_module_u } from "../../../../js/multimodal_v2.js";
+import "../../styled-system/jsx/index.js";
+import { styled } from "../../styled-system/jsx/factory.js";
+
+/** @jsxImportSource preact */ 
+
+const properties = {
+    position: "absolute",
+    width: "1px",
+    height: "1px",
+    padding: "0",
+    margin: "-1px",
+    overflow: "hidden",
+    clip: "rect(0,0,0,0)",
+    border: "0"
+};
+const VISUALLY_HIDDEN_STYLE = Object.entries(properties).map((param)=>{
+    let [k, v] = param;
+    return k.replace(/[A-Z]/g, (m)=>"-" + m.toLowerCase()) + ":" + v;
+}).join(";");
+const VisuallyHidden = (param)=>{
+    let { children } = param;
+    return /*#__PURE__*/ jsxRuntime_module_u(Hidden, {
+        children: children
+    });
+};
+const Hidden = styled("span", {
+    base: {
+        position: properties.position,
+        width: "[" + properties.width + "]",
+        height: "[" + properties.height + "]",
+        padding: "[" + properties.padding + "]",
+        margin: "[" + properties.margin + "]",
+        overflow: properties.overflow,
+        clip: "[" + properties.clip + "]",
+        border: "[" + properties.border + "]"
+    }
+});
+Hidden.displayName = "VisuallyHidden";
+
+export { VISUALLY_HIDDEN_STYLE, VisuallyHidden };

package/widget/multimodal_v2/components/helpers/content_click_payloads.js

@@ -0,0 +1,58 @@
+/**
+ * Builders for custEv_contentClick, custEv_chatView, and custEv_contentImpression
+ * GTM events (Piper web tracking).
+ */ /** Payload for custEv_chatView when user interacts with the initial Chat Invitation UI. */ function buildCustEvChatViewPayload(conversationId, formJoinIDUnique) {
+    if (formJoinIDUnique === void 0) formJoinIDUnique = "";
+    return {
+        event: "custEv_chatView",
+        chatExperience: "qualified",
+        nameCaptureCampaignId: "",
+        formJoinIDUnique,
+        conversationId
+    };
+}
+/** Payload for custEv_contentImpression when rich content or links become visible in the viewport. */ function buildCustEvContentImpressionPayload(modules) {
+    return {
+        event: "custEv_contentImpression",
+        blade: {
+            id: "",
+            name: "qualified/customerstory",
+            position: "",
+            source: "qualified",
+            modules: modules.map((m)=>({
+                    id: "",
+                    name: m.name,
+                    type: "",
+                    url: m.url
+                }))
+        }
+    };
+}
+/** Payload for custEv_contentClick when a link in the widget is clicked (e.g. in a message body). */ function buildCustEvContentClickPayloadForLink(url, moduleName, clickedLinkText, conversationId) {
+    if (conversationId === void 0) conversationId = "";
+    return {
+        event: "custEv_contentClick",
+        blade: {
+            id: "",
+            conversationId,
+            name: "qualified/link",
+            position: "",
+            source: "qualified",
+            variant: "",
+            module: {
+                id: "",
+                name: moduleName,
+                type: "link",
+                position: "",
+                link: {
+                    url,
+                    text: clickedLinkText,
+                    internalDriver: "qualified",
+                    elementType: ""
+                }
+            }
+        }
+    };
+}
+
+export { buildCustEvChatViewPayload, buildCustEvContentClickPayloadForLink, buildCustEvContentImpressionPayload };