clarity-decode 0.6.23

package/build/clarity.decode.module.js

@@ -0,0 +1,673 @@
+// tslint:disable: no-bitwise
+function hash (input) {
+    // Code inspired from C# GetHashCode: https://github.com/Microsoft/referencesource/blob/master/mscorlib/system/string.cs
+    var hash = 0;
+    var hashOne = 5381;
+    var hashTwo = hashOne;
+    for (var i = 0; i < input.length; i += 2) {
+        var charOne = input.charCodeAt(i);
+        hashOne = ((hashOne << 5) + hashOne) ^ charOne;
+        if (i + 1 < input.length) {
+            var charTwo = input.charCodeAt(i + 1);
+            hashTwo = ((hashTwo << 5) + hashTwo) ^ charTwo;
+        }
+    }
+    // Replace the magic number from C# implementation (1566083941) with a smaller prime number (11579)
+    // This ensures we don't hit integer overflow and prevent collisions
+    hash = Math.abs(hashOne + (hashTwo * 11579));
+    return hash.toString(36);
+}
+
+var version$1 = "0.6.23";
+
+function selector (tag, prefix, attributes, position) {
+    var suffix = position ? ":nth-of-type(" + position + ")" : "" /* Empty */;
+    switch (tag) {
+        case "STYLE":
+        case "TITLE":
+        case "LINK":
+        case "META":
+        case "*T" /* TextTag */:
+        case "*D" /* DocumentTag */:
+            return "" /* Empty */;
+        case "HTML":
+            return "HTML" /* HTML */;
+        default:
+            if (prefix === null) {
+                return "" /* Empty */;
+            }
+            tag = tag.indexOf("svg:" /* SvgPrefix */) === 0 ? tag.substr("svg:" /* SvgPrefix */.length) : tag;
+            var selector = "" + prefix + tag + suffix;
+            if ("class" /* Class */ in attributes && attributes["class" /* Class */].length > 0) {
+                selector = "" + prefix + tag + "." + attributes.class.trim().split(/\s+/).join(".") + suffix;
+            }
+            return selector;
+    }
+}
+
+var helper = { hash: hash, selector: selector };
+var version = version$1;
+
+function decode$5(tokens) {
+    var time = tokens[0];
+    var event = tokens[1];
+    switch (event) {
+        case 25 /* Ping */:
+            var ping = { gap: tokens[2] };
+            return { time: time, event: event, data: ping };
+        case 35 /* Limit */:
+            var limit = { check: tokens[2] };
+            return { time: time, event: event, data: limit };
+        case 24 /* Custom */:
+            var custom = { key: tokens[2], value: tokens[3] };
+            return { time: time, event: event, data: custom };
+        case 3 /* Upgrade */:
+            var upgrade = { key: tokens[2] };
+            return { time: time, event: event, data: upgrade };
+        case 2 /* Upload */:
+            var upload = { sequence: tokens[2], attempts: tokens[3], status: tokens[4] };
+            return { time: time, event: event, data: upload };
+        case 0 /* Metric */:
+            var m = 2; // Start from 3rd index since first two are used for time & event
+            var metrics = {};
+            while (m < tokens.length) {
+                metrics[tokens[m++]] = tokens[m++];
+            }
+            return { time: time, event: event, data: metrics };
+        case 1 /* Dimension */:
+            var d = 2; // Start from 3rd index since first two are used for time & event
+            var dimensions = {};
+            while (d < tokens.length) {
+                dimensions[tokens[d++]] = tokens[d++];
+            }
+            return { time: time, event: event, data: dimensions };
+        case 36 /* Summary */:
+            var s = 2; // Start from 3rd index since first two are used for time & event
+            var summary = {};
+            while (s < tokens.length) {
+                var key = tokens[s++];
+                var values = tokens[s++];
+                summary[key] = [];
+                for (var i = 0; i < values.length - 1; i += 2) {
+                    summary[key].push([values[i], values[i + 1]]);
+                }
+            }
+            return { time: time, event: event, data: summary };
+        case 4 /* Baseline */:
+            var baselineData = {
+                visible: tokens[2],
+                docWidth: tokens[3],
+                docHeight: tokens[4],
+                screenWidth: tokens[5],
+                screenHeight: tokens[6],
+                scrollX: tokens[7],
+                scrollY: tokens[8],
+                pointerX: tokens[9],
+                pointerY: tokens[10],
+                activityTime: tokens[11]
+            };
+            return { time: time, event: event, data: baselineData };
+        case 34 /* Variable */:
+            var v = 2; // Start from 3rd index since first two are used for time & event
+            var variables = {};
+            while (v < tokens.length) {
+                variables[tokens[v++]] = typeof tokens[v + 1] == "string" /* String */ ? [tokens[v++]] : tokens[v++];
+            }
+            return { time: time, event: event, data: variables };
+    }
+    return null;
+}
+function envelope(tokens) {
+    return {
+        version: tokens[0],
+        sequence: tokens[1],
+        start: tokens[2],
+        duration: tokens[3],
+        projectId: tokens[4],
+        userId: tokens[5],
+        sessionId: tokens[6],
+        pageNum: tokens[7],
+        upload: tokens[8],
+        end: tokens[9]
+    };
+}
+
+function decode$4(tokens) {
+    var time = tokens[0];
+    var event = tokens[1];
+    switch (event) {
+        case 32 /* ImageError */:
+            var imageError = {
+                source: tokens[2],
+                target: tokens[3],
+            };
+            return { time: time, event: event, data: imageError };
+        case 31 /* ScriptError */:
+            var scriptError = {
+                message: tokens[2],
+                line: tokens[3],
+                column: tokens[4],
+                stack: tokens[5],
+                source: tokens[6]
+            };
+            return { time: time, event: event, data: scriptError };
+        case 33 /* Log */:
+            var log = {
+                code: tokens[2],
+                name: tokens[3],
+                message: tokens[4],
+                stack: tokens[5],
+                severity: tokens[6]
+            };
+            return { time: time, event: event, data: log };
+    }
+    return null;
+}
+
+function decode$3(tokens) {
+    var time = tokens[0];
+    var event = tokens[1];
+    switch (event) {
+        case 13 /* MouseDown */:
+        case 14 /* MouseUp */:
+        case 12 /* MouseMove */:
+        case 15 /* MouseWheel */:
+        case 16 /* DoubleClick */:
+        case 17 /* TouchStart */:
+        case 20 /* TouchCancel */:
+        case 18 /* TouchEnd */:
+        case 19 /* TouchMove */:
+            var pointerData = {
+                target: tokens[2],
+                x: tokens[3],
+                y: tokens[4]
+            };
+            return { time: time, event: event, data: pointerData };
+        case 9 /* Click */:
+            var clickData = {
+                target: tokens[2],
+                x: tokens[3],
+                y: tokens[4],
+                eX: tokens[5],
+                eY: tokens[6],
+                button: tokens[7],
+                reaction: tokens[8],
+                context: tokens[9],
+                text: tokens[10],
+                link: tokens[11],
+                hash: tokens[12]
+            };
+            return { time: time, event: event, data: clickData };
+        case 11 /* Resize */:
+            var resizeData = { width: tokens[2], height: tokens[3] };
+            return { time: time, event: event, data: resizeData };
+        case 27 /* Input */:
+            var inputData = {
+                target: tokens[2],
+                value: tokens[3]
+            };
+            return { time: time, event: event, data: inputData };
+        case 21 /* Selection */:
+            var selectionData = {
+                start: tokens[2],
+                startOffset: tokens[3],
+                end: tokens[4],
+                endOffset: tokens[5]
+            };
+            return { time: time, event: event, data: selectionData };
+        case 10 /* Scroll */:
+            var scrollData = {
+                target: tokens[2],
+                x: tokens[3],
+                y: tokens[4]
+            };
+            return { time: time, event: event, data: scrollData };
+        case 22 /* Timeline */:
+            var timelineData = {
+                type: tokens[2],
+                hash: tokens[3],
+                x: tokens[4],
+                y: tokens[5],
+                reaction: tokens[6],
+                context: tokens[7]
+            };
+            return { time: time, event: event, data: timelineData };
+        case 28 /* Visibility */:
+            var visibleData = { visible: tokens[2] };
+            return { time: time, event: event, data: visibleData };
+        case 26 /* Unload */:
+            var unloadData = { name: tokens[2] };
+            return { time: time, event: event, data: unloadData };
+    }
+    return null;
+}
+
+var AverageWordLength = 6;
+var Space = " ";
+var hashes = {};
+function reset() {
+    hashes = {};
+}
+function decode$2(tokens) {
+    var time = tokens[0];
+    var event = tokens[1];
+    switch (event) {
+        case 8 /* Document */:
+            var documentData = { width: tokens[2], height: tokens[3] };
+            return { time: time, event: event, data: documentData };
+        case 7 /* Region */:
+            var regionData = [];
+            // From 0.6.15 we send each reach update in an individual event. This allows us to include time with it.
+            // To keep it backward compatible (<= 0.6.14), we look for multiple regions in the same event. This works both with newer and older payloads.
+            // In future, we can update the logic to look deterministically for only 3 fields and remove the for loop.
+            for (var i = 2; i < tokens.length; i += 3) {
+                var region = {
+                    id: tokens[i],
+                    state: tokens[i + 1],
+                    name: tokens[i + 2]
+                };
+                regionData.push(region);
+            }
+            return { time: time, event: event, data: regionData };
+        case 37 /* Box */:
+            var boxData = [];
+            for (var i = 2; i < tokens.length; i += 3) {
+                var box = {
+                    id: tokens[i],
+                    width: tokens[i + 1] / 100 /* BoxPrecision */,
+                    height: tokens[i + 2] / 100 /* BoxPrecision */
+                };
+                boxData.push(box);
+            }
+            return { time: time, event: event, data: boxData };
+        case 5 /* Discover */:
+        case 6 /* Mutation */:
+            var lastType = null;
+            var node = [];
+            var tagIndex = 0;
+            var domData = [];
+            for (var i = 2; i < tokens.length; i++) {
+                var token = tokens[i];
+                var type = typeof (token);
+                switch (type) {
+                    case "number":
+                        if (type !== lastType && lastType !== null) {
+                            domData.push(process(node, tagIndex));
+                            node = [];
+                            tagIndex = 0;
+                        }
+                        node.push(token);
+                        tagIndex++;
+                        break;
+                    case "string":
+                        node.push(token);
+                        break;
+                    case "object":
+                        var subtoken = token[0];
+                        var subtype = typeof (subtoken);
+                        switch (subtype) {
+                            case "number":
+                                for (var _i = 0, _a = token; _i < _a.length; _i++) {
+                                    var t = _a[_i];
+                                    node.push(tokens.length > t ? tokens[t] : null);
+                                }
+                                break;
+                        }
+                }
+                lastType = type;
+            }
+            // Process last node
+            domData.push(process(node, tagIndex));
+            return { time: time, event: event, data: domData };
+    }
+    return null;
+}
+function process(node, tagIndex) {
+    var _a = node[tagIndex] ? node[tagIndex].split("~") : [node[tagIndex]], tag = _a[0], position = _a[1];
+    var output = {
+        id: Math.abs(node[0]),
+        parent: tagIndex > 1 ? node[1] : null,
+        previous: tagIndex > 2 ? node[2] : null,
+        tag: tag,
+        position: position ? parseInt(position, 10) : null,
+        selector: null,
+        hash: null
+    };
+    var masked = node[0] < 0;
+    var hasAttribute = false;
+    var attributes = {};
+    var value = null;
+    var prefix = output.parent in hashes ? hashes[output.parent] + ">" : (output.parent ? "" /* Empty */ : null);
+    for (var i = tagIndex + 1; i < node.length; i++) {
+        // Explicitly convert the token into a string value
+        var token = node[i].toString();
+        var keyIndex = token.indexOf("=");
+        var firstChar = token[0];
+        var lastChar = token[token.length - 1];
+        if (i === (node.length - 1) && output.tag === "STYLE") {
+            value = token;
+        }
+        else if (output.tag !== "*T" /* TextTag */ && lastChar === ">" && keyIndex === -1) {
+            prefix = token;
+        }
+        else if (output.tag !== "*T" /* TextTag */ && firstChar === "#" /* Box */ && keyIndex === -1) {
+            var parts = token.substr(1).split("." /* Period */);
+            if (parts.length === 2) {
+                output.width = num(parts[0]) / 100 /* BoxPrecision */;
+                output.height = num(parts[1]) / 100 /* BoxPrecision */;
+            }
+        }
+        else if (output.tag !== "*T" /* TextTag */ && keyIndex > 0) {
+            hasAttribute = true;
+            var k = token.substr(0, keyIndex);
+            var v = token.substr(keyIndex + 1);
+            attributes[k] = v;
+        }
+        else if (output.tag === "*T" /* TextTag */) {
+            value = masked ? unmask(token) : token;
+        }
+    }
+    var selector = helper.selector(output.tag, prefix, attributes, output.position);
+    if (selector.length > 0) {
+        output.selector = selector;
+        output.hash = helper.hash(selector);
+        hashes[output.id] = selector;
+    }
+    if (hasAttribute) {
+        output.attributes = attributes;
+    }
+    if (value) {
+        output.value = value;
+    }
+    return output;
+}
+function num(input) {
+    return input ? parseInt(input, 36) : null;
+}
+function unmask(value) {
+    var trimmed = value.trim();
+    if (trimmed.length > 0 && trimmed.indexOf(Space) === -1) {
+        var length_1 = num(trimmed);
+        if (length_1 > 0) {
+            var quotient = Math.floor(length_1 / AverageWordLength);
+            var remainder = length_1 % AverageWordLength;
+            var output = Array(remainder + 1).join("\u2022" /* Mask */);
+            for (var i = 0; i < quotient; i++) {
+                output += (i === 0 && remainder === 0 ? "\u2022" /* Mask */ : Space) + Array(AverageWordLength).join("\u2022" /* Mask */);
+            }
+            return output;
+        }
+    }
+    return value;
+}
+
+function decode$1(tokens) {
+    var time = tokens[0];
+    var event = tokens[1];
+    switch (event) {
+        case 30 /* Connection */:
+            var connectionData = {
+                downlink: tokens[2],
+                rtt: tokens[3],
+                saveData: tokens[4],
+                type: tokens[5]
+            };
+            return { time: time, event: event, data: connectionData };
+        case 29 /* Navigation */:
+            var navigationData = {
+                fetchStart: tokens[2],
+                connectStart: tokens[3],
+                connectEnd: tokens[4],
+                requestStart: tokens[5],
+                responseStart: tokens[6],
+                responseEnd: tokens[7],
+                domInteractive: tokens[8],
+                domComplete: tokens[9],
+                loadEventStart: tokens[10],
+                loadEventEnd: tokens[11],
+                redirectCount: tokens[12],
+                size: tokens[13],
+                type: tokens[14],
+                protocol: tokens[15],
+                encodedSize: tokens[16],
+                decodedSize: tokens[17]
+            };
+            return { time: time, event: event, data: navigationData };
+    }
+    return null;
+}
+
+function decode(input) {
+    var json = JSON.parse(input);
+    var envelope$1 = envelope(json.e);
+    var timestamp = Date.now();
+    var payload = { timestamp: timestamp, envelope: envelope$1 };
+    // Sort encoded events by time to simplify summary computation
+    // It's possible for individual events to be out of order, dependent on how they are buffered on the client
+    // E.g. scroll events are queued internally before they are sent over the wire.
+    // By comparison, events like resize & click are sent out immediately.
+    var encoded = json.p ? json.a.concat(json.p) : json.a;
+    encoded = encoded.sort(function (a, b) { return a[0] - b[0]; });
+    // Check if the incoming version is compatible with the current running code
+    // We do an exact match for the major version and minor version.
+    // For patch, we are backward and forward compatible with up to version change.
+    var jsonVersion = parseVersion(payload.envelope.version);
+    var codeVersion = parseVersion(version);
+    if (jsonVersion.major !== codeVersion.major ||
+        Math.abs(jsonVersion.minor - codeVersion.minor) > 1) {
+        throw new Error("Invalid version. Actual: " + payload.envelope.version + " | Expected: " + version + " (+/- 1) | " + input.substr(0, 250));
+    }
+    /* Reset components before decoding to keep them stateless */
+    reset();
+    for (var _i = 0, encoded_1 = encoded; _i < encoded_1.length; _i++) {
+        var entry = encoded_1[_i];
+        switch (entry[1]) {
+            case 4 /* Baseline */:
+                if (payload.baseline === undefined) {
+                    payload.baseline = [];
+                }
+                payload.baseline.push(decode$5(entry));
+                break;
+            case 25 /* Ping */:
+                if (payload.ping === undefined) {
+                    payload.ping = [];
+                }
+                payload.ping.push(decode$5(entry));
+                break;
+            case 35 /* Limit */:
+                if (payload.limit === undefined) {
+                    payload.limit = [];
+                }
+                payload.limit.push(decode$5(entry));
+                break;
+            case 3 /* Upgrade */:
+                if (payload.upgrade === undefined) {
+                    payload.upgrade = [];
+                }
+                payload.upgrade.push(decode$5(entry));
+                break;
+            case 0 /* Metric */:
+                if (payload.metric === undefined) {
+                    payload.metric = [];
+                }
+                var metric = decode$5(entry);
+                // It's not possible to accurately include the byte count of the payload within the same payload
+                // The value we get from clarity-js lags behind by a payload. To work around that,
+                // we increment the bytes from the incoming payload at decode time.
+                metric.data[2 /* TotalBytes */] = input.length;
+                payload.metric.push(metric);
+                break;
+            case 1 /* Dimension */:
+                if (payload.dimension === undefined) {
+                    payload.dimension = [];
+                }
+                payload.dimension.push(decode$5(entry));
+                break;
+            case 36 /* Summary */:
+                if (payload.summary === undefined) {
+                    payload.summary = [];
+                }
+                payload.summary.push(decode$5(entry));
+                break;
+            case 24 /* Custom */:
+                if (payload.custom === undefined) {
+                    payload.custom = [];
+                }
+                payload.custom.push(decode$5(entry));
+                break;
+            case 34 /* Variable */:
+                if (payload.variable === undefined) {
+                    payload.variable = [];
+                }
+                payload.variable.push(decode$5(entry));
+                break;
+            case 2 /* Upload */:
+                if (payload.upload === undefined) {
+                    payload.upload = [];
+                }
+                payload.upload.push(decode$5(entry));
+                break;
+            case 13 /* MouseDown */:
+            case 14 /* MouseUp */:
+            case 12 /* MouseMove */:
+            case 15 /* MouseWheel */:
+            case 16 /* DoubleClick */:
+            case 17 /* TouchStart */:
+            case 20 /* TouchCancel */:
+            case 18 /* TouchEnd */:
+            case 19 /* TouchMove */:
+                if (payload.pointer === undefined) {
+                    payload.pointer = [];
+                }
+                payload.pointer.push(decode$3(entry));
+                break;
+            case 9 /* Click */:
+                if (payload.click === undefined) {
+                    payload.click = [];
+                }
+                var clickEntry = decode$3(entry);
+                payload.click.push(clickEntry);
+                break;
+            case 10 /* Scroll */:
+                if (payload.scroll === undefined) {
+                    payload.scroll = [];
+                }
+                payload.scroll.push(decode$3(entry));
+                break;
+            case 11 /* Resize */:
+                if (payload.resize === undefined) {
+                    payload.resize = [];
+                }
+                payload.resize.push(decode$3(entry));
+                break;
+            case 21 /* Selection */:
+                if (payload.selection === undefined) {
+                    payload.selection = [];
+                }
+                payload.selection.push(decode$3(entry));
+                break;
+            case 22 /* Timeline */:
+                if (payload.timeline === undefined) {
+                    payload.timeline = [];
+                }
+                payload.timeline.push(decode$3(entry));
+                break;
+            case 27 /* Input */:
+                if (payload.input === undefined) {
+                    payload.input = [];
+                }
+                payload.input.push(decode$3(entry));
+                break;
+            case 26 /* Unload */:
+                if (payload.unload === undefined) {
+                    payload.unload = [];
+                }
+                payload.unload.push(decode$3(entry));
+                break;
+            case 28 /* Visibility */:
+                if (payload.visibility === undefined) {
+                    payload.visibility = [];
+                }
+                payload.visibility.push(decode$3(entry));
+                break;
+            case 37 /* Box */:
+                if (payload.box === undefined) {
+                    payload.box = [];
+                }
+                payload.box.push(decode$2(entry));
+                break;
+            case 7 /* Region */:
+                if (payload.region === undefined) {
+                    payload.region = [];
+                }
+                payload.region.push(decode$2(entry));
+                break;
+            case 5 /* Discover */:
+            case 6 /* Mutation */:
+                if (payload.dom === undefined) {
+                    payload.dom = [];
+                }
+                payload.dom.push(decode$2(entry));
+                break;
+            case 8 /* Document */:
+                if (payload.doc === undefined) {
+                    payload.doc = [];
+                }
+                payload.doc.push(decode$2(entry));
+                break;
+            case 31 /* ScriptError */:
+                if (payload.script === undefined) {
+                    payload.script = [];
+                }
+                payload.script.push(decode$4(entry));
+                break;
+            case 32 /* ImageError */:
+                if (payload.image === undefined) {
+                    payload.image = [];
+                }
+                payload.image.push(decode$4(entry));
+                break;
+            case 33 /* Log */:
+                if (payload.log === undefined) {
+                    payload.log = [];
+                }
+                payload.log.push(decode$4(entry));
+                break;
+            case 30 /* Connection */:
+                if (payload.connection === undefined) {
+                    payload.connection = [];
+                }
+                payload.connection.push(decode$1(entry));
+                break;
+            case 29 /* Navigation */:
+                if (payload.navigation === undefined) {
+                    payload.navigation = [];
+                }
+                payload.navigation.push(decode$1(entry));
+                break;
+            default:
+                console.error("No handler for Event: " + JSON.stringify(entry));
+                break;
+        }
+    }
+    return payload;
+}
+function parseVersion(ver) {
+    var output = { major: 0, minor: 0, patch: 0, beta: 0 };
+    var parts = ver.split(".");
+    if (parts.length === 3) {
+        var subparts = parts[2].split("-b");
+        output.major = parseInt(parts[0], 10);
+        output.minor = parseInt(parts[1], 10);
+        if (subparts.length === 2) {
+            output.patch = parseInt(subparts[0], 10);
+            output.beta = parseInt(subparts[1], 10);
+        }
+        else {
+            output.patch = parseInt(parts[2], 10);
+        }
+    }
+    return output;
+}
+
+export { decode };