avo-inspector 1.4.1 → 1.4.2

package/dist-native/AvoDeduplicator.js

@@ -0,0 +1,142 @@
+"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;

package/dist-native/AvoGuid.d.ts

@@ -0,0 +1,3 @@
+export default class AvoGuid {
+    static newGuid(): string;
+}

package/dist-native/AvoGuid.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var AvoGuid = /** @class */ (function () {
+    function AvoGuid() {
+    }
+    AvoGuid.newGuid = function () {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+            var r = (Math.random() * 16) | 0, v = c == "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    };
+    return AvoGuid;
+}());
+exports.default = AvoGuid;

package/dist-native/AvoInspector.d.ts

@@ -0,0 +1,52 @@
+import { AvoInspectorEnvValueType } from "./AvoInspectorEnv";
+import { AvoSessionTracker } from "./AvoSessionTracker";
+import { AvoBatcher } from "./AvoBatcher";
+import { AvoStorage } from "./AvoStorage";
+import { AvoDeduplicator } from "./AvoDeduplicator";
+export declare class AvoInspector {
+    environment: AvoInspectorEnvValueType;
+    avoBatcher: AvoBatcher;
+    avoDeduplicator: AvoDeduplicator;
+    sessionTracker: AvoSessionTracker;
+    apiKey: string;
+    version: string;
+    static avoStorage: AvoStorage;
+    private static _batchSize;
+    static get batchSize(): number;
+    static set batchSize(newSize: number);
+    private static _batchFlushSeconds;
+    static get batchFlushSeconds(): number;
+    private static _shouldLog;
+    static get shouldLog(): boolean;
+    static set shouldLog(enable: boolean);
+    constructor(options: {
+        apiKey: string;
+        env: AvoInspectorEnvValueType;
+        version: string;
+        appName?: string;
+    });
+    trackSchemaFromEvent(eventName: string, eventProperties: {
+        [propName: string]: any;
+    }): Array<{
+        propertyName: string;
+        propertyType: string;
+        children?: any;
+    }>;
+    private _avoFunctionTrackSchemaFromEvent;
+    trackSchema(eventName: string, eventSchema: Array<{
+        propertyName: string;
+        propertyType: string;
+        children?: any;
+    }>): void;
+    private trackSchemaInternal;
+    enableLogging(enable: boolean): void;
+    extractSchema(eventProperties: {
+        [propName: string]: any;
+    }, shouldLogIfEnabled?: boolean): Array<{
+        propertyName: string;
+        propertyType: string;
+        children?: any;
+    }>;
+    setBatchSize(newBatchSize: number): void;
+    setBatchFlushSeconds(newBatchFlushSeconds: number): void;
+}

package/dist-native/AvoInspector.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvoInspector = void 0;
+var AvoInspectorEnv_1 = require("./AvoInspectorEnv");
+var AvoSchemaParser_1 = require("./AvoSchemaParser");
+var AvoSessionTracker_1 = require("./AvoSessionTracker");
+var AvoBatcher_1 = require("./AvoBatcher");
+var AvoNetworkCallsHandler_1 = require("./AvoNetworkCallsHandler");
+var AvoStorage_1 = require("./AvoStorage");
+var AvoDeduplicator_1 = require("./AvoDeduplicator");
+var utils_1 = require("./utils");
+var libVersion = require("../package.json").version;
+var AvoInspector = /** @class */ (function () {
+    // constructor(apiKey: string, env: AvoInspectorEnv, version: string) {
+    function AvoInspector(options) {
+        var _this = this;
+        // the constructor does aggressive null/undefined checking because same code paths will be accessible from JS
+        if ((0, utils_1.isValueEmpty)(options.env)) {
+            this.environment = AvoInspectorEnv_1.AvoInspectorEnv.Dev;
+            console.warn("[Avo Inspector] No environment provided. Defaulting to dev.");
+        }
+        else if (Object.values(AvoInspectorEnv_1.AvoInspectorEnv).indexOf(options.env) === -1) {
+            this.environment = AvoInspectorEnv_1.AvoInspectorEnv.Dev;
+            console.warn("[Avo Inspector] Unsupported environment provided. Defaulting to dev. Supported environments - Dev, Staging, Prod.");
+        }
+        else {
+            this.environment = options.env;
+        }
+        if ((0, utils_1.isValueEmpty)(options.apiKey)) {
+            throw new Error("[Avo Inspector] No API key provided. Inspector can't operate without API key.");
+        }
+        else {
+            this.apiKey = options.apiKey;
+        }
+        if ((0, utils_1.isValueEmpty)(options.version)) {
+            throw new Error("[Avo Inspector] No version provided. Many features of Inspector rely on versioning. Please provide comparable string version, i.e. integer or semantic.");
+        }
+        else {
+            this.version = options.version;
+        }
+        if (this.environment === AvoInspectorEnv_1.AvoInspectorEnv.Dev) {
+            AvoInspector._batchSize = 1;
+            AvoInspector._shouldLog = true;
+        }
+        else {
+            AvoInspector._batchSize = 30;
+            AvoInspector._batchFlushSeconds = 30;
+            AvoInspector._shouldLog = false;
+        }
+        AvoInspector.avoStorage = new AvoStorage_1.AvoStorage(AvoInspector._shouldLog);
+        var avoNetworkCallsHandler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler(this.apiKey, this.environment.toString(), options.appName || "", this.version, libVersion);
+        this.avoBatcher = new AvoBatcher_1.AvoBatcher(avoNetworkCallsHandler);
+        this.sessionTracker = new AvoSessionTracker_1.AvoSessionTracker(this.avoBatcher);
+        this.avoDeduplicator = new AvoDeduplicator_1.AvoDeduplicator();
+        try {
+            if (process.env.BROWSER) {
+                // XXX make node/browser split clearer
+                if (typeof window !== "undefined") {
+                    window.addEventListener("load", function () {
+                        _this.sessionTracker.startOrProlongSession(Date.now());
+                    }, false);
+                }
+            }
+            else {
+                this.sessionTracker.startOrProlongSession(Date.now());
+            }
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+        }
+    }
+    Object.defineProperty(AvoInspector, "batchSize", {
+        get: function () {
+            return this._batchSize;
+        },
+        set: function (newSize) {
+            if (newSize < 1) {
+                this._batchSize = 1;
+            }
+            else {
+                this._batchSize = newSize;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AvoInspector, "batchFlushSeconds", {
+        get: function () {
+            return this._batchFlushSeconds;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AvoInspector, "shouldLog", {
+        get: function () {
+            return this._shouldLog;
+        },
+        set: function (enable) {
+            this._shouldLog = enable;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AvoInspector.prototype.trackSchemaFromEvent = function (eventName, eventProperties) {
+        try {
+            if (this.avoDeduplicator.shouldRegisterEvent(eventName, eventProperties, false)) {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: supplied event " +
+                        eventName +
+                        " with params " +
+                        JSON.stringify(eventProperties));
+                }
+                var eventSchema = this.extractSchema(eventProperties, false);
+                this.trackSchemaInternal(eventName, eventSchema, null, null);
+                return eventSchema;
+            }
+            else {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: Deduplicated event: " + eventName);
+                }
+                return [];
+            }
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+            return [];
+        }
+    };
+    AvoInspector.prototype._avoFunctionTrackSchemaFromEvent = function (eventName, eventProperties, eventId, eventHash) {
+        try {
+            if (this.avoDeduplicator.shouldRegisterEvent(eventName, eventProperties, true)) {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: supplied event " +
+                        eventName +
+                        " with params " +
+                        JSON.stringify(eventProperties));
+                }
+                var eventSchema = this.extractSchema(eventProperties, false);
+                this.trackSchemaInternal(eventName, eventSchema, eventId, eventHash);
+                return eventSchema;
+            }
+            else {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: Deduplicated event: " + eventName);
+                }
+                return [];
+            }
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+            return [];
+        }
+    };
+    AvoInspector.prototype.trackSchema = function (eventName, eventSchema) {
+        try {
+            if (this.avoDeduplicator.shouldRegisterSchemaFromManually(eventName, eventSchema)) {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: supplied event " +
+                        eventName +
+                        " with schema " +
+                        JSON.stringify(eventSchema));
+                }
+                this.trackSchemaInternal(eventName, eventSchema, null, null);
+            }
+            else {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: Deduplicated event: " + eventName);
+                }
+            }
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+        }
+    };
+    AvoInspector.prototype.trackSchemaInternal = function (eventName, eventSchema, eventId, eventHash) {
+        try {
+            this.sessionTracker.startOrProlongSession(Date.now());
+            this.avoBatcher.handleTrackSchema(eventName, eventSchema, eventId, eventHash);
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+        }
+    };
+    AvoInspector.prototype.enableLogging = function (enable) {
+        AvoInspector._shouldLog = enable;
+    };
+    AvoInspector.prototype.extractSchema = function (eventProperties, shouldLogIfEnabled) {
+        if (shouldLogIfEnabled === void 0) { shouldLogIfEnabled = true; }
+        try {
+            this.sessionTracker.startOrProlongSession(Date.now());
+            if (this.avoDeduplicator.hasSeenEventParams(eventProperties, true)) {
+                if (shouldLogIfEnabled && AvoInspector.shouldLog) {
+                    console.warn("Avo Inspector: WARNING! You are trying to extract schema shape that was just reported by your Avo functions. " +
+                        "This is an indicator of duplicate inspector reporting. " +
+                        "Please reach out to support@avo.app for advice if you are not sure how to handle this.");
+                }
+            }
+            if (AvoInspector.shouldLog) {
+                console.log("Avo Inspector: extracting schema from " +
+                    JSON.stringify(eventProperties));
+            }
+            return AvoSchemaParser_1.AvoSchemaParser.extractSchema(eventProperties);
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+            return [];
+        }
+    };
+    AvoInspector.prototype.setBatchSize = function (newBatchSize) {
+        AvoInspector._batchSize = newBatchSize;
+    };
+    AvoInspector.prototype.setBatchFlushSeconds = function (newBatchFlushSeconds) {
+        AvoInspector._batchFlushSeconds = newBatchFlushSeconds;
+    };
+    AvoInspector._batchSize = 30;
+    AvoInspector._batchFlushSeconds = 30;
+    AvoInspector._shouldLog = false;
+    return AvoInspector;
+}());
+exports.AvoInspector = AvoInspector;

