@formo/analytics 1.20.0 → 1.21.0

package/dist/esm/src/lib/event/EventFactory.d.ts

@@ -16,16 +16,16 @@ declare class EventFactory implements IEventFactory {
      */
     private getPageProperties;
     private getEnrichedEvent;
-    generatePageEvent(category?: string, name?: string, properties?: IFormoEventProperties, context?: IFormoEventContext): IFormoEvent;
-    generateDetectWalletEvent(providerName: string, rdns: string, properties?: IFormoEventProperties, context?: IFormoEventContext): IFormoEvent;
-    generateIdentifyEvent(providerName: string, rdns: string, address: Nullable<Address>, userId?: Nullable<string>, properties?: IFormoEventProperties, context?: IFormoEventContext): IFormoEvent;
-    generateConnectEvent(chainId: ChainID, address: Address, properties?: IFormoEventProperties, context?: IFormoEventContext): IFormoEvent;
-    generateDisconnectEvent(chainId?: ChainID, address?: Address, properties?: IFormoEventProperties, context?: IFormoEventContext): IFormoEvent;
-    generateChainChangedEvent(chainId: ChainID, address: Address, properties?: IFormoEventProperties, context?: IFormoEventContext): IFormoEvent;
-    generateSignatureEvent(status: SignatureStatus, chainId: ChainID, address: Address, message: string, signatureHash?: string, properties?: IFormoEventProperties, context?: IFormoEventContext): IFormoEvent;
-    generateTransactionEvent(status: TransactionStatus, chainId: ChainID, address: Address, data: string, to: string, value: string, transactionHash?: string, properties?: IFormoEventProperties, context?: IFormoEventContext): IFormoEvent;
-    generateTrackEvent(event: string, properties?: IFormoEventProperties, context?: IFormoEventContext): IFormoEvent;
-    create(event: APIEvent, address?: Address, userId?: string): IFormoEvent;
+    generatePageEvent(category?: string, name?: string, properties?: IFormoEventProperties, context?: IFormoEventContext): Promise<IFormoEvent>;
+    generateDetectWalletEvent(providerName: string, rdns: string, properties?: IFormoEventProperties, context?: IFormoEventContext): Promise<IFormoEvent>;
+    generateIdentifyEvent(providerName: string, rdns: string, address: Nullable<Address>, userId?: Nullable<string>, properties?: IFormoEventProperties, context?: IFormoEventContext): Promise<IFormoEvent>;
+    generateConnectEvent(chainId: ChainID, address: Address, properties?: IFormoEventProperties, context?: IFormoEventContext): Promise<IFormoEvent>;
+    generateDisconnectEvent(chainId?: ChainID, address?: Address, properties?: IFormoEventProperties, context?: IFormoEventContext): Promise<IFormoEvent>;
+    generateChainChangedEvent(chainId: ChainID, address: Address, properties?: IFormoEventProperties, context?: IFormoEventContext): Promise<IFormoEvent>;
+    generateSignatureEvent(status: SignatureStatus, chainId: ChainID, address: Address, message: string, signatureHash?: string, properties?: IFormoEventProperties, context?: IFormoEventContext): Promise<IFormoEvent>;
+    generateTransactionEvent(status: TransactionStatus, chainId: ChainID, address: Address, data: string, to: string, value: string, transactionHash?: string, properties?: IFormoEventProperties, context?: IFormoEventContext): Promise<IFormoEvent>;
+    generateTrackEvent(event: string, properties?: IFormoEventProperties, context?: IFormoEventContext): Promise<IFormoEvent>;
+    create(event: APIEvent, address?: Address, userId?: string): Promise<IFormoEvent>;
 }
 export { EventFactory };
 //# sourceMappingURL=EventFactory.d.ts.map

package/dist/esm/src/lib/event/EventFactory.js

@@ -9,6 +9,42 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import { COUNTRY_LIST, LOCAL_ANONYMOUS_ID_KEY, SESSION_TRAFFIC_SOURCE_KEY, } from "../../constants";
 import { toChecksumAddress, toSnakeCase } from "../../utils";
 import { getValidAddress } from "../../utils/address";
