gatsby-core-theme 44.19.2 → 44.21.0

package/CHANGELOG.md

@@ -1,3 +1,40 @@
+# [44.21.0](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/compare/v44.20.0...v44.21.0) (2026-04-07)
+
+
+### Bug Fixes
+
+* apply INP fix to core theme level ([76bc451](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/76bc4516d27376203f6eafa71a2ca04456c10a20))
+* fix test by mocking the useCtaClickHandler ([882f602](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/882f602797a4b0605cb0d16f71604906f6303552))
+* fix test by mocking the useCtaClickHandler ([99b6f73](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/99b6f7324d09f053182ffb019ce2cb79d9fb4b22))
+* improve code ([7d5ec29](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/7d5ec29d6db3105082de5b1f2267b434b8f2ff06))
+* remove unused param ([aaa3e22](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/aaa3e22478d5cff7c5dfdbae8da7736d3e5a3ddc))
+
+
+* Merge branch 'improve-code' into 'master' ([1d4be07](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/1d4be073aa4727c500452713fb88d46216e2c60c))
+* Merge branch 'feat/gatsby-browser-yield-thread' into 'master' ([d107be8](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/d107be8a617e1c24ee4598310be7f160247329c6))
+* Merge branch 'inp-fix' into 'master' ([c892c47](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/c892c47ee11e8b4635c043764ec47b210b9ba192))
+
+
+### Features
+
+* yield before script loading ([ad0e7de](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/ad0e7de84050d8cdf7a5c3dc503f7dd11d67f63b))
+
+# [44.20.0](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/compare/v44.19.2...v44.20.0) (2026-04-03)
+
+
+### Bug Fixes
+
+* fix odds software id ([336729c](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/336729c7b3e23123a1080bdbe0acc3d092d01b09))
+* fix tests for operators.mjs ([b6704af](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/b6704afbf8d76eab82d4bfff22dafaf398e199d0))
+
+
+* Merge branch 'EN-408/add-odds-data' into 'master' ([173f818](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/173f81822d669b6c5e0ca08143cd7ac5c0649339))
+
+
+### Features
+
+* add odds new data for sportsbook type ([96d45ca](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/96d45ca44c29f1114dfe0fb2cdb955b84837e76b))
+
 ## [44.19.2](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/compare/v44.19.1...v44.19.2) (2026-04-02)
 
 

package/gatsby-browser.js

@@ -16,6 +16,17 @@ require("./src/styles/base/_reset.scss");
 require("./src/styles/base/_spacing.scss");
 require("./src/styles/layouts/_grid.scss");
 
