avo-inspector 3.2.0 → 3.2.3

package/dist/lite/AvoNetworkCallsHandlerLite.js

@@ -40,8 +40,75 @@ exports.AvoNetworkCallsHandler = exports.AvoNetworkCallsHandlerLite = void 0;
 // LITE COPY of src/AvoNetworkCallsHandler.ts — Sync: review src/AvoNetworkCallsHandler.ts changes for applicability here
 var AvoGuid_1 = require("../AvoGuid");
 var AvoInspectorLite_1 = require("./AvoInspectorLite");
+/**
+ * Normalizes a hint value: strings are trimmed; anything else (numbers,
+ * booleans, null, undefined, objects, arrays) is treated as absent.
+ */
+function normalizeHint(value) {
+    if (typeof value !== "string")
+        return undefined;
+    var trimmed = value.trim();
+    return trimmed === "" ? undefined : trimmed;
+}
+/**
+ * The only client that selects the v2 transport: the one the web GTM tag template
+ * writes to `window.inspector.__CLIENT__`. It is also the only `X-Avo-Client`
+ * value this SDK ever sends.
+ */
+var webGtmTemplateClient = "gtm-web";
+/**
+ * Normalizes the client, which is also what selects the transport. It returns
+ * "gtm-web" — v2 — only when the client is a string that is exactly "gtm-web"
+ * after trimming (a value copied out of a config keeps its trailing newline, so
+ * trimming keeps that attribution). Anything else — absent, blank, non-string,
+ * "web", another platform token, a different case — returns undefined: v1,
+ * exactly as 3.2.0 sent it. Every caller other than the web GTM tag template
+ * stays on v1.
+ *
+ * Returning only the constant also means no caller-supplied string ever becomes
+ * a request header, so an unusable value can never make setRequestHeader throw
+ * during synchronous request setup.
+ */
+function normalizeClient(client) {
+    return normalizeHint(client) === webGtmTemplateClient
+        ? webGtmTemplateClient
+        : undefined;
+}
+/**
+ * Whether a value can be sent as a request header as it is. Browsers throw from
+ * setRequestHeader for a value containing NUL, CR or LF, or any code point above
+ * U+00FF. Only v2 sends the api key and env as headers.
+ */
+function isHeaderValue(value) {
+    return (typeof value === "string" && !/[\u0000\n\r]|[^\u0000-\u00ff]/.test(value));
+}
+/**
+ * v2 only: after this many permanent failures in a row (a request the browser
+ * refuses to build, or a 4xx other than 408 and 429), the handler stops trying.
+ * For this instance's own events it stops sending for the rest of the page,
+ * while the batcher keeps queueing them, so a later page load can still deliver
+ * them. For events queued under another api key and env it drops that group,
+ * which is the only case where events are discarded: nothing on a later page can
+ * change the key they carry.
+ */
+var maxConsecutivePermanentFailures = 3;
 /** Bodies smaller than this are sent uncompressed — gzip overhead outweighs the gain. */
 var gzipMinBodyLength = 1024;
