@dashgram/javascript 1.0.0 → 1.0.1

package/dist/trackers/deep-tracker.js

@@ -1,6 +1,5 @@
 import { BaseTracker } from "./base-tracker";
 import { throttle } from "../utils/helpers";
-import { getScrollDepth } from "../utils/device";
 import { subscribeToTelegramEvent } from "../utils/telegram";
 export class DeepTracker extends BaseTracker {
     constructor(config, trackCallback) {
@@ -9,6 +8,7 @@ export class DeepTracker extends BaseTracker {
         this.observers = [];
         this.clickTracker = new Map();
         this.maxScrollDepth = 0;
+        this.trackedMedia = new WeakSet();
     }
     setup() {
         if (typeof window === "undefined") {
@@ -19,6 +19,9 @@ export class DeepTracker extends BaseTracker {
         this.setupRageClickTracking();
         this.setupLongTaskTracking();
         this.setupWebVitals();
+        this.setupNetworkTracking();
+        this.setupOrientationTracking();
+        this.setupMediaTracking();
         this.setupTelegramTracking();
     }
     teardown() {
@@ -28,9 +31,20 @@ export class DeepTracker extends BaseTracker {
         this.observers = [];
         this.clickTracker.clear();
     }
+    getScrollDepth() {
+        const windowHeight = window.innerHeight;
+        const documentHeight = document.documentElement.scrollHeight;
+        const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+        if (documentHeight <= windowHeight) {
+            return 100;
+        }
+        const maxScroll = documentHeight - windowHeight;
+        const scrollPercentage = (scrollTop / maxScroll) * 100;
+        return Math.min(Math.round(scrollPercentage), 100);
+    }
     setupScrollTracking() {
         const handleScroll = throttle(() => {
-            const depth = getScrollDepth();
+            const depth = this.getScrollDepth();
             if (depth > this.maxScrollDepth) {
                 this.maxScrollDepth = depth;
                 const milestones = [25, 50, 75, 100];
@@ -218,24 +232,560 @@ export class DeepTracker extends BaseTracker {
             this.log("CLS tracking not supported");
         }
     }
+    setupNetworkTracking() {
+        const handleOnline = () => {
+            this.track("network_status", {
+                status: "online",
+                effective_type: navigator.connection?.effectiveType,
+                downlink: navigator.connection?.downlink,
+                rtt: navigator.connection?.rtt
+            });
+        };
+        const handleOffline = () => {
+            this.track("network_status", {
+                status: "offline"
+            });
+        };
+        window.addEventListener("online", handleOnline);
+        window.addEventListener("offline", handleOffline);
+        this.unsubscribers.push(() => {
+            window.removeEventListener("online", handleOnline);
+            window.removeEventListener("offline", handleOffline);
+        });
+        const connection = navigator.connection;
+        if (connection) {
+            const handleConnectionChange = () => {
+                this.track("network_change", {
+                    effective_type: connection.effectiveType,
+                    downlink: connection.downlink,
+                    rtt: connection.rtt,
+                    save_data: connection.saveData
+                });
+            };
+            connection.addEventListener("change", handleConnectionChange);
+            this.unsubscribers.push(() => {
+                connection.removeEventListener("change", handleConnectionChange);
+            });
+        }
+    }
+    setupOrientationTracking() {
+        const handleOrientationChange = () => {
+            const orientation = screen.orientation?.type || (window.innerWidth > window.innerHeight ? "landscape" : "portrait");
+            this.track("orientation_change", {
+                orientation: orientation,
+                angle: screen.orientation?.angle,
+                width: window.innerWidth,
+                height: window.innerHeight
+            });
+        };
+        if (screen.orientation) {
+            screen.orientation.addEventListener("change", handleOrientationChange);
+            this.unsubscribers.push(() => {
+                screen.orientation.removeEventListener("change", handleOrientationChange);
+            });
+        }
+        else {
+            window.addEventListener("orientationchange", handleOrientationChange);
+            this.unsubscribers.push(() => {
+                window.removeEventListener("orientationchange", handleOrientationChange);
+            });
+        }
+    }
+    setupMediaTracking() {
+        const trackMediaEvent = (event) => {
+            const media = event.target;
+            if (!media || this.trackedMedia.has(media))
+                return;
+            const mediaType = media.tagName.toLowerCase();
+            const eventType = event.type;
+            const baseProps = {
+                media_type: mediaType,
+                src: media.currentSrc || media.src,
+                duration: isFinite(media.duration) ? Math.round(media.duration) : undefined,
+                current_time: Math.round(media.currentTime),
+                muted: media.muted,
+                volume: Math.round(media.volume * 100)
+            };
+            if (eventType === "play") {
+                this.track("media_play", baseProps);
+            }
+            else if (eventType === "pause") {
+                this.track("media_pause", {
+                    ...baseProps,
+                    percent_played: media.duration ? Math.round((media.currentTime / media.duration) * 100) : 0
+                });
+            }
+            else if (eventType === "ended") {
+                this.track("media_ended", {
+                    ...baseProps,
+                    completed: true
+                });
+            }
+            else if (eventType === "error") {
+                this.track("media_error", {
+                    media_type: mediaType,
+                    src: media.currentSrc || media.src,
+                    error: media.error?.message || "unknown"
+                });
+            }
+        };
+        const setupMediaElement = (media) => {
+            if (this.trackedMedia.has(media))
+                return;
+            this.trackedMedia.add(media);
+            media.addEventListener("play", trackMediaEvent);
+            media.addEventListener("pause", trackMediaEvent);
+            media.addEventListener("ended", trackMediaEvent);
+            media.addEventListener("error", trackMediaEvent);
+        };
+        document.querySelectorAll("video, audio").forEach(media => {
+            setupMediaElement(media);
+        });
+        const observer = new MutationObserver(mutations => {
+            mutations.forEach(mutation => {
+                mutation.addedNodes.forEach(node => {
+                    if (node instanceof HTMLMediaElement) {
+                        setupMediaElement(node);
+                    }
+                    if (node instanceof Element) {
+                        node.querySelectorAll("video, audio").forEach(media => {
+                            setupMediaElement(media);
+                        });
+                    }
+                });
+            });
+        });
+        observer.observe(document.body, {
+            childList: true,
+            subtree: true
+        });
+        this.observers.push(observer);
+    }
     setupTelegramTracking() {
+        const webApp = window.Telegram?.WebApp;
+        const trackEvent = (eventName, data) => {
+            this.track(`telegram_${eventName}`, data || {});
+        };
         const unsubTheme = subscribeToTelegramEvent("themeChanged", () => {
-            this.track("telegram_theme_changed", {});
+            trackEvent("theme_changed", {
+                color_scheme: webApp?.colorScheme,
+                theme_params: webApp?.themeParams
+            });
         });
         this.unsubscribers.push(unsubTheme);
-        const unsubViewport = subscribeToTelegramEvent("viewportChanged", () => {
-            this.track("telegram_viewport_changed", {
-                is_expanded: window.Telegram?.WebApp?.isExpanded
+        const unsubViewport = subscribeToTelegramEvent("viewportChanged", (eventData) => {
+            trackEvent("viewport_changed", {
+                is_state_stable: eventData?.isStateStable,
+                is_expanded: webApp?.isExpanded,
+                viewport_height: webApp?.viewportHeight,
+                viewport_stable_height: webApp?.viewportStableHeight
             });
         });
         this.unsubscribers.push(unsubViewport);
-        const unsubBack = subscribeToTelegramEvent("backButtonClicked", () => {
-            this.track("telegram_back_button_clicked", {});
+        const unsubSafeArea = subscribeToTelegramEvent("safeAreaChanged", () => {
+            trackEvent("safe_area_changed", {
+                safe_area: webApp?.safeAreaInset
+            });
+        });
+        this.unsubscribers.push(unsubSafeArea);
+        const unsubContentSafeArea = subscribeToTelegramEvent("contentSafeAreaChanged", () => {
+            trackEvent("content_safe_area_changed", {
+                content_safe_area: webApp?.contentSafeAreaInset
+            });
+        });
+        this.unsubscribers.push(unsubContentSafeArea);
+        const unsubBackButton = subscribeToTelegramEvent("backButtonClicked", () => {
+            trackEvent("back_button_clicked", {});
+        });
+        this.unsubscribers.push(unsubBackButton);
+        const unsubMainButton = subscribeToTelegramEvent("mainButtonClicked", () => {
+            trackEvent("main_button_clicked", {
+                button_text: webApp?.MainButton?.text
+            });
+        });
+        this.unsubscribers.push(unsubMainButton);
+        const unsubInvoice = subscribeToTelegramEvent("invoiceClosed", (eventData) => {
+            trackEvent("invoice_closed", {
+                url: eventData?.url,
+                status: eventData?.status
+            });
+        });
+        this.unsubscribers.push(unsubInvoice);
+        const unsubPopup = subscribeToTelegramEvent("popupClosed", (eventData) => {
+            trackEvent("popup_closed", {
+                button_id: eventData?.button_id
+            });
+        });
+        this.unsubscribers.push(unsubPopup);
+        const unsubQrText = subscribeToTelegramEvent("qrTextReceived", (eventData) => {
+            trackEvent("qr_text_received", {
+                data: eventData?.data
+            });
+        });
+        this.unsubscribers.push(unsubQrText);
+        const unsubScanQr = subscribeToTelegramEvent("scanQrPopupClosed", () => {
+            trackEvent("scan_qr_popup_closed", {});
+        });
+        this.unsubscribers.push(unsubScanQr);
+        const unsubClipboard = subscribeToTelegramEvent("clipboardTextReceived", (eventData) => {
+            trackEvent("clipboard_text_received", {
+                data: eventData?.data
+            });
+        });
+        this.unsubscribers.push(unsubClipboard);
+        const unsubWriteAccess = subscribeToTelegramEvent("writeAccessRequested", (eventData) => {
+            trackEvent("write_access_requested", {
+                status: eventData?.status
+            });
+        });
+        this.unsubscribers.push(unsubWriteAccess);
+        const unsubFileDownload = subscribeToTelegramEvent("fileDownloadRequested", (eventData) => {
+            trackEvent("file_download_requested", {
+                status: eventData?.status
+            });
+        });
+        this.unsubscribers.push(unsubFileDownload);
+        const unsubCustomMethod = subscribeToTelegramEvent("customMethodInvoked", (eventData) => {
+            trackEvent("custom_method_invoked", {
+                req_id: eventData?.req_id,
+                result: eventData?.result,
+                error: eventData?.error
+            });
+        });
+        this.unsubscribers.push(unsubCustomMethod);
+        const unsubFullscreen = subscribeToTelegramEvent("fullscreenChanged", (eventData) => {
+            trackEvent("fullscreen_changed", {
+                is_fullscreen: eventData?.isFullscreen
+            });
+        });
+        this.unsubscribers.push(unsubFullscreen);
+        const unsubFullscreenFailed = subscribeToTelegramEvent("fullscreenFailed", (eventData) => {
+            trackEvent("fullscreen_failed", {
+                error: eventData?.error
+            });
+        });
+        this.unsubscribers.push(unsubFullscreenFailed);
+        const unsubHomeScreenAdded = subscribeToTelegramEvent("homeScreenAdded", () => {
+            trackEvent("home_screen_added", {});
+        });
+        this.unsubscribers.push(unsubHomeScreenAdded);
+        const unsubHomeScreenChecked = subscribeToTelegramEvent("homeScreenChecked", (eventData) => {
+            trackEvent("home_screen_checked", {
+                status: eventData?.status
+            });
         });
-        this.unsubscribers.push(unsubBack);
-        const unsubMain = subscribeToTelegramEvent("mainButtonClicked", () => {
-            this.track("telegram_main_button_clicked", {});
+        this.unsubscribers.push(unsubHomeScreenChecked);
+        const unsubPreparedMessageSent = subscribeToTelegramEvent("preparedMessageSent", () => {
+            trackEvent("prepared_message_sent", {});
         });
-        this.unsubscribers.push(unsubMain);
+        this.unsubscribers.push(unsubPreparedMessageSent);
+        const unsubPreparedMessageFailed = subscribeToTelegramEvent("preparedMessageFailed", (eventData) => {
+            trackEvent("prepared_message_failed", {
+                error: eventData?.error
+            });
+        });
+        this.unsubscribers.push(unsubPreparedMessageFailed);
+        const unsubEmojiStatusSet = subscribeToTelegramEvent("emojiStatusSet", () => {
+            trackEvent("emoji_status_set", {});
+        });
+        this.unsubscribers.push(unsubEmojiStatusSet);
+        const unsubEmojiStatusFailed = subscribeToTelegramEvent("emojiStatusFailed", (eventData) => {
+            trackEvent("emoji_status_failed", {
+                error: eventData?.error
+            });
+        });
+        this.unsubscribers.push(unsubEmojiStatusFailed);
+        const unsubEmojiStatusAccess = subscribeToTelegramEvent("emojiStatusAccessRequested", (eventData) => {
+            trackEvent("emoji_status_access_requested", {
+                status: eventData?.status
+            });
+        });
+        this.unsubscribers.push(unsubEmojiStatusAccess);
+        const unsubSettingsButton = subscribeToTelegramEvent("settingsButtonClicked", () => {
+            trackEvent("settings_button_clicked", {});
+        });
+        this.unsubscribers.push(unsubSettingsButton);
+        const unsubSecondaryButton = subscribeToTelegramEvent("secondaryButtonClicked", () => {
+            trackEvent("secondary_button_clicked", {});
+        });
+        this.unsubscribers.push(unsubSecondaryButton);
+        const unsubShareMessageSent = subscribeToTelegramEvent("shareMessageSent", () => {
+            trackEvent("share_message_sent", {});
+        });
+        this.unsubscribers.push(unsubShareMessageSent);
+        const unsubShareMessageFailed = subscribeToTelegramEvent("shareMessageFailed", (eventData) => {
+            trackEvent("share_message_failed", {
+                error: eventData?.error
+            });
+        });
+        this.unsubscribers.push(unsubShareMessageFailed);
+        const unsubLocationManager = subscribeToTelegramEvent("locationManagerUpdated", () => {
+            const locationManager = webApp?.LocationManager;
+            trackEvent("location_manager_updated", {
+                is_inited: locationManager?.isInited,
+                is_location_available: locationManager?.isLocationAvailable,
+                is_access_requested: locationManager?.isAccessRequested,
+                is_access_granted: locationManager?.isAccessGranted
+            });
+        });
+        this.unsubscribers.push(unsubLocationManager);
+        const unsubLocationRequested = subscribeToTelegramEvent("locationRequested", (eventData) => {
+            trackEvent("location_requested", {
+                available: eventData?.available !== false,
+                latitude: eventData?.latitude,
+                longitude: eventData?.longitude,
+                altitude: eventData?.altitude,
+                course: eventData?.course,
+                speed: eventData?.speed,
+                horizontal_accuracy: eventData?.horizontal_accuracy,
+                vertical_accuracy: eventData?.vertical_accuracy,
+                course_accuracy: eventData?.course_accuracy,
+                speed_accuracy: eventData?.speed_accuracy
+            });
+        });
+        this.unsubscribers.push(unsubLocationRequested);
+        const unsubAccelerometerStarted = subscribeToTelegramEvent("accelerometerStarted", () => {
+            trackEvent("accelerometer_started", {});
+        });
+        this.unsubscribers.push(unsubAccelerometerStarted);
+        const unsubAccelerometerStopped = subscribeToTelegramEvent("accelerometerStopped", () => {
+            trackEvent("accelerometer_stopped", {});
+        });
+        this.unsubscribers.push(unsubAccelerometerStopped);
+        const unsubAccelerometerChanged = subscribeToTelegramEvent("accelerometerChanged", () => {
+            const accelerometer = webApp?.Accelerometer;
+            trackEvent("accelerometer_changed", {
+                x: accelerometer?.x,
+                y: accelerometer?.y,
+                z: accelerometer?.z
+            });
+        });
+        this.unsubscribers.push(unsubAccelerometerChanged);
+        const unsubAccelerometerFailed = subscribeToTelegramEvent("accelerometerFailed", (eventData) => {
+            trackEvent("accelerometer_failed", {
+                error: eventData?.error
+            });
+        });
+        this.unsubscribers.push(unsubAccelerometerFailed);
+        const unsubDeviceOrientationStarted = subscribeToTelegramEvent("deviceOrientationStarted", () => {
+            trackEvent("device_orientation_started", {});
+        });
+        this.unsubscribers.push(unsubDeviceOrientationStarted);
+        const unsubDeviceOrientationStopped = subscribeToTelegramEvent("deviceOrientationStopped", () => {
+            trackEvent("device_orientation_stopped", {});
+        });
+        this.unsubscribers.push(unsubDeviceOrientationStopped);
+        const unsubDeviceOrientationChanged = subscribeToTelegramEvent("deviceOrientationChanged", () => {
+            const deviceOrientation = webApp?.DeviceOrientation;
+            trackEvent("device_orientation_changed", {
+                absolute: deviceOrientation?.absolute,
+                alpha: deviceOrientation?.alpha,
+                beta: deviceOrientation?.beta,
+                gamma: deviceOrientation?.gamma
+            });
+        });
+        this.unsubscribers.push(unsubDeviceOrientationChanged);
+        const unsubDeviceOrientationFailed = subscribeToTelegramEvent("deviceOrientationFailed", (eventData) => {
+            trackEvent("device_orientation_failed", {
+                error: eventData?.error
+            });
+        });
+        this.unsubscribers.push(unsubDeviceOrientationFailed);
+        const unsubGyroscopeStarted = subscribeToTelegramEvent("gyroscopeStarted", () => {
+            trackEvent("gyroscope_started", {});
+        });
+        this.unsubscribers.push(unsubGyroscopeStarted);
+        const unsubGyroscopeStopped = subscribeToTelegramEvent("gyroscopeStopped", () => {
+            trackEvent("gyroscope_stopped", {});
+        });
+        this.unsubscribers.push(unsubGyroscopeStopped);
+        const unsubGyroscopeChanged = subscribeToTelegramEvent("gyroscopeChanged", () => {
+            const gyroscope = webApp?.Gyroscope;
+            trackEvent("gyroscope_changed", {
+                x: gyroscope?.x,
+                y: gyroscope?.y,
+                z: gyroscope?.z
+            });
+        });
+        this.unsubscribers.push(unsubGyroscopeChanged);
+        const unsubGyroscopeFailed = subscribeToTelegramEvent("gyroscopeFailed", (eventData) => {
+            trackEvent("gyroscope_failed", {
+                error: eventData?.error
+            });
+        });
+        this.unsubscribers.push(unsubGyroscopeFailed);
+        const unsubContactRequested = subscribeToTelegramEvent("contactRequested", (eventData) => {
+            trackEvent("contact_requested", {
+                status: eventData?.status
+            });
+        });
+        this.unsubscribers.push(unsubContactRequested);
+        const unsubActivated = subscribeToTelegramEvent("activated", () => {
+            trackEvent("activated", {});
+        });
+        this.unsubscribers.push(unsubActivated);
+        const unsubDeactivated = subscribeToTelegramEvent("deactivated", () => {
+            trackEvent("deactivated", {});
+        });
+        this.unsubscribers.push(unsubDeactivated);
+        const unsubBiometricManager = subscribeToTelegramEvent("biometricManagerUpdated", () => {
+            const biometricManager = webApp?.BiometricManager;
+            trackEvent("biometric_manager_updated", {
+                is_inited: biometricManager?.isInited,
+                is_biometric_available: biometricManager?.isBiometricAvailable,
+                biometric_type: biometricManager?.biometricType,
+                is_access_requested: biometricManager?.isAccessRequested,
+                is_access_granted: biometricManager?.isAccessGranted,
+                is_biometric_token_saved: biometricManager?.isBiometricTokenSaved,
+                device_id: biometricManager?.deviceId
+            });
+        });
+        this.unsubscribers.push(unsubBiometricManager);
+        const unsubBiometricAuth = subscribeToTelegramEvent("biometricAuthRequested", (eventData) => {
+            trackEvent("biometric_auth_requested", {
+                is_authenticated: eventData?.isAuthenticated,
+                biometric_token: eventData?.biometricToken
+            });
+        });
+        this.unsubscribers.push(unsubBiometricAuth);
+        const unsubBiometricToken = subscribeToTelegramEvent("biometricTokenUpdated", (eventData) => {
+            trackEvent("biometric_token_updated", {
+                is_updated: eventData?.isUpdated
+            });
+        });
+        this.unsubscribers.push(unsubBiometricToken);
+        this.patchWebAppMethods(webApp, trackEvent);
+    }
+    patchWebAppMethods(webApp, trackEvent) {
+        if (!webApp)
+            return;
+        if (webApp.openLink?._dashgramPatched) {
+            return;
+        }
+        if (webApp.openLink && typeof webApp.openLink === "function") {
+            const originalOpenLink = webApp.openLink.bind(webApp);
+            const patchedOpenLink = (url, options) => {
+                trackEvent("open_link", {
+                    url: url,
+                    options: options
+                });
+                return originalOpenLink(url, options);
+            };
+            patchedOpenLink._dashgramPatched = true;
+            webApp.openLink = patchedOpenLink;
+        }
+        if (webApp.openTelegramLink && typeof webApp.openTelegramLink === "function") {
+            const originalOpenTelegramLink = webApp.openTelegramLink.bind(webApp);
+            const patchedOpenTelegramLink = (url) => {
+                trackEvent("open_telegram_link", {
+                    url: url
+                });
+                return originalOpenTelegramLink(url);
+            };
+            patchedOpenTelegramLink._dashgramPatched = true;
+            webApp.openTelegramLink = patchedOpenTelegramLink;
+        }
+        if (webApp.switchInlineQuery && typeof webApp.switchInlineQuery === "function") {
+            const originalSwitchInlineQuery = webApp.switchInlineQuery.bind(webApp);
+            const patchedSwitchInlineQuery = (query, chooseChatTypes) => {
+                trackEvent("switch_inline_query", {
+                    query: query,
+                    choose_chat_types: chooseChatTypes
+                });
+                return originalSwitchInlineQuery(query, chooseChatTypes);
+            };
+            patchedSwitchInlineQuery._dashgramPatched = true;
+            webApp.switchInlineQuery = patchedSwitchInlineQuery;
+        }
+        if (webApp.shareToStory && typeof webApp.shareToStory === "function") {
+            const originalShareToStory = webApp.shareToStory.bind(webApp);
+            const patchedShareToStory = (mediaUrl, params) => {
+                trackEvent("share_story", {
+                    media_url: mediaUrl,
+                    params: params
+                });
+                return originalShareToStory(mediaUrl, params);
+            };
+            patchedShareToStory._dashgramPatched = true;
+            webApp.shareToStory = patchedShareToStory;
+        }
+        if (webApp.close && typeof webApp.close === "function") {
+            const originalClose = webApp.close.bind(webApp);
+            const patchedClose = (options) => {
+                trackEvent("webapp_close", {
+                    return_back: options?.return_back
+                });
+                return originalClose(options);
+            };
+            patchedClose._dashgramPatched = true;
+            webApp.close = patchedClose;
+        }
+        if (webApp.exitFullscreen && typeof webApp.exitFullscreen === "function") {
+            const originalExitFullscreen = webApp.exitFullscreen.bind(webApp);
+            const patchedExitFullscreen = () => {
+                trackEvent("webapp_exit_fullscreen", {});
+                return originalExitFullscreen();
+            };
+            patchedExitFullscreen._dashgramPatched = true;
+            webApp.exitFullscreen = patchedExitFullscreen;
+        }
+        if (webApp.openInvoice && typeof webApp.openInvoice === "function") {
+            const originalOpenInvoice = webApp.openInvoice.bind(webApp);
+            const patchedOpenInvoice = (slug, callback) => {
+                trackEvent("open_invoice", {
+                    slug: slug
+                });
+                return originalOpenInvoice(slug, callback);
+            };
+            patchedOpenInvoice._dashgramPatched = true;
+            webApp.openInvoice = patchedOpenInvoice;
+        }
+        if (webApp.requestAccess && typeof webApp.requestAccess === "function") {
+            const originalRequestAccess = webApp.requestAccess.bind(webApp);
+            const patchedRequestAccess = (accessType, callback) => {
+                trackEvent("request_access", {
+                    access_type: accessType
+                });
+                return originalRequestAccess(accessType, callback);
+            };
+            patchedRequestAccess._dashgramPatched = true;
+            webApp.requestAccess = patchedRequestAccess;
+        }
+        if (webApp.requestContact && typeof webApp.requestContact === "function") {
+            const originalRequestContact = webApp.requestContact.bind(webApp);
+            const patchedRequestContact = (callback) => {
+                trackEvent("request_contact", {});
+                return originalRequestContact(callback);
+            };
+            patchedRequestContact._dashgramPatched = true;
+            webApp.requestContact = patchedRequestContact;
+        }
+        if (webApp.requestPhone && typeof webApp.requestPhone === "function") {
+            const originalRequestPhone = webApp.requestPhone.bind(webApp);
+            const patchedRequestPhone = (callback) => {
+                trackEvent("request_phone", {});
+                return originalRequestPhone(callback);
+            };
+            patchedRequestPhone._dashgramPatched = true;
+            webApp.requestPhone = patchedRequestPhone;
+        }
+        if (webApp.requestLocation && typeof webApp.requestLocation === "function") {
+            const originalRequestLocation = webApp.requestLocation.bind(webApp);
+            const patchedRequestLocation = (callback) => {
+                trackEvent("request_location", {});
+                return originalRequestLocation(callback);
+            };
+            patchedRequestLocation._dashgramPatched = true;
+            webApp.requestLocation = patchedRequestLocation;
+        }
+        if (webApp.checkLocation && typeof webApp.checkLocation === "function") {
+            const originalCheckLocation = webApp.checkLocation.bind(webApp);
+            const patchedCheckLocation = (callback) => {
+                trackEvent("check_location", {});
+                return originalCheckLocation(callback);
+            };
+            patchedCheckLocation._dashgramPatched = true;
+            webApp.checkLocation = patchedCheckLocation;
+        }
     }
 }

package/dist/trackers/interaction-tracker.d.ts

@@ -1,17 +1,21 @@
-import { BaseTracker } from './base-tracker';
-import type { Config } from '../core/config';
-import type { TrackCallback } from './base-tracker';
+import { BaseTracker } from "./base-tracker";
+import type { Config } from "../core/config";
+import type { TrackCallback } from "./base-tracker";
 export declare class InteractionTracker extends BaseTracker {
     private unsubscribers;
     private lastPath;
+    private inputValues;
     constructor(config: Config, trackCallback: TrackCallback);
     protected setup(): void;
     protected teardown(): void;
     private trackScreenView;
     private setupHistoryTracking;
     private setupClickTracking;
+    private isExternalLink;
     private setupFormTracking;
     private setupInputTracking;
+    private setupClipboardTracking;
+    private setupSelectionTracking;
     private setupErrorTracking;
 }
 //# sourceMappingURL=interaction-tracker.d.ts.map

package/dist/trackers/interaction-tracker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interaction-tracker.d.ts","sourceRoot":"","sources":["../../src/trackers/interaction-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AASpD,qBAAa,kBAAmB,SAAQ,WAAW;IACjD,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,QAAQ,CAAc;gBAElB,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa;IAIxD,SAAS,CAAC,KAAK,IAAI,IAAI;IAgBvB,SAAS,CAAC,QAAQ,IAAI,IAAI;IAQ1B,OAAO,CAAC,eAAe;IAoBvB,OAAO,CAAC,oBAAoB;IAgC5B,OAAO,CAAC,kBAAkB;IA+B1B,OAAO,CAAC,iBAAiB;IAuBzB,OAAO,CAAC,kBAAkB;IA4B1B,OAAO,CAAC,kBAAkB;CAgC3B"}
+{"version":3,"file":"interaction-tracker.d.ts","sourceRoot":"","sources":["../../src/trackers/interaction-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAUnD,qBAAa,kBAAmB,SAAQ,WAAW;IACjD,OAAO,CAAC,aAAa,CAAqB;IAC1C,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,WAAW,CAAiC;gBAExC,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa;IAIxD,SAAS,CAAC,KAAK,IAAI,IAAI;IAkBvB,SAAS,CAAC,QAAQ,IAAI,IAAI;IAQ1B,OAAO,CAAC,eAAe;IAoBvB,OAAO,CAAC,oBAAoB;IAgC5B,OAAO,CAAC,kBAAkB;IA4C1B,OAAO,CAAC,cAAc;IAYtB,OAAO,CAAC,iBAAiB;IAuBzB,OAAO,CAAC,kBAAkB;IA8D1B,OAAO,CAAC,sBAAsB;IA6C9B,OAAO,CAAC,sBAAsB;IA6B9B,OAAO,CAAC,kBAAkB;CAgC3B"}