@formo/analytics 1.21.0 → 1.23.0

package/dist/cjs/src/FormoAnalytics.d.ts

@@ -224,6 +224,12 @@ export declare class FormoAnalytics implements IFormoAnalytics {
      * @returns {boolean} True if tracking should be enabled
      */
     private shouldTrack;
+    /**
+     * Check if a specific wallet event type is enabled for autocapture
+     * @param eventType The wallet event type to check
+     * @returns {boolean} True if the event type should be autocaptured
+     */
+    private isAutocaptureEnabled;
     /**
      * Get provider information for a given provider
      * @param provider The provider to get info for

package/dist/cjs/src/FormoAnalytics.js

@@ -114,13 +114,14 @@ var FormoAnalytics = /** @class */ (function () {
         this.transaction = this.transaction.bind(this);
         this.detect = this.detect.bind(this);
         this.track = this.track.bind(this);
+        this.isAutocaptureEnabled = this.isAutocaptureEnabled.bind(this);
         // Initialize logger with configuration from options
         lib_1.Logger.init({
             enabled: ((_a = options.logger) === null || _a === void 0 ? void 0 : _a.enabled) || false,
             enabledLevels: ((_b = options.logger) === null || _b === void 0 ? void 0 : _b.levels) || [],
         });
         this.eventManager = new lib_1.EventManager(new lib_1.EventQueue(this.config.writeKey, {
-            url: constants_1.EVENTS_API_URL,
+            apiHost: options.apiHost || constants_1.EVENTS_API_HOST,
             flushAt: options.flushAt,
             retryCount: options.retryCount,
             maxQueueSize: options.maxQueueSize,
@@ -623,12 +624,26 @@ var FormoAnalytics = /** @class */ (function () {
                 lib_1.logger.warn("TrackProvider: Provider already tracked.");
                 return;
             }
-            // Register listeners for this provider first
+            // CRITICAL: Always register accountsChanged for state management
+            // This ensures currentAddress, currentChainId, and _provider are always up-to-date
+            // Event emission is controlled conditionally inside the handlers
             this.registerAccountsChangedListener(provider);
-            this.registerChainChangedListener(provider);
-            this.registerConnectListener(provider);
-            this.registerRequestListeners(provider);
-            this.registerDisconnectListener(provider);
+            // Register other listeners based on autocapture configuration
+            if (this.isAutocaptureEnabled("chain")) {
+                this.registerChainChangedListener(provider);
+            }
+            if (this.isAutocaptureEnabled("connect")) {
+                this.registerConnectListener(provider);
+            }
+            if (this.isAutocaptureEnabled("signature") || this.isAutocaptureEnabled("transaction")) {
+                this.registerRequestListeners(provider);
+            }
+            else {
+                lib_1.logger.debug("TrackProvider: Skipping request wrapping (both signature and transaction autocapture disabled)");
+            }
+            if (this.isAutocaptureEnabled("disconnect")) {
+                this.registerDisconnectListener(provider);
+            }
             // Only add to tracked providers after all listeners are successfully registered
             this._trackedProviders.add(provider);
         }
@@ -713,13 +728,14 @@ var FormoAnalytics = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (!(accounts.length === 0)) return [3 /*break*/, 7];
-                        if (!(this._provider === provider)) return [3 /*break*/, 5];
+                        if (!(accounts.length === 0)) return [3 /*break*/, 9];
+                        if (!(this._provider === provider)) return [3 /*break*/, 7];
                         lib_1.logger.info("OnAccountsChanged: Detecting disconnect, current state:", {
                             currentAddress: this.currentAddress,
                             currentChainId: this.currentChainId,
                             providerMatch: this._provider === provider,
                         });
+                        if (!this.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 5];
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 3, , 4]);
@@ -738,16 +754,24 @@ var FormoAnalytics = /** @class */ (function () {
                         return [3 /*break*/, 4];
                     case 4: return [3 /*break*/, 6];
                     case 5:
-                        lib_1.logger.info("OnAccountsChanged: Ignoring disconnect for non-active provider");
+                        lib_1.logger.debug("OnAccountsChanged: Disconnect event skipped (autocapture.disconnect: false)");
+                        // Still clear state even if not tracking the event
+                        this.currentAddress = undefined;
+                        this.currentChainId = undefined;
+                        this.clearActiveProvider();
                         _a.label = 6;
-                    case 6: return [2 /*return*/];
+                    case 6: return [3 /*break*/, 8];
                     case 7:
+                        lib_1.logger.info("OnAccountsChanged: Ignoring disconnect for non-active provider");
+                        _a.label = 8;
+                    case 8: return [2 /*return*/];
+                    case 9:
                         address = this.validateAndChecksumAddress(accounts[0]);
                         if (!address) {
                             lib_1.logger.warn("onAccountsChanged: Invalid address received", accounts[0]);
                             return [2 /*return*/];
                         }
-                        if (!(this._provider && this._provider !== provider)) return [3 /*break*/, 18];
+                        if (!(this._provider && this._provider !== provider)) return [3 /*break*/, 26];
                         currentStoredAddress = this.currentAddress;
                         newProviderAddress = this.validateAndChecksumAddress(address);
                         lib_1.logger.info("OnAccountsChanged: Different provider attempting to connect", {
@@ -756,11 +780,11 @@ var FormoAnalytics = /** @class */ (function () {
                             currentStoredAddress: currentStoredAddress,
                             newProviderAddress: newProviderAddress,
                         });
-                        _a.label = 8;
-                    case 8:
-                        _a.trys.push([8, 16, , 18]);
+                        _a.label = 10;
+                    case 10:
+                        _a.trys.push([10, 22, , 26]);
                         return [4 /*yield*/, this.getAccounts(this._provider)];
-                    case 9:
+                    case 11:
                         activeProviderAccounts = _a.sent();
                         lib_1.logger.info("OnAccountsChanged: Checking current provider accounts", {
                             activeProvider: this.getProviderInfo(this._provider).name,
@@ -769,10 +793,10 @@ var FormoAnalytics = /** @class */ (function () {
                                 : 0,
                             accounts: activeProviderAccounts,
                         });
-                        if (!(activeProviderAccounts && activeProviderAccounts.length > 0)) return [3 /*break*/, 13];
+                        if (!(activeProviderAccounts && activeProviderAccounts.length > 0)) return [3 /*break*/, 17];
                         if (!(newProviderAddress &&
                             currentStoredAddress &&
-                            newProviderAddress !== currentStoredAddress)) return [3 /*break*/, 11];
+                            newProviderAddress !== currentStoredAddress)) return [3 /*break*/, 15];
                         lib_1.logger.info("OnAccountsChanged: Different address detected, switching providers despite current provider having accounts", {
                             activeProvider: this.getProviderInfo(this._provider).name,
                             eventProvider: this.getProviderInfo(provider).name,
@@ -780,18 +804,25 @@ var FormoAnalytics = /** @class */ (function () {
                             newAddress: newProviderAddress,
                             reason: PROVIDER_SWITCH_REASONS.ADDRESS_MISMATCH,
                         });
-                        // Emit disconnect for the old provider
+                        if (!this.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 13];
                         return [4 /*yield*/, this.disconnect({
                                 chainId: this.currentChainId,
                                 address: this.currentAddress,
                             })];
-                    case 10:
-                        // Emit disconnect for the old provider
+                    case 12:
                         _a.sent();
+                        return [3 /*break*/, 14];
+                    case 13:
+                        lib_1.logger.debug("OnAccountsChanged: Disconnect event skipped during provider switch (autocapture.disconnect: false)");
+                        // Still clear state even if not tracking the event
+                        this.currentAddress = undefined;
+                        this.currentChainId = undefined;
+                        _a.label = 14;
+                    case 14:
                         // Clear state and let the new provider become active
                         this.clearActiveProvider();
-                        return [3 /*break*/, 12];
-                    case 11:
+                        return [3 /*break*/, 16];
+                    case 15:
                         lib_1.logger.info("OnAccountsChanged: Current provider still has accounts and same address, ignoring new provider", {
                             activeProvider: this.getProviderInfo(this._provider).name,
                             eventProvider: this.getProviderInfo(provider).name,
@@ -800,26 +831,33 @@ var FormoAnalytics = /** @class */ (function () {
                             newAddress: newProviderAddress,
                         });
                         return [2 /*return*/];
-                    case 12: return [3 /*break*/, 15];
-                    case 13:
+                    case 16: return [3 /*break*/, 21];
+                    case 17:
                         lib_1.logger.info("OnAccountsChanged: Current provider has no accounts, switching to new provider", {
                             oldProvider: this.getProviderInfo(this._provider).name,
                             newProvider: this.getProviderInfo(provider).name,
                             reason: PROVIDER_SWITCH_REASONS.NO_ACCOUNTS,
                         });
-                        // Emit disconnect for the old provider that didn't signal properly
+                        if (!this.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 19];
                         return [4 /*yield*/, this.disconnect({
                                 chainId: this.currentChainId,
                                 address: this.currentAddress,
                             })];
-                    case 14:
-                        // Emit disconnect for the old provider that didn't signal properly
+                    case 18:
                         _a.sent();
+                        return [3 /*break*/, 20];
+                    case 19:
+                        lib_1.logger.debug("OnAccountsChanged: Disconnect event skipped for old provider (autocapture.disconnect: false)");
+                        // Still clear state even if not tracking the event
+                        this.currentAddress = undefined;
+                        this.currentChainId = undefined;
+                        _a.label = 20;
+                    case 20:
                         // Clear state and let the new provider become active
                         this.clearActiveProvider();
-                        _a.label = 15;
-                    case 15: return [3 /*break*/, 18];
-                    case 16:
+                        _a.label = 21;
+                    case 21: return [3 /*break*/, 26];
+                    case 22:
                         error_2 = _a.sent();
                         lib_1.logger.warn("OnAccountsChanged: Could not check current provider accounts, switching to new provider", {
                             error: error_2 instanceof Error ? error_2.message : String(error_2),
@@ -830,17 +868,24 @@ var FormoAnalytics = /** @class */ (function () {
                             newProvider: this.getProviderInfo(provider).name,
                             reason: PROVIDER_SWITCH_REASONS.CHECK_FAILED,
                         });
-                        // If we can't check the current provider, assume it's disconnected
+                        if (!this.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 24];
                         return [4 /*yield*/, this.disconnect({
                                 chainId: this.currentChainId,
                                 address: this.currentAddress,
                             })];
-                    case 17:
-                        // If we can't check the current provider, assume it's disconnected
+                    case 23:
                         _a.sent();
+                        return [3 /*break*/, 25];
+                    case 24:
+                        lib_1.logger.debug("OnAccountsChanged: Disconnect event skipped for failed provider check (autocapture.disconnect: false)");
+                        // Still clear state even if not tracking the event
+                        this.currentAddress = undefined;
+                        this.currentChainId = undefined;
+                        _a.label = 25;
+                    case 25:
                         this.clearActiveProvider();
-                        return [3 /*break*/, 18];
-                    case 18:
+                        return [3 /*break*/, 26];
+                    case 26:
                         // Set provider if none exists (first connection)
                         if (!this._provider) {
                             this._provider = provider;
@@ -850,33 +895,44 @@ var FormoAnalytics = /** @class */ (function () {
                             return [2 /*return*/];
                         }
                         return [4 /*yield*/, this.getCurrentChainId(provider)];
-                    case 19:
+                    case 27:
                         nextChainId = _a.sent();
                         wasDisconnected = !this.currentAddress;
+                        // CRITICAL: Always update state regardless of whether connect tracking is enabled
+                        // This ensures disconnect events will have valid address/chainId values
                         this.currentAddress = address;
                         this.currentChainId = nextChainId;
                         providerInfo = this.getProviderInfo(provider);
-                        lib_1.logger.info("OnAccountsChanged: Detected wallet connection, emitting connect event", {
-                            chainId: nextChainId,
-                            address: address,
-                            wasDisconnected: wasDisconnected,
-                            providerName: providerInfo.name,
-                            rdns: providerInfo.rdns,
-                            hasChainId: !!nextChainId,
-                        });
                         effectiveChainId = nextChainId || 0;
-                        if (effectiveChainId === 0) {
-                            lib_1.logger.info("OnAccountsChanged: Using fallback chainId 0 for connect event");
+                        if (this.isAutocaptureEnabled("connect")) {
+                            lib_1.logger.info("OnAccountsChanged: Detected wallet connection, emitting connect event", {
+                                chainId: nextChainId,
+                                address: address,
+                                wasDisconnected: wasDisconnected,
+                                providerName: providerInfo.name,
+                                rdns: providerInfo.rdns,
+                                hasChainId: !!nextChainId,
+                            });
+                            if (effectiveChainId === 0) {
+                                lib_1.logger.info("OnAccountsChanged: Using fallback chainId 0 for connect event");
+                            }
+                            this.connect({
+                                chainId: effectiveChainId,
+                                address: address,
+                            }, {
+                                providerName: providerInfo.name,
+                                rdns: providerInfo.rdns,
+                            }).catch(function (error) {
+                                lib_1.logger.error("Failed to track connect event during account change:", error);
+                            });
+                        }
+                        else {
+                            lib_1.logger.debug("OnAccountsChanged: Connect event skipped (autocapture.connect: false)", {
+                                chainId: nextChainId,
+                                address: address,
+                                providerName: providerInfo.name,
+                            });
                         }
-                        this.connect({
-                            chainId: effectiveChainId,
-                            address: address,
-                        }, {
-                            providerName: providerInfo.name,
-                            rdns: providerInfo.rdns,
-                        }).catch(function (error) {
-                            lib_1.logger.error("Failed to track connect event during account change:", error);
-                        });
                         return [2 /*return*/];
                 }
             });
@@ -917,10 +973,18 @@ var FormoAnalytics = /** @class */ (function () {
                 this.currentChainId = nextChainId;
                 try {
                     // This is just a chain change since we already confirmed currentAddress exists
-                    return [2 /*return*/, this.chain({
+                    if (this.isAutocaptureEnabled("chain")) {
+                        return [2 /*return*/, this.chain({
+                                chainId: this.currentChainId,
+                                address: this.currentAddress,
+                            })];
+                    }
+                    else {
+                        lib_1.logger.debug("OnChainChanged: Chain event skipped (autocapture.chain: false)", {
                             chainId: this.currentChainId,
                             address: this.currentAddress,
-                        })];
+                        });
+                    }
                 }
                 catch (error) {
                     lib_1.logger.error("OnChainChanged: Failed to emit chain event:", error);
@@ -957,6 +1021,7 @@ var FormoAnalytics = /** @class */ (function () {
                             currentAddress: this.currentAddress,
                             currentChainId: this.currentChainId,
                         });
+                        if (!this.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 5];
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 3, , 4]);
@@ -973,7 +1038,15 @@ var FormoAnalytics = /** @class */ (function () {
                         e_2 = _a.sent();
                         lib_1.logger.error("Error during disconnect in disconnect listener", e_2);
                         return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
+                    case 4: return [3 /*break*/, 6];
+                    case 5:
+                        lib_1.logger.debug("OnDisconnect: Disconnect event skipped (autocapture.disconnect: false)");
+                        // Still clear state even if not tracking the event
+                        this.currentAddress = undefined;
+                        this.currentChainId = undefined;
+                        this.clearActiveProvider();
+                        _a.label = 6;
+                    case 6: return [2 /*return*/];
                 }
             });
         }); };
@@ -1003,35 +1076,46 @@ var FormoAnalytics = /** @class */ (function () {
                                 this._provider = provider;
                             }
                             isActiveProvider = this._provider === provider;
-                            // Only update global state (chainId/address) from the active provider
+                            // CRITICAL: Always update state from active provider regardless of tracking config
+                            // This ensures disconnect events will have valid address/chainId values
                             if (isActiveProvider) {
                                 this.currentChainId = chainId;
                                 this.currentAddress =
                                     this.validateAndChecksumAddress(address) || undefined;
                             }
+                            // Conditionally emit connect event based on tracking configuration
                             if (isActiveProvider && this.currentAddress) {
                                 providerInfo = this.getProviderInfo(provider);
-                                lib_1.logger.info("OnConnected: Detected wallet connection, emitting connect event", {
-                                    chainId: chainId,
-                                    wasDisconnected: wasDisconnected,
-                                    providerName: providerInfo.name,
-                                    rdns: providerInfo.rdns,
-                                    hasChainId: !!chainId,
-                                    isActiveProvider: isActiveProvider,
-                                });
                                 effectiveChainId = chainId || 0;
-                                if (effectiveChainId === 0) {
-                                    lib_1.logger.info("OnConnected: Using fallback chainId 0 for connect event");
+                                if (this.isAutocaptureEnabled("connect")) {
+                                    lib_1.logger.info("OnConnected: Detected wallet connection, emitting connect event", {
+                                        chainId: chainId,
+                                        wasDisconnected: wasDisconnected,
+                                        providerName: providerInfo.name,
+                                        rdns: providerInfo.rdns,
+                                        hasChainId: !!chainId,
+                                        isActiveProvider: isActiveProvider,
+                                    });
+                                    if (effectiveChainId === 0) {
+                                        lib_1.logger.info("OnConnected: Using fallback chainId 0 for connect event");
+                                    }
+                                    this.connect({
+                                        chainId: effectiveChainId,
+                                        address: address,
+                                    }, {
+                                        providerName: providerInfo.name,
+                                        rdns: providerInfo.rdns,
+                                    }).catch(function (error) {
+                                        lib_1.logger.error("Failed to track connect event during provider connection:", error);
+                                    });
+                                }
+                                else {
+                                    lib_1.logger.debug("OnConnected: Connect event skipped (autocapture.connect: false)", {
+                                        chainId: chainId,
+                                        address: address,
+                                        providerName: providerInfo.name,
+                                    });
                                 }
-                                this.connect({
-                                    chainId: effectiveChainId,
-                                    address: address,
-                                }, {
-                                    providerName: providerInfo.name,
-                                    rdns: providerInfo.rdns,
-                                }).catch(function (error) {
-                                    lib_1.logger.error("Failed to track connect event during provider connection:", error);
-                                });
                             }
                             else if (address && !isActiveProvider) {
                                 providerInfo = this.getProviderInfo(provider);
@@ -1079,6 +1163,10 @@ var FormoAnalytics = /** @class */ (function () {
                     case 0:
                         if (!(Array.isArray(params) &&
                             ["eth_signTypedData_v4", "personal_sign"].includes(method))) return [3 /*break*/, 6];
+                        if (!this.isAutocaptureEnabled("signature")) {
+                            lib_1.logger.debug("Signature event skipped (autocapture.signature: false)", { method: method });
+                            return [2 /*return*/, request({ method: method, params: params })];
+                        }
                         _c = this.currentChainId;
                         if (_c) return [3 /*break*/, 2];
                         return [4 /*yield*/, this.getCurrentChainId(provider)];
@@ -1142,6 +1230,10 @@ var FormoAnalytics = /** @class */ (function () {
                         if (!(Array.isArray(params) &&
                             method === "eth_sendTransaction" &&
                             params[0])) return [3 /*break*/, 10];
+                        if (!this.isAutocaptureEnabled("transaction")) {
+                            lib_1.logger.debug("Transaction event skipped (autocapture.transaction: false)", { method: method });
+                            return [2 /*return*/, request({ method: method, params: params })];
+                        }
                         (function () { return __awaiter(_this, void 0, void 0, function () {
                             var payload, e_4;
                             return __generator(this, function (_a) {
@@ -1381,6 +1473,30 @@ var FormoAnalytics = /** @class */ (function () {
         // Default behavior: track everywhere except localhost
         return !(0, validators_1.isLocalhost)();
     };
+    /**
+     * Check if a specific wallet event type is enabled for autocapture
+     * @param eventType The wallet event type to check
+     * @returns {boolean} True if the event type should be autocaptured
+     */
+    FormoAnalytics.prototype.isAutocaptureEnabled = function (eventType) {
+        // If no configuration provided, default to enabled
+        if (this.options.autocapture === undefined) {
+            return true;
+        }
+        // If boolean, return that value for all events
+        if (typeof this.options.autocapture === "boolean") {
+            return this.options.autocapture;
+        }
+        // If it's an object, check the specific event configuration
+        if (this.options.autocapture !== null &&
+            typeof this.options.autocapture === "object") {
+            var eventConfig = this.options.autocapture[eventType];
+            // Default to true if not explicitly set to false
+            return eventConfig !== false;
+        }
+        // Default to enabled if no specific configuration
+        return true;
+    };
     /*
       Utility functions
     */

package/dist/cjs/src/constants/config.d.ts

@@ -1,6 +1,5 @@
-export declare const EVENTS_API_HOST = "https://events.formo.so";
-export declare const EVENTS_API_URL = "https://events.formo.so/v0/raw_events";
-export declare const USER_API_URL = "https://events.formo.so/user";
+export declare const EVENTS_API_ORIGIN = "https://events.formo.so";
+export declare const EVENTS_API_HOST = "https://events.formo.so/v0/raw_events";
 export declare const EVENTS_API_REQUEST_HEADER: (writeKey: string) => {
     "Content-Type": string;
     Authorization: string;

package/dist/cjs/src/constants/config.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.COUNTRY_LIST = exports.EVENTS_API_REQUEST_HEADER = exports.USER_API_URL = exports.EVENTS_API_URL = exports.EVENTS_API_HOST = void 0;
-exports.EVENTS_API_HOST = "https://events.formo.so";
-exports.EVENTS_API_URL = "".concat(exports.EVENTS_API_HOST, "/v0/raw_events");
-exports.USER_API_URL = "".concat(exports.EVENTS_API_HOST, "/user");
+exports.COUNTRY_LIST = exports.EVENTS_API_REQUEST_HEADER = exports.EVENTS_API_HOST = exports.EVENTS_API_ORIGIN = void 0;
+exports.EVENTS_API_ORIGIN = "https://events.formo.so";
+exports.EVENTS_API_HOST = "".concat(exports.EVENTS_API_ORIGIN, "/v0/raw_events");
 var EVENTS_API_REQUEST_HEADER = function (writeKey) { return ({
     "Content-Type": "application/json",
     Authorization: "Basic ".concat(writeKey),

package/dist/cjs/src/lib/queue/EventQueue.d.ts

@@ -1,7 +1,7 @@
 import { IFormoEvent } from "../../types";
 import { IEventQueue } from "./type";
 type Options = {
-    url: string;
+    apiHost: string;
     flushAt?: number;
     flushInterval?: number;
     host?: string;
@@ -11,7 +11,7 @@ type Options = {
 };
 export declare class EventQueue implements IEventQueue {
     private writeKey;
-    private url;
+    private apiHost;
     private queue;
     private timer;
     private flushAt;

package/dist/cjs/src/lib/queue/EventQueue.js

@@ -127,7 +127,7 @@ var EventQueue = /** @class */ (function () {
         options = options || {};
         this.queue = [];
         this.writeKey = writeKey;
-        this.url = options.url;
+        this.apiHost = options.apiHost;
         this.retryCount = (0, utils_1.clampNumber)(options.retryCount || DEFAULT_RETRY, MAX_RETRY, MIN_RETRY);
         this.flushAt = (0, utils_1.clampNumber)(options.flushAt || DEFAULT_FLUSH_AT, MAX_FLUSH_AT, MIN_FLUSH_AT);
         this.maxQueueSize = (0, utils_1.clampNumber)(options.maxQueueSize || DEFAULT_QUEUE_SIZE, MAX_QUEUE_SIZE, MIN_QUEUE_SIZE);
@@ -245,7 +245,7 @@ var EventQueue = /** @class */ (function () {
                             });
                             callback(err, data);
                         };
-                        return [2 /*return*/, (this.pendingFlush = (0, fetch_1.default)("".concat(this.url), {
+                        return [2 /*return*/, (this.pendingFlush = (0, fetch_1.default)("".concat(this.apiHost), {
                                 headers: (0, constants_1.EVENTS_API_REQUEST_HEADER)(this.writeKey),
                                 method: "POST",
                                 body: JSON.stringify(data),

package/dist/cjs/src/lib/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.20.0";
+export declare const version = "1.22.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/cjs/src/lib/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // Generated by genversion.
-exports.version = '1.20.0';
+exports.version = '1.22.0';
 //# sourceMappingURL=version.js.map

package/dist/cjs/src/types/base.d.ts

@@ -63,9 +63,57 @@ export interface TrackingOptions {
     excludePaths?: string[];
     excludeChains?: ChainID[];
 }
+/**
+ * Configuration options for controlling wallet event autocapture
+ * All events are enabled by default unless explicitly set to false
+ */
+export interface AutocaptureOptions {
+    /**
+     * Track wallet connect events
+     * @default true
+     */
+    connect?: boolean;
+    /**
+     * Track wallet disconnect events
+     * @default true
+     */
+    disconnect?: boolean;
+    /**
+     * Track wallet signature events (personal_sign, eth_signTypedData_v4)
+     * @default true
+     */
+    signature?: boolean;
+    /**
+     * Track wallet transaction events (eth_sendTransaction)
+     * @default true
+     */
+    transaction?: boolean;
+    /**
+     * Track wallet chain change events
+     * @default true
+     */
+    chain?: boolean;
+}
 export interface Options {
     provider?: EIP1193Provider;
     tracking?: boolean | TrackingOptions;
+    /**
+     * Control wallet event autocapture
+     * - `false`: Disable all wallet autocapture
+     * - `true`: Enable all wallet events (default)
+     * - `AutocaptureOptions`: Granular control over specific events
+     * @default true
+     */
+    autocapture?: boolean | AutocaptureOptions;
+    /**
+     * Custom API host for sending events through your own domain to bypass ad blockers
+     * - If not provided, events are sent directly to events.formo.so
+     * - When provided, events are sent to your custom endpoint which should forward them to Formo
+     * - Example: 'https://your-host-url.com/ingest' or '/api/analytics'
+     *
+     * See https://docs.formo.so/sdks/web#proxy for setup instructions
+     */
+    apiHost?: string;
     flushAt?: number;
     flushInterval?: number;
     retryCount?: number;

package/dist/esm/src/FormoAnalytics.d.ts

@@ -224,6 +224,12 @@ export declare class FormoAnalytics implements IFormoAnalytics {
      * @returns {boolean} True if tracking should be enabled
      */
     private shouldTrack;
+    /**
+     * Check if a specific wallet event type is enabled for autocapture
+     * @param eventType The wallet event type to check
+     * @returns {boolean} True if the event type should be autocaptured
+     */
+    private isAutocaptureEnabled;
     /**
      * Get provider information for a given provider
      * @param provider The provider to get info for