@times-components/ts-components 1.140.5 → 1.141.0

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.141.0](https://github.com/newsuk/times-components/compare/@times-components/ts-components@1.140.5...@times-components/ts-components@1.141.0) (2025-11-04)
+
+
+### Features
+
+* **TGGA-653:** added algolia conversion event ([#4228](https://github.com/newsuk/times-components/issues/4228)) ([c7553b2](https://github.com/newsuk/times-components/commit/c7553b266d39c7b7b8fc831669f0d896fe21ff63))
+
+
+
+
+
 ## [1.140.5](https://github.com/newsuk/times-components/compare/@times-components/ts-components@1.140.4...@times-components/ts-components@1.140.5) (2025-11-03)
 
 **Note:** Version bump only for package @times-components/ts-components

package/dist/helpers/algolia/__tests__/AlgoliaSearchProvider.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

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

@@ -0,0 +1,200 @@
+import React from 'react';
+import { render, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { AlgoliaSearchProvider, useAlgoliaSearch } from '../AlgoliaSearchProvider';
+jest.mock('algoliasearch', () => {
+    return jest.fn(() => ({
+        initIndex: jest.fn()
+    }));
+});
+jest.mock('../algoliaRelatedArticles', () => ({
+    searchRelatedArticles: jest.fn()
+}));
+import algoliasearch from 'algoliasearch';
+import { searchRelatedArticles } from '../algoliaRelatedArticles';
+const mockAlgoliasearch = algoliasearch;
+const mockSearchRelatedArticles = searchRelatedArticles;
+const TestComponent = () => {
+    const { getRelatedArticles } = useAlgoliaSearch();
+    React.useEffect(() => {
+        if (getRelatedArticles) {
+            getRelatedArticles();
+        }
+    }, [getRelatedArticles]);
+    return React.createElement("div", { "data-testid": "test-component" }, "Test Component");
+};
+const mockAnalyticsStream = jest.fn();
+const mockAlgoliaSearchKeys = {
+    applicationId: 'test-app-id',
+    apiKey: 'test-api-key',
+    indexName: 'test-index'
+};
+const mockArticle = {
+    id: 'test-article-123',
+    label: 'Test Article Label',
+    headline: 'Test Article Headline',
+    section: 'news',
+    topics: [{ name: 'Technology' }],
+    bylines: []
+};
+describe('AlgoliaSearchProvider', () => {
+    let mockIndex;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockIndex = {
+            search: jest.fn()
+        };
+        mockAlgoliasearch.mockReturnValue({
+            initIndex: jest.fn().mockReturnValue(mockIndex)
+        });
+    });
+    describe('Provider functionality', () => {
+        it('should render children correctly', () => {
+            const { getByTestId } = render(React.createElement(AlgoliaSearchProvider, { algoliaSearchKeys: mockAlgoliaSearchKeys, article: mockArticle, analyticsStream: mockAnalyticsStream },
+                React.createElement("div", { "data-testid": "child-component" }, "Child Content")));
+            expect(getByTestId('child-component')).toBeInTheDocument();
+        });
+        it('should create algolia index with correct parameters', () => {
+            render(React.createElement(AlgoliaSearchProvider, { algoliaSearchKeys: mockAlgoliaSearchKeys, article: mockArticle, analyticsStream: mockAnalyticsStream },
+                React.createElement("div", null, "Content")));
+            expect(mockAlgoliasearch).toHaveBeenCalledWith('test-app-id', 'test-api-key');
+            expect(mockAlgoliasearch('test-app-id', 'test-api-key').initIndex).toHaveBeenCalledWith('test-index');
+        });
+        it('should handle null algoliaSearchKeys', () => {
+            render(React.createElement(AlgoliaSearchProvider, { algoliaSearchKeys: null, article: mockArticle, analyticsStream: mockAnalyticsStream },
+                React.createElement("div", null, "Content")));
+            expect(mockAlgoliasearch).not.toHaveBeenCalled();
+        });
+        it('should recreate index when algoliaSearchKeys change', () => {
+            const { rerender } = render(React.createElement(AlgoliaSearchProvider, { algoliaSearchKeys: mockAlgoliaSearchKeys, article: mockArticle, analyticsStream: mockAnalyticsStream },
+                React.createElement("div", null, "Content")));
+            expect(mockAlgoliasearch).toHaveBeenCalledTimes(1);
+            const newKeys = {
+                ...mockAlgoliaSearchKeys,
+                applicationId: 'new-app-id'
+            };
+            rerender(React.createElement(AlgoliaSearchProvider, { algoliaSearchKeys: newKeys, article: mockArticle, analyticsStream: mockAnalyticsStream },
+                React.createElement("div", null, "Content")));
+            expect(mockAlgoliasearch).toHaveBeenCalledTimes(2);
+            expect(mockAlgoliasearch).toHaveBeenLastCalledWith('new-app-id', 'test-api-key');
+        });
+    });
+    describe('getRelatedArticles functionality', () => {
+        it('should call searchRelatedArticles with correct parameters when index and article exist', async () => {
+            const mockResults = {
+                query: 'test query',
+                sliceName: 'test slice',
+                items: [],
+                count: 5
+            };
+            mockSearchRelatedArticles.mockResolvedValue(mockResults);
+            render(React.createElement(AlgoliaSearchProvider, { algoliaSearchKeys: mockAlgoliaSearchKeys, article: mockArticle, analyticsStream: mockAnalyticsStream },
+                React.createElement(TestComponent, null)));
+            await waitFor(() => {
+                expect(mockSearchRelatedArticles).toHaveBeenCalledWith(mockIndex, mockArticle, mockAnalyticsStream);
+            });
+        });
+        it('should return null when no index is available', async () => {
+            let resultFromHook;
+            const TestComponentWithResult = () => {
+                const { getRelatedArticles } = useAlgoliaSearch();
+                React.useEffect(() => {
+                    const fetchResults = async () => {
+                        if (getRelatedArticles) {
+                            resultFromHook = await getRelatedArticles();
+                        }
+                    };
+                    fetchResults();
+                }, [getRelatedArticles]);
+                return React.createElement("div", null, "Test");
+            };
+            render(React.createElement(AlgoliaSearchProvider, { algoliaSearchKeys: null, article: mockArticle, analyticsStream: mockAnalyticsStream },
+                React.createElement(TestComponentWithResult, null)));
+            await waitFor(() => {
+                expect(resultFromHook).toBeNull();
+            });
+            expect(mockSearchRelatedArticles).not.toHaveBeenCalled();
+        });
+        it('should return null when no article is provided', async () => {
+            let resultFromHook;
+            const TestComponentWithResult = () => {
+                const { getRelatedArticles } = useAlgoliaSearch();
+                React.useEffect(() => {
+                    const fetchResults = async () => {
+                        if (getRelatedArticles) {
+                            resultFromHook = await getRelatedArticles();
+                        }
+                    };
+                    fetchResults();
+                }, [getRelatedArticles]);
+                return React.createElement("div", null, "Test");
+            };
+            render(React.createElement(AlgoliaSearchProvider, { algoliaSearchKeys: mockAlgoliaSearchKeys, article: null, analyticsStream: mockAnalyticsStream },
+                React.createElement(TestComponentWithResult, null)));
+            await waitFor(() => {
+                expect(resultFromHook).toBeNull();
+            });
+            expect(mockSearchRelatedArticles).not.toHaveBeenCalled();
+        });
+        it('should return results from searchRelatedArticles', async () => {
+            const mockResults = {
+                query: 'test query',
+                sliceName: 'test slice',
+                items: [{ id: 1 }, { id: 2 }, { id: 3 }],
+                count: 3
+            };
+            mockSearchRelatedArticles.mockResolvedValue(mockResults);
+            let resultFromHook;
+            const TestComponentWithResult = () => {
+                const { getRelatedArticles } = useAlgoliaSearch();
+                React.useEffect(() => {
+                    const fetchResults = async () => {
+                        if (getRelatedArticles) {
+                            resultFromHook = await getRelatedArticles();
+                        }
+                    };
+                    fetchResults();
+                }, [getRelatedArticles]);
+                return React.createElement("div", null, "Test");
+            };
+            render(React.createElement(AlgoliaSearchProvider, { algoliaSearchKeys: mockAlgoliaSearchKeys, article: mockArticle, analyticsStream: mockAnalyticsStream },
+                React.createElement(TestComponentWithResult, null)));
+            await waitFor(() => {
+                expect(resultFromHook).toEqual(mockResults);
+            });
+        });
+        it('should memoize getRelatedArticles callback based on dependencies', () => {
+            let firstCallback;
+            let secondCallback;
+            const CallbackCapture = () => {
+                const { getRelatedArticles } = useAlgoliaSearch();
+                if (!firstCallback) {
+                    firstCallback = getRelatedArticles;
+                }
+                else if (!secondCallback) {
+                    secondCallback = getRelatedArticles;
+                }
+                return React.createElement("div", null, "Test");
+            };
+            const { rerender } = render(React.createElement(AlgoliaSearchProvider, { algoliaSearchKeys: mockAlgoliaSearchKeys, article: mockArticle, analyticsStream: mockAnalyticsStream },
+                React.createElement(CallbackCapture, null)));
+            rerender(React.createElement(AlgoliaSearchProvider, { algoliaSearchKeys: mockAlgoliaSearchKeys, article: mockArticle, analyticsStream: mockAnalyticsStream },
+                React.createElement(CallbackCapture, null)));
+            expect(firstCallback).toBe(secondCallback);
+        });
+    });
+    describe('useAlgoliaSearch hook', () => {
+        it('should provide context value when used within provider', () => {
+            let contextValue;
+            const TestComponentInsideProvider = () => {
+                contextValue = useAlgoliaSearch();
+                return React.createElement("div", null, "Test");
+            };
+            render(React.createElement(AlgoliaSearchProvider, { algoliaSearchKeys: mockAlgoliaSearchKeys, article: mockArticle, analyticsStream: mockAnalyticsStream },
+                React.createElement(TestComponentInsideProvider, null)));
+            expect(contextValue).toHaveProperty('getRelatedArticles');
+            expect(typeof contextValue.getRelatedArticles).toBe('function');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AlgoliaSearchProvider.test.js","sourceRoot":"","sources":["../../../../src/helpers/algolia/__tests__/AlgoliaSearchProvider.test.tsx"],"names":[],"mappings":"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"}

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

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