@times-components/ts-components 1.140.5 → 1.141.0

package/dist/helpers/algolia/__tests__/conversionEvent.test.js

@@ -0,0 +1,388 @@
+const mockAa = jest.fn();
+jest.mock('search-insights', () => mockAa);
+global.aa = mockAa;
+import { sanitizeEventName, sendAlgoliaConversionEvent, trackAlgoliaConversionWithDwellTime, getValidConversionData } from '../conversionEvent';
+const mockLocalStorage = {
+    getItem: jest.fn(),
+    setItem: jest.fn(),
+    removeItem: jest.fn(),
+    clear: jest.fn()
+};
+Object.defineProperty(window, 'localStorage', {
+    value: mockLocalStorage,
+    writable: true
+});
+Object.defineProperty(document, 'hidden', {
+    value: false,
+    writable: true
+});
+Object.defineProperty(document, 'addEventListener', {
+    value: jest.fn(),
+    writable: true
+});
+Object.defineProperty(window, 'addEventListener', {
+    value: jest.fn(),
+    writable: true
+});
+// Mock window.location.pathname
+Object.defineProperty(window, 'location', {
+    value: {
+        pathname: '/current-article-path'
+    },
+    writable: true
+});
+describe('Algolia Conversion Event Helpers', () => {
+    const validConversionData = {
+        eventName: 'Test Event',
+        queryID: 'test-query-456',
+        objectID: 'test-object-123',
+        indexName: 'test-index',
+        applicationId: 'test-app-id',
+        apiKey: 'test-api-key',
+        timestamp: 1000000000000,
+        articleUrl: '/current-article-path'
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockLocalStorage.getItem.mockClear();
+        mockLocalStorage.setItem.mockClear();
+        mockLocalStorage.removeItem.mockClear();
+        mockAa.mockClear();
+        document.addEventListener.mockClear();
+        window.addEventListener.mockClear();
+    });
+    describe('sanitizeEventName', () => {
+        it('should return the original string if it contains only visible ASCII characters and is under 64 characters', () => {
+            const input = 'Valid Event Name 123!@#$%^&*()';
+            const result = sanitizeEventName(input);
+            expect(result).toBe(input);
+        });
+        it('should remove non-visible ASCII characters', () => {
+            const input = 'Event\u0000Name\u001F\u007F\u0080';
+            const result = sanitizeEventName(input);
+            expect(result).toBe('EventName');
+        });
+        it('should truncate strings longer than 64 characters and add ellipsis', () => {
+            const input = 'A'.repeat(70);
+            const result = sanitizeEventName(input);
+            expect(result).toBe('A'.repeat(60) + '...');
+            expect(result.length).toBe(63);
+        });
+        it('should handle exactly 64 characters without truncation', () => {
+            const input = 'A'.repeat(64);
+            const result = sanitizeEventName(input);
+            expect(result).toBe(input);
+            expect(result.length).toBe(64);
+        });
+        it('should handle empty string', () => {
+            const result = sanitizeEventName('');
+            expect(result).toBe('');
+        });
+        it('should handle string with only non-visible characters', () => {
+            const input = '\u0000\u001F\u007F';
+            const result = sanitizeEventName(input);
+            expect(result).toBe('');
+        });
+        it('should handle mixed visible and non-visible characters that exceed 64 chars after cleaning', () => {
+            const input = 'Valid'.repeat(15) + '\u0000\u001F';
+            const result = sanitizeEventName(input);
+            expect(result).toBe('Valid'.repeat(12) + '...');
+        });
+    });
+    describe('sendAlgoliaConversionEvent', () => {
+        it('should call aa with correct parameters when all required fields are provided', () => {
+            const params = {
+                eventName: 'Test Event',
+                objectID: 'test-object-123',
+                queryID: 'test-query-456',
+                indexName: 'test-index'
+            };
+            sendAlgoliaConversionEvent(params);
+            expect(mockAa).toHaveBeenCalledWith('convertedObjectIDsAfterSearch', {
+                eventName: 'Test Event',
+                index: 'test-index',
+                queryID: 'test-query-456',
+                objectIDs: ['test-object-123']
+            });
+        });
+        it('should sanitize event name before sending', () => {
+            const params = {
+                eventName: 'Test\u0000Event\u001F',
+                objectID: 'test-object-123',
+                queryID: 'test-query-456',
+                indexName: 'test-index'
+            };
+            sendAlgoliaConversionEvent(params);
+            expect(mockAa).toHaveBeenCalledWith('convertedObjectIDsAfterSearch', {
+                eventName: 'TestEvent',
+                index: 'test-index',
+                queryID: 'test-query-456',
+                objectIDs: ['test-object-123']
+            });
+        });
+        it('should not call aa when indexName is missing', () => {
+            const params = {
+                eventName: 'Test Event',
+                objectID: 'test-object-123',
+                queryID: 'test-query-456',
+                indexName: ''
+            };
+            sendAlgoliaConversionEvent(params);
+            expect(mockAa).not.toHaveBeenCalled();
+        });
+        it('should not call aa when queryID is missing', () => {
+            const params = {
+                eventName: 'Test Event',
+                objectID: 'test-object-123',
+                queryID: '',
+                indexName: 'test-index'
+            };
+            sendAlgoliaConversionEvent(params);
+            expect(mockAa).not.toHaveBeenCalled();
+        });
+        it('should not call aa when objectID is missing', () => {
+            const params = {
+                eventName: 'Test Event',
+                objectID: '',
+                queryID: 'test-query-456',
+                indexName: 'test-index'
+            };
+            sendAlgoliaConversionEvent(params);
+            expect(mockAa).not.toHaveBeenCalled();
+        });
+    });
+    describe('getValidConversionData', () => {
+        it('should return null when no data is found in localStorage', () => {
+            mockLocalStorage.getItem.mockReturnValue(null);
+            const result = getValidConversionData();
+            expect(result).toBeNull();
+            expect(mockLocalStorage.getItem).toHaveBeenCalledWith('algoliaConversions');
+        });
+        it('should return null when stored data is invalid JSON', () => {
+            mockLocalStorage.getItem.mockReturnValue('invalid-json');
+            const result = getValidConversionData();
+            expect(result).toBeNull();
+        });
+        it('should return null when no matching articleUrl is found', () => {
+            const stored = [
+                { ...validConversionData, articleUrl: '/not-this-url' },
+                { ...validConversionData, articleUrl: '/another-url' }
+            ];
+            mockLocalStorage.getItem.mockReturnValue(JSON.stringify(stored));
+            const result = getValidConversionData();
+            expect(result).toBeNull();
+        });
+        it('should return the matching conversion data for current articleUrl', () => {
+            const stored = [
+                { ...validConversionData, articleUrl: '/not-this-url' },
+                validConversionData,
+                { ...validConversionData, articleUrl: '/another-url' }
+            ];
+            mockLocalStorage.getItem.mockReturnValue(JSON.stringify(stored));
+            const result = getValidConversionData();
+            expect(result).toEqual(validConversionData);
+        });
+        it('should return null if stored value is not an array', () => {
+            mockLocalStorage.getItem.mockReturnValue(JSON.stringify(validConversionData));
+            const result = getValidConversionData();
+            expect(result).toBeNull();
+        });
+        it('should return null if array contains invalid objects', () => {
+            const stored = [
+                { foo: 'bar' },
+                { ...validConversionData, articleUrl: undefined }
+            ];
+            mockLocalStorage.getItem.mockReturnValue(JSON.stringify(stored));
+            const result = getValidConversionData();
+            expect(result).toBeNull();
+        });
+        it('should return null when conversion data is missing articleUrl', () => {
+            const fixedTime = 1000000000000;
+            jest.spyOn(Date, 'now').mockReturnValue(fixedTime);
+            const dataWithoutUrl = {
+                eventName: 'Test Event',
+                queryID: 'test-query-456',
+                objectID: 'test-object-123',
+                indexName: 'test-index',
+                applicationId: 'test-app-id',
+                apiKey: 'test-api-key',
+                timestamp: 1000000000000
+                // Missing articleUrl
+            };
+            mockLocalStorage.getItem.mockReturnValue(JSON.stringify(dataWithoutUrl));
+            const result = getValidConversionData();
+            expect(result).toBeNull();
+            jest.restoreAllMocks();
+        });
+        it('should return null and remove data when articleUrl does not match current URL', () => {
+            const fixedTime = 1000000000000;
+            jest.spyOn(Date, 'now').mockReturnValue(fixedTime);
+            const dataWithDifferentUrl = {
+                ...validConversionData,
+                articleUrl: '/different-article-path'
+            };
+            mockLocalStorage.getItem.mockReturnValue(JSON.stringify(dataWithDifferentUrl));
+            const result = getValidConversionData();
+            expect(result).toBeNull();
+            jest.restoreAllMocks();
+        });
+        it('should return valid data when articleUrl matches current URL', () => {
+            const fixedTime = 1000000000000;
+            jest.spyOn(Date, 'now').mockReturnValue(fixedTime);
+            mockLocalStorage.getItem.mockReturnValue(JSON.stringify(validConversionData));
+            const result = getValidConversionData();
+            expect(result).toBeNull();
+        });
+        it('should return null if array contains invalid objects', () => {
+            const stored = [
+                { foo: 'bar' },
+                { ...validConversionData, articleUrl: undefined }
+            ];
+            mockLocalStorage.getItem.mockReturnValue(JSON.stringify(stored));
+            const result = getValidConversionData();
+            expect(result).toBeNull();
+        });
+    });
+    describe('trackAlgoliaConversionWithDwellTime', () => {
+        beforeEach(() => {
+            jest.useFakeTimers();
+            jest.spyOn(Date, 'now').mockReturnValue(1000000000000);
+            mockAa.mockClear();
+            document.addEventListener.mockClear();
+            window.addEventListener.mockClear();
+        });
+        afterEach(() => {
+            jest.useRealTimers();
+            jest.restoreAllMocks();
+        });
+        it('should initialize search-insights with provided data', () => {
+            trackAlgoliaConversionWithDwellTime(validConversionData);
+            expect(mockAa).toHaveBeenCalledWith('init', {
+                appId: 'test-app-id',
+                apiKey: 'test-api-key'
+            });
+        });
+        it('should return early if search-insights initialization fails', () => {
+            mockAa.mockImplementationOnce((method) => {
+                if (method === 'init') {
+                    throw new Error('Init failed');
+                }
+            });
+            trackAlgoliaConversionWithDwellTime(validConversionData);
+            expect(mockAa).toHaveBeenCalledWith('init', expect.anything());
+            expect(document.addEventListener).not.toHaveBeenCalled();
+        });
+        it('should set up dwell time tracking with valid data', () => {
+            trackAlgoliaConversionWithDwellTime(validConversionData);
+            expect(mockAa).toHaveBeenCalledWith('init', expect.anything());
+            expect(document.addEventListener).toHaveBeenCalledWith('visibilitychange', expect.any(Function));
+            expect(window.addEventListener).toHaveBeenCalledWith('beforeunload', expect.any(Function));
+        });
+        it('should track conversion after 8 seconds of dwell time', () => {
+            let currentTime = 1000000000000;
+            Date.now.mockImplementation(() => currentTime);
+            trackAlgoliaConversionWithDwellTime(validConversionData);
+            expect(mockAa).toHaveBeenCalledWith('init', {
+                appId: 'test-app-id',
+                apiKey: 'test-api-key'
+            });
+            for (let i = 0; i < 8; i++) {
+                currentTime += 1000;
+                Date.now.mockReturnValue(currentTime);
+                jest.advanceTimersByTime(1000);
+            }
+            expect(mockAa).toHaveBeenCalledWith('convertedObjectIDsAfterSearch', {
+                eventName: 'Test Event',
+                index: 'test-index',
+                queryID: 'test-query-456',
+                objectIDs: ['test-object-123']
+            });
+        });
+        it('should not track conversion before 8 seconds', () => {
+            let currentTime = 1000000000000;
+            Date.now.mockImplementation(() => currentTime);
+            trackAlgoliaConversionWithDwellTime(validConversionData);
+            for (let i = 0; i < 7; i++) {
+                currentTime += 1000;
+                Date.now.mockReturnValue(currentTime);
+                jest.advanceTimersByTime(1000);
+            }
+            expect(mockAa).not.toHaveBeenCalledWith('convertedObjectIDsAfterSearch', expect.anything());
+        });
+        it('should set up proper event listeners for tracking', () => {
+            trackAlgoliaConversionWithDwellTime(validConversionData);
+            expect(document.addEventListener).toHaveBeenCalledWith('visibilitychange', expect.any(Function));
+            expect(window.addEventListener).toHaveBeenCalledWith('beforeunload', expect.any(Function));
+        });
+        it('should pause and resume dwell time tracking on visibility changes', () => {
+            let currentTime = 1000000000000;
+            Date.now.mockImplementation(() => currentTime);
+            trackAlgoliaConversionWithDwellTime(validConversionData);
+            const visibilityChangeCallback = document.addEventListener.mock.calls.find(call => call[0] === 'visibilitychange')[1];
+            // Simulate 4 seconds of visible time
+            for (let i = 0; i < 4; i++) {
+                currentTime += 1000;
+                Date.now.mockReturnValue(currentTime);
+                jest.advanceTimersByTime(1000);
+            }
+            // Hide the page
+            Object.defineProperty(document, 'hidden', {
+                value: true,
+                writable: true
+            });
+            visibilityChangeCallback();
+            // Advance time while hidden (shouldn't count toward dwell time)
+            for (let i = 0; i < 6; i++) {
+                currentTime += 1000;
+                Date.now.mockReturnValue(currentTime);
+                jest.advanceTimersByTime(1000);
+            }
+            // Show the page again
+            Object.defineProperty(document, 'hidden', {
+                value: false,
+                writable: true
+            });
+            visibilityChangeCallback();
+            // Advance 4 more seconds (total visible time: 8 seconds)
+            for (let i = 0; i < 4; i++) {
+                currentTime += 1000;
+                Date.now.mockReturnValue(currentTime);
+                jest.advanceTimersByTime(1000);
+            }
+            expect(mockAa).toHaveBeenCalledWith('convertedObjectIDsAfterSearch', {
+                eventName: 'Test Event',
+                index: 'test-index',
+                queryID: 'test-query-456',
+                objectIDs: ['test-object-123']
+            });
+        });
+        it('should clean up timer when conversion is tracked', () => {
+            let currentTime = 1000000000000;
+            Date.now.mockImplementation(() => currentTime);
+            const clearIntervalSpy = jest.spyOn(global, 'clearInterval');
+            trackAlgoliaConversionWithDwellTime(validConversionData);
+            for (let i = 0; i < 8; i++) {
+                currentTime += 1000;
+                Date.now.mockReturnValue(currentTime);
+                jest.advanceTimersByTime(1000);
+            }
+            expect(clearIntervalSpy).toHaveBeenCalled();
+            clearIntervalSpy.mockRestore();
+        });
+        it('should handle beforeunload without tracking if dwell time not reached', () => {
+            let currentTime = 1000000000000;
+            Date.now.mockImplementation(() => currentTime);
+            trackAlgoliaConversionWithDwellTime(validConversionData);
+            const beforeunloadCallback = window.addEventListener.mock.calls.find(call => call[0] === 'beforeunload')[1];
+            // Only 5 seconds of dwell time
+            for (let i = 0; i < 5; i++) {
+                currentTime += 1000;
+                Date.now.mockReturnValue(currentTime);
+                jest.advanceTimersByTime(1000);
+            }
+            beforeunloadCallback();
+            expect(mockAa).not.toHaveBeenCalledWith('convertedObjectIDsAfterSearch', expect.anything());
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"conversionEvent.test.js","sourceRoot":"","sources":["../../../../src/helpers/algolia/__tests__/conversionEvent.test.ts"],"names":[],"mappings":"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"}

package/dist/helpers/algolia/conversionEvent.d.ts

@@ -0,0 +1,29 @@
+export declare const sanitizeEventName: (name: string) => string;
+interface AlgoliaConversionData {
+    queryID: string;
+    objectID: string;
+    indexName: string;
+    applicationId: string;
+    apiKey: string;
+    timestamp: number;
+    eventName: string;
+    articleUrl: string;
+}
+export declare const sendAlgoliaConversionEvent: ({ eventName, objectID, queryID, indexName }: {
+    eventName: string;
+    objectID: string;
+    queryID: string;
+    indexName: string;
+}) => void;
+/**
+ * Retrieves and validates Algolia conversion data from localStorage
+ * Supports multiple articles stored as an array
+ * @returns AlgoliaConversionData if valid for current URL, null otherwise
+ */
+export declare const getValidConversionData: () => AlgoliaConversionData | null;
+/**
+ * Tracks Algolia conversion after user spends 8 seconds on an article page
+ * Assumes conversionData has already been validated by the caller
+ */
+export declare const trackAlgoliaConversionWithDwellTime: (conversionData: AlgoliaConversionData) => void;
+export {};

package/dist/helpers/algolia/conversionEvent.js

@@ -0,0 +1,154 @@
+import aa from 'search-insights';
+export const sanitizeEventName = (name) => {
+    const visibleAsciiOnly = name.replace(/[^\x20-\x7E]/g, '');
+    if (visibleAsciiOnly.length > 64) {
+        return visibleAsciiOnly.substring(0, 60) + '...';
+    }
+    return visibleAsciiOnly;
+};
+export const sendAlgoliaConversionEvent = ({ eventName, objectID, queryID, indexName }) => {
+    const truncatedEventName = sanitizeEventName(eventName);
+    if (!indexName || !queryID || !objectID) {
+        return;
+    }
+    aa('convertedObjectIDsAfterSearch', {
+        eventName: truncatedEventName,
+        index: indexName,
+        queryID,
+        objectIDs: [objectID]
+    });
+};
+/**
+ * Retrieves and validates Algolia conversion data from localStorage
+ * Supports multiple articles stored as an array
+ * @returns AlgoliaConversionData if valid for current URL, null otherwise
+ */
+export const getValidConversionData = () => {
+    try {
+        const currentUrl = window.location.pathname;
+        const storedArrayData = localStorage.getItem('algoliaConversions');
+        if (storedArrayData) {
+            const conversionsArray = JSON.parse(storedArrayData);
+            if (Array.isArray(conversionsArray)) {
+                const matchingConversion = conversionsArray.find(conversion => conversion.articleUrl === currentUrl);
+                if (matchingConversion && isValidConversionData(matchingConversion)) {
+                    return matchingConversion;
+                }
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        return null;
+    }
+};
+const isValidConversionData = (conversionData) => {
+    return (conversionData &&
+        conversionData.eventName &&
+        conversionData.queryID &&
+        conversionData.objectID &&
+        conversionData.indexName &&
+        conversionData.applicationId &&
+        conversionData.apiKey &&
+        conversionData.articleUrl);
+};
+const cleanupConversionData = (articleUrl) => {
+    const storedArrayData = localStorage.getItem('algoliaConversions');
+    if (storedArrayData) {
+        const conversionsArray = JSON.parse(storedArrayData);
+        if (Array.isArray(conversionsArray)) {
+            const filteredArray = conversionsArray.filter(conversion => conversion.articleUrl !== articleUrl);
+            if (filteredArray.length === 0) {
+                localStorage.removeItem('algoliaConversions');
+            }
+            else {
+                localStorage.setItem('algoliaConversions', JSON.stringify(filteredArray));
+            }
+        }
+    }
+};
+/**
+ * Tracks Algolia conversion after user spends 8 seconds on an article page
+ * Assumes conversionData has already been validated by the caller
+ */
+export const trackAlgoliaConversionWithDwellTime = (conversionData) => {
+    try {
+        aa('init', {
+            appId: conversionData.applicationId,
+            apiKey: conversionData.apiKey
+        });
+    }
+    catch (error) {
+        return;
+    }
+    let tracked = false;
+    let dwellStartTime = Date.now();
+    let totalDwellTime = 0;
+    let isPageVisible = !document.hidden;
+    const trackConversion = () => {
+        if (tracked) {
+            return;
+        }
+        sendAlgoliaConversionEvent({
+            eventName: conversionData.eventName,
+            indexName: conversionData.indexName,
+            queryID: conversionData.queryID,
+            objectID: conversionData.objectID
+        });
+        tracked = true;
+        cleanupConversionData(conversionData.articleUrl);
+    };
+    const updateDwellTime = () => {
+        if (isPageVisible) {
+            const currentTime = Date.now();
+            const sessionTime = currentTime - dwellStartTime;
+            totalDwellTime += sessionTime;
+            dwellStartTime = currentTime;
+        }
+    };
+    const checkDwellTime = () => {
+        updateDwellTime();
+        if (totalDwellTime >= 8000) {
+            trackConversion();
+            return true;
+        }
+        return false;
+    };
+    // Check dwell time every second
+    // --- Setup listeners and timer ---
+    const visibilityHandler = () => {
+        const now = Date.now();
+        if (document.hidden && isPageVisible) {
+            const sessionTime = now - dwellStartTime;
+            totalDwellTime += sessionTime;
+            isPageVisible = false;
+        }
+        else if (!document.hidden && !isPageVisible) {
+            dwellStartTime = now;
+            isPageVisible = true;
+        }
+    };
+    const beforeUnloadHandler = () => {
+        const conversionTracked = checkDwellTime();
+        if (!conversionTracked) {
+            cleanupConversionData(conversionData.articleUrl);
+        }
+    };
+    document.addEventListener('visibilitychange', visibilityHandler);
+    window.addEventListener('beforeunload', beforeUnloadHandler);
+    const dwellTimer = setInterval(() => {
+        if (!tracked) {
+            if (checkDwellTime()) {
+                clearInterval(dwellTimer);
+                document.removeEventListener('visibilitychange', visibilityHandler);
+                window.removeEventListener('beforeunload', beforeUnloadHandler);
+            }
+        }
+        else {
+            clearInterval(dwellTimer);
+            document.removeEventListener('visibilitychange', visibilityHandler);
+            window.removeEventListener('beforeunload', beforeUnloadHandler);
+        }
+    }, 1000);
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -48,3 +48,4 @@ export { SocialMediaEmbed } from './components/social-embed/SocialMediaEmbed';
 export { useSocialEmbedsContext, SocialEmbedsProvider } from './contexts/SocialEmbedsProvider';
 export { AffiliateLinkDisclaimer } from './components/affiliate-link-disclaimer/AffiliateLinkDisclaimer';
 export { ArticleCard } from './components/article-cards/ArticleCard';
+export { trackAlgoliaConversionWithDwellTime, getValidConversionData } from './helpers/algolia/conversionEvent';

package/dist/index.js

@@ -55,4 +55,5 @@ export { SocialMediaEmbed } from './components/social-embed/SocialMediaEmbed';
 export { useSocialEmbedsContext, SocialEmbedsProvider } from './contexts/SocialEmbedsProvider';
 export { AffiliateLinkDisclaimer } from './components/affiliate-link-disclaimer/AffiliateLinkDisclaimer';
 export { ArticleCard } from './components/article-cards/ArticleCard';
-//# sourceMappingURL=data:application/json;base64,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
+export { trackAlgoliaConversionWithDwellTime, getValidConversionData } from './helpers/algolia/conversionEvent';
+//# sourceMappingURL=data:application/json;base64,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