@guardian/ophan-tracker-js 2.1.1 → 2.1.2-next.1

package/NPM-dist/tests/core.test.js

@@ -0,0 +1,161 @@
+import { _testExports } from '../core.js';
+import transmit from '../transmit';
+const mockSendMore = jest.fn();
+transmit.sendMore = mockSendMore;
+const { getQueryParameterValue, appendComponentDataToEvent, trimComponentNamesToUrlSafeLength, onLoadCapture, onLoadCaptures, processCaptures, appendContentType, } = _testExports;
+describe('appendComponentDataToEvent', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should append unique, trimmed component names to event', () => {
+        document.querySelectorAll = jest.fn().mockReturnValue([
+            {
+                getAttribute: () => 'longComponentNameThatExceedsLimit................................................',
+            },
+            { getAttribute: () => 'shortName' },
+            {
+                getAttribute: () => 'longComponentNameThatExceedsLimit................................................',
+            },
+        ]);
+        const event = {};
+        appendComponentDataToEvent(event);
+        expect(document.querySelectorAll).toHaveBeenCalledWith('[data-component]');
+        const expectedTrimmedNames = [
+            'longComponentNameThatExceedsLimit.................…',
+            'shortName',
+        ];
+        expect(event.renderedComponents).toEqual(expectedTrimmedNames);
+    });
+    it('should not modify event if no components are found', () => {
+        document.querySelectorAll = jest.fn().mockReturnValue([]);
+        const event = {};
+        appendComponentDataToEvent(event);
+        expect(event).not.toHaveProperty('renderedComponents');
+    });
+    it('should correctly trim component names exceeding maximum length', () => {
+        const componentNames = [
+            'veryLongComponentName................................................',
+            'shortName',
+        ];
+        const trimmedNames = trimComponentNamesToUrlSafeLength(componentNames);
+        expect(trimmedNames).toEqual([
+            'veryLongComponentName.............................…',
+            'shortName',
+        ]);
+    });
+});
+describe('getQueryParameterValue', () => {
+    const originalLocation = window.location;
+    beforeEach(() => {
+        delete window.location;
+        window.location = { search: '' };
+    });
+    afterEach(() => {
+        window.location = originalLocation;
+    });
+    it('should return the value of a given query parameter', () => {
+        window.location.search = '?param1=value1&param2=value2';
+        const value = getQueryParameterValue('param1');
+        expect(value).toBe('value1');
+    });
+    it('should return undefined if the parameter is not found', () => {
+        window.location.search = '?param1=value1&param2=value2';
+        const value = getQueryParameterValue('param3');
+        expect(value).toBeUndefined();
+    });
+    it('should correctly decode URI-encoded values', () => {
+        window.location.search = '?param=encoded%20value';
+        const value = getQueryParameterValue('param');
+        expect(value).toBe('encoded value');
+    });
+    it('should handle cases where the query string is empty', () => {
+        window.location.search = '';
+        const value = getQueryParameterValue('param');
+        expect(value).toBeUndefined();
+    });
+});
+describe('onLoadCapture', () => {
+    beforeEach(() => {
+        Object.defineProperty(document, 'readyState', {
+            configurable: true,
+            get() {
+                return this._readyState;
+            },
+            set(value) {
+                this._readyState = value;
+            },
+        });
+        document.readyState = 'loading';
+        onLoadCaptures.length = 0;
+        jest.clearAllMocks();
+    });
+    it('should add dataCapture to onLoadCaptures if document is not ready', () => {
+        const dataCapture = jest.fn();
+        onLoadCapture(dataCapture);
+        expect(onLoadCaptures).toContain(dataCapture);
+    });
+    it('should call dataCapture and sendMore if document is ready', () => {
+        document.readyState = 'complete';
+        const dataCapture = jest.fn().mockReturnValue({
+            performance: {
+                dns: 50,
+                connection: 100,
+                firstByte: 200,
+                lastByte: 300,
+                domContentLoadedEvent: 400,
+                loadEvent: 500,
+                navType: 1,
+                redirectCount: 2
+            }
+        });
+        onLoadCapture(dataCapture);
+        expect(dataCapture).toHaveBeenCalled();
+        expect(transmit.sendMore).toHaveBeenCalledWith({
+            performance: {
+                dns: 50,
+                connection: 100,
+                firstByte: 200,
+                lastByte: 300,
+                domContentLoadedEvent: 400,
+                loadEvent: 500,
+                navType: 1,
+                redirectCount: 2
+            }
+        });
+    });
+});
+describe('processCaptures', () => {
+    beforeEach(() => {
+        onLoadCaptures.length = 0;
+        jest.clearAllMocks();
+    });
+    it('should call all dataCaptures and merge their output into the sendMore function', () => {
+        onLoadCaptures.push(() => ({ performance: { domContentLoadedEvent: 400, loadEvent: 500 } }));
+        processCaptures();
+        expect(transmit.sendMore).toHaveBeenCalledWith({
+            performance: {
+                domContentLoadedEvent: 400,
+                loadEvent: 500
+            }
+        });
+    });
+});
+describe('appendContentType', () => {
+    it('should set the lowercase content type for next-gen platform', () => {
+        const event = {};
+        const guardian = { config: { page: { contentType: 'Article' } } };
+        appendContentType(event, 'next-gen', guardian);
+        expect(event.contentType).toBe('article');
+    });
+    it('should set the lowercase content type for other platforms', () => {
+        const event = {};
+        const guardian = { page: { contentTypes: 'LiveBlog' } };
+        appendContentType(event, 'other', guardian);
+        expect(event.contentType).toBe('liveblog');
+    });
+    it('should not set content type if it is not available', () => {
+        const event = {};
+        appendContentType(event, 'next-gen', {});
+        expect(event.contentType).toBeUndefined();
+    });
+});