@@ -20,6 +56,7 @@ import { session } from "../storage";
 import { version } from "../version";
 import { CHANNEL, VERSION } from "./constants";
 import { generateAnonymousId } from "./utils";
+import { detectBrowser } from "../browser/browsers";
 var EventFactory = /** @class */ (function () {
     function EventFactory() {
         var _this = this;
@@ -105,33 +142,6 @@ var EventFactory = /** @class */ (function () {
             }
             return pageProps;
         };
-        this.getEnrichedEvent = function (formoEvent, context) {
-            var commonEventData = {
-                context: _this.generateContext(context),
-                original_timestamp: getCurrentTimeFormatted(),
-                user_id: formoEvent.user_id,
-                type: formoEvent.type,
-                channel: CHANNEL,
-                version: VERSION,
-            };
-            commonEventData.anonymous_id = generateAnonymousId(LOCAL_ANONYMOUS_ID_KEY);
-            // Handle address - convert undefined to null for consistency
-            var validAddress = getValidAddress(formoEvent.address);
-            if (validAddress) {
-                commonEventData.address = toChecksumAddress(validAddress);
-            }
-            else {
-                commonEventData.address = null;
-            }
-            var processedEvent = mergeDeepRight(formoEvent, commonEventData);
-            if (processedEvent.event === undefined) {
-                processedEvent.event = null;
-            }
-            if (processedEvent.properties === undefined) {
-                processedEvent.properties = null;
-            }
-            return toSnakeCase(processedEvent);
-        };
     }
     EventFactory.prototype.getTimezone = function () {
         try {
@@ -170,140 +180,262 @@ var EventFactory = /** @class */ (function () {
     };
     // Contextual fields that are automatically collected and populated by the Formo SDK
     EventFactory.prototype.generateContext = function (context) {
-        var path = globalThis.location.pathname;
-        var language = this.getLanguage();
-        var timezone = this.getTimezone();
-        var location = this.getLocation();
-        var library_version = this.getLibraryVersion();
-        // contextual properties
-        var defaultContext = __assign(__assign({ user_agent: globalThis.navigator.userAgent, locale: language, timezone: timezone, location: location }, this.getTrafficSources(globalThis.location.href)), { page_path: path, page_title: document.title, page_url: globalThis.location.href, library_name: "Formo Web SDK", library_version: library_version });
-        var mergedContext = mergeDeepRight(defaultContext, context || {});
-        return mergedContext;
+        return __awaiter(this, void 0, void 0, function () {
+            var path, browserName, language, timezone, location, library_version, defaultContext, mergedContext;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        path = globalThis.location.pathname;
+                        return [4 /*yield*/, detectBrowser()];
+                    case 1:
+                        browserName = _a.sent();
+                        language = this.getLanguage();
+                        timezone = this.getTimezone();
+                        location = this.getLocation();
+                        library_version = this.getLibraryVersion();
+                        defaultContext = __assign(__assign({ user_agent: globalThis.navigator.userAgent, locale: language, timezone: timezone, location: location }, this.getTrafficSources(globalThis.location.href)), { page_path: path, page_title: document.title, page_url: globalThis.location.href, library_name: "Formo Web SDK", library_version: library_version, browser: browserName });
+                        mergedContext = mergeDeepRight(defaultContext, context || {});
+                        return [2 /*return*/, mergedContext];
+                }
+            });
+        });
+    };
+    EventFactory.prototype.getEnrichedEvent = function (formoEvent, context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var commonEventData, validAddress, processedEvent;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = {};
+                        return [4 /*yield*/, this.generateContext(context)];
+                    case 1:
+                        commonEventData = (_a.context = _b.sent(),
+                            _a.original_timestamp = getCurrentTimeFormatted(),
+                            _a.user_id = formoEvent.user_id,
+                            _a.type = formoEvent.type,
+                            _a.channel = CHANNEL,
+                            _a.version = VERSION,
+                            _a);
+                        commonEventData.anonymous_id = generateAnonymousId(LOCAL_ANONYMOUS_ID_KEY);
+                        validAddress = getValidAddress(formoEvent.address);
+                        if (validAddress) {
+                            commonEventData.address = toChecksumAddress(validAddress);
+                        }
+                        else {
+                            commonEventData.address = null;
+                        }
+                        processedEvent = mergeDeepRight(formoEvent, commonEventData);
+                        if (processedEvent.event === undefined) {
+                            processedEvent.event = null;
+                        }
+                        if (processedEvent.properties === undefined) {
+                            processedEvent.properties = null;
+                        }
+                        return [2 /*return*/, toSnakeCase(processedEvent)];
+                }
+            });
+        });
     };
     EventFactory.prototype.generatePageEvent = function (category, name, properties, context) {
-        var props = properties !== null && properties !== void 0 ? properties : {};
-        props.category = category;
-        props.name = name;
-        props = this.getPageProperties(props);
-        var pageEvent = {
-            properties: props,
-            type: "page",
-        };
-        return this.getEnrichedEvent(pageEvent, context);
+        return __awaiter(this, void 0, void 0, function () {
+            var props, pageEvent;
+            return __generator(this, function (_a) {
+                props = properties !== null && properties !== void 0 ? properties : {};
+                props.category = category;
+                props.name = name;
+                props = this.getPageProperties(props);
+                pageEvent = {
+                    properties: props,
+                    type: "page",
+                };
+                return [2 /*return*/, this.getEnrichedEvent(pageEvent, context)];
+            });
+        });
     };
     EventFactory.prototype.generateDetectWalletEvent = function (providerName, rdns, properties, context) {
-        var detectEvent = {
-            properties: __assign({ providerName: providerName, rdns: rdns }, properties),
-            type: "detect",
-        };
-        return this.getEnrichedEvent(detectEvent, context);
+        return __awaiter(this, void 0, void 0, function () {
+            var detectEvent;
+            return __generator(this, function (_a) {
+                detectEvent = {
+                    properties: __assign({ providerName: providerName, rdns: rdns }, properties),
+                    type: "detect",
+                };
+                return [2 /*return*/, this.getEnrichedEvent(detectEvent, context)];
+            });
+        });
     };
     EventFactory.prototype.generateIdentifyEvent = function (providerName, rdns, address, userId, properties, context) {
-        var identifyEvent = {
-            properties: __assign({ providerName: providerName, rdns: rdns }, properties),
-            user_id: userId,
-            address: address,
-            type: "identify",
-        };
-        return this.getEnrichedEvent(identifyEvent, context);
+        return __awaiter(this, void 0, void 0, function () {
+            var identifyEvent;
+            return __generator(this, function (_a) {
+                identifyEvent = {
+                    properties: __assign({ providerName: providerName, rdns: rdns }, properties),
+                    user_id: userId,
+                    address: address,
+                    type: "identify",
+                };
+                return [2 /*return*/, this.getEnrichedEvent(identifyEvent, context)];
+            });
+        });
     };
     EventFactory.prototype.generateConnectEvent = function (chainId, address, properties, context) {
-        var connectEvent = {
-            properties: __assign({ chainId: chainId }, properties),
-            address: address,
-            type: "connect",
-        };
-        return this.getEnrichedEvent(connectEvent, context);
+        return __awaiter(this, void 0, void 0, function () {
+            var connectEvent;
+            return __generator(this, function (_a) {
+                connectEvent = {
+                    properties: __assign({ chainId: chainId }, properties),
+                    address: address,
+                    type: "connect",
+                };
+                return [2 /*return*/, this.getEnrichedEvent(connectEvent, context)];
+            });
+        });
     };
     EventFactory.prototype.generateDisconnectEvent = function (chainId, address, properties, context) {
-        var disconnectEvent = {
-            properties: __assign({ chainId: chainId }, properties),
-            address: address,
-            type: "disconnect",
-        };
-        return this.getEnrichedEvent(disconnectEvent, context);
+        return __awaiter(this, void 0, void 0, function () {
+            var disconnectEvent;
+            return __generator(this, function (_a) {
+                disconnectEvent = {
+                    properties: __assign({ chainId: chainId }, properties),
+                    address: address,
+                    type: "disconnect",
+                };
+                return [2 /*return*/, this.getEnrichedEvent(disconnectEvent, context)];
+            });
+        });
     };
     EventFactory.prototype.generateChainChangedEvent = function (chainId, address, properties, context) {
-        var chainEvent = {
-            properties: __assign({ chainId: chainId }, properties),
-            address: address,
-            type: "chain",
-        };
-        return this.getEnrichedEvent(chainEvent, context);
+        return __awaiter(this, void 0, void 0, function () {
+            var chainEvent;
+            return __generator(this, function (_a) {
+                chainEvent = {
+                    properties: __assign({ chainId: chainId }, properties),
+                    address: address,
+                    type: "chain",
+                };
+                return [2 /*return*/, this.getEnrichedEvent(chainEvent, context)];
+            });
+        });
     };
     EventFactory.prototype.generateSignatureEvent = function (status, chainId, address, message, signatureHash, properties, context) {
-        var signatureEvent = {
-            properties: __assign(__assign({ status: status, chainId: chainId, message: message }, (signatureHash && { signatureHash: signatureHash })), properties),
-            address: address,
-            type: "signature",
-        };
-        return this.getEnrichedEvent(signatureEvent, context);
+        return __awaiter(this, void 0, void 0, function () {
+            var signatureEvent;
+            return __generator(this, function (_a) {
+                signatureEvent = {
+                    properties: __assign(__assign({ status: status, chainId: chainId, message: message }, (signatureHash && { signatureHash: signatureHash })), properties),
+                    address: address,
+                    type: "signature",
+                };
+                return [2 /*return*/, this.getEnrichedEvent(signatureEvent, context)];
+            });
+        });
     };
     EventFactory.prototype.generateTransactionEvent = function (status, chainId, address, data, to, value, transactionHash, properties, context) {
-        var transactionEvent = {
-            properties: __assign(__assign({ status: status, chainId: chainId, data: data, to: to, value: value }, (transactionHash && { transactionHash: transactionHash })), properties),
-            address: address,
-            type: "transaction",
-        };
-        return this.getEnrichedEvent(transactionEvent, context);
+        return __awaiter(this, void 0, void 0, function () {
+            var transactionEvent;
+            return __generator(this, function (_a) {
+                transactionEvent = {
+                    properties: __assign(__assign({ status: status, chainId: chainId, data: data, to: to, value: value }, (transactionHash && { transactionHash: transactionHash })), properties),
+                    address: address,
+                    type: "transaction",
+                };
+                return [2 /*return*/, this.getEnrichedEvent(transactionEvent, context)];
+            });
+        });
     };
     EventFactory.prototype.generateTrackEvent = function (event, properties, context) {
-        var trackEvent = {
-            properties: __assign(__assign(__assign(__assign({}, properties), ((properties === null || properties === void 0 ? void 0 : properties.revenue) !== undefined && {
-                revenue: Number(properties.revenue),
-                currency: (typeof (properties === null || properties === void 0 ? void 0 : properties.currency) === "string"
-                    ? properties.currency
-                    : "USD").toLowerCase(),
-            })), ((properties === null || properties === void 0 ? void 0 : properties.points) !== undefined && {
-                points: Number(properties.points),
-            })), ((properties === null || properties === void 0 ? void 0 : properties.volume) !== undefined && {
-                volume: Number(properties.volume),
-            })),
-            event: event,
-            type: "track",
-        };
-        return this.getEnrichedEvent(trackEvent, context);
+        return __awaiter(this, void 0, void 0, function () {
+            var trackEvent;
+            return __generator(this, function (_a) {
+                trackEvent = {
+                    properties: __assign(__assign(__assign(__assign({}, properties), ((properties === null || properties === void 0 ? void 0 : properties.revenue) !== undefined && {
+                        revenue: Number(properties.revenue),
+                        currency: (typeof (properties === null || properties === void 0 ? void 0 : properties.currency) === "string"
+                            ? properties.currency
+                            : "USD").toLowerCase(),
+                    })), ((properties === null || properties === void 0 ? void 0 : properties.points) !== undefined && {
+                        points: Number(properties.points),
+                    })), ((properties === null || properties === void 0 ? void 0 : properties.volume) !== undefined && {
+                        volume: Number(properties.volume),
+                    })),
+                    event: event,
+                    type: "track",
+                };
+                return [2 /*return*/, this.getEnrichedEvent(trackEvent, context)];
+            });
+        });
     };
     // Returns an event with type, context, properties, and common properties
     EventFactory.prototype.create = function (event, address, userId) {
-        var formoEvent = {};
-        switch (event.type) {
-            case "page":
-                formoEvent = this.generatePageEvent(event.category, event.name, event.properties, event.context);
-                break;
-            case "detect":
-                formoEvent = this.generateDetectWalletEvent(event.providerName, event.rdns, event.properties, event.context);
-                break;
-            case "identify":
-                formoEvent = this.generateIdentifyEvent(event.providerName, event.rdns, event.address, event.userId, event.properties, event.context);
-                break;
-            case "chain":
-                formoEvent = this.generateChainChangedEvent(event.chainId, event.address, event.properties, event.context);
-                break;
-            case "connect":
-                formoEvent = this.generateConnectEvent(event.chainId, event.address, event.properties, event.context);
-                break;
-            case "disconnect":
-                formoEvent = this.generateDisconnectEvent(event.chainId, event.address, event.properties, event.context);
-                break;
-            case "signature":
-                formoEvent = this.generateSignatureEvent(event.status, event.chainId, event.address, event.message, event.signatureHash, event.properties, event.context);
-                break;
-            case "transaction":
-                formoEvent = this.generateTransactionEvent(event.status, event.chainId, event.address, event.data, event.to, event.value, event.transactionHash, event.properties, event.context);
-                break;
-            case "track":
-            default:
-                formoEvent = this.generateTrackEvent(event.event, event.properties, event.context);
-                break;
-        }
-        // Set address if not already set by the specific event generator
-        if (formoEvent.address === undefined || formoEvent.address === null) {
-            var validAddress = getValidAddress(address);
-            formoEvent.address = validAddress ? toChecksumAddress(validAddress) : null;
-        }
-        formoEvent.user_id = userId || null;
-        return formoEvent;
+        return __awaiter(this, void 0, void 0, function () {
+            var formoEvent, _a, validAddress;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        formoEvent = {};
+                        _a = event.type;
+                        switch (_a) {
+                            case "page": return [3 /*break*/, 1];
+                            case "detect": return [3 /*break*/, 3];
+                            case "identify": return [3 /*break*/, 5];
+                            case "chain": return [3 /*break*/, 7];
+                            case "connect": return [3 /*break*/, 9];
+                            case "disconnect": return [3 /*break*/, 11];
+                            case "signature": return [3 /*break*/, 13];
+                            case "transaction": return [3 /*break*/, 15];
+                            case "track": return [3 /*break*/, 17];
+                        }
+                        return [3 /*break*/, 17];
+                    case 1: return [4 /*yield*/, this.generatePageEvent(event.category, event.name, event.properties, event.context)];
+                    case 2:
+                        formoEvent = _b.sent();
+                        return [3 /*break*/, 19];
+                    case 3: return [4 /*yield*/, this.generateDetectWalletEvent(event.providerName, event.rdns, event.properties, event.context)];
+                    case 4:
+                        formoEvent = _b.sent();
+                        return [3 /*break*/, 19];
+                    case 5: return [4 /*yield*/, this.generateIdentifyEvent(event.providerName, event.rdns, event.address, event.userId, event.properties, event.context)];
+                    case 6:
+                        formoEvent = _b.sent();
+                        return [3 /*break*/, 19];
+                    case 7: return [4 /*yield*/, this.generateChainChangedEvent(event.chainId, event.address, event.properties, event.context)];
+                    case 8:
+                        formoEvent = _b.sent();
+                        return [3 /*break*/, 19];
+                    case 9: return [4 /*yield*/, this.generateConnectEvent(event.chainId, event.address, event.properties, event.context)];
+                    case 10:
+                        formoEvent = _b.sent();
+                        return [3 /*break*/, 19];
+                    case 11: return [4 /*yield*/, this.generateDisconnectEvent(event.chainId, event.address, event.properties, event.context)];
+                    case 12:
+                        formoEvent = _b.sent();
+                        return [3 /*break*/, 19];
+                    case 13: return [4 /*yield*/, this.generateSignatureEvent(event.status, event.chainId, event.address, event.message, event.signatureHash, event.properties, event.context)];
+                    case 14:
+                        formoEvent = _b.sent();
+                        return [3 /*break*/, 19];
+                    case 15: return [4 /*yield*/, this.generateTransactionEvent(event.status, event.chainId, event.address, event.data, event.to, event.value, event.transactionHash, event.properties, event.context)];
+                    case 16:
+                        formoEvent = _b.sent();
+                        return [3 /*break*/, 19];
+                    case 17: return [4 /*yield*/, this.generateTrackEvent(event.event, event.properties, event.context)];
+                    case 18:
+                        formoEvent = _b.sent();
+                        return [3 /*break*/, 19];
+                    case 19:
+                        // Set address if not already set by the specific event generator
+                        if (formoEvent.address === undefined || formoEvent.address === null) {
+                            validAddress = getValidAddress(address);
+                            formoEvent.address = validAddress
+                                ? toChecksumAddress(validAddress)
+                                : null;
+                        }
+                        formoEvent.user_id = userId || null;
+                        return [2 /*return*/, formoEvent];
+                }
+            });
+        });
     };
     return EventFactory;
 }());

