@technoapple/ga4 1.0.4 → 1.1.0

package/build/main/plugins/impression-tracker.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImpressionTracker = void 0;
+const dom_ready_1 = require("../helpers/dom-ready");
+/**
+ * Tracks when specific DOM elements become visible in the viewport
+ * using `IntersectionObserver`.
+ *
+ * Useful for tracking ad impressions, CTA visibility, or any
+ * element that enters the user's viewport.
+ */
+class ImpressionTracker {
+    send;
+    rootMargin;
+    attributePrefix;
+    eventName;
+    hitFilter;
+    items = [];
+    elementMap = {};
+    thresholdMap = {};
+    mutationObserver = null;
+    impressedIds = new Set();
+    supported;
+    constructor(send, options) {
+        this.supported =
+            typeof IntersectionObserver !== 'undefined' &&
+                typeof MutationObserver !== 'undefined';
+        this.send = send;
+        this.rootMargin = options?.rootMargin ?? '0px';
+        this.attributePrefix = options?.attributePrefix ?? 'data-ga4-';
+        this.eventName = options?.eventName ?? 'element_impression';
+        this.hitFilter = options?.hitFilter;
+        if (!this.supported)
+            return;
+        this.handleIntersectionChanges = this.handleIntersectionChanges.bind(this);
+        this.handleDomMutations = this.handleDomMutations.bind(this);
+        const elements = options?.elements;
+        (0, dom_ready_1.domReady)(() => {
+            if (elements && elements.length > 0) {
+                this.observeElements(elements);
+            }
+        });
+    }
+    observeElements(elements) {
+        if (!this.supported)
+            return;
+        const newItems = this.normalizeElements(elements);
+        this.items = this.items.concat(newItems);
+        newItems.forEach((item) => {
+            const observer = this.getObserverForThreshold(item.threshold);
+            const element = document.getElementById(item.id);
+            this.elementMap[item.id] = element;
+            if (element) {
+                observer.observe(element);
+            }
+        });
+        if (!this.mutationObserver && document.body) {
+            this.mutationObserver = new MutationObserver(this.handleDomMutations);
+            this.mutationObserver.observe(document.body, {
+                childList: true,
+                subtree: true,
+            });
+        }
+    }
+    unobserveElements(elements) {
+        if (!this.supported)
+            return;
+        const idsToRemove = new Set(elements.map((el) => (typeof el === 'string' ? el : el.id)));
+        this.items = this.items.filter((item) => {
+            if (idsToRemove.has(item.id)) {
+                const element = this.elementMap[item.id];
+                if (element && this.thresholdMap[item.threshold]) {
+                    this.thresholdMap[item.threshold].unobserve(element);
+                }
+                delete this.elementMap[item.id];
+                return false;
+            }
+            return true;
+        });
+        if (this.items.length === 0) {
+            this.disconnectAll();
+        }
+    }
+    unobserveAllElements() {
+        this.disconnectAll();
+        this.items = [];
+        this.elementMap = {};
+    }
+    normalizeElements(elements) {
+        return elements.map((el) => {
+            if (typeof el === 'string') {
+                return { id: el, threshold: 0, trackFirstImpressionOnly: true };
+            }
+            return {
+                id: el.id,
+                threshold: el.threshold ?? 0,
+                trackFirstImpressionOnly: el.trackFirstImpressionOnly ?? true,
+            };
+        });
+    }
+    getObserverForThreshold(threshold) {
+        if (!this.thresholdMap[threshold]) {
+            this.thresholdMap[threshold] = new IntersectionObserver(this.handleIntersectionChanges, {
+                rootMargin: this.rootMargin,
+                threshold: [threshold],
+            });
+        }
+        return this.thresholdMap[threshold];
+    }
+    handleIntersectionChanges(entries) {
+        entries.forEach((entry) => {
+            if (!entry.isIntersecting)
+                return;
+            const id = entry.target.id;
+            if (!id)
+                return;
+            const item = this.items.find((i) => i.id === id);
+            if (!item)
+                return;
+            if (item.trackFirstImpressionOnly && this.impressedIds.has(id))
+                return;
+            this.impressedIds.add(id);
+            const prefix = this.attributePrefix;
+            const attrParams = {};
+            for (let i = 0; i < entry.target.attributes.length; i++) {
+                const attr = entry.target.attributes[i];
+                if (attr.name.startsWith(prefix)) {
+                    const key = attr.name.slice(prefix.length).replace(/-/g, '_');
+                    attrParams[key] = attr.value;
+                }
+            }
+            let params = {
+                element_id: id,
+                ...attrParams,
+            };
+            if (this.hitFilter) {
+                const filtered = this.hitFilter(params, entry.target);
+                if (filtered === null)
+                    return;
+                params = filtered;
+            }
+            this.send(this.eventName, params);
+            if (item.trackFirstImpressionOnly && this.thresholdMap[item.threshold]) {
+                this.thresholdMap[item.threshold].unobserve(entry.target);
+            }
+        });
+    }
+    handleDomMutations(mutations) {
+        mutations.forEach((mutation) => {
+            mutation.addedNodes.forEach((node) => {
+                if (node.nodeType !== Node.ELEMENT_NODE)
+                    return;
+                this.walkNodeTree(node, (id) => {
+                    const element = document.getElementById(id);
+                    if (element) {
+                        this.elementMap[id] = element;
+                        const item = this.items.find((i) => i.id === id);
+                        if (item && this.thresholdMap[item.threshold]) {
+                            this.thresholdMap[item.threshold].observe(element);
+                        }
+                    }
+                });
+            });
+            mutation.removedNodes.forEach((node) => {
+                if (node.nodeType !== Node.ELEMENT_NODE)
+                    return;
+                this.walkNodeTree(node, (id) => {
+                    const element = this.elementMap[id];
+                    if (element) {
+                        const item = this.items.find((i) => i.id === id);
+                        if (item && this.thresholdMap[item.threshold]) {
+                            this.thresholdMap[item.threshold].unobserve(element);
+                        }
+                    }
+                    this.elementMap[id] = null;
+                });
+            });
+        });
+    }
+    walkNodeTree(node, callback) {
+        if (node.id && node.id in this.elementMap) {
+            callback(node.id);
+        }
+        for (let i = 0; i < node.children.length; i++) {
+            this.walkNodeTree(node.children[i], callback);
+        }
+    }
+    disconnectAll() {
+        Object.values(this.thresholdMap).forEach((observer) => observer.disconnect());
+        this.thresholdMap = {};
+        if (this.mutationObserver) {
+            this.mutationObserver.disconnect();
+            this.mutationObserver = null;
+        }
+    }
+    remove() {
+        this.unobserveAllElements();
+        this.impressedIds.clear();
+    }
+}
+exports.ImpressionTracker = ImpressionTracker;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"impression-tracker.js","sourceRoot":"","sources":["../../../src/plugins/impression-tracker.ts"],"names":[],"mappings":"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"}

