@inseefr/lunatic 3.14.0-rc-delay-sequence-cleaning.0 → 4.0.0

package/src/use-lunatic/commons/remove-condition-filters.ts

@@ -0,0 +1,103 @@
+import type { ComponentDefinition } from '../../type.source';
+import type { ActiveFilter, LunaticExpression, LunaticSource } from '../type';
+
+/**
+ * Decide if a conditionFilter must be kept, depending on the active filters mode.
+ * - "ALL": Keep every filter
+ * - "EXTERNAL": Keep filters based only on external variables
+ * - "NONE": Ignore every filter
+ */
+export function shouldKeepFilter(
+	filter: LunaticExpression | undefined,
+	activeFilters: ActiveFilter
+): boolean {
+	if (!filter) return true;
+	if (activeFilters === 'ALL') return true;
+	if (activeFilters === 'NONE') return false;
+	// For external active filter we have to check dependencies and remove any filter based on collected or calculated variables
+	const dependencies = filter.variablesDependencies;
+	return Boolean(
+		dependencies &&
+		(dependencies.COLLECTED?.length ?? 0) === 0 &&
+		(dependencies.CALCULATED?.length ?? 0) === 0
+	);
+}
+
+/**
+ * Compare the existing element against the outcome of the filtering function
+ * and remove it from the source if needed
+ */
+const removeFilterIfChanged = <T>(
+	elements: T[],
+	cleanFilterFunction: (element: T) => T
+): T[] => {
+	const cleaned = elements.map((element) => cleanFilterFunction(element));
+	return cleaned.some((element, index) => element !== elements[index])
+		? cleaned
+		: elements;
+};
+
+/**
+ * Remove filters from source based from activeFilters props
+ */
+export function removeConditionFilters(
+	source: LunaticSource,
+	activeFilters: ActiveFilter
+): LunaticSource {
+	if (activeFilters === 'ALL') {
+		return source;
+	}
+
+	// 	Element that can have a condition filter
+	//  Component is too dynamic to be typed
+	const cleanSingleElement = <T extends object>(element: T): T => {
+		if (
+			'conditionFilter' in element &&
+			!shouldKeepFilter(
+				element.conditionFilter as LunaticExpression | undefined,
+				activeFilters
+			)
+		) {
+			const rest = { ...element };
+			delete rest.conditionFilter;
+			return rest as T;
+		}
+
+		return element;
+	};
+
+	const cleanComponents = <T extends ComponentDefinition>(component: T): T => {
+		let current = cleanSingleElement(component);
+		if ('components' in current && Array.isArray(current.components)) {
+			const components = removeFilterIfChanged(
+				current.components,
+				cleanComponents
+			);
+			if (components !== current.components) {
+				current = { ...current, components } as T;
+			}
+		}
+		if ('responses' in current && Array.isArray(current.responses)) {
+			const currentResponses = current.responses;
+			const responses = removeFilterIfChanged(
+				currentResponses,
+				cleanSingleElement
+			);
+			if (responses !== currentResponses) {
+				current = { ...current, responses } as T;
+			}
+		}
+		if ('options' in current && Array.isArray(current.options)) {
+			const currentOptions = current.options
+			const options = removeFilterIfChanged(currentOptions, cleanSingleElement);
+			if (options !== currentOptions) {
+				current = { ...current, options } as T;
+			}
+		}
+		return current;
+	};
+	return {
+		...source,
+		components: source.components.map(cleanComponents),
+	};
+}

package/src/use-lunatic/hooks/useOverview.spec.ts

