@redacto.io/consent-sdk-react 9.3.0 → 9.4.0-beta.0

package/src/RedactoPrivacyCenter/lib/utils.ts

@@ -1,10 +1,33 @@
 import { refreshOtpTokenServer } from './api';
+import { isTerminalRefreshError } from '../api/fetcher';
+import {
+  MIN_REFRESH_BACKOFF_MS,
+  MAX_REFRESH_BACKOFF_MS,
+  REFRESH_TOKEN_STORAGE_KEY,
+  LEGACY_REFRESH_TOKEN_COOKIE,
+} from './constants';
 import type { BaseUrlContextValue } from '../context/BaseUrlContext';
 
 // Token refresh lock to prevent concurrent refresh attempts
 let isRefreshing = false;
 let refreshPromise: Promise<string | null> | null = null;
 
+// ─── OTP refresh circuit breaker (incident 2026-06-22) ──────────────────────
+// ensureValidToken is called from 3 independent 30s pollers, before every
+// authenticated API call, and from render-driven effects. Without a memory of
+// failure, a single dead refresh token gets re-submitted on every one of those
+// triggers, hammering POST /otp/refresh until the tab closes. These guards make a
+// terminally-failed token cost exactly one request, and apply backoff to transient
+// failures.
+//
+// `deadRefreshToken` holds the *value* of a refresh token that terminally failed.
+// It auto-clears the moment a different token value appears (i.e. the user
+// re-authenticated), so the breaker never permanently bricks a session.
+let deadRefreshToken: string | null = null;
+// Transient-failure backoff window (epoch ms) and the current backoff duration.
+let transientRefreshFailureUntil = 0;
+let transientRefreshBackoffMs = 0;
+
 // Buffer time in seconds before token expiration to proactively refresh
 // Using 30 seconds to ensure tokens are refreshed before they expire
 const TOKEN_EXPIRY_BUFFER_SECONDS = 30;
@@ -20,25 +43,140 @@ export const getCookieValue = (name: string) => {
   return null;
 };
 
