@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/vendor/actioncable/connection_monitor.js

@@ -0,0 +1,129 @@
+import { __webpack_require__ } from "../../js/runtime.js";
+import { logger } from "./logger.js";
+import "../../widget/utils/native_globals.js";
+
+/* provided dependency */ var connection_monitor_clearTimeout = __webpack_require__(68034).Kj;
+/* provided dependency */ var connection_monitor_setTimeout = __webpack_require__(68034).pS;
+
+// Responsible for ensuring the cable connection is in good health by validating the heartbeat pings sent from the server, and attempting
+// revival reconnections if things go astray. Internal class, not intended for direct user manipulation.
+const now = ()=>new Date().getTime();
+const secondsSince = (time)=>(now() - time) / 1000;
+class ConnectionMonitor {
+    start() {
+        if (!this.isRunning()) {
+            this.startedAt = now();
+            delete this.stoppedAt;
+            this.startPolling();
+            addEventListener("visibilitychange", this.visibilityDidChange);
+            logger.log("ConnectionMonitor started. stale threshold = " + this.constructor.staleThreshold + " s");
+        }
+    }
+    stop() {
+        if (this.isRunning()) {
+            this.stoppedAt = now();
+            this.stopPolling();
+            removeEventListener("visibilitychange", this.visibilityDidChange);
+            logger.log("ConnectionMonitor stopped");
+        }
+    }
+    isRunning() {
+        return this.startedAt && !this.stoppedAt;
+    }
+    recordPing() {
+        this.pingedAt = now();
+    }
+    // START PATCH
+    recordConnectWaiting() {
+        this.connectWaitingStartedAt = now();
+        logger.log("ConnectionMonitor recorded waiting for connect");
+    }
+    // END PATCH
+    recordConnect() {
+        this.reconnectAttempts = 0;
+        this.recordPing();
+        delete this.connectWaitingStartedAt;
+        delete this.disconnectedAt;
+        logger.log("ConnectionMonitor recorded connect");
+    }
+    recordDisconnect() {
+        this.disconnectedAt = now();
+        logger.log("ConnectionMonitor recorded disconnect");
+    }
+    // Private
+    startPolling() {
+        this.stopPolling();
+        this.poll();
+    }
+    stopPolling() {
+        connection_monitor_clearTimeout(this.pollTimeout);
+    }
+    poll() {
+        this.pollTimeout = connection_monitor_setTimeout(()=>{
+            this.reconnectIfStale();
+            this.poll();
+        }, this.getPollInterval());
+    }
+    // The poll interval introduces a jitter of a relatively large range (e.g. first reconnect attempt can take)
+    // anywhere from 6-12s. This is intentionally wide (and most important for the first reconnect) to avoid stampeding-herd
+    // effects when dynos restart (e.g. during deploy) and widgets reconnect.
+    getPollInterval() {
+        const { staleThreshold, reconnectionBackoffRate } = this.constructor;
+        const backoff = Math.pow(1 + reconnectionBackoffRate, Math.min(this.reconnectAttempts, 10));
+        const jitterMax = this.reconnectAttempts === 0 ? 1.0 : reconnectionBackoffRate;
+        const jitter = jitterMax * Math.random();
+        return staleThreshold * 1000 * backoff * (1 + jitter);
+    }
+    reconnectIfStale() {
+        if (this.connectionIsStale()) {
+            logger.log("ConnectionMonitor detected stale connection. reconnectAttempts = " + this.reconnectAttempts + ", time stale = " + secondsSince(this.refreshedAt) + " s, stale threshold = " + this.constructor.staleThreshold + " s");
+            this.reconnectAttempts++;
+            if (this.disconnectedRecently()) {
+                logger.log("ConnectionMonitor skipping reopening recent disconnect. time disconnected = " + secondsSince(this.disconnectedAt) + " s");
+            // START PATCH
+            } else if (this.waitingForConnect()) {
+                logger.log("ConnectionMonitor skipping reopening recent connect waiting. time waiting = " + secondsSince(this.connectWaitingStartedAt) + " s");
+            // END PATCH
+            } else {
+                logger.log("ConnectionMonitor reopening");
+                this.connection.reopen();
+            }
+        }
+    }
+    get refreshedAt() {
+        return this.pingedAt ? this.pingedAt : this.startedAt;
+    }
+    connectionIsStale() {
+        return secondsSince(this.refreshedAt) > this.constructor.staleThreshold;
+    }
+    disconnectedRecently() {
+        return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
+    }
+    // START PATCH
+    waitingForConnect() {
+        return this.connectWaitingStartedAt && secondsSince(this.connectWaitingStartedAt) < this.constructor.staleThreshold;
+    }
+    // END PATCH
+    visibilityDidChange() {
+        if (document.visibilityState === "visible") {
+            connection_monitor_setTimeout(()=>{
+                // START PATCH
+                if (this.connectionIsStale() && !this.waitingForConnect() || !this.connection.isOpen()) {
+                    // END PATCH
+                    logger.log("ConnectionMonitor reopening stale connection on visibilitychange. visibilityState = " + document.visibilityState);
+                    this.connection.reopen();
+                }
+            }, 200);
+        }
+    }
+    constructor(connection){
+        this.visibilityDidChange = this.visibilityDidChange.bind(this);
+        this.connection = connection;
+        this.reconnectAttempts = 0;
+    }
+}
+ConnectionMonitor.staleThreshold = 6; // Server::Connections::BEAT_INTERVAL * 2 (missed two pings)
+ConnectionMonitor.reconnectionBackoffRate = 0.15;
+/* export default */ const connection_monitor = (ConnectionMonitor);
+
+export default connection_monitor;