package/NPM-dist/tests/heatmap.test.js

@@ -0,0 +1,45 @@
+"use strict";
+describe('Heatmap init', () => {
+    beforeEach(() => {
+        jest.resetModules();
+    });
+    it('should load the heatmap based on a query param', () => {
+        const heatmap = require('../heatmap.js').default;
+        const scriptSrc = '//dashboard.ophan.co.uk/assets/js/heatmap-bookmarklet.js';
+        Object.defineProperty(window, 'location', {
+            value: new URL('https://www.theguardian.com/uk?heatmap=show'),
+            writable: true,
+        });
+        heatmap.init();
+        const scripts = document.getElementsByTagName("script");
+        let heatmapScript = Array.from(scripts).find(item => item.src.endsWith(scriptSrc));
+        expect(heatmapScript).not.toBeNull();
+    });
+    it('should load the heatmap script once', () => {
+        const heatmap = require('../heatmap.js').default;
+        const scriptSrc = '//dashboard.ophan.co.uk/assets/js/react/heatphan/index.js';
+        Object.defineProperty(window, 'location', {
+            value: new URL('https://www.theguardian.com/uk?heatmap=experimental'),
+            writable: true,
+        });
+        for (let i = 0; i < 10; i++) {
+            heatmap.init();
+        }
+        const scripts = document.getElementsByTagName("script");
+        let heatmapScript = Array.from(scripts).filter(item => item.src.endsWith(scriptSrc));
+        expect(heatmapScript.length).toBe(1);
+        expect(heatmapScript[0]).not.toBeNull();
+    });
+    it('should load heatphan based on a query param', () => {
+        const heatmap = require('../heatmap.js').default;
+        const scriptSrc = '//dashboard.ophan.co.uk/assets/js/react/heatphan/index.js';
+        Object.defineProperty(window, 'location', {
+            value: new URL('https://www.theguardian.com/uk?heatmap=experimental'),
+            writable: true,
+        });
+        heatmap.init();
+        const scripts = document.getElementsByTagName("script");
+        let heatmapScript = Array.from(scripts).find(item => item.src.endsWith(scriptSrc));
+        expect(heatmapScript).not.toBeNull();
+    });
+});

package/NPM-dist/tests/transmit.test.js

