Reshaping the code for better testing

Author: avoidwork

dist/filesize.cjs

@@ -3,7 +3,7 @@
  *
  * @copyright 2025 Jason Mulligan <jason.mulligan@avoidwork.com>
  * @license BSD-3-Clause
- * @version 11.0.10
+ * @version 11.0.11
  */
 'use strict';
 
@@ -89,6 +89,13 @@ const DECIMAL_POWERS = [
 const LOG_2_1024 = Math.log(1024);
 const LOG_10_1000 = Math.log(1000);
 
+// Cached configuration lookup for better performance
+const STANDARD_CONFIGS = {
+	[SI]: { isDecimal: true, ceil: 1000, actualStandard: JEDEC },
+	[IEC]: { isDecimal: false, ceil: 1024, actualStandard: IEC },
+	[JEDEC]: { isDecimal: false, ceil: 1024, actualStandard: JEDEC }
+};
+
 /**
  * Converts a file size in bytes to a human-readable string with appropriate units
  * @param {number|string|bigint} arg - The file size in bytes to convert
@@ -140,29 +147,9 @@ function filesize (arg, {
 		val = 0,
 		u = EMPTY;
 
-	// Optimized base & standard synchronization with early returns
-	let isDecimal, ceil, actualStandard;
-	if (standard === SI) {
-		isDecimal = true;
-		ceil = 1000;
-		actualStandard = JEDEC;
-	} else if (standard === IEC) {
-		isDecimal = false;
-		ceil = 1024;
-		actualStandard = IEC;
-	} else if (standard === JEDEC) {
-		isDecimal = false; // JEDEC uses binary (1024) by default
-		ceil = 1024;
-		actualStandard = JEDEC;
-	} else if (base === 2) {
-		isDecimal = false;
-		ceil = 1024;
-		actualStandard = IEC;
-	} else {
-		isDecimal = true;
-		ceil = 1000;
-		actualStandard = JEDEC;
-	}
+	// Optimized base & standard configuration lookup
+	const config = getBaseConfiguration(standard, base);
+	const { isDecimal, ceil, actualStandard } = config;
 
 	const full = fullform === true,
 		neg = num < 0,
@@ -183,38 +170,12 @@ function filesize (arg, {
 
 	// Fast path for zero
 	if (num === 0) {
-		result[0] = precision > 0 ? (0).toPrecision(precision) : 0;
-		u = result[1] = STRINGS.symbol[actualStandard][bits ? BITS : BYTES][0];
-		
-		if (output === EXPONENT) {
-			return 0;
-		}
-		
-		// Skip most processing for zero case
-		if (symbols[result[1]]) {
-			result[1] = symbols[result[1]];
-		}
-		
-		if (full) {
-			result[1] = fullforms[0] || STRINGS.fullform[actualStandard][0] + (bits ? BIT : BYTE);
-		}
-		
-		return output === ARRAY ? result : output === OBJECT ? {
-			value: result[0],
-			symbol: result[1],
-			exponent: 0,
-			unit: u
-		} : result.join(spacer);
+		return handleZeroValue(precision, actualStandard, bits, symbols, full, fullforms, output, spacer);
 	}
 
 	// Optimized exponent calculation using pre-computed log values
 	if (e === -1 || isNaN(e)) {
-		if (isDecimal) {
-			e = Math.floor(Math.log(num) / LOG_10_1000);
-		} else {
-			e = Math.floor(Math.log(num) / LOG_2_1024);
-		}
-
+		e = isDecimal ? Math.floor(Math.log(num) / LOG_10_1000) : Math.floor(Math.log(num) / LOG_2_1024);
 		if (e < 0) {
 			e = 0;
 		}
@@ -232,24 +193,10 @@ function filesize (arg, {
 		return e;
 	}
 
-	// Use pre-computed lookup tables (e is always <= 8, arrays have 9 elements)
-	let d;
-	if (isDecimal) {
-		d = DECIMAL_POWERS[e];
-	} else {
-		d = BINARY_POWERS[e];
-	}
-	
-	val = num / d;
-
-	if (bits) {
-		val = val * 8;
-
-		if (val >= ceil && e < 8) {
-			val = val / ceil;
-			e++;
-		}
-	}
+	// Calculate value with optimized lookup and bits handling
+	const valueResult = calculateOptimizedValue(num, e, isDecimal, bits, ceil);
+	val = valueResult.val;
+	e = valueResult.e;
 
 	// Optimize rounding calculation
 	const p = e > 0 && round > 0 ? Math.pow(10, round) : 1;
@@ -260,21 +207,11 @@ function filesize (arg, {
 		e++;
 	}
 
-	// Setting optional precision
+	// Apply precision handling
 	if (precision > 0) {
-		result[0] = result[0].toPrecision(precision);
-
-		if (result[0].includes(E) && e < 8) {
-			e++;
-			// Recalculate with new exponent (e is always <= 8)
-			if (isDecimal) {
-				d = DECIMAL_POWERS[e];
-			} else {
-				d = BINARY_POWERS[e];
-			}
-			val = num / d;
-			result[0] = (p === 1 ? roundingFunc(val) : roundingFunc(val * p) / p).toPrecision(precision);
-		}
+		const precisionResult = applyPrecisionHandling(result[0], precision, e, num, isDecimal, bits, ceil, roundingFunc, round);
+		result[0] = precisionResult.value;
+		e = precisionResult.e;
 	}
 
 	// Cache symbol lookup
@@ -291,25 +228,8 @@ function filesize (arg, {
 		result[1] = symbols[result[1]];
 	}
 
-	// Optimized locale/separator handling
-	if (locale === true) {
-		result[0] = result[0].toLocaleString();
-	} else if (locale.length > 0) {
-		result[0] = result[0].toLocaleString(locale, localeOptions);
-	} else if (separator.length > 0) {
-		result[0] = result[0].toString().replace(PERIOD, separator);
-	}
-
-	if (pad && round > 0) {
-		const resultStr = result[0].toString(),
-			x = separator || ((resultStr.match(/(\D)/g) || []).pop() || PERIOD),
-			tmp = resultStr.split(x),
-			s = tmp[1] || EMPTY,
-			l = s.length,
-			n = round - l;
-
-		result[0] = `${tmp[0]}${x}${s.padEnd(l + n, ZERO)}`;
-	}
+	// Apply locale, separator, and padding formatting
+	result[0] = applyNumberFormatting(result[0], locale, localeOptions, separator, pad, round);
 
 	if (full) {
 		result[1] = fullforms[e] || STRINGS.fullform[actualStandard][e] + (bits ? BIT : BYTE) + (result[0] === 1 ? EMPTY : S);
@@ -319,7 +239,7 @@ function filesize (arg, {
 	if (output === ARRAY) {
 		return result;
 	}
-	
+
 	if (output === OBJECT) {
 		return {
 			value: result[0],
@@ -328,10 +248,160 @@ function filesize (arg, {
 			unit: u
 		};
 	}
-	
+
 	return spacer === SPACE ? `${result[0]} ${result[1]}` : result.join(spacer);
 }
 
+/**
+ * Optimized base configuration lookup
+ * @param {string} standard - Standard type
+ * @param {number} base - Base number
+ * @returns {Object} Configuration object
+ */
+function getBaseConfiguration(standard, base) {
+	// Use cached lookup table for better performance
+	if (STANDARD_CONFIGS[standard]) {
+		return STANDARD_CONFIGS[standard];
+	}
+
+	// Base override
+	if (base === 2) {
+		return { isDecimal: false, ceil: 1024, actualStandard: IEC };
+	}
+
+	// Default
+	return { isDecimal: true, ceil: 1000, actualStandard: JEDEC };
+}
+
+/**
+ * Optimized zero value handling
+ * @param {number} precision - Precision value
+ * @param {string} actualStandard - Standard to use
+ * @param {boolean} bits - Whether to use bits
+ * @param {Object} symbols - Custom symbols
+ * @param {boolean} full - Whether to use full form
+ * @param {Array} fullforms - Custom full forms
+ * @param {string} output - Output format
+ * @param {string} spacer - Spacer character
+ * @returns {string|Array|Object|number} Formatted result
+ */
+function handleZeroValue(precision, actualStandard, bits, symbols, full, fullforms, output, spacer) {
+	const result = [];
+	result[0] = precision > 0 ? (0).toPrecision(precision) : 0;
+	const u = result[1] = STRINGS.symbol[actualStandard][bits ? BITS : BYTES][0];
+
+	if (output === EXPONENT) {
+		return 0;
+	}
+
+	// Apply symbol customization
+	if (symbols[result[1]]) {
+		result[1] = symbols[result[1]];
+	}
+
+	// Apply full form
+	if (full) {
+		result[1] = fullforms[0] || STRINGS.fullform[actualStandard][0] + (bits ? BIT : BYTE);
+	}
+
+	// Return in requested format
+	return output === ARRAY ? result : output === OBJECT ? {
+		value: result[0],
+		symbol: result[1],
+		exponent: 0,
+		unit: u
+	} : result.join(spacer);
+}
+
+/**
+ * Optimized value calculation with bits handling
+ * @param {number} num - Input number
+ * @param {number} e - Exponent
+ * @param {boolean} isDecimal - Whether to use decimal powers
+ * @param {boolean} bits - Whether to calculate bits
+ * @param {number} ceil - Ceiling value for auto-increment
+ * @returns {Object} Object with val and e properties
+ */
+function calculateOptimizedValue(num, e, isDecimal, bits, ceil) {
+	const d = isDecimal ? DECIMAL_POWERS[e] : BINARY_POWERS[e];
+	let val = num / d;
+
+	if (bits) {
+		val *= 8;
+		// Handle auto-increment for bits
+		if (val >= ceil && e < 8) {
+			val /= ceil;
+			e++;
+		}
+	}
+
+	return { val, e };
+}
+
+/**
+ * Optimized precision handling with scientific notation correction
+ * @param {number} value - Current value
+ * @param {number} precision - Precision to apply
+ * @param {number} e - Current exponent
+ * @param {number} num - Original number
+ * @param {boolean} isDecimal - Whether using decimal base
+ * @param {boolean} bits - Whether calculating bits
+ * @param {number} ceil - Ceiling value
+ * @param {Function} roundingFunc - Rounding function
+ * @param {number} round - Round value
+ * @returns {Object} Object with value and e properties
+ */
+function applyPrecisionHandling(value, precision, e, num, isDecimal, bits, ceil, roundingFunc, round) {
+	let result = value.toPrecision(precision);
+
+	// Handle scientific notation by recalculating with incremented exponent
+	if (result.includes(E) && e < 8) {
+		e++;
+		const valueResult = calculateOptimizedValue(num, e, isDecimal, bits, ceil);
+		const p = round > 0 ? Math.pow(10, round) : 1;
+		result = (p === 1 ? roundingFunc(valueResult.val) : roundingFunc(valueResult.val * p) / p).toPrecision(precision);
+	}
+
+	return { value: result, e };
+}
+
+/**
+ * Optimized number formatting with locale, separator, and padding
+ * @param {number|string} value - Value to format
+ * @param {string|boolean} locale - Locale setting
+ * @param {Object} localeOptions - Locale options
+ * @param {string} separator - Custom separator
+ * @param {boolean} pad - Whether to pad
+ * @param {number} round - Round value
+ * @returns {string|number} Formatted value
+ */
+function applyNumberFormatting(value, locale, localeOptions, separator, pad, round) {
+	let result = value;
+
+	// Apply locale formatting
+	if (locale === true) {
+		result = result.toLocaleString();
+	} else if (locale.length > 0) {
+		result = result.toLocaleString(locale, localeOptions);
+	} else if (separator.length > 0) {
+		result = result.toString().replace(PERIOD, separator);
+	}
+
+	// Apply padding
+	if (pad && round > 0) {
+		const resultStr = result.toString();
+		const x = separator || ((resultStr.match(/(\D)/g) || []).pop() || PERIOD);
+		const tmp = resultStr.split(x);
+		const s = tmp[1] || EMPTY;
+		const l = s.length;
+		const n = round - l;
+
+		result = `${tmp[0]}${x}${s.padEnd(l + n, ZERO)}`;
+	}
+
+	return result;
+}
+
 /**
  * Creates a partially applied version of filesize with preset options
  * @param {Object} [options={}] - Default options to apply to the returned function
@@ -396,5 +466,10 @@ function partial ({
 	});
 }
 
+exports.applyNumberFormatting = applyNumberFormatting;
+exports.applyPrecisionHandling = applyPrecisionHandling;
+exports.calculateOptimizedValue = calculateOptimizedValue;
 exports.filesize = filesize;
+exports.getBaseConfiguration = getBaseConfiguration;
+exports.handleZeroValue = handleZeroValue;
 exports.partial = partial;