package/vendor/actioncable/consumer.js

@@ -0,0 +1,91 @@
+import { default as connection } from "./connection.js";
+import { Subscriptions } from "./subscriptions.js";
+
+
+
+class Consumer {
+    get url() {
+        // START PATCH: Modify existing url getter to return with initial connect param attached
+        const websocketUrl = createWebSocketURL(this._url);
+        return urlWithInitialConnectParam(websocketUrl, this.connection.hasConnectedBefore());
+    // END PATCH
+    }
+    send(data) {
+        return this.connection.send(data);
+    }
+    connect() {
+        return this.connection.open();
+    }
+    disconnect() {
+        return this.connection.close({
+            allowReconnect: false
+        });
+    }
+    ensureActiveConnection() {
+        if (!this.connection.isActive()) {
+            return this.connection.open();
+        }
+    }
+    constructor(url){
+        this._url = url;
+        this.subscriptions = new Subscriptions(this);
+        this.connection = new connection(this);
+    }
+}
+// The ActionCable.Consumer establishes the connection to a server-side Ruby Connection object. Once established,
+// the ActionCable.ConnectionMonitor will ensure that its properly maintained through heartbeats and checking for stale updates.
+// The Consumer instance is also the gateway to establishing subscriptions to desired channels through the #createSubscription
+// method.
+//
+// The following example shows how this can be set up:
+//
+//   App = {}
+//   App.cable = ActionCable.createConsumer("ws://example.com/accounts/1")
+//   App.appearance = App.cable.subscriptions.create("AppearanceChannel")
+//
+// For more details on how you'd configure an actual channel subscription, see ActionCable.Subscription.
+//
+// When a consumer is created, it automatically connects with the server.
+//
+// To disconnect from the server, call
+//
+//   App.cable.disconnect()
+//
+// and to restart the connection:
+//
+//   App.cable.connect()
+//
+// Any channel subscriptions which existed prior to disconnecting will
+// automatically resubscribe.
+
+function createWebSocketURL(url) {
+    if (typeof url === "function") {
+        url = url();
+    }
+    if (url && !/^wss?:/i.test(url)) {
+        const a = document.createElement("a");
+        a.href = url;
+        // Fix populating Location properties in IE. Otherwise, protocol will be blank.
+        a.href = a.href;
+        a.protocol = a.protocol.replace("http", "ws");
+        return a.href;
+    } else {
+        return url;
+    }
+}
+// START PATCH
+function urlWithInitialConnectParam(url, connectedBefore) {
+    let hasQueryParamsAlready;
+    try {
+        const urlObject = new URL(url);
+        hasQueryParamsAlready = Array.from(urlObject.searchParams.entries()).length > 0;
+    } catch (unused) {
+        hasQueryParamsAlready = false;
+    }
+    const initialConnectQueryParam = "ic=" + !connectedBefore;
+    return url + (hasQueryParamsAlready ? "&" + initialConnectQueryParam : "?" + initialConnectQueryParam);
+} // END PATCH
+
+var consumer_createWebSocketURL = /* unused export */ undefined;
+export { consumer_createWebSocketURL as createWebSocketURL };
+export default Consumer;