package/dist/esm/src/lib/event/EventManager.d.ts

@@ -16,7 +16,7 @@ declare class EventManager implements IEventManager {
      * Consumes a new incoming event
      * @param event Incoming event data
      */
-    addEvent(event: APIEvent, address?: Address, userId?: string): void;
+    addEvent(event: APIEvent, address?: Address, userId?: string): Promise<void>;
 }
 export { EventManager };
 //# sourceMappingURL=EventManager.d.ts.map

package/dist/esm/src/lib/event/EventManager.js

@@ -1,3 +1,39 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 var __rest = (this && this.__rest) || function (s, e) {
     var t = {};
     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -29,20 +65,31 @@ var EventManager = /** @class */ (function () {
      * @param event Incoming event data
      */
     EventManager.prototype.addEvent = function (event, address, userId) {
-        var callback = event.callback, _event = __rest(event, ["callback"]);
-        var formoEvent = this.eventFactory.create(_event, address, userId);
-        // Check if the final event has a blocked address - don't queue it
-        if (formoEvent.address && isBlockedAddress(formoEvent.address)) {
-            logger.warn("Event blocked: Address ".concat(formoEvent.address, " is in the blocked list and cannot emit events"));
-            return;
-        }
-        this.eventQueue.enqueue(formoEvent, function (err, _, data) {
-            if (err) {
-                logger.error("Error sending events:", err);
-            }
-            else
-                logger.info("Events sent successfully: ".concat(data.length, " events"));
-            callback === null || callback === void 0 ? void 0 : callback(err, _, data);
+        return __awaiter(this, void 0, void 0, function () {
+            var callback, _event, formoEvent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        callback = event.callback, _event = __rest(event, ["callback"]);
+                        return [4 /*yield*/, this.eventFactory.create(_event, address, userId)];
+                    case 1:
+                        formoEvent = _a.sent();
+                        // Check if the final event has a blocked address - don't queue it
+                        if (formoEvent.address && isBlockedAddress(formoEvent.address)) {
+                            logger.warn("Event blocked: Address ".concat(formoEvent.address, " is in the blocked list and cannot emit events"));
+                            return [2 /*return*/];
+                        }
+                        this.eventQueue.enqueue(formoEvent, function (err, _, data) {
+                            if (err) {
+                                logger.error("Error sending events:", err);
+                            }
+                            else
+                                logger.info("Events sent successfully: ".concat(data.length, " events"));
+                            callback === null || callback === void 0 ? void 0 : callback(err, _, data);
+                        });
+                        return [2 /*return*/];
+                }
+            });
         });
     };
     return EventManager;

package/dist/esm/src/lib/event/type.d.ts

@@ -1,8 +1,8 @@
 import { Address, APIEvent, IFormoEvent } from "../../types";
 export interface IEventManager {
-    addEvent(event: APIEvent, address?: Address, userId?: string): void;
+    addEvent(event: APIEvent, address?: Address, userId?: string): Promise<void>;
 }
 export interface IEventFactory {
-    create(event: APIEvent, address?: Address, userId?: string): IFormoEvent;
+    create(event: APIEvent, address?: Address, userId?: string): Promise<IFormoEvent>;
 }
 //# sourceMappingURL=type.d.ts.map