@@ -0,0 +1,118 @@
+global.ophanRemoteHost = 'https://ophan.theguardian.com';
+global.fetch = jest.fn(() => Promise.resolve({
+    json: () => Promise.resolve({}),
+}));
+beforeEach(() => {
+    fetch.mockClear();
+});
+import transmit, { _testExports } from "../transmit";
+const { smartEncode, isDefined, buildQueryString, generatePageViewId } = _testExports;
+describe('generatePageViewId', () => {
+    it('generates a viewId of correct length', () => {
+        const viewId = generatePageViewId();
+        expect(typeof viewId).toBe('string');
+        expect(viewId.length).toBe(20);
+    });
+});
+describe('smartEncode', () => {
+    it('encodes strings correctly', () => {
+        expect(smartEncode('test string')).toBe(encodeURIComponent('test string'));
+    });
+    it('encodes numbers correctly', () => {
+        expect(smartEncode(123)).toBe(encodeURIComponent(123));
+    });
+    it('encodes objects correctly', () => {
+        const obj = { a: 1, b: 'test' };
+        expect(smartEncode(obj)).toBe(encodeURIComponent(JSON.stringify(obj)));
+    });
+});
+describe('isDefined', () => {
+    it('returns true for non-null values', () => {
+        expect(isDefined(123)).toBe(true);
+        expect(isDefined('test')).toBe(true);
+        expect(isDefined([1])).toBe(true);
+    });
+    it('returns false for null or undefined values', () => {
+        expect(isDefined(null)).toBeFalsy();
+        expect(isDefined(undefined)).toBeFalsy();
+    });
+    it('returns false for empty arrays', () => {
+        expect(isDefined([])).toBeFalsy();
+    });
+});
+describe('buildQueryString', () => {
+    it('should build a query string from an object', () => {
+        const obj = {
+            "v": "17",
+            "platform": "next-gen",
+            "url": "https://www.theguardian.com/commentisfree/2024/jan/04/luke-littler-darts-championship-pdc-british-sport",
+            "ref": "",
+            "visibilityState": "visible",
+            "tz": "0",
+            "navigationType": "reload",
+            "contentType": "article",
+            "viewId": "lqz6au1wqb9mwq92w4zh",
+        };
+        const queryString = buildQueryString(obj);
+        expect(queryString).toContain(`v=17&platform=next-gen&url=https%3A%2F%2Fwww.theguardian.com%2Fcommentisfree%2F2024%2Fjan%2F04%2Fluke-littler-darts-championship-pdc-british-sport&ref=&visibilityState=visible&tz=0&navigationType=reload&contentType=article`);
+    });
+    it('should ignore null and undefined values', () => {
+        const obj = {
+            "v": "17",
+            "platform": "next-gen",
+            "url": "https://www.theguardian.com/commentisfree/2024/jan/04/luke-littler-darts-championship-pdc-british-sport",
+            "ref": "",
+            "visibilityState": "visible",
+            "tz": "0",
+            "navigationType": "reload",
+            "contentType": "article",
+            "viewId": "lqz6au1wqb9mwq92w4zh",
+            "nullValue": null
+        };
+        const queryString = buildQueryString(obj);
+        expect(queryString).toContain(`v=17&platform=next-gen&url=https%3A%2F%2Fwww.theguardian.com%2Fcommentisfree%2F2024%2Fjan%2F04%2Fluke-littler-darts-championship-pdc-british-sport&ref=&visibilityState=visible&tz=0&navigationType=reload&contentType=article`);
+        expect(queryString).not.toContain(`nullValue`);
+    });
+});
+describe('sendMore', () => {
+    it('should call send with correct URL and callback', async () => {
+        const obj = {
+            "componentEvent": {
+                "component": {
+                    "componentType": "ACQUISITIONS_ENGAGEMENT_BANNER",
+                    "products": [],
+                    "campaignCode": "2023-12-19_EOY_ANNUAL_PUSH__BANNER_V2",
+                    "id": "designable-banner : close",
+                    "labels": []
+                },
+                "abTest": {
+                    "name": "2023-12-19_EOY_ANNUAL_PUSH__BANNER",
+                    "variant": "V2"
+                },
+                "action": "CLICK"
+            }
+        };
+        const callback = jest.fn();
+        await transmit.sendMore(obj, callback);
+        // Access the first argument (the URL) of the first call to fetch
+        const calledUrl = fetch.mock.calls[0][0];
+        expect(calledUrl).toContain('ACQUISITIONS_ENGAGEMENT_BANNER');
+        expect(calledUrl).toContain('2023-12-19_EOY_ANNUAL_PUSH__BANNER_V2');
+        expect(calledUrl).toContain('CLICK');
+        expect(callback).toHaveBeenCalled();
+    });
+    it('should not call send if object has no defined properties', () => {
+        const obj = { key1: undefined, key2: null };
+        const callback = jest.fn();
+        transmit.sendMore(obj, callback);
+        expect(fetch).not.toHaveBeenCalled();
+        expect(callback).not.toHaveBeenCalled();
+    });
+    it('should not call send if object is empty', () => {
+        const obj = {};
+        const callback = jest.fn();
+        transmit.sendMore(obj, callback);
+        expect(fetch).not.toHaveBeenCalled();
+        expect(callback).not.toHaveBeenCalled();
+    });
+});