package/build/main/plugins/index.d.ts

@@ -0,0 +1,8 @@
+export { EventTracker } from './event-tracker';
+export { OutboundLinkTracker } from './outbound-link-tracker';
+export { OutboundFormTracker } from './outbound-form-tracker';
+export { PageVisibilityTracker } from './page-visibility-tracker';
+export { UrlChangeTracker } from './url-change-tracker';
+export { ImpressionTracker } from './impression-tracker';
+export { CleanUrlTracker } from './clean-url-tracker';
+export { MediaQueryTracker } from './media-query-tracker';

package/build/main/plugins/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaQueryTracker = exports.CleanUrlTracker = exports.ImpressionTracker = exports.UrlChangeTracker = exports.PageVisibilityTracker = exports.OutboundFormTracker = exports.OutboundLinkTracker = exports.EventTracker = void 0;
+var event_tracker_1 = require("./event-tracker");
+Object.defineProperty(exports, "EventTracker", { enumerable: true, get: function () { return event_tracker_1.EventTracker; } });
+var outbound_link_tracker_1 = require("./outbound-link-tracker");
+Object.defineProperty(exports, "OutboundLinkTracker", { enumerable: true, get: function () { return outbound_link_tracker_1.OutboundLinkTracker; } });
+var outbound_form_tracker_1 = require("./outbound-form-tracker");
+Object.defineProperty(exports, "OutboundFormTracker", { enumerable: true, get: function () { return outbound_form_tracker_1.OutboundFormTracker; } });
+var page_visibility_tracker_1 = require("./page-visibility-tracker");
+Object.defineProperty(exports, "PageVisibilityTracker", { enumerable: true, get: function () { return page_visibility_tracker_1.PageVisibilityTracker; } });
+var url_change_tracker_1 = require("./url-change-tracker");
+Object.defineProperty(exports, "UrlChangeTracker", { enumerable: true, get: function () { return url_change_tracker_1.UrlChangeTracker; } });
+var impression_tracker_1 = require("./impression-tracker");
+Object.defineProperty(exports, "ImpressionTracker", { enumerable: true, get: function () { return impression_tracker_1.ImpressionTracker; } });
+var clean_url_tracker_1 = require("./clean-url-tracker");
+Object.defineProperty(exports, "CleanUrlTracker", { enumerable: true, get: function () { return clean_url_tracker_1.CleanUrlTracker; } });
+var media_query_tracker_1 = require("./media-query-tracker");
+Object.defineProperty(exports, "MediaQueryTracker", { enumerable: true, get: function () { return media_query_tracker_1.MediaQueryTracker; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcGx1Z2lucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxpREFBK0M7QUFBdEMsNkdBQUEsWUFBWSxPQUFBO0FBQ3JCLGlFQUE4RDtBQUFyRCw0SEFBQSxtQkFBbUIsT0FBQTtBQUM1QixpRUFBOEQ7QUFBckQsNEhBQUEsbUJBQW1CLE9BQUE7QUFDNUIscUVBQWtFO0FBQXpELGdJQUFBLHFCQUFxQixPQUFBO0FBQzlCLDJEQUF3RDtBQUEvQyxzSEFBQSxnQkFBZ0IsT0FBQTtBQUN6QiwyREFBeUQ7QUFBaEQsdUhBQUEsaUJBQWlCLE9BQUE7QUFDMUIseURBQXNEO0FBQTdDLG9IQUFBLGVBQWUsT0FBQTtBQUN4Qiw2REFBMEQ7QUFBakQsd0hBQUEsaUJBQWlCLE9BQUEifQ==

package/build/main/plugins/media-query-tracker.d.ts

@@ -0,0 +1,20 @@
+import { GA4Plugin, SendFunction, MediaQueryTrackerOptions } from '../types/plugins';
+/**
+ * Tracks CSS media query breakpoint matching and changes.
+ *
+ * Fires an event whenever the active breakpoint changes
+ * (e.g. from "mobile" to "desktop"), debounced to avoid
+ * rapid-fire events during window resizing.
+ */
+export declare class MediaQueryTracker implements GA4Plugin {
+    private send;
+    private changeTimeout;
+    private eventName;
+    private changeTemplate?;
+    private hitFilter?;
+    private trackedQueries;
+    private debouncedHandlers;
+    constructor(send: SendFunction, options?: MediaQueryTrackerOptions);
+    private trackDefinition;
+    remove(): void;
+}

package/build/main/plugins/media-query-tracker.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaQueryTracker = void 0;
+const debounce_1 = require("../helpers/debounce");
+function getMatchingValue(definition) {
+    for (const item of definition.items) {
+        if (window.matchMedia(item.media).matches) {
+            return item.name;
+        }
+    }
+    return '(not set)';
+}
+/**
+ * Tracks CSS media query breakpoint matching and changes.
+ *
+ * Fires an event whenever the active breakpoint changes
+ * (e.g. from "mobile" to "desktop"), debounced to avoid
+ * rapid-fire events during window resizing.
+ */
+class MediaQueryTracker {
+    send;
+    changeTimeout;
+    eventName;
+    changeTemplate;
+    hitFilter;
+    trackedQueries = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    debouncedHandlers = [];
+    constructor(send, options) {
+        this.send = send;
+        this.changeTimeout = options?.changeTimeout ?? 1000;
+        this.eventName = options?.eventName ?? 'media_query_change';
+        this.changeTemplate = options?.changeTemplate;
+        this.hitFilter = options?.hitFilter;
+        if (typeof window.matchMedia !== 'function')
+            return;
+        const definitions = options?.definitions ?? [];
+        definitions.forEach((definition) => {
+            this.trackDefinition(definition);
+        });
+    }
+    trackDefinition(definition) {
+        const initialValue = getMatchingValue(definition);
+        definition.items.forEach((item) => {
+            const mql = window.matchMedia(item.media);
+            const debouncedHandler = (0, debounce_1.debounce)(() => {
+                const newValue = getMatchingValue(definition);
+                const tracked = this.trackedQueries.find((tq) => tq.definition === definition);
+                if (!tracked || newValue === tracked.currentValue)
+                    return;
+                const oldValue = tracked.currentValue;
+                tracked.currentValue = newValue;
+                const changeLabel = this.changeTemplate
+                    ? this.changeTemplate(oldValue, newValue)
+                    : `${oldValue} => ${newValue}`;
+                let params = {
+                    media_query_name: definition.name,
+                    media_query_value: newValue,
+                    media_query_change: changeLabel,
+                };
+                if (this.hitFilter) {
+                    const filtered = this.hitFilter(params);
+                    if (filtered === null)
+                        return;
+                    params = filtered;
+                }
+                this.send(this.eventName, params);
+            }, this.changeTimeout);
+            this.debouncedHandlers.push(debouncedHandler);
+            const listener = () => {
+                debouncedHandler();
+            };
+            if (typeof mql.addEventListener === 'function') {
+                mql.addEventListener('change', listener);
+            }
+            this.trackedQueries.push({
+                definition,
+                mql,
+                currentValue: initialValue,
+                listener,
+            });
+        });
+    }
+    remove() {
+        this.trackedQueries.forEach(({ mql, listener }) => {
+            if (typeof mql.removeEventListener === 'function') {
+                mql.removeEventListener('change', listener);
+            }
+        });
+        this.debouncedHandlers.forEach((d) => d.cancel());
+        this.trackedQueries = [];
+        this.debouncedHandlers = [];
+    }
+}
+exports.MediaQueryTracker = MediaQueryTracker;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVkaWEtcXVlcnktdHJhY2tlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wbHVnaW5zL21lZGlhLXF1ZXJ5LXRyYWNrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0Esa0RBQWtFO0FBU2xFLFNBQVMsZ0JBQWdCLENBQUMsVUFBZ0M7SUFDdEQsS0FBSyxNQUFNLElBQUksSUFBSSxVQUFVLENBQUMsS0FBSyxFQUFFO1FBQ2pDLElBQUksTUFBTSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsT0FBTyxFQUFFO1lBQ3ZDLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQztTQUNwQjtLQUNKO0lBQ0QsT0FBTyxXQUFXLENBQUM7QUFDdkIsQ0FBQztBQUVEOzs7Ozs7R0FNRztBQUNILE1BQWEsaUJBQWlCO0lBQ2xCLElBQUksQ0FBZTtJQUNuQixhQUFhLENBQVM7SUFDdEIsU0FBUyxDQUFTO0lBQ2xCLGNBQWMsQ0FBOEM7SUFDNUQsU0FBUyxDQUF5QztJQUNsRCxjQUFjLEdBQW1CLEVBQUUsQ0FBQztJQUM1Qyw4REFBOEQ7SUFDdEQsaUJBQWlCLEdBQTZCLEVBQUUsQ0FBQztJQUV6RCxZQUFZLElBQWtCLEVBQUUsT0FBa0M7UUFDOUQsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7UUFDakIsSUFBSSxDQUFDLGFBQWEsR0FBRyxPQUFPLEVBQUUsYUFBYSxJQUFJLElBQUksQ0FBQztRQUNwRCxJQUFJLENBQUMsU0FBUyxHQUFHLE9BQU8sRUFBRSxTQUFTLElBQUksb0JBQW9CLENBQUM7UUFDNUQsSUFBSSxDQUFDLGNBQWMsR0FBRyxPQUFPLEVBQUUsY0FBYyxDQUFDO1FBQzlDLElBQUksQ0FBQyxTQUFTLEdBQUcsT0FBTyxFQUFFLFNBQVMsQ0FBQztRQUVwQyxJQUFJLE9BQU8sTUFBTSxDQUFDLFVBQVUsS0FBSyxVQUFVO1lBQUUsT0FBTztRQUVwRCxNQUFNLFdBQVcsR0FBRyxPQUFPLEVBQUUsV0FBVyxJQUFJLEVBQUUsQ0FBQztRQUMvQyxXQUFXLENBQUMsT0FBTyxDQUFDLENBQUMsVUFBVSxFQUFFLEVBQUU7WUFDL0IsSUFBSSxDQUFDLGVBQWUsQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUNyQyxDQUFDLENBQUMsQ0FBQztJQUNQLENBQUM7SUFFTyxlQUFlLENBQUMsVUFBZ0M7UUFDcEQsTUFBTSxZQUFZLEdBQUcsZ0JBQWdCLENBQUMsVUFBVSxDQUFDLENBQUM7UUFFbEQsVUFBVSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRTtZQUM5QixNQUFNLEdBQUcsR0FBRyxNQUFNLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUUxQyxNQUFNLGdCQUFnQixHQUFHLElBQUEsbUJBQVEsRUFBQyxHQUFHLEVBQUU7Z0JBQ25DLE1BQU0sUUFBUSxHQUFHLGdCQUFnQixDQUFDLFVBQVUsQ0FBQyxDQUFDO2dCQUM5QyxNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsY0FBYyxDQUFDLElBQUksQ0FDcEMsQ0FBQyxFQUFFLEVBQUUsRUFBRSxDQUFDLEVBQUUsQ0FBQyxVQUFVLEtBQUssVUFBVSxDQUN2QyxDQUFDO2dCQUNGLElBQUksQ0FBQyxPQUFPLElBQUksUUFBUSxLQUFLLE9BQU8sQ0FBQyxZQUFZO29CQUFFLE9BQU87Z0JBRTFELE1BQU0sUUFBUSxHQUFHLE9BQU8sQ0FBQyxZQUFZLENBQUM7Z0JBQ3RDLE9BQU8sQ0FBQyxZQUFZLEdBQUcsUUFBUSxDQUFDO2dCQUVoQyxNQUFNLFdBQVcsR0FBRyxJQUFJLENBQUMsY0FBYztvQkFDbkMsQ0FBQyxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsUUFBUSxFQUFFLFFBQVEsQ0FBQztvQkFDekMsQ0FBQyxDQUFDLEdBQUcsUUFBUSxPQUFPLFFBQVEsRUFBRSxDQUFDO2dCQUVuQyxJQUFJLE1BQU0sR0FBNEI7b0JBQ2xDLGdCQUFnQixFQUFFLFVBQVUsQ0FBQyxJQUFJO29CQUNqQyxpQkFBaUIsRUFBRSxRQUFRO29CQUMzQixrQkFBa0IsRUFBRSxXQUFXO2lCQUNsQyxDQUFDO2dCQUVGLElBQUksSUFBSSxDQUFDLFNBQVMsRUFBRTtvQkFDaEIsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQztvQkFDeEMsSUFBSSxRQUFRLEtBQUssSUFBSTt3QkFBRSxPQUFPO29CQUM5QixNQUFNLEdBQUcsUUFBUSxDQUFDO2lCQUNyQjtnQkFFRCxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsTUFBTSxDQUFDLENBQUM7WUFDdEMsQ0FBQyxFQUFFLElBQUksQ0FBQyxhQUFhLENBQUMsQ0FBQztZQUV2QixJQUFJLENBQUMsaUJBQWlCLENBQUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLENBQUM7WUFFOUMsTUFBTSxRQUFRLEdBQUcsR0FBRyxFQUFFO2dCQUNsQixnQkFBZ0IsRUFBRSxDQUFDO1lBQ3ZCLENBQUMsQ0FBQztZQUVGLElBQUksT0FBTyxHQUFHLENBQUMsZ0JBQWdCLEtBQUssVUFBVSxFQUFFO2dCQUM1QyxHQUFHLENBQUMsZ0JBQWdCLENBQUMsUUFBUSxFQUFFLFFBQVEsQ0FBQyxDQUFDO2FBQzVDO1lBRUQsSUFBSSxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUM7Z0JBQ3JCLFVBQVU7Z0JBQ1YsR0FBRztnQkFDSCxZQUFZLEVBQUUsWUFBWTtnQkFDMUIsUUFBUTthQUNYLENBQUMsQ0FBQztRQUNQLENBQUMsQ0FBQyxDQUFDO0lBQ1AsQ0FBQztJQUVELE1BQU07UUFDRixJQUFJLENBQUMsY0FBYyxDQUFDLE9BQU8sQ0FBQyxDQUFDLEVBQUUsR0FBRyxFQUFFLFFBQVEsRUFBRSxFQUFFLEVBQUU7WUFDOUMsSUFBSSxPQUFPLEdBQUcsQ0FBQyxtQkFBbUIsS0FBSyxVQUFVLEVBQUU7Z0JBQy9DLEdBQUcsQ0FBQyxtQkFBbUIsQ0FBQyxRQUFRLEVBQUUsUUFBUSxDQUFDLENBQUM7YUFDL0M7UUFDTCxDQUFDLENBQUMsQ0FBQztRQUNILElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDO1FBQ2xELElBQUksQ0FBQyxjQUFjLEdBQUcsRUFBRSxDQUFDO1FBQ3pCLElBQUksQ0FBQyxpQkFBaUIsR0FBRyxFQUFFLENBQUM7SUFDaEMsQ0FBQztDQUNKO0FBekZELDhDQXlGQyJ9

package/build/main/plugins/outbound-form-tracker.d.ts

@@ -0,0 +1,17 @@
+import { GA4Plugin, SendFunction, OutboundFormTrackerOptions } from '../types/plugins';
+/**
+ * Automatically tracks form submissions to external domains.
+ *
+ * Sends an event when a form's `action` attribute points to a
+ * different hostname than the current page.
+ */
+export declare class OutboundFormTracker implements GA4Plugin {
+    private delegateHandle;
+    private send;
+    private eventName;
+    private shouldTrackOutboundForm;
+    private hitFilter?;
+    constructor(send: SendFunction, options?: OutboundFormTrackerOptions);
+    private handleFormSubmit;
+    remove(): void;
+}

package/build/main/plugins/outbound-form-tracker.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutboundFormTracker = void 0;
+const delegate_1 = require("../helpers/delegate");
+const parse_url_1 = require("../helpers/parse-url");
+function defaultShouldTrack(form, parseUrlFn) {
+    const action = form.action;
+    if (!action)
+        return false;
+    const url = parseUrlFn(action);
+    return url.hostname !== location.hostname && url.protocol.startsWith('http');
+}
+/**
+ * Automatically tracks form submissions to external domains.
+ *
+ * Sends an event when a form's `action` attribute points to a
+ * different hostname than the current page.
+ */
+class OutboundFormTracker {
+    delegateHandle;
+    send;
+    eventName;
+    shouldTrackOutboundForm;
+    hitFilter;
+    constructor(send, options) {
+        this.send = send;
+        this.eventName = options?.eventName ?? 'outbound_form_submit';
+        this.shouldTrackOutboundForm = options?.shouldTrackOutboundForm ?? defaultShouldTrack;
+        this.hitFilter = options?.hitFilter;
+        const formSelector = options?.formSelector ?? 'form';
+        this.delegateHandle = (0, delegate_1.delegate)(document, 'submit', formSelector, (event, element) => this.handleFormSubmit(event, element), { composed: true, useCapture: true });
+    }
+    handleFormSubmit(event, form) {
+        if (!this.shouldTrackOutboundForm(form, parse_url_1.parseUrl))
+            return;
+        const url = (0, parse_url_1.parseUrl)(form.action);
+        let params = {
+            form_action: url.href,
+            form_domain: url.hostname,
+            outbound: true,
+        };
+        if (this.hitFilter) {
+            const filtered = this.hitFilter(params, form, event);
+            if (filtered === null)
+                return;
+            params = filtered;
+        }
+        this.send(this.eventName, params);
+    }
+    remove() {
+        this.delegateHandle.destroy();
+    }
+}
+exports.OutboundFormTracker = OutboundFormTracker;
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/plugins/outbound-link-tracker.d.ts

@@ -0,0 +1,19 @@
+import { GA4Plugin, SendFunction, OutboundLinkTrackerOptions } from '../types/plugins';
+/**
+ * Automatically tracks clicks on outbound links (links to external domains).
+ *
+ * Sends an event when a user clicks a link whose hostname differs
+ * from the current page's hostname.
+ */
+export declare class OutboundLinkTracker implements GA4Plugin {
+    private delegates;
+    private send;
+    private events;
+    private linkSelector;
+    private eventName;
+    private shouldTrackOutboundLink;
+    private hitFilter?;
+    constructor(send: SendFunction, options?: OutboundLinkTrackerOptions);
+    private handleLinkInteraction;
+    remove(): void;
+}

package/build/main/plugins/outbound-link-tracker.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutboundLinkTracker = void 0;
+const delegate_1 = require("../helpers/delegate");
+const parse_url_1 = require("../helpers/parse-url");
+function defaultShouldTrack(link, parseUrlFn) {
+    const href = link.getAttribute('href') || link.getAttribute('xlink:href');
+    if (!href)
+        return false;
+    const url = parseUrlFn(href);
+    return url.hostname !== location.hostname && url.protocol.startsWith('http');
+}
+/**
+ * Automatically tracks clicks on outbound links (links to external domains).
+ *
+ * Sends an event when a user clicks a link whose hostname differs
+ * from the current page's hostname.
+ */
+class OutboundLinkTracker {
+    delegates = [];
+    send;
+    events;
+    linkSelector;
+    eventName;
+    shouldTrackOutboundLink;
+    hitFilter;
+    constructor(send, options) {
+        this.send = send;
+        this.events = options?.events ?? ['click'];
+        this.linkSelector = options?.linkSelector ?? 'a, area';
+        this.eventName = options?.eventName ?? 'outbound_link_click';
+        this.shouldTrackOutboundLink = options?.shouldTrackOutboundLink ?? defaultShouldTrack;
+        this.hitFilter = options?.hitFilter;
+        this.events.forEach((eventType) => {
+            const handle = (0, delegate_1.delegate)(document, eventType, this.linkSelector, (event, element) => this.handleLinkInteraction(event, element), { composed: true, useCapture: true });
+            this.delegates.push(handle);
+        });
+    }
+    handleLinkInteraction(event, element) {
+        if (!this.shouldTrackOutboundLink(element, parse_url_1.parseUrl))
+            return;
+        const href = element.getAttribute('href') || element.getAttribute('xlink:href') || '';
+        const url = (0, parse_url_1.parseUrl)(href);
+        let params = {
+            link_url: url.href,
+            link_domain: url.hostname,
+            outbound: true,
+        };
+        if (this.hitFilter) {
+            const filtered = this.hitFilter(params, element, event);
+            if (filtered === null)
+                return;
+            params = filtered;
+        }
+        this.send(this.eventName, params);
+    }
+    remove() {
+        this.delegates.forEach((d) => d.destroy());
+        this.delegates = [];
+    }
+}
+exports.OutboundLinkTracker = OutboundLinkTracker;
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/plugins/page-visibility-tracker.d.ts

@@ -0,0 +1,24 @@
+import { GA4Plugin, SendFunction, PageVisibilityTrackerOptions } from '../types/plugins';
+/**
+ * Tracks how long a page is in the visible state vs. hidden (background tab).
+ *
+ * Sends a `page_visibility` event each time the visibility state changes,
+ * reporting how long the page was in the previous state.
+ * Optionally sends a new `page_view` when the page becomes visible
+ * again after the session timeout has elapsed.
+ */
+export declare class PageVisibilityTracker implements GA4Plugin {
+    private send;
+    private sendInitialPageview;
+    private sessionTimeout;
+    private eventName;
+    private hitFilter?;
+    private lastChangeTime;
+    private isVisible;
+    private boundVisibilityChange;
+    private boundBeforeUnload;
+    constructor(send: SendFunction, options?: PageVisibilityTrackerOptions);
+    private onVisibilityChange;
+    private onBeforeUnload;
+    remove(): void;
+}