@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/src/iframes.js

@@ -0,0 +1,86 @@
+import { __webpack_require__ } from "../js/runtime.js";
+import "../js/4101.js";
+
+const escapeRegExp = __webpack_require__("64700");
+var escapeRegExp_default = /*#__PURE__*/__webpack_require__.n(escapeRegExp);
+
+function isIframed() {
+    try {
+        return window.self !== window.top;
+    } catch (e) {
+        return true; // Some browsers will raise a same origin exception on `window.top`
+    }
+}
+function getParentOrigin() {
+    let origin;
+    try {
+        var _window_location_ancestorOrigins;
+        // ancestorOrigins is always correct but is only supported on Chrome/Edge/Safari.
+        if (((_window_location_ancestorOrigins = window.location.ancestorOrigins) == null ? void 0 : _window_location_ancestorOrigins.length) > 0) {
+            origin = window.location.ancestorOrigins[0];
+        }
+        // document.referrer works in all browsers, but may be wrong if an iframe is redirected
+        // like after an embedded form submission.
+        if (!origin) {
+            origin = new URL(document.referrer).origin;
+        }
+    } catch (e) {
+    /* IGNORE */ }
+    return origin;
+}
+/**
+ * Check if a url matches a list of domain patterns
+ * @param hosts array of strings that represent domain patterns. If checkPath is true, this can also represent full urls (host + pathname)
+ * @param url valid url string
+ * @param checkPath if true, the pathname of the url will be checked as well
+ */ function isDomainMatch(hosts, url, checkPath) {
+    if (checkPath === void 0) checkPath = false;
+    if (!url) return false;
+    let urlHost;
+    let normalizedUrl;
+    try {
+        const parsedUrl = new URL(url);
+        urlHost = parsedUrl.host.toLowerCase();
+        urlHost = urlHost.startsWith("www.") && checkPath ? urlHost.slice(4) : urlHost;
+        normalizedUrl = urlHost + parsedUrl.pathname.toLocaleLowerCase();
+        normalizedUrl = normalizedUrl.endsWith("/") ? normalizedUrl.slice(0, -1) : normalizedUrl;
+    } catch (e) {
+        return false; // invalid url always returns false
+    }
+    if (hosts.length === 0) return true; // here if hosts is empty then we allow all valid urls
+    // compile regex patterns from hosts string array
+    // this implementation mirrors implementation of Team::Allowlisting#allowlisted? and Domains::RegexMap#compile_pattern
+    const allowedRegexMap = {};
+    hosts.forEach((host)=>{
+        const splitStringList = host.split(".");
+        const splitStringRegexpList = [];
+        splitStringList.forEach((stringSegment)=>{
+            if (stringSegment === "*") {
+                splitStringRegexpList.push("(.*?)");
+            } else {
+                splitStringRegexpList.push(escapeRegExp_default()(stringSegment));
+            }
+        });
+        allowedRegexMap[host] = new RegExp("^" + splitStringRegexpList.join("\\.") + "$");
+    });
+    const normalizedHostPattern = (host)=>host.replace(/^https?:\/\//, "").toLowerCase();
+    for (const [host, regexExp] of Object.entries(allowedRegexMap)){
+        const hostPattern = normalizedHostPattern(host);
+        const hasPath = hostPattern.includes("/");
+        // If checkPath is true, we have to check the pathname
+        // But, if host represents an entire domain (eg: "example.com"), we don't need to check the pathname
+        // If host represents a specific page (eg: "example.com/path"), we need to check the pathname
+        if (checkPath && hasPath) {
+            if (regexExp.test(normalizedUrl)) {
+                return true;
+            }
+        // If checkPath is false, we only check the host
+        } else if (regexExp.test(urlHost)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+var iframes_getParentOrigin = /* unused export */ undefined;
+export { iframes_getParentOrigin as getParentOrigin, isDomainMatch, isIframed };

package/src/localstorage.js

@@ -0,0 +1,43 @@
+function set(key, value) {
+    localStorage.setItem(key, JSON.stringify(value));
+    return true;
+}
+function safeSet(key, value) {
+    try {
+        return set(key, value);
+    } catch (e) {
+        return false;
+    }
+}
+function get(key) {
+    const str = localStorage.getItem(key);
+    return JSON.parse(str);
+}
+function safeGet(key) {
+    try {
+        return get(key);
+    } catch (e) {
+        return null;
+    }
+}
+function remove(key) {
+    localStorage.removeItem(key);
+    return true;
+}
+function safeRemove(key) {
+    try {
+        return remove(key);
+    } catch (e) {
+        return false;
+    }
+}
+// TODO: update downstream imports from "safeSet as localStorageSet" to "localStorageSet"
+const localStorageSet = safeSet;
+const localStorageGet = safeGet;
+const localStorageRemove = safeRemove;
+
+var localstorage_get = /* unused export */ undefined;
+var localstorage_remove = /* unused export */ undefined;
+var localstorage_safeRemove = /* unused export */ undefined;
+var localstorage_set = /* unused export */ undefined;
+export { localStorageGet, localStorageRemove, localStorageSet, localstorage_get as get, localstorage_remove as remove, localstorage_safeRemove as safeRemove, localstorage_set as set, safeGet, safeSet };

package/src/mirror/Shipper.js

@@ -0,0 +1,133 @@
+import { __webpack_require__ } from "../../js/runtime.js";
+import "../../js/4101.js";
+import { MessageType } from "./constants.js";
+import { ChangeQueue } from "./shipper/ChangeQueue.js";
+import { DOMSerializer } from "./shipper/DOMSerializer.js";
+import { WindowFocus, Location, MousePosition, MouseClick, Selection, Mutations, Visibility, StylesheetRulesObserver, DocumentScroll, Dimensions, ElementFocus, MediaStateObserver, InputValueObserver, DocumentTree } from "./shipper/observers.js";
+
+const throttle = __webpack_require__("61442");
+var throttle_default = /*#__PURE__*/__webpack_require__.n(throttle);
+
+
+
+
+
+// Helper classes resposible for state or observering. Order here matters for inclusion in keyframes.
+const Helpers = [
+    Location,
+    DocumentTree,
+    DocumentScroll,
+    MousePosition,
+    MouseClick,
+    Dimensions,
+    Visibility,
+    WindowFocus,
+    Selection,
+    ElementFocus,
+    Mutations,
+    StylesheetRulesObserver,
+    MediaStateObserver,
+    InputValueObserver
+];
+class Shipper {
+    dispose() {
+        this.clear();
+        this.helpers.forEach((helper)=>helper.dispose());
+        if (this.window.__qlfdNodeForId) {
+            delete this.window.__qlfdNodeForId;
+        }
+    }
+    // Reverse lookup: a co-browse node-id -> the live host-page node it was assigned to. Used by the
+    // multimodal widget to anchor Piper's cursor to a specific element (point_at_page). The element's
+    // node-id is the same on both ends (Shipper assigns it; the renderer's Receiver mirrors it), so
+    // this survives scroll/reflow unlike pixel coordinates.
+    //
+    // Backed by a lazily-built reverse Map of serializer.nodesToIds, rebuilt only when that map has
+    // changed. Additions always bump serializer.idSeq and deletions always shrink the map, so the
+    // (idSeq, size) pair changes on every mutation and is a sound staleness check.
+    nodeForId(id) {
+        var _this_idsToNodes_get;
+        const { nodesToIds, idSeq } = this.serializer;
+        if (!this.idsToNodes || this.idsToNodesIdSeq !== idSeq || this.idsToNodesSize !== nodesToIds.size) {
+            this.idsToNodes = new Map();
+            for (const [node, nodeId] of nodesToIds){
+                this.idsToNodes.set(nodeId, node);
+            }
+            this.idsToNodesIdSeq = idSeq;
+            this.idsToNodesSize = nodesToIds.size;
+        }
+        return (_this_idsToNodes_get = this.idsToNodes.get(id)) != null ? _this_idsToNodes_get : null;
+    }
+    clear() {
+        this.serializer.clear();
+        this.changeQueue.clear();
+        this.sendFrame.cancel();
+    }
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.helpers.forEach((helper)=>helper.init());
+        this.started = true;
+        // Expose the id->node reverse lookup on the host window so the multimodal widget can anchor
+        // Piper's cursor to an element by its co-browse node-id (see website_navigation_store#pointAtNode).
+        this.window.__qlfdNodeForId = (id)=>this.nodeForId(id);
+        this.sendKeyframe();
+    }
+    // A message is: [protocolVersion!, messageType!, changes[], newNodes[], deletedNodes[]]
+    sendKeyframe() {
+        if (!this.started) {
+            return;
+        } // Ignore keyframe requests until we start.
+        this.clear();
+        // It's important serializer.take() happens after changes serialization.
+        const changes = this.keyframeHelpers.map((helper)=>helper.serialize()), [newNodes, deletedNodes] = this.serializer.take();
+        this.sendMessage([
+            (/* inlined export .ProtocolVersion */1),
+            MessageType.Keyframe,
+            changes,
+            newNodes,
+            deletedNodes
+        ]);
+    }
+    onNestedShipperMessage(iframeElement, message) {
+        this.changeQueue.nestedShipperMessage(iframeElement, message);
+        this.sendFrame();
+    }
+    constructor(wind, doc, sendMessage, observeInputValue = false){
+        this.sendFrame = throttle_default()(()=>{
+            // Order here also matters like in sendKeyframe.
+            const changes = this.changeQueue.take(), [newNodes, deletedNodes] = this.serializer.take();
+            this.sendMessage([
+                (/* inlined export .ProtocolVersion */1),
+                MessageType.Frame,
+                changes,
+                newNodes,
+                deletedNodes
+            ]);
+        }, 1000 / (/* inlined export .FRAME_FPS */15));
+        this.window = wind;
+        this.document = doc;
+        this.sendMessage = sendMessage;
+        this.observeInputValue = observeInputValue;
+        this.started = false;
+        this.serializer = new DOMSerializer(this);
+        this.changeQueue = new ChangeQueue(this);
+        // Lazily-built reverse index for nodeForId (see below).
+        this.idsToNodes = null;
+        this.idsToNodesIdSeq = 0;
+        this.idsToNodesSize = 0;
+        this.helpers = [];
+        this.keyframeHelpers = [];
+        Helpers.forEach((Helper)=>{
+            const helper = new Helper(this);
+            this.helpers.push(helper);
+            if (Helper.includedInKeyframe) {
+                this.keyframeHelpers.push(helper);
+            }
+        });
+    }
+}
+
+
+export default Shipper;

package/src/mirror/constants.generated.js

@@ -0,0 +1,13 @@
+// DO NOT EDIT! This file is auto-generated from:
+// app/javascript/codegen.rb
+//
+// To regenerate this file, run `./bin/rails js:codegen`.
+const COBROWSE_PSEUDO_CLASSES = {
+    ":hover": ".__q__hover",
+    ":focus-within": ".__q__focus_within",
+    ":focus-visible": ".__q__focus_visible",
+    ":focus": ".__q__focus",
+    ":active": ".__q__active"
+};
+
+export { COBROWSE_PSEUDO_CLASSES };

package/src/mirror/constants.js

@@ -0,0 +1,238 @@
+import { __webpack_require__ } from "../../js/runtime.js";
+import "../../js/4101.js";
+
+const invert = __webpack_require__("81198");
+var invert_default = /*#__PURE__*/__webpack_require__.n(invert);
+const mapValues = __webpack_require__("20504");
+var mapValues_default = /*#__PURE__*/__webpack_require__.n(mapValues);
+
+
+const FRAME_FPS = 15;
+const FRAME_MS = (/* unused pure expression or super */ null && (1000 / FRAME_FPS));
+// Detecting IFRAME load can be tricky, especially on Safari, so this canary is used as an extra check.
+// We use a non-displaying character because if nested IFRAMEs fail, we don't want users to see anything.
+// Note: Must match public/console/live-view.html (used by Firefox)
+const IFRAME_BODY_CANARY = "\u200B";
+const IFRAME_SRCDOC = "<body>&#8203;</body>";
+// Protocol Constants
+const ProtocolVersion = 1;
+const MessageType = {
+    Keyframe: 1,
+    Frame: 2,
+    Connected: 3,
+    Disconnected: 4
+};
+const ChangeType = {
+    DocumentTree: 1,
+    NodeTree: 2,
+    NodeAttribute: 3,
+    NodeData: 4,
+    NodeProperty: 5,
+    DocumentScroll: 6,
+    Mouse: 7,
+    Click: 8,
+    Dimensions: 9,
+    Visibility: 10,
+    WindowFocus: 11,
+    Selection: 12,
+    ElementFocus: 13,
+    Location: 14,
+    NestedMessage: 15
+};
+// DOM Serialization Constants to save on message space
+const NODE_TYPES = (/* unused pure expression or super */ null && ({
+    1: "Element",
+    3: "Text",
+    4: "CDATASection",
+    7: "ProcessingInstruction",
+    8: "Comment",
+    9: "Document",
+    10: "DocumentType",
+    11: "DocumentFragment"
+}));
+// Common tags, attributes, and properties to reduce message sizes.
+// DO NOT CHANGE the order or insert a new one in the middle, it will change the protocol.
+const invertCodingArray = (array)=>mapValues_default()(invert_default()(array), (value)=>Number.parseInt(value, 10));
+const NAMESPACE_CODING = [
+    "http://www.w3.org/1999/xhtml",
+    "http://www.w3.org/2000/svg",
+    "http://www.w3.org/1999/xlink",
+    "http://www.w3.org/1998/Math/MathML"
+];
+const NAMESPACES = invertCodingArray(NAMESPACE_CODING);
+const TAGNAME_CODING = [
+    null,
+    // HTML
+    "A",
+    "ABBR",
+    "ADDRESS",
+    "AREA",
+    "ARTICLE",
+    "ASIDE",
+    "AUDIO",
+    "B",
+    "BASE",
+    "BDI",
+    "BDO",
+    "BIG",
+    "BLOCKQUOTE",
+    "BODY",
+    "BR",
+    "BUTTON",
+    "CANVAS",
+    "CAPTION",
+    "CITE",
+    "CODE",
+    "COL",
+    "COLGROUP",
+    "DATA",
+    "DATALIST",
+    "DD",
+    "DEL",
+    "DETAILS",
+    "DFN",
+    "DIALOG",
+    "DIV",
+    "DL",
+    "DT",
+    "EM",
+    "EMBED",
+    "FIELDSET",
+    "FIGCAPTION",
+    "FIGURE",
+    "FOOTER",
+    "FORM",
+    "H1",
+    "H2",
+    "H3",
+    "H4",
+    "H5",
+    "H6",
+    "HEAD",
+    "HEADER",
+    "HR",
+    "HTML",
+    "I",
+    "IFRAME",
+    "IMG",
+    "INPUT",
+    "INS",
+    "KBD",
+    "KEYGEN",
+    "LABEL",
+    "LEGEND",
+    "LI",
+    "LINK",
+    "MAIN",
+    "MAP",
+    "MARK",
+    "MENU",
+    "MENUITEM",
+    "META",
+    "METER",
+    "NAV",
+    "NOSCRIPT",
+    "OBJECT",
+    "OL",
+    "OPTGROUP",
+    "OPTION",
+    "OUTPUT",
+    "P",
+    "PARAM",
+    "PICTURE",
+    "PRE",
+    "PROGRESS",
+    "Q",
+    "RP",
+    "RT",
+    "RUBY",
+    "S",
+    "SAMP",
+    "SCRIPT",
+    "SECTION",
+    "SELECT",
+    "SMALL",
+    "SOURCE",
+    "SPAN",
+    "STRONG",
+    "STYLE",
+    "SUB",
+    "SUMMARY",
+    "SUP",
+    "TABLE",
+    "TBODY",
+    "TD",
+    "TEXTAREA",
+    "TFOOT",
+    "TH",
+    "THEAD",
+    "TIME",
+    "TITLE",
+    "TR",
+    "TRACK",
+    "U",
+    "UL",
+    "VAR",
+    "VIDEO",
+    "WBR",
+    // SVG
+    "circle",
+    "clipPath",
+    "defs",
+    "ellipse",
+    "g",
+    "line",
+    "linearGradient",
+    "mask",
+    "path",
+    "pattern",
+    "polygon",
+    "polyline",
+    "radialGradient",
+    "rect",
+    "stop",
+    "svg",
+    "text",
+    "tspan",
+    "use"
+];
+const TAGNAMES = invertCodingArray(TAGNAME_CODING);
+const ATTRIBUTE_CODING = [
+    null
+];
+const ATTRIBUTES = invertCodingArray(ATTRIBUTE_CODING);
+const PROPERTY_CODING = [
+    null,
+    "scrollLeft",
+    "scrollTop",
+    "value",
+    "paused",
+    "currentTime",
+    "controls"
+];
+const PROPERTIES = invertCodingArray(PROPERTY_CODING);
+const VALID_PROPERTIES = PROPERTY_CODING.filter((propertyName)=>!!propertyName);
+// These tags neither ship mutations on the Shipper side, nor emit DOM on the receiver side. It's
+// important to filter on both sides because of security implications.
+const IGNORED_TAGS = [
+    "NOSCRIPT",
+    "SCRIPT",
+    "TITLE",
+    "FRAME"
+];
+
+const safeArrayGet = (array, untrustedIndex)=>typeof untrustedIndex === "number" && untrustedIndex >= 0 && untrustedIndex < array.length ? array[untrustedIndex] : undefined;
+
+var constants_ATTRIBUTES = /* unused export */ undefined;
+var constants_ATTRIBUTE_CODING = /* unused export */ undefined;
+var constants_FRAME_MS = /* unused export */ undefined;
+var constants_IFRAME_BODY_CANARY = /* unused export */ undefined;
+var constants_IFRAME_SRCDOC = /* unused export */ undefined;
+var constants_NAMESPACE_CODING = /* unused export */ undefined;
+var constants_NODE_TYPES = /* unused export */ undefined;
+var constants_PROPERTIES = /* unused export */ undefined;
+var constants_PROPERTY_CODING = /* unused export */ undefined;
+var constants_TAGNAME_CODING = /* unused export */ undefined;
+var constants_safeArrayGet = /* unused export */ undefined;
+export { ChangeType, FRAME_FPS, IGNORED_TAGS, MessageType, NAMESPACES, ProtocolVersion, TAGNAMES, VALID_PROPERTIES, constants_ATTRIBUTES as ATTRIBUTES, constants_ATTRIBUTE_CODING as ATTRIBUTE_CODING, constants_FRAME_MS as FRAME_MS, constants_IFRAME_BODY_CANARY as IFRAME_BODY_CANARY, constants_IFRAME_SRCDOC as IFRAME_SRCDOC, constants_NAMESPACE_CODING as NAMESPACE_CODING, constants_NODE_TYPES as NODE_TYPES, constants_PROPERTIES as PROPERTIES, constants_PROPERTY_CODING as PROPERTY_CODING, constants_TAGNAME_CODING as TAGNAME_CODING, constants_safeArrayGet as safeArrayGet };
+export { COBROWSE_PSEUDO_CLASSES } from "./constants.generated.js";

package/src/mirror/shipper/ChangeQueue.js

@@ -0,0 +1,155 @@
+import { ChangeType, IGNORED_TAGS } from "../constants.js";
+import { ShipperHelper } from "./utils.js";
+
+
+
+class ChangeQueue extends ShipperHelper {
+    clear() {
+        this.changes = [];
+        this.changedGlobals.clear();
+        this.changedNodes.clear();
+    }
+    // ENQUEUE CHANGES
+    globalChanged(state) {
+        this.changedGlobals.add(state);
+    }
+    // Event-like changes immediately queue up a change record, they don't de-dupe between frames.
+    eventHappened(eventChangeRecord) {
+        this.changes.push(eventChangeRecord);
+    }
+    // Tree changes immediately queue up a change record, they don't de-dupe between frames.
+    nodeTreeChanged(target, removedNodes, nextSibling, addedNodes) {
+        const changeRecord = [
+            this.serializer.nodeToId(target),
+            0,
+            nextSibling != null ? this.serializer.nodeToId(nextSibling) : 0,
+            0
+        ];
+        if (removedNodes.length > 0) {
+            changeRecord[1] = [];
+            for(let j = 0; j < removedNodes.length; j++){
+                const removedNode = removedNodes[j];
+                this.serializer.possiblyRemoved(removedNode);
+                changeRecord[1].push(this.serializer.nodeToId(removedNode));
+            }
+        }
+        if (addedNodes.length > 0) {
+            changeRecord[3] = [];
+            for(let j = 0; j < addedNodes.length; j++){
+                const addedNode = addedNodes[j];
+                changeRecord[3].push(this.serializer.idTree(addedNode));
+            }
+        }
+        this.changes.push([
+            ChangeType.NodeTree,
+            changeRecord
+        ]);
+    }
+    // Single node changes are marked dirty and converted to change records at next frame.
+    nodeAttributeChanged(node, attributeName) {
+        if (this.isRelevantNodeType(node)) {
+            this.getNodeChanges(node).markAttribute(attributeName);
+        }
+    }
+    nodeDataChanged(node) {
+        if (this.isRelevantNodeType(node)) {
+            this.getNodeChanges(node).markData();
+        }
+    }
+    nodePropertyChanged(node, propertyName) {
+        if (this.isRelevantNodeType(node)) {
+            this.getNodeChanges(node).markProperty(propertyName);
+        }
+    }
+    nestedShipperMessage(node, message) {
+        this.changes.push([
+            ChangeType.NestedMessage,
+            [
+                this.serializer.nodeToId(node),
+                message
+            ]
+        ]);
+    }
+    // DEQUEUE
+    take() {
+        // Add a change record for every node attribute, property, or data that changed since last frame.
+        this.changedNodes.forEach((nodeChanges, node)=>{
+            nodeChanges.forEachProperty((propertyName)=>{
+                this.changes.push([
+                    ChangeType.NodeProperty,
+                    this.serializer.serializeNodePropertyRow(node, propertyName)
+                ]);
+            });
+            nodeChanges.forEachAttribute((attributeName)=>{
+                this.changes.push([
+                    ChangeType.NodeAttribute,
+                    this.serializer.serializeNodeAttributeRow(node, attributeName)
+                ]);
+            });
+            if (nodeChanges.data) {
+                this.changes.push([
+                    ChangeType.NodeData,
+                    this.serializer.serializeNodeDataRow(node)
+                ]);
+            }
+        });
+        // Add change records for any global state that changed.
+        if (this.changedGlobals.size > 0) {
+            this.changedGlobals.forEach((state)=>{
+                this.changes.push(state.serialize());
+            });
+        }
+        const changesOut = this.changes;
+        this.clear();
+        return changesOut;
+    }
+    // PRIVATE
+    isRelevantNodeType(node) {
+        const { Node } = this.shipper.window, { nodeType } = node;
+        return nodeType === Node.TEXT_NODE || nodeType === Node.ELEMENT_NODE && !IGNORED_TAGS.includes(node.tagName) || nodeType === Node.DOCUMENT_NODE;
+    }
+    getNodeChanges(node) {
+        if (!this.changedNodes.has(node)) {
+            const nodeChanges = new NodeChanges();
+            this.changedNodes.set(node, nodeChanges);
+            return nodeChanges;
+        } else {
+            return this.changedNodes.get(node);
+        }
+    }
+    constructor(shipper){
+        super(shipper);
+        this.changes = [];
+        this.changedGlobals = new Set();
+        this.changedNodes = new Map();
+    }
+}
+// Track what parts of a node changed for the next frame. This auto-dedupes multiple changes to the
+// same property or attribute between frames.
+//
+// TODO: don't dedupe class or style attributes, as they control animations and transitions. Need
+// a next tick setting mechanism in Receiver nodes to properly do that.
+class NodeChanges {
+    markProperty(propertyName) {
+        this.properties[propertyName] = true;
+    }
+    markAttribute(attributeName) {
+        this.attributes[attributeName] = true;
+    }
+    markData() {
+        this.data = true;
+    }
+    forEachProperty(callback) {
+        Object.keys(this.properties).forEach(callback);
+    }
+    forEachAttribute(callback) {
+        Object.keys(this.attributes).forEach(callback);
+    }
+    constructor(){
+        this.properties = {};
+        this.attributes = {};
+        this.data = false;
+    }
+}
+
+export { ChangeQueue };