@osano/osano-cmp-react-native 0.18.4 → 0.18.6

package/src/doNotSell.ts

@@ -0,0 +1,122 @@
+import {
+	ConsentCategory,
+	type ConsentCategoryType,
+	OsanoCategories,
+} from './constants';
+
+// "Do Not Sell / Share" opt-out logic as pure functions, shared by the service
+// layer, reducer, and selectors.
+
+/**
+ * Visible only when `enableDoNotSell` is set and CCPA applies: `ccpaApplies`
+ * when the config provides it, else the US geo fallback (explicit `false` hides
+ * it).
+ */
+export const isDoNotSellVisible = (opts: {
+	enableDoNotSell?: boolean;
+	ccpaApplies?: boolean | null;
+	browsingFromUS?: boolean;
+}): boolean =>
+	!!opts.enableDoNotSell && (opts.ccpaApplies ?? !!opts.browsingFromUS);
+
+/**
+ * The governed categories: config's `doNotSellCategories`, upper-cased and
+ * mapped, falling back to Marketing. ESSENTIAL and OPT_OUT are never governed —
+ * governing OPT_OUT would make it toggle itself off. Tolerant of malformed
+ * input (a non-array, or null/non-string elements from remote/cached config) so
+ * a bad field can't crash the consent UI.
+ */
+export const resolveDoNotSellCategories = (
+	categories?: string[],
+): ConsentCategoryType[] => {
+	const list = Array.isArray(categories) ? categories : [];
+	const mapped = list
+		.filter((category): category is string => typeof category === 'string')
+		.map((category) => category.toUpperCase())
+		.filter(
+			(category): category is ConsentCategoryType =>
+				(OsanoCategories as string[]).includes(category) &&
+				category !== ConsentCategory.ESSENTIAL &&
+				category !== ConsentCategory.OPT_OUT,
+		);
+	return mapped.length ? mapped : [ConsentCategory.MARKETING];
+};
+
+/**
+ * Opt-out precedence: when opted out, forces the governed categories off.
+ * Config-aware, so custom `doNotSellCategories` are honored. No-op when
+ * Do-Not-Sell is off or not opted out.
+ */
+export const normalizeDoNotSellConsent = <
+	T extends Record<ConsentCategoryType, boolean | undefined>,
+>(
+	consent: T,
+	opts: { enableDoNotSell?: boolean; doNotSellCategories?: string[] },
+): T => {
+	if (!opts.enableDoNotSell || !consent[ConsentCategory.OPT_OUT]) {
+		return consent;
+	}
+	const governed = resolveDoNotSellCategories(opts.doNotSellCategories);
+	const result: T = { ...consent };
+	for (const category of governed) {
+		result[category] = false as T[ConsentCategoryType];
+	}
+	return result;
+};
+
+/**
+ * Seeds the Do-Not-Sell default into a starting selection (no-op unless
+ * enabled): default-on opts out and drops the governed categories; default-off
+ * consents them with no opt-out signal.
+ */
+export const applyDoNotSellDefault = (
+	categories: ConsentCategoryType[],
+	opts: {
+		enableDoNotSell?: boolean;
+		enableDoNotSellDefault?: boolean;
+		doNotSellCategories?: string[];
+	},
+): ConsentCategoryType[] => {
+	if (!opts.enableDoNotSell) {
+		return categories;
+	}
+	const governed = resolveDoNotSellCategories(opts.doNotSellCategories);
+	const result: ConsentCategoryType[] = categories.filter(
+		(category) => category !== ConsentCategory.OPT_OUT,
+	);
+	if (opts.enableDoNotSellDefault) {
+		return [
+			...result.filter((category) => !governed.includes(category)),
+			ConsentCategory.OPT_OUT,
+		];
+	}
+	for (const category of governed) {
+		if (!result.includes(category)) {
+			result.push(category);
+		}
+	}
+	return result;
+};
+
+/**
+ * Categories to force off to keep the opt-out and its governed categories
+ * mutually exclusive: opt-out on clears the governed ones; a governed one on
+ * clears the opt-out. Empty when disabled or toggling off.
+ */
+export const doNotSellSideEffects = (
+	category: ConsentCategoryType,
+	isConsented: boolean,
+	opts: { enableDoNotSell?: boolean; doNotSellCategories?: string[] },
+): ConsentCategoryType[] => {
+	if (!opts.enableDoNotSell || !isConsented) {
+		return [];
+	}
+	const governed = resolveDoNotSellCategories(opts.doNotSellCategories);
+	if (category === ConsentCategory.OPT_OUT) {
+		return governed;
+	}
+	if (governed.includes(category)) {
+		return [ConsentCategory.OPT_OUT];
+	}
+	return [];
+};

package/src/index.tsx

