@osimatic/helpers-js 1.4.25 → 1.4.26

package/.claude/settings.local.json

@@ -7,7 +7,7 @@
       "Bash(npm login)",
       "Bash(npm publish:*)",
       "Bash(npm logout:*)",
-      "Bash(node -e:*)",
+      "Bash(node -e:*)"
     ]
   }
 }

package/duration.js

@@ -1,196 +1,245 @@
 
 class Duration {
 
-	// ---------- Nb jours ----------
+	// -------------------------------------------------------------------------
+	// Days formatting
+	// -------------------------------------------------------------------------
 
-	static formatNbDays(nbDays, locale='fr-FR') {
+	static formatDays(days, locale = 'fr-FR') {
 		return new Intl.NumberFormat(locale, {
 			minimumFractionDigits: 2,
 			maximumFractionDigits: 2
-		}).format(nbDays);
+		}).format(days);
 	}
-	static formatNbDaysIfPositive(nbDays) {
-		return nbDays < 0 ? '-' : this.formatNbDays(nbDays);
+
+	static formatDaysIfPositive(days) {
+		return days < 0 ? '-' : this.formatDays(days);
 	}
-	static formatNbDaysWithColor(nbDays) {
-		return '<span class="text-'+(nbDays<0?'danger':'success')+'">'+this.formatNbDays(nbDays)+'</span>';
+
+	static formatDaysWithColor(days) {
+		return '<span class="text-' + (days < 0 ? 'danger' : 'success') + '">' + this.formatDays(days) + '</span>';
 	}
 
-	// ---------- Durée en seconde ----------
+	// -------------------------------------------------------------------------
+	// Seconds — conversion
+	// -------------------------------------------------------------------------
 
-	static convertInputTimeValueToDuration(inputTimeValue) {
-		if (null === inputTimeValue || -1 === inputTimeValue.indexOf(':')) {
+	static parseTimeInputToSeconds(timeInput) {
+		if (null === timeInput || -1 === timeInput.indexOf(':')) {
 			return 0;
 		}
-		let arrayTime = inputTimeValue.split(':');
-		const nbHours = typeof arrayTime[0] != 'undefined' ? parseInt(arrayTime[0]) || 0 : 0;
+		let arrayTime = timeInput.split(':');
+		const nbHours   = typeof arrayTime[0] != 'undefined' ? parseInt(arrayTime[0]) || 0 : 0;
 		const nbMinutes = typeof arrayTime[1] != 'undefined' ? parseInt(arrayTime[1]) || 0 : 0;
 		const nbSeconds = typeof arrayTime[2] != 'undefined' ? parseInt(arrayTime[2]) || 0 : 0;
 		return nbHours * 3600 + nbMinutes * 60 + nbSeconds;
 	}
 
-	static convertToDurationAsInputTimeValue(durationInSeconds) {
-		return Duration.convertToDurationInHourChronoDisplay(Math.abs(durationInSeconds), 'input_time');
+	// -------------------------------------------------------------------------
+	// Seconds — formatting
+	// -------------------------------------------------------------------------
+
+	static formatSecondsAsTimeInput(seconds) {
+		return Duration.formatSecondsAsChrono(Math.abs(seconds), 'input_time');
 	}
 
-	static convertToDurationInHourChronoDisplay(durationInSeconds, displayMode='chrono') {
-		durationInSeconds = Math.round(durationInSeconds);
+	static formatSecondsAsChrono(seconds, displayMode = 'chrono', withSeconds = true) {
+		seconds = Math.round(seconds);
+		const absoluteSeconds = Math.abs(seconds);
+
+		let secs = absoluteSeconds % 60;
+		let remainder = (absoluteSeconds % 3600) - secs;
+		let minutes = remainder / 60;
+		remainder = absoluteSeconds - (absoluteSeconds % 3600);
+		let hours = remainder / 3600;
 
-		let durationInSecondsOriginal = durationInSeconds;
-		durationInSeconds = Math.abs(durationInSeconds);
-		let seconds = ( durationInSeconds % 60 );
-		let remander = ( durationInSeconds % 3600 ) - seconds;
-		let minutes = ( remander / 60 );
-		remander = ( durationInSeconds ) - ( durationInSeconds % 3600 );
-		let hours = ( remander / 3600 );
-		if(hours.toString().length < 2) hours = '0'+hours;
-		if(hours.toString().charAt(0) === "-") hours[0] = '0';
-		if(minutes.toString().length < 2) minutes = '0'+minutes;
-		if(minutes.toString().charAt(0) === "-") minutes[0] = '0';
-		if(seconds.toString().length < 2) seconds = '0'+seconds;
-		return (durationInSecondsOriginal < 0 ? '- ' : '')+hours+':'+minutes+(displayMode==='input_time'?':':'.')+seconds;
+		hours = hours.toString().length < 2 ? '0' + hours : hours;
+		minutes = minutes.toString().length < 2 ? '0' + minutes : minutes;
+
+		let result = (seconds < 0 ? '- ' : '') + hours + ':' + minutes;
+		if (withSeconds) {
+			secs = secs.toString().length < 2 ? '0' + secs : secs;
+			result += (displayMode === 'input_time' ? ':' : '.') + secs;
+		}
+		return result;
 	}
 
-	static convertToDurationInHourStringDisplay(durationInSeconds, withSeconds=true, withMinutes=true, withMinuteLabel=true, fullLabel=false, hideHourIfZeroHour=false) {
-		durationInSeconds = Math.round(durationInSeconds);
+	static formatSecondsAsString(seconds, withSeconds = true, withMinutes = true, withMinuteLabel = true, fullLabel = false, hideHourIfZero = false) {
+		seconds = Math.round(seconds);
 
-		// Heures
-		let strHeure = '';
-		let nbHeures = this.getNbHoursOfDurationInSeconds(durationInSeconds);
-		if (!hideHourIfZeroHour || nbHeures > 0) {
-			strHeure += nbHeures;
+		// Hours
+		let strHours = '';
+		let nbHours = this.totalHours(seconds);
+		if (!hideHourIfZero || nbHours > 0) {
+			strHours += nbHours;
 			if (fullLabel) {
-				strHeure += ' heure'+(nbHeures>1?'s':'');
-			}
-			else {
-				strHeure += 'h';
+				strHours += ' heure' + (nbHours > 1 ? 's' : '');
+			} else {
+				strHours += 'h';
 			}
 		}
-		
+
 		// Minutes
-		let strMinute = '';
+		let strMinutes = '';
 		if (withMinutes) {
-			let nbMinutes = this.getNbMinutesRemainingOfDurationInSeconds(durationInSeconds);
-			strMinute += ' ';
+			let nbMinutes = this.remainingMinutes(seconds);
+			strMinutes += ' ';
 			if (fullLabel) {
-				strMinute += nbMinutes.toString()+(withMinuteLabel ? ' minute'+(nbMinutes>1?'s':'') : '');
-			}
-			else {
-				strMinute += nbMinutes.toString().padStart(2, '0')+(withMinuteLabel ? 'min' : '');
+				strMinutes += nbMinutes.toString() + (withMinuteLabel ? ' minute' + (nbMinutes > 1 ? 's' : '') : '');
+			} else {
+				strMinutes += nbMinutes.toString().padStart(2, '0') + (withMinuteLabel ? 'min' : '');
 			}
 		}
 
-		// Secondes
-		let strSeconde = '';
+		// Seconds
+		let strSeconds = '';
 		if (withSeconds) {
-			let nbSecondes = this.getNbSecondsRemainingOfDurationInSeconds(durationInSeconds);
-			strSeconde += ' ';
+			let nbSeconds = this.remainingSeconds(seconds);
+			strSeconds += ' ';
 			if (fullLabel) {
-				strSeconde += nbSecondes.toString()+' seconde'+(nbSecondes>1?'s':'');
-			}
-			else {
-				strSeconde += nbSecondes.toString().padStart(2, '0')+'s';
+				strSeconds += nbSeconds.toString() + ' seconde' + (nbSeconds > 1 ? 's' : '');
+			} else {
+				strSeconds += nbSeconds.toString().padStart(2, '0') + 's';
 			}
 		}
-		
-		return (strHeure+strMinute+strSeconde).trim();
+
+		return (strHours + strMinutes + strSeconds).trim();
 	}
 
-	static roundNbSeconds(durationInSeconds, roundPrecision, roundMode='close') {
-		let hours = Math.floor(durationInSeconds / 3600);
-		let minutes = Math.floor((durationInSeconds % 3600) / 60);
-		let seconds = durationInSeconds % 60;
+	// -------------------------------------------------------------------------
+	// Seconds — rounding
+	// -------------------------------------------------------------------------
 
-		let hoursRounded = hours;
-		let minutesRounded = minutes;
-		let secondsRounded = seconds;
+	static roundSeconds(seconds, precision, roundMode = 'close') {
+		let hours   = Math.floor(seconds / 3600);
+		let minutes = Math.floor((seconds % 3600) / 60);
+		let secs    = seconds % 60;
 
-		if (roundPrecision > 0) {
-			let minutesRemaining = minutes % roundPrecision;
-			let minutesRemainingAndSecondsAsCentieme = minutesRemaining + seconds/60;
-			if (minutesRemainingAndSecondsAsCentieme === 0) {
-				// pas d'arrondissement
-			}
-			else {
-				let halfRoundPrecision = roundPrecision / 2;
-				hoursRounded = hours;
+		let hoursRounded   = hours;
+		let minutesRounded = minutes;
+		let secondsRounded = secs;
+
+		if (precision > 0) {
+			let minutesRemaining = minutes % precision;
+			let minutesRemainingAndSecondsAsFraction = minutesRemaining + secs / 60;
+			if (minutesRemainingAndSecondsAsFraction === 0) {
+				// already aligned, no rounding needed
+			} else {
+				let halfPrecision = precision / 2;
+				hoursRounded   = hours;
 				secondsRounded = 0;
-				if (roundMode === 'up' || (roundMode === 'close' && minutesRemainingAndSecondsAsCentieme > halfRoundPrecision)) {
-					// Arrondissement au dessus
-					if (minutes > (60-roundPrecision)) {
+				if (roundMode === 'up' || (roundMode === 'close' && minutesRemainingAndSecondsAsFraction > halfPrecision)) {
+					// Round up
+					if (minutes > (60 - precision)) {
 						minutesRounded = 0;
 						hoursRounded++;
+					} else {
+						minutesRounded = (minutes - minutesRemaining) + precision;
 					}
-					else {
-						minutesRounded = (minutes-minutesRemaining)+roundPrecision;
-					}
-				}
-				else {
-					// Arrondissement au dessous
-					minutesRounded = (minutes-minutesRemaining);
+				} else {
+					// Round down
+					minutesRounded = minutes - minutesRemaining;
 				}
 			}
 		}
-		// console.log(element.data('duration_default'), durationInSeconds, hours, minutes, seconds, '->', secondsTotalRounded, hoursRounded, minutesRounded, secondsRounded);
+
 		return hoursRounded * 3600 + minutesRounded * 60 + secondsRounded;
 	}
 
-	static getNbDaysOfDurationInSeconds(durationInSeconds) {
-		return Math.floor(durationInSeconds / 86400);
-	}
-	static getNbHoursOfDurationInSeconds(durationInSeconds) {
-		return Math.floor(durationInSeconds / 3600);
-	}
-	static getNbMinutesOfDurationInSeconds(durationInSeconds) {
-		return Math.floor(durationInSeconds / 60);
+	// -------------------------------------------------------------------------
+	// Seconds — total extraction
+	// -------------------------------------------------------------------------
+
+	static totalDays(seconds) {
+		return Math.floor(seconds / 86400);
 	}
 
-	/*static getNbMinutesRemaining(durationInSeconds) {
-		var remander = ( durationInSeconds % 3600 ) - ( durationInSeconds % 60 );
-		return ( remander / 60 );
+	static totalHours(seconds) {
+		return Math.floor(seconds / 3600);
 	}
-	static getNbHoursOfDurationInSeconds(durationInSeconds) {
-		// return (this.getNbDaysOfDurationInSeconds(durationInSeconds)*24)+this.getNbHoursRemainingOfDurationInSeconds(durationInSeconds);
-		return (durationInSeconds - (durationInSeconds % 3600)) / 3600;
+
+	static totalMinutes(seconds) {
+		return Math.floor(seconds / 60);
 	}
-	static getNbMinutesOfDurationInSeconds(durationInSeconds) {
-		// return (this.getNbDaysOfDurationInSeconds(durationInSeconds)*24*60)+(this.getNbHoursRemainingOfDurationInSeconds(durationInSeconds)*60)+this.getNbMinutesRemainingOfDurationInSeconds(durationInSeconds);
-		return (durationInSeconds - (durationInSeconds % 60)) / 60;
-	}*/
 
-	static getNbHoursRemainingOfDurationInSeconds(durationInSeconds) {
-		return this.getNbHoursOfDurationInSeconds(durationInSeconds % 86400);
+	// -------------------------------------------------------------------------
+	// Seconds — remaining extraction
+	// -------------------------------------------------------------------------
+
+	static remainingHours(seconds) {
+		return this.totalHours(seconds % 86400);
 	}
-	static getNbMinutesRemainingOfDurationInSeconds(durationInSeconds) {
-		return this.getNbMinutesOfDurationInSeconds(durationInSeconds % 3600);
+
+	static remainingMinutes(seconds) {
+		return this.totalMinutes(seconds % 3600);
 	}
-	static getNbSecondsRemainingOfDurationInSeconds(durationInSeconds) {
-		return durationInSeconds % 60;
+
+	static remainingSeconds(seconds) {
+		return seconds % 60;
 	}
 
-	// ---------- Durée en centième d'heure ----------
+	// -------------------------------------------------------------------------
+	// Decimal hours (hundredth of an hour)
+	// -------------------------------------------------------------------------
 
-	static convertToDurationAsHundredthOfAnHour(durationInSeconds) {
-		let hour = Math.floor(durationInSeconds / 3600);
-		let minutes = durationInSeconds % 3600;
-		minutes = Math.floor(minutes / 60);
-		// minutes = minutes - (minutes % 60);
-		let minCentieme = Math.round( (minutes / 60 ) * 100 );
-		return hour+(minCentieme/100);
-		//return parseFloat(hour+'.'+minCentieme);
+	static toDecimalHours(seconds) {
+		let hour    = Math.floor(seconds / 3600);
+		let minutes = Math.floor((seconds % 3600) / 60);
+		let centieme = Math.round((minutes / 60) * 100);
+		return hour + (centieme / 100);
 	}
 
-	static getNbHoursOfHundredthOfAnHour(durationAsHundredthOfAnHour) {
-		return Math.trunc(durationAsHundredthOfAnHour);
+	static getHoursFromDecimal(decimalHours) {
+		return Math.trunc(decimalHours);
 	}
 
-	static getNbMinutesOfHundredthOfAnHour(durationAsHundredthOfAnHour) {
-		// Extraire la partie décimale et convertir en minutes
-		// Ex: 1.5h -> 0.5 * 60 = 30 minutes
-		const decimalPart = durationAsHundredthOfAnHour - Math.floor(durationAsHundredthOfAnHour);
-		return Math.floor(decimalPart * 60);
+	static getMinutesFromDecimal(decimalHours) {
+		const decimal = decimalHours - Math.floor(decimalHours);
+		return Math.floor(decimal * 60);
 	}
 
+	// -------------------------------------------------------------------------
+	// Deprecated aliases — kept for backwards compatibility
+	// -------------------------------------------------------------------------
+
+	/** @deprecated Use {@link formatDays} instead */
+	static formatNbDays(nbDays, locale = 'fr-FR') { return this.formatDays(nbDays, locale); }
+	/** @deprecated Use {@link formatDaysIfPositive} instead */
+	static formatNbDaysIfPositive(nbDays) { return this.formatDaysIfPositive(nbDays); }
+	/** @deprecated Use {@link formatDaysWithColor} instead */
+	static formatNbDaysWithColor(nbDays) { return this.formatDaysWithColor(nbDays); }
+
+	/** @deprecated Use {@link parseTimeInputToSeconds} instead */
+	static convertInputTimeValueToDuration(inputTimeValue) { return this.parseTimeInputToSeconds(inputTimeValue); }
+	/** @deprecated Use {@link formatSecondsAsTimeInput} instead */
+	static convertToDurationAsInputTimeValue(durationInSeconds) { return this.formatSecondsAsTimeInput(durationInSeconds); }
+	/** @deprecated Use {@link formatSecondsAsChrono} instead */
+	static convertToDurationInHourChronoDisplay(durationInSeconds, displayMode = 'chrono') { return this.formatSecondsAsChrono(durationInSeconds, displayMode); }
+	/** @deprecated Use {@link formatSecondsAsString} instead */
+	static convertToDurationInHourStringDisplay(durationInSeconds, withSeconds = true, withMinutes = true, withMinuteLabel = true, fullLabel = false, hideHourIfZeroHour = false) { return this.formatSecondsAsString(durationInSeconds, withSeconds, withMinutes, withMinuteLabel, fullLabel, hideHourIfZeroHour); }
+	/** @deprecated Use {@link roundSeconds} instead */
+	static roundNbSeconds(durationInSeconds, roundPrecision, roundMode = 'close') { return this.roundSeconds(durationInSeconds, roundPrecision, roundMode); }
+
+	/** @deprecated Use {@link totalDays} instead */
+	static getNbDaysOfDurationInSeconds(durationInSeconds) { return this.totalDays(durationInSeconds); }
+	/** @deprecated Use {@link totalHours} instead */
+	static getNbHoursOfDurationInSeconds(durationInSeconds) { return this.totalHours(durationInSeconds); }
+	/** @deprecated Use {@link totalMinutes} instead */
+	static getNbMinutesOfDurationInSeconds(durationInSeconds) { return this.totalMinutes(durationInSeconds); }
+
+	/** @deprecated Use {@link remainingHours} instead */
+	static getNbHoursRemainingOfDurationInSeconds(durationInSeconds) { return this.remainingHours(durationInSeconds); }
+	/** @deprecated Use {@link remainingMinutes} instead */
+	static getNbMinutesRemainingOfDurationInSeconds(durationInSeconds) { return this.remainingMinutes(durationInSeconds); }
+	/** @deprecated Use {@link remainingSeconds} instead */
+	static getNbSecondsRemainingOfDurationInSeconds(durationInSeconds) { return this.remainingSeconds(durationInSeconds); }
+
+	/** @deprecated Use {@link toDecimalHours} instead */
+	static convertToDurationAsHundredthOfAnHour(durationInSeconds) { return this.toDecimalHours(durationInSeconds); }
+	/** @deprecated Use {@link getHoursFromDecimal} instead */
+	static getNbHoursOfHundredthOfAnHour(durationAsHundredthOfAnHour) { return this.getHoursFromDecimal(durationAsHundredthOfAnHour); }
+	/** @deprecated Use {@link getMinutesFromDecimal} instead */
+	static getNbMinutesOfHundredthOfAnHour(durationAsHundredthOfAnHour) { return this.getMinutesFromDecimal(durationAsHundredthOfAnHour); }
 
 }
 

package/file.js

@@ -124,10 +124,25 @@ class Img {
 	}
 
 	static setBlobToImg(img, blob) {
-		// img.attr('src', btoa(unescape(encodeURIComponent(data))));
-		// img.attr('src', 'data:image/png;base64, '+btoa(unescape(encodeURIComponent(data))));
-		let urlCreator = window.URL || window.webkitURL;
-		img.attr('src', urlCreator.createObjectURL(blob));
+		// Validation de l'élément img
+		if (!img || !img.length) {
+			console.error('Invalid img element provided to setBlobToImg');
+			return;
+		}
+
+		// Validation du blob
+		if (!blob || !(blob instanceof Blob) || blob.size === 0) {
+			console.error('Invalid blob provided to setBlobToImg', blob);
+			return;
+		}
+
+		try {
+			let urlCreator = window.URL || window.webkitURL;
+			let objectURL = urlCreator.createObjectURL(blob);
+			img.attr('src', objectURL);
+		} catch (error) {
+			console.error('Error creating object URL from blob:', error);
+		}
 	}
 
 	static async getBase64FromUrl(url) {

package/google_charts.js

@@ -77,6 +77,7 @@ class GoogleCharts {
 		}
 
 		let data = null;
+		let nbCells = 0;
 		if (typeGraph === 'pie_chart') {
 			//data = google.visualization.arrayToDataTable(tabDataAbsParam);
 
@@ -101,7 +102,7 @@ class GoogleCharts {
 			});
 
 			// Remplissage des données
-			let nbCells = 0;
+			nbCells = 0;
 			let numRow = 0;
 			$.each(tabDataAbsParam, function(idx, dataAbs) {
 				// dataOrd = tabDataOrd[idx];

package/location.js

@@ -629,7 +629,11 @@ class GeographicCoordinates {
 	}
 
 	static formatPoint(geoJsonPoint, fractionDigit=6) {
-		const [lat, long] = GeographicCoordinates.parseFromGeoJson(geoJsonPoint);
+		const coords = GeographicCoordinates.parseFromGeoJson(geoJsonPoint);
+		if (coords == null) {
+			return '';
+		}
+		const [lat, long] = coords;
 		if (typeof long == 'undefined' || typeof lat == 'undefined') {
 			return '';
 		}

package/media.js

@@ -152,12 +152,12 @@ class UserMedia {
 			return;
 		}*/
 
-		return new Promise((resolve, reject) => {	
+		return new Promise((resolve, reject) => {
 			const bowser = require('bowser');
 			const browser = bowser.getParser(window.navigator.userAgent);
 			const browserName = browser.getBrowserName();
 
-			navigator.mediaDevices.getUserMedia(constraints !== 'undefined' ? constraints : { audio: true, video: true })
+			navigator.mediaDevices.getUserMedia(typeof constraints !== 'undefined' ? constraints : { audio: true, video: true })
 			.then((stream) => resolve(stream))
 			.catch((error) => {
 				const errName = error.name;
@@ -203,15 +203,15 @@ class UserMedia {
 	}
 
 	static requestAudioPermissions(audioConstraints) {
-		return this.requestMediaPermissions({ audio: (audioConstraints !== 'undefined' ? audioConstraints : true), video: false });
+		return this.requestMediaPermissions({ audio: (typeof audioConstraints !== 'undefined' ? audioConstraints : true), video: false });
 	}
-	
+
 	static requestVideoPermissions(audioConstraints, videoConstraints) {
-		return this.requestMediaPermissions({ audio: (audioConstraints !== 'undefined' ? audioConstraints : true), video: (videoConstraints !== 'undefined' ? videoConstraints : true )});
+		return this.requestMediaPermissions({ audio: (typeof audioConstraints !== 'undefined' ? audioConstraints : true), video: (typeof videoConstraints !== 'undefined' ? videoConstraints : true )});
 	}
 
 	static requestMutedVideoPermissions(videoConstraints) {
-		return this.requestMediaPermissions({ audio: false, video: (videoConstraints !== 'undefined' ? videoConstraints : true )});
+		return this.requestMediaPermissions({ audio: false, video: (typeof videoConstraints !== 'undefined' ? videoConstraints : true )});
 	}
 }
 

package/multi_files_input.js

@@ -1,3 +1,5 @@
+const { Str } = require('./string');
+
 class MultiFilesInput {
 	static init(fileInput, setFilesList, nbMaxFiles, maxFileSize) {
 		let filesList = [];
@@ -72,7 +74,7 @@ class MultiFilesInput {
 			const wrap = $(`
 				<div class="border rounded p-2 d-inline-flex align-items-center" data-file-id="${id}" style="background:white;">
 					<div class="me-2 preview-thumb" style="width:64px; height:48px; display:flex; align-items:center; justify-content:center; overflow:hidden;"></div>
-					<div class="small text-truncate" style="max-width:160px;">${file.name}</div>
+					<div class="small text-truncate" style="max-width:160px;">${(file.name || '').escapeHtml()}</div>
 					<button type="button" class="btn-close btn-close-small ms-2" aria-label="Supprimer" style="margin-left:8px;"></button>
 				</div>
 			`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@osimatic/helpers-js",
-  "version": "1.4.25",
+  "version": "1.4.26",
   "main": "main.js",
   "scripts": {
     "test": "jest",
@@ -17,6 +17,7 @@
   },
   "devDependencies": {
     "jest": "^30.2.0",
+    "jest-environment-jsdom": "^30.2.0",
     "whatwg-fetch": "^3.6.20"
   },
   "jest": {

package/paging.js

@@ -32,7 +32,7 @@ class Pagination {
 
 			maxItems = parseInt(select.val());
 
-			select.change(update);
+			select.change(() => Pagination.paginate(div, items, nbItemsPerPage, select, doublePagination));
 		}
 
 		const ulPagination = $('ul.pagination');
@@ -151,7 +151,7 @@ class Navigation {
 			window.history.replaceState('', document.title, url);
 		}
 		else {
-			window.history.pushState("", "", newUrl);
+			window.history.pushState("", "", url);
 		}
 	}
 }

package/tests/__mocks__/socket.io-client.js

@@ -0,0 +1,13 @@
+// Mock for socket.io-client
+const mockSocket = {
+	on: jest.fn(),
+	emit: jest.fn(),
+	connected: false
+};
+
+const io = jest.fn(() => mockSocket);
+
+module.exports = {
+	io,
+	__mockSocket: mockSocket
+};