+// ─── Refresh token persistence ──────────────────────────────────────────────
+// The refresh token lives in localStorage (key REFRESH_TOKEN_STORAGE_KEY), not a
+// cookie. A path-scoped cookie is not readable when the host mounts the privacy
+// center under a basePath (e.g. consent-app at /consent → /consent/privacy-center/...),
+// so a rotated token can't be read back and the stale token gets re-presented,
+// causing a 401 "Refresh token not found or already used" storm. localStorage is
+// origin-scoped (no path matching), so it is readable under any basePath.
+//
+// localStorage access throws when storage is disabled or over quota (private
+// modes, embedded webviews). Guard every access so the SDK degrades to "refresh
+// fails -> re-auth" instead of crashing the render tree (setRefreshTokenCookie
+// runs during AuthProvider's render). Mirrors components/AppShell/hooks/useSidebarState.ts.
+const readStorage = (key: string): string | null => {
+  try {
+    return window.localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+};
+
+const writeStorage = (key: string, value: string): void => {
+  try {
+    window.localStorage.setItem(key, value);
+  } catch {
+    // localStorage unavailable / quota exceeded — ignore
+  }
+};
+
+const removeStorage = (key: string): void => {
+  try {
+    window.localStorage.removeItem(key);
+  } catch {
+    // localStorage unavailable — ignore
+  }
+};
+
 /**
- * Set refresh token cookie with proper attributes
+ * Expire the SDK's own legacy refresh_token cookie (older versions wrote it at
+ * path=/privacy-center). Scoped to that path only on purpose: a refresh_token
+ * cookie at path=/ belongs to the host app, and clearing it would sign the host
+ * out.
+ */
+const clearLegacyRefreshTokenCookie = (): void => {
+  if (typeof window === 'undefined') {
+    return;
+  }
+  document.cookie = `${LEGACY_REFRESH_TOKEN_COOKIE}=; path=/privacy-center; expires=Thu, 01 Jan 1970 00:00:00 GMT`;
+};
+
+/**
+ * Persist the refresh token. Named `setRefreshTokenCookie` for backward
+ * compatibility (it is part of the package's exported surface); it now writes
+ * to localStorage rather than a cookie, and clears any cookie an older SDK
+ * version left at path=/privacy-center.
  * @param refreshToken - The refresh token value to set
  */
 export const setRefreshTokenCookie = (refreshToken: string): void => {
   if (typeof window === 'undefined') {
     return;
   }
+  writeStorage(REFRESH_TOKEN_STORAGE_KEY, refreshToken);
+  clearLegacyRefreshTokenCookie();
+};
+
+/**
+ * Read the persisted refresh token from localStorage.
+ *
+ * Intentionally does NOT fall back to reading a `refresh_token` cookie: a cookie
+ * read is name-only (the path isn't visible to JS), so it cannot tell the SDK's
+ * own legacy cookie from a host app's unrelated `refresh_token` cookie — reading
+ * the latter would leak a host credential to the OTP refresh endpoint. Existing
+ * sessions are preserved by AuthProvider re-seeding storage from the token prop.
+ */
+export const getStoredRefreshToken = (): string | null => {
+  if (typeof window === 'undefined') {
+    return null;
+  }
+  return readStorage(REFRESH_TOKEN_STORAGE_KEY);
+};
+
+/**
+ * Resolve the refresh token currently in play: from auth context (props mode) or
+ * persisted storage (legacy mode). Centralised so the circuit breaker and the
+ * refresh routine always agree on exactly which token value is being used.
+ */
+const getActiveRefreshToken = (authContext?: { refreshToken?: string }): string | null => {
+  if (authContext) {
+    return authContext.refreshToken && authContext.refreshToken.trim() !== ''
+      ? authContext.refreshToken
+      : null;
+  }
+  if (typeof window === 'undefined') return null;
+  return getStoredRefreshToken();
+};
+
+/**
+ * Clear all OTP-refresh circuit-breaker state. Called after a successful refresh
+ * and exposed for tests. Deliberately NOT called from signOutPrivacyCenter: in
+ * props mode the refresh token lives in a prop that sign-out cannot clear, so
+ * clearing the breaker there would immediately re-arm the retry storm. Recovery
+ * instead happens automatically when a *different* token value appears.
+ */
+export const resetRefreshCircuit = (): void => {
+  deadRefreshToken = null;
+  transientRefreshFailureUntil = 0;
+  transientRefreshBackoffMs = 0;
+};
+
+/**
+ * True when attempting a refresh right now would be pointless — the active refresh
+ * token has already terminally failed, or we're inside the transient backoff
+ * window. Pollers consult this to avoid scheduling doomed work.
+ */
+export const isRefreshBlocked = (authContext?: { refreshToken?: string }): boolean => {
+  const active = getActiveRefreshToken(authContext);
+  if (active !== null && active === deadRefreshToken) return true;
+  if (Date.now() < transientRefreshFailureUntil) return true;
+  return false;
+};
 
-  const cookieAttributes = [
-    `refresh_token=${refreshToken}`,
-    'path=/privacy-center',
-    `max-age=${60 * 60 * 24 * 7}`, // 7 days
-    `samesite=lax`,
-  ]
-    .filter(Boolean)
-    .join('; ');
+/** Record a transient refresh failure (network / 5xx) and grow the backoff window. */
+const noteTransientRefreshFailure = (): void => {
+  transientRefreshBackoffMs = Math.min(
+    Math.max(transientRefreshBackoffMs * 2, MIN_REFRESH_BACKOFF_MS),
+    MAX_REFRESH_BACKOFF_MS,
+  );
+  transientRefreshFailureUntil = Date.now() + transientRefreshBackoffMs;
+};
 
-  document.cookie = cookieAttributes;
+/** Trip the circuit breaker for a refresh token value that terminally failed. */
+const markRefreshTokenDead = (token: string | null): void => {
+  if (token) {
+    deadRefreshToken = token;
+  }
 };
 
 /**
@@ -210,14 +348,23 @@ export const checkAndRefreshAuth = async (
       return false;
     }
 
-    try {
-      const refreshToken = getCookieValue('refresh_token');
-      if (!refreshToken) {
-        // No refresh token available - user needs to sign in again
-        signOutPrivacyCenter();
-        return false;
-      }
+    const refreshToken = getStoredRefreshToken();
+    if (!refreshToken) {
+      // No refresh token available - user needs to sign in again
+      signOutPrivacyCenter();
+      return false;
+    }
+
+    // Circuit breaker (incident 2026-06-22): a new token re-arms; a known-dead
+    // token or an open backoff window short-circuits without hitting the network.
+    if (deadRefreshToken !== null && refreshToken !== deadRefreshToken) {
+      resetRefreshCircuit();
+    }
+    if (refreshToken === deadRefreshToken || Date.now() < transientRefreshFailureUntil) {
+      return false;
+    }
 
+    try {
       const result = await refreshOtpTokenServer(orgId, wsId, refreshToken, consentClient);
       if (result && result.success !== false) {
         const newAccessToken = (result as { access_token?: string })?.access_token;
@@ -227,13 +374,17 @@ export const checkAndRefreshAuth = async (
           // Validate the new token is not expired before storing
           if (isJwtExpired(newAccessToken, TOKEN_EXPIRY_BUFFER_SECONDS)) {
             console.error('Refreshed access token is already expired - clearing auth state');
+            markRefreshTokenDead(refreshToken);
             signOutPrivacyCenter();
             return false;
           }
           sessionStorage.setItem('access_token', newAccessToken);
+          // Success — re-arm the circuit breaker.
+          resetRefreshCircuit();
         } else {
           // No access token in response - refresh failed
           console.error('Refresh response missing access token - clearing auth state');
+          markRefreshTokenDead(refreshToken);
           signOutPrivacyCenter();
           return false;
         }
@@ -252,27 +403,20 @@ export const checkAndRefreshAuth = async (
       } else {
         // Refresh token expired/revoked or server returned failure
         // This is an expected scenario - silently handle it
+        markRefreshTokenDead(refreshToken);
         signOutPrivacyCenter();
         return false;
       }
     } catch (error: any) {
-      // Check if error indicates refresh token is expired/revoked (expected scenario)
-      const errorMessage = error?.message || '';
-      const isRefreshTokenExpired =
-        errorMessage.includes('revoked') ||
-        errorMessage.includes('expired') ||
-        errorMessage.includes('Refresh token') ||
-        errorMessage.includes('Invalid refresh token') ||
-        errorMessage.includes('401') ||
-        errorMessage.includes('Unauthorized');
-
-      if (isRefreshTokenExpired) {
-        // Refresh token is expired/revoked - silently handle (expected scenario)
+      if (isTerminalRefreshError(error)) {
+        // Refresh token is expired / not found / already used - trip the breaker.
+        markRefreshTokenDead(refreshToken);
         signOutPrivacyCenter();
         return false;
       }
 
-      // For other errors (network, etc.), log and don't clear auth state - might be temporary
+      // Transient (network / 5xx): keep auth state, back off, retry on a later call.
+      noteTransientRefreshFailure();
       console.error('[Token Refresh] Unexpected error refreshing token:', error);
       return false;
     }
@@ -323,12 +467,10 @@ export const signOutPrivacyCenter = (): void => {
     sessionStorage.removeItem(key);
   });
 
-  // Clear refresh token cookie set for privacy center
-  document.cookie =
-    'refresh_token=; path=/privacy-center; expires=Thu, 01 Jan 1970 00:00:00 GMT';
-  // Fallback in case the cookie path differs
-  document.cookie =
-    'refresh_token=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT';
+  // Clear the persisted refresh token (and the SDK's own legacy cookie from
+  // older versions). The host app's path=/ cookie is intentionally left alone.
+  removeStorage(REFRESH_TOKEN_STORAGE_KEY);
+  clearLegacyRefreshTokenCookie();
 };
 
 /**
@@ -371,6 +513,22 @@ export const ensureValidToken = async (
     return accessToken;
   }
 
+  // Circuit breaker: before any network work, consult the failure memory.
+  // (Incident 2026-06-22 — stops the /otp/refresh retry storm at its source.)
+  const activeRefreshToken = getActiveRefreshToken(authContext);
+  // A new refresh token value means the user re-authenticated — re-arm the breaker.
+  if (deadRefreshToken !== null && activeRefreshToken !== deadRefreshToken) {
+    resetRefreshCircuit();
+  }
+  // Known-dead token: do not touch the network until a different token appears.
+  if (activeRefreshToken !== null && activeRefreshToken === deadRefreshToken) {
+    return null;
+  }
+  // Transient-failure backoff window still open: skip the network.
+  if (Date.now() < transientRefreshFailureUntil) {
+    return null;
+  }
+
   // Token is missing or expired, need to refresh
   // Use lock to prevent concurrent refresh attempts
   if (isRefreshing && refreshPromise) {
@@ -430,26 +588,19 @@ const performTokenRefresh = async (
     return null;
   }
 
-  // Use context refreshToken if provided, otherwise fall back to cookie
-  // If authContext is provided, prioritize its refreshToken (props mode)
-  // Otherwise, fall back to cookie (legacy mode)
-  let refreshTokenValue: string | null = null;
-
-  if (authContext) {
-    // Props mode: use refreshToken from context
-    refreshTokenValue = authContext.refreshToken || null;
-  } else {
-    // Legacy mode: use refreshToken from cookie
-    refreshTokenValue = getCookieValue('refresh_token');
-  }
+  // Resolve the refresh token (props mode → context, legacy mode → storage) via
+  // the shared helper so the value matches what the circuit breaker keyed on.
+  const refreshTokenValue: string | null = getActiveRefreshToken(authContext);
 
   // Validate refreshToken is a non-empty string
   if (!refreshTokenValue || typeof refreshTokenValue !== 'string' || refreshTokenValue.trim() === '') {
     // No refresh token available - user needs to sign in again
+    // Log presence only — never the raw token, which would leak a credential to
+    // browser log collectors.
     console.warn('[Token Refresh] No valid refresh token available', {
       hasAuthContext: !!authContext,
-      refreshTokenFromContext: authContext?.refreshToken,
-      refreshTokenFromCookie: getCookieValue('refresh_token'),
+      hasRefreshTokenInContext: !!authContext?.refreshToken?.trim(),
+      hasRefreshTokenInStorage: !!getStoredRefreshToken(),
     });
     const error = new Error('No refresh token available');
     // Call onError if provided, check return value before proceeding
@@ -478,6 +629,7 @@ const performTokenRefresh = async (
         // Validate the new token is not expired before storing
         if (isJwtExpired(newAccessToken, TOKEN_EXPIRY_BUFFER_SECONDS)) {
           console.error('[Token Refresh] New access token is already expired');
+          markRefreshTokenDead(refreshToken);
           const error = new Error('New access token is already expired');
           // Call onError if provided, check return value before proceeding
           if (authContext?.onError) {
@@ -501,11 +653,14 @@ const performTokenRefresh = async (
           }
         }
 
+        // Success — re-arm the circuit breaker so future failures are tracked afresh.
+        resetRefreshCircuit();
         // Return the new access token directly (already stored in sessionStorage/context)
         return newAccessToken;
       } else {
         // No access token in response - refresh failed
         console.error('[Token Refresh] Response missing access token');
+        markRefreshTokenDead(refreshToken);
         const error = new Error('Response missing access token');
         // Call onError if provided, check return value before proceeding
         if (authContext?.onError) {
@@ -520,6 +675,7 @@ const performTokenRefresh = async (
       }
     } else {
       // Refresh token expired/revoked or server returned failure
+      markRefreshTokenDead(refreshToken);
       const error = new Error('Refresh token expired or revoked');
       // Call onError if provided, check return value before proceeding
       if (authContext?.onError) {
@@ -533,19 +689,12 @@ const performTokenRefresh = async (
       return null;
     }
   } catch (error: any) {
-    const errorMessage = error?.message || '';
-    const isRefreshTokenExpired =
-      errorMessage.includes('revoked') ||
-      errorMessage.includes('expired') ||
-      errorMessage.includes('Refresh token') ||
-      errorMessage.includes('Invalid refresh token') ||
-      errorMessage.includes('401') ||
-      errorMessage.includes('Unauthorized');
-
-    if (isRefreshTokenExpired) {
-      // Refresh token is expired/revoked - expected scenario
+    if (isTerminalRefreshError(error)) {
+      // Terminal: refresh token expired / not found / already used / 4xx. Trip the
+      // breaker so this dead token is never re-submitted (onError controls
+      // navigation only — the breaker has already tripped).
+      markRefreshTokenDead(refreshToken);
       const err = new Error('Refresh token expired or revoked');
-      // Call onError if provided, check return value before proceeding
       if (authContext?.onError) {
         const shouldProceed = authContext.onError(err);
         if (!shouldProceed) {
@@ -557,7 +706,8 @@ const performTokenRefresh = async (
       return null;
     }
 
-    // For other errors (network, etc.), log but don't clear auth state
+    // Transient (network / 5xx): keep auth state, back off, and let a later call retry.
+    noteTransientRefreshFailure();
     console.error('[Token Refresh] Unexpected error:', error);
     // Still call onError for unexpected errors
     if (authContext?.onError) {

package/src/RedactoPrivacyCenter/locales/en/translation.json

@@ -138,6 +138,9 @@
   "activities": "Activities",
   "activitiesSubtitle": "View your privacy center activity history",
   "activity": "Activity",
+  "allCaughtUp": "You're all caught up",
+  "noActivitiesYet": "No activity yet",
+  "noActivitiesDescription": "Your privacy center activity will appear here as it happens.",
   "myReceipt": "My Receipt",
   "myReceiptSubtitle": "View your consent receipts",
   "event": "Event",

package/src/RedactoPrivacyCenter/styles/injectStyles.ts

@@ -386,6 +386,22 @@ export const injectPCStyles = () => {
       transition: max-height 0.3s ease, padding 0.3s ease !important;
     }
 
+    /* Activity Timeline */
+    .pc-timeline-content {
+      transition: background-color var(--pc-transition-fast) !important;
+    }
+    .pc-timeline-row:hover .pc-timeline-content {
+      background-color: var(--pc-bg-secondary) !important;
+    }
+    .pc-timeline-item {
+      animation: pc-fadeIn 0.2s ease both;
+    }
+    @media (prefers-reduced-motion: reduce) {
+      .pc-timeline-item {
+        animation: none !important;
+      }
+    }
+
     /* Scrollbar Styles (for better UX) */
     .pc-scrollbar::-webkit-scrollbar {
       width: 8px;

package/src/index.ts

@@ -1,5 +1,7 @@
 export { default as RedactoNoticeConsent } from "./RedactoNoticeConsent";
 export { default as RedactoNoticeConsentInline } from "./RedactoNoticeConsentInline";
+export { default as RedactoNoticeAssisted } from "./RedactoNoticeAssisted";
+export type { RedactoNoticeAssistedProps } from "./RedactoNoticeAssisted/RedactoNoticeAssisted";
 
 // Guardian Verification Components
 export { DigiLockerCallback } from "./RedactoNoticeConsent/components/DigiLockerCallback";

package/src/shared/api-errors.ts

@@ -52,6 +52,10 @@ interface ApiErrorDetail {
 interface ApiErrorBody {
   message?: string;
   error_code?: string | null;
+  // Some endpoints (e.g. OTP verify) signal "this code is dead, request a fresh
+  // one" via a top-level boolean instead of an `error_code`. Captured so callers
+  // can branch on it (e.g. to distinguish an expired code from a wrong one).
+  should_request_new?: boolean;
   // `detail` may arrive as:
   //   { message: "...", error_code: "..." }    -- our MessageResponse via Ninja
   //   { detail: "..." }                         -- Ninja auto-401
@@ -69,16 +73,20 @@ export type ApiErrorCodeLike = ApiErrorCode | (string & {});
 export class ApiError extends Error {
   readonly status: number;
   readonly code?: ApiErrorCodeLike;
+  // Mirrors the server's `should_request_new` flag, when present.
+  readonly shouldRequestNew?: boolean;
 
   constructor(opts: {
     status: number;
     code?: ApiErrorCodeLike;
     message: string;
+    shouldRequestNew?: boolean;
   }) {
     super(opts.message);
     this.name = "ApiError";
     this.status = opts.status;
     this.code = opts.code;
+    this.shouldRequestNew = opts.shouldRequestNew;
   }
 }
 
@@ -167,5 +175,6 @@ export async function parseApiError(
     status: response.status,
     code,
     message,
+    shouldRequestNew: body?.should_request_new,
   });
 }

package/src/RedactoPrivacyCenter/components/activitiesColumns.tsx

@@ -1,141 +0,0 @@
-import { useMemo } from 'react';
-import { useTranslation } from 'react-i18next';
-import { createColumnHelper } from '@tanstack/react-table';
-import { PCText, PCTooltip } from '../ui';
-import { pcStyles } from '../styles/pcStyles';
-import dayjs from 'dayjs';
-import relativeTime from 'dayjs/plugin/relativeTime';
-import type { Activity } from '../lib/types';
-import StatusBadge from '../ui/StatusBadge';
-import { getActivityTypeStatus, formatActivityType } from '../lib/utils';
-import {
-  ACTIVITY_COLUMN_SIZES,
-  ACTIVITY_DESCRIPTION_TRUNCATE_LENGTH,
-  ACTIVITY_DATE_FORMATS,
-} from '../lib/constants';
-
-dayjs.extend(relativeTime);
-
-const columnHelper = createColumnHelper<Activity>();
-
-export const useActivitiesColumns = () => {
-  const { t } = useTranslation();
-  return useMemo(
-    () => [
-  columnHelper.accessor('title', {
-    id: 'title',
-    minSize: ACTIVITY_COLUMN_SIZES.TITLE,
-    header: t('activity'),
-    cell: (info) => {
-      const row = info.row.original;
-      const title = row.title_display || info.getValue();
-      return (
-        <div style={{ paddingTop: pcStyles.pySm.paddingTop, paddingBottom: pcStyles.pySm.paddingBottom }}>
-          <PCText size="sm" weight="medium" color="primary">
-            {title}
-          </PCText>
-        </div>
-      );
-    },
-    enableSorting: false,
-    enableColumnFilter: false,
-  }),
-  columnHelper.accessor('activity_type', {
-    id: 'activity_type',
-    minSize: ACTIVITY_COLUMN_SIZES.ACTIVITY_TYPE,
-    header: t('activityType'),
-    cell: (info) => {
-      const activityType = info.getValue();
-      const row = info.row.original;
-      const displayType = row.activity_type_display || formatActivityType(activityType);
-      const status = getActivityTypeStatus(activityType);
-
-      return (
-        <div style={{ paddingTop: pcStyles.pySm.paddingTop, paddingBottom: pcStyles.pySm.paddingBottom }}>
-          <StatusBadge status={status} className="pc-status-badge">
-            {displayType}
-          </StatusBadge>
-        </div>
-      );
-    },
-    enableSorting: false,
-    enableColumnFilter: false,
-  }),
-  columnHelper.accessor('description', {
-    id: 'description',
-    minSize: ACTIVITY_COLUMN_SIZES.DESCRIPTION,
-    header: t('activityDescription'),
-    cell: (info) => {
-      const row = info.row.original;
-      const description = row.description_display || info.getValue();
-      const truncatedDescription =
-        description.length > ACTIVITY_DESCRIPTION_TRUNCATE_LENGTH
-          ? `${description.substring(0, ACTIVITY_DESCRIPTION_TRUNCATE_LENGTH)}...`
-          : description;
-
-      return (
-        <div style={{ paddingTop: pcStyles.pySm.paddingTop, paddingBottom: pcStyles.pySm.paddingBottom }}>
-          {description.length > ACTIVITY_DESCRIPTION_TRUNCATE_LENGTH ? (
-            <PCTooltip content={description} placement="top">
-              <span style={{ display: 'block', cursor: 'help' }}>
-                <PCText size="sm" color="secondary" style={{
-                  display: '-webkit-box',
-                  WebkitLineClamp: 2,
-                  WebkitBoxOrient: 'vertical',
-                  overflow: 'hidden',
-                }}>
-                  {truncatedDescription}
-                </PCText>
-              </span>
-            </PCTooltip>
-          ) : (
-            <PCText size="sm" color="secondary">
-              {description}
-            </PCText>
-          )}
-        </div>
-      );
-    },
-    enableSorting: false,
-    enableColumnFilter: false,
-  }),
-  columnHelper.accessor('timestamp', {
-    id: 'timestamp',
-    minSize: ACTIVITY_COLUMN_SIZES.TIMESTAMP,
-    header: t('timestamp'),
-    cell: (info) => {
-      const timestamp = info.getValue();
-      const date = dayjs(timestamp);
-      const formattedDateTime = date.format(ACTIVITY_DATE_FORMATS.DISPLAY);
-      const relativeTime = date.fromNow();
-
-      return (
-        <div style={{ paddingTop: pcStyles.pySm.paddingTop, paddingBottom: pcStyles.pySm.paddingBottom }}>
-          <PCTooltip
-            content={date.format(ACTIVITY_DATE_FORMATS.TOOLTIP)}
-            placement="top"
-          >
-            <div style={{
-              ...pcStyles.flex,
-              ...pcStyles.flexCol,
-              minWidth: '120px',
-              gap: '0.125rem',
-            }}>
-              <PCText size="sm" weight="medium" color="primary">
-                {formattedDateTime}
-              </PCText>
-              <PCText size="sm" color="secondary" style={{ fontSize: '0.75rem' }}>
-                {relativeTime}
-              </PCText>
-            </div>
-          </PCTooltip>
-        </div>
-      );
-    },
-    enableSorting: false,
-    enableColumnFilter: false,
-  }),
-],
-    [t]
-  );
-};