gatsby-core-theme 44.31.1 → 44.32.0

package/CHANGELOG.md

@@ -1,3 +1,23 @@
+# [44.32.0](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/compare/v44.31.1...v44.32.0) (2026-07-10)
+
+
+### Bug Fixes
+
+* pass ctaAsButton to nested coupon in bonus-box template-one ([3ccce08](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/3ccce08110044b9197910ac2701f1ca0baa17c8b))
+
+
+* Merge branch 'feat/notification-bonus-code-cta' into 'master' ([45b70ce](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/45b70cee5cb86a947054d57e3f3cd1631056c463))
+
+
+### Features
+
+* notification bonus code acts as CTA via shared useCopyCtaRedirect hook ([7a8055a](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/7a8055a7ce4674f4506f2458e27ab122f8d72912))
+
+
+### Tests
+
+* cover useCopyCtaRedirect hook to restore coverage threshold ([f23afa6](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/f23afa63d82527528fcb890b8919e3b61de8eda9))
+
 ## [44.31.1](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/compare/v44.31.0...v44.31.1) (2026-07-09)
 
 

package/package.json

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

package/src/components/atoms/notifications/index.js

@@ -25,7 +25,12 @@ const getNotificationToplist = (modules) => {
   );
 };
 
-const Notifications = ({ section, market, hideBadges = false }) => {
+const Notifications = ({
+  section,
+  market,
+  hideBadges = false,
+  bonusCodeActsAsCta = false,
+}) => {
   const { setShowSearch, setShowMenu, showMenu, showSearch } =
     useContext(NavigationContext);
   const notificationRef = useRef(null);
@@ -148,6 +153,7 @@ const Notifications = ({ section, market, hideBadges = false }) => {
                     toplist={notificationToplist}
                     showUnread={newNotification}
                     hideBadges={hideBadges}
+                    bonusCodeActsAsCta={bonusCodeActsAsCta}
                   />
                 ) : (
                   renderTrendingContent()
@@ -165,7 +171,8 @@ Notifications.propTypes = {
   section: PropTypes.shape({
     modules: PropTypes.arrayOf(PropTypes.shape({})),
   }),
-  hideBadges: PropTypes.bool
+  hideBadges: PropTypes.bool,
+  bonusCodeActsAsCta: PropTypes.bool
 };
 
 export default Notifications;

package/src/components/atoms/notifications/notification-items/bonuses/index.js

@@ -1,4 +1,4 @@
-import React, { useState } from "react";
+import React from "react";
 import PropTypes from "prop-types";
 import { FaArrowRight } from "@react-icons/all-files/fa/FaArrowRight";
 import CopyIcon from "~images/icons/copyIcon";
@@ -8,11 +8,14 @@ import PrettyLink from "~atoms/pretty-link";
 import ReviewLink from "~atoms/review-link";
 import Tnc from "~molecules/tnc";
 import keygen from "~helpers/keygen";
+import useCopyCtaRedirect from "~hooks/useCopyCtaRedirect/index";
+import { getCtaDataAttributes } from "~helpers/tracker";
 import {
   getBonusData,
   getPromoCode,
   getOperatorTnc,
   imagePrettyUrl,
+  prettyTracker,
 } from "~helpers/getters";
 import { getAltText } from "~helpers/image";
 import { getTimeAgo, parseSortableDate } from "~helpers/date-time";
@@ -28,9 +31,10 @@ const BonusItem = ({
   showUnread,
   bonusCodeLabel,
   updatedLabel,
-  hideBadges
+  hideBadges,
+  bonusCodeActsAsCta = false,
+  redirectDelay = 2000
 }) => {
-  const [copySuccess, setCopySuccess] = useState(false);
   const bonus = getBonusData(item, tracker);
   const oneliner = [bonus?.mainLine, bonus?.secondLine]
     .filter(Boolean)
@@ -67,17 +71,26 @@ const BonusItem = ({
   const codeCopiedLabel = useTranslate("code_copied", "CODE COPIED");
   const isBet365 = item.short_name === "bet365";
 
-  const copyToClipBoard = async (e, copyMe) => {
-    e.preventDefault();
-    e.stopPropagation();
+  // Optional CTA behaviour: when enabled the bonus-code button doubles as a CTA —
+  // copy, drop the affiliate cookie, then open the operator. It stays a <button>
+  // (no nested-anchor hydration issue), so 'button' redirect mode.
+  const trackerType = tracker?.toLowerCase()?.replace(" ", "_");
+  const ctaLink = bonusCodeActsAsCta ? prettyTracker(item, trackerType, false) : null;
+  const ctaActive =
+    bonusCodeActsAsCta && !!ctaLink && !isBet365 && item?.status !== "inactive";
 
-    try {
-      await navigator.clipboard.writeText(copyMe);
-      setCopySuccess(true);
-    } catch (err) {
-      setCopySuccess(false);
-    }
-  };
+  const { copySuccess, handleCopyClick } = useCopyCtaRedirect({
+    code: promoCode,
+    enabled: ctaActive,
+    disabled: isBet365,
+    redirectLink: ctaLink,
+    redirectMode: "button",
+    redirectDelay,
+    moduleName: TrackingKeys.NAVIGATIONTOPLIST,
+    tracker,
+    clickedElement: "notification_bonus_code",
+    itemPosition: index + 1,
+  });
 
   return (
     <li className={styles.bonusItem}>
@@ -107,10 +120,15 @@ const BonusItem = ({
               <button
                 type="button"
                 className={`${styles.bonusCode} ${copySuccess ? styles.bonusCodeCopied : ""}`}
-                onClick={(e) =>
-                  promoCode && !isBet365 ? copyToClipBoard(e, promoCode) : undefined
-                }
+                onClick={handleCopyClick}
                 disabled={isBet365}
+                {...(ctaActive
+                  ? getCtaDataAttributes(item, {
+                      tracker,
+                      moduleName: TrackingKeys.NAVIGATIONTOPLIST,
+                      itemPosition: index + 1,
+                    })
+                  : {})}
               >
                 {!copySuccess ? (
                   <>
@@ -180,6 +198,7 @@ BonusItem.propTypes = {
     updated_at: PropTypes.string,
     short_name: PropTypes.string,
     name: PropTypes.string,
+    status: PropTypes.string,
     founded: PropTypes.string,
     logo: PropTypes.shape({
       filename: PropTypes.string,
@@ -190,10 +209,12 @@ BonusItem.propTypes = {
   showUnread: PropTypes.bool,
   bonusCodeLabel: PropTypes.string.isRequired,
   updatedLabel: PropTypes.string.isRequired,
-  hideBadges: PropTypes.bool
+  hideBadges: PropTypes.bool,
+  bonusCodeActsAsCta: PropTypes.bool,
+  redirectDelay: PropTypes.number
 };
 
-const BonusesItems = ({ toplist, showUnread, hideBadges }) => {
+const BonusesItems = ({ toplist, showUnread, hideBadges, bonusCodeActsAsCta = false }) => {
   const items = [...(toplist?.items || [])].sort(
     (a, b) =>
       parseSortableDate(b.updated_at || b.founded) -
@@ -219,6 +240,7 @@ const BonusesItems = ({ toplist, showUnread, hideBadges }) => {
           bonusCodeLabel={bonusCodeLabel}
           updatedLabel={updatedLabel}
           hideBadges={hideBadges}
+          bonusCodeActsAsCta={bonusCodeActsAsCta}
         />
       ))}
     </ul>
@@ -233,7 +255,8 @@ BonusesItems.propTypes = {
     tracker: PropTypes.string,
   }),
   showUnread: PropTypes.bool,
-  hideBadges: PropTypes.bool
+  hideBadges: PropTypes.bool,
+  bonusCodeActsAsCta: PropTypes.bool
 };
 
 export default BonusesItems;

package/src/components/molecules/bonus-box/template-one/index.js

@@ -51,6 +51,7 @@ export default function BonusBox({
             itemPosition={itemPosition}
             clickedElement={clickedElement}
             showFreespinsBelowCoupon={showFreespinsBelowCoupon}
+            ctaAsButton
           />
         )}
       </PrettyLink>

package/src/hooks/useCopyCtaRedirect/index.js

@@ -0,0 +1,216 @@
+import { useState, useRef, useEffect } from 'react';
+import useCtaClickHandler from '../useCtaClickHandler/index';
+
+/**
+ * Copy-to-clipboard with an optional "act as CTA" redirect. Shared by the coupon
+ * atom (gatsby-matrix-theme) and the notification bonus-code button so the
+ * copy → track → open-operator flow lives in one place.
+ *
+ * On click it copies `code` and flips `copySuccess`. When `enabled` it also drops
+ * the affiliate cookie (`fireTracking`) and opens the operator. Two open strategies:
+ *  - Non-Safari (Chrome/Firefox/Edge, desktop or Android): dwell `redirectDelay`,
+ *    then open and revert the label — the delay stays within the transient-activation
+ *    window so the open is not popup-blocked.
+ *  - Safari / iOS (all iOS browsers are WebKit): open immediately inside the tap
+ *    gesture (a delayed open would be popup-blocked), and reset the label only once
+ *    the user returns to the tab (Page Visibility) — never while they're on the operator.
+ *
+ * Two redirect modes:
+ *  - 'anchor': re-dispatch a real click on `ctaRef` (so GTM's outbound-click
+ *    trigger fires), falling back to window.open(redirectLink). Attach the
+ *    returned `ctaRef` to the rendered <a>.
+ *  - 'button': window.open(redirectLink) directly; the element stays a <button>.
+ *
+ * When `enabled` is false it just copies (original non-CTA behaviour).
+ */
+const useCopyCtaRedirect = ({
+  code = '',
+  enabled = false,
+  disabled = false,
+  redirectLink = null,
+  redirectMode = 'button',
+  redirectDelay = 2000,
+  pageTemplate = null,
+  moduleName = null,
+  tracker = 'main',
+  clickedElement = 'cta',
+  modulePosition,
+  itemPosition
+} = {}) => {
+  const [copySuccess, setCopySuccess] = useState(false);
+  const redirectTimer = useRef(null);
+  const isPending = useRef(false); // a redirect is scheduled
+  const allowNavigation = useRef(false); // the next click is our own re-dispatch (anchor mode)
+  const visibilityHandler = useRef(null); // Safari: the reset-on-return listener
+  const safariFallbackTimer = useRef(null); // Safari: safety-net reset if the tab never backgrounds
+
+  // Safari — and every iOS browser, which is WebKit under the hood — only honours
+  // window.open when it runs synchronously inside the tap/click gesture; a delayed
+  // open is blocked as a popup. So on Safari we open immediately within the gesture
+  // and reset the "copied" label only once the user returns to our tab. Every other
+  // browser (Chrome/Firefox/Edge, desktop or Android) keeps the desktop dwell +
+  // delayed open.
+  const ua = typeof navigator !== 'undefined' ? navigator.userAgent : '';
+  const isIOS =
+    /iP(hone|od|ad)/.test(ua) ||
+    // iPadOS 13+ reports as "Macintosh"; disambiguate via touch points.
+    (/Macintosh/.test(ua) && (navigator?.maxTouchPoints || 0) > 1);
+  const isSafari =
+    isIOS ||
+    (/Safari/.test(ua) && !/Chrome|Chromium|Android|CriOS|FxiOS|Edg|OPR/.test(ua));
+
+  // `fireTracking` drops the affiliate cookie / fires the pixel; `ctaRef` points
+  // at the anchor we redirect through in 'anchor' mode.
+  const { ctaRef, fireTracking } = useCtaClickHandler({
+    pageTemplate,
+    moduleName,
+    tracker,
+    clickedElement,
+    modulePosition,
+    itemPosition
+  });
+
+  // Clear a scheduled redirect if the component unmounts mid-flow
+  useEffect(
+    () => () => {
+      if (redirectTimer.current) clearTimeout(redirectTimer.current);
+      if (safariFallbackTimer.current) clearTimeout(safariFallbackTimer.current);
+      if (visibilityHandler.current && typeof document !== 'undefined') {
+        document.removeEventListener('visibilitychange', visibilityHandler.current);
+      }
+    },
+    []
+  );
+
+  const openRedirect = () => {
+    if (redirectMode === 'anchor') {
+      const anchor = ctaRef.current;
+      if (anchor) {
+        // Re-dispatch a real click so the anchor navigates (new tab) and GTM's
+        // outbound-click trigger still fires. `allowNavigation` lets our own
+        // handler fall through instead of intercepting the click again.
+        allowNavigation.current = true;
+        const clickEvent = new MouseEvent('click', {
+          bubbles: true,
+          cancelable: true,
+          view: window
+        });
+        // opened === false when a wrapping anchor cancelled navigation → fall back.
+        if (anchor.dispatchEvent(clickEvent)) return;
+      }
+    }
+    if (redirectLink) window.open(redirectLink, '_blank');
+  };
+
+  // Safari flow: after the operator tab opens, keep the "copied" label until the
+  // user comes back to our tab, then reset it `redirectDelay` later. If they never
+  // return the label just stays (the tab is backgrounded anyway). Uses the Page
+  // Visibility API instead of a fixed timer so the dwell isn't spent while the
+  // user is away — and so backgrounded-timer throttling can't fire it early.
+  const armVisibilityReset = () => {
+    if (typeof document === 'undefined') return;
+
+    const onVisible = () => {
+      if (document.visibilityState !== 'visible') return;
+      document.removeEventListener('visibilitychange', onVisible);
+      visibilityHandler.current = null;
+      // The user is back — cancel the safety-net timer; we now dwell then reset.
+      if (safariFallbackTimer.current) clearTimeout(safariFallbackTimer.current);
+      if (redirectTimer.current) clearTimeout(redirectTimer.current);
+      redirectTimer.current = setTimeout(() => {
+        isPending.current = false;
+        setCopySuccess(false);
+      }, redirectDelay);
+    };
+
+    // Drop any listener left over from an earlier tap before arming a fresh one.
+    if (visibilityHandler.current) {
+      document.removeEventListener('visibilitychange', visibilityHandler.current);
+    }
+    visibilityHandler.current = onVisible;
+    document.addEventListener('visibilitychange', onVisible);
+  };
+
+  const handleCopyClick = (e) => {
+    // Our own re-dispatched click (anchor mode): let it navigate + GTM record it
+    if (allowNavigation.current) {
+      allowNavigation.current = false;
+      return;
+    }
+
+    if (e) {
+      e.preventDefault();
+      e.stopPropagation();
+    }
+
+    if (disabled) return;
+    // Ignore extra clicks while a redirect is already queued
+    if (isPending.current) return;
+
+    if (!enabled) {
+      // Non-CTA: copy, then reflect success/failure in the label. No redirect.
+      // `navigator.clipboard` is absent in insecure contexts / some in-app webviews,
+      // where the property access itself throws — guard before calling.
+      const write = navigator.clipboard?.writeText(code);
+      if (write) {
+        write.then(() => setCopySuccess(true), () => setCopySuccess(false));
+      } else {
+        setCopySuccess(false);
+      }
+      return;
+    }
+
+    // CTA path. Fire the clipboard write WITHOUT awaiting it: an await would break
+    // out of the synchronous tap gesture and let Safari popup-block the open. We flip
+    // to "copied" regardless of the write result — the redirect is the primary action.
+    // Optional-chain because `navigator.clipboard` is absent in insecure contexts /
+    // some in-app webviews, where the access itself would throw and abort the CTA.
+    navigator.clipboard?.writeText(code)?.catch(() => {});
+    setCopySuccess(true);
+    fireTracking();
+    isPending.current = true;
+
+    if (isSafari) {
+      // Open now, inside the tap gesture, so it isn't popup-blocked. Use window.open
+      // directly — on WebKit a synthetic anchor click carries no user activation and
+      // would itself be popup-blocked, so we skip the re-dispatch here (the affiliate
+      // pixel already fired via fireTracking above).
+      if (redirectLink) window.open(redirectLink, '_blank');
+
+      // Normal case: the tab backgrounds (user moves to the operator) → reset the
+      // "copied" label only once they return. `isPending` stays true until then so a
+      // second tap can't open another tab.
+      armVisibilityReset();
+
+      // Safety net: if the tab never actually backgrounds — open blocked, opened in a
+      // background tab, or a no-op in an in-app webview — the visibility handler never
+      // fires. After the dwell, if we're still visible, reset so the CTA isn't frozen;
+      // if we're hidden the user is on the operator, so leave it for the return reset.
+      if (safariFallbackTimer.current) clearTimeout(safariFallbackTimer.current);
+      safariFallbackTimer.current = setTimeout(() => {
+        if (typeof document !== 'undefined' && document.visibilityState !== 'visible') {
+          return;
+        }
+        if (visibilityHandler.current && typeof document !== 'undefined') {
+          document.removeEventListener('visibilitychange', visibilityHandler.current);
+          visibilityHandler.current = null;
+        }
+        isPending.current = false;
+        setCopySuccess(false);
+      }, redirectDelay);
+      return;
+    }
+
+    // Non-Safari (desktop-style): dwell, then open the operator and revert the label.
+    if (redirectTimer.current) clearTimeout(redirectTimer.current);
+    redirectTimer.current = setTimeout(() => {
+      isPending.current = false;
+      openRedirect();
+      setCopySuccess(false);
+    }, redirectDelay);
+  };
+
+  return { copySuccess, setCopySuccess, ctaRef, handleCopyClick };
+};
+
+export default useCopyCtaRedirect;

package/src/hooks/useCopyCtaRedirect/useCopyCtaRedirect.test.js

@@ -0,0 +1,287 @@
+import { renderHook, act } from '@testing-library/react';
+import useCopyCtaRedirect from './index';
+import useCtaClickHandler from '../useCtaClickHandler/index';
+
+jest.mock('../useCtaClickHandler/index', () => ({
+  __esModule: true,
+  default: jest.fn(),
+}));
+
+const SAFARI_UA =
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15';
+const CHROME_UA =
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36';
+
+const setUserAgent = (ua) =>
+  Object.defineProperty(navigator, 'userAgent', { value: ua, configurable: true });
+const setVisibility = (state) =>
+  Object.defineProperty(document, 'visibilityState', { value: state, configurable: true });
+const makeEvent = () => ({ preventDefault: jest.fn(), stopPropagation: jest.fn() });
+
+describe('useCopyCtaRedirect', () => {
+  let fireTracking;
+  let ctaRef;
+  let writeText;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fireTracking = jest.fn();
+    ctaRef = { current: null };
+    useCtaClickHandler.mockReturnValue({ ctaRef, fireTracking });
+
+    writeText = jest.fn().mockResolvedValue(undefined);
+    Object.defineProperty(navigator, 'clipboard', { value: { writeText }, configurable: true });
+    window.open = jest.fn();
+    setVisibility('visible');
+    setUserAgent(CHROME_UA);
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  test('non-CTA: copies and flips the "copied" label on success', async () => {
+    const { result } = renderHook(() => useCopyCtaRedirect({ code: 'PROMO', enabled: false }));
+
+    await act(async () => {
+      result.current.handleCopyClick(makeEvent());
+    });
+
+    expect(writeText).toHaveBeenCalledWith('PROMO');
+    expect(result.current.copySuccess).toBe(true);
+    expect(fireTracking).not.toHaveBeenCalled();
+  });
+
+  test('non-CTA: keeps the label unset when the clipboard API is unavailable', async () => {
+    Object.defineProperty(navigator, 'clipboard', { value: undefined, configurable: true });
+    const { result } = renderHook(() => useCopyCtaRedirect({ code: 'PROMO', enabled: false }));
+
+    await act(async () => {
+      result.current.handleCopyClick(makeEvent());
+    });
+
+    expect(result.current.copySuccess).toBe(false);
+  });
+
+  test('disabled: prevents default but does nothing else', () => {
+    const { result } = renderHook(() =>
+      useCopyCtaRedirect({ code: 'PROMO', enabled: true, disabled: true })
+    );
+    const event = makeEvent();
+
+    act(() => {
+      result.current.handleCopyClick(event);
+    });
+
+    expect(event.preventDefault).toHaveBeenCalled();
+    expect(writeText).not.toHaveBeenCalled();
+    expect(fireTracking).not.toHaveBeenCalled();
+  });
+
+  test('CTA non-Safari: copies, tracks, and opens the operator after the dwell (button mode)', () => {
+    jest.useFakeTimers();
+    const { result } = renderHook(() =>
+      useCopyCtaRedirect({
+        code: 'PROMO',
+        enabled: true,
+        redirectMode: 'button',
+        redirectLink: 'https://op',
+        redirectDelay: 2000,
+      })
+    );
+
+    act(() => {
+      result.current.handleCopyClick(makeEvent());
+    });
+
+    expect(result.current.copySuccess).toBe(true);
+    expect(fireTracking).toHaveBeenCalledTimes(1);
+    expect(window.open).not.toHaveBeenCalled();
+
+    act(() => {
+      jest.advanceTimersByTime(2000);
+    });
+
+    expect(window.open).toHaveBeenCalledWith('https://op', '_blank');
+    expect(result.current.copySuccess).toBe(false);
+  });
+
+  test('CTA: ignores a second tap while a redirect is already pending', () => {
+    jest.useFakeTimers();
+    const { result } = renderHook(() =>
+      useCopyCtaRedirect({
+        code: 'PROMO',
+        enabled: true,
+        redirectMode: 'button',
+        redirectLink: 'https://op',
+      })
+    );
+
+    act(() => {
+      result.current.handleCopyClick(makeEvent());
+    });
+    act(() => {
+      result.current.handleCopyClick(makeEvent());
+    });
+
+    expect(fireTracking).toHaveBeenCalledTimes(1);
+  });
+
+  test('CTA non-Safari anchor mode: re-dispatches a click, then falls through on our own click', () => {
+    jest.useFakeTimers();
+    const dispatchEvent = jest.fn(() => true);
+    ctaRef.current = { dispatchEvent };
+    const { result } = renderHook(() =>
+      useCopyCtaRedirect({
+        code: 'PROMO',
+        enabled: true,
+        redirectMode: 'anchor',
+        redirectLink: 'https://op',
+      })
+    );
+
+    act(() => {
+      result.current.handleCopyClick(makeEvent());
+    });
+    act(() => {
+      jest.advanceTimersByTime(2000);
+    });
+
+    expect(dispatchEvent).toHaveBeenCalledTimes(1);
+    expect(window.open).not.toHaveBeenCalled();
+
+    // openRedirect flagged allowNavigation → our own re-dispatched click is ignored.
+    const ownClick = makeEvent();
+    act(() => {
+      result.current.handleCopyClick(ownClick);
+    });
+    expect(ownClick.preventDefault).not.toHaveBeenCalled();
+  });
+
+  test('CTA anchor mode: falls back to window.open when the anchor navigation is cancelled', () => {
+    jest.useFakeTimers();
+    ctaRef.current = { dispatchEvent: jest.fn(() => false) };
+    const { result } = renderHook(() =>
+      useCopyCtaRedirect({
+        code: 'PROMO',
+        enabled: true,
+        redirectMode: 'anchor',
+        redirectLink: 'https://op',
+      })
+    );
+
+    act(() => {
+      result.current.handleCopyClick(makeEvent());
+    });
+    act(() => {
+      jest.advanceTimersByTime(2000);
+    });
+
+    expect(window.open).toHaveBeenCalledWith('https://op', '_blank');
+  });
+
+  test('CTA Safari: opens immediately in-gesture and resets only after the user returns', () => {
+    jest.useFakeTimers();
+    setUserAgent(SAFARI_UA);
+    const { result } = renderHook(() =>
+      useCopyCtaRedirect({
+        code: 'PROMO',
+        enabled: true,
+        redirectMode: 'button',
+        redirectLink: 'https://op',
+        redirectDelay: 2000,
+      })
+    );
+
+    act(() => {
+      result.current.handleCopyClick(makeEvent());
+    });
+
+    expect(window.open).toHaveBeenCalledWith('https://op', '_blank');
+    expect(result.current.copySuccess).toBe(true);
+
+    // user comes back to our tab → dwell → reset
+    setVisibility('visible');
+    act(() => {
+      document.dispatchEvent(new Event('visibilitychange'));
+    });
+    act(() => {
+      jest.advanceTimersByTime(2000);
+    });
+
+    expect(result.current.copySuccess).toBe(false);
+  });
+
+  test('CTA Safari: safety-net resets the label if the tab never backgrounds', () => {
+    jest.useFakeTimers();
+    setUserAgent(SAFARI_UA);
+    setVisibility('visible');
+    const { result } = renderHook(() =>
+      useCopyCtaRedirect({
+        code: 'PROMO',
+        enabled: true,
+        redirectMode: 'button',
+        redirectLink: 'https://op',
+        redirectDelay: 2000,
+      })
+    );
+
+    act(() => {
+      result.current.handleCopyClick(makeEvent());
+    });
+    expect(result.current.copySuccess).toBe(true);
+
+    act(() => {
+      jest.advanceTimersByTime(2000);
+    });
+    expect(result.current.copySuccess).toBe(false);
+  });
+
+  test('CTA Safari: safety-net leaves the label while the user is on the operator tab', () => {
+    jest.useFakeTimers();
+    setUserAgent(SAFARI_UA);
+    const { result } = renderHook(() =>
+      useCopyCtaRedirect({
+        code: 'PROMO',
+        enabled: true,
+        redirectMode: 'button',
+        redirectLink: 'https://op',
+        redirectDelay: 2000,
+      })
+    );
+
+    act(() => {
+      result.current.handleCopyClick(makeEvent());
+    });
+    setVisibility('hidden');
+    act(() => {
+      jest.advanceTimersByTime(2000);
+    });
+
+    expect(result.current.copySuccess).toBe(true);
+  });
+
+  test('cleans up the visibility listener on unmount', () => {
+    jest.useFakeTimers();
+    setUserAgent(SAFARI_UA);
+    const removeSpy = jest.spyOn(document, 'removeEventListener');
+    const { result, unmount } = renderHook(() =>
+      useCopyCtaRedirect({
+        code: 'PROMO',
+        enabled: true,
+        redirectMode: 'button',
+        redirectLink: 'https://op',
+      })
+    );
+
+    act(() => {
+      result.current.handleCopyClick(makeEvent());
+    });
+    act(() => {
+      unmount();
+    });
+
+    expect(removeSpy).toHaveBeenCalledWith('visibilitychange', expect.any(Function));
+    removeSpy.mockRestore();
+  });
+});