@osano/osano-cmp-react-native 0.1.0 → 0.2.0

package/src/hooks/useThunkReducer.ts

@@ -8,20 +8,30 @@ import {
 	type Reducer,
 	type ReducerState,
 	type Dispatch,
+	useMemo,
 } from 'react';
+import useBoundCallback from './useBoundCallback';
 
 export type Store<S, A> = {
-	getState: GetState<S>;
+	addMiddleware: (
+		m: (store: Store<S, A>) => (next: MiddlewareNext<A>) => MiddlewareNext<A>
+	) => void;
+	addReducer: (r: Reducer<S, A>) => void;
 	dispatch: ThunkDispatch<S, A, any>;
+	getState: GetState<S>;
+	removeMiddleware: (
+		m: (store: Store<S, A>) => (next: MiddlewareNext<A>) => MiddlewareNext<A>
+	) => void;
+	removeReducer: (r: Reducer<S, A>) => void;
 };
 export type Initializer<S> = (arg: any) => S;
 export type GetState<S> = () => S;
 export type AsyncAction<S, A> = (
 	dispatch: Dispatch<A>,
-	getState: GetState<S>,
+	getState: GetState<S>
 ) => void;
 export type ThunkDispatch<S, A, T> = (
-	action: A | AsyncAction<S, A>,
+	action: A | AsyncAction<S, A>
 ) => void | Promise<T>;
 export type MiddlewareNext<A> = (action: A) => any;
 