package/NPM-dist/transmit.js

@@ -0,0 +1,126 @@
+const ophanRemoteHost = window?.ophanRemoteHost || 'https://ophan.theguardian.com';
+/**
+ * Generates a unique page view ID.
+ * @returns {string}
+ */
+const generatePageViewId = () => {
+    return `${new Date().getTime().toString(36)}${'xxxxxxxxxxxx'.replace(/x/g, () => Math.floor(Math.random() * 36).toString(36))}`;
+};
+// Guardian Frontend Project pre-generates the pageViewId
+let viewId;
+if (typeof guardian !== 'undefined') {
+    viewId = guardian.config?.ophan?.pageViewId ?? generatePageViewId();
+}
+else {
+    viewId = generatePageViewId();
+}
+const bumpViewId = () => {
+    viewId = generatePageViewId();
+};
+/**
+ * Sends the initial event associated with this page view.
+ * @param {Record<string, any>} obj - The data to be sent.
+ */
+const sendInitial = (obj) => {
+    send(`${ophanRemoteHost}/img/1?${buildQueryString(obj)}`);
+};
+/**
+ * Encodes a value for URL transmission.
+ * @param {string | number} value - The value to encode.
+ * @returns {string} The encoded value.
+ */
+const smartEncode = (value) => {
+    if (typeof value === 'string' || typeof value === 'number') {
+        return encodeURIComponent(value);
+    }
+    else {
+        return encodeURIComponent(JSON.stringify(value));
+    }
+};
+/**
+ * Used for sending additional events after the initial PageView event.
+ * @param {EventPayload} obj - The data object to be sent.
+ * @param {Function} [f] - An optional callback function.
+ */
+const sendMore = (obj, f) => {
+    if (!JSON)
+        return;
+    const values = [];
+    for (const prop in obj) {
+        // @ts-ignore
+        if (obj.hasOwnProperty(prop) && isDefined(obj[prop])) {
+            // @ts-ignore
+            values.push(`${encodeURIComponent(prop)}=${smartEncode(obj[prop])}`);
+        }
+    }
+    if (values.length === 0) {
+        return;
+    }
+    const url = `${ophanRemoteHost}/img/2?viewId=${viewId}&${values.join('&')}`;
+    send(url, f);
+};
+/**
+ * Checks if a value is defined and not null.
+ * @param {*} v - The value to check.
+ * @returns {boolean} True if the value is defined, false otherwise.
+ */
+const isDefined = (v) => {
+    if (Array.isArray(v)) {
+        return !!v.length;
+    }
+    else {
+        return v != null;
+    }
+};
+/**
+ * Builds a query string from an object.
+ * @param {Record<string, any>} obj - The object to convert to a query string.
+ * @returns {string} The resulting query string.
+ */
+const buildQueryString = (obj) => {
+    obj.viewId = viewId;
+    const values = [];
+    for (const prop in obj) {
+        if (obj.hasOwnProperty(prop) && obj[prop] != null) {
+            values.push(`${encodeURIComponent(prop)}=${encodeURIComponent(obj[prop])}`);
+        }
+    }
+    return values.join('&');
+};
+/**
+ * Sends data to a specified URL.
+ * @param {string} url - The URL to send data to.
+ * @param {() => void} [f] - An optional callback function.
+ */
+const send = (url, f) => {
+    if (typeof fetch === 'function') {
+        fetch(url, { method: 'GET', mode: 'no-cors', keepalive: true, credentials: 'include' }).then(() => f?.());
+    }
+    else {
+        const image = new Image();
+        const checker = setInterval(() => {
+            if (image.complete) {
+                if (typeof f === 'function') {
+                    f();
+                }
+                clearInterval(checker);
+            }
+        }, 10);
+        image.src = url;
+    }
+};
+export default {
+    sendInitial,
+    sendMore,
+    viewId,
+    bumpViewId,
+};
+/**
+ * Exports for testing purposes.
+ */
+export const _testExports = {
+    generatePageViewId,
+    smartEncode,
+    isDefined,
+    buildQueryString,
+};

package/NPM-dist/types/abtest.js

@@ -0,0 +1 @@
+export {};

