@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/pardot_visitor.js

@@ -0,0 +1,137 @@
+import { __webpack_require__ } from "../js/runtime.js";
+import { api } from "../js/4101.js";
+import { delay as timing_delay } from "../src/timing.js";
+import "./telemetry/index.js";
+import "./utils/native_globals.js";
+import { telemetry, getTelemetryCtx } from "./telemetry/telemetry.js";
+
+/* provided dependency */ var pardot_visitor_setTimeout = __webpack_require__(68034).pS;
+
+
+
+class PardotVisitor {
+    async getIdentities() {
+        const identities = {};
+        let promiseGetProspectEmail;
+        let promiseGetVisitorId;
+        telemetry.startActiveSpanAsync("Pardot Get Prospect Email", {}, this.telemetryCtx, async (span)=>{
+            promiseGetProspectEmail = this.getProspectEmail();
+            try {
+                identities.prospectEmail = await promiseGetProspectEmail;
+            } catch (unused) {
+            /* IGNORE */ } finally{
+                span.end();
+            }
+        });
+        telemetry.startActiveSpanAsync("Pardot Get Visitor Id", {}, this.telemetryCtx, async (span)=>{
+            promiseGetVisitorId = this.getVisitorId();
+            try {
+                identities.visitorId = await promiseGetVisitorId;
+            } catch (unused) {
+            /* IGNORE */ } finally{
+                span.end();
+            }
+        });
+        const bothFinished = Promise.allSettled([
+            promiseGetProspectEmail,
+            promiseGetVisitorId
+        ]);
+        await Promise.any([
+            promiseGetProspectEmail,
+            bothFinished,
+            timing_delay(750)
+        ]);
+        // The existence of dynamic content email means visitor association has already happened
+        // so there's no need to wait any longer for visitorId.
+        if (!identities.prospectEmail) {
+            await Promise.any([
+                promiseGetProspectEmail,
+                promiseGetVisitorId,
+                bothFinished,
+                timing_delay(1250)
+            ]);
+        }
+        promiseGetProspectEmail.cancel();
+        promiseGetVisitorId.cancel();
+        return identities;
+    }
+    getVisitorId() {
+        const { accountId } = this.config;
+        let cancel = ()=>{};
+        let interval;
+        const promise = new Promise((resolve, reject)=>{
+            cancel = reject;
+            const getCookiedId = ()=>api.get("visitor_id" + accountId);
+            // We were able to access the vistor cookie directly
+            if (getCookiedId()) {
+                resolve(getCookiedId());
+            // If window.piAId is defined, this page is setup for campaign tracking
+            // and we can get the visitor id from the cookie once it loads
+            } else if (window.parseInt(window.piAId || "", 10) - 1000 === parseInt(accountId, 10)) {
+                interval = window.setInterval(()=>{
+                    const cookieId = getCookiedId();
+                    if (cookieId) {
+                        resolve(cookieId);
+                    }
+                }, 50);
+            } else {
+                // TODO: SOL for now if there's no cookie. Add our own campaign tracking
+                // code in these cases to ensure we get a visitor id
+                reject();
+            }
+        }).finally(()=>{
+            window.clearInterval(interval);
+        });
+        promise.cancel = cancel;
+        return promise;
+    }
+    getProspectEmail() {
+        const { trackerDomain, accountId, dynamicContentId } = this.config;
+        if (!dynamicContentId) {
+            const promise = Promise.reject();
+            promise.cancel = ()=>{};
+            return promise;
+        }
+        const script = document.createElement("script");
+        const origWrite = document.write;
+        let cancel = ()=>{};
+        const promise = new Promise((resolve, reject)=>{
+            cancel = reject;
+            // Pardot dynamic content scripts use document.write to inject content
+            // and we can hijack the contents by overriding it. At this point, the
+            // document has already been loaded and invocations of document.write
+            // are illegal, so this should be mostly safe. However, in the slim
+            // chance that the embedded page has overridden it, we'll keep it around
+            // and restore it when we're done.
+            document.write = function(html) {
+                const match = /\*QUALIFIED\*(.*)\*QUALIFIED\*/.exec(html);
+                if (match) {
+                    const email = match[1].trim();
+                    if (email !== "") {
+                        resolve(email);
+                    } else {
+                        reject();
+                    }
+                } else {
+                    origWrite(html);
+                }
+            };
+            script.src = "https://" + trackerDomain + "/dcjs/" + accountId + "/" + dynamicContentId + "/dc.js";
+            // If the script loads but doesn't call document.write, we need to time out and cancel the promise
+            script.onload = ()=>pardot_visitor_setTimeout(cancel, 250);
+            script.onerror = ()=>cancel();
+            document.body.appendChild(script);
+        }).finally(()=>{
+            document.write = origWrite;
+        });
+        promise.cancel = cancel;
+        return promise;
+    }
+    constructor(pardotConfig){
+        this.config = pardotConfig;
+        this.telemetryCtx = getTelemetryCtx();
+    }
+}
+/* export default */ const pardot_visitor = (PardotVisitor);
+
+export default pardot_visitor;