@@ -30,85 +40,107 @@ export type MiddlewareNext<A> = (action: A) => any;
  * dispatcher supports thunks.
  */
 export function useThunkReducer<S, A>(
-	reducer: Reducer<S, A>,
+	rootReducer: Reducer<S, A>,
 	initializerArg: any,
 	initializer?: Initializer<any>,
 	middleware: ((
-		store: Store<S, A>,
-	) => (next: MiddlewareNext<A>) => MiddlewareNext<A>)[] = [],
-): [
-	ReducerState<Reducer<S, A>>,
-	ThunkDispatch<S, A, any>,
-	GetState<ReducerState<Reducer<S, A>>>,
-	(
-		m: (store: Store<S, A>) => (next: MiddlewareNext<A>) => MiddlewareNext<A>,
-	) => void,
-	(
-		m: (store: Store<S, A>) => (next: MiddlewareNext<A>) => MiddlewareNext<A>,
-	) => void,
-] {
+		store: Store<S, A>
+	) => (next: MiddlewareNext<A>) => MiddlewareNext<A>)[] = []
+): [ReducerState<Reducer<S, A>>, Store<S, A>] {
 	const mounted = useRef(true);
 	const allMiddleware = useRef([...middleware].reverse());
+	const allReducers = useRef([rootReducer]);
+	// The following is only used to generate the initial state from the root reducer.
 	const [initialState] = initializer
 		? // eslint-disable-next-line react-hooks/rules-of-hooks
-			useReducer(reducer, initializerArg, initializer)
+			useReducer(rootReducer, initializerArg, initializer)
 		: // eslint-disable-next-line react-hooks/rules-of-hooks
-			useReducer(reducer, initializerArg);
+			useReducer(rootReducer, initializerArg);
 
 	const [hookState, setHookState] = useState(initialState);
 
 	// State management.
 	const state = useRef<S>(hookState);
-	const getState = useCallback(() => state.current, [state]);
-	const setState = useCallback(
-		(newState: S) => {
-			state.current = newState;
-			mounted.current && setHookState(newState);
-		},
-		[state, setHookState],
-	);
+	const getState = useCallback(() => state.current, []);
+	const setState = useCallback((newState: S) => {
+		state.current = newState;
+		mounted.current && setHookState(newState);
+	}, []);
 	const addMiddleware = useCallback(
 		(
-			m: (store: Store<S, A>) => (next: MiddlewareNext<A>) => MiddlewareNext<A>,
+			m: (store: Store<S, A>) => (next: MiddlewareNext<A>) => MiddlewareNext<A>
 		) => {
-			allMiddleware.current = [m, ...allMiddleware.current];
+			allMiddleware.current = [m, ...allMiddleware.current].filter(
+				(middleware, index, all) => all.indexOf(middleware) === index
+			);
 		},
-		[],
+		[]
 	);
 	const removeMiddleware = useCallback(
 		(
-			m: (store: Store<S, A>) => (next: MiddlewareNext<A>) => MiddlewareNext<A>,
+			m: (store: Store<S, A>) => (next: MiddlewareNext<A>) => MiddlewareNext<A>
 		) => {
 			allMiddleware.current = allMiddleware.current.filter(
-				toRemove => toRemove !== m,
+				(toRemove) => toRemove !== m
 			);
 		},
-		[],
+		[]
 	);
 
+	const addReducer = useCallback((reducer: Reducer<S, A>) => {
+		allReducers.current = [...allReducers.current, reducer];
+	}, []);
+	const removeReducer = useCallback((reducer: Reducer<S, A>) => {
+		allReducers.current = allReducers.current.filter(
+			(toRemove) => toRemove !== reducer
+		);
+	}, []);
+
 	// Reducer.
-	const reduce = useCallback(
-		(action: A) => {
-			const store = { getState, dispatch };
-			return allMiddleware.current.reduce(
-				(next, currentMiddleware) => (a: A) =>
-					currentMiddleware(store)(next)(a),
-				(a: A) => reducer(getState(), a),
-			)(action);
-		},
-		[reducer, getState],
-	);
+	const reduce = useBoundCallback((action: A) => {
+		return [...allMiddleware.current].reduce(
+			(next, currentMiddleware) => (a: A) => currentMiddleware(store)(next)(a),
+			(a: A) =>
+				allReducers.current.reduce((newState, currentReducer) => {
+					const nextState = currentReducer(newState, a);
+					/*
+					 *	Update the state reference so that getState() returns the latest state in case there
+					 *	are side effects triggered in middleware or reducers. If there are no side effects,
+					 *	this will behave normally anyway.
+					 */
+					state.current = nextState;
+					return nextState;
+				}, getState())
+		)(action);
+	}, []);
 
 	// Augmented dispatcher.
-	const dispatch: ThunkDispatch<S, A, any> = useCallback(
-		action => {
-			const response =
-				action instanceof Function
-					? action(dispatch, getState)
-					: setState(reduce(action));
-			return response;
-		},
-		[getState, setState, reduce],
+	const dispatch: ThunkDispatch<S, A, any> = useCallback((action) => {
+		const response =
+			action instanceof Function
+				? action(dispatch, getState)
+				: setState(reduce(action));
+		return response;
+	}, []);
+
+	const store: Store<S, A> = useMemo(
+		() => ({
+			addMiddleware,
+			addReducer,
+			removeMiddleware,
+			removeReducer,
+			getState,
+			dispatch,
+		}),
+		[
+			// All these functions are stable and are not redefined. Added to satisfy exhaustive-deps.
+			addMiddleware,
+			addReducer,
+			removeMiddleware,
+			removeReducer,
+			getState,
+			dispatch,
+		]
 	);
 
 	useEffect(() => {
@@ -118,7 +150,7 @@ export function useThunkReducer<S, A>(
 		};
 	}, []);
 
-	return [hookState, dispatch, getState, addMiddleware, removeMiddleware];
+	return [hookState, store];
 }
 
 export default useThunkReducer;

package/src/iab/actions.ts

@@ -0,0 +1,19 @@
+import type { OsanoAction } from '../types/store';
+
+const prefix = 'IAB';
+
+export const SET_CONSENT_DATA = `${prefix}/SET_CONSENT_DATA`;
+
+export const setConsentData = (
+	gppSection: string,
+	value: any
+): OsanoAction<
+	typeof SET_CONSENT_DATA,
+	{
+		gppSection: string;
+		value: any;
+	}
+> => ({
+	type: SET_CONSENT_DATA,
+	payload: { gppSection, value },
+});

package/src/iab/constants.ts

@@ -1 +1,3 @@
 export const CMP_ID: number = 279;
+export const IAB_CMP_VERSION = 2023;
+export const GDPR_COUNTRIES: string[] = [];

package/src/iab/gpp/encoders/FixedIntegerEncoder.ts

@@ -19,7 +19,7 @@
  * the License.
  */
 
-import { InvalidSizeError } from './errors.js';
+import { InvalidSizeError } from './errors';
 
 // We use browser native functions to encode/decode integers to/from bit strings
 // instead of the more verbose method in the reference implementation

package/src/iab/gpp/encoders/TraditionalBase64UrlEncoder.ts

@@ -20,7 +20,6 @@
  */
 
 import { decode, makeEncode } from './AbstractBase64UrlEncoder';
-import type { Codable } from './types';
 
 const pad = (bitString: string) => {
 	while (bitString.length % 24 > 0) {
@@ -36,4 +35,4 @@ export { decode } from './AbstractBase64UrlEncoder';
 export default {
 	decode,
 	encode,
-} as Codable;
+};

package/src/iab/index.ts

@@ -0,0 +1,34 @@
+import type { IabFramework, IabState } from './types';
+import type { OsanoAction, OsanoState } from '../types/store';
+
+import type { Store } from '../hooks/useThunkReducer';
+import { reducer as iabReducer } from './reducer';
+import { setConsentData } from './actions';
+
+export const addIabReducers =
+	(frameworks: IabFramework[]) =>
+	(store: Store<OsanoState & IabState, OsanoAction>) => {
+		iabReducer && store.addReducer(iabReducer);
+		Object.values(frameworks).forEach(
+			({ reducer: frameworkReducer, versions }) => {
+				frameworkReducer && store.addReducer(frameworkReducer);
+				Object.values(versions).forEach(
+					({
+						middleware: versionMiddleware,
+						gppSection,
+						reducer: versionReducer,
+					}) => {
+						if (gppSection !== 'gpp') {
+							// Adds the section to the state so that GPP knows about it
+							// but we don't store the GPP string itself since it's
+							// basically just the other strings concatenated together.
+							store.dispatch(setConsentData(gppSection, ''));
+						}
+
+						versionReducer && store.addReducer(versionReducer);
+						versionMiddleware && store.addMiddleware(versionMiddleware);
+					}
+				);
+			}
+		);
+	};

package/src/iab/reducer.ts

@@ -0,0 +1,38 @@
+import type { Iab, IabFramework, IabState } from './types';
+
+import type { OsanoState } from '../types/store';
+import { SET_CONSENT_DATA } from './actions';
+import { isConsentReady } from '../selectors';
+
+export const initialState = {
+	iab: {} as Iab,
+};
+
+export const reducer: IabFramework['reducer'] = (state, action) => {
+	const { type } = action;
+	switch (type) {
+		case SET_CONSENT_DATA: {
+			const { gppSection, value } = action.payload;
+			const consentStrings = state?.iab?.consentStrings || {};
+			return {
+				...state,
+				iab: {
+					...state?.iab,
+					consentStrings: {
+						...consentStrings,
+						[gppSection]: value,
+					},
+					hasActed: {
+						...state?.iab?.hasActed,
+						[gppSection]:
+							!!isConsentReady(state) &&
+							value !== consentStrings[`${gppSection}`],
+					},
+				},
+			};
+		}
+	}
+	return state.iab
+		? (state as OsanoState & IabState)
+		: { ...state, iab: initialState.iab };
+};

package/src/iab/tcf/actions.ts

@@ -0,0 +1,116 @@
+import type { OsanoAction } from '../../types/store';
+import type { TcfState } from './types';
+
+const prefix = 'IAB-TCF';
+
+export const SET_TCSTRING = `${prefix}/SET_TCSTRING`;
+export const SET_CONSENT = `${prefix}/SET_CONSENT`;
+export const SET_PURPOSE_CONSENT = `${prefix}/SET_PURPOSE_CONSENT`;
+export const SET_ALL_PURPOSE_CONSENT = `${prefix}/SET_ALL_PURPOSE_CONSENT`;
+export const SET_VENDOR_CONSENT = `${prefix}/SET_VENDOR_CONSENT`;
+export const SET_ALL_VENDOR_CONSENT = `${prefix}/SET_ALL_VENDOR_CONSENT`;
+export const SET_SPECIAL_FEATURE_CONSENT = `${prefix}/SET_SPECIAL_FEATURE_CONSENT`;
+export const SET_ALL_SPECIAL_FEATURE_CONSENT = `${prefix}/SET_ALL_SPECIAL_FEATURE_CONSENT`;
+export const SET_GDPR_APPLIES = `${prefix}/SET_GDPR_APPLIES`;
+export const UPDATE_PURPOSE_LIST = `${prefix}/UPDATE_PURPOSE_LIST`;
+
+export const setTCString = (
+	tcString: string
+): OsanoAction<typeof SET_TCSTRING, string> => ({
+	type: SET_TCSTRING,
+	payload: tcString,
+});
+
+export const setConsent = (
+	consent: Partial<TcfState>
+): OsanoAction<typeof SET_CONSENT, any> => ({
+	type: SET_CONSENT,
+	payload: consent,
+});
+
+export const setSpecialFeatureConsent = (
+	specialFeatureId: string | number,
+	acceptOrDeny?: boolean
+): OsanoAction<
+	typeof SET_SPECIAL_FEATURE_CONSENT,
+	{
+		specialFeatureId: string | number;
+		acceptOrDeny?: boolean;
+	}
+> => ({
+	type: SET_SPECIAL_FEATURE_CONSENT,
+	payload: { specialFeatureId, acceptOrDeny },
+});
+
+export const setPurposeConsent = (
+	purposeId: string | number,
+	acceptOrDeny?: boolean
+): OsanoAction<
+	typeof SET_PURPOSE_CONSENT,
+	{
+		purposeId: string | number;
+		acceptOrDeny?: boolean;
+	}
+> => ({
+	type: SET_PURPOSE_CONSENT,
+	payload: { purposeId, acceptOrDeny },
+});
+
+export const setVendorConsent = (
+	vendorId: string | number,
+	acceptOrDeny?: boolean
+): OsanoAction<
+	typeof SET_VENDOR_CONSENT,
+	{
+		vendorId: string | number;
+		acceptOrDeny?: boolean;
+	}
+> => ({
+	type: SET_VENDOR_CONSENT,
+	payload: { vendorId, acceptOrDeny },
+});
+
+export const setAllVendorConsent = (
+	acceptOrDeny: boolean
+): OsanoAction<typeof SET_ALL_VENDOR_CONSENT, boolean> => ({
+	type: SET_ALL_VENDOR_CONSENT,
+	payload: acceptOrDeny,
+});
+
+export const setAllPurposeConsent = (
+	acceptOrDeny: boolean
+): OsanoAction<typeof SET_ALL_PURPOSE_CONSENT, boolean> => ({
+	type: SET_ALL_PURPOSE_CONSENT,
+	payload: acceptOrDeny,
+});
+
+export const setAllSpecialFeatureConsent = (
+	acceptOrDeny: boolean
+): OsanoAction<typeof SET_ALL_SPECIAL_FEATURE_CONSENT, boolean> => ({
+	type: SET_ALL_SPECIAL_FEATURE_CONSENT,
+	payload: acceptOrDeny,
+});
+
+export const setGdprApplies = (
+	gdprApplies: boolean
+): OsanoAction<typeof SET_GDPR_APPLIES, boolean> => ({
+	type: SET_GDPR_APPLIES,
+	payload: gdprApplies,
+});
+
+export const updatePurposeList = (
+	purposeList: any,
+	language: string
+): OsanoAction<
+	typeof UPDATE_PURPOSE_LIST,
+	{
+		purposeList: any;
+		language: string;
+	}
+> => ({
+	type: UPDATE_PURPOSE_LIST,
+	payload: {
+		purposeList,
+		language,
+	},
+});