package/NPM-dist/types/acquisition.js

@@ -0,0 +1 @@
+export {};

package/NPM-dist/types/adblock-detection.d.ts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function run(): Promise<any>;
+}
+export default _default;

package/NPM-dist/types/attention.d.ts

@@ -0,0 +1,9 @@
+declare namespace _default {
+    export { initAttention as init };
+    export { initComponent };
+    export { setEventEmitter };
+}
+export default _default;
+declare function initAttention(visibility: any): void;
+declare function initComponent(name: any, el: any, visibilityThreshold?: number): void;
+declare function setEventEmitter(emitter: any): void;

package/NPM-dist/types/campaign.d.ts

@@ -0,0 +1 @@
+export {};

package/NPM-dist/types/click-path-capture.d.ts

@@ -0,0 +1,14 @@
+export function validAncestorAnchorElement(el: Element): Element | null;
+export function getContainingComponent(el: Element): string | null;
+declare namespace _default {
+    export { getDataLinkNames };
+}
+export default _default;
+/**
+ * Collects all `data-link-name` attribute values from the ancestor elements.
+ *
+ * @param {Element} el - The element to start searching from.
+ * @param {string[]} dataLinkNames - Initial array of data link names (optional).
+ * @returns {string[]} Array of `data-link-name` values.
+ */
+declare function getDataLinkNames(el: Element, dataLinkNames?: string[]): string[];

package/NPM-dist/types/component-event.js

@@ -0,0 +1 @@
+export {};

package/NPM-dist/types/component-type.js

@@ -0,0 +1 @@
+export {};

package/NPM-dist/types/components.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @type {Component[]}
+ */
+export const components: Component[];
+declare namespace _default {
+    export function setEventEmitter(emitter: Object): Object;
+    export { startMonitoring };
+    export { stopMonitoring };
+    export { getAttentionTimes };
+    export let registerComponent: (...args: [name: string, element: HTMLElement, visibilityThreshold1: number, reportingInterval1: number]) => void;
+}
+export default _default;
+declare class Component {
+    /**
+     * Component constructor.
+     * @param {string} name - The name of the component.
+     * @param {HTMLElement} element - The DOM element of the component.
+     * @param {number} visibilityThreshold1 -
+     *    visibilityThreshold represents the fraction of each component that must
+     *    be in the viewport before it is considered visible.
+     *    e.g. 0.5 means that half the height or width must be in the viewport
+     *    1 means that the entire element must be in the viewport
+     * @param {number} reportingInterval1 - ??
+     */
+    constructor(name: string, element: HTMLElement, visibilityThreshold1: number, reportingInterval1: number);
+    name: string;
+    element: HTMLElement;
+    visibilityThreshold: number;
+    reportingInterval: number;
+    visible: boolean;
+    totalAttentionMs: number;
+    unrecordedAttentionStarted: number | null;
+    reportedTotalAttentionMs: number;
+    usingEmitter: boolean;
+    visCheck: () => number | null | undefined;
+    isVisible(threshold?: number): boolean;
+    visibilityHasChanged(): boolean;
+    rebindToEventEmitter(): any;
+    checkVisibility(): number | null | undefined;
+    makeActive(): number;
+    makeInactive(): null;
+    hadAttentionSinceLastGet(): boolean;
+    getAttentionTime(): number;
+    incrementTotalAttentionTimeByUnrecordedAmount(): number | undefined;
+}
+/**
+ * Begins monitoring the components on the page for attention time.
+ * @returns {Array} Array of results from makeActive() for each visible component.
+ */
+declare function startMonitoring(): any[];
+/**
+ * Stops monitoring the components on the page for attention time.
+ * @returns {Array} Array of results from makeInactive() for each component.
+ */
+declare function stopMonitoring(): any[];
+/**
+ * Retrieves the attention times for all components.
+ * @returns {Object}
+ */
+declare function getAttentionTimes(): Object;

package/NPM-dist/types/consent.js

@@ -0,0 +1 @@
+export {};

package/NPM-dist/types/contribution.d.ts

@@ -0,0 +1,5 @@
+declare namespace _default {
+    let record: (obj: import("./ng.js").EventPayload, f?: (() => void) | undefined) => void;
+    let viewId: string;
+}
+export default _default;

package/NPM-dist/types/core.d.ts