package/vendor/actioncable/index.js

@@ -0,0 +1,34 @@
+import { default as Consumer } from "./consumer.js";
+import { INTERNAL as internal } from "./internal.js";
+
+
+
+
+
+
+
+
+
+
+function createConsumer(url) {
+    if (url === void 0) url = getConfig("url") || internal.default_mount_path;
+    return new Consumer(url);
+}
+function getConfig(name) {
+    const element = document.head.querySelector("meta[name='action-cable-" + name + "']");
+    if (element) {
+        return element.getAttribute("content");
+    }
+}
+
+var actioncable_createWebSocketURL = /* unused export */ undefined;
+var actioncable_getConfig = /* unused export */ undefined;
+export { actioncable_createWebSocketURL as createWebSocketURL, actioncable_getConfig as getConfig, createConsumer };
+export { default as Connection } from "./connection.js";
+export { default as ConnectionMonitor } from "./connection_monitor.js";
+export { default as Consumer } from "./consumer.js";
+export { INTERNAL } from "./internal.js";
+export { Subscription } from "./subscription.js";
+export { Subscriptions } from "./subscriptions.js";
+export { default as adapters } from "./adapters.js";
+export { logger } from "./logger.js";

package/vendor/actioncable/internal.js

@@ -0,0 +1,22 @@
+/* export default */ const internal = ({
+    message_types: {
+        welcome: "welcome",
+        disconnect: "disconnect",
+        ping: "ping",
+        confirmation: "confirm_subscription",
+        rejection: "reject_subscription"
+    },
+    disconnect_reasons: {
+        unauthorized: "unauthorized",
+        invalid_request: "invalid_request",
+        server_restart: "server_restart"
+    },
+    default_mount_path: "/cable",
+    protocols: [
+        "actioncable-v1-json",
+        "actioncable-unsupported"
+    ]
+});
+
+export { internal as INTERNAL };
+export default internal;

package/vendor/actioncable/logger.js

@@ -0,0 +1,28 @@
+import { default as adapters } from "./adapters.js";
+
+
+// The logger is disabled by default. You can enable it with:
+//
+//   ActionCable.logger.enabled = true
+//
+//   Example:
+//
+//   import * as ActionCable from '@rails/actioncable'
+//
+//   ActionCable.logger.enabled = true
+//   ActionCable.logger.log('Connection Established.')
+//
+/* export default */ const logger = ({
+    log () {
+        for(var _len = arguments.length, messages = new Array(_len), _key = 0; _key < _len; _key++){
+            messages[_key] = arguments[_key];
+        }
+        if (this.enabled) {
+            messages.push(Date.now());
+            adapters.logger.log("[ActionCable]", ...messages);
+        }
+    }
+});
+
+export { logger };
+export default logger;

package/vendor/actioncable/subscription.js