package/dist-native/AvoInspectorEnv.d.ts

@@ -0,0 +1,7 @@
+export declare const AvoInspectorEnv: {
+    readonly Prod: "prod";
+    readonly Dev: "dev";
+    readonly Staging: "staging";
+};
+export type AvoInspectorEnvType = typeof AvoInspectorEnv;
+export type AvoInspectorEnvValueType = AvoInspectorEnvType[keyof AvoInspectorEnvType];

package/dist-native/AvoInspectorEnv.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvoInspectorEnv = void 0;
+exports.AvoInspectorEnv = {
+    Prod: "prod",
+    Dev: "dev",
+    Staging: "staging",
+};

package/dist-native/AvoInstallationId.d.ts

@@ -0,0 +1,5 @@
+export declare class AvoInstallationId {
+    static installationId: null | string;
+    static getInstallationId(): string;
+    static get cacheKey(): string;
+}

package/dist-native/AvoInstallationId.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvoInstallationId = void 0;
+var AvoGuid_1 = require("./AvoGuid");
+var AvoInspector_1 = require("./AvoInspector");
+var AvoInstallationId = /** @class */ (function () {
+    function AvoInstallationId() {
+    }
+    AvoInstallationId.getInstallationId = function () {
+        if (AvoInstallationId.installationId !== null) {
+            return AvoInstallationId.installationId;
+        }
+        if (!AvoInspector_1.AvoInspector.avoStorage.isInitialized()) {
+            return "unknown";
+        }
+        var maybeInstallationId = AvoInspector_1.AvoInspector.avoStorage.getItem(AvoInstallationId.cacheKey);
+        if (maybeInstallationId === null || maybeInstallationId === undefined) {
+            AvoInstallationId.installationId = AvoGuid_1.default.newGuid();
+            AvoInspector_1.AvoInspector.avoStorage.setItem(AvoInstallationId.cacheKey, AvoInstallationId.installationId);
+        }
+        else {
+            AvoInstallationId.installationId = maybeInstallationId;
+        }
+        return AvoInstallationId.installationId;
+    };
+    Object.defineProperty(AvoInstallationId, "cacheKey", {
+        get: function () {
+            return "AvoInstallationId";
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AvoInstallationId.installationId = null;
+    return AvoInstallationId;
+}());
+exports.AvoInstallationId = AvoInstallationId;

package/dist-native/AvoNetworkCallsHandler.d.ts

@@ -0,0 +1,48 @@
+export interface BaseBody {
+    apiKey: string;
+    appName: string;
+    appVersion: string;
+    libVersion: string;
+    env: string;
+    libPlatform: "web";
+    messageId: string;
+    trackingId: string;
+    createdAt: string;
+    sessionId: string;
+    samplingRate: number;
+}
+export interface SessionStartedBody extends BaseBody {
+    type: "sessionStarted";
+}
+export interface EventSchemaBody extends BaseBody {
+    type: "event";
+    eventName: string;
+    eventProperties: Array<{
+        propertyName: string;
+        propertyType: string;
+        children?: any;
+    }>;
+    avoFunction: boolean;
+    eventId: string | null;
+    eventHash: string | null;
+}
+export declare class AvoNetworkCallsHandler {
+    private apiKey;
+    private envName;
+    private appName;
+    private appVersion;
+    private libVersion;
+    private samplingRate;
+    private sending;
+    private static trackingEndpoint;
+    constructor(apiKey: string, envName: string, appName: string, appVersion: string, libVersion: string);
+    callInspectorWithBatchBody(inEvents: Array<SessionStartedBody | EventSchemaBody>, onCompleted: (error: string | null) => any): void;
+    private fixSessionAndTrackingIds;
+    bodyForSessionStartedCall(): SessionStartedBody;
+    bodyForEventSchemaCall(eventName: string, eventProperties: Array<{
+        propertyName: string;
+        propertyType: string;
+        children?: any;
+    }>, eventId: string | null, eventHash: string | null): EventSchemaBody;
+    private createBaseCallBody;
+}

package/dist-native/AvoNetworkCallsHandler.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvoNetworkCallsHandler = void 0;
+var AvoGuid_1 = require("./AvoGuid");
+var AvoSessionTracker_1 = require("./AvoSessionTracker");
+var AvoInspector_1 = require("./AvoInspector");
+var AvoInstallationId_1 = require("./AvoInstallationId");
+var AvoNetworkCallsHandler = /** @class */ (function () {
+    function AvoNetworkCallsHandler(apiKey, envName, appName, appVersion, libVersion) {
+        this.samplingRate = 1.0;
+        this.sending = false;
+        this.apiKey = apiKey;
+        this.envName = envName;
+        this.appName = appName;
+        this.appVersion = appVersion;
+        this.libVersion = libVersion;
+    }
+    AvoNetworkCallsHandler.prototype.callInspectorWithBatchBody = function (inEvents, onCompleted) {
+        var _this = this;
+        if (this.sending) {
+            onCompleted("Batch sending cancelled because another batch sending is in progress. Your events will be sent with next batch.");
+            return;
+        }
+        var events = inEvents.filter(function (x) { return x != null; });
+        this.fixSessionAndTrackingIds(events);
+        if (events.length === 0) {
+            return;
+        }
+        if (Math.random() > this.samplingRate) {
+            if (AvoInspector_1.AvoInspector.shouldLog) {
+                console.log("Avo Inspector: last event schema dropped due to sampling rate.");
+            }
+            return;
+        }
+        if (AvoInspector_1.AvoInspector.shouldLog) {
+            console.log("Avo Inspector: events", events);
+            events.forEach(function (event) {
+                if (event.type === "sessionStarted") {
+                    console.log("Avo Inspector: sending session started event.");
+                }
+                else if (event.type === "event") {
+                    var schemaEvent = event;
+                    console.log("Avo Inspector: sending event " + schemaEvent.eventName + " with schema " + JSON.stringify(schemaEvent.eventProperties));
+                }
+            });
+        }
+        this.sending = true;
+        var xmlhttp = new XMLHttpRequest();
+        xmlhttp.open("POST", AvoNetworkCallsHandler.trackingEndpoint, true);
+        xmlhttp.setRequestHeader("Content-Type", "text/plain");
+        xmlhttp.send(JSON.stringify(events));
+        xmlhttp.onload = function () {
+            if (xmlhttp.status != 200) {
+                onCompleted("Error ".concat(xmlhttp.status, ": ").concat(xmlhttp.statusText));
+            }
+            else {
+                var samplingRate = JSON.parse(xmlhttp.response).samplingRate;
+                if (samplingRate !== undefined) {
+                    _this.samplingRate = samplingRate;
+                }
+                onCompleted(null);
+            }
+        };
+        xmlhttp.onerror = function () {
+            onCompleted("Request failed");
+        };
+        xmlhttp.ontimeout = function () {
+            onCompleted("Request timed out");
+        };
+        this.sending = false;
+    };
+    AvoNetworkCallsHandler.prototype.fixSessionAndTrackingIds = function (events) {
+        var knownSessionId = null;
+        var knownTrackingId = null;
+        events.forEach(function (event) {
+            if (event.sessionId !== null && event.sessionId !== undefined && event.sessionId !== "unknown") {
+                knownSessionId = event.sessionId;
+            }
+            if (event.trackingId !== null && event.trackingId !== undefined && event.trackingId !== "unknown") {
+                knownTrackingId = event.trackingId;
+            }
+        });
+        events.forEach(function (event) {
+            if (event.sessionId === "unknown") {
+                if (knownSessionId != null) {
+                    event.sessionId = knownSessionId;
+                }
+                else {
+                    event.sessionId = AvoSessionTracker_1.AvoSessionTracker.sessionId;
+                }
+            }
+            if (event.trackingId === "unknown") {
+                if (knownTrackingId != null) {
+                    event.trackingId = knownTrackingId;
+                }
+                else {
+                    event.trackingId = AvoInstallationId_1.AvoInstallationId.getInstallationId();
+                }
+            }
+        });
+    };
+    AvoNetworkCallsHandler.prototype.bodyForSessionStartedCall = function () {
+        var sessionBody = this.createBaseCallBody();
+        sessionBody.type = "sessionStarted";
+        return sessionBody;
+    };
+    AvoNetworkCallsHandler.prototype.bodyForEventSchemaCall = function (eventName, eventProperties, eventId, eventHash) {
+        var eventSchemaBody = this.createBaseCallBody();
+        eventSchemaBody.type = "event";
+        eventSchemaBody.eventName = eventName;
+        eventSchemaBody.eventProperties = eventProperties;
+        if (eventId != null) {
+            eventSchemaBody.avoFunction = true;
+            eventSchemaBody.eventId = eventId;
+            eventSchemaBody.eventHash = eventHash;
+        }
+        else {
+            eventSchemaBody.avoFunction = false;
+            eventSchemaBody.eventId = null;
+            eventSchemaBody.eventHash = null;
+        }
+        return eventSchemaBody;
+    };
+    AvoNetworkCallsHandler.prototype.createBaseCallBody = function () {
+        return {
+            apiKey: this.apiKey,
+            appName: this.appName,
+            appVersion: this.appVersion,
+            libVersion: this.libVersion,
+            env: this.envName,
+            libPlatform: "web",
+            messageId: AvoGuid_1.default.newGuid(),
+            trackingId: AvoInstallationId_1.AvoInstallationId.getInstallationId(),
+            createdAt: new Date().toISOString(),
+            sessionId: AvoSessionTracker_1.AvoSessionTracker.sessionId,
+            samplingRate: this.samplingRate,
+        };
+    };
+    AvoNetworkCallsHandler.trackingEndpoint = "https://api.avo.app/inspector/v1/track";
+    return AvoNetworkCallsHandler;
+}());
+exports.AvoNetworkCallsHandler = AvoNetworkCallsHandler;