@osimatic/helpers-js 1.4.24 → 1.4.26

package/.claude/settings.local.json

@@ -6,7 +6,8 @@
       "Bash(npm run test:coverage:*)",
       "Bash(npm login)",
       "Bash(npm publish:*)",
-      "Bash(npm logout:*)"
+      "Bash(npm logout:*)",
+      "Bash(node -e:*)"
     ]
   }
 }

package/chartjs.js

@@ -298,7 +298,7 @@ class Chartjs {
 	}
 
 	static getAutoGranularity(data) {
-		const dates = Object.keys(data);
+		const dates = Object.keys(data).sort();
 		const days = (new Date(dates[dates.length - 1]) - new Date(dates[0])) / (1000 * 60 * 60 * 24);
 		if (days > 90) return 'month';
 		if (days > 30) return 'week';

package/date_time.js

@@ -206,9 +206,7 @@ class DateTime {
 	}
 
 	static getLastDayOfYear(date) {
-		date.setUTCDate(31);
-		date.setUTCMonth(11);
-		return new Date(date);
+		return new Date(Date.UTC(date.getUTCFullYear(), 11, 31));
 	}
 
 	static getFirstDayOfWeekAndYear(year, week) {
@@ -308,7 +306,7 @@ class DatePeriod {
 		return partOfDay === DatePeriod.PART_OF_DAY_MORNING || partOfDay === DatePeriod.PART_OF_DAY_AFTERNOON;
 	}
 
-	static getNbDayBetweenTwo(jsDate1, jsDate2, asPeriod=false, timeZone="Europe/Paris") {
+	static getNbDayBetweenTwo(jsDate1, jsDate2, considerTime=false, timeZone="Europe/Paris", returnDecimal=false) {
 		//jsDate1.set
 		if (jsDate1 == null || jsDate2 == null) {
 			return 0;
@@ -317,7 +315,7 @@ class DatePeriod {
 		let timestamp1 = jsDate1.getTime() / 1000;
 		let timestamp2 = jsDate2.getTime() / 1000;
 
-		if (!asPeriod) {
+		if (!considerTime) {
 			let jsMidnightDate1 = new Date(jsDate1.toLocaleDateString('en-US', {timeZone: timeZone})+' 00:00:00');
 			let jsMidnightDate2 = new Date(jsDate2.toLocaleDateString('en-US', {timeZone: timeZone})+' 00:00:00');
 			timestamp1 = jsMidnightDate1.getTime() / 1000;
@@ -327,7 +325,9 @@ class DatePeriod {
 			//jsDate1.setUTCHours(0, 0, 0);
 			//jsDate2.setUTCHours(0, 0, 0);
 		}
-		return parseInt(Math.round((timestamp2-timestamp1)/86400));
+
+		const daysDiff = (timestamp2-timestamp1)/86400;
+		return returnDecimal ? daysDiff : parseInt(Math.round(daysDiff));
 	}
 
 	static getPeriodLabels(data, period, locale = 'fr-FR', timeZone = 'Europe/Paris') {
@@ -392,23 +392,32 @@ class TimestampUnix {
 	}
 
 	static getYear(timestamp, timeZone="Europe/Paris") {
-		return this.parse(timestamp).toLocaleDateString('fr-FR', {year: 'numeric', timeZone: timeZone});
+		//const sqlDate = this.getSqlDate(timestamp, timeZone);
+		//return parseInt(sqlDate.substring(0, 4));
+		return parseInt(this.parse(timestamp).toLocaleDateString('fr-FR', {year: 'numeric', timeZone: timeZone}));
 	}
 	static getMonth(timestamp, timeZone="Europe/Paris") {
-		return this.parse(timestamp).toLocaleDateString('fr-FR', {month: 'numeric', timeZone: timeZone});
+		//const sqlDate = this.getSqlDate(timestamp, timeZone);
+		//return parseInt(sqlDate.substring(5, 7));
+		return parseInt(this.parse(timestamp).toLocaleDateString('fr-FR', {month: 'numeric', timeZone: timeZone}));
 	}
 	static getDayOfMonth(timestamp, timeZone="Europe/Paris") {
-		return this.parse(timestamp).toLocaleDateString('fr-FR', {day: 'numeric', timeZone: timeZone});
+		//const sqlDate = this.getSqlDate(timestamp, timeZone);
+		//return parseInt(sqlDate.substring(8, 10));
+		return parseInt(this.parse(timestamp).toLocaleDateString('fr-FR', {day: 'numeric', timeZone: timeZone}));
 	}
 
 	static getHour(timestamp, timeZone="Europe/Paris") {
-		return this.parse(timestamp).toLocaleTimeString('en-GB', {hour: 'numeric', timeZone: timeZone});
+		const sqlTime = this.getSqlTime(timestamp, timeZone);
+		return parseInt(sqlTime.substring(0, 2));
 	}
 	static getMinute(timestamp, timeZone="Europe/Paris") {
-		return this.parse(timestamp).toLocaleTimeString('en-GB', {minute: 'numeric', timeZone: timeZone});
+		const sqlTime = this.getSqlTime(timestamp, timeZone);
+		return parseInt(sqlTime.substring(3, 5));
 	}
 	static getSecond(timestamp, timeZone="Europe/Paris") {
-		return this.parse(timestamp).toLocaleTimeString('en-GB', {second: 'numeric', timeZone: timeZone});
+		const sqlTime = this.getSqlTime(timestamp, timeZone);
+		return parseInt(sqlTime.substring(6, 8));
 	}
 
 	static getSqlDateTime(timestamp, timeZone="Europe/Paris") {
@@ -556,18 +565,18 @@ class SqlDateTime {
 		return DateTime.getSqlDateTime(new Date());
 	}
 
-	static getSqlDate(sqlDateTime) {
+	static getSqlDate(sqlDateTime, timeZone="UTC") {
 		if (sqlDateTime == null) {
 			return null;
 		}
-		return DateTime.getSqlDate(this.parse(sqlDateTime));
+		return DateTime.getSqlDate(this.parse(sqlDateTime), timeZone);
 	}
 
-	static getSqlTime(sqlDateTime) {
+	static getSqlTime(sqlDateTime, timeZone="UTC") {
 		if (sqlDateTime == null) {
 			return null;
 		}
-		return DateTime.getSqlTime(this.parse(sqlDateTime));
+		return DateTime.getSqlTime(this.parse(sqlDateTime), timeZone);
 	}
 
 	static parse(sqlDateTime) {

package/draw.js

@@ -1,6 +1,7 @@
 class HexColor {
 	static check(hexColor) {
-		return hexColor.match(/^[0-9a-fA-F]{6}$/).length;
+		const match = hexColor.match(/^[0-9a-fA-F]{6}$/);
+		return match ? match.length > 0 : false;
 	}
 
 	static convertToRgb(hexColor) {
@@ -9,7 +10,7 @@ class HexColor {
 		}
 
 		if (hexColor.length === 3) {
-			hexColor = hexColor+hexColor;
+			hexColor = hexColor[0]+hexColor[0]+hexColor[1]+hexColor[1]+hexColor[2]+hexColor[2];
 		}
 
 		if (!HexColor.check(hexColor)) {

package/duration.js

@@ -1,199 +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;
+
+		hours = hours.toString().length < 2 ? '0' + hours : hours;
+		minutes = minutes.toString().length < 2 ? '0' + minutes : minutes;
 
-		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;
+		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 += ' ';
-			//strMinute += sprintf('%02d', nbMinutes);
-			strMinute += nbMinutes.toString().padStart(2, '0');
-			if (withMinuteLabel) {
-				if (fullLabel) {
-					strMinute += ' minute'+(nbMinutes>1?'s':'');
-				}
-				else {
-					strMinute += 'min';
-				}
+			let nbMinutes = this.remainingMinutes(seconds);
+			strMinutes += ' ';
+			if (fullLabel) {
+				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 += ' ';
-			//strSeconde += sprintf('%02d', nbSecondes);
-			strSeconde += nbSecondes.toString().padStart(2, '0');
+			let nbSeconds = this.remainingSeconds(seconds);
+			strSeconds += ' ';
 			if (fullLabel) {
-				strSeconde += ' seconde'+(nbSecondes>1?'s':'');
-			}
-			else {
-				strSeconde += '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) {
-		return Math.floor(Math.getDecimals(Number.roundDecimal(durationAsHundredthOfAnHour, 2)) / 100 * 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/event_bus.js

@@ -30,9 +30,9 @@ class EventBus {
 
         if (!!handlers === false) {
             return;
-        } 
+        }
 
-		handlers.splice(handlers.indexOf(handler));
+		handlers.splice(handlers.indexOf(handler), 1);
     }
 }
 

package/file.js

@@ -52,7 +52,7 @@ class File {
 			fileSizeInBytes = fileSizeInBytes / 1024;
 			i++;
 		}
-		while (fileSizeInBytes > 1024);
+		while (fileSizeInBytes >= 1024);
 		//var size = Math.max(fileSizeInBytes, 0.1).toFixed(fractionDigits);
 		let size = Math.max(fileSizeInBytes, 0.1);
 		return (new Intl.NumberFormat(locale, {
@@ -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/form_helper.js

@@ -294,7 +294,7 @@ class FormHelper {
 			if (typeof errors[property] == 'function') {
 				continue;
 			}
-			if (typeof errors[property]['error_description'] !== 'undefined') {
+			if (errors[property] != null && typeof errors[property]['error_description'] !== 'undefined') {
 				errorLabels.push(errors[property]['error_description']);
 				continue;
 			}

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/http_client.js

@@ -1,3 +1,5 @@
+const { JwtSession } = require('./jwt');
+const { UrlAndQueryString } = require('./network');
 
 class HTTPClient {
 	static setAuthorizationToken(authorizationToken) {