@@ -6,7 +6,7 @@ import { useLunatic } from '../use-lunatic';
 import { dataFromObject } from '../../utils/object';
 
 describe('use-overview test with useLunatic()', () => {
-	it('should initialize correctly with disableFilters: false (without data)', () => {
+	it('should initialize correctly with all filters active (without data)', () => {
 		const params = [
 			source as any,
 			dataFromObject({}),
@@ -16,7 +16,7 @@ describe('use-overview test with useLunatic()', () => {
 		expect(result.current.overview.length).toBe(3);
 	});
 
-	it('should initialize correctly with disableFilters: false (with data)', () => {
+	it('should initialize correctly with all filters active (with data)', () => {
 		const params = [
 			source as any,
 			dataFromObject({
@@ -29,15 +29,26 @@ describe('use-overview test with useLunatic()', () => {
 		expect(result.current.overview.length).toBe(9);
 	});
 
-	it('should initialize correctly with disableFilters: true (without data)', () => {
+	it('should show filtered items when activeFilters is NONE', () => {
 		const params = [
 			source as any,
 			dataFromObject({}),
-			{ withOverview: true, disableFilters: true },
+			{ withOverview: true, activeFilters: 'NONE' },
 		] as const;
 
 		const { result } = renderHook(() => useLunatic(...params));
 		// All elements have to be presents
 		expect(result.current.overview.length).toBe(9);
 	});
+
+	it('should show items without external-only filter dependencies when activeFilters is EXTERNAL', () => {
+		const params = [
+			source as any,
+			dataFromObject({}),
+			{ withOverview: true, activeFilters: 'EXTERNAL' },
+		] as const;
+
+		const { result } = renderHook(() => useLunatic(...params));
+		expect(result.current.overview.length).toBe(9);
+	});
 });

package/src/use-lunatic/hooks/useOverview.ts

@@ -1,5 +1,4 @@
 import type {
-	LunaticOptions,
 	LunaticOverviewItem,
 	LunaticReducerState,
 	PageTag,
@@ -30,23 +29,13 @@ export const useOverview = (
 		overview,
 		executeExpression,
 		pager,
-		options,
-	}: Pick<
-		LunaticReducerState,
-		'executeExpression' | 'overview' | 'pager' | 'options'
-	>,
+	}: Pick<LunaticReducerState, 'executeExpression' | 'overview' | 'pager'>,
 	deps: DependencyList
 ) => {
 	return useMemo(
-		() =>
-			interpretOverview(
-				overview,
-				executeExpression,
-				pager,
-				options.disableFilters
-			),
+		() => interpretOverview(overview, executeExpression, pager),
 		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[...deps, overview, options.disableFilters]
+		[...deps, overview]
 	);
 };
 
@@ -56,15 +45,13 @@ export const useOverview = (
 const interpretOverview = (
 	overviewItems: LunaticOverviewItem[],
 	executeExpression: LunaticReducerState['executeExpression'],
-	pager?: LunaticReducerState['pager'],
-	disableFilters?: LunaticOptions['disableFilters']
+	pager?: LunaticReducerState['pager']
 ) => {
 	// Flat structure of the overview
 	let items = overviewItems.reduce(
 		(acc, item) =>
 			interpretOverviewItem(acc, item, executeExpression, {
 				pager,
-				disableFilters,
 			}),
 		[] as InterpretedLunaticOverviewItem[]
 	);
@@ -99,7 +86,6 @@ const interpretOverviewItem = (
 	executeExpression: LunaticReducerState['executeExpression'],
 	state: {
 		pager?: LunaticReducerState['pager'];
-		disableFilters?: LunaticOptions['disableFilters'];
 	},
 
 	iteration?: number
@@ -115,9 +101,8 @@ const interpretOverviewItem = (
 		);
 	}
 
-	// if disableFilters is set to true, item are visible and reached by default
 	const isVisible = (() => {
-		if (state.disableFilters || !item.conditionFilter) return true;
+		if (!item.conditionFilter) return true;
 		return Boolean(
 			executeExpression(item.conditionFilter, {
 				iteration: iteration,

package/src/use-lunatic/props/propOptions.spec.ts

@@ -5,7 +5,9 @@ import type { DeepTranslateExpression } from '../commons/fill-components/fill-co
 import type {
 	LunaticChangesHandler,
 	LunaticComponentDefinition,
+	LunaticSource,
 } from '../type';
+import { removeConditionFilters } from '../commons/remove-condition-filters';
 
 describe('computeOptionsFromComponent', () => {
 	let variables: LunaticVariablesStore;
@@ -318,7 +320,7 @@ describe('computeOptionsFromComponent', () => {
 			expect(options).toHaveLength(1);
 			expect(options[0].shouldBeFiltered).toBe(false);
 		});
-		it('should not filter any response (CheckboxGroup) when disableFilters is true', () => {
+		it('should keep responses after NONE filters have been removed during initialization', () => {
 			const definition = {
 				...checkboxGroupDefinition,
 				responses: [
@@ -331,26 +333,27 @@ describe('computeOptionsFromComponent', () => {
 				],
 			} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
 
-			// ensure interpreted expression is false
-			vi.spyOn(variables, 'run').mockImplementation(() => {
-				return false;
-			});
-
-			const options = computeOptionsFromComponent(definition, {
+			const cleanedDefinition = removeConditionFilters(
+				{
+					variables: [],
+					components: [definition as any],
+				} as LunaticSource,
+				'NONE'
+			)
+				.components[0] as unknown as DeepTranslateExpression<LunaticComponentDefinition>;
+
+			const options = computeOptionsFromComponent(cleanedDefinition, {
 				variables,
 				handleChanges: mockChange,
 				pagerIteration: undefined,
 				value: undefined,
 				logger: mockLogger,
-				disableFilters: true,
 			});
 
-			// Ensure the option is not filtered
 			expect(options).toHaveLength(1);
-			// the option should would have been filtered if we did not disable filters
-			expect(options[0].shouldBeFiltered).toBe(true);
+			expect(options[0].shouldBeFiltered).toBe(false);
 		});
-		it('should not filter any option (Radio) when disableFilters is true', () => {
+		it('should keep options after NONE filters have been removed during initialization', () => {
 			const definition = {
 				...radioDefinition,
 				options: [
@@ -362,79 +365,99 @@ describe('computeOptionsFromComponent', () => {
 				],
 			} as any as DeepTranslateExpression<LunaticComponentDefinition>;
 
-			// ensure interpreted expression is false
-			vi.spyOn(variables, 'run').mockImplementation(() => {
-				return false;
-			});
-
-			const options = computeOptionsFromComponent(definition, {
+			const cleanedDefinition = removeConditionFilters(
+				{
+					variables: [],
+					components: [definition as any],
+				} as LunaticSource,
+				'NONE'
+			)
+				.components[0] as unknown as DeepTranslateExpression<LunaticComponentDefinition>;
+
+			const options = computeOptionsFromComponent(cleanedDefinition, {
 				variables,
 				handleChanges: mockChange,
 				pagerIteration: undefined,
 				value: undefined,
 				logger: mockLogger,
-				disableFilters: true,
 			});
 
-			// Ensure the option is not filtered
 			expect(options).toHaveLength(1);
-			// the option should would have been filtered if we did not disable filters
-			expect(options[0].shouldBeFiltered).toBe(true);
+			expect(options[0].shouldBeFiltered).toBe(false);
 		});
-		it('should set the response (CheckboxGroup) shouldBeFiltered=true when the parent component should be filtered', () => {
-			const definition = {
-				...checkboxGroupDefinition,
-				responses: [
-					{
-						label: 'Option 1',
-						response: { name: 'O1' },
-						id: 'id1',
-						conditionFilter: { type: 'VTL', value: 'expression' },
-					},
-				],
-			} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
-
-			const options = computeOptionsFromComponent(definition, {
-				variables,
-				handleChanges: mockChange,
-				pagerIteration: undefined,
-				value: undefined,
-				logger: mockLogger,
-				disableFilters: true,
-				shouldParentBeFiltered: true,
-			});
 
-			// Ensure the option is not filtered
-			expect(options).toHaveLength(1);
-			// the option would have been filtered if we did not disable filters because its parent would
-			expect(options[0].shouldBeFiltered).toBe(true);
-		});
-		it('should set the option (Radio) shouldBeFiltered=true when the parent component should be filtered', () => {
+		it('should evaluate the external-only filters retained during initialization', () => {
 			const definition = {
 				...radioDefinition,
 				options: [
 					{
-						label: 'Option 1',
-						value: 'id1',
-						conditionFilter: { type: 'VTL', value: 'expression' },
+						label: 'External option',
+						value: 'external',
+						conditionFilter: {
+							type: 'VTL',
+							value: 'externalFilter',
+							variablesDependencies: {
+								EXTERNAL: ['CADRE'],
+								COLLECTED: [],
+								CALCULATED: [],
+							},
+						},
+					},
+					{
+						label: 'Collected option',
+						value: 'collected',
+						conditionFilter: {
+							type: 'VTL',
+							value: 'collectedFilter',
+							variablesDependencies: {
+								EXTERNAL: [],
+								COLLECTED: ['NAME'],
+								CALCULATED: [],
+							},
+						},
 					},
 				],
 			} as any as DeepTranslateExpression<LunaticComponentDefinition>;
 
-			const options = computeOptionsFromComponent(definition, {
+			const cleanedDefinition = removeConditionFilters(
+				{
+					variables: [],
+					components: [definition as any],
+				} as LunaticSource,
+				'EXTERNAL'
+			)
+				.components[0] as unknown as DeepTranslateExpression<LunaticComponentDefinition>;
+			expect((cleanedDefinition as any).options).toEqual([
+				{
+					label: 'External option',
+					value: 'external',
+					conditionFilter: {
+						type: 'VTL',
+						value: 'externalFilter',
+						variablesDependencies: {
+							EXTERNAL: ['CADRE'],
+							COLLECTED: [],
+							CALCULATED: [],
+						},
+					},
+				},
+				{ label: 'Collected option', value: 'collected' },
+			]);
+			vi.spyOn(variables, 'run').mockImplementation(
+				(expression) => expression !== 'externalFilter'
+			);
+
+			const options = computeOptionsFromComponent(cleanedDefinition, {
 				variables,
 				handleChanges: mockChange,
 				pagerIteration: undefined,
 				value: undefined,
 				logger: mockLogger,
-				disableFilters: true,
-				shouldParentBeFiltered: true,
 			});
 
-			// Ensure the option is not filtered
-			expect(options).toHaveLength(1);
-			// the option would have been filtered if we did not disable filters because its parent would
-			expect(options[0].shouldBeFiltered).toBe(true);
+			expect(
+				(options as InterpretedOption[]).map((option) => option.value)
+			).toEqual(['collected']);
 		});
 	});
 

package/src/use-lunatic/props/propOptions.ts

@@ -36,7 +36,6 @@ export function computeOptionsFromComponent(
 		pagerIteration,
 		value,
 		logger,
-		disableFilters,
 		shouldParentBeFiltered,
 	}: {
 		variables: LunaticVariablesStore;
@@ -44,7 +43,6 @@ export function computeOptionsFromComponent(
 		pagerIteration: LunaticState['pager']['iteration'];
 		value: unknown;
 		logger: LunaticLogger;
-		disableFilters?: boolean;
 		shouldParentBeFiltered?: boolean;
 	}
 ) {
@@ -53,7 +51,7 @@ export function computeOptionsFromComponent(
 	if (definition.componentType === 'CheckboxGroup') {
 		return definition.responses
 			.filter((response) => {
-				if (disableFilters || !response.conditionFilter) {
+				if (!response.conditionFilter) {
 					return true;
 				}
 				return !isFilteredOutOption(
@@ -118,11 +116,7 @@ export function computeOptionsFromComponent(
 
 	return definition.options
 		.filter((option) => {
-			if (
-				disableFilters ||
-				!('conditionFilter' in option) ||
-				!option.conditionFilter
-			) {
+			if (!('conditionFilter' in option) || !option.conditionFilter) {
 				return true;
 			}
 			return !isFilteredOutOption(

package/src/use-lunatic/reducer/reducerInitializer.tsx

@@ -6,6 +6,7 @@ import type {
 } from '../type';
 import { LunaticVariablesStore } from '../commons/variables/lunatic-variables-store';
 import { checkLoops, createMapPages } from '../commons';
+import { removeConditionFilters } from '../commons/remove-condition-filters';
 import { getExpressionAsString, getExpressionType } from '../../utils/vtl';
 import { MD, VTL } from '../../utils/constants';
 import { MDLabel } from '../../components/shared/MDLabel/MDLabel';
@@ -35,7 +36,10 @@ const baseState = {
 	overview: [],
 	updateBindings: () => {},
 	executeExpression: <T,>() => null as T,
-	options: { disableFilters: false, disableFiltersDescription: true },
+	options: {
+		activeFilters: 'ALL',
+		disableFiltersDescription: true,
+	},
 } satisfies LunaticReducerState;
 
 const onChange = { current: () => {} };
@@ -47,8 +51,8 @@ export function reducerInitializer({
 	initialPage = '1',
 	lastReachedPage = undefined,
 	withOverview = false,
-	disableFilters = false,
 	disableFiltersDescription = true,
+	activeFilters,
 	getReferentiel,
 	onVariableChange = onChange,
 	logger = console.error,
@@ -59,18 +63,26 @@ export function reducerInitializer({
 	initialPage?: LunaticOptions['initialPage'];
 	lastReachedPage?: LunaticOptions['lastReachedPage'];
 	withOverview?: LunaticOptions['withOverview'];
-	disableFilters?: LunaticOptions['disableFilters'];
 	disableFiltersDescription?: LunaticOptions['disableFiltersDescription'];
+	activeFilters?: LunaticOptions['activeFilters'];
 	getReferentiel?: LunaticOptions['getReferentiel'];
 	onVariableChange?: RefObject<LunaticOptions['onVariableChange']>;
 	logger?: LunaticLogger;
 }): LunaticReducerState {
-	const variables = LunaticVariablesStore.makeFromSource(source, data, {
+	const filteredSource =
+		activeFilters && activeFilters !== 'ALL'
+			? removeConditionFilters(source, activeFilters)
+			: source;
+
+	// Cleaning is disabled if not all filters are active.
+	const disableCleaning =
+		activeFilters !== undefined && activeFilters !== 'ALL';
+	const variables = LunaticVariablesStore.makeFromSource(filteredSource, data, {
 		autoCommit: false,
 		changeHandler: onVariableChange,
-		disableCleaning: disableFilters,
+		disableCleaning: disableCleaning,
 	});
-	const pages = checkLoops(createMapPages(source));
+	const pages = checkLoops(createMapPages(filteredSource));
 
 	if (!source || !data) {
 		return baseState;
@@ -151,10 +163,13 @@ export function reducerInitializer({
 		pages,
 		isInLoop: pager.subPage !== undefined,
 		updatedAt: Date.now(),
-		overview: withOverview ? buildOverview(source) : [],
+		overview: withOverview ? buildOverview(filteredSource) : [],
 		updateBindings,
 		executeExpression,
-		options: { disableFilters, disableFiltersDescription },
+		options: {
+			activeFilters: activeFilters ?? 'ALL',
+			disableFiltersDescription,
+		},
 	});
 }
 

package/src/use-lunatic/type.ts

@@ -59,6 +59,7 @@ export type LunaticError = Pick<
 
 export type VariableType = 'COLLECTED' | 'EXTERNAL' | 'CALCULATED';
 export type LunaticExpression = VTLExpression | VTLScalarExpression;
+export type ActiveFilter = 'ALL' | 'EXTERNAL' | 'NONE';
 
 /**
  * Page numerotation.
@@ -142,22 +143,22 @@ export type LunaticReducerState = {
 	pager: LunaticPager;
 	pages: {
 		[key: number | string]:
-			| {
-					components: LunaticSource['components'];
-					isLoop: false;
-					iterations?: undefined;
-					loopDependencies?: undefined;
-					subPages?: undefined;
-			  }
-			| {
-					components: LunaticSource['components'];
-					isLoop: true;
-					iterations: VTLScalarExpression;
-					/** Variables affecting this loop. */
-					loopDependencies: string[];
-					/** List of child pages (ex: ['20.1', '20.2'] */
-					subPages: string[];
-			  };
+		| {
+			components: LunaticSource['components'];
+			isLoop: false;
+			iterations?: undefined;
+			loopDependencies?: undefined;
+			subPages?: undefined;
+		}
+		| {
+			components: LunaticSource['components'];
+			isLoop: true;
+			iterations: VTLScalarExpression;
+			/** Variables affecting this loop. */
+			loopDependencies: string[];
+			/** List of child pages (ex: ['20.1', '20.2'] */
+			subPages: string[];
+		};
 	};
 	/** Run an expression using the value from the state. */
 	executeExpression: <T = unknown>(
@@ -178,25 +179,28 @@ export type LunaticReducerState = {
 		options: { iteration?: number[] }
 	) => unknown;
 	options: {
-		disableFilters?: boolean;
 		disableFiltersDescription?: boolean;
+		activeFilters?: ActiveFilter;
 	};
 };
 
 /** Specific behaviour options defined in the {@link useLunatic} hook. */
 export type LunaticOptions = {
-	/**
-	 * Ignore filters.
-	 * @default false
-	 */
-	disableFilters?: boolean;
-
 	/**
 	 * Disable filters description.
 	 * @default true
 	 */
 	disableFiltersDescription?: boolean;
 
+	/**
+	 * Decides whether or not filters are active.
+	 * - "ALL": Keep every filters
+	 * - "EXTERNAL": Keep filter only if it is based on external variables only
+	 * - "NONE": Ignore every filters
+	 * @default 'ALL'
+	 */
+	activeFilters?: ActiveFilter;
+
 	/** Enable VTL and Markdown support. */
 	features?: ('MD' | 'VTL')[];
 	preferences?: ['COLLECTED'];

package/src/use-lunatic/use-lunatic.test.ts

@@ -240,8 +240,8 @@ describe('use-lunatic()', () => {
 		});
 	});
 
-	describe('disable filters', () => {
-		const lunaticConfigurationWithoutDisableFilters = {
+	describe('active filters', () => {
+		const lunaticConfiguration = {
 			management: false,
 			activeControls: false,
 			initialPage: '1' as PageTag,
@@ -258,29 +258,29 @@ describe('use-lunatic()', () => {
 				useLunatic(
 					sourceLogement,
 					undefined,
-					lunaticConfigurationWithoutDisableFilters
+					lunaticConfiguration
 				)
 			);
 			act(() => result.current.goToPage({ page: '3' }));
 			const currentPage = result.current.pageTag;
 			expect(currentPage).not.toBe('3');
 		});
-		it('should filter out some components when false', function () {
+		it('should filter out some components when activeFilters is ALL', function () {
 			const { result } = renderHook(() =>
 				useLunatic(sourceLogement, undefined, {
-					...lunaticConfigurationWithoutDisableFilters,
-					disableFilters: false,
+					...lunaticConfiguration,
+					activeFilters: 'ALL',
 				})
 			);
 			act(() => result.current.goToPage({ page: '3' }));
 			const currentPage = result.current.pageTag;
 			expect(currentPage).not.toBe('3');
 		});
-		it('should not filter any component when true', function () {
+		it('should not filter any component when activeFilters is NONE', function () {
 			const { result } = renderHook(() =>
 				useLunatic(sourceLogement, undefined, {
-					...lunaticConfigurationWithoutDisableFilters,
-					disableFilters: true,
+					...lunaticConfiguration,
+					activeFilters: 'NONE',
 				})
 			);
 			act(() => result.current.goToPage({ page: '3' }));