@formo/analytics 1.21.0 → 1.22.0

package/dist/esm/src/FormoAnalytics.js

@@ -111,6 +111,7 @@ 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
         Logger.init({
             enabled: ((_a = options.logger) === null || _a === void 0 ? void 0 : _a.enabled) || false,
@@ -620,12 +621,26 @@ var FormoAnalytics = /** @class */ (function () {
                 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 {
+                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);
         }
@@ -710,13 +725,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];
                         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]);
@@ -735,16 +751,24 @@ var FormoAnalytics = /** @class */ (function () {
                         return [3 /*break*/, 4];
                     case 4: return [3 /*break*/, 6];
                     case 5:
-                        logger.info("OnAccountsChanged: Ignoring disconnect for non-active provider");
+                        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:
+                        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) {
                             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);
                         logger.info("OnAccountsChanged: Different provider attempting to connect", {
@@ -753,11 +777,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();
                         logger.info("OnAccountsChanged: Checking current provider accounts", {
                             activeProvider: this.getProviderInfo(this._provider).name,
@@ -766,10 +790,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];
                         logger.info("OnAccountsChanged: Different address detected, switching providers despite current provider having accounts", {
                             activeProvider: this.getProviderInfo(this._provider).name,
                             eventProvider: this.getProviderInfo(provider).name,
@@ -777,18 +801,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:
+                        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:
                         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,
@@ -797,26 +828,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:
                         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:
+                        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();
                         logger.warn("OnAccountsChanged: Could not check current provider accounts, switching to new provider", {
                             error: error_2 instanceof Error ? error_2.message : String(error_2),
@@ -827,17 +865,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:
+                        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;
@@ -847,33 +892,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);
-                        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) {
-                            logger.info("OnAccountsChanged: Using fallback chainId 0 for connect event");
+                        if (this.isAutocaptureEnabled("connect")) {
+                            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) {
+                                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) {
+                                logger.error("Failed to track connect event during account change:", error);
+                            });
+                        }
+                        else {
+                            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) {
-                            logger.error("Failed to track connect event during account change:", error);
-                        });
                         return [2 /*return*/];
                 }
             });
@@ -914,10 +970,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 {
+                        logger.debug("OnChainChanged: Chain event skipped (autocapture.chain: false)", {
                             chainId: this.currentChainId,
                             address: this.currentAddress,
-                        })];
+                        });
+                    }
                 }
                 catch (error) {
                     logger.error("OnChainChanged: Failed to emit chain event:", error);
@@ -954,6 +1018,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]);
@@ -970,7 +1035,15 @@ var FormoAnalytics = /** @class */ (function () {
                         e_2 = _a.sent();
                         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:
+                        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*/];
                 }
             });
         }); };
@@ -1000,35 +1073,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);
-                                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) {
-                                    logger.info("OnConnected: Using fallback chainId 0 for connect event");
+                                if (this.isAutocaptureEnabled("connect")) {
+                                    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) {
+                                        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) {
+                                        logger.error("Failed to track connect event during provider connection:", error);
+                                    });
+                                }
+                                else {
+                                    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) {
-                                    logger.error("Failed to track connect event during provider connection:", error);
-                                });
                             }
                             else if (address && !isActiveProvider) {
                                 providerInfo = this.getProviderInfo(provider);
@@ -1076,6 +1160,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")) {
+                            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)];
@@ -1139,6 +1227,10 @@ var FormoAnalytics = /** @class */ (function () {
                         if (!(Array.isArray(params) &&
                             method === "eth_sendTransaction" &&
                             params[0])) return [3 /*break*/, 10];
+                        if (!this.isAutocaptureEnabled("transaction")) {
+                            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) {
@@ -1378,6 +1470,30 @@ var FormoAnalytics = /** @class */ (function () {
         // Default behavior: track everywhere except localhost
         return !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/esm/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/esm/src/lib/version.js

@@ -1,3 +1,3 @@
 // Generated by genversion.
-export var version = '1.20.0';
+export var version = '1.22.0';
 //# sourceMappingURL=version.js.map

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

@@ -63,9 +63,48 @@ 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;
     flushAt?: number;
     flushInterval?: number;
     retryCount?: number;