package/widget/personalization_observer.js

@@ -0,0 +1,96 @@
+import { __webpack_require__ } from "../js/runtime.js";
+import { PersonalizationManager } from "../src/personalizations/personalization-manager.js";
+import { BUTTON_LIKE_SELECTOR, _debugLog } from "../src/smart_website/utils.js";
+import "./utils/native_globals.js";
+
+/* provided dependency */ var personalization_observer_setTimeout = __webpack_require__(68034).pS;
+/* provided dependency */ var cancelAnimationFrame = __webpack_require__(68034).pP;
+/* provided dependency */ var personalization_observer_clearTimeout = __webpack_require__(68034).Kj;
+/* provided dependency */ var requestAnimationFrame = __webpack_require__(68034).gj;
+
+
+const REVERT_WAIT_TIMEOUT_MS = 3000;
+class PersonalizationObserver {
+    start() {
+        this.debugLog("starting");
+        this.observer.observe(document, {
+            childList: true,
+            subtree: true
+        });
+        this.revertTimeoutHandle = personalization_observer_setTimeout(this.revert.bind(this), REVERT_WAIT_TIMEOUT_MS);
+    }
+    stop(cancelRevert) {
+        if (cancelRevert === void 0) cancelRevert = false;
+        this.debugLog("stopping");
+        this.observer.disconnect();
+        if (typeof this.requestAnimationFrameHandle === "number") {
+            cancelAnimationFrame(this.requestAnimationFrameHandle);
+        }
+        if (cancelRevert) {
+            personalization_observer_clearTimeout(this.revertTimeoutHandle);
+        }
+    }
+    revert() {
+        this.debugLog("reverting");
+        if (typeof this.requestAnimationFrameHandle === "number") {
+            cancelAnimationFrame(this.requestAnimationFrameHandle);
+        }
+        this.manager.reset();
+    }
+    observeSelectors(mutations) {
+        for (const { target } of mutations){
+            const { shouldProcess, selector } = this.shouldProcessElement(target);
+            if (!shouldProcess) {
+                continue;
+            }
+            const element = this.manager.add(target, selector);
+            // If queue is empty request processing in next frame
+            if (this.processElementsQueue.length === 0) {
+                this.requestAnimationFrameHandle = requestAnimationFrame(this.processElements.bind(this));
+            }
+            this.processElementsQueue.push(element);
+            this.processedElements.add(element);
+        }
+    }
+    shouldProcessElement(element) {
+        var _this_selectors_find;
+        if (!(element instanceof HTMLElement) || !element.matches(BUTTON_LIKE_SELECTOR) || this.processedElements.has(element)) {
+            return {
+                shouldProcess: false
+            };
+        }
+        const selector = (_this_selectors_find = this.selectors.find((param)=>{
+            let { selector } = param;
+            return element.matches(selector);
+        })) == null ? void 0 : _this_selectors_find.selector;
+        if (selector) {
+            this.debugLog("found selector " + selector);
+            return {
+                shouldProcess: true,
+                selector
+            };
+        }
+        return {
+            shouldProcess: false
+        };
+    }
+    processElements() {
+        for (const element of this.processElementsQueue){
+            this.manager.applyLoading(element, "icon");
+        }
+        this.processElementsQueue = [];
+    }
+    debugLog(msg, context) {
+        _debugLog("[personalization-observer] " + msg, context);
+    }
+    constructor(selectors){
+        this.selectors = selectors;
+        this.processedElements = new Set();
+        this.processElementsQueue = [];
+        this.manager = new PersonalizationManager();
+        this.observer = new MutationObserver(this.observeSelectors.bind(this));
+    }
+}
+
+
+export default PersonalizationObserver;

package/widget/personalizations_config.js