+async function yieldToMain() {
+  if (globalThis.scheduler?.yield) {
+    return scheduler.yield();
+  }
+
+  // Fall back to yielding with setTimeout.
+  return new Promise((resolve) => {
+    setTimeout(resolve, 0);
+  });
+}
+
 function initGTM() {
   if (
     window.loadGTM === false ||
@@ -129,7 +140,8 @@ const piguard = () => {
   document.head.appendChild(script);
 };
 
-function scrollEvent(event) {
+async function scrollEvent(event) {
+  await yieldToMain();
   initGTM();
 
   if (
@@ -173,6 +185,13 @@ function scrollEvent(event) {
 }
 
 exports.onClientEntry = () => {
+  if (
+    /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+      navigator.userAgent
+    )
+  ) {
+    scrollEvent(null);
+  }
   if (process.env.PPC === "true") {
     scrollEvent(null);
   } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gatsby-core-theme",
-  "version": "44.19.2",
+  "version": "44.21.0",
   "description": "Gatsby Theme NPM Package",
   "author": "",
   "license": "ISC",

package/src/components/atoms/button/operator-cta.js

@@ -2,13 +2,11 @@
 /* eslint-disable no-unused-expressions */
 import React from 'react';
 import PropTypes from 'prop-types';
-import { globalHistory } from '@reach/router';
 import useTranslate from '~hooks/useTranslate/useTranslate';
 import { prettyTracker } from '~helpers/getters';
-import { setCookie } from '~helpers/cookies';
-import { getTrackingAPIParams, trackerLinkActive } from '~helpers/tracker';
-import keygen from '~helpers/keygen';
+import { trackerLinkActive } from '~helpers/tracker';
 import styles from './button.module.scss';
+import useCtaClickHandler from '../../../hooks/useCtaClickHandler/index';
 
 const OperatorCtaButton = ({
   operator,
@@ -43,10 +41,6 @@ const OperatorCtaButton = ({
 }) => {
   const status = operator?.status || ''
   const trackerType = tracker?.toLowerCase()?.replace(' ', '_')
-  const referer =
-    typeof document !== 'undefined' && document?.referrer
-      ? document.referrer
-      : '';
 
   const prettyLink = `${prettyTracker(
     operator,
@@ -54,6 +48,16 @@ const OperatorCtaButton = ({
     false
   )}`
 
+  const { ctaRef, handleCtaClick } = useCtaClickHandler({
+    pageTemplate,
+    moduleName,
+    tracker,
+    clickedElement,
+    modulePosition,
+    itemPosition,
+  });
+
+
   const translateBtn =
     status && translationsObj[status]
       ? // eslint-disable-next-line react-hooks/rules-of-hooks
@@ -63,40 +67,13 @@ const OperatorCtaButton = ({
       )
       : 'Claim'
 
-  const affObject = JSON.stringify(
-    getTrackingAPIParams(
-      pageTemplate,
-      moduleName,
-      tracker,
-      clickedElement,
-      globalHistory.location.href,
-      referer,
-      modulePosition,
-      itemPosition
-    )
-  )
-
-  const onCTAClick = () => {
-    process.env.IS_TRACKING_SSR &&
-      setCookie(
-        'affObject',
-        affObject,
-        1,
-        '/'
-      )
-
-    if (process.env.ENABLE_PIXEL === 'true' && typeof window.fbq !== 'undefined') {
-      // Call fbq track event
-      window.fbq('track', 'InitiateCheckout', { keyID: keygen() })
-    }
-  }
-
   const classes = `${styles[buttonType] || ''} ${status && styles[status] ? styles[status] : ''} ${buttonSize ? styles[`${buttonSize}_size`] : ''
     } `;
 
   return (
     trackerLinkActive(operator, tracker) && status === "active" ? (
       <a
+        ref={ctaRef}
         href={prettyLink || "#"}
         title={`${typeof translateBtn === "string" ? translateBtn : ""} ${titleSuffix || ""
           }`.trimEnd()}
@@ -105,7 +82,7 @@ const OperatorCtaButton = ({
         className={`${classes} ${gtmClass}`}
         target="_blank"
         rel={rel}
-        onClick={onCTAClick}
+        onClick={handleCtaClick}
       >
         {translateBtn}
         {icon && icon}

package/src/components/atoms/button/operator-cta.test.js

@@ -4,6 +4,9 @@ import React from 'react';
 import { render, cleanup, fireEvent } from '@testing-library/react';
 import '@testing-library/jest-dom/extend-expect';
 import OperatorCtaButton from './operator-cta';
+import useCtaClickHandler from '../../../hooks/useCtaClickHandler/index';
+
+jest.mock('../../../hooks/useCtaClickHandler/index', () => jest.fn());
 
 const data = (activeStatus = 'active', links = true) => ({
   operator: {
@@ -24,62 +27,35 @@ const data = (activeStatus = 'active', links = true) => ({
 });
 
 describe('OperatorCtaButton Component', () => {
-  test('OperatorCtaButton with status active', () => {
-    const { getByText, queryByRole } = render(<OperatorCtaButton {...data()} />);
-    const button = queryByRole('link');
-    if (button) {
-      expect(getByText("Visit")).toBeInTheDocument();
-    } else {
-      expect(button).toBeNull();
-    }
+  beforeEach(() => {
+    useCtaClickHandler.mockImplementation(() => ({
+      ctaRef: { current: null },
+      handleCtaClick: jest.fn(),
+    }));
   });
 
-  test('OperatorCtaButton with status inactive', () => {
-    const { getByText, queryByRole } = render(<OperatorCtaButton {...data('inactive')} />);
-    const button = queryByRole('link');
-    if (button) {
-      expect(getByText('Not Accepting New Players')).toBeInTheDocument();
-    } else {
-      expect(button).toBeNull();
-    }
-  });
-
-  test('OperatorCtaButton with status not_recommended', () => {
-    const { getByText, queryByRole } = render(<OperatorCtaButton {...data('not_recommended')} />);
-    const button = queryByRole('link');
-    if (button) {
-      expect(getByText("Not Recommended")).toBeInTheDocument();
-    } else {
-      expect(button).toBeNull();
-    }
-  });
-
-  test('OperatorCtaButton with status coming_soon', () => {
-    const { getByText, queryByRole } = render(<OperatorCtaButton {...data('coming_soon')} />);
-    const button = queryByRole('link');
-    if (button) {
-      expect(getByText("Soon Available")).toBeInTheDocument();
-    } else {
-      expect(button).toBeNull();
-    }
+  afterEach(() => {
+    jest.clearAllMocks();
   });
 
   test('Affiliate object in cookie', () => {
-    // eslint-disable-next-line no-global-assign
-    window = Object.create(window);
-    const url = 'http://test.com/?fbclid=param1&msclkid=param2&gclid=param3';
-    Object.defineProperty(window, "location", {
-      value: {
-        href: url,
-      },
-      writable: true, // possibility to override
+    const mockClickHandler = jest.fn((e) => {
+      e.preventDefault();
+      document.cookie =
+        'affObject={"page_type":"test","module":"test2","request_url":"http://localhost/","tracker_name":"testing"}';
     });
+    useCtaClickHandler.mockImplementation(() => ({
+      ctaRef: { current: null },
+      handleCtaClick: mockClickHandler,
+    }));
+
     const { container } = render(
       <OperatorCtaButton {...data()} pageTemplate="test" moduleName="test2" tracker="testing" />
     );
     const button = container.querySelector('a');
     if (button) {
       fireEvent.click(button);
+      expect(mockClickHandler).toHaveBeenCalled();
       const affObject = JSON.parse(document.cookie.split('=')[1]);
       expect(affObject.page_type).toEqual('test');
       expect(affObject.module).toEqual('test2');
@@ -91,10 +67,20 @@ describe('OperatorCtaButton Component', () => {
   });
 
   test('Default Affiliate object in cookie', () => {
+    const mockClickHandler = jest.fn((e) => {
+      e.preventDefault();
+      document.cookie =
+        'affObject={"page_type":"default","request_url":"http://localhost/"}';
+    });
+    useCtaClickHandler.mockImplementation(() => ({
+      ctaRef: { current: null },
+      handleCtaClick: mockClickHandler,
+    }));
     const { container } = render(<OperatorCtaButton {...data()} />);
     const button = container.querySelector('a');
     if (button) {
       fireEvent.click(button);
+      expect(mockClickHandler).toHaveBeenCalled();
       const affObject = JSON.parse(document.cookie.split('=')[1]);
       expect(affObject.page_type).toEqual('default');
       expect(affObject.request_url).toEqual('http://localhost/');
@@ -108,6 +94,58 @@ describe('OperatorCtaButton Component', () => {
     const button = queryByRole('link');
     expect(button).toBeNull();
   });
+
+  test('Passes tracking props to cta click hook', () => {
+    render(<OperatorCtaButton {...data()} moduleName="test-module" tracker="testing" />);
+    expect(useCtaClickHandler).toHaveBeenCalledWith({
+      pageTemplate: 'default',
+      moduleName: 'test-module',
+      tracker: 'testing',
+      clickedElement: 'cta',
+      modulePosition: undefined,
+      itemPosition: undefined,
+    });
+  });
+
+  test('OperatorCtaButton with status active', () => {
+    const { getByText, queryByRole } = render(<OperatorCtaButton {...data()} />);
+    const button = queryByRole('link');
+    if (button) {
+      expect(getByText("Visit")).toBeInTheDocument();
+    } else {
+      expect(button).toBeNull();
+    }
+  });
+
+  test('OperatorCtaButton with status inactive', () => {
+    const { getByText, queryByRole } = render(<OperatorCtaButton {...data('inactive')} />);
+    const button = queryByRole('link');
+    if (button) {
+      expect(getByText('Not Accepting New Players')).toBeInTheDocument();
+    } else {
+      expect(button).toBeNull();
+    }
+  });
+
+  test('OperatorCtaButton with status not_recommended', () => {
+    const { getByText, queryByRole } = render(<OperatorCtaButton {...data('not_recommended')} />);
+    const button = queryByRole('link');
+    if (button) {
+      expect(getByText("Not Recommended")).toBeInTheDocument();
+    } else {
+      expect(button).toBeNull();
+    }
+  });
+
+  test('OperatorCtaButton with status coming_soon', () => {
+    const { getByText, queryByRole } = render(<OperatorCtaButton {...data('coming_soon')} />);
+    const button = queryByRole('link');
+    if (button) {
+      expect(getByText("Soon Available")).toBeInTheDocument();
+    } else {
+      expect(button).toBeNull();
+    }
+  });
 });
 
 afterEach(() => {

package/src/components/atoms/pretty-link/index.js

@@ -1,11 +1,9 @@
 /* eslint-disable react/jsx-no-target-blank */
 import React from 'react'
 import PropTypes from 'prop-types'
-import { globalHistory } from '@reach/router'
 import { prettyTracker } from '~helpers/getters'
-import { setCookie } from '~helpers/cookies'
-import keygen from '~helpers/keygen'
-import { getTrackingAPIParams, trackerLinkActive } from '~helpers/tracker'
+import { trackerLinkActive } from '~helpers/tracker'
+import useCtaClickHandler from '../../../hooks/useCtaClickHandler/index'
 
 const PrettyLink = ({
   operator,
@@ -22,57 +20,30 @@ const PrettyLink = ({
   itemPosition
 }) => {
   const prettyLink = prettyTracker(operator, tracker, false, pageTemplate)
-  const referer =
-    typeof document !== 'undefined' && document?.referrer
-      ? document.referrer
-      : ''
-  
-  const affObject = JSON.stringify(
-    getTrackingAPIParams(
-      pageTemplate,
-      moduleName,
-      tracker,
-      clickedElement,
-      globalHistory.location.href,
-      referer,
-      modulePosition,
-      itemPosition
-    )
-  )
   
+  const { ctaRef, handleCtaClick } = useCtaClickHandler({
+    pageTemplate,
+    moduleName,
+    tracker,
+    clickedElement,
+    modulePosition,
+    itemPosition,
+  });
 
-  const onCTAClick = () => {
-    // eslint-disable-next-line no-unused-expressions
-    process.env.IS_TRACKING_SSR &&
-      setCookie(
-        'affObject',
-        affObject,
-        1,
-        '/'
-      )
-
-    if (
-      process.env.ENABLE_PIXEL === 'true' &&
-      typeof window.fbq !== 'undefined'
-    ) {
-      // Call fbq track event
-      window.fbq('track', 'InitiateCheckout', { keyID: keygen() })
-    }
-  }
-  
   const isLinkActive =
     (prettyLink && trackerLinkActive(operator, tracker)) || directPrettyLink
   const hrefLink = prettyLink || directPrettyLink || '#'
 
   return isLinkActive ? (
     <a
+      ref={ctaRef}
       href={hrefLink}
       title={`${operator?.name || ''} ${titleSuffix || ''}`.trimEnd() || ''}
       className={className}
       target="_blank"
       rel={rel}
       aria-label={`${operator?.name} ${titleSuffix || 'Link'}`}
-      onClick={onCTAClick}
+      onClick={handleCtaClick}
     >
       {children}
     </a>

package/src/components/atoms/pretty-link/pretty-link.test.js

@@ -5,6 +5,9 @@ import { render, cleanup, fireEvent } from '@testing-library/react';
 import '@testing-library/jest-dom/extend-expect';
 
 import PrettyLink from '.';
+import useCtaClickHandler from '../../../hooks/useCtaClickHandler/index';
+
+jest.mock('../../../hooks/useCtaClickHandler/index', () => jest.fn());
 
 const data = (activeStatus = 'active') => ({
   operator: {
@@ -21,6 +24,17 @@ const data = (activeStatus = 'active') => ({
 });
 
 describe('PrettyLink Component', () => {
+  beforeEach(() => {
+    useCtaClickHandler.mockImplementation(() => ({
+      ctaRef: { current: null },
+      handleCtaClick: jest.fn(),
+    }));
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
   test('PrettyLink children and link', () => {
     const { getByText, container } = render(<PrettyLink {...data()} />);
     expect(getByText('Test children').tagName.toLowerCase()).toBe('h1');
@@ -28,6 +42,15 @@ describe('PrettyLink Component', () => {
   });
 
   test('Affiliate object in cookie', () => {
+    const mockClickHandler = jest.fn((e) => {
+      e.preventDefault();
+      document.cookie =
+        'affObject={"page_type":"test","module":"test2","request_url":"http://localhost/","tracker_name":"testing","clicked_element":"cta"}';
+    });
+    useCtaClickHandler.mockImplementation(() => ({
+      ctaRef: { current: null },
+      handleCtaClick: mockClickHandler,
+    }));
     const { container } = render(
       <PrettyLink
         {...data()}
@@ -39,6 +62,7 @@ describe('PrettyLink Component', () => {
     );
     const button = container.querySelector('a');
     fireEvent.click(button);
+    expect(mockClickHandler).toHaveBeenCalled();
     const affObject = JSON.parse(document.cookie.split('=')[1]);
     expect(affObject.page_type).toEqual('test');
     expect(affObject.module).toEqual('test2');
@@ -62,13 +86,43 @@ describe('PrettyLink Component', () => {
   });
 
   test('Default Affiliate object in cookie', () => {
+    const mockClickHandler = jest.fn((e) => {
+      e.preventDefault();
+      document.cookie =
+        'affObject={"page_type":"default","request_url":"http://localhost/"}';
+    });
+    useCtaClickHandler.mockImplementation(() => ({
+      ctaRef: { current: null },
+      handleCtaClick: mockClickHandler,
+    }));
     const { container } = render(<PrettyLink {...data()} />);
     const button = container.querySelector('a');
     fireEvent.click(button);
+    expect(mockClickHandler).toHaveBeenCalled();
     const affObject = JSON.parse(document.cookie.split('=')[1]);
     expect(affObject.page_type).toEqual('default');
     expect(affObject.request_url).toEqual('http://localhost/');
   });
+
+  test('Passes tracking props to cta click hook', () => {
+    render(
+      <PrettyLink
+        {...data()}
+        pageTemplate="test"
+        moduleName="test2"
+        tracker="testing"
+        clickedElement="cta"
+      />
+    );
+    expect(useCtaClickHandler).toHaveBeenCalledWith({
+      pageTemplate: 'test',
+      moduleName: 'test2',
+      tracker: 'testing',
+      clickedElement: 'cta',
+      modulePosition: undefined,
+      itemPosition: undefined,
+    });
+  });
 });
 
 afterEach(() => {

package/src/constants/pick-keys.mjs

@@ -137,12 +137,11 @@ export const pickRelationKeys = {
     'rating_comments',
     'toplist_bonus',
     'toplist_item_tracker_name',
-    'odds_types',
     'odds_provider',
     'live_streaming',
-    'sport_competitions_ids',
     'betting_types',
-    'betting_features'
+    'betting_features',
+    'sport_categories'
   ],
   operator_simplified: [
     "short_name",

package/src/helpers/validateData.mjs

@@ -1,17 +1,35 @@
-/* eslint-disable no-useless-return */
 // eslint-disable-next-line import/prefer-default-export
 import { excludeStatusInactiveToplist } from '../constants/excluded.mjs';
 
-export default function checkForInactiveOperatorToplist(item, status, res) {
-  const shortCode = item && item.items && item.items.length && item.items[0].value;
+const INACTIVE_SHORTCODES = new Set([
+  'inactive_operator_toplist',
+  'inactive_sportsbook_toplist',
+]);
+
+export default function checkForInactiveOperatorToplist(item, status, res, pageType) {
+  const shortCode = item?.items?.[0]?.value;
   const siteName = process.env.GATSBY_SITE_NAME;
-  const excludeStatus = excludeStatusInactiveToplist[siteName] || excludeStatusInactiveToplist.default;  
-  if (
-    ((item.name === "top_list" && (shortCode === "inactive_operator_toplist" || shortCode === "inactive_sportsbook_toplist") && excludeStatus.includes(status)) ||
-      (item.name === "cards_v2" && status === "active" && res === "pre_main_operators"))
-  ) {
-    return true;
+  const excludeStatus =
+    excludeStatusInactiveToplist[siteName] || excludeStatusInactiveToplist.default;
+
+  if (item.name === 'top_list') {
+    
+    if (!INACTIVE_SHORTCODES.has(shortCode)) return false;
+
+
+    if (excludeStatus.includes(status)) return true;
+
+    const expectedShortcode =
+      pageType === 'sportsbook'
+        ? 'inactive_sportsbook_toplist'
+        : 'inactive_operator_toplist';
+        
+    return shortCode !== expectedShortcode;
   }
 
+  if (item.name === 'cards_v2') {
+    return status === 'active' && res === 'pre_main_operators';
+  }
+  
   return false;
 }

package/src/hooks/useCtaClickHandler/index.js

@@ -0,0 +1,82 @@
+import { useCallback, useRef } from 'react';
+import { globalHistory } from '@reach/router';
+import { setCookie } from '~helpers/cookies';
+import keygen from '~helpers/keygen';
+import { getTrackingAPIParams } from '~helpers/tracker';
+
+const useCtaClickHandler = ({
+  pageTemplate,
+  moduleName,
+  tracker,
+  clickedElement,
+  modulePosition,
+  itemPosition,
+}) => {
+  const referer =
+    typeof document !== 'undefined' && document?.referrer
+      ? document.referrer
+      : '';
+
+  const affObject = JSON.stringify(
+    getTrackingAPIParams(
+      pageTemplate,
+      moduleName,
+      tracker,
+      clickedElement,
+      globalHistory.location.href,
+      referer,
+      modulePosition,
+      itemPosition
+    )
+  );
+
+  const ctaRef = useRef(null);
+
+  const fireTracking = useCallback(() => {
+    if (process.env.IS_TRACKING_SSR) {
+      setCookie('affObject', affObject, 1, '/');
+    }
+
+    if (
+      process.env.ENABLE_PIXEL === 'true' &&
+      typeof window.fbq !== 'undefined'
+    ) {
+      window.fbq('track', 'InitiateCheckout', { keyID: keygen() });
+    }
+  }, [affObject]);
+
+  const handleCtaClick = useCallback(
+    (e) => {
+      // Ignore synthetic events dispatched for GTM
+      if (!e.isTrusted) {
+        e.preventDefault();
+        return;
+      }
+
+      // Block GTM's click listener from running synchronously (it listens on document)
+      e.stopPropagation();
+
+      const anchor = ctaRef.current;
+      if (!anchor) return;
+
+      requestAnimationFrame(() => {
+        setTimeout(() => {
+          fireTracking();
+
+          // Re-notify GTM with a synthetic click so it can still track the event
+          const gtmEvent = new MouseEvent('click', {
+            bubbles: true,
+            cancelable: true,
+            view: window,
+          });
+          anchor.dispatchEvent(gtmEvent);
+        }, 0);
+      });
+    },
+    [fireTracking]
+  );
+
+  return { ctaRef, handleCtaClick };
+};
+
+export default useCtaClickHandler;

package/src/hooks/useCtaClickHandler/useCtaClickHandler.test.js

@@ -0,0 +1,145 @@
+import { renderHook } from '@testing-library/react';
+import useCtaClickHandler from './index';
+import { setCookie } from '~helpers/cookies';
+import keygen from '~helpers/keygen';
+import { getTrackingAPIParams } from '~helpers/tracker';
+
+jest.mock('@reach/router', () => ({
+  globalHistory: {
+    location: {
+      href: 'http://localhost/',
+    },
+  },
+}));
+
+jest.mock('~helpers/cookies', () => ({
+  setCookie: jest.fn(),
+}));
+
+jest.mock('~helpers/keygen', () => jest.fn());
+
+jest.mock('~helpers/tracker', () => ({
+  getTrackingAPIParams: jest.fn(),
+}));
+
+describe('useCtaClickHandler', () => {
+  const originalTrackingSsr = process.env.IS_TRACKING_SSR;
+  const originalEnablePixel = process.env.ENABLE_PIXEL;
+  const originalFbq = window.fbq;
+  const originalRequestAnimationFrame = global.requestAnimationFrame;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    process.env.IS_TRACKING_SSR = 'true';
+    process.env.ENABLE_PIXEL = 'false';
+    getTrackingAPIParams.mockReturnValue({
+      page_type: 'default',
+      request_url: 'http://localhost/',
+    });
+    keygen.mockReturnValue('generated-key');
+    global.requestAnimationFrame = (cb) => cb();
+  });
+
+  afterEach(() => {
+    process.env.IS_TRACKING_SSR = originalTrackingSsr;
+    process.env.ENABLE_PIXEL = originalEnablePixel;
+    window.fbq = originalFbq;
+    global.requestAnimationFrame = originalRequestAnimationFrame;
+    jest.useRealTimers();
+  });
+
+  test('builds tracking params from hook arguments', () => {
+    renderHook(() =>
+      useCtaClickHandler({
+        pageTemplate: 'review',
+        moduleName: 'top-list',
+        tracker: 'main',
+        clickedElement: 'cta',
+        modulePosition: 1,
+        itemPosition: 2,
+      })
+    );
+
+    expect(getTrackingAPIParams).toHaveBeenCalledWith(
+      'review',
+      'top-list',
+      'main',
+      'cta',
+      'http://localhost/',
+      '',
+      1,
+      2
+    );
+  });
+
+  test('ignores non-trusted click events', () => {
+    const { result } = renderHook(() =>
+      useCtaClickHandler({
+        pageTemplate: 'default',
+      })
+    );
+    const event = {
+      isTrusted: false,
+      preventDefault: jest.fn(),
+      stopPropagation: jest.fn(),
+    };
+
+    result.current.handleCtaClick(event);
+
+    expect(event.preventDefault).toHaveBeenCalled();
+    expect(event.stopPropagation).not.toHaveBeenCalled();
+    expect(setCookie).not.toHaveBeenCalled();
+  });
+
+  test('does nothing when trusted click has no anchor ref', () => {
+    const { result } = renderHook(() =>
+      useCtaClickHandler({
+        pageTemplate: 'default',
+      })
+    );
+    const event = {
+      isTrusted: true,
+      preventDefault: jest.fn(),
+      stopPropagation: jest.fn(),
+    };
+
+    result.current.handleCtaClick(event);
+
+    expect(event.stopPropagation).toHaveBeenCalled();
+    expect(setCookie).not.toHaveBeenCalled();
+  });
+
+  test('fires tracking and redispatches click for trusted events', () => {
+    jest.useFakeTimers();
+    process.env.ENABLE_PIXEL = 'true';
+    window.fbq = jest.fn();
+
+    const { result } = renderHook(() =>
+      useCtaClickHandler({
+        pageTemplate: 'default',
+        tracker: 'main',
+      })
+    );
+    const dispatchEvent = jest.fn();
+    result.current.ctaRef.current = { dispatchEvent };
+    const event = {
+      isTrusted: true,
+      preventDefault: jest.fn(),
+      stopPropagation: jest.fn(),
+    };
+
+    result.current.handleCtaClick(event);
+    jest.runAllTimers();
+
+    expect(setCookie).toHaveBeenCalledWith(
+      'affObject',
+      JSON.stringify({ page_type: 'default', request_url: 'http://localhost/' }),
+      1,
+      '/'
+    );
+    expect(window.fbq).toHaveBeenCalledWith('track', 'InitiateCheckout', {
+      keyID: 'generated-key',
+    });
+    expect(dispatchEvent).toHaveBeenCalledTimes(1);
+  });
+});

package/src/resolver/index.mjs

@@ -627,24 +627,11 @@ export default {
                       checkForInactiveOperatorToplist(
                         item,
                         page.relation.status,
-                        res
+                        res,
+                        page.relation.type
                       )
                     )
                       return;
-                    
-                    if (item.name === "top_list") {
-                      const shortCode = item?.items?.[0]?.value;
-                      const isSportsbook =
-                        page?.relation?.type === "sportsbook";
-
-                      const shouldSkip =
-                        (isSportsbook &&
-                          shortCode === "inactive_operator_toplist") ||
-                        (!isSportsbook &&
-                          shortCode === "inactive_sportsbook_toplist");
-                      
-                      if (shouldSkip) return;
-                    }
 
                     //pre main games section will show only on inactive game page
                     const isActiveGamePage = page?.relation?.type === "game" || page?.relation?.status === "active";

package/src/resolver/operators.mjs

@@ -117,6 +117,15 @@ export function transformOperators(jsonData, relationsData, pages) {
             type: operatorType,
           };
 
+          newOperatorData.live_streaming = generalData.live_streaming;
+
+          // Odds providers
+          newOperatorData.odds_provider = generalData.odds_software_id
+          ? processProviders([generalData.odds_software_id], relationsData.providers)
+              .map((provider) => provider?.name)
+              .filter(Boolean)
+          : [];
+          
           // OPERATOR LOGO (temp fix included and will be removed)
           newOperatorData.logo = processLogo(
             newOperatorData.logo,

package/src/resolver/operators.test.js

@@ -1,11 +1,22 @@
 import { cleanup } from "@testing-library/react";
-import { sanitizeOperatorData } from "./operators.mjs";
+import { sanitizeOperatorData, transformOperators } from "./operators.mjs";
 import {
 getRelationsData,
 getTransformedV2operator,
 } from "../../tests/factories/relations/operatorV2.factory";
 import getPageDataList from "../../tests/factories/pages/list.factory";
 
+jest.mock("./relations.mjs", () => ({
+  processLogo: jest.fn((logo) => logo || null),
+  processPaymentMethods: jest.fn(() => []),
+  processCountries: jest.fn(() => []),
+  processCurrencies: jest.fn(() => []),
+  processProviders: jest.fn((ids) =>
+    ids?.includes(956) ? [{ id: 956, name: "18Peaches" }] : []
+  ),
+  processGamblingCompanies: jest.fn(() => null),
+}));
+
 describe("Sanitize Operator Data", () => {
 test("Sanitize Data with Operator Page", () => {
 const operatorData = getTransformedV2operator();
@@ -46,10 +57,127 @@ expect(result.name).toBe("Test Casino");
 expect(result.url).toBe("/test-url");
 expect(result.ribbons).toEqual(["customLabel", "fromRelations"]);
 expect(result.author_name).toBeUndefined();
-
 });
 });
 
+describe("transformOperators", () => {
+  test("uses live_streaming from general_data", () => {
+    const jsonData = {
+      bet365sb: {
+        general_data: {
+          id: 142,
+          name: "bet365",
+          short_name: "bet365sb",
+          live_streaming: true,
+          odds_software_id: null,
+          game_provider_ids: [],
+          currency_ids: [],
+          country_ids: [],
+          gambling_company_id: null,
+        },
+        markets_data: {
+          gb_en: {
+            sportsbook: {
+              live_streaming: false,
+            },
+          },
+        },
+        sites_data: {
+          gb_en: {
+            sportsbook: {
+              id: 45587,
+              market: "gb_en",
+              operator_id: 142,
+              status: "active",
+            },
+          },
+        },
+      },
+    };
+
+    const relationsData = {
+      providers: {},
+      payments: {},
+      currencies: {},
+      gamblingCompanies: {},
+      countries: {},
+      games: {},
+      ribbons: {},
+    };
+
+    const pages = {
+      1: {
+        relation_type: "operator",
+        type: "operator",
+        relation_id: 45587,
+        path: "sportsbook-review-test",
+      },
+    };
+
+    const result = transformOperators(jsonData, relationsData, pages);
+
+    expect(result[45587].live_streaming).toBe(true);
+  });
+
+  test("maps odds provider from general data odds software id", () => {
+    const jsonData = {
+      bet365sb: {
+        general_data: {
+          id: 142,
+          name: "bet365",
+          short_name: "bet365sb",
+          live_streaming: true,
+          odds_software_id: 956,
+          game_provider_ids: [],
+          currency_ids: [],
+          country_ids: [],
+          gambling_company_id: null,
+        },
+        markets_data: {
+          gb_en: {
+            sportsbook: {},
+          },
+        },
+        sites_data: {
+          gb_en: {
+            sportsbook: {
+              id: 45587,
+              market: "gb_en",
+              operator_id: 142,
+              status: "active",
+            },
+          },
+        },
+      },
+    };
+
+    const relationsData = {
+      providers: {
+        peaches: { id: 956, name: "18Peaches" },
+      },
+      payments: {},
+      currencies: {},
+      gamblingCompanies: {},
+      countries: {},
+      games: {},
+      ribbons: {},
+    };
+
+    const pages = {
+      1: {
+        relation_type: "operator",
+        type: "operator",
+        relation_id: 45587,
+        path: "sportsbook-review-test",
+      },
+    };
+
+    const result = transformOperators(jsonData, relationsData, pages);
+
+    expect(result[45587].odds_provider).toEqual(["18Peaches"]);
+  });
+});
+
 afterEach(() => {
 cleanup();
 });