@@ -0,0 +1,93 @@
+// A new subscription is created through the ActionCable.Subscriptions instance available on the consumer.
+// It provides a number of callbacks and a method for calling remote procedure calls on the corresponding
+// Channel instance on the server side.
+//
+// An example demonstrates the basic functionality:
+//
+//   App.appearance = App.cable.subscriptions.create("AppearanceChannel", {
+//     connected() {
+//       // Called once the subscription has been successfully completed
+//     },
+//
+//     disconnected({ willAttemptReconnect: boolean }) {
+//       // Called when the client has disconnected with the server.
+//       // The object will have an `willAttemptReconnect` property which
+//       // says whether the client has the intention of attempting
+//       // to reconnect.
+//     },
+//
+//     appear() {
+//       this.perform('appear', {appearing_on: this.appearingOn()})
+//     },
+//
+//     away() {
+//       this.perform('away')
+//     },
+//
+//     appearingOn() {
+//       $('main').data('appearing-on')
+//     }
+//   })
+//
+// The methods #appear and #away forward their intent to the remote AppearanceChannel instance on the server
+// by calling the `perform` method with the first parameter being the action (which maps to AppearanceChannel#appear/away).
+// The second parameter is a hash that'll get JSON encoded and made available on the server in the data parameter.
+//
+// This is how the server component would look:
+//
+//   class AppearanceChannel < ApplicationActionCable::Channel
+//     def subscribed
+//       current_user.appear
+//     end
+//
+//     def unsubscribed
+//       current_user.disappear
+//     end
+//
+//     def appear(data)
+//       current_user.appear on: data['appearing_on']
+//     end
+//
+//     def away
+//       current_user.away
+//     end
+//   end
+//
+// The "AppearanceChannel" name is automatically mapped between the client-side subscription creation and the server-side Ruby class name.
+// The AppearanceChannel#appear/away public methods are exposed automatically to client-side invocation through the perform method.
+const subscription_extend = function extend(object, properties) {
+    if (properties != null) {
+        for(let key in properties){
+            const value = properties[key];
+            object[key] = value;
+        }
+    }
+    return object;
+};
+class Subscription {
+    // Perform a channel action with the optional data passed as an attribute
+    perform(action, data) {
+        if (data === void 0) data = {};
+        data.action = action;
+        return this.send(data);
+    }
+    send(data) {
+        return this.consumer.send({
+            command: "message",
+            identifier: this.identifier,
+            data: JSON.stringify(data)
+        });
+    }
+    unsubscribe() {
+        return this.consumer.subscriptions.remove(this);
+    }
+    constructor(consumer, params = {}, mixin){
+        this.consumer = consumer;
+        this.identifier = JSON.stringify(params);
+        subscription_extend(this, mixin);
+    }
+}
+
+
+export { Subscription };
+export default Subscription;

package/vendor/actioncable/subscriptions.js

