@redacto.io/consent-sdk-react 10.0.0-beta.9 → 10.0.0

package/src/RedactoPrivacyCenter/components/utils.tsx

@@ -1,10 +0,0 @@
-import { getStatusColor as getSharedStatusColor } from '../utils/status';
-import { formatDateShort } from '../utils/date';
-
-// Re-export shared utilities with case-specific naming
-export const getStatusColor = (status: string) => {
-    return getSharedStatusColor({ status });
-};
-
-// Re-export shared date formatting
-export const formatDate = formatDateShort;

package/src/RedactoPrivacyCenter/config/routes.ts

@@ -1,9 +0,0 @@
-export const routes = {
-  cmp: {
-    privacyCenter: {
-      home: '/privacy-center',
-      signIn: (slug: string) => `/privacy-center/${slug}/sign-in`,
-      dashboard: (slug: string) => `/privacy-center/${slug}/home`,
-    },
-  },
-};

package/src/RedactoPrivacyCenter/config/table.ts

@@ -1,25 +0,0 @@
-/**
- * Unified table and pagination configuration constants
- */
-
-export const DEFAULT_PAGE = 1;
-export const DEFAULT_PAGE_SIZE = 10;
-export const INITIAL_PAGE = 1;
-export const INITIAL_PAGE_SIZE = 10;
-
-export const PAGE_SIZE_OPTIONS = [
-  { value: 10, label: '10' },
-  { value: 15, label: '15' },
-  { value: 20, label: '20' },
-  { value: 25, label: '25' },
-  { value: 50, label: '50' },
-  { value: 100, label: '100' },
-] as const;
-
-export const TABLE_CONFIG = {
-  pageSize: DEFAULT_PAGE_SIZE,
-  maxDisplayPurposes: 3,
-} as const;
-
-export const SEARCH_DEBOUNCE_DELAY = 500;
-export const SKELETON_ROW_COUNT = 5;

package/src/RedactoPrivacyCenter/context/AuthContext.tsx

