@osimatic/helpers-js 1.5.5 → 1.5.6

package/tests/count_down.test.js

@@ -4,59 +4,15 @@
 const { CountDown } = require('../count_down');
 
 describe('CountDown', () => {
-	let mockDiv;
-	let mockLink;
-	let mockCountDownCurrent;
-	let mockCountDownText;
+	let div;
 	let intervalCallback;
-	let clickCallback;
 
 	beforeEach(() => {
 		jest.useFakeTimers();
 
-		// Mock link element
-		mockLink = {
-			click: jest.fn(function(callback) {
-				clickCallback = callback;
-				return this;
-			}),
-			attr: jest.fn().mockReturnThis(),
-			button: jest.fn().mockReturnThis(),
-			prop: jest.fn(() => false),
-			length: 1
-		};
-
-		// Mock progress bar current
-		mockCountDownCurrent = {
-			width: jest.fn(),
-			length: 1
-		};
-
-		// Mock text element
-		mockCountDownText = {
-			html: jest.fn(),
-			length: 1
-		};
-
-		// Mock main div
-		mockDiv = {
-			length: 1,
-			append: jest.fn().mockReturnThis(),
-			find: jest.fn((selector) => {
-				if (selector === '.count_down_link a') {
-					return mockLink;
-				}
-				if (selector === '.count_down_current') {
-					return mockCountDownCurrent;
-				}
-				if (selector === '.count_down_text') {
-					return mockCountDownText;
-				}
-				return { length: 0 };
-			})
-		};
-
-		// Spy on setInterval to capture callback
+		div = document.createElement('div');
+		document.body.appendChild(div);
+
 		const originalSetInterval = global.setInterval;
 		jest.spyOn(global, 'setInterval').mockImplementation((callback, delay) => {
 			intervalCallback = callback;
@@ -67,144 +23,124 @@ describe('CountDown', () => {
 	afterEach(() => {
 		jest.clearAllTimers();
 		jest.restoreAllMocks();
+		document.body.innerHTML = '';
 	});
 
-	describe('init', () => {
-		test('should return undefined when div has no length', () => {
-			const result = CountDown.init({ length: 0 }, { onRefreshData: jest.fn() });
+	function getLinkA()           { return div.querySelector('.count_down_link a'); }
+	function getCountDownCurrent(){ return div.querySelector('.count_down_current'); }
+	function getCountDownText()   { return div.querySelector('.count_down_text'); }
 
+	describe('init', () => {
+		test('should return undefined when div is null', () => {
+			const result = CountDown.init(null, { onRefreshData: jest.fn() });
 			expect(result).toBeUndefined();
 		});
 
 		test('should create countdown UI elements with provided labels', () => {
-			CountDown.init(mockDiv, { labelNextUpdate: 'Next Update', labelDoUpdate: 'Refresh Now' });
+			CountDown.init(div, { labelNextUpdate: 'Next Update', labelDoUpdate: 'Refresh Now' });
 
-			expect(mockDiv.append).toHaveBeenCalledTimes(4);
-			expect(mockDiv.append).toHaveBeenCalledWith('<div class="count_down_title">Next Update</div>');
-			expect(mockDiv.append).toHaveBeenCalledWith('<div class="count_down_progress"><div class="count_down_current"></div></div>');
-			expect(mockDiv.append).toHaveBeenCalledWith('<div class="count_down_text"></div>');
-			expect(mockDiv.append).toHaveBeenCalledWith('<div class="count_down_link"><a href="#" data-loading-text="<i class=\'fa fa-circle-notch fa-spin\'></i>">Refresh Now</a></div>');
+			expect(div.querySelector('.count_down_title').textContent).toBe('Next Update');
+			expect(div.querySelector('.count_down_progress')).not.toBeNull();
+			expect(getCountDownCurrent()).not.toBeNull();
+			expect(getCountDownText()).not.toBeNull();
+			expect(getLinkA().textContent).toBe('Refresh Now');
 		});
 
 		test('should use default labels when not provided', () => {
-			CountDown.init(mockDiv, {});
+			CountDown.init(div, {});
 
-			expect(mockDiv.append).toHaveBeenCalledWith('<div class="count_down_title">Prochaine mise à jour</div>');
-			expect(mockDiv.append).toHaveBeenCalledWith(expect.stringContaining('Mettre à jour'));
+			expect(div.querySelector('.count_down_title').textContent).toBe('Prochaine mise à jour');
+			expect(getLinkA().textContent).toBe('Mettre à jour');
 		});
 
 		test('should set up click handler on refresh link', () => {
-			CountDown.init(mockDiv, {});
-
-			expect(mockLink.click).toHaveBeenCalled();
-		});
-
-		test('should return false on click', () => {
-			const callback = jest.fn((completeCallback) => completeCallback());
-			CountDown.init(mockDiv, { onRefreshData: callback });
+			const callback = jest.fn((cb) => cb());
+			CountDown.init(div, { onRefreshData: callback });
+			const callCountAfterInit = callback.mock.calls.length;
 
-			const result = clickCallback.call(mockLink);
+			getLinkA().click();
 
-			expect(result).toBe(false);
+			expect(callback.mock.calls.length).toBeGreaterThan(callCountAfterInit);
 		});
 
 		test('should start interval timer', () => {
-			CountDown.init(mockDiv, {});
-
+			CountDown.init(div, {});
 			expect(setInterval).toHaveBeenCalledWith(expect.any(Function), 60);
 		});
 
 		test('should call onRefreshData immediately after init', () => {
-			const callback = jest.fn((completeCallback) => completeCallback());
-			CountDown.init(mockDiv, { onRefreshData: callback });
+			const callback = jest.fn((cb) => cb());
+			CountDown.init(div, { onRefreshData: callback });
 
 			expect(callback).toHaveBeenCalled();
 		});
 
-		test('should not throw when refresh link is missing', () => {
-			mockDiv.find = jest.fn((selector) => {
-				if (selector === '.count_down_link a') return { length: 0, attr: jest.fn().mockReturnThis(), button: jest.fn().mockReturnThis() };
-				if (selector === '.count_down_current') return mockCountDownCurrent;
-				if (selector === '.count_down_text') return mockCountDownText;
-				return { length: 0 };
-			});
-
-			expect(() => {
-				CountDown.init(mockDiv, {});
-			}).not.toThrow();
+		test('should accept a jQuery-like object', () => {
+			const jqueryLike = { jquery: '3.6.0', 0: div, length: 1 };
+			expect(() => CountDown.init(jqueryLike, {})).not.toThrow();
+			expect(div.querySelector('.count_down_title')).not.toBeNull();
 		});
 	});
 
 	describe('refreshData', () => {
 		test('should call onRefreshData on click', () => {
-			const callback = jest.fn((completeCallback) => completeCallback());
-			CountDown.init(mockDiv, { onRefreshData: callback });
-			jest.clearAllMocks();
+			const callback = jest.fn((cb) => cb());
+			CountDown.init(div, { onRefreshData: callback });
+			const callCountAfterInit = callback.mock.calls.length;
 
-			clickCallback.call(mockLink);
+			getLinkA().click();
 
-			expect(callback).toHaveBeenCalledWith(expect.any(Function));
+			expect(callback.mock.calls.length).toBe(callCountAfterInit + 1);
 		});
 
 		test('should disable button during request', () => {
 			let callCount = 0;
-			const callback = jest.fn((completeCallback) => {
+			const callback = jest.fn((cb) => {
 				callCount++;
-				if (callCount === 1) completeCallback(); // init call complète
-				// le click ne complète pas → alreadyMakingRequest reste true
+				if (callCount === 1) cb(); // first (init) call completes, click does not
 			});
-			CountDown.init(mockDiv, { onRefreshData: callback });
-			jest.clearAllMocks();
+			CountDown.init(div, { onRefreshData: callback });
 
-			clickCallback.call(mockLink);
+			getLinkA().click();
 
-			expect(mockLink.attr).toHaveBeenCalledWith('disabled', true);
-			expect(mockLink.button).toHaveBeenCalledWith('loading');
+			expect(getLinkA().disabled).toBe(true);
 		});
 
 		test('should re-enable button after request completes', () => {
-			const callback = jest.fn((completeCallback) => completeCallback());
-			CountDown.init(mockDiv, { onRefreshData: callback });
-			jest.clearAllMocks();
+			const callback = jest.fn((cb) => cb());
+			CountDown.init(div, { onRefreshData: callback });
 
-			clickCallback.call(mockLink);
+			getLinkA().click();
 
-			expect(mockLink.attr).toHaveBeenCalledWith('disabled', false);
-			expect(mockLink.button).toHaveBeenCalledWith('reset');
+			expect(getLinkA().disabled).toBe(false);
 		});
 
 		test('should not launch new request if already making request', () => {
 			const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
-			const callback = jest.fn(); // ne complète pas, laisse alreadyMakingRequest = true
-			CountDown.init(mockDiv, { onRefreshData: callback });
-
-			// à ce stade le premier refreshData() a été appelé sans compléter
+			const callback = jest.fn(); // never completes → alreadyMakingRequest stays true
+			CountDown.init(div, { onRefreshData: callback });
 			const callCountAfterInit = callback.mock.calls.length;
 
-			clickCallback.call(mockLink); // bloqué
+			getLinkA().click();
 
 			expect(callback.mock.calls.length).toBe(callCountAfterInit);
 			expect(consoleLogSpy).toHaveBeenCalledWith('Already making request, no new request lauched.');
-
 			consoleLogSpy.mockRestore();
 		});
 
 		test('should not crash if onRefreshData is not a function', () => {
-			expect(() => {
-				CountDown.init(mockDiv, {});
-			}).not.toThrow();
+			expect(() => CountDown.init(div, {})).not.toThrow();
 		});
 
 		test('should allow new request after previous completes', () => {
 			let completeCallback;
 			const callback = jest.fn((cb) => { completeCallback = cb; });
-			CountDown.init(mockDiv, { onRefreshData: callback });
+			CountDown.init(div, { onRefreshData: callback });
 
-			// complète la première requête
 			completeCallback();
 			const callCountAfterComplete = callback.mock.calls.length;
 
-			clickCallback.call(mockLink);
+			getLinkA().click();
 
 			expect(callback.mock.calls.length).toBe(callCountAfterComplete + 1);
 		});
@@ -212,147 +148,97 @@ describe('CountDown', () => {
 
 	describe('interval timer behavior', () => {
 		test('should show remaining seconds in text', () => {
-			const callback = jest.fn((completeCallback) => completeCallback());
-			CountDown.init(mockDiv, { onRefreshData: callback });
-			jest.clearAllMocks();
+			const callback = jest.fn((cb) => cb());
+			CountDown.init(div, { onRefreshData: callback });
 
 			intervalCallback();
 
-			expect(mockCountDownText.html).toHaveBeenCalledWith('10s');
+			expect(getCountDownText().innerHTML).toBe('10s');
 		});
 
 		test('should show 0s when time reaches limit', () => {
-			const callback = jest.fn((completeCallback) => completeCallback());
-			CountDown.init(mockDiv, { onRefreshData: callback });
+			const callback = jest.fn((cb) => cb());
+			CountDown.init(div, { onRefreshData: callback });
 
-			for (let i = 0; i < 166; i++) {
-				intervalCallback();
-			}
-			jest.clearAllMocks();
-			intervalCallback(); // tick 167 : currentMillis = 10020 → 0s
+			for (let i = 0; i < 167; i++) intervalCallback();
 
-			expect(mockCountDownText.html).toHaveBeenCalledWith('0s');
+			expect(getCountDownText().innerHTML).toBe('0s');
 		});
 
 		test('should set progress bar to full when time reaches limit', () => {
-			const callback = jest.fn((completeCallback) => completeCallback());
-			CountDown.init(mockDiv, { onRefreshData: callback });
+			const callback = jest.fn((cb) => cb());
+			CountDown.init(div, { onRefreshData: callback });
 
-			for (let i = 0; i < 166; i++) {
-				intervalCallback();
-			}
-			jest.clearAllMocks();
-			intervalCallback(); // tick 167 : width = 120
+			for (let i = 0; i < 167; i++) intervalCallback();
 
-			expect(mockCountDownCurrent.width).toHaveBeenCalledWith(120);
+			expect(getCountDownCurrent().style.width).toBe('120px');
 		});
 
-		test('should update progress bar width', () => {
-			const callback = jest.fn((completeCallback) => completeCallback());
-			CountDown.init(mockDiv, { onRefreshData: callback });
-			jest.clearAllMocks();
+		test('should update progress bar width proportionally', () => {
+			const callback = jest.fn((cb) => cb());
+			CountDown.init(div, { onRefreshData: callback });
 
 			intervalCallback();
 
-			expect(mockCountDownCurrent.width).toHaveBeenCalled();
-			const widthArg = mockCountDownCurrent.width.mock.calls[0][0];
-			expect(widthArg).toBeGreaterThanOrEqual(0);
-			expect(widthArg).toBeLessThanOrEqual(120);
+			const width = parseInt(getCountDownCurrent().style.width);
+			expect(width).toBeGreaterThanOrEqual(0);
+			expect(width).toBeLessThanOrEqual(120);
 		});
 
 		test('should trigger refreshData after timeout when time limit reached', () => {
-			const callback = jest.fn((completeCallback) => completeCallback());
-			CountDown.init(mockDiv, { onRefreshData: callback });
+			const callback = jest.fn((cb) => cb());
+			CountDown.init(div, { onRefreshData: callback });
 
-			for (let i = 0; i < 167; i++) {
-				intervalCallback();
-			}
+			for (let i = 0; i < 167; i++) intervalCallback();
 
 			const callCountBefore = callback.mock.calls.length;
-			intervalCallback();
 			jest.advanceTimersByTime(100);
 
 			expect(callback.mock.calls.length).toBeGreaterThan(callCountBefore);
 		});
 
-		test('should reset progress to 0 when button is disabled', () => {
-			mockLink.prop = jest.fn(() => true); // bouton désactivé
-
-			const callback = jest.fn((completeCallback) => completeCallback());
-			CountDown.init(mockDiv, { onRefreshData: callback });
-			jest.clearAllMocks();
+		test('should reset currentMillis to 0 when button is disabled', () => {
+			const callback = jest.fn((cb) => cb());
+			CountDown.init(div, { onRefreshData: callback });
 
+			getLinkA().disabled = true;
 			intervalCallback();
 
-			// currentMillis reste à 0 → currentSecond = 0 → width = 0
-			const widthArg = mockCountDownCurrent.width.mock.calls[0][0];
-			expect(widthArg).toBe(0);
-		});
-
-		test('should handle missing progress bar element', () => {
-			mockDiv.find = jest.fn((selector) => {
-				if (selector === '.count_down_link a') return mockLink;
-				if (selector === '.count_down_current') return { length: 0 };
-				if (selector === '.count_down_text') return mockCountDownText;
-				return { length: 0 };
-			});
-
-			const callback = jest.fn((completeCallback) => completeCallback());
-			CountDown.init(mockDiv, { onRefreshData: callback });
-
-			expect(() => { intervalCallback(); }).not.toThrow();
-		});
-
-		test('should handle missing text element', () => {
-			mockDiv.find = jest.fn((selector) => {
-				if (selector === '.count_down_link a') return mockLink;
-				if (selector === '.count_down_current') return mockCountDownCurrent;
-				if (selector === '.count_down_text') return { length: 0 };
-				return { length: 0 };
-			});
-
-			const callback = jest.fn((completeCallback) => completeCallback());
-			CountDown.init(mockDiv, { onRefreshData: callback });
-
-			expect(() => { intervalCallback(); }).not.toThrow();
+			expect(getCountDownCurrent().style.width).toBe('0px');
 		});
 	});
 
 	describe('integration scenarios', () => {
 		test('should complete full countdown cycle', () => {
-			const callback = jest.fn((completeCallback) => completeCallback());
-			CountDown.init(mockDiv, { onRefreshData: callback });
-
+			const callback = jest.fn((cb) => cb());
+			CountDown.init(div, { onRefreshData: callback });
 			const initialCallCount = callback.mock.calls.length;
 
-			for (let i = 0; i < 167; i++) {
-				intervalCallback();
-			}
+			for (let i = 0; i < 167; i++) intervalCallback();
 			jest.advanceTimersByTime(100);
 
 			expect(callback.mock.calls.length).toBeGreaterThan(initialCallCount);
 		});
 
-		test('should handle rapid manual refreshes', () => {
-			const callback = jest.fn(); // ne complète pas
-			CountDown.init(mockDiv, { onRefreshData: callback });
-
+		test('should block rapid manual refreshes when already in progress', () => {
+			const callback = jest.fn(); // never completes
+			CountDown.init(div, { onRefreshData: callback });
 			const callCountAfterInit = callback.mock.calls.length;
 
-			// déjà en cours → bloqué
-			clickCallback.call(mockLink);
+			getLinkA().click();
+
 			expect(callback.mock.calls.length).toBe(callCountAfterInit);
 		});
 
 		test('should allow new refresh after previous completes', () => {
 			let completeCallback;
 			const callback = jest.fn((cb) => { completeCallback = cb; });
-			CountDown.init(mockDiv, { onRefreshData: callback });
+			CountDown.init(div, { onRefreshData: callback });
 
 			completeCallback();
 			const callCountAfterComplete = callback.mock.calls.length;
 
-			clickCallback.call(mockLink);
+			getLinkA().click();
 			expect(callback.mock.calls.length).toBe(callCountAfterComplete + 1);
 		});
 	});

package/tests/file.test.js

@@ -336,11 +336,7 @@ describe('Img', () => {
 			// Set global.Blob to our MockBlob so instanceof checks pass
 			global.Blob = MockBlob;
 
-			// Mock jQuery image element with length property (essential for jQuery objects)
-			mockImg = {
-				attr: jest.fn().mockReturnThis(),
-				length: 1  // Valid jQuery object has length > 0
-			};
+			mockImg = { src: '' };
 
 			// Mock URL.createObjectURL
 			mockURL = {
@@ -377,7 +373,7 @@ describe('Img', () => {
 
 			Img.setBlobToImg(mockImg, mockBlob);
 
-			expect(mockImg.attr).toHaveBeenCalledWith('src', 'blob:mock-url-12345');
+			expect(mockImg.src).toBe('blob:mock-url-12345');
 		});
 
 		test('should handle different blob types', () => {
@@ -386,7 +382,7 @@ describe('Img', () => {
 			Img.setBlobToImg(mockImg, mockBlob);
 
 			expect(mockURL.createObjectURL).toHaveBeenCalledWith(mockBlob);
-			expect(mockImg.attr).toHaveBeenCalledWith('src', 'blob:mock-url-12345');
+			expect(mockImg.src).toBe('blob:mock-url-12345');
 		});
 
 		test('should use webkitURL as fallback when URL is not available', () => {
@@ -404,7 +400,7 @@ describe('Img', () => {
 			Img.setBlobToImg(mockImg, mockBlob);
 
 			expect(mockWebkitURL.createObjectURL).toHaveBeenCalledWith(mockBlob);
-			expect(mockImg.attr).toHaveBeenCalledWith('src', 'blob:webkit-url-67890');
+			expect(mockImg.src).toBe('blob:webkit-url-67890');
 		});
 
 		test('should return early and log error when img is null', () => {
@@ -414,7 +410,6 @@ describe('Img', () => {
 
 			expect(consoleErrorSpy).toHaveBeenCalledWith('Invalid img element provided to setBlobToImg');
 			expect(mockURL.createObjectURL).not.toHaveBeenCalled();
-			expect(mockImg.attr).not.toHaveBeenCalled();
 		});
 
 		test('should return early and log error when img is undefined', () => {
@@ -426,26 +421,12 @@ describe('Img', () => {
 			expect(mockURL.createObjectURL).not.toHaveBeenCalled();
 		});
 
-		test('should return early and log error when img.length is 0 (empty jQuery)', () => {
-			const emptyJQuery = {
-				attr: jest.fn().mockReturnThis(),
-				length: 0  // Empty jQuery selector result
-			};
-			const mockBlob = new Blob(['test'], { type: 'image/png' });
-
-			Img.setBlobToImg(emptyJQuery, mockBlob);
-
-			expect(consoleErrorSpy).toHaveBeenCalledWith('Invalid img element provided to setBlobToImg');
-			expect(mockURL.createObjectURL).not.toHaveBeenCalled();
-			expect(emptyJQuery.attr).not.toHaveBeenCalled();
-		});
 
 		test('should return early and log error when blob is null', () => {
 			Img.setBlobToImg(mockImg, null);
 
 			expect(consoleErrorSpy).toHaveBeenCalledWith('Invalid blob provided to setBlobToImg', null);
 			expect(mockURL.createObjectURL).not.toHaveBeenCalled();
-			expect(mockImg.attr).not.toHaveBeenCalled();
 		});
 
 		test('should return early and log error when blob is undefined', () => {
@@ -471,21 +452,8 @@ describe('Img', () => {
 
 			expect(consoleErrorSpy).toHaveBeenCalledWith('Invalid blob provided to setBlobToImg', emptyBlob);
 			expect(mockURL.createObjectURL).not.toHaveBeenCalled();
-			expect(mockImg.attr).not.toHaveBeenCalled();
 		});
 
-		test('should work with valid jQuery-wrapped img element with length property', () => {
-			const validJQuery = {
-				attr: jest.fn().mockReturnThis(),
-				length: 1  // Valid jQuery object
-			};
-			const mockBlob = new Blob(['test'], { type: 'image/gif' });
-
-			Img.setBlobToImg(validJQuery, mockBlob);
-
-			expect(mockURL.createObjectURL).toHaveBeenCalledWith(mockBlob);
-			expect(validJQuery.attr).toHaveBeenCalledWith('src', 'blob:mock-url-12345');
-		});
 
 		test('should catch and log error when createObjectURL throws', () => {
 			mockURL.createObjectURL = jest.fn(() => {
@@ -504,17 +472,19 @@ describe('Img', () => {
 				'Error creating object URL from blob:',
 				expect.objectContaining({ message: 'Quota exceeded' })
 			);
-			expect(mockImg.attr).not.toHaveBeenCalled();
+			expect(mockImg.src).toBe('');
 		});
 
-		test('should catch and log error when img.attr throws', () => {
-			mockImg.attr = jest.fn(() => {
-				throw new Error('Invalid element');
+		test('should catch and log error when setting img.src throws', () => {
+			const throwingImg = {};
+			Object.defineProperty(throwingImg, 'src', {
+				set: () => { throw new Error('Invalid element'); },
+				get: () => '',
 			});
 
 			const mockBlob = new Blob(['test'], { type: 'image/png' });
 
-			Img.setBlobToImg(mockImg, mockBlob);
+			Img.setBlobToImg(throwingImg, mockBlob);
 
 			expect(consoleErrorSpy).toHaveBeenCalledWith(
 				'Error creating object URL from blob:',

package/util.js

@@ -14,4 +14,8 @@ function refresh() {
 	window.location.reload(true);
 }
 
-module.exports = { sleep, refresh };
+function toEl(el) {
+	return el && el.jquery ? el[0] : el;
+}
+
+module.exports = { sleep, refresh, toEl };