@osimatic/helpers-js 1.5.21 → 1.5.23

package/chartjs.js

@@ -1,9 +1,10 @@
 const { toEl } = require('./util');
 const deepmerge = require('deepmerge');
+const { DatePeriod } = require('./date_time');
 
 class Chartjs {
 	static init() {
-		if (typeof Chartjs.initialized == 'undefined' || Chartjs.initialized) {
+		if (Chartjs.initialized) {
 			return;
 		}
 
@@ -40,6 +41,7 @@ class Chartjs {
 	}
 
 	static createStackedChart(chartDiv, chartData, title=null, options={}) {
+		Chartjs.init();
 		chartDiv = toEl(chartDiv);
 		chartDiv.innerHTML = '';
 		new Chart(chartDiv.getContext("2d"), deepmerge({
@@ -90,6 +92,7 @@ class Chartjs {
 	}
 
 	static createBarChart(chartDiv, chartData, title=null, options={}) {
+		Chartjs.init();
 		chartDiv = toEl(chartDiv);
 		chartDiv.innerHTML = '';
 		new Chart(chartDiv.getContext("2d"), deepmerge({

package/form_helper.js

@@ -239,7 +239,7 @@ class FormHelper {
 			return json.error;
 		}
 
-		if (onlyIfUniqueError && !json.length || json.length > 1) {
+		if (onlyIfUniqueError && (!json.length || json.length > 1)) {
 			return null;
 		}
 
@@ -263,7 +263,7 @@ class FormHelper {
 			return json.error;
 		}
 
-		if (onlyIfUniqueError && !json.length || json.length > 1) {
+		if (onlyIfUniqueError && (!json.length || json.length > 1)) {
 			return null;
 		}
 
@@ -279,9 +279,10 @@ class FormHelper {
 	}
 
 	static hideFormErrors(form) {
+		const wasJQuery = form && form.jquery;
 		form = toEl(form);
 		form.querySelectorAll('div.form_errors').forEach(el => el.remove());
-		return form;
+		return wasJQuery ? toJquery(form) : form;
 	}
 
 	static getFormErrorText(errors) {

package/media.js

@@ -101,7 +101,7 @@ class AudioMedia {
 		canvasCtx.clearRect(0, 0, canvasWidth, canvasHeight);
 
 		function draw() {
-			let drawVisual = requestAnimationFrame(draw);
+			requestAnimationFrame(draw);
 
 			analyser.getByteFrequencyData(dataArray);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@osimatic/helpers-js",
-  "version": "1.5.21",
+  "version": "1.5.23",
   "main": "main.js",
   "scripts": {
     "test": "jest",

package/select_all.js

@@ -11,6 +11,9 @@ class SelectAll {
 		linkClone.addEventListener('click', function(e) {
 			e.preventDefault();
 			const formGroup = this.closest('.form-group');
+			if (!formGroup) {
+				return;
+			}
 			const allCheckbox = formGroup.querySelectorAll('input[type="checkbox"]:not(.check_all)');
 			const allCheckboxChecked = formGroup.querySelectorAll('input[type="checkbox"]:not(.check_all):checked');
 			const allCheckboxWithCheckAll = formGroup.querySelectorAll('input[type="checkbox"]');
@@ -20,6 +23,9 @@ class SelectAll {
 		});
 
 		const formGroup = linkClone.closest('.form-group');
+		if (!formGroup) {
+			return;
+		}
 		formGroup.querySelectorAll('input[type="checkbox"]').forEach(cb => {
 			cb.addEventListener('change', () => {
 				SelectAll.updateFormGroup(cb.closest('.form-group'));
@@ -30,6 +36,9 @@ class SelectAll {
 
 	static updateFormGroup(formGroup) {
 		formGroup = toEl(formGroup);
+		if (!formGroup) {
+			return;
+		}
 		const allCheckbox = formGroup.querySelectorAll('input[type="checkbox"]:not(.check_all)');
 		const allCheckboxChecked = formGroup.querySelectorAll('input[type="checkbox"]:not(.check_all):checked');
 		const lienSelectAll = formGroup.querySelector('a.check_all');
@@ -48,6 +57,9 @@ class SelectAll {
 
 	static initInTable(table) {
 		table = toEl(table);
+		if (!table) {
+			return;
+		}
 		const inputCheckAll = table.querySelector('tr input.check_all');
 		if (!inputCheckAll) {
 			return;
@@ -72,6 +84,9 @@ class SelectAll {
 
 	static updateTable(table) {
 		table = toEl(table);
+		if (!table) {
+			return;
+		}
 		const allCheckbox = table.querySelectorAll('tbody input[type="checkbox"]');
 		const allCheckboxChecked = table.querySelectorAll('tbody input[type="checkbox"]:checked');
 		const checkboxSelectAll = table.querySelector('thead input.check_all');
@@ -85,6 +100,9 @@ class SelectAll {
 
 	static initDiv(contentDiv) {
 		contentDiv = toEl(contentDiv);
+		if (!contentDiv) {
+			return;
+		}
 		contentDiv.querySelectorAll('input.check_all').forEach(inputCheckAll => {
 			const div = inputCheckAll.closest('div.checkbox_with_check_all');
 
@@ -92,6 +110,9 @@ class SelectAll {
 			inputCheckAll.parentElement.replaceChild(clone, inputCheckAll);
 			clone.addEventListener('click', function() {
 				const d = this.closest('div.checkbox_with_check_all');
+				if (!d) {
+					return;
+				}
 				const allCheckbox = d.querySelectorAll('input[type="checkbox"]:not(.check_all)');
 				const allCheckboxChecked = d.querySelectorAll('input[type="checkbox"]:not(.check_all):checked');
 				const newState = allCheckbox.length !== allCheckboxChecked.length;
@@ -99,6 +120,9 @@ class SelectAll {
 				SelectAll.updateDiv(d);
 			});
 
+			if (!div) {
+				return;
+			}
 			div.querySelectorAll('div.checkbox input[type="checkbox"], div.form-check input[type="checkbox"]').forEach(cb => {
 				cb.addEventListener('change', () => {
 					SelectAll.updateDiv(cb.closest('div.checkbox_with_check_all'));
@@ -110,6 +134,9 @@ class SelectAll {
 
 	static updateDiv(div) {
 		div = toEl(div);
+		if (!div) {
+			return;
+		}
 		// 22/11/2021 : rajout :not(.check_all) sinon si toutes les cases sont coché, la case select all n'est pas coché à l'initialisation
 		const allCheckbox = div.querySelectorAll('div.checkbox input[type="checkbox"]:not(.check_all), div.form-check input[type="checkbox"]:not(.check_all)');
 		const allCheckboxChecked = div.querySelectorAll('div.checkbox input[type="checkbox"]:not(.check_all):checked, div.form-check input[type="checkbox"]:not(.check_all):checked');

package/tests/chartjs.test.js

@@ -3,8 +3,6 @@
  */
 const { Chartjs } = require('../chartjs');
 
-// ─── chart creation helpers ──────────────────────────────────────────────────
-
 let mockChartInstance;
 
 beforeEach(() => {
@@ -13,11 +11,14 @@ beforeEach(() => {
 		mockChartInstance.config = config;
 		return mockChartInstance;
 	});
+	global.Chart.register = jest.fn();
+	Chartjs.initialized = false;
 	HTMLCanvasElement.prototype.getContext = jest.fn(() => ({}));
 });
 
 afterEach(() => {
 	delete global.Chart;
+	Chartjs.initialized = false;
 	document.body.innerHTML = '';
 	jest.restoreAllMocks();
 });
@@ -28,9 +29,150 @@ function makeCanvas() {
 	return canvas;
 }
 
-// ─── groupByPeriod ───────────────────────────────────────────────────────────
-
 describe('Chartjs', () => {
+
+	describe('init', () => {
+		test('registers centerText plugin on first call', () => {
+			Chartjs.init();
+			expect(global.Chart.register).toHaveBeenCalledTimes(1);
+			expect(global.Chart.register).toHaveBeenCalledWith(
+				expect.objectContaining({ id: 'centerText' })
+			);
+		});
+
+		test('does not register plugin on subsequent calls', () => {
+			Chartjs.init();
+			global.Chart.register.mockClear();
+			Chartjs.init();
+			expect(global.Chart.register).not.toHaveBeenCalled();
+		});
+
+		test('sets Chartjs.initialized to true', () => {
+			Chartjs.init();
+			expect(Chartjs.initialized).toBe(true);
+		});
+	});
+
+	describe('createStackedChart', () => {
+		const chartData = { labels: ['A', 'B'], datasets: [{ label: 'X', data: [1, 2] }] };
+
+		test('clears div and calls Chart constructor with type bar', () => {
+			const canvas = makeCanvas();
+			canvas.innerHTML = '<span>old</span>';
+			Chartjs.createStackedChart(canvas, chartData);
+			expect(canvas.innerHTML).toBe('');
+			expect(global.Chart).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ type: 'bar' }));
+		});
+
+		test('merges user options', () => {
+			Chartjs.createStackedChart(makeCanvas(), chartData, null, { options: { responsive: false } });
+			expect(mockChartInstance.config.options.responsive).toBe(false);
+		});
+
+		test('title displayed when provided', () => {
+			Chartjs.createStackedChart(makeCanvas(), chartData, 'My Title');
+			expect(mockChartInstance.config.options.plugins.title.display).toBe(true);
+			expect(mockChartInstance.config.options.plugins.title.text).toBe('My Title');
+		});
+
+		test('title not displayed when null', () => {
+			Chartjs.createStackedChart(makeCanvas(), chartData, null);
+			expect(mockChartInstance.config.options.plugins.title.display).toBe(false);
+		});
+
+		test('tooltip label callback', () => {
+			Chartjs.createStackedChart(makeCanvas(), chartData);
+			const fn = mockChartInstance.config.options.plugins.tooltip.callbacks.label;
+			expect(fn({ dataset: { label: 'Test' }, parsed: { y: 42 } })).toBe('Test: 42');
+		});
+
+		test('accepts jQuery-like object', () => {
+			const canvas = makeCanvas();
+			const jq = { jquery: '3.6.0', 0: canvas, length: 1 };
+			expect(() => Chartjs.createStackedChart(jq, chartData)).not.toThrow();
+			expect(global.Chart).toHaveBeenCalled();
+		});
+	});
+
+	describe('createBarChart', () => {
+		const chartData = { labels: ['A', 'B'], datasets: [{ label: 'X', data: [1, 2] }] };
+
+		test('clears div and calls Chart constructor with type bar', () => {
+			const canvas = makeCanvas();
+			canvas.innerHTML = '<span>old</span>';
+			Chartjs.createBarChart(canvas, chartData);
+			expect(canvas.innerHTML).toBe('');
+			expect(global.Chart).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ type: 'bar' }));
+		});
+
+		test('title displayed when provided', () => {
+			Chartjs.createBarChart(makeCanvas(), chartData, 'My Title');
+			expect(mockChartInstance.config.options.plugins.title.display).toBe(true);
+			expect(mockChartInstance.config.options.plugins.title.text).toBe('My Title');
+		});
+
+		test('title not displayed when null', () => {
+			Chartjs.createBarChart(makeCanvas(), chartData, null);
+			expect(mockChartInstance.config.options.plugins.title.display).toBe(false);
+		});
+
+		test('tooltip label callback', () => {
+			Chartjs.createBarChart(makeCanvas(), chartData);
+			const fn = mockChartInstance.config.options.plugins.tooltip.callbacks.label;
+			expect(fn({ dataset: { label: 'Test' }, parsed: { y: 10 } })).toBe('Test : 10');
+		});
+
+		test('accepts jQuery-like object', () => {
+			const canvas = makeCanvas();
+			const jq = { jquery: '3.6.0', 0: canvas, length: 1 };
+			expect(() => Chartjs.createBarChart(jq, chartData)).not.toThrow();
+			expect(global.Chart).toHaveBeenCalled();
+		});
+	});
+
+	describe('createLineChart', () => {
+		const chartData = { labels: ['A', 'B'], datasets: [{ label: 'X', data: [1, 2] }] };
+
+		test('clears div and calls Chart constructor with type line', () => {
+			const canvas = makeCanvas();
+			Chartjs.createLineChart(canvas, chartData);
+			expect(canvas.innerHTML).toBe('');
+			expect(global.Chart).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ type: 'line' }));
+		});
+
+		test('tooltip label callback', () => {
+			Chartjs.createLineChart(makeCanvas(), chartData);
+			const fn = mockChartInstance.config.options.plugins.tooltip.callbacks.label;
+			expect(fn({ dataset: { label: 'Line' }, parsed: { y: 7 } })).toBe('Line : 7');
+		});
+	});
+
+	describe('createDoughnutChart', () => {
+		test('clears div and calls Chart constructor with type doughnut', () => {
+			const canvas = makeCanvas();
+			Chartjs.createDoughnutChart(canvas, { labels: ['A'], values: [1], colors: ['#f00'] });
+			expect(canvas.innerHTML).toBe('');
+			expect(global.Chart).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ type: 'doughnut' }));
+		});
+
+		test('uses chartData.values as dataset data', () => {
+			Chartjs.createDoughnutChart(makeCanvas(), { labels: ['A', 'B'], values: [30, 70], colors: ['#f00', '#00f'] });
+			expect(mockChartInstance.config.data.datasets[0].data).toEqual([30, 70]);
+		});
+
+		test('tooltip label shows percentage', () => {
+			Chartjs.createDoughnutChart(makeCanvas(), { labels: ['A', 'B'], values: [30, 70], colors: ['#f00', '#00f'] });
+			const fn = mockChartInstance.config.options.plugins.tooltip.callbacks.label;
+			expect(fn({ label: 'A', raw: 30, dataset: { data: [30, 70] } })).toBe('A: 30 (30.0%)');
+		});
+
+		test('tooltip label for 100%', () => {
+			Chartjs.createDoughnutChart(makeCanvas(), { labels: ['Only'], values: [100], colors: ['#f00'] });
+			const fn = mockChartInstance.config.options.plugins.tooltip.callbacks.label;
+			expect(fn({ label: 'Only', raw: 100, dataset: { data: [100] } })).toBe('Only: 100 (100.0%)');
+		});
+	});
+
 	describe('groupByPeriod', () => {
 		test('should group data by day (default)', () => {
 			const data = {
@@ -38,10 +180,7 @@ describe('Chartjs', () => {
 				'2024-01-16': { views: 20, clicks: 8 },
 				'2024-01-17': { views: 15, clicks: 6 }
 			};
-			const metrics = ['views', 'clicks'];
-
-			const result = Chartjs.groupByPeriod(data, 'day', metrics);
-
+			const result = Chartjs.groupByPeriod(data, 'day', ['views', 'clicks']);
 			expect(result).toHaveLength(3);
 			expect(result[0]).toEqual({ label: '2024-01-15', views: 10, clicks: 5 });
 			expect(result[1]).toEqual({ label: '2024-01-16', views: 20, clicks: 8 });
@@ -54,17 +193,12 @@ describe('Chartjs', () => {
 				'2024-01-20': { views: 20, clicks: 8 },
 				'2024-02-05': { views: 15, clicks: 6 }
 			};
-			const metrics = ['views', 'clicks'];
-
-			const result = Chartjs.groupByPeriod(data, 'month', metrics);
-
+			const result = Chartjs.groupByPeriod(data, 'month', ['views', 'clicks']);
 			expect(result).toHaveLength(2);
 			expect(result[0].label).toBe('2024-01');
 			expect(result[0].views).toBe(15);
 			expect(result[0].clicks).toBe(6.5);
 			expect(result[1].label).toBe('2024-02');
-			expect(result[1].views).toBe(15);
-			expect(result[1].clicks).toBe(6);
 		});
 
 		test('should group data by week', () => {
@@ -74,10 +208,7 @@ describe('Chartjs', () => {
 				'2024-01-08': { views: 15 },
 				'2024-01-09': { views: 25 }
 			};
-			const metrics = ['views'];
-
-			const result = Chartjs.groupByPeriod(data, 'week', metrics);
-
+			const result = Chartjs.groupByPeriod(data, 'week', ['views']);
 			expect(result.length).toBeGreaterThan(0);
 			result.forEach(item => {
 				expect(item.label).toMatch(/^\d{4}-S\d+$/);
@@ -85,34 +216,20 @@ describe('Chartjs', () => {
 		});
 
 		test('should handle single metric', () => {
-			const data = {
-				'2024-01-15': { views: 10 },
-				'2024-01-16': { views: 20 }
-			};
-			const metrics = ['views'];
-
-			const result = Chartjs.groupByPeriod(data, 'day', metrics);
-
+			const data = { '2024-01-15': { views: 10 }, '2024-01-16': { views: 20 } };
+			const result = Chartjs.groupByPeriod(data, 'day', ['views']);
 			expect(result).toHaveLength(2);
 			expect(result[0]).toEqual({ label: '2024-01-15', views: 10 });
-			expect(result[1]).toEqual({ label: '2024-01-16', views: 20 });
 		});
 
 		test('should handle multiple metrics', () => {
-			const data = {
-				'2024-01-15': { views: 10, clicks: 5, conversions: 2 }
-			};
-			const metrics = ['views', 'clicks', 'conversions'];
-
-			const result = Chartjs.groupByPeriod(data, 'day', metrics);
-
-			expect(result).toHaveLength(1);
+			const data = { '2024-01-15': { views: 10, clicks: 5, conversions: 2 } };
+			const result = Chartjs.groupByPeriod(data, 'day', ['views', 'clicks', 'conversions']);
 			expect(result[0]).toEqual({ label: '2024-01-15', views: 10, clicks: 5, conversions: 2 });
 		});
 
 		test('should handle empty data', () => {
-			const result = Chartjs.groupByPeriod({}, 'day', ['views']);
-			expect(result).toEqual([]);
+			expect(Chartjs.groupByPeriod({}, 'day', ['views'])).toEqual([]);
 		});
 
 		test('should average values when grouping by month', () => {
@@ -122,37 +239,42 @@ describe('Chartjs', () => {
 				'2024-01-20': { score: 300 }
 			};
 			const result = Chartjs.groupByPeriod(data, 'month', ['score']);
-
-			expect(result).toHaveLength(1);
-			expect(result[0].label).toBe('2024-01');
 			expect(result[0].score).toBe(200);
 		});
 
 		test('should handle missing metric values', () => {
-			const data = {
-				'2024-01-15': { views: 10 },
-				'2024-01-16': { views: 20, clicks: 5 }
-			};
+			const data = { '2024-01-15': { views: 10 }, '2024-01-16': { views: 20, clicks: 5 } };
 			const result = Chartjs.groupByPeriod(data, 'day', ['views', 'clicks']);
-
-			expect(result).toHaveLength(2);
 			expect(result[0]).toEqual({ label: '2024-01-15', views: 10, clicks: NaN });
 			expect(result[1]).toEqual({ label: '2024-01-16', views: 20, clicks: 5 });
 		});
 
 		test('should handle dates across different years', () => {
-			const data = {
-				'2023-12-30': { count: 5 },
-				'2024-01-02': { count: 10 }
-			};
+			const data = { '2023-12-30': { count: 5 }, '2024-01-02': { count: 10 } };
 			const result = Chartjs.groupByPeriod(data, 'month', ['count']);
-
-			expect(result).toHaveLength(2);
 			expect(result[0].label).toBe('2023-12');
 			expect(result[1].label).toBe('2024-01');
 		});
 	});
 
+	describe('getPeriodLabels', () => {
+		const { DatePeriod } = require('../date_time');
+
+		test('delegates to DatePeriod.getPeriodLabels with default locale/timezone', () => {
+			const spy = jest.spyOn(DatePeriod, 'getPeriodLabels');
+			const data = { '2024-01-01': {}, '2024-02-01': {} };
+			Chartjs.getPeriodLabels(data, 'month');
+			expect(spy).toHaveBeenCalledWith(Object.keys(data), 'month', 'fr-FR', 'Europe/Paris');
+		});
+
+		test('passes custom locale and timezone', () => {
+			const spy = jest.spyOn(DatePeriod, 'getPeriodLabels');
+			const data = { '2024-01-01': {} };
+			Chartjs.getPeriodLabels(data, 'month', 'en-US', 'America/New_York');
+			expect(spy).toHaveBeenCalledWith(Object.keys(data), 'month', 'en-US', 'America/New_York');
+		});
+	});
+
 	describe('getAutoGranularity', () => {
 		test('should return day_of_month for data spanning 30 days or less', () => {
 			expect(Chartjs.getAutoGranularity({ '2024-01-01': {}, '2024-01-15': {}, '2024-01-30': {} })).toBe('day_of_month');
@@ -191,99 +313,4 @@ describe('Chartjs', () => {
 		});
 	});
 
-	describe('chart creation', () => {
-		const chartData = { labels: ['A', 'B'], datasets: [{ label: 'X', data: [1, 2] }] };
-
-		test('createStackedChart clears div and calls Chart constructor', () => {
-			const canvas = makeCanvas();
-			canvas.innerHTML = '<span>old</span>';
-
-			Chartjs.createStackedChart(canvas, chartData);
-
-			expect(canvas.innerHTML).toBe('');
-			expect(global.Chart).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ type: 'bar' }));
-		});
-
-		test('createStackedChart merges user options', () => {
-			Chartjs.createStackedChart(makeCanvas(), chartData, null, { options: { responsive: false } });
-
-			expect(mockChartInstance.config.options.responsive).toBe(false);
-		});
-
-		test('createBarChart clears div and calls Chart constructor', () => {
-			const canvas = makeCanvas();
-			canvas.innerHTML = '<span>old</span>';
-
-			Chartjs.createBarChart(canvas, chartData);
-
-			expect(canvas.innerHTML).toBe('');
-			expect(global.Chart).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ type: 'bar' }));
-		});
-
-		test('createBarChart sets title when provided', () => {
-			Chartjs.createBarChart(makeCanvas(), chartData, 'My Title');
-
-			expect(mockChartInstance.config.options.plugins.title.display).toBe(true);
-			expect(mockChartInstance.config.options.plugins.title.text).toBe('My Title');
-		});
-
-		test('createLineChart clears div and calls Chart constructor', () => {
-			const canvas = makeCanvas();
-			Chartjs.createLineChart(canvas, chartData);
-
-			expect(canvas.innerHTML).toBe('');
-			expect(global.Chart).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ type: 'line' }));
-		});
-
-		test('createDoughnutChart clears div and calls Chart constructor', () => {
-			const canvas = makeCanvas();
-			Chartjs.createDoughnutChart(canvas, { labels: ['A'], values: [1], colors: ['#f00'] });
-
-			expect(canvas.innerHTML).toBe('');
-			expect(global.Chart).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ type: 'doughnut' }));
-		});
-
-		test('createDoughnutChart uses chartData.values as dataset data', () => {
-			Chartjs.createDoughnutChart(makeCanvas(), { labels: ['A', 'B'], values: [30, 70], colors: ['#f00', '#00f'] });
-
-			expect(mockChartInstance.config.data.datasets[0].data).toEqual([30, 70]);
-		});
-
-		test('title not displayed when null', () => {
-			Chartjs.createBarChart(makeCanvas(), chartData, null);
-
-			expect(mockChartInstance.config.options.plugins.title.display).toBe(false);
-		});
-
-		describe('jQuery compatibility (toEl)', () => {
-			test('createStackedChart accepts jQuery-like object', () => {
-				const canvas = makeCanvas();
-				const jq = { jquery: '3.6.0', 0: canvas, length: 1 };
-
-				expect(() => Chartjs.createStackedChart(jq, chartData)).not.toThrow();
-				expect(global.Chart).toHaveBeenCalled();
-			});
-
-			test('createBarChart accepts jQuery-like object', () => {
-				const canvas = makeCanvas();
-				const jq = { jquery: '3.6.0', 0: canvas, length: 1 };
-
-				expect(() => Chartjs.createBarChart(jq, chartData)).not.toThrow();
-				expect(global.Chart).toHaveBeenCalled();
-			});
-		});
-	});
-
-	describe('class structure', () => {
-		test('should have all expected static methods', () => {
-			expect(typeof Chartjs.init).toBe('function');
-			expect(typeof Chartjs.createStackedChart).toBe('function');
-			expect(typeof Chartjs.createBarChart).toBe('function');
-			expect(typeof Chartjs.createLineChart).toBe('function');
-			expect(typeof Chartjs.createDoughnutChart).toBe('function');
-			expect(typeof Chartjs.groupByPeriod).toBe('function');
-			expect(typeof Chartjs.getPeriodLabels).toBe('function');
-			expect(typeof Chartjs.getAutoGranularity).toBe('function');
-		});
-	});
 });

package/tests/form_helper.test.js

@@ -2,6 +2,7 @@
  * @jest-environment jsdom
  */
 require('../array'); // For removeEmptyValues method
+require('../string'); // For normalizeBreaks method
 const { FormHelper, ArrayField, EditValue } = require('../form_helper');
 
 // Helper functions
@@ -43,9 +44,15 @@ function addSelect(form, name, options = []) {
 	return select;
 }
 
+// Simule un objet jQuery wrappant un élément DOM natif
+function mockJQuery(el) {
+	return { jquery: '3.0', 0: el, length: 1 };
+}
+
 afterEach(() => {
 	document.body.innerHTML = '';
 	jest.clearAllMocks();
+	delete global.$;
 });
 
 describe('FormHelper', () => {
@@ -88,6 +95,18 @@ describe('FormHelper', () => {
 			expect(onSubmitCallback).toHaveBeenCalledWith(form, customBtn);
 		});
 
+		test('should return jQuery wrapper when passed a jQuery object', () => {
+			const form = setupForm();
+			addButton(form, 'validate', 'Submit');
+			const jqForm = mockJQuery(form);
+			global.$ = jest.fn(el => mockJQuery(el));
+
+			const result = FormHelper.init(jqForm, jest.fn());
+
+			expect(result).toHaveProperty('jquery');
+			expect(result[0]).toBe(form);
+		});
+
 		test('should call buttonLoader with loading on submit', () => {
 			const form = setupForm();
 			const btn = addButton(form, 'validate', 'Submit');
@@ -521,6 +540,17 @@ describe('FormHelper', () => {
 			expect(form.querySelectorAll('div.form_errors').length).toBe(0);
 			expect(result).toBe(form);
 		});
+
+		test('should return jQuery wrapper when passed a jQuery object', () => {
+			const form = setupForm();
+			const jqForm = mockJQuery(form);
+			global.$ = jest.fn(el => mockJQuery(el));
+
+			const result = FormHelper.hideFormErrors(jqForm);
+
+			expect(result).toHaveProperty('jquery');
+			expect(result[0]).toBe(form);
+		});
 	});
 
 	describe('displayFormErrorsFromText', () => {
@@ -909,23 +939,306 @@ describe('FormHelper', () => {
 });
 
 describe('ArrayField', () => {
-	test('should be a class', () => {
-		expect(typeof ArrayField).toBe('function');
-		expect(typeof ArrayField.init).toBe('function');
+	let container;
+
+	beforeEach(() => {
+		container = document.createElement('div');
+		document.body.appendChild(container);
+	});
+
+	afterEach(() => {
+		document.body.innerHTML = '';
+	});
+
+	function makeOptions(overrides = {}) {
+		return Object.assign({
+			entering_field_in_table: false,
+			add_one_button_enabled: true,
+			add_multi_button_enabled: false,
+			input_name: 'items[]',
+			item_name: 'Item',
+		}, overrides);
+	}
+
+	// jsdom applies HTML5 foster-parenting: <tr> inside <div>.innerHTML gets stripped.
+	// ArrayField.init falls back to cloneNode when a .base template row exists,
+	// so we pre-populate the container with a base row to make row tests work.
+	function addBaseRow(opts = {}) {
+		const enteringInTable = opts.entering_field_in_table ?? false;
+		const inputName = opts.input_name ?? 'items[]';
+		let tdContent, links;
+		if (enteringInTable) {
+			tdContent = `<input type="text" name="${inputName}" class="form-control">`;
+			links = '<a href="#" class="add btn btn-sm btn-success ms-1"></a><a href="#" class="remove btn btn-sm btn-danger ms-1"></a>';
+		} else {
+			tdContent = `<input type="hidden" name="${inputName}"> <span class="value"></span>`;
+			links = '<a href="#" class="remove btn btn-sm btn-danger ms-1"></a>';
+		}
+		container.innerHTML = `<table class="table table-sm"><tbody><tr class="base hide"><td class="table-input">${tdContent}</td><td class="table-links">${links}</td></tr></tbody></table>`;
+	}
+
+	test('creates table and list_empty if not present', () => {
+		ArrayField.init(container, [], makeOptions());
+		expect(container.querySelector('table')).not.toBeNull();
+		expect(container.querySelector('.list_empty')).not.toBeNull();
+	});
+
+	test('shows list_empty and hides table when no items', () => {
+		ArrayField.init(container, [], makeOptions());
+		expect(container.querySelector('.list_empty').classList.contains('hide')).toBe(false);
+		expect(container.querySelector('table').classList.contains('hide')).toBe(true);
+	});
+
+	test('populates default values as rows', () => {
+		addBaseRow();
+		ArrayField.init(container, ['foo', 'bar'], makeOptions());
+		const rows = container.querySelectorAll('table tbody tr:not(.base)');
+		expect(rows).toHaveLength(2);
+	});
+
+	test('table is visible when items are present', () => {
+		addBaseRow();
+		ArrayField.init(container, ['item1'], makeOptions());
+		expect(container.querySelector('table').classList.contains('hide')).toBe(false);
+		expect(container.querySelector('.list_empty').classList.contains('hide')).toBe(true);
+	});
+
+	test('row contains hidden input and span.value for entering_field_in_table=false', () => {
+		addBaseRow({ entering_field_in_table: false });
+		ArrayField.init(container, ['hello'], makeOptions({ entering_field_in_table: false }));
+		const row = container.querySelector('table tbody tr:not(.base)');
+		expect(row.querySelector('input[type="hidden"]')).not.toBeNull();
+		expect(row.querySelector('span.value')).not.toBeNull();
+		expect(row.querySelector('input[type="hidden"]').value).toBe('hello');
+		expect(row.querySelector('span.value').textContent).toBe('hello');
+	});
+
+	test('row contains text input for entering_field_in_table=true', () => {
+		addBaseRow({ entering_field_in_table: true });
+		ArrayField.init(container, ['hello'], makeOptions({ entering_field_in_table: true, nb_min_lines: 0 }));
+		const row = container.querySelector('table tbody tr:not(.base)');
+		expect(row.querySelector('input[type="text"]')).not.toBeNull();
+	});
+
+	test('creates add_one button when add_one_button_enabled', () => {
+		ArrayField.init(container, [], makeOptions({ add_one_button_enabled: true }));
+		expect(container.querySelector('a.add_one')).not.toBeNull();
+	});
+
+	test('does not create add_one button when disabled', () => {
+		ArrayField.init(container, [], makeOptions({ add_one_button_enabled: false }));
+		expect(container.querySelector('a.add_one')).toBeNull();
+	});
+
+	test('clicking add_one shows item_add_one div', () => {
+		ArrayField.init(container, [], makeOptions({ add_one_button_enabled: true }));
+		container.querySelector('a.add_one').click();
+		expect(container.querySelector('.item_add_one').classList.contains('hide')).toBe(false);
+	});
+
+	test('clicking cancel in add_one hides item_add_one div', () => {
+		ArrayField.init(container, [], makeOptions({ add_one_button_enabled: true }));
+		container.querySelector('a.add_one').click();
+		container.querySelector('.item_add_one a.cancel').click();
+		expect(container.querySelector('.item_add_one').classList.contains('hide')).toBe(true);
+	});
+
+	test('clicking add in item_add_one adds a new row', () => {
+		addBaseRow();
+		ArrayField.init(container, [], makeOptions({ add_one_button_enabled: true }));
+		container.querySelector('a.add_one').click();
+		container.querySelector('.item_add_one input.form-control').value = 'newitem';
+		container.querySelector('.item_add_one a.add').click();
+		const rows = container.querySelectorAll('table tbody tr:not(.base)');
+		expect(rows).toHaveLength(1);
+		expect(rows[0].querySelector('span.value').textContent).toBe('newitem');
+	});
+
+	test('remove button removes a row', () => {
+		addBaseRow();
+		ArrayField.init(container, ['a', 'b'], makeOptions());
+		expect(container.querySelectorAll('table tbody tr:not(.base)')).toHaveLength(2);
+		container.querySelector('table tbody tr:not(.base) a.remove').click();
+		expect(container.querySelectorAll('table tbody tr:not(.base)')).toHaveLength(1);
+	});
+
+	test('calls update_list_callback on changes', () => {
+		addBaseRow();
+		const cb = jest.fn();
+		ArrayField.init(container, ['x'], makeOptions({ update_list_callback: cb }));
+		expect(cb).toHaveBeenCalled();
+	});
+
+	test('calls init_callback with container after init', () => {
+		const cb = jest.fn();
+		ArrayField.init(container, [], makeOptions({ init_callback: cb }));
+		expect(cb).toHaveBeenCalledWith(container, expect.any(Function), expect.any(Function));
+	});
+
+	test('uses custom list_empty_text', () => {
+		ArrayField.init(container, [], makeOptions({ list_empty_text: 'Nothing here' }));
+		expect(container.querySelector('.list_empty').textContent).toBe('Nothing here');
+	});
+
+	test('calls get_errors_callback and shows errors on invalid input', () => {
+		addBaseRow();
+		ArrayField.init(container, [], makeOptions({
+			add_one_button_enabled: true,
+			get_errors_callback: () => ['Invalid value'],
+		}));
+		container.querySelector('a.add_one').click();
+		container.querySelector('.item_add_one input.form-control').value = 'bad';
+		container.querySelector('.item_add_one a.add').click();
+		expect(container.querySelectorAll('table tbody tr:not(.base)')).toHaveLength(0);
+	});
+
+	test('does not add duplicate items', () => {
+		addBaseRow();
+		ArrayField.init(container, ['dup'], makeOptions({ add_one_button_enabled: true }));
+		container.querySelector('a.add_one').click();
+		container.querySelector('.item_add_one input.form-control').value = 'dup';
+		container.querySelector('.item_add_one a.add').click();
+		expect(container.querySelectorAll('table tbody tr:not(.base)')).toHaveLength(1);
+	});
+
+	test('applies nb_max_lines limit: disables add button when reached', () => {
+		addBaseRow({ entering_field_in_table: true });
+		ArrayField.init(container, ['a', 'b'], makeOptions({
+			entering_field_in_table: true,
+			nb_max_lines: 2,
+			nb_min_lines: 0,
+		}));
+		const addLinks = container.querySelectorAll('table tbody tr:not(.base) a.add');
+		addLinks.forEach(a => expect(a.classList.contains('disabled')).toBe(true));
+	});
+
+	test('creates add_multi button when add_multi_button_enabled', () => {
+		ArrayField.init(container, [], makeOptions({ add_multi_button_enabled: true, add_one_button_enabled: false }));
+		expect(container.querySelector('a.add_multi')).not.toBeNull();
 	});
 
-	test('init should be a static method', () => {
-		expect(typeof ArrayField.init).toBe('function');
+	test('clicking add_multi shows item_add_multi div', () => {
+		ArrayField.init(container, [], makeOptions({ add_multi_button_enabled: true, add_one_button_enabled: false }));
+		container.querySelector('a.add_multi').click();
+		expect(container.querySelector('.item_add_multi').classList.contains('hide')).toBe(false);
+	});
+
+	test('clicking cancel in add_multi hides item_add_multi', () => {
+		ArrayField.init(container, [], makeOptions({ add_multi_button_enabled: true, add_one_button_enabled: false }));
+		container.querySelector('a.add_multi').click();
+		container.querySelector('.item_add_multi a.cancel').click();
+		expect(container.querySelector('.item_add_multi').classList.contains('hide')).toBe(true);
+	});
+
+	test('add_multi adds multiple items from textarea', () => {
+		addBaseRow();
+		ArrayField.init(container, [], makeOptions({ add_multi_button_enabled: true, add_one_button_enabled: false }));
+		container.querySelector('a.add_multi').click();
+		container.querySelector('.item_add_multi textarea').value = 'alpha\nbeta\ngamma';
+		container.querySelector('.item_add_multi a.add').click();
+		expect(container.querySelectorAll('table tbody tr:not(.base)')).toHaveLength(3);
+	});
+
+	test('applies format_entered_value_callback on add', () => {
+		addBaseRow();
+		ArrayField.init(container, [], makeOptions({
+			add_one_button_enabled: true,
+			format_entered_value_callback: v => v.toUpperCase(),
+		}));
+		container.querySelector('a.add_one').click();
+		container.querySelector('.item_add_one input.form-control').value = 'hello';
+		container.querySelector('.item_add_one a.add').click();
+		const row = container.querySelector('table tbody tr:not(.base)');
+		expect(row.querySelector('span.value').textContent).toBe('HELLO');
+	});
+
+	test('entering_field_in_table: remove disabled when only 1 row remains', () => {
+		addBaseRow({ entering_field_in_table: true });
+		ArrayField.init(container, ['only'], makeOptions({ entering_field_in_table: true, nb_min_lines: 0 }));
+		const removeLink = container.querySelector('table tbody tr:not(.base) a.remove');
+		expect(removeLink.classList.contains('disabled')).toBe(true);
 	});
 });
 
 describe('EditValue', () => {
-	test('should be a class', () => {
-		expect(typeof EditValue).toBe('function');
-		expect(typeof EditValue.init).toBe('function');
+	let valueDiv, parent;
+
+	beforeEach(() => {
+		parent = document.createElement('div');
+		valueDiv = document.createElement('span');
+		valueDiv.textContent = 'original';
+		parent.appendChild(valueDiv);
+		document.body.appendChild(parent);
+	});
+
+	afterEach(() => {
+		document.body.innerHTML = '';
+	});
+
+	test('appends a pencil link next to valueDiv', () => {
+		EditValue.init(valueDiv, jest.fn());
+		expect(parent.querySelector('a')).not.toBeNull();
+	});
+
+	test('clicking pencil link hides spans and links and shows a form', () => {
+		EditValue.init(valueDiv, jest.fn());
+		parent.querySelector('a').click();
+		expect(parent.querySelector('form')).not.toBeNull();
+		expect(valueDiv.classList.contains('hide')).toBe(true);
+	});
+
+	test('form contains input pre-filled with current text', () => {
+		valueDiv.textContent = 'current value';
+		EditValue.init(valueDiv, jest.fn());
+		parent.querySelector('a').click();
+		const input = parent.querySelector('form input');
+		expect(input.value).toBe('current value');
+	});
+
+	test('form uses data-value attribute when present', () => {
+		valueDiv.dataset.value = 'raw-value';
+		valueDiv.textContent = 'Formatted value';
+		EditValue.init(valueDiv, jest.fn());
+		parent.querySelector('a').click();
+		expect(parent.querySelector('form input').value).toBe('raw-value');
+	});
+
+	test('calls onSubmitCallback with new value when submit button clicked', () => {
+		const cb = jest.fn();
+		EditValue.init(valueDiv, cb);
+		parent.querySelector('a').click();
+		parent.querySelector('form input').value = 'new val';
+		parent.querySelector('form button').click();
+		expect(cb).toHaveBeenCalledWith('new val', parent, expect.any(Function));
+	});
+
+	test('on success callback updates span value', () => {
+		let capturedCallback;
+		const cb = jest.fn((newVal, par, done) => { capturedCallback = done; });
+		EditValue.init(valueDiv, cb);
+		parent.querySelector('a').click();
+		parent.querySelector('form input').value = 'updated';
+		parent.querySelector('form button').click();
+		capturedCallback(true);
+		expect(valueDiv.textContent).toBe('updated');
+	});
+
+	test('on failure callback does not update span value', () => {
+		let capturedCallback;
+		const cb = jest.fn((newVal, par, done) => { capturedCallback = done; });
+		EditValue.init(valueDiv, cb);
+		parent.querySelector('a').click();
+		parent.querySelector('form input').value = 'updated';
+		parent.querySelector('form button').click();
+		capturedCallback(false);
+		expect(valueDiv.textContent).toBe('original');
 	});
 
-	test('init should be a static method', () => {
-		expect(typeof EditValue.init).toBe('function');
+	test('uses getInputCallback for custom input element', () => {
+		const getInput = jest.fn(() => '<select><option value="x">X</option></select>');
+		EditValue.init(valueDiv, jest.fn(), getInput);
+		parent.querySelector('a').click();
+		expect(parent.querySelector('form select')).not.toBeNull();
+		expect(getInput).toHaveBeenCalled();
 	});
 });

package/tests/select_all.test.js

@@ -82,6 +82,10 @@ describe('SelectAll', () => {
 			const formGroup = document.querySelector('.form-group');
 			expect(() => SelectAll.updateFormGroup(formGroup)).not.toThrow();
 		});
+
+		test('should do nothing when formGroup is null', () => {
+			expect(() => SelectAll.updateFormGroup(null)).not.toThrow();
+		});
 	});
 
 	describe('initLinkInFormGroup', () => {
@@ -130,6 +134,20 @@ describe('SelectAll', () => {
 			});
 			expect(formGroup.querySelector('a.check_all').textContent).toBe('Tout désélectionner');
 		});
+
+		test('should not throw when checkbox has no .form-group ancestor', () => {
+			// Simule une checkbox hors de tout .form-group (le cas du bug en prod)
+			document.body.innerHTML = `
+				<div>
+					<a class="check_all" href="#">Tout sélectionner</a>
+					<input type="checkbox" id="orphan">
+				</div>`;
+			const link = document.querySelector('a.check_all');
+			SelectAll.initLinkInFormGroup(link);
+			const cb = document.getElementById('orphan');
+			cb.checked = true;
+			expect(() => cb.dispatchEvent(new Event('change'))).not.toThrow();
+		});
 	});
 
 	describe('updateTable', () => {
@@ -159,6 +177,10 @@ describe('SelectAll', () => {
 				</table>`;
 			expect(() => SelectAll.updateTable(document.querySelector('table'))).not.toThrow();
 		});
+
+		test('should do nothing when table is null', () => {
+			expect(() => SelectAll.updateTable(null)).not.toThrow();
+		});
 	});
 
 	describe('initInTable', () => {
@@ -197,6 +219,10 @@ describe('SelectAll', () => {
 			});
 			expect(table.querySelector('thead input.check_all').checked).toBe(true);
 		});
+
+		test('should do nothing when table is null', () => {
+			expect(() => SelectAll.initInTable(null)).not.toThrow();
+		});
 	});
 
 	describe('updateDiv', () => {
@@ -222,6 +248,10 @@ describe('SelectAll', () => {
 			document.body.innerHTML = `<div class="checkbox_with_check_all"><div class="form-check"><input type="checkbox"></div></div>`;
 			expect(() => SelectAll.updateDiv(document.querySelector('.checkbox_with_check_all'))).not.toThrow();
 		});
+
+		test('should do nothing when div is null', () => {
+			expect(() => SelectAll.updateDiv(null)).not.toThrow();
+		});
 	});
 
 	describe('initDiv', () => {
@@ -270,5 +300,23 @@ describe('SelectAll', () => {
 			SelectAll.initDiv(contentDiv);
 			expect(contentDiv.querySelector('input.check_all').checked).toBe(true);
 		});
+
+		test('should do nothing when contentDiv is null', () => {
+			expect(() => SelectAll.initDiv(null)).not.toThrow();
+		});
+
+		test('should not throw when checkbox has no .checkbox_with_check_all ancestor', () => {
+			// check_all orpheline — closest('div.checkbox_with_check_all') retourne null
+			document.body.innerHTML = `
+				<div id="content">
+					<input type="checkbox" class="check_all">
+					<div class="form-check"><input type="checkbox" id="orphan"></div>
+				</div>`;
+			const contentDiv = document.getElementById('content');
+			SelectAll.initDiv(contentDiv);
+			const cb = document.getElementById('orphan');
+			cb.checked = true;
+			expect(() => cb.dispatchEvent(new Event('change'))).not.toThrow();
+		});
 	});
 });