@formo/analytics 1.35.0 → 1.35.2

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

@@ -11,7 +11,6 @@ export declare const ACTIVE_WALLET_KEY = "active-wallet";
 export declare const ACTIVE_WALLET_TTL_MS: number;
 export declare const LOCAL_ANONYMOUS_ID_KEY = "anonymous-id";
 export declare const CONSENT_OPT_OUT_KEY = "opt-out-tracking";
-export declare const DEFAULT_PROVIDER_ICON = "data:image/svg+xml;base64,";
 export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 export declare const DEAD_ADDRESS = "0x000000000000000000000000000000000000dEaD";
 export declare const BLOCKED_ADDRESSES: readonly ["0x0000000000000000000000000000000000000000", "0x000000000000000000000000000000000000dEaD"];

package/dist/esm/src/constants/base.js

@@ -14,8 +14,6 @@ export var ACTIVE_WALLET_TTL_MS = 24 * 60 * 60 * 1000;
 export var LOCAL_ANONYMOUS_ID_KEY = "anonymous-id";
 // Consent management keys
 export var CONSENT_OPT_OUT_KEY = "opt-out-tracking";
-// Default provider icon (empty data URL)
-export var DEFAULT_PROVIDER_ICON = 'data:image/svg+xml;base64,';
 // Blocked addresses that should not emit events
 export var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 export var DEAD_ADDRESS = "0x000000000000000000000000000000000000dEaD";

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

@@ -60,7 +60,7 @@ import { validateAddress } from "../utils/address";
 import { getCurrentTimeFormatted } from "../utils/timestamp";
 import { isUndefined } from "../validators";
 import { logger } from "../logger";
-import mergeDeepRight from "../ramda/mergeDeepRight";
+import mergeDeepRight from "../utils/mergeDeepRight";
 import { session } from "../storage";
 import { version } from "../version";
 import { CHANNEL, CLICK_ID_PARAMS, DEFAULT_EXCLUDED_QUERY_PARAMS, DEFAULT_REFERRAL_PARAMS, PAGE_PROPERTIES_EXCLUDED_FIELDS, VERSION, } from "./constants";

package/dist/esm/src/utils/mergeDeepRight.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Deep merge two plain objects, with the right-hand side winning.
+ *
+ * Replaces a vendored copy of ramda's `mergeDeepRight` (9 files, ~200 lines
+ * of currying and placeholder machinery) that existed to serve exactly two
+ * call sites, each passing two plain objects. None of the currying was
+ * reachable.
+ *
+ * Behaviour is deliberately identical to the implementation it replaces:
+ *
+ * - Only PLAIN objects recurse. `Object.prototype.toString` is the test, so
+ *   arrays, dates, class instances, null and primitives are all replaced
+ *   wholesale by the right-hand value rather than merged into.
+ * - Own enumerable keys only, via `hasOwnProperty` - inherited keys are not
+ *   copied, and a key literally named `hasOwnProperty` cannot break it.
+ * - A key present on the left and absent on the right keeps the left value.
+ * - Neither input is mutated; a new object is returned at every level.
+ * - Nullish inputs are treated as empty objects.
+ */
+export declare function mergeDeepRight<L, R>(left: L, right: R): L & R;
+export default mergeDeepRight;
+//# sourceMappingURL=mergeDeepRight.d.ts.map

package/dist/esm/src/utils/mergeDeepRight.js