@@ -0,0 +1,64 @@
+declare namespace _default {
+    export { init };
+    export { storeDataToSendOnNextEvent };
+    export { onLoadCapture };
+    export function servingPlatform(): any;
+    export let viewId: string;
+    export { sendInitialEvent };
+}
+export default _default;
+export namespace _testExports {
+    export { appendComponentDataToEvent };
+    export { trimComponentNamesToUrlSafeLength };
+    export { getQueryParameterValue };
+    export { onLoadCaptures };
+    export { onLoadCapture };
+    export { processCaptures };
+    export { appendContentType };
+}
+declare let init: any;
+declare let storeDataToSendOnNextEvent: any;
+/**
+ * Registers a data capture function to be called when the document is fully loaded.
+ * The result of this function is then sent to the tracker backend service.
+ * If the document is already loaded, this is done immediately.
+ *
+ * @param {() => Record<string, unknown>} dataCapture - A function that returns an object containing performance metrics such as page load time, network latency, etc.
+ * Refer to the `perf.js` file where this function is used for more info.
+ */
+declare function onLoadCapture(dataCapture: () => Record<string, unknown>): void;
+declare let sendInitialEvent: any;
+/**
+ * Appends data about rendered components to an event object.
+ * Extracts component names from elements with a 'data-component' attribute, trims them for URL safety, ensures uniqueness, and adds them to the event.
+ * @param {Object} event - The event object to which component data will be appended.
+ */
+declare function appendComponentDataToEvent(event: Object): void;
+/**
+ * Trims component names to a maximum length to ensure they are URL safe.
+ * If a component name exceeds the maximum length, it is truncated and appended with an ellipsis.
+ * @param {string[]} componentNames - An array of component names.
+ * @returns {string[]} An array of trimmed component names.
+ */
+declare function trimComponentNamesToUrlSafeLength(componentNames: string[]): string[];
+/**
+ * Retrieves the value of a specified query parameter from the current page's URL.
+ * Using an old-fashioned way of finding a query param rather than using searchParams
+ * as we don't control which environments the CDN distribution is being used in and so don't know if it's supported.
+ * @param {string} paramName - The name of the query parameter to retrieve.
+ * @returns {string | undefined} The value of the query parameter, or undefined if not found.
+ */
+declare function getQueryParameterValue(paramName: string): string | undefined;
+declare const onLoadCaptures: any[];
+/**
+ * Processes all registered data capture functions, merges their outputs and sends it to the tracker backend service.
+ * If on a 'next-gen' platform, additional component data is appended to the event via the `appendComponentDataToEvent` function.
+ */
+declare function processCaptures(): void;
+/**
+ * Determines the 'content type' based on the platform and guardian object.
+ * @param {Record<string, unknown>} event - The event object that will be updated with contentType.
+ * @param {string} platform - The current platform ('next-gen', 'embed' or other).
+ * @param {Record<string, unknown>} guardian - The guardian object.
+ */
+declare function appendContentType(event: Record<string, unknown>, platform: string, guardian: Record<string, unknown>): void;

package/NPM-dist/types/embed.d.ts

@@ -0,0 +1,5 @@
+declare namespace _default {
+    let record: (obj: import("./ng.js").EventPayload, f?: (() => void) | undefined) => void;
+    let viewId: string;
+}
+export default _default;

package/NPM-dist/types/event.js

@@ -0,0 +1 @@
+export {};

package/NPM-dist/types/fb-instant.d.ts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    let viewId: string;
+}
+export default _default;

package/NPM-dist/types/heatmap.d.ts

@@ -0,0 +1,5 @@
+declare namespace _default {
+    export { init };
+}
+export default _default;
+declare function init(): void | "//dashboard.ophan.co.uk/assets/js/react/heatphan/index.js" | "//dashboard.ophan.co.uk/assets/js/heatmap-bookmarklet.js";

package/NPM-dist/types/holidays.d.ts

@@ -0,0 +1,5 @@
+declare namespace _default {
+    let record: (obj: import("./ng.js").EventPayload, f?: (() => void) | undefined) => void;
+    let viewId: string;
+}
+export default _default;

package/NPM-dist/types/http-status.d.ts

@@ -0,0 +1,5 @@
+declare namespace _default {
+    export { reportStatus };
+}
+export default _default;
+declare function reportStatus(platform: any, status: any): any;

package/NPM-dist/types/iframe-tracking.d.ts

@@ -0,0 +1 @@
+export {};