+/**
+ * Lowest timeout, in milliseconds, for every send in dev and staging: immediate
+ * (validated) sends and batches. A send that times out is retried, and a
+ * request that was slow but did reach the server would then be ingested twice,
+ * so outside prod the client waits longer for the answer instead of giving up at
+ * networkTimeout. A larger AvoInspector.networkTimeout still applies, and so
+ * does 0 (no timeout). Prod batches keep networkTimeout.
+ */
+var validatedSendMinTimeout = 10000;
+/** networkTimeout raised to validatedSendMinTimeout; 0 means no timeout for XMLHttpRequest, so it stays 0. */
+function nonProdSendTimeout() {
+    return AvoInspectorLite_1.AvoInspector.networkTimeout === 0
+        ? 0
+        : Math.max(AvoInspectorLite_1.AvoInspector.networkTimeout, validatedSendMinTimeout);
+}
 /**
  * Gzips a string body using the browser-native CompressionStream API.
  * Returns null if compression fails for any reason.
@@ -89,15 +156,58 @@ function gzip(body) {
     });
 }
 var AvoNetworkCallsHandlerLite = /** @class */ (function () {
-    function AvoNetworkCallsHandlerLite(apiKey, envName, appName, appVersion, libVersion) {
+    function AvoNetworkCallsHandlerLite(apiKey, envName, appName, appVersion, libVersion, client) {
         this.samplingRate = 1.0;
         this.sending = false;
+        /** v2 only: permanent failures in a row for this instance's own events. */
+        this.permanentFailures = 0;
+        /** v2 only: permanent failures in a row per other api key and env, keyed as the send groups are. */
+        this.foreignFailures = {};
+        /** v2 only: set at most once, when sending can no longer succeed on this page. */
+        this.sendingDisabled = false;
+        /** v2 only: set when the events themselves can never be sent, so queueing them would only grow the stored queue. */
+        this.queueingDisabled = false;
         this.apiKey = apiKey;
         this.envName = envName;
         this.appName = appName;
         this.appVersion = appVersion;
         this.libVersion = libVersion;
+        this.client = normalizeClient(client);
+        this.trackingEndpoint =
+            this.client === undefined
+                ? "https://api.avo.app/inspector/v1/track"
+                : "https://api.avo.app/inspector/v2/track";
+        // v2 sends the api key and env as headers. One the browser refuses would fail
+        // every send, so v2 stops before queueing anything instead of retrying.
+        if (this.client !== undefined &&
+            !(isHeaderValue(apiKey) && isHeaderValue(envName))) {
+            this.disableSending("the api key cannot be sent as a request header");
+            // Every event this instance builds would carry that key, so queueing is pointless too.
+            this.queueingDisabled = true;
+        }
     }
+    /**
+     * v2 only: true once sending has stopped for this page (see
+     * maxConsecutivePermanentFailures). Always false on v1.
+     */
+    AvoNetworkCallsHandlerLite.prototype.isSendingDisabled = function () {
+        return this.sendingDisabled;
+    };
+    /**
+     * v2 only: true when queueing events would only grow the stored queue, because
+     * they could never be sent under any configuration. Always false on v1.
+     */
+    AvoNetworkCallsHandlerLite.prototype.isQueueingDisabled = function () {
+        return this.queueingDisabled;
+    };
+    AvoNetworkCallsHandlerLite.prototype.disableSending = function (reason) {
+        this.sendingDisabled = true;
+        console.error("[Avo Inspector] Stopped sending events on this page: " + reason + ".");
+    };
+    /** True while a batch sent through callInspectorWithBatchBody awaits its response. */
+    AvoNetworkCallsHandlerLite.prototype.isBatchInFlight = function () {
+        return this.sending;
+    };
     AvoNetworkCallsHandlerLite.prototype.callInspectorWithBatchBody = function (inEvents, onCompleted) {
         var _this = this;
         if (this.sending) {
@@ -130,10 +240,16 @@ var AvoNetworkCallsHandlerLite = /** @class */ (function () {
             });
         }
         this.sending = true;
-        this.callInspectorApi(events, function (error) {
+        var timeout = this.envName === "prod" ? AvoInspectorLite_1.AvoInspector.networkTimeout : nonProdSendTimeout();
+        this.callInspectorApi(events, function (error, retryEvents) {
             _this.sending = false;
-            onCompleted(error);
-        });
+            if (retryEvents === undefined) {
+                onCompleted(error);
+            }
+            else {
+                onCompleted(error, retryEvents);
+            }
+        }, timeout);
     };
     AvoNetworkCallsHandlerLite.prototype.fixStreamIds = function (_events) {
         // No-op in lite build: streamId is a dev/staging debugger feature
@@ -143,7 +259,7 @@ var AvoNetworkCallsHandlerLite = /** @class */ (function () {
         sessionBody.type = "sessionStarted";
         return sessionBody;
     };
-    AvoNetworkCallsHandlerLite.prototype.bodyForEventSchemaCall = function (eventName, eventProperties, eventId, eventHash, eventSpecMetadata, validatedBranchId) {
+    AvoNetworkCallsHandlerLite.prototype.bodyForEventSchemaCall = function (eventName, eventProperties, eventId, eventHash, eventSpecMetadata, validatedBranchId, options) {
         var eventSchemaBody = this.createBaseCallBody();
         eventSchemaBody.type = "event";
         eventSchemaBody.eventName = eventName;
@@ -166,6 +282,26 @@ var AvoNetworkCallsHandlerLite = /** @class */ (function () {
         if (validatedBranchId) {
             eventSchemaBody.validatedBranchId = validatedBranchId;
         }
+        // Gateway options belong to the v2 transport. Without a client they are
+        // ignored entirely — the appVersion override included — so the body is
+        // exactly the one 3.2.0 built for the same call.
+        if (this.client !== undefined) {
+            var outputReference = normalizeHint(options === null || options === void 0 ? void 0 : options.outputReference);
+            var originHint = normalizeHint(options === null || options === void 0 ? void 0 : options.originHint);
+            var appVersion = normalizeHint(options === null || options === void 0 ? void 0 : options.appVersion);
+            if (outputReference !== undefined) {
+                eventSchemaBody.outputReference = outputReference;
+            }
+            if (originHint !== undefined) {
+                eventSchemaBody.originHint = originHint;
+                // An origin hint marks an event from another source, whose app version is
+                // unrelated to this SDK instance's configured version.
+                eventSchemaBody.appVersion = appVersion !== undefined ? appVersion : null;
+            }
+            else if (appVersion !== undefined) {
+                eventSchemaBody.appVersion = appVersion;
+            }
+        }
         return eventSchemaBody;
     };
     AvoNetworkCallsHandlerLite.prototype.createBaseCallBody = function () {
@@ -195,7 +331,7 @@ var AvoNetworkCallsHandlerLite = /** @class */ (function () {
             console.log("Avo Inspector: calling inspector immediately (with validation)", eventBody.eventName);
             console.log("Avo Inspector: event body", eventBody);
         }
-        this.callInspectorApi([eventBody], onCompleted);
+        this.callInspectorApi([eventBody], onCompleted, nonProdSendTimeout());
     };
     /**
      * Check if event should be dropped based on sampling rate.
@@ -211,36 +347,181 @@ var AvoNetworkCallsHandlerLite = /** @class */ (function () {
      * compression fails, the body is sent uncompressed exactly as before —
      * synchronously in the unavailable case, so legacy timing is preserved.
      */
-    AvoNetworkCallsHandlerLite.prototype.callInspectorApi = function (events, onCompleted) {
+    AvoNetworkCallsHandlerLite.prototype.callInspectorApi = function (events, onCompleted, timeout) {
+        var _this = this;
+        if (timeout === void 0) { timeout = AvoInspectorLite_1.AvoInspector.networkTimeout; }
+        if (this.client === undefined) {
+            this.sendEvents(events, this.apiKey, this.envName, timeout, function (error) {
+                onCompleted(error);
+            });
+            return;
+        }
+        // v2 takes the api key and env from the headers, for every event in the
+        // request, so each event is sent under the ones it was queued with. They
+        // differ from this instance's only for events persisted by an earlier page
+        // with another configuration — a GTM Preview load flushing a published
+        // container's queue, or the reverse. One request per pair, in order.
+        var groups = [];
+        var groupKeys = [];
+        events.forEach(function (event) {
+            var key = JSON.stringify([event.apiKey, event.env]);
+            var index = groupKeys.indexOf(key);
+            if (index === -1) {
+                index = groupKeys.push(key) - 1;
+                groups.push([]);
+            }
+            groups[index].push(event);
+        });
+        var retryEvents = [];
+        var firstError = null;
+        var sendGroup = function (index) {
+            if (index === groups.length) {
+                if (firstError === null) {
+                    onCompleted(null);
+                }
+                else {
+                    onCompleted(firstError, retryEvents);
+                }
+                return;
+            }
+            var group = groups[index];
+            var groupKey = groupKeys[index];
+            var apiKey = group[0].apiKey;
+            var env = group[0].env;
+            var own = apiKey === _this.apiKey && env === _this.envName;
+            var completed = function (error, permanent) {
+                if (error === null) {
+                    if (own) {
+                        _this.permanentFailures = 0;
+                    }
+                    else {
+                        delete _this.foreignFailures[groupKey];
+                    }
+                }
+                else {
+                    firstError = firstError || error;
+                    if (!permanent) {
+                        Array.prototype.push.apply(retryEvents, group);
+                    }
+                    else if (own) {
+                        // Kept: the api key and env are this page's, and a later page load —
+                        // or the server catching up on a key it has not seen yet — can still
+                        // deliver them. Sending stops, queueing does not.
+                        Array.prototype.push.apply(retryEvents, group);
+                        _this.permanentFailures += 1;
+                        if (!_this.sendingDisabled &&
+                            _this.permanentFailures >= maxConsecutivePermanentFailures) {
+                            _this.disableSending("the Avo Inspector API refused its events " +
+                                maxConsecutivePermanentFailures +
+                                " times in a row");
+                        }
+                    }
+                    else {
+                        // Queued under another api key and env, which a retry cannot change.
+                        // Retried a few times anyway, in case the refusal was about the
+                        // moment rather than the key, then dropped.
+                        var failures = (_this.foreignFailures[groupKey] || 0) + 1;
+                        _this.foreignFailures[groupKey] = failures;
+                        if (failures < maxConsecutivePermanentFailures) {
+                            Array.prototype.push.apply(retryEvents, group);
+                        }
+                    }
+                }
+                sendGroup(index + 1);
+            };
+            if (_this.sendingDisabled) {
+                completed(new Error("Sending events is stopped on this page"));
+            }
+            else if (!isHeaderValue(apiKey) || !isHeaderValue(env)) {
+                completed(new Error("Failed to send request: the api key or env cannot be sent as a request header"), true);
+            }
+            else {
+                _this.sendEvents(group, apiKey, env, timeout, completed);
+            }
+        };
+        sendGroup(0);
+    };
+    AvoNetworkCallsHandlerLite.prototype.sendEvents = function (events, apiKey, env, timeout, onCompleted) {
         var _this = this;
         var body = JSON.stringify(events);
         if (typeof CompressionStream === "undefined" ||
             body.length < gzipMinBodyLength) {
-            this.sendTrackingRequest(body, false, onCompleted);
+            this.sendTrackingRequest(body, false, apiKey, env, timeout, onCompleted);
             return;
         }
         gzip(body).then(function (compressed) {
             if (compressed !== null) {
-                _this.sendTrackingRequest(compressed, true, onCompleted);
+                _this.sendTrackingRequest(compressed, true, apiKey, env, timeout, onCompleted);
             }
             else {
-                _this.sendTrackingRequest(body, false, onCompleted);
+                _this.sendTrackingRequest(body, false, apiKey, env, timeout, onCompleted);
             }
         });
     };
-    AvoNetworkCallsHandlerLite.prototype.sendTrackingRequest = function (body, isGzipped, onCompleted) {
+    /**
+     * Reports a failure as permanent (second argument true) when retrying the same
+     * request cannot succeed: the browser refused to build it, or the API answered
+     * a 4xx other than 408 and 429.
+     */
+    AvoNetworkCallsHandlerLite.prototype.sendTrackingRequest = function (body, isGzipped, apiKey, env, timeout, onCompleted) {
         var _this = this;
-        var xmlhttp = new XMLHttpRequest();
-        xmlhttp.open("POST", AvoNetworkCallsHandlerLite.trackingEndpoint, true);
-        xmlhttp.setRequestHeader("Content-Type", "text/plain");
-        if (isGzipped) {
-            xmlhttp.setRequestHeader("Content-Encoding", "gzip");
+        // Everything from construction up to and including send() runs synchronously,
+        // and any of it can throw: a header value the browser rejects, or a send() the
+        // environment refuses. callInspectorWithBatchBody clears its `sending`
+        // re-entrancy guard only from onCompleted, so an exception escaping this method
+        // would latch the guard and silently cancel every later batch for the lifetime
+        // of the page. Reporting through onCompleted keeps that path recoverable — the
+        // batcher puts the events back and retries with the next batch.
+        //
+        // The XMLHttpRequest construction is inside the try for the same reason. What
+        // that buys is a precise guarantee, worth stating exactly: no synchronous XHR
+        // setup step can throw out of this method, on either the direct or the gzipped
+        // path. It is NOT a claim that the method never throws — onCompleted is the
+        // caller's own callback, typed to return any, and a throw from it propagates.
+        // That case is harmless here: callInspectorWithBatchBody clears `sending`
+        // before forwarding to its caller's callback, so a throwing callback cannot
+        // latch the guard; on the gzipped path it surfaces as an unhandled rejection.
+        // The event handlers below are assigned after the try deliberately — they run
+        // in a later task, which no try/catch here could cover.
+        var xmlhttp;
+        try {
+            xmlhttp = new XMLHttpRequest();
+            xmlhttp.open("POST", this.trackingEndpoint, true);
+            if (this.client === undefined) {
+                // v1, byte for byte the 3.2.0 request: the api key and env travel only in
+                // the body, and text/plain keeps an uncompressed send inside the CORS
+                // safelist, so it is not preflighted.
+                xmlhttp.setRequestHeader("Content-Type", "text/plain");
+            }
+            else {
+                // v2 reads the api key and env from headers (the body keeps carrying both,
+                // so one body shape serves every endpoint version) and attributes traffic
+                // by X-Avo-Client without decoding a body. None of the three is
+                // CORS-safelisted, so a browser preflights every v2 send — which is why the
+                // body is not `text/plain` here: that content type existed only to stay
+                // inside the safelist and dodge the preflight, a saving custom headers
+                // cancel out, and v2's body reader parses a text/plain body twice and throws.
+                xmlhttp.setRequestHeader("Content-Type", "application/json");
+                xmlhttp.setRequestHeader("api-key", apiKey);
+                xmlhttp.setRequestHeader("env", env);
+                xmlhttp.setRequestHeader("X-Avo-Client", this.client);
+            }
+            if (isGzipped) {
+                xmlhttp.setRequestHeader("Content-Encoding", "gzip");
+            }
+            xmlhttp.timeout = timeout;
+            xmlhttp.send(body);
+        }
+        catch (e) {
+            onCompleted(new Error("Failed to send request: ".concat(e instanceof Error ? e.message : String(e))), true);
+            return;
         }
-        xmlhttp.timeout = AvoInspectorLite_1.AvoInspector.networkTimeout;
-        xmlhttp.send(body);
         xmlhttp.onload = function () {
             if (xmlhttp.status !== 200) {
-                onCompleted(new Error("Error ".concat(xmlhttp.status, ": ").concat(xmlhttp.statusText)));
+                onCompleted(new Error("Error ".concat(xmlhttp.status, ": ").concat(xmlhttp.statusText)), xmlhttp.status >= 400 &&
+                    xmlhttp.status < 500 &&
+                    xmlhttp.status !== 408 &&
+                    xmlhttp.status !== 429);
             }
             else {
                 var response = void 0;
@@ -266,7 +547,6 @@ var AvoNetworkCallsHandlerLite = /** @class */ (function () {
             onCompleted(new Error("Request timed out"));
         };
     };
-    AvoNetworkCallsHandlerLite.trackingEndpoint = "https://api.avo.app/inspector/v1/track";
     return AvoNetworkCallsHandlerLite;
 }());
 exports.AvoNetworkCallsHandlerLite = AvoNetworkCallsHandlerLite;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "avo-inspector",
-  "version": "3.2.0",
+  "version": "3.2.3",
   "description": "",
   "main": "dist/index.js",
   "browser": "dist/index.js",
@@ -64,6 +64,15 @@
     "@noble/curves": "^1.4.0",
     "safe-regex2": "^5.0.0"
   },
+  "resolutions": {
+    "handlebars": "4.7.9",
+    "form-data": "4.0.6",
+    "serialize-javascript": "7.0.3",
+    "fast-uri": "3.1.2",
+    "flatted": "3.4.2",
+    "@babel/plugin-transform-modules-systemjs": "7.29.4",
+    "minimatch": "3.1.4"
+  },
   "devDependencies": {
     "@babel/core": "^7.25.2",
     "@babel/preset-env": "^7.25.3",

package/dist/AvoBatcher.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvoBatcher = void 0;
-var AvoInspector_1 = require("./AvoInspector");
-var AvoBatcher = /** @class */ (function () {
-    function AvoBatcher(networkCallsHandler) {
-        var _this = this;
-        this.events = [];
-        this.networkCallsHandler = networkCallsHandler;
-        this.batchFlushAttemptTimestamp = Date.now();
-        AvoInspector_1.AvoInspector.avoStorage
-            .getItemAsync(AvoBatcher.cacheKey)
-            .then(function (savedEvents) {
-            if (savedEvents !== null) {
-                var nonNullSavedEvents = savedEvents.filter(function (event) { return event !== null; });
-                _this.events = _this.events.concat(nonNullSavedEvents);
-                _this.checkIfBatchNeedsToBeSent();
-            }
-        })
-            .catch(function (error) {
-            if (AvoInspector_1.AvoInspector.shouldLog) {
-                console.error("Avo Inspector: failed to load cached events.", error);
-            }
-        });
-    }
-    AvoBatcher.prototype.handleTrackSchema = function (eventName, schema, eventId, eventHash, eventProps) {
-        var _this = this;
-        this.networkCallsHandler.bodyForEventSchemaCall(eventName, schema, eventId, eventHash, eventProps).then(function (eventBody) {
-            _this.events.push(eventBody);
-            _this.saveEvents();
-            if (AvoInspector_1.AvoInspector.shouldLog) {
-                console.log("Avo Inspector: saved event " +
-                    eventName +
-                    " with schema " +
-                    JSON.stringify(schema));
-            }
-            _this.checkIfBatchNeedsToBeSent();
-        }).catch(function (error) {
-            console.error("Avo Inspector: failed to prepare event body for " + eventName + ".", error);
-        });
-    };
-    AvoBatcher.prototype.checkIfBatchNeedsToBeSent = function () {
-        var batchSize = this.events.length;
-        var now = Date.now();
-        var timeSinceLastFlushAttempt = now - this.batchFlushAttemptTimestamp;
-        var sendBySize = batchSize % AvoInspector_1.AvoInspector.batchSize == 0;
-        var sendByTime = timeSinceLastFlushAttempt >= AvoInspector_1.AvoInspector.batchFlushSeconds * 1000;
-        var avoBatcher = this;
-        if (sendBySize || sendByTime) {
-            this.batchFlushAttemptTimestamp = now;
-            var sendingEvents_1 = avoBatcher.events;
-            avoBatcher.events = [];
-            this.networkCallsHandler.callInspectorWithBatchBody(sendingEvents_1, function (error) {
-                if (error != null) {
-                    avoBatcher.events = avoBatcher.events.concat(sendingEvents_1);
-                    if (AvoInspector_1.AvoInspector.shouldLog) {
-                        console.log("Avo Inspector: batch sending failed: " +
-                            error +
-                            ". We will attempt to send your schemas with next batch");
-                    }
-                }
-                else {
-                    if (AvoInspector_1.AvoInspector.shouldLog) {
-                        console.log("Avo Inspector: batch sent successfully.");
-                    }
-                }
-                avoBatcher.saveEvents();
-            });
-        }
-    };
-    AvoBatcher.prototype.saveEvents = function () {
-        if (this.events.length > 1000) {
-            var extraElements = this.events.length - 1000;
-            this.events.splice(0, extraElements);
-        }
-        AvoInspector_1.AvoInspector.avoStorage.setItem(AvoBatcher.cacheKey, this.events);
-    };
-    Object.defineProperty(AvoBatcher, "cacheKey", {
-        get: function () {
-            return "AvoInspectorEvents";
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return AvoBatcher;
-}());
-exports.AvoBatcher = AvoBatcher;

package/dist/AvoDeduplicator.js

@@ -1,142 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvoDeduplicator = void 0;
-var AvoSchemaParser_1 = require("./AvoSchemaParser");
-var utils_1 = require("./utils");
-var AvoDeduplicator = /** @class */ (function () {
-    function AvoDeduplicator() {
-        this.avoFunctionsEvents = {};
-        this.manualEvents = {};
-        this.avoFunctionsEventsParams = {};
-        this.manualEventsParams = {};
-    }
-    AvoDeduplicator.prototype.shouldRegisterEvent = function (eventName, params, fromAvoFunction) {
-        this.clearOldEvents();
-        if (fromAvoFunction) {
-            this.avoFunctionsEvents[Date.now()] = eventName;
-            this.avoFunctionsEventsParams[eventName] = params;
-        }
-        else {
-            this.manualEvents[Date.now()] = eventName;
-            this.manualEventsParams[eventName] = params;
-        }
-        var checkInAvoFunctions = !fromAvoFunction;
-        return !this.hasSameEventAs(eventName, params, checkInAvoFunctions);
-    };
-    AvoDeduplicator.prototype.hasSameEventAs = function (eventName, params, checkInAvoFunctions) {
-        var result = false;
-        if (checkInAvoFunctions) {
-            if (this.lookForEventIn(eventName, params, this.avoFunctionsEventsParams)) {
-                result = true;
-            }
-        }
-        else {
-            if (this.lookForEventIn(eventName, params, this.manualEventsParams)) {
-                result = true;
-            }
-        }
-        if (result) {
-            delete this.avoFunctionsEventsParams[eventName];
-            delete this.manualEventsParams[eventName];
-        }
-        return result;
-    };
-    AvoDeduplicator.prototype.lookForEventIn = function (eventName, params, eventsStorage) {
-        for (var otherEventName in eventsStorage) {
-            if (eventsStorage.hasOwnProperty(otherEventName)) {
-                if (otherEventName === eventName) {
-                    var otherParams = eventsStorage[eventName];
-                    if (otherParams && (0, utils_1.deepEquals)(params, otherParams)) {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    };
-    AvoDeduplicator.prototype.hasSeenEventParams = function (params, checkInAvoFunctions) {
-        var result = false;
-        if (checkInAvoFunctions) {
-            if (this.lookForEventParamsIn(params, this.avoFunctionsEventsParams)) {
-                result = true;
-            }
-        }
-        else {
-            if (this.lookForEventParamsIn(params, this.manualEventsParams)) {
-                result = true;
-            }
-        }
-        return result;
-    };
-    AvoDeduplicator.prototype.lookForEventParamsIn = function (params, eventsStorage) {
-        for (var otherEventName in eventsStorage) {
-            if (eventsStorage.hasOwnProperty(otherEventName)) {
-                var otherParams = eventsStorage[otherEventName];
-                if (otherParams && (0, utils_1.deepEquals)(params, otherParams)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    };
-    AvoDeduplicator.prototype.shouldRegisterSchemaFromManually = function (eventName, eventSchema) {
-        this.clearOldEvents();
-        return !this.hasSameShapeInAvoFunctionsAs(eventName, eventSchema);
-    };
-    AvoDeduplicator.prototype.hasSameShapeInAvoFunctionsAs = function (eventName, eventSchema) {
-        var result = false;
-        if (this.lookForEventSchemaIn(eventName, eventSchema, this.avoFunctionsEventsParams)) {
-            result = true;
-        }
-        if (result) {
-            delete this.avoFunctionsEventsParams[eventName];
-        }
-        return result;
-    };
-    AvoDeduplicator.prototype.lookForEventSchemaIn = function (eventName, eventSchema, eventsStorage) {
-        for (var otherEventName in eventsStorage) {
-            if (eventsStorage.hasOwnProperty(otherEventName)) {
-                if (otherEventName === eventName) {
-                    var otherSchema = AvoSchemaParser_1.AvoSchemaParser.extractSchema(eventsStorage[eventName]);
-                    if (otherSchema && (0, utils_1.deepEquals)(eventSchema, otherSchema)) {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    };
-    AvoDeduplicator.prototype.clearOldEvents = function () {
-        var now = Date.now();
-        var msToConsiderOld = 300;
-        for (var time in this.avoFunctionsEvents) {
-            if (this.avoFunctionsEvents.hasOwnProperty(time)) {
-                var timestamp = Number(time) || 0;
-                if (now - timestamp > msToConsiderOld) {
-                    var eventName = this.avoFunctionsEvents[time];
-                    delete this.avoFunctionsEvents[time];
-                    delete this.avoFunctionsEventsParams[eventName];
-                }
-            }
-        }
-        for (var time in this.manualEvents) {
-            if (this.manualEvents.hasOwnProperty(time)) {
-                var timestamp = Number(time) || 0;
-                if (now - timestamp > msToConsiderOld) {
-                    var eventName = this.manualEvents[time];
-                    delete this.manualEvents[time];
-                    delete this.manualEventsParams[eventName];
-                }
-            }
-        }
-    };
-    // used in tests
-    AvoDeduplicator.prototype._clearEvents = function () {
-        this.avoFunctionsEvents = {};
-        this.manualEvents = {};
-        this.avoFunctionsEventsParams = {};
-        this.manualEventsParams = {};
-    };
-    return AvoDeduplicator;
-}());
-exports.AvoDeduplicator = AvoDeduplicator;