@@ -1,252 +0,0 @@
-import { createContext, useContext, useState, useEffect, useCallback, useMemo } from 'react';
-import { setRefreshTokenCookie, decodeJwtToken, resolveContactFromJwt, setSessionExpiredListener } from '../lib/utils';
-import { setSandboxConfig } from '../lib/sandbox';
-import type {
-  AuthContextValue,
-  AuthProviderProps,
-  SeedSessionStorageData,
-} from './types';
-
-export type { AuthContextValue } from './types';
-
-const AuthContext = createContext<AuthContextValue | null>(null);
-
-/**
- * Raw sessionStorage writer for the five keys the Privacy Center reads
- * (access_token / pc_org_id / pc_workspace_id / pc_org_slug / email). Single
- * source of truth for those key names so the JWT and sandbox seeding paths can
- * never drift. Each key is written only when its value is a non-empty string;
- * `accessToken` is optional because the JWT path stores it separately. The
- * `contact` value goes under the `email` key even when it is a mobile number
- * (matching resolveContactFromJwt, which also stores mobile/org_user_id
- * subjects there). No-ops when `window` is unavailable (SSR).
- */
-const seedSessionStorage = (data: SeedSessionStorageData): void => {
-  if (typeof window === 'undefined') {
-    return;
-  }
-  if (data.accessToken) sessionStorage.setItem('access_token', data.accessToken);
-  if (data.orgId) sessionStorage.setItem('pc_org_id', data.orgId);
-  if (data.workspaceId) sessionStorage.setItem('pc_workspace_id', data.workspaceId);
-  if (data.slug) sessionStorage.setItem('pc_org_slug', data.slug);
-  if (data.contact) sessionStorage.setItem('email', data.contact);
-};
-
-/**
- * Seed the sessionStorage keys the Privacy Center reads (org/workspace/slug/
- * email/access_token) from the sandbox props and register the module-level
- * sandbox config, so the fetch + auth layers switch to sandbox headers and skip
- * token refresh. Returns true when sandbox mode was configured.
- */
-const configureSandbox = (props: AuthProviderProps): boolean => {
-  const token = props.token?.trim();
-  if (!token) {
-    setSandboxConfig(null);
-    return false;
-  }
-
-  const organisationUuid = props.organisationUuid?.trim() ?? '';
-  const workspaceUuid = props.workspaceUuid?.trim() ?? '';
-  const ucic = props.sandboxUcic?.trim() ?? '';
-  const subject = props.sandboxSubject?.trim() ?? '';
-  const slug = props.slug?.trim() ?? '';
-
-  setSandboxConfig({
-    token,
-    ucic: ucic || undefined,
-    subject,
-    organisationUuid,
-    workspaceUuid,
-    slug,
-  });
-
-  seedSessionStorage({
-    accessToken: token,
-    orgId: organisationUuid,
-    workspaceId: workspaceUuid,
-    slug,
-    contact: ucic || subject,
-  });
-  return true;
-};
-
-/**
- * Extract and store organization/auth data from JWT token to sessionStorage
- * This makes the SDK self-sufficient - it doesn't depend on host app to set these values
- */
-const syncJwtDataToSessionStorage = (accessToken: string): void => {
-  if (typeof window === 'undefined') return;
-
-  const decoded = decodeJwtToken(accessToken);
-  if (!decoded) {
-    return;
-  }
-
-  // Resolve the user's contact identifier (email, or mobile/org_user_id for
-  // mobile-only logins) so case + consent-management actions have a subject.
-  // Falls back to previously stored values when the token omits identifiers.
-  const contact = resolveContactFromJwt(decoded)
-    || sessionStorage.getItem('email')
-    || (typeof localStorage !== 'undefined' ? localStorage.getItem('userEmail') : null);
-
-  // The access_token is stored separately by the caller (state initializer /
-  // updateTokens), so it is intentionally omitted here.
-  seedSessionStorage({
-    orgId: typeof decoded.organisation_uuid === 'string' ? decoded.organisation_uuid : undefined,
-    workspaceId: typeof decoded.workspace_uuid === 'string' ? decoded.workspace_uuid : undefined,
-    slug: typeof decoded.organisation_slug === 'string' ? decoded.organisation_slug : undefined,
-    contact: typeof contact === 'string' ? contact : undefined,
-  });
-};
-
-export const AuthProvider = (props: AuthProviderProps) => {
-  const {
-    children,
-    accessToken: initialAccessToken,
-    refreshToken: initialRefreshToken,
-    token: sandboxToken,
-    sandboxUcic,
-    sandboxSubject,
-    organisationUuid,
-    workspaceUuid,
-    slug,
-    onError,
-  } = props;
-
-  // Sandbox PoC: configure the module singleton + seed sessionStorage BEFORE any
-  // child renders (same reason the JWT sync runs in the state initializer). This
-  // MUST run during render, not in a useEffect: child effects (which fire the
-  // first data fetch and read `sandboxAuthHeaders()` synchronously) run on commit
-  // BEFORE the parent's effects, so an effect here would configure the singleton
-  // too late. A useState lazy initializer runs once on the first render, ahead of
-  // any child, and is not re-run on subsequent parent re-renders — so it sets the
-  // config before the first fetch without the every-render side effect. When
-  // active, the JWT path below is skipped entirely.
-  const [sandboxActive] = useState(() => configureSandbox(props));
-
-  // Sync to sessionStorage synchronously during initialization so child
-  // components (ConsentManager, SideBarPC) find the data when they mount.
-  // useEffect runs AFTER children render — too late for components that
-  // read sessionStorage during their render phase.
-  const [accessToken, setAccessToken] = useState(() => {
-    if (sandboxActive) {
-      return sandboxToken ?? '';
-    }
-    if (initialAccessToken && typeof initialAccessToken === 'string' && initialAccessToken.trim() !== '') {
-      if (typeof window !== 'undefined') {
-        sessionStorage.setItem('access_token', initialAccessToken);
-        syncJwtDataToSessionStorage(initialAccessToken);
-      }
-    }
-    return initialAccessToken ?? '';
-  });
-  const [refreshToken, setRefreshToken] = useState(() => {
-    if (sandboxActive) {
-      return '';
-    }
-    if (initialRefreshToken && typeof initialRefreshToken === 'string' && initialRefreshToken.trim() !== '') {
-      if (typeof window !== 'undefined') {
-        setRefreshTokenCookie(initialRefreshToken);
-      }
-    }
-    return initialRefreshToken ?? '';
-  });
-
-  // Terminal "session expired" flag. Set by utils' refresh routines (via the
-  // module listener registered below) when the refresh token is dead; reset when
-  // a new refresh token appears (re-auth) so the breaker and the screen recover
-  // together. Drives the shared session-expired screen and gates all fetching.
-  const [sessionExpired, setSessionExpired] = useState(false);
-  const markSessionExpired = useCallback(() => setSessionExpired(true), []);
-
-  // Bridge the module-level refresh routines to React state. utils calls the
-  // registered listener on terminal failure; this is the same single-instance
-  // singleton model as the OTP refresh circuit breaker.
-  useEffect(() => {
-    setSessionExpiredListener(markSessionExpired);
-    return () => setSessionExpiredListener(null);
-  }, [markSessionExpired]);
-
-  // Re-sync when props change (for token refresh scenarios). Sandbox mode has no
-  // JWT and no refresh, so these are no-ops there.
-  useEffect(() => {
-    if (sandboxActive) {
-      return;
-    }
-    if (initialAccessToken && typeof initialAccessToken === 'string' && initialAccessToken.trim() !== '') {
-      setAccessToken(initialAccessToken);
-      if (typeof window !== 'undefined') {
-        sessionStorage.setItem('access_token', initialAccessToken);
-        syncJwtDataToSessionStorage(initialAccessToken);
-      }
-    }
-  }, [initialAccessToken, sandboxActive]);
-
-  useEffect(() => {
-    if (sandboxActive) {
-      return;
-    }
-    if (initialRefreshToken && typeof initialRefreshToken === 'string' && initialRefreshToken.trim() !== '') {
-      setRefreshToken(initialRefreshToken);
-      // A fresh refresh token means the user re-authenticated — clear the
-      // terminal state (the breaker auto-re-arms on the next ensureValidToken).
-      setSessionExpired(false);
-      if (typeof window !== 'undefined') {
-        setRefreshTokenCookie(initialRefreshToken);
-      }
-    }
-  }, [initialRefreshToken, sandboxActive]);
-
-  // Sandbox PoC: re-configure the module singleton when the sandbox inputs
-  // change after mount (the lazy initializer above only runs once, on first
-  // render — this mirrors the JWT re-sync effects for prop changes). Clears the
-  // singleton on unmount so a later JWT-mode mount never inherits a stale sandbox
-  // config. First-fetch ordering is unaffected: the initializer already set the
-  // config before any child effect ran.
-  useEffect(() => {
-    if (!sandboxActive) {
-      return;
-    }
-    configureSandbox(props);
-    return () => setSandboxConfig(null);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [sandboxActive, sandboxToken, sandboxUcic, sandboxSubject, organisationUuid, workspaceUuid, slug]);
-
-  // Internal method to update tokens after refresh
-  const updateTokens = useCallback((newAccessToken: string, newRefreshToken?: string) => {
-    setAccessToken(newAccessToken);
-    if (newRefreshToken) {
-      setRefreshToken(newRefreshToken);
-    }
-    // A successful refresh clears any prior terminal state.
-    setSessionExpired(false);
-    // Also update storage
-    if (typeof window !== 'undefined') {
-      sessionStorage.setItem('access_token', newAccessToken);
-      // Extract and store org/auth data from JWT
-      syncJwtDataToSessionStorage(newAccessToken);
-      if (newRefreshToken) {
-        setRefreshTokenCookie(newRefreshToken);
-      }
-    }
-  }, []);
-
-  // Memoize context value to prevent unnecessary re-renders
-  const value: AuthContextValue = useMemo(() => ({
-    accessToken,
-    refreshToken,
-    onError,
-    updateTokens,
-    sessionExpired,
-  }), [accessToken, refreshToken, onError, updateTokens, sessionExpired]);
-
-  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
-};
-
-export const useAuth = (): AuthContextValue => {
-  const context = useContext(AuthContext);
-  if (!context) {
-    throw new Error('useAuth must be used within an AuthProvider');
-  }
-  return context;
-};

package/src/RedactoPrivacyCenter/context/BaseUrlContext.tsx

@@ -1,47 +0,0 @@
-import { createContext, useContext, useMemo, type ReactNode } from 'react';
-import { createConsentClient } from '../api/client';
-import type { BaseUrlContextValue } from './types';
-
-export type { BaseUrlContextValue } from './types';
-
-export const BaseUrlContext = createContext<BaseUrlContextValue | null>(null);
-
-export const BaseUrlProvider = ({
-  children,
-  baseUrl,
-  ledgerBaseUrl,
-}: {
-  children: ReactNode;
-  baseUrl: string; // Consent server base URL
-  ledgerBaseUrl?: string; // Go ledger base URL — serves user-consents
-}) => {
-  const consentClient = useMemo(
-    () => createConsentClient(baseUrl, ledgerBaseUrl),
-    [baseUrl, ledgerBaseUrl]
-  );
-
-  const value: BaseUrlContextValue = useMemo(
-    () => ({
-      baseUrl,
-      ledgerBaseUrl,
-      consentClient,
-    }),
-    [baseUrl, ledgerBaseUrl, consentClient]
-  );
-
-  return (
-    <BaseUrlContext.Provider value={value}>
-      {children}
-    </BaseUrlContext.Provider>
-  );
-};
-
-export const useBaseUrl = () => {
-  const context = useContext(BaseUrlContext);
-  if (!context) {
-    throw new Error(
-      'useBaseUrl must be used within a BaseUrlProvider'
-    );
-  }
-  return context;
-};

package/src/RedactoPrivacyCenter/context/BrandingContext.tsx

@@ -1,52 +0,0 @@
-import { createContext, useContext, useEffect, useState, type ReactNode } from 'react';
-import { fetchOrgBranding } from '../api/orgBranding';
-import { applyBrandingTheme, clearBrandingTheme } from '../styles/applyBrandingTheme';
-import type { OrgBrandingDetail } from '../lib/types';
-
-type BrandingContextValue = { branding: OrgBrandingDetail | null };
-
-const BrandingContext = createContext<BrandingContextValue | null>(null);
-
-export const BrandingProvider = ({
-  children,
-  slug,
-  baseUrl,
-}: {
-  children: ReactNode;
-  slug: string;
-  baseUrl: string;
-}) => {
-  const [branding, setBranding] = useState<OrgBrandingDetail | null>(null);
-
-  useEffect(() => {
-    if (!slug) return;
-    let cancelled = false;
-    fetchOrgBranding(slug, baseUrl)
-      .then((data) => {
-        if (!cancelled) setBranding(data);
-      })
-      .catch((error) => {
-        console.warn('[RedactoPrivacyCenter] org branding fetch failed:', error);
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [slug, baseUrl]);
-
-  useEffect(() => {
-    if (!branding) return;
-    applyBrandingTheme(branding.theme);
-    return clearBrandingTheme;
-  }, [branding]);
-
-  return (
-    <BrandingContext.Provider value={{ branding }}>
-      {children}
-    </BrandingContext.Provider>
-  );
-};
-
-export const useBranding = (): OrgBrandingDetail | null => {
-  const ctx = useContext(BrandingContext);
-  return ctx?.branding ?? null;
-};

package/src/RedactoPrivacyCenter/context/DataAvailabilityContext.session-expired.test.tsx

@@ -1,92 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { render, screen, waitFor, cleanup } from '@testing-library/react';
-import {
-  DataAvailabilityProvider,
-  useDataAvailability,
-} from './DataAvailabilityContext';
-
-/**
- * Regression: when the session is terminally expired, the DataAvailabilityProvider
- * must NOT fire any data fetch on mount — it goes straight to the 'session-expired'
- * status so the shell renders the terminal screen instead of (fail-open) content.
- */
-
-// Mutable auth state shared with the hoisted mock so each test can flip it.
-const auth = vi.hoisted(() => ({
-  current: {
-    accessToken: 'stale-access-token',
-    refreshToken: 'dead-refresh-token',
-    onError: () => false,
-    updateTokens: () => {},
-    sessionExpired: true,
-  },
-}));
-
-vi.mock('../lib/api', () => ({
-  fetchUserConsents: vi.fn(() => Promise.resolve(null)),
-  fetchActivities: vi.fn(() => Promise.resolve(null)),
-  fetchCaseHistory: vi.fn(() => Promise.resolve(null)),
-}));
-
-vi.mock('./AuthContext', () => ({ useAuth: () => auth.current }));
-vi.mock('./OrganizationContext', () => ({
-  useOrganization: () => ({
-    organization: { uuid: 'org-uuid', workspaces: [{ uuid: 'ws-uuid' }] },
-  }),
-}));
-vi.mock('./BaseUrlContext', () => ({ useBaseUrl: () => ({ consentClient: {} }) }));
-vi.mock('../lib/useCurrentLanguage', () => ({
-  useCurrentLanguage: () => ({ langParam: 'en' }),
-}));
-
-import { fetchUserConsents, fetchActivities, fetchCaseHistory } from '../lib/api';
-
-function StatusProbe() {
-  const { status } = useDataAvailability();
-  return <div data-testid="status">{status}</div>;
-}
-
-describe('DataAvailabilityProvider — session-expired gate', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    sessionStorage.clear();
-    sessionStorage.setItem('email', 'user@example.com');
-    auth.current = {
-      accessToken: 'stale-access-token',
-      refreshToken: 'dead-refresh-token',
-      onError: () => false,
-      updateTokens: () => {},
-      sessionExpired: true,
-    };
-  });
-
-  afterEach(() => cleanup());
-
-  it('does not fetch and reports session-expired when the session is expired', () => {
-    auth.current.sessionExpired = true;
-
-    render(
-      <DataAvailabilityProvider>
-        <StatusProbe />
-      </DataAvailabilityProvider>,
-    );
-
-    expect(screen.getByTestId('status').textContent).toBe('session-expired');
-    expect(fetchUserConsents).not.toHaveBeenCalled();
-    expect(fetchActivities).not.toHaveBeenCalled();
-    expect(fetchCaseHistory).not.toHaveBeenCalled();
-  });
-
-  it('does fetch when the session is NOT expired (gate is meaningful)', async () => {
-    auth.current.sessionExpired = false;
-
-    render(
-      <DataAvailabilityProvider>
-        <StatusProbe />
-      </DataAvailabilityProvider>,
-    );
-
-    await waitFor(() => expect(fetchUserConsents).toHaveBeenCalled());
-    expect(fetchActivities).toHaveBeenCalled();
-  });
-});

package/src/RedactoPrivacyCenter/context/DataAvailabilityContext.tsx

@@ -1,181 +0,0 @@
-import {
-  createContext,
-  useCallback,
-  useContext,
-  useEffect,
-  useMemo,
-  useRef,
-  useState,
-  type ReactNode,
-} from 'react';
-import { fetchUserConsents, fetchActivities, fetchCaseHistory } from '../lib/api';
-import { useCurrentLanguage } from '../lib/useCurrentLanguage';
-import { useOrganization } from './OrganizationContext';
-import { useAuth } from './AuthContext';
-import { useBaseUrl } from './BaseUrlContext';
-
-export type DataAvailabilityStatus =
-  | 'checking'
-  | 'has-data'
-  | 'empty'
-  | 'session-expired';
-
-type DataAvailabilityContextValue = {
-  status: DataAvailabilityStatus;
-};
-
-const DataAvailabilityContext = createContext<DataAvailabilityContextValue | null>(null);
-
-/**
- * Determines whether the authenticated user has ANY data in the Privacy Center
- * (consents, data-request cases, or activity). When all three are empty we
- * surface a dedicated empty state instead of dropping the user into a shell
- * full of empty tables.
- *
- * Fail-open by design: the underlying fetchers return `null` on non-auth
- * errors (and may reject if a post-refresh retry throws). A `null`/rejected
- * signal is treated as "has data" so a transient or auth error never wrongly
- * locks a user out — the empty state shows ONLY when all three signals
- * conclusively resolve to empty.
- */
-export const DataAvailabilityProvider = ({ children }: { children: ReactNode }) => {
-  const { organization } = useOrganization();
-  const { accessToken, refreshToken, onError, updateTokens, sessionExpired } = useAuth();
-  const { consentClient } = useBaseUrl();
-  const { langParam } = useCurrentLanguage();
-
-  const organizationId = organization?.uuid;
-  const workspaceId = organization?.workspaces[0]?.uuid;
-
-  // Memoized to keep the fetch identity stable across renders (mirrors the
-  // canonical pattern in ActivitiesList / AuthContext).
-  const authContext = useMemo(
-    () => ({ accessToken, refreshToken, onError, updateTokens }),
-    [accessToken, refreshToken, onError, updateTokens],
-  );
-
-  const [status, setStatus] = useState<DataAvailabilityStatus>('checking');
-
-  // Monotonic run id guards against a stale in-flight check (org/token changed)
-  // overwriting a newer one; mountedRef guards against setState after unmount.
-  const runIdRef = useRef(0);
-  const mountedRef = useRef(true);
-  useEffect(() => {
-    mountedRef.current = true;
-    return () => {
-      mountedRef.current = false;
-    };
-  }, []);
-
-  const runCheck = useCallback(async () => {
-    if (!organizationId || !workspaceId) return;
-
-    const runId = ++runIdRef.current;
-    setStatus('checking');
-
-    // Cases require the user's email (same source the request Form reads).
-    const contact =
-      typeof window !== 'undefined' ? sessionStorage.getItem('email') : null;
-
-    // Each signal resolves to a boolean "is empty". A `null` result (the
-    // fetchers' non-auth error path) or a rejection (rare post-refresh retry
-    // throw) resolves to `false` so the signal counts as "has data" — the
-    // empty state shows ONLY when all three conclusively resolve to empty.
-    const consentsEmptyP: Promise<boolean> = fetchUserConsents({
-      organizationId,
-      workspaceId,
-      limit: 1,
-      nominatedLimit: 1,
-      language: langParam,
-      authContext,
-      consentClient,
-    })
-      .then(
-        (v) =>
-          !!v &&
-          v.status_summary?.total_purposes === 0 &&
-          (v.direct?.length ?? 0) === 0 &&
-          (v.nominated?.length ?? 0) === 0 &&
-          (v.nominators?.length ?? 0) === 0,
-      )
-      .catch(() => false);
-
-    // No contact => we can't check cases, so treat as empty and rely on the
-    // other two signals' fail-open. With a contact, a null/rejected result
-    // fails open (not empty).
-    const casesEmptyP: Promise<boolean> = contact
-      ? fetchCaseHistory(
-          organizationId,
-          workspaceId,
-          contact,
-          0,
-          1,
-          authContext,
-          consentClient,
-          langParam,
-        )
-          .then((v) => !!v && (v.data?.length ?? 0) === 0)
-          .catch(() => false)
-      : Promise.resolve(true);
-
-    const activitiesEmptyP: Promise<boolean> = fetchActivities(
-      organizationId,
-      workspaceId,
-      0,
-      1,
-      authContext,
-      consentClient,
-      langParam,
-    )
-      .then((v) => !!v && (v.pagination?.total_count ?? 0) === 0)
-      .catch(() => false);
-
-    const [consentsEmpty, casesEmpty, activitiesEmpty] = await Promise.all([
-      consentsEmptyP,
-      casesEmptyP,
-      activitiesEmptyP,
-    ]);
-
-    // Ignore if a newer check superseded this one or we unmounted.
-    if (!mountedRef.current || runId !== runIdRef.current) return;
-
-    setStatus(
-      consentsEmpty && casesEmpty && activitiesEmpty ? 'empty' : 'has-data',
-    );
-  }, [organizationId, workspaceId, authContext, consentClient, langParam]);
-
-  useEffect(() => {
-    // Terminal session: never fetch. Bump the run id so any in-flight runCheck
-    // resolves into a no-op (its fail-open path would otherwise flip the status
-    // back to 'has-data' and remount the content), then show the expired screen.
-    if (sessionExpired) {
-      runIdRef.current += 1;
-      setStatus('session-expired');
-      return;
-    }
-    if (organizationId && workspaceId && accessToken) {
-      void runCheck();
-    }
-  }, [organizationId, workspaceId, accessToken, runCheck, sessionExpired]);
-
-  const value = useMemo<DataAvailabilityContextValue>(
-    () => ({ status }),
-    [status],
-  );
-
-  return (
-    <DataAvailabilityContext.Provider value={value}>
-      {children}
-    </DataAvailabilityContext.Provider>
-  );
-};
-
-export const useDataAvailability = (): DataAvailabilityContextValue => {
-  const ctx = useContext(DataAvailabilityContext);
-  if (!ctx) {
-    throw new Error(
-      'useDataAvailability must be used within a DataAvailabilityProvider',
-    );
-  }
-  return ctx;
-};

package/src/RedactoPrivacyCenter/context/LocaleContext.tsx

@@ -1,11 +0,0 @@
-import { createContext } from 'react';
-
-type LocaleContextType = {
-  locale: string;
-  setLocale: (locale: string) => void;
-};
-
-export const LocaleContext = createContext<LocaleContextType>({
-  locale: 'en',
-  setLocale: () => {},
-});