@@ -0,0 +1,89 @@
+import { Subscription } from "./subscription.js";
+
+
+class Subscriptions {
+    create(channelName, mixin) {
+        const channel = channelName;
+        const params = typeof channel === "object" ? channel : {
+            channel
+        };
+        const subscription = new Subscription(this.consumer, params, mixin);
+        return this.add(subscription);
+    }
+    // Private
+    add(subscription) {
+        this.subscriptions.push(subscription);
+        this.consumer.ensureActiveConnection();
+        this.notify(subscription, "initialized");
+        this.sendCommand(subscription, "subscribe");
+        return subscription;
+    }
+    remove(subscription) {
+        this.forget(subscription);
+        if (!this.findAll(subscription.identifier).length) {
+            this.sendCommand(subscription, "unsubscribe");
+        }
+        return subscription;
+    }
+    reject(identifier) {
+        return this.findAll(identifier).map((subscription)=>{
+            this.forget(subscription);
+            this.notify(subscription, "rejected");
+            return subscription;
+        });
+    }
+    forget(subscription) {
+        this.subscriptions = this.subscriptions.filter((s)=>s !== subscription);
+        return subscription;
+    }
+    findAll(identifier) {
+        return this.subscriptions.filter((s)=>s.identifier === identifier);
+    }
+    reload() {
+        return this.subscriptions.map((subscription)=>this.sendCommand(subscription, "subscribe"));
+    }
+    notifyAll(callbackName) {
+        for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+            args[_key - 1] = arguments[_key];
+        }
+        return this.subscriptions.map((subscription)=>this.notify(subscription, callbackName, ...args));
+    }
+    notify(subscription, callbackName) {
+        for(var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+            args[_key - 2] = arguments[_key];
+        }
+        let subscriptions;
+        if (typeof subscription === "string") {
+            subscriptions = this.findAll(subscription);
+        } else {
+            subscriptions = [
+                subscription
+            ];
+        }
+        return subscriptions.map((subscription)=>typeof subscription[callbackName] === "function" ? subscription[callbackName](...args) : undefined);
+    }
+    sendCommand(subscription, command) {
+        const { identifier } = subscription;
+        return this.consumer.send({
+            command,
+            identifier
+        });
+    }
+    constructor(consumer){
+        this.consumer = consumer;
+        this.subscriptions = [];
+    }
+}
+// Collection class for creating (and internally managing) channel subscriptions.
+// The only method intended to be triggered by the user is ActionCable.Subscriptions#create,
+// and it should be called through the consumer like so:
+//
+//   App = {}
+//   App.cable = ActionCable.createConsumer("ws://example.com/accounts/1")
+//   App.appearance = App.cable.subscriptions.create("AppearanceChannel")
+//
+// For more details on how you'd configure an actual channel subscription, see ActionCable.Subscription.
+
+
+export { Subscriptions };
+export default Subscriptions;

package/vendor/open-telemetry-idgenerator.js

@@ -0,0 +1,43 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ const SPAN_ID_BYTES = 8;
+const TRACE_ID_BYTES = 16;
+class RandomIdGenerator {
+    constructor(){
+        /**
+   * Returns a random 16-byte trace ID formatted/encoded as a 32 lowercase hex
+   * characters corresponding to 128 bits.
+   */ this.generateTraceId = getIdGenerator(TRACE_ID_BYTES);
+        /**
+   * Returns a random 8-byte span ID formatted/encoded as a 16 lowercase hex
+   * characters corresponding to 64 bits.
+   */ this.generateSpanId = getIdGenerator(SPAN_ID_BYTES);
+    }
+}
+const SHARED_CHAR_CODES_ARRAY = Array(32);
+function getIdGenerator(bytes) {
+    return function generateId() {
+        for(let i = 0; i < bytes * 2; i++){
+            SHARED_CHAR_CODES_ARRAY[i] = Math.floor(Math.random() * 16) + 48;
+            // valid hex characters in the range 48-57 and 97-102
+            if (SHARED_CHAR_CODES_ARRAY[i] >= 58) {
+                SHARED_CHAR_CODES_ARRAY[i] += 39;
+            }
+        }
+        return String.fromCharCode.apply(null, SHARED_CHAR_CODES_ARRAY.slice(0, bytes * 2));
+    };
+}
+
+export { RandomIdGenerator };

package/widget/analytics/facebook_tracker.js

@@ -0,0 +1,8 @@
+class FacebookTracker {
+    trackEvent(event) {
+        window.fbq == null ? void 0 : window.fbq.call(window, "trackCustom", event);
+    }
+}
+/* export default */ const facebook_tracker = (FacebookTracker);
+
+export default facebook_tracker;

package/widget/analytics/google_analytics_tracker.js