@@ -0,0 +1,51 @@
+/**
+ * Deep merge two plain objects, with the right-hand side winning.
+ *
+ * Replaces a vendored copy of ramda's `mergeDeepRight` (9 files, ~200 lines
+ * of currying and placeholder machinery) that existed to serve exactly two
+ * call sites, each passing two plain objects. None of the currying was
+ * reachable.
+ *
+ * Behaviour is deliberately identical to the implementation it replaces:
+ *
+ * - Only PLAIN objects recurse. `Object.prototype.toString` is the test, so
+ *   arrays, dates, class instances, null and primitives are all replaced
+ *   wholesale by the right-hand value rather than merged into.
+ * - Own enumerable keys only, via `hasOwnProperty` - inherited keys are not
+ *   copied, and a key literally named `hasOwnProperty` cannot break it.
+ * - A key present on the left and absent on the right keeps the left value.
+ * - Neither input is mutated; a new object is returned at every level.
+ * - Nullish inputs are treated as empty objects.
+ */
+export function mergeDeepRight(left, right) {
+    var l = (left !== null && left !== void 0 ? left : {});
+    var r = (right !== null && right !== void 0 ? right : {});
+    var result = {};
+    for (var k in l) {
+        if (!Object.prototype.hasOwnProperty.call(l, k))
+            continue;
+        result[k] = Object.prototype.hasOwnProperty.call(r, k)
+            ? mergeValues(l[k], r[k])
+            : l[k];
+    }
+    for (var k in r) {
+        if (!Object.prototype.hasOwnProperty.call(r, k))
+            continue;
+        if (Object.prototype.hasOwnProperty.call(result, k))
+            continue;
+        result[k] = r[k];
+    }
+    return result;
+}
+/** Recurse only when BOTH sides are plain objects; otherwise the right wins. */
+function mergeValues(lVal, rVal) {
+    if (isPlainObject(lVal) && isPlainObject(rVal)) {
+        return mergeDeepRight(lVal, rVal);
+    }
+    return rVal;
+}
+function isPlainObject(x) {
+    return Object.prototype.toString.call(x) === "[object Object]";
+}
+export default mergeDeepRight;
+//# sourceMappingURL=mergeDeepRight.js.map

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

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

package/dist/esm/src/version.js

@@ -1,4 +1,4 @@
 // This file is auto-generated by scripts/update-version.js during npm version
 // Do not edit manually - it will be overwritten
-export var version = '1.35.0';
+export var version = '1.35.2';
 //# sourceMappingURL=version.js.map

package/dist/esm/src/wagmi/WagmiEventHandler.d.ts

@@ -7,12 +7,72 @@
  */
 import { FormoAnalytics } from "../FormoAnalytics";
 import { WagmiConfig, QueryClient } from "./types";
