avo-inspector 3.1.0-alpha.2 → 3.2.0

package/README.md

@@ -25,9 +25,9 @@ or
     yarn add avo-inspector
 ```
 
-# Lite Build (Production-Optimized)
+# Lite Build (Production Only)
 
-For size-sensitive deployments (GTM, script tags, etc.), use the lite entry point which excludes encryption and event spec validation — reducing the gzipped bundle from ~37 KB to ~7.5 KB:
+Available since version `3.1.0`. For production environments where bundle size matters (GTM, script tags, etc.), use the lite entry point which excludes encryption and event spec validation. Use the full build in dev/staging environments for the complete development experience:
 
 ```javascript
 import { AvoInspector, AvoInspectorEnv } from "avo-inspector/lite";
@@ -41,19 +41,12 @@ let inspector = new AvoInspector({
 
 The lite build has the same tracking API as the full version — `trackSchemaFromEvent`, `trackSchema`, and `extractSchema` all work identically. The differences:
 
-- No `publicEncryptionKey` constructor option (TypeScript will error if passed)
-- No event spec validation (dev/staging feature)
-- No property value encryption (dev/staging feature)
-- No stream ID generation/persistence (dev/staging debugger feature)
-- No event deduplication — **if you use both Avo Codegen and manual `trackSchemaFromEvent` calls for the same events, use the full build instead** to avoid sending duplicate schemas
+- Does not support [property value validation](https://www.avo.app/docs/inspector/inspector-debugger#enabling-advanced-debugger-features) in the [Inspector Debugger](https://www.avo.app/docs/inspector/inspector-debugger) (no `publicEncryptionKey` constructor option — TypeScript will error if passed)
+- Does not support [session filtering](https://www.avo.app/docs/inspector/inspector-debugger) in the Inspector Debugger (no stream ID generation/persistence)
+- Does not support event deduplication — **if you use both Avo Codegen and manual `trackSchemaFromEvent` calls for the same events, use the full build instead** to avoid sending duplicate schemas
 - Works universally with any bundler or minifier — no flags or configuration needed
 
-**Size comparison:**
-
-| | Minified | Gzipped |
-|---|---|---|
-| Full (`avo-inspector`) | 129 KB | 37 KB |
-| Lite (`avo-inspector/lite`) | 20 KB | 5.2 KB |
+**Lite build size:** ~20 KB minified, ~5.2 KB gzipped.
 
 See `examples/lite-size-demos/` for working examples with terser, webpack, and rollup.
 

package/dist/AvoBatcher.js

@@ -1,58 +1,61 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AvoBatcher = void 0;
-const AvoInspector_1 = require("./AvoInspector");
-class AvoBatcher {
-    constructor(networkCallsHandler) {
+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((savedEvents) => {
+            .then(function (savedEvents) {
             if (savedEvents !== null) {
-                const nonNullSavedEvents = savedEvents.filter((event) => event !== null);
-                this.events = this.events.concat(nonNullSavedEvents);
-                this.checkIfBatchNeedsToBeSent();
+                var nonNullSavedEvents = savedEvents.filter(function (event) { return event !== null; });
+                _this.events = _this.events.concat(nonNullSavedEvents);
+                _this.checkIfBatchNeedsToBeSent();
             }
         })
-            .catch((error) => {
-            console.error("Avo Inspector: error getting events from cache", error);
+            .catch(function (error) {
+            if (AvoInspector_1.AvoInspector.shouldLog) {
+                console.error("Avo Inspector: failed to load cached events.", error);
+            }
         });
     }
-    handleSessionStarted() {
-        this.events.push(this.networkCallsHandler.bodyForSessionStartedCall());
-        this.saveEvents();
-        this.checkIfBatchNeedsToBeSent();
-    }
-    handleTrackSchema(eventName, schema, eventId, eventHash, eventSpecMetadata) {
-        this.events.push(this.networkCallsHandler.bodyForEventSchemaCall(eventName, schema, eventId, eventHash, eventSpecMetadata));
-        this.saveEvents();
-        if (AvoInspector_1.AvoInspector.shouldLog) {
-            console.log("Avo Inspector: saved event " +
-                eventName +
-                " with schema " +
-                JSON.stringify(schema));
-        }
-        this.checkIfBatchNeedsToBeSent();
-    }
-    checkIfBatchNeedsToBeSent() {
-        const batchSize = this.events.length;
-        const now = Date.now();
-        const timeSinceLastFlushAttempt = now - this.batchFlushAttemptTimestamp;
-        const sendBySize = batchSize % AvoInspector_1.AvoInspector.batchSize == 0;
-        const sendByTime = timeSinceLastFlushAttempt >= AvoInspector_1.AvoInspector.batchFlushSeconds * 1000;
-        const avoBatcher = this;
+    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;
-            const sendingEvents = avoBatcher.events;
+            var sendingEvents_1 = avoBatcher.events;
             avoBatcher.events = [];
-            this.networkCallsHandler.callInspectorWithBatchBody(sendingEvents, function (error) {
+            this.networkCallsHandler.callInspectorWithBatchBody(sendingEvents_1, function (error) {
                 if (error != null) {
-                    avoBatcher.events = avoBatcher.events.concat(sendingEvents);
+                    avoBatcher.events = avoBatcher.events.concat(sendingEvents_1);
                     if (AvoInspector_1.AvoInspector.shouldLog) {
                         console.log("Avo Inspector: batch sending failed: " +
-                            error.message +
+                            error +
                             ". We will attempt to send your schemas with next batch");
                     }
                 }
@@ -64,16 +67,21 @@ class AvoBatcher {
                 avoBatcher.saveEvents();
             });
         }
-    }
-    saveEvents() {
+    };
+    AvoBatcher.prototype.saveEvents = function () {
         if (this.events.length > 1000) {
-            const extraElements = this.events.length - 1000;
+            var extraElements = this.events.length - 1000;
             this.events.splice(0, extraElements);
         }
         AvoInspector_1.AvoInspector.avoStorage.setItem(AvoBatcher.cacheKey, this.events);
-    }
-    static get cacheKey() {
-        return "AvoInspectorEvents";
-    }
-}
+    };
+    Object.defineProperty(AvoBatcher, "cacheKey", {
+        get: function () {
+            return "AvoInspectorEvents";
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AvoBatcher;
+}());
 exports.AvoBatcher = AvoBatcher;

package/dist/AvoDeduplicator.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AvoDeduplicator = void 0;
-const AvoSchemaParser_1 = require("./AvoSchemaParser");
-const utils_1 = require("./utils");
-class AvoDeduplicator {
-    constructor() {
+var AvoSchemaParser_1 = require("./AvoSchemaParser");
+var utils_1 = require("./utils");
+var AvoDeduplicator = /** @class */ (function () {
+    function AvoDeduplicator() {
         this.avoFunctionsEvents = {};
         this.manualEvents = {};
         this.avoFunctionsEventsParams = {};
         this.manualEventsParams = {};
     }
-    shouldRegisterEvent(eventName, params, fromAvoFunction) {
+    AvoDeduplicator.prototype.shouldRegisterEvent = function (eventName, params, fromAvoFunction) {
         this.clearOldEvents();
         if (fromAvoFunction) {
             this.avoFunctionsEvents[Date.now()] = eventName;
@@ -20,11 +20,11 @@ class AvoDeduplicator {
             this.manualEvents[Date.now()] = eventName;
             this.manualEventsParams[eventName] = params;
         }
-        const checkInAvoFunctions = !fromAvoFunction;
+        var checkInAvoFunctions = !fromAvoFunction;
         return !this.hasSameEventAs(eventName, params, checkInAvoFunctions);
-    }
-    hasSameEventAs(eventName, params, checkInAvoFunctions) {
-        let result = false;
+    };
+    AvoDeduplicator.prototype.hasSameEventAs = function (eventName, params, checkInAvoFunctions) {
+        var result = false;
         if (checkInAvoFunctions) {
             if (this.lookForEventIn(eventName, params, this.avoFunctionsEventsParams)) {
                 result = true;
@@ -40,12 +40,12 @@ class AvoDeduplicator {
             delete this.manualEventsParams[eventName];
         }
         return result;
-    }
-    lookForEventIn(eventName, params, eventsStorage) {
-        for (const otherEventName in eventsStorage) {
+    };
+    AvoDeduplicator.prototype.lookForEventIn = function (eventName, params, eventsStorage) {
+        for (var otherEventName in eventsStorage) {
             if (eventsStorage.hasOwnProperty(otherEventName)) {
                 if (otherEventName === eventName) {
-                    const otherParams = eventsStorage[eventName];
+                    var otherParams = eventsStorage[eventName];
                     if (otherParams && (0, utils_1.deepEquals)(params, otherParams)) {
                         return true;
                     }
@@ -53,9 +53,9 @@ class AvoDeduplicator {
             }
         }
         return false;
-    }
-    hasSeenEventParams(params, checkInAvoFunctions) {
-        let result = false;
+    };
+    AvoDeduplicator.prototype.hasSeenEventParams = function (params, checkInAvoFunctions) {
+        var result = false;
         if (checkInAvoFunctions) {
             if (this.lookForEventParamsIn(params, this.avoFunctionsEventsParams)) {
                 result = true;
@@ -67,37 +67,37 @@ class AvoDeduplicator {
             }
         }
         return result;
-    }
-    lookForEventParamsIn(params, eventsStorage) {
-        for (const otherEventName in eventsStorage) {
+    };
+    AvoDeduplicator.prototype.lookForEventParamsIn = function (params, eventsStorage) {
+        for (var otherEventName in eventsStorage) {
             if (eventsStorage.hasOwnProperty(otherEventName)) {
-                const otherParams = eventsStorage[otherEventName];
+                var otherParams = eventsStorage[otherEventName];
                 if (otherParams && (0, utils_1.deepEquals)(params, otherParams)) {
                     return true;
                 }
             }
         }
         return false;
-    }
-    async shouldRegisterSchemaFromManually(eventName, eventSchema) {
+    };
+    AvoDeduplicator.prototype.shouldRegisterSchemaFromManually = function (eventName, eventSchema) {
         this.clearOldEvents();
-        return !(await this.hasSameShapeInAvoFunctionsAs(eventName, eventSchema));
-    }
-    async hasSameShapeInAvoFunctionsAs(eventName, eventSchema) {
-        let result = false;
-        if (await this.lookForEventSchemaIn(eventName, eventSchema, this.avoFunctionsEventsParams)) {
+        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;
-    }
-    async lookForEventSchemaIn(eventName, eventSchema, eventsStorage) {
-        for (const otherEventName in eventsStorage) {
+    };
+    AvoDeduplicator.prototype.lookForEventSchemaIn = function (eventName, eventSchema, eventsStorage) {
+        for (var otherEventName in eventsStorage) {
             if (eventsStorage.hasOwnProperty(otherEventName)) {
                 if (otherEventName === eventName) {
-                    const otherSchema = await AvoSchemaParser_1.AvoSchemaParser.extractSchema(eventsStorage[eventName]);
+                    var otherSchema = AvoSchemaParser_1.AvoSchemaParser.extractSchema(eventsStorage[eventName]);
                     if (otherSchema && (0, utils_1.deepEquals)(eventSchema, otherSchema)) {
                         return true;
                     }
@@ -105,37 +105,38 @@ class AvoDeduplicator {
             }
         }
         return false;
-    }
-    clearOldEvents() {
-        const now = Date.now();
-        const msToConsiderOld = 300;
-        for (const time in this.avoFunctionsEvents) {
+    };
+    AvoDeduplicator.prototype.clearOldEvents = function () {
+        var now = Date.now();
+        var msToConsiderOld = 300;
+        for (var time in this.avoFunctionsEvents) {
             if (this.avoFunctionsEvents.hasOwnProperty(time)) {
-                const timestamp = Number(time) || 0;
+                var timestamp = Number(time) || 0;
                 if (now - timestamp > msToConsiderOld) {
-                    const eventName = this.avoFunctionsEvents[time];
+                    var eventName = this.avoFunctionsEvents[time];
                     delete this.avoFunctionsEvents[time];
                     delete this.avoFunctionsEventsParams[eventName];
                 }
             }
         }
-        for (const time in this.manualEvents) {
+        for (var time in this.manualEvents) {
             if (this.manualEvents.hasOwnProperty(time)) {
-                const timestamp = Number(time) || 0;
+                var timestamp = Number(time) || 0;
                 if (now - timestamp > msToConsiderOld) {
-                    const eventName = this.manualEvents[time];
+                    var eventName = this.manualEvents[time];
                     delete this.manualEvents[time];
                     delete this.manualEventsParams[eventName];
                 }
             }
         }
-    }
+    };
     // used in tests
-    _clearEvents() {
+    AvoDeduplicator.prototype._clearEvents = function () {
         this.avoFunctionsEvents = {};
         this.manualEvents = {};
         this.avoFunctionsEventsParams = {};
         this.manualEventsParams = {};
-    }
-}
+    };
+    return AvoDeduplicator;
+}());
 exports.AvoDeduplicator = AvoDeduplicator;