@@ -0,0 +1,160 @@
+import { __webpack_require__ } from "../js/runtime.js";
+import { PersonalizationManager } from "../src/personalizations/personalization-manager.js";
+import { normalizeURL, hasURLMatch } from "../src/url-utils.js";
+import "./telemetry/index.js";
+import { ShadowDomHelper } from "../src/shadow-dom-helper.js";
+import "./utils/native_globals.js";
+import { telemetry } from "./telemetry/telemetry.js";
+
+/* provided dependency */ var personalizations_config_setTimeout = __webpack_require__(68034).pS;
+
+
+
+
+const PERSONALIZE_WAIT_TIMEOUT_MS = 3000;
+class PersonalizationsConfig {
+    get hasEndedInitSpan() {
+        return this.initSpan && this.initSpan.endTime !== 0;
+    }
+    get hasExperimentSelectors() {
+        return this.experimentSelectors && this.experimentSelectors.length > 0;
+    }
+    get experimentSelectors() {
+        return this.config.experimentSelectors;
+    }
+    constructor(config, personalizationManager = new PersonalizationManager()){
+        this.config = config;
+        this.personalizationManager = personalizationManager;
+        this.donePersonalizing = false;
+        this.intermediateStateType = "icon";
+        this.selectorMetadata = new Map();
+        this.shadowDomHelper = new ShadowDomHelper();
+        this.lookupSelectorMetadata = (selector)=>{
+            return this.selectorMetadata.get(selector);
+        };
+        this.onPersonalizeWebsite = (personalizedElements)=>{
+            this.trace("Apply Personalizations", ()=>{
+                for (const element of personalizedElements){
+                    const htmlElement = this.personalizationManager.get(element.selector);
+                    if (htmlElement) {
+                        this.personalizationManager.personalize(htmlElement, {
+                            textContent: element.dom_update.text_content,
+                            backgroundColor: element.dom_update.background_color,
+                            borderColor: element.dom_update.border_color,
+                            textColor: element.dom_update.text_color
+                        });
+                        this.selectorMetadata.get(element.selector).experimentArmId = element.experiment_arm_id;
+                        this.emitPersonalizationActivity(element.selector, element.experiment_arm_id);
+                    }
+                }
+                this.donePersonalizing = true;
+            });
+            this.endInitSpan();
+        };
+        this.initCurrentExperimentSelectors = ()=>{
+            this.experimentSelectors.forEach((param)=>{
+                let { url, selector } = param;
+                if (!hasURLMatch(this.normalizedCurrentURL, normalizeURL(url), url.endsWith("*"))) {
+                    return;
+                }
+                // Selector was already added in mutation observer
+                if (this.personalizationManager.get(selector)) {
+                    this.selectorMetadata.set(selector, {
+                        emittedInView: false
+                    });
+                    return;
+                }
+                const element = this.shadowDomHelper.querySelector(selector);
+                const tag = this.personalizationManager.add(element, selector);
+                if (!tag) {
+                    return;
+                }
+                this.selectorMetadata.set(selector, {
+                    emittedInView: false
+                });
+                this.personalizationManager.applyLoading(tag, this.intermediateStateType);
+            });
+            this.initIntersectionObserver();
+        };
+        this.initIntersectionObserver = ()=>{
+            if (!this.config.activityEmitter) return;
+            const observer = new IntersectionObserver((entries)=>{
+                entries.forEach((entry)=>{
+                    if (entry.isIntersecting && entry.target instanceof HTMLElement) {
+                        const selector = this.personalizationManager.getSelector(entry.target);
+                        if (selector) {
+                            this.emitInView(selector);
+                        }
+                    }
+                });
+            }, {
+                root: null,
+                threshold: 1.0
+            });
+            this.personalizationManager.addObserver(observer);
+        };
+        this.trace = (name, fn)=>{
+            const parentSpan = this.hasEndedInitSpan ? this.initSpan : null;
+            telemetry.startActiveSpan(name, {}, parentSpan, (span)=>{
+                fn();
+                span.end();
+            });
+        };
+        this.endInitSpan = ()=>{
+            if (this.initSpan && !this.hasEndedInitSpan) {
+                this.initSpan.end();
+            }
+        };
+        this.resetElements = ()=>{
+            if (this.donePersonalizing) {
+                return;
+            }
+            this.trace("Revert Experiment Selectors", ()=>this.personalizationManager.reset());
+            this.endInitSpan();
+        };
+        this.emitPersonalizationActivity = (selector, experimentArmId)=>{
+            if (!this.config.activityEmitter) {
+                return;
+            }
+            if (experimentArmId) {
+                this.config.activityEmitter.emitPersonalizationApplied({
+                    experimentArmId,
+                    selector
+                });
+            } else {
+                this.config.activityEmitter.emitPersonalizationFallback({
+                    selector
+                });
+            }
+        };
+        this.emitInView = (selector)=>{
+            if (!this.config.activityEmitter) {
+                return;
+            }
+            const metadata = this.selectorMetadata.get(selector);
+            if (!metadata) {
+                return;
+            }
+            const { experimentArmId, emittedInView } = metadata;
+            if (!emittedInView) {
+                this.config.activityEmitter.emitPersonalizationInView({
+                    selector,
+                    experimentArmId
+                });
+                metadata.emittedInView = true;
+            }
+        };
+        const { currentUrl } = config;
+        this.initSpan = telemetry.startSpan("Evaluating Personalization", {}, null) || null;
+        this.normalizedCurrentURL = normalizeURL(currentUrl);
+        if (!this.hasExperimentSelectors) {
+            this.donePersonalizing = true;
+            return;
+        }
+        this.trace("Initialize Experiment Selectors", this.initCurrentExperimentSelectors);
+        personalizations_config_setTimeout(this.resetElements, PERSONALIZE_WAIT_TIMEOUT_MS);
+    }
+}
+/* export default */ const personalizations_config = (PersonalizationsConfig);
+
+export default personalizations_config;