@@ -19,6 +19,7 @@ import {
 	makeConsentFromCategories,
 	type ConsentCategoryType,
 } from './constants';
+import { normalizeDoNotSellConsent } from './doNotSell';
 import { OsanoPublicContext } from './context';
 import { usePrevious } from './hooks/usePrevious';
 import useThunkReducer, { type Store } from './hooks/useThunkReducer';
@@ -97,7 +98,11 @@ export const Osano: React.FunctionComponent<
 					 */
 					const categories = Array.isArray(category) ? category : [category];
 					consentedCategories = formatConsentArray(
-						makeConsentFromCategories(categories),
+						normalizeDoNotSellConsent(makeConsentFromCategories(categories), {
+							enableDoNotSell: consentManager.current.config.enableDoNotSell,
+							doNotSellCategories:
+								consentManager.current.config.doNotSellCategories,
+						}),
 					);
 				}
 				return recordConsent(consentManager.current, consentedCategories);
@@ -161,6 +166,15 @@ export const Osano: React.FunctionComponent<
 			return consentManager.current.jurisdiction;
 		}, []);
 
+		const handleSetConsentExpirationTestingMode = useCallback(
+			(expirationSeconds: number | null) => {
+				consentManager.current.setConsentExpirationTestingMode(
+					expirationSeconds,
+				);
+			},
+			[],
+		);
+
 		const context = useMemo(() => {
 			return {
 				locale: consentManager.current.translator.locale,
@@ -172,6 +186,7 @@ export const Osano: React.FunctionComponent<
 				setLocale: handleSetLocale,
 				showBanner: handleShowDialog,
 				showDrawer: handleShowDrawer,
+				setConsentExpirationTestingMode: handleSetConsentExpirationTestingMode,
 				isReady: consentManager.current.loaded,
 			};
 		}, [
@@ -195,6 +210,10 @@ export const Osano: React.FunctionComponent<
 					// We need to reset the state when the configId or customerId changes
 					dispatch(
 						reload({
+							// Pass config so init-time opt-out normalization runs on the
+							// stored consent even in headless consumers, where SET_CONFIG's
+							// UI effect never fires.
+							config: consentManager.current.config,
 							configId: reloadProps.configId,
 							customerId: reloadProps.customerId,
 							consent: reloadProps.consent,

package/src/reducer.ts

@@ -24,6 +24,7 @@ import {
 	OsanoCategories,
 	type ConsentCategoryType,
 } from './constants';
+import { doNotSellSideEffects, normalizeDoNotSellConsent } from './doNotSell';
 import type { Disclosure, OsanoAction, OsanoState } from './types/store';
 import {
 	getFinalOptOutValue,
@@ -36,11 +37,17 @@ import { ConsentConfig } from './ConsentManager';
 
 export const init = (initialArgs: OsanoState & any): OsanoState => {
 	const { consent, ...reloadProps } = initialArgs;
-	const consentRecord = consent
-		? Array.isArray(consent)
-			? makeConsentFromCategories(consent)
-			: { ...consent }
-		: initialState.consent;
+	const consentRecord = normalizeDoNotSellConsent(
+		consent
+			? Array.isArray(consent)
+				? makeConsentFromCategories(consent)
+				: { ...consent }
+			: initialState.consent,
+		{
+			enableDoNotSell: reloadProps.config?.enableDoNotSell,
+			doNotSellCategories: reloadProps.config?.doNotSellCategories,
+		},
+	);
 	return {
 		...initialState,
 		...reloadProps,
@@ -109,11 +116,17 @@ export function reducer(state: OsanoState, action: OsanoAction): OsanoState {
 		 */
 		case SAVE_BEGIN: {
 			const consentedCategories: ConsentCategoryType[] = action.payload;
-			const consent = makeConsentFromCategories(consentedCategories);
+			const consent = normalizeDoNotSellConsent(
+				makeConsentFromCategories(consentedCategories),
+				{
+					enableDoNotSell: state.config?.enableDoNotSell,
+					doNotSellCategories: state.config?.doNotSellCategories,
+				},
+			);
 			return {
 				...state,
 				consent,
-				savedConsent: { ...consent },
+				savedConsent: { ...consent } as Record<ConsentCategoryType, boolean>,
 			};
 		}
 		case CLEAR_CONSENT: {
@@ -144,64 +157,48 @@ export function reducer(state: OsanoState, action: OsanoAction): OsanoState {
 		}
 		case SET_ALL_CONSENT: {
 			const acceptOrDeny = action.payload;
-			return setAllConsent(acceptOrDeny)(state);
+			const next = setAllConsent(acceptOrDeny)(state);
+			return {
+				...next,
+				consent: normalizeDoNotSellConsent(next.consent, {
+					enableDoNotSell: state.config?.enableDoNotSell,
+					doNotSellCategories: state.config?.doNotSellCategories,
+				}),
+			};
 		}
 		case TOGGLE_CATEGORY: {
-			const { category, value } = action.payload;
+			// The action creator accepts either the shorthand string form
+			// (toggleCategory(ConsentCategory.X)) or an explicit { category, value }.
+			const { category, value } =
+				typeof action.payload === 'string'
+					? { category: action.payload, value: undefined }
+					: action.payload;
 			if (typeof category !== 'string') {
 				return state;
 			}
+			const key = category as ConsentCategoryType;
 
-			// don't turn MARKETING on if OPT_OUT is already on
-			if (
-				category === ConsentCategory.MARKETING &&
-				state.consent[ConsentCategory.OPT_OUT] === true
-			) {
-				return state;
-			}
+			// Resolve the new value: an explicit boolean, otherwise flip the current
+			// value (an unset category defaults to on).
+			const current = state.consent[key];
+			const newValue =
+				typeof value === 'boolean'
+					? value
+					: current !== undefined
+						? !current
+						: true;
 
-			// turn MARKETING off if turning on OPT_OUT
-			if (
-				category === ConsentCategory.OPT_OUT &&
-				value === true &&
-				state.consent[ConsentCategory.MARKETING]
-			) {
-				return {
-					...state,
-					consent: {
-						...state.consent,
-						[ConsentCategory.MARKETING]: false,
-						[category as ConsentCategoryType]: value,
-					},
-				};
-			}
+			// Keep the opt-out and its governed categories mutually exclusive.
+			const forcedOff = doNotSellSideEffects(key, newValue, {
+				enableDoNotSell: state.config?.enableDoNotSell,
+				doNotSellCategories: state.config?.doNotSellCategories,
+			});
 
-			if (typeof value === 'boolean') {
-				return {
-					...state,
-					consent: {
-						...state.consent,
-						[category as ConsentCategoryType]: value,
-					},
-				};
+			const consent = { ...state.consent, [key]: newValue };
+			for (const forced of forcedOff) {
+				consent[forced] = false;
 			}
-			if (state.consent[category as ConsentCategoryType] !== undefined) {
-				return {
-					...state,
-					consent: {
-						...state.consent,
-						[category as ConsentCategoryType]:
-							!state.consent[category as ConsentCategoryType],
-					},
-				};
-			}
-			return {
-				...state,
-				consent: {
-					...state.consent,
-					[category as ConsentCategoryType]: true,
-				},
-			};
+			return { ...state, consent };
 		}
 		case SHOW_DIALOG:
 			return {

package/src/selectors.ts

@@ -5,6 +5,7 @@ import {
 } from './constants';
 import type { Disclosure, OsanoState } from './types/store';
 
+import { resolveDoNotSellCategories } from './doNotSell';
 import { get } from './utils';
 
 export const isCategoryAccepted = (
@@ -14,14 +15,36 @@ export const isCategoryAccepted = (
 
 export const isAnalyticsAlwaysAllowed = (state: OsanoState) =>
 	!!state.config?.type.analyticsAlways;
+
+export const isBrowsingFromUS = (state: OsanoState) =>
+	!!state.config?.browsingFromUS;
+
+export const isDoNotSellEnabled = (state: OsanoState) =>
+	!!state.config?.enableDoNotSell;
+
+// Whether to render the "Do Not Sell / Share" opt-out toggle. Delegates to the
+// config's visibility rule (tenant flag AND ccpaApplies/US).
+export const shouldRenderOptOut = (state: OsanoState) =>
+	!!state.config?.isDoNotSellVisible;
+
+// The categories the opt-out governs (config's doNotSellCategories, defaulting
+// to Marketing). ESSENTIAL and OPT_OUT are never governed.
+const isGovernedByOptOut = (state: OsanoState, category: ConsentCategoryType) =>
+	resolveDoNotSellCategories(state.config?.doNotSellCategories).includes(
+		category,
+	);
+
 export const isCategoryDisabled = (
 	state: OsanoState,
 	category: ConsentCategoryType,
 ) =>
 	category === ConsentCategory.ESSENTIAL ||
 	(category === ConsentCategory.OPT_OUT && isGPCSupportEnabled(state)) ||
-	(category === ConsentCategory.MARKETING &&
-		(state.config?.shouldRenderOptOut || isGPCSupportEnabled(state)) &&
+	// A governed category is locked off while the opt-out is active. Keyed off the
+	// configured governed categories, so a non-governed category (e.g. Marketing
+	// when the tenant governs Analytics) stays enabled.
+	(isGovernedByOptOut(state, category) &&
+		(shouldRenderOptOut(state) || isGPCSupportEnabled(state)) &&
 		isCategoryAccepted(state, ConsentCategory.OPT_OUT));
 
 export const isDrawerOpen = (state: OsanoState) => state.stack.length > 0;