@@ -0,0 +1,83 @@
+class GoogleAnalyticsTracker {
+    trackEvent(name) {
+        var _this_tracker;
+        (_this_tracker = this.tracker) == null ? void 0 : _this_tracker.trackEvent("Qualified Chat", name);
+    }
+    constructor(propertyId){
+        try {
+            if (window._gat) {
+                // ga.js
+                this.tracker = new GaJsTracker(propertyId);
+            } else if (window.ga) {
+                // analytics.js
+                this.tracker = new AnalyticsJsTracker(propertyId);
+            } else if (window.gtag) {
+                // google tag manager or global site tag
+                // Note: if we're pushing events via gtag or gtm, the customer will need
+                // to configure tags or (gtm) set up products (gtag)
+                this.tracker = new GtagTracker(propertyId);
+            }
+        } catch (e) {
+            console.warn("Qualified: Error initializing Google Analytics", e); // eslint-disable-line no-console
+        }
+    }
+}
+class GaJsTracker {
+    trackEvent(category, name) {
+        var _this_tracker;
+        (_this_tracker = this.tracker) == null ? void 0 : _this_tracker._trackEvent(category, name);
+    }
+    constructor(propertyId){
+        // Create a tracker with the specified property ID, otherwise use the
+        // default tracker
+        if (propertyId) {
+            this.tracker = window._gat._getTracker(propertyId);
+        } else {
+            this.tracker = window.pageTracker;
+        }
+    }
+}
+class GtagTracker {
+    // eslint-disable-next-line camelcase
+    trackEvent(category, name) {
+        // eslint-disable-next-line camelcase
+        const options = {
+            event_category: category
+        };
+        if (this.propertyId) {
+            options.send_to = this.propertyId;
+        }
+        window.gtag == null ? void 0 : window.gtag.call(window, "event", name, options);
+    }
+    constructor(propertyId){
+        this.propertyId = propertyId;
+    }
+}
+class AnalyticsJsTracker {
+    trackEvent(category, action) {
+        this.initialized.then(()=>{
+            var _this_tracker;
+            (_this_tracker = this.tracker) == null ? void 0 : _this_tracker.send("event", category, action);
+        });
+    }
+    constructor(propertyId){
+        this.initialized = new Promise((resolve)=>{
+            window.ga(()=>{
+                // Create a named tracker with the specified property ID, otherwise use
+                // the default tracker
+                if (propertyId) {
+                    var _window_ga;
+                    window.ga == null ? void 0 : window.ga.call(window, "create", propertyId, "auto", "_qualifiedTracker");
+                    this.tracker = (_window_ga = window.ga) == null ? void 0 : _window_ga.getByName("_qualifiedTracker");
+                } else {
+                    var _window_ga1;
+                    this.tracker = (_window_ga1 = window.ga) == null ? void 0 : _window_ga1.getAll()[0];
+                }
+                resolve();
+            });
+        });
+    }
+}
+/* export default */ const google_analytics_tracker = (GoogleAnalyticsTracker);
+
+export default google_analytics_tracker;

package/widget/analytics/google_tag_manager_tracker.js

@@ -0,0 +1,22 @@
+class GoogleTagManagerTracker {
+    trackEvent(action) {
+        var _window_dataLayer;
+        (_window_dataLayer = window.dataLayer) == null ? void 0 : _window_dataLayer.push({
+            action,
+            category: "Qualified Chat",
+            event: "ga_event"
+        });
+    }
+    /**
+   * Push a full event object to dataLayer (e.g. for multimodal/Salesforce-style tracking).
+   */ trackSalesforceEvent(event) {
+        if (typeof window === "undefined") return;
+        if (!window.dataLayer) return;
+        window.dataLayer.push(event);
+    }
+}
+/* export default */ const google_tag_manager_tracker = (GoogleTagManagerTracker);
+
+var google_tag_manager_tracker_GoogleTagManagerTracker = /* unused export */ undefined;
+export { google_tag_manager_tracker_GoogleTagManagerTracker as GoogleTagManagerTracker };
+export default google_tag_manager_tracker;