+/**
+ * How long the markers stay trustworthy after the last handler goes away.
+ *
+ * A marker only means "already announced" while the SDK is actually watching
+ * wagmi. With no handler mounted nothing observes a disconnect, so a wallet
+ * that disconnects and reconnects in that window would otherwise look
+ * unchanged and its genuine connect would be swallowed for the rest of the
+ * page load.
+ *
+ * Rebuilding the SDK tears the old handler down and builds a new one, and
+ * `FormoAnalytics.init()` is async, so the gap is real but short. This grace
+ * period spans a rebuild and little else: markers survive it, and a longer
+ * unmount discards them so the next connect is treated as new.
+ */
+export declare const MARKER_GRACE_MS = 3000;
+/** Test hook. Real page loads reset this naturally. */
+export declare function __resetSeededWallet(): void;
 export declare class WagmiEventHandler {
     private formo;
     private wagmiConfig;
     private queryClient?;
     private unsubscribers;
     private trackingState;
+    /**
+     * Set by `cleanup()`. Every deferred emission checks it, so a handler that
+     * has been torn down cannot push an event into a queue the replacement SDK
+     * instance no longer owns.
+     */
+    private disposed;
+    /**
+     * Drop markers for wallets wagmi no longer holds, and report whether any
+     * announced wallet is still connected.
+     *
+     * Called when a handler mounts. Cancelling the expiry timer on the strength
+     * of "some connection exists" let a marker for a wallet that had since
+     * disconnected survive indefinitely, suppressing its genuine reconnect.
+     */
+    private pruneMarkersForLostWallets;
+    /** Identifies this handler's destination for emit-ownership. */
+    private ownerKey?;
+    /**
+     * Whether this handler is the one allowed to emit for its destination.
+     *
+     * A handler that lost the race still tracks state, so it is ready to take
+     * over the moment the owner goes away; it just does not emit.
+     */
+    private get isEmittingOwner();
+    /** Reentrancy guard for `reconcileWithLiveState()`. */
+    private reconciling;
+    /**
+     * Ticket for each active-connection transition. Emissions are awaited, and
+     * wagmi can move again in that window; a continuation whose ticket is no
+     * longer current must not write stale state over the newer one.
+     */
+    private transitionGeneration;
+    /**
+     * A chain reported while wagmi was not `connected`, so the chain callback
+     * had to drop it. Replayed by `reconcileWithLiveState()`.
+     */
+    private pendingChainId?;
+    /**
+     * A `disconnected` status that arrived while the lock was held. Final-state
+     * reconciliation cannot see a disconnect/reconnect cycle that completed
+     * inside that window, so this records that one happened.
+     */
+    private missedDisconnect;
     /**
      * Track processed mutation states to prevent duplicate event emissions
      * Key format: `${mutationId}:${status}`
@@ -27,16 +87,130 @@ export declare class WagmiEventHandler {
      * Store transaction details from BROADCASTED events for use in CONFIRMED/REVERTED
      * Key: transactionHash, Value: transaction details including the original sender address
      */
-    private pendingTransactions;
+    /**
+     * Shared per destination, not per handler.
+     *
+     * A broadcast observed by handler A, followed by a replacement B taking
+     * over before the receipt arrives, used to lose the confirmation entirely:
+     * A no longer emits because it is not the owner, and B had no record of the
+     * broadcast to match the receipt against.
+     */
+    private get pendingTransactions();
     constructor(formoAnalytics: FormoAnalytics, wagmiConfig: WagmiConfig, queryClient?: QueryClient);
     /**
      * Set up listeners for wallet connection, disconnection, and chain changes
      */
     private setupConnectionListeners;
+    /**
+     * Adopt a connection that already existed when this handler was created.
+     *
+     * `config.subscribe` reports *changes* only, so a wallet restored by wagmi's
+     * mount-time `reconnect()` is invisible to a handler built afterwards. That
+     * is the normal case whenever the host app loads the SDK lazily (dynamic
+     * import, `requestIdleCallback`) and can also happen on a plain mount, since
+     * `FormoAnalytics.init()` and wagmi's reconnect are both async and race.
+     *
+     * Without this seed the whole session is lost: no connect event, and
+     * `lastAddress` stays undefined so the signature and transaction handlers
+     * drop their events too, and the eventual disconnect carries neither address
+     * nor chain id.
+     *
+     * `subscribe(..., { fireImmediately: true })` is not a substitute. It reports
+     * the current value with no distinct previous value, so the connect branch's
+     * `prevStatus !== "connected"` test never passes, and wagmi v3 does not
+     * honour the option at all.
+     *
+     * Deliberately synchronous, and deliberately does NOT take the
+     * `isProcessing` lock. Everything that mutates tracking state runs before
+     * any await, so no status change can interleave with it. Holding the lock
+     * across the `connect()` emission instead would make `handleStatusChange()`
+     * drop - not defer - a disconnect or wallet switch that lands in that
+     * window, which is exactly when a lazily loaded SDK is racing app activity.
+     *
+     * A genuine `connected` transition cannot double-emit alongside this seed.
+     * `config.subscribe` only fires on change, and the connect branch treats a
+     * re-entry for an already-tracked address as a no-op (or a chain change).
+     */
+    private seedFromCurrentState;
+    /**
+     * Re-assert the tracked wallet into central state.
+     *
+     * Needed when an awaited emission clears the central namespace after a newer
+     * transition has already adopted a different wallet: the two then disagree,
+     * and `trackEvent()` reads the central one.
+     */
+    private restoreCentralStateFromTracking;
+    /**
+     * Drop the wallet this handler is attributing events to.
+     *
+     * Used whenever central state refuses to hold the wallet - an excluded path
+     * or chain, or an opt-out. Keeping the address privately would let the
+     * mutation handlers label signatures and transactions with an identity the
+     * SDK has deliberately declined to know.
+     */
+    private releaseTrackedWallet;
+    /**
+     * Adopt the live connection if one exists and nothing is tracked yet.
+     *
+     * `seedFromCurrentState()` runs once at construction and can legitimately
+     * decline: wagmi may still be filling `connections`, the chain may not have
+     * arrived, or tracking may be suppressed because the app happens to be on an
+     * excluded path. `config.subscribe` only reports *changes*, so an unchanged
+     * connection would then stay invisible for the rest of the page load and
+     * every later signature and transaction would be dropped.
+     *
+     * Idempotent. The page-load marker keeps it from re-emitting a connect for a
+     * wallet already announced, so this is safe to call from any listener.
+     */
+    retryAdoption(): void;
+    /** Whether the wallet this handler tracks is the one wagmi currently has. */
+    private tracksLiveWallet;
+    /**
+     * Put the tracked wallet back into central state without emitting anything.
+     *
+     * Used when the two have diverged for a reason that is not a wallet change:
+     * an opt-out `reset()`, or a stale disconnect completing after a newer
+     * transition adopted a different wallet.
+     */
+    private resyncCentralState;
+    /** Whether the wallet currently tracked has already had a connect emitted. */
+    private isCurrentWalletAnnounced;
     /**
      * Handle status changes (connect/disconnect)
      */
     private handleStatusChange;
+    /**
+     * Re-run the status logic when the handler's view diverges from wagmi.
+     *
+     * `handleStatusChange()` drops - rather than defers - anything that arrives
+     * while it holds `isProcessing`, and it holds that lock across an awaited
+     * `connect()` / `disconnect()` emission. A wallet that reconnects inside
+     * that window would otherwise leave the handler believing it is
+     * disconnected for the rest of the page load, silently dropping every later
+     * signature and transaction. The mirror case leaves a disconnected wallet
+     * marked connected.
+     *
+     * Converges: each pass either adopts the live wallet or releases the tracked
+     * one, so the next pass finds the two in agreement and returns.
+     */
+    private reconcileWithLiveState;
+    /**
+     * Handle a switch to a different account on an already-connected wallet.
+     *
+     * Only fires for a genuine in-place switch. A fresh connect and a disconnect
+     * both move `state.status`, and that listener is registered first, so it has
+     * already recorded the new address synchronously by the time this runs. The
+     * `lastAddress` check below is what makes the two paths mutually exclusive.
+     */
+    private handleActiveAddressChange;
+    /**
+     * Record and emit a chain move for the wallet already being tracked.
+     *
+     * Shared by `handleChainChange()` and the connector-fallback path, which
+     * has to apply the chain itself: the chain callback defers while the new
+     * connection is not adopted yet, so nothing else would.
+     */
+    private applyChainForTrackedWallet;
     /**
      * Handle chain ID changes
      */
@@ -77,10 +251,28 @@ export declare class WagmiEventHandler {
      * for compatibility with different Wagmi wrappers (RainbowKit, etc.)
      */
     private getState;
+    /**
+     * Chain of the connection that is currently active.
+     *
+     * Authoritative, because `state.chainId` is a single global value. With
+     * `syncConnectedChain: false` it stays on the chain the APP selected while
+     * the connection reports the chain the WALLET is actually on, so seeding
+     * from the global could label a wallet on an excluded chain as an allowed
+     * one and send events the exclusion forbids.
+     */
+    private getActiveConnectionChainId;
     /**
      * Get the currently connected address from Wagmi state
      */
     private getConnectedAddress;
+    /**
+     * Whether any live connection still holds this address.
+     *
+     * Distinguishes "the user switched away from this account" (gone from every
+     * connection) from "this account merely stopped being the current one"
+     * (still connected through its own connector).
+     */
+    private isAddressConnected;
     /**
      * Get the connector name from Wagmi state
      */