package/widget/qualified_form/constants.js

@@ -0,0 +1,23 @@
+import { isIn } from "../../src/utils.js";
+
+// Need to import as a type or to avoid importing the react library
+
+const QUALIFIED_FORM_CONVERSATION_NOT_SUPPORTED_MESSAGES = [
+    "lightbox_gather"
+];
+const QUALIFIED_FORM_CONVERSATION_ALLOWED_MESSAGES = [
+    "lightbox_gather",
+    "calendar_event_offer",
+    "calendar_event_confirmation",
+    "text"
+].filter((message)=>!isIn(QUALIFIED_FORM_CONVERSATION_NOT_SUPPORTED_MESSAGES, message));
+const QUALIFIED_FORM_EVENTS = [
+    "initQualifiedFormElementConversation",
+    "qualifiedFormEnd",
+    "qualifiedFormRedirect"
+];
+const QUALIFIED_FORM_END_TIMEOUT = 30000;
+const WIDGET_PASS_CONTROL_DELAY = 500;
+
+var constants_QUALIFIED_FORM_CONVERSATION_NOT_SUPPORTED_MESSAGES = /* unused export */ undefined;
+export { QUALIFIED_FORM_CONVERSATION_ALLOWED_MESSAGES, QUALIFIED_FORM_END_TIMEOUT, QUALIFIED_FORM_EVENTS, WIDGET_PASS_CONTROL_DELAY, constants_QUALIFIED_FORM_CONVERSATION_NOT_SUPPORTED_MESSAGES as QUALIFIED_FORM_CONVERSATION_NOT_SUPPORTED_MESSAGES };

package/widget/qualified_form/phone_utils.js

@@ -0,0 +1,38 @@
+function isValidPhoneNumber(phoneNumber) {
+    // Check for null/undefined/non-string
+    if (!phoneNumber || typeof phoneNumber !== "string") {
+        return false;
+    }
+    // Trim whitespace
+    phoneNumber = phoneNumber.replace(/\s+/g, "");
+    // Check for empty string
+    if (phoneNumber.length === 0) {
+        return false;
+    }
+    // Check for invalid characters
+    if (/[^\d\s+().-]/.test(phoneNumber)) {
+        return false;
+    }
+    // Check for invalid patterns
+    if (phoneNumber.includes("++") || // Multiple plus signs
+    phoneNumber.includes("+0") || // Plus followed by zero
+    phoneNumber.includes("+-") || // Plus followed by minus
+    phoneNumber.includes("+00") || // Plus followed by 00
+    (phoneNumber.match(/\+/g) || []).length > 1 || // Multiple plus signs anywhere
+    phoneNumber.includes("00+") || // 00 followed by plus
+    phoneNumber.includes("+") && !phoneNumber.startsWith("+") // Plus sign not at start
+    ) {
+        return false;
+    }
+    // Clean the number to check final format
+    const cleaned = phoneNumber.replace(/[^0-9+]/g, "").replace(/^00/g, "+");
+    // Validate final format (8-15 digits, with optional + prefix)
+    return /^(?:\+\d{8,15}|\d{8,15})$/.test(cleaned);
+}
+function formatPhoneNumber(phoneNumber) {
+    return phoneNumber.trim().replace(/[^0-9+]/g, "") // Remove all non-digit chars except +
+    .replace(/^00/g, "+"); // Convert 00 prefix to +
+}
+
+
+export { formatPhoneNumber, isValidPhoneNumber };

package/widget/qualified_form/qualified_form_action.js

@@ -0,0 +1,91 @@
+import { __webpack_require__ } from "../../js/runtime.js";
+import "../utils/native_globals.js";
+
+/* provided dependency */ var qualified_form_action_setTimeout = __webpack_require__(68034).pS;
+/* provided dependency */ var qualified_form_action_clearTimeout = __webpack_require__(68034).Kj;
+class QualifiedFormAction {
+    wait() {
+        if (this.isWaiting) {
+            return this.promise;
+        }
+        this.isWaiting = true;
+        if (this.options.type === "custom-event-resolver") {
+            this.resolveUsingCustomResolver();
+        }
+        if (this.options.type === "basic-event-resolver" || this.options.type === "custom-event-resolver") {
+            this.channel.on(this.options.event, this.listener);
+        }
+        if (this.options.type === "timeout") {
+            this.timeoutHandle = qualified_form_action_setTimeout(()=>this.resolveUsingTimeout(), this.options.timeout);
+        }
+        return this.promise;
+    }
+    waitDisposed() {
+        return this.disposedPromise;
+    }
+    waitDisposedOrResolved() {
+        return Promise.race([
+            this.wait(),
+            this.waitDisposed()
+        ]);
+    }
+    get isDisposed() {
+        return this._isDisposed;
+    }
+    get isResolved() {
+        return this._isResolved;
+    }
+    resolveUsingCustomResolver(payload) {
+        if (this._isResolved || this.options.type !== "custom-event-resolver") return;
+        if (!this.options.shouldResolve(payload)) return;
+        this.options.resolver(this.resolve, this.dispose);
+    }
+    resolveUsingBasicResolver(payload) {
+        if (this._isResolved || this.options.type !== "basic-event-resolver") return;
+        this.resolve(this.options.resolver(payload));
+        this.dispose();
+    }
+    resolveUsingTimeout() {
+        if (this._isResolved || this.options.type !== "timeout") return;
+        this.resolve(this.options.result);
+        this.dispose();
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor(channel, options){
+        this.channel = channel;
+        this.options = options;
+        this._isResolved = false;
+        this._isDisposed = false;
+        this.timeoutHandle = null;
+        this.isWaiting = false;
+        this.dispose = ()=>{
+            if (this._isDisposed) return;
+            if (this.options.type === "basic-event-resolver" || this.options.type === "custom-event-resolver") {
+                this.channel.off(this.options.event, this.listener);
+            }
+            if (this.timeoutHandle) {
+                qualified_form_action_clearTimeout(this.timeoutHandle);
+                this.timeoutHandle = null;
+            }
+            this._isDisposed = true;
+            this._resolveDisposed();
+        };
+        this.listener = (payload)=>{
+            if (this.options.type === "custom-event-resolver") {
+                this.options.onMessage(payload, this.dispose);
+                this.resolveUsingCustomResolver(payload);
+            } else {
+                this.resolveUsingBasicResolver(payload);
+            }
+        };
+        this.resolve = (value)=>{
+            if (this._isResolved) return;
+            this._isResolved = true;
+            this._resolve(value);
+        };
+        this.promise = new Promise((resolve)=>this._resolve = resolve);
+        this.disposedPromise = new Promise((resolve)=>this._resolveDisposed = resolve);
+    }
+}
+
+export { QualifiedFormAction };

package/widget/qualified_form/qualified_form_action_orchestrator.js

@@ -0,0 +1,21 @@
+class QualifiedFormActionOrchestrator {
+    addActions(actions) {
+        this.actions.push(...actions);
+        return this;
+    }
+    async race() {
+        const action = await Promise.race(this.actions.map((action)=>action.wait()));
+        this.dispose();
+        return action;
+    }
+    dispose() {
+        this.actions.forEach((action)=>!action.isResolved && action.dispose());
+        this.actions = [];
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor(actions = []){
+        this.actions = actions;
+    }
+}
+
+export { QualifiedFormActionOrchestrator };