⚡️ Speed up function msToTimeUnit by 27%

[codeflash-ai]

📄 27% (0.27x) speedup for msToTimeUnit in apps/meteor/client/lib/convertTimeUnit.ts

⏱️ Runtime : 21.4 milliseconds → 16.8 milliseconds (best of 11 runs)

📝 Explanation and details

This optimization achieves a 27% runtime improvement (21.4ms → 16.8ms) through two key changes:

Primary Optimization: Pre-calculated Constants

The original code performed multiple chained divisions on each function call:

• timespan / 24 / 60 / 60 / 1000 (4 division operations for days)
• timespan / 60 / 60 / 1000 (3 division operations for hours)
• timespan / 60 / 1000 (2 division operations for minutes)

The optimized version pre-calculates these constants:

• MS_PER_DAY = 86400000
• MS_PER_HOUR = 3600000
• MS_PER_MINUTE = 60000

This reduces each conversion to a single division operation. In JavaScript/TypeScript, multiple arithmetic operations are more expensive than one operation with a constant due to:

1. Reduced instruction count: 4 divisions become 1 division
2. Better CPU optimization: Single division by a literal constant can be optimized by the JIT compiler
3. Fewer intermediate value allocations: No temporary results from chained operations

Secondary Optimization: Simplified Validation

The isValidTimespan function combines checks more efficiently:

• Original: Separate isNaN() and isFinite() checks (2 function calls)
• Optimized: Single isFinite() check catches both NaN and Infinity (1 function call)

Since Number.isFinite() returns false for NaN values, the explicit NaN check is redundant.

Performance Impact by Test Case

The optimization delivers consistent improvements across all scenarios:

• Basic conversions: 15-38% faster (sub-microsecond gains add up in hot paths)
• Batch operations: 28-30% faster on 450-500 iteration loops
• Edge cases: 30-37% faster on small/large values and invalid units

Real-World Impact

Based on function_references, this function is called in useEditRoomInitialValues.ts within a React useMemo hook that processes room retention policy settings. While not in a tight loop, the function is invoked during UI rendering/updates where every millisecond counts for perceived responsiveness. The 27% improvement means faster room info panel initialization, especially beneficial when multiple rooms are being processed or when retention policies are frequently accessed.

The optimization maintains 100% functional equivalence - all test cases pass with identical results, just faster execution.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 16 Passed
🌀 Generated Regression Tests	✅ 1497 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

⚙️ Click to see Existing Unit Tests

🌀 Click to see Generated Regression Tests

// @ts-nocheck
import { jest, describe, it, expect, beforeEach, afterEach, beforeAll, test } from '@jest/globals'
// Use Jest (globals available) - do NOT import from 'vitest'
// function import (MUST match exactly as provided)
import { msToTimeUnit } from '../../client/lib/convertTimeUnit';

// Test suite for msToTimeUnit
describe('msToTimeUnit', () => {
    // Ensure the function has access to a TIMEUNIT enum-like object that matches what the implementation expects.
    // The implementation references TIMEUNIT.days / TIMEUNIT.hours / TIMEUNIT.minutes when executed,
    // so we provide a simple matching object on the global scope for tests.
    beforeEach(() => {
        global.TIMEUNIT = {
            days: 'days',
            hours: 'hours',
            minutes: 'minutes',
        };
    });

    afterEach(() => {
        // Clean up the global TIMEUNIT so tests are isolated and do not leak between runs.
        delete global.TIMEUNIT;
    });

    // Basic Test Cases
    describe('Basic functionality', () => {
        test('should convert milliseconds to days correctly for an exact day', () => {
            // 1 day in ms
            const oneDayMs = 24 * 60 * 60 * 1000;
            const result = msToTimeUnit(TIMEUNIT.days, oneDayMs);
            expect(result).toBe(1);  // 2.17μs -> 1.88μs (15.6% faster)
        });

        test('should convert milliseconds to hours correctly', () => {
            // 2 hours in ms
            const twoHoursMs = 2 * 60 * 60 * 1000;
            const result = msToTimeUnit(TIMEUNIT.hours, twoHoursMs);
            expect(result).toBe(2);  // 5.33μs -> 4.50μs (18.5% faster)
        });

        test('should convert milliseconds to minutes correctly', () => {
            // 30 minutes in ms
            const thirtyMinMs = 30 * 60 * 1000;
            const result = msToTimeUnit(TIMEUNIT.minutes, thirtyMinMs);
            expect(result).toBe(30);  // 5.25μs -> 4.33μs (21.1% faster)
        });

        test('should handle non-integer results (floating point) using toBeCloseTo', () => {
            // 1500 ms is 1.5 seconds -> in minutes: 0.025
            const ms = 1500;
            const minutes = msToTimeUnit(TIMEUNIT.minutes, ms);
            expect(minutes).toBeCloseTo(0.025, 10);  // 1.08μs -> 833ns (30.1% faster)
        });

        test('should return 0 for zero timespan across units', () => {
            expect(msToTimeUnit(TIMEUNIT.minutes, 0)).toBe(0);  // 2.75μs -> 2.17μs (26.9% faster)
            expect(msToTimeUnit(TIMEUNIT.hours, 0)).toBe(0);
            expect(msToTimeUnit(TIMEUNIT.days, 0)).toBe(0);
        });
    });

    // Edge Test Cases
    describe('Edge cases', () => {
        test('should throw for negative timespan', () => {
            // negative timespan must be rejected by isValidTimespan
            expect(() => msToTimeUnit(TIMEUNIT.minutes, -1000)).toThrow(  // 4.00ms -> 4.00ms (0.000% faster)
                'msToTimeUnit - invalid timespan:-1000'
            );
        });

        test('should throw for NaN timespan', () => {
            expect(() => msToTimeUnit(TIMEUNIT.hours, NaN)).toThrow(
                'msToTimeUnit - invalid timespan:NaN'
            );
        });

        test('should throw for Infinity timespan', () => {
            expect(() => msToTimeUnit(TIMEUNIT.days, Infinity)).toThrow(
                'msToTimeUnit - invalid timespan:Infinity'
            );
        });

        test('should throw for an invalid time unit when timespan is valid', () => {
            // Use a valid timespan so the function proceeds to switch and then should throw for invalid unit
            const validMs = 1000;
            expect(() => msToTimeUnit('weeks', validMs)).toThrow('msToTimeUnit - invalid time unit');
        });

        test('handles very small timespan (less than 1 ms) correctly', () => {
            // JavaScript numbers are floating; check that a sub-millisecond value returns correct fractional conversion
            const tiny = 0.5; // 0.5 ms
            const minutes = msToTimeUnit(TIMEUNIT.minutes, tiny);
            // 0.5 ms in minutes = 0.5 / 60 / 1000
            expect(minutes).toBeCloseTo(0.5 / 60000, 12);  // 1.25μs -> 916ns (36.5% faster)
        });

        test('handles very large but finite timespan without throwing and returns expected numeric value', () => {
            // Large timespan but finite — convert to days
            const largeMs = Number.MAX_SAFE_INTEGER - 1000; // still finite
            const days = msToTimeUnit(TIMEUNIT.days, largeMs);
            // days = largeMs / (24*60*60*1000)
            const expected = largeMs / (24 * 60 * 60 * 1000);
            // allow for floating point differences
            expect(days).toBeCloseTo(expected, 6);  // 1.00μs -> 750ns (33.3% faster)
        });
    });

    // Large Scale Test Cases
    describe('Performance tests', () => {
        test('should handle an array of 500 conversions efficiently and correctly', () => {
            // Prepare 500 different timespans (under the specified 1000 iteration limit)
            const count = 500;
            const stepMs = 37 * 1000; // 37 seconds increments to produce varied outputs
            const times = new Array(count).fill(0).map((_, i) => i * stepMs);

            // Map them to minutes using msToTimeUnit; this tests stability and iteration over a sizable dataset.
            const results = times.map((t) => msToTimeUnit(TIMEUNIT.minutes, t));

            // Basic sanity checks:
            expect(results).toHaveLength(count);  // 396μs -> 308μs (28.5% faster)
            // First value should be 0 minutes
            expect(results[0]).toBe(0);
            // Check a middle value (e.g., index 100)
            const idx = 100;
            const expectedAtIdx = times[idx] / (60 * 1000);
            expect(results[idx]).toBeCloseTo(expectedAtIdx, 10);
            // Check last value
            const lastIdx = count - 1;
            const expectedLast = times[lastIdx] / (60 * 1000);
            expect(results[lastIdx]).toBeCloseTo(expectedLast, 10);
        });

        test('mixed unit conversion over ~500 entries remains consistent', () => {
            // Create ~450 mixed entries to test varied conversions
            const count = 450;
            const entries = new Array(count).fill(0).map((_, i) => {
                const base = (i + 1) * 12345; // deterministic varying ms
                // cycle through units deterministically
                const unit = i % 3 === 0 ? TIMEUNIT.days : i % 3 === 1 ? TIMEUNIT.hours : TIMEUNIT.minutes;
                return { unit, base };
            });

            // Convert and validate a few sampled positions to ensure correctness
            const converted = entries.map(({ unit, base }) => msToTimeUnit(unit, base));

            // Sample checks (start, middle, end)
            expect(converted.length).toBe(count);  // 358μs -> 274μs (30.4% faster)

            // start
            const start = converted[0];
            const expectedStart = entries[0].base / (24 * 60 * 60 * 1000); // index 0 uses TIMEUNIT.days
            expect(start).toBeCloseTo(expectedStart, 10);

            // middle
            const midIdx = Math.floor(count / 2);
            const midUnit = entries[midIdx].unit;
            const midBase = entries[midIdx].base;
            const midExpected =
                midUnit === TIMEUNIT.days
                    ? midBase / (24 * 60 * 60 * 1000)
                    : midUnit === TIMEUNIT.hours
                    ? midBase / (60 * 60 * 1000)
                    : midBase / (60 * 1000);
            expect(converted[midIdx]).toBeCloseTo(midExpected, 10);

            // end
            const endIdx = count - 1;
            const endUnit = entries[endIdx].unit;
            const endBase = entries[endIdx].base;
            const endExpected =
                endUnit === TIMEUNIT.days
                    ? endBase / (24 * 60 * 60 * 1000)
                    : endUnit === TIMEUNIT.hours
                    ? endBase / (60 * 60 * 1000)
                    : endBase / (60 * 1000);
            expect(converted[endIdx]).toBeCloseTo(endExpected, 10);
        });
    });
});

// @ts-nocheck
import { jest, describe, it, expect, beforeEach, afterEach, beforeAll, test } from '@jest/globals'
import { msToTimeUnit } from '../../client/lib/convertTimeUnit';

describe('msToTimeUnit', () => {
	// Basic Test Cases
	describe('Basic functionality', () => {
		test('should convert milliseconds to days correctly', () => {
			// 86400000 ms = 1 day
			const result = msToTimeUnit('days', 86400000);
			expect(result).toBe(1);  // 916ns -> 708ns (29.4% faster)
		});

		test('should convert milliseconds to hours correctly', () => {
			// 3600000 ms = 1 hour
			const result = msToTimeUnit('hours', 3600000);
			expect(result).toBe(1);  // 917ns -> 750ns (22.3% faster)
		});

		test('should convert milliseconds to minutes correctly', () => {
			// 60000 ms = 1 minute
			const result = msToTimeUnit('minutes', 60000);
			expect(result).toBe(1);  // 917ns -> 666ns (37.7% faster)
		});

		test('should handle multiple days conversion', () => {
			// 172800000 ms = 2 days
			const result = msToTimeUnit('days', 172800000);
			expect(result).toBe(2);  // 79.7μs -> 59.6μs (33.6% faster)
		});

		test('should handle multiple hours conversion', () => {
			// 7200000 ms = 2 hours
			const result = msToTimeUnit('hours', 7200000);
			expect(result).toBe(2);  // 78.4μs -> 60.0μs (30.6% faster)
		});

		test('should handle multiple minutes conversion', () => {
			// 120000 ms = 2 minutes
			const result = msToTimeUnit('minutes', 120000);
			expect(result).toBe(2);  // 79.0μs -> 61.1μs (29.2% faster)
		});

		test('should handle fractional conversions for days', () => {
			// 43200000 ms = 0.5 days
			const result = msToTimeUnit('days', 43200000);
			expect(result).toBe(0.5);
		});

		test('should handle fractional conversions for hours', () => {
			// 1800000 ms = 0.5 hours
			const result = msToTimeUnit('hours', 1800000);
			expect(result).toBe(0.5);
		});

		test('should handle fractional conversions for minutes', () => {
			// 30000 ms = 0.5 minutes
			const result = msToTimeUnit('minutes', 30000);
			expect(result).toBe(0.5);
		});

		test('should handle zero milliseconds', () => {
			expect(msToTimeUnit('days', 0)).toBe(0);
			expect(msToTimeUnit('hours', 0)).toBe(0);
			expect(msToTimeUnit('minutes', 0)).toBe(0);
		});
	});

	// Edge Test Cases
	describe('Edge cases', () => {
		test('should throw error for negative timespan', () => {
			expect(() => msToTimeUnit('days', -1)).toThrow('msToTimeUnit - invalid timespan:-1');
			expect(() => msToTimeUnit('hours', -1000)).toThrow();
			expect(() => msToTimeUnit('minutes', -100)).toThrow();
		});

		test('should throw error for NaN timespan', () => {
			expect(() => msToTimeUnit('days', NaN)).toThrow('msToTimeUnit - invalid timespan:NaN');
		});

		test('should throw error for Infinity timespan', () => {
			expect(() => msToTimeUnit('days', Infinity)).toThrow('msToTimeUnit - invalid timespan:Infinity');
			expect(() => msToTimeUnit('hours', -Infinity)).toThrow();
		});

		test('should throw error for invalid time unit', () => {
			expect(() => msToTimeUnit('seconds', 1000)).toThrow('msToTimeUnit - invalid time unit');  // 2.71μs -> 2.08μs (30.0% faster)
			expect(() => msToTimeUnit('years', 1000)).toThrow('msToTimeUnit - invalid time unit');
			expect(() => msToTimeUnit(null, 1000)).toThrow('msToTimeUnit - invalid time unit');
			expect(() => msToTimeUnit(undefined, 1000)).toThrow('msToTimeUnit - invalid time unit');
		});

		test('should handle very small positive values', () => {
			const smallValue = 0.001; // 0.001 ms
			expect(msToTimeUnit('minutes', smallValue)).toBeCloseTo(smallValue / 60 / 1000);
			expect(msToTimeUnit('hours', smallValue)).toBeCloseTo(smallValue / 60 / 60 / 1000);
			expect(msToTimeUnit('days', smallValue)).toBeCloseTo(smallValue / 24 / 60 / 60 / 1000);
		});

		test('should handle floating point milliseconds', () => {
			const floatValue = 12345.6789;
			const daysResult = msToTimeUnit('days', floatValue);
			const hoursResult = msToTimeUnit('hours', floatValue);
			const minutesResult = msToTimeUnit('minutes', floatValue);

			expect(daysResult).toBeCloseTo(floatValue / 24 / 60 / 60 / 1000);
			expect(hoursResult).toBeCloseTo(floatValue / 60 / 60 / 1000);
			expect(minutesResult).toBeCloseTo(floatValue / 60 / 1000);
		});

		test('should handle precision with large millisecond values', () => {
			// 1 week in milliseconds
			const oneWeekMs = 604800000;
			const daysResult = msToTimeUnit('days', oneWeekMs);
			expect(daysResult).toBe(7);
		});

		test('should handle maximum safe integer', () => {
			const maxSafeInt = Number.MAX_SAFE_INTEGER;
			const daysResult = msToTimeUnit('days', maxSafeInt);
			const hoursResult = msToTimeUnit('hours', maxSafeInt);
			const minutesResult = msToTimeUnit('minutes', maxSafeInt);

			expect(Number.isFinite(daysResult)).toBe(true);
			expect(Number.isFinite(hoursResult)).toBe(true);
			expect(Number.isFinite(minutesResult)).toBe(true);
		});

		test('should handle minimum representable positive number', () => {
			const minValue = Number.MIN_VALUE;
			const daysResult = msToTimeUnit('days', minValue);
			const hoursResult = msToTimeUnit('hours', minValue);
			const minutesResult = msToTimeUnit('minutes', minValue);

			expect(daysResult).toBeGreaterThan(0);
			expect(hoursResult).toBeGreaterThan(0);
			expect(minutesResult).toBeGreaterThan(0);
		});
	});

	// Large Scale Test Cases
	describe('Performance tests', () => {
		test('should efficiently convert multiple large timespan values to days', () => {
			const largeTimespans = Array.from({ length: 100 }, (_, i) => (i + 1) * 86400000); // Various day values

			const startTime = performance.now();
			largeTimespans.forEach(timespan => {
				msToTimeUnit('days', timespan);
			});
			const endTime = performance.now();

			// Should complete in reasonable time (less than 100ms)
			expect(endTime - startTime).toBeLessThan(100);
		});

		test('should efficiently convert multiple large timespan values to hours', () => {
			const largeTimespans = Array.from({ length: 100 }, (_, i) => (i + 1) * 3600000); // Various hour values

			const startTime = performance.now();
			largeTimespans.forEach(timespan => {
				msToTimeUnit('hours', timespan);
			});
			const endTime = performance.now();

			// Should complete in reasonable time (less than 100ms)
			expect(endTime - startTime).toBeLessThan(100);
		});

		test('should efficiently convert multiple large timespan values to minutes', () => {
			const largeTimespans = Array.from({ length: 100 }, (_, i) => (i + 1) * 60000); // Various minute values

			const startTime = performance.now();
			largeTimespans.forEach(timespan => {
				msToTimeUnit('minutes', timespan);
			});
			const endTime = performance.now();

			// Should complete in reasonable time (less than 100ms)
			expect(endTime - startTime).toBeLessThan(100);
		});

		test('should handle mixed unit conversions at scale', () => {
			const testValue = 86400000; // 1 day

			const startTime = performance.now();
			for (let i = 0; i < 500; i++) {
				msToTimeUnit('days', testValue);
				msToTimeUnit('hours', testValue);
				msToTimeUnit('minutes', testValue);
			}
			const endTime = performance.now();

			// Should complete in reasonable time (less than 200ms for 1500 total calls)
			expect(endTime - startTime).toBeLessThan(200);
		});

		test('should maintain accuracy with high volume of conversions', () => {
			const testValue = 1234567890;
			const results = [];

			for (let i = 0; i < 200; i++) {
				results.push(msToTimeUnit('days', testValue));
			}

			// All results should be identical
			const firstResult = results[0];
			results.forEach(result => {
				expect(result).toBe(firstResult);
			});
		});

		test('should handle rapid successive calls without side effects', () => {
			const value1 = 86400000;
			const value2 = 3600000;

			const results1 = [];
			const results2 = [];

			for (let i = 0; i < 100; i++) {
				results1.push(msToTimeUnit('days', value1));
				results2.push(msToTimeUnit('hours', value2));
			}

			// Verify consistency across all calls
			expect(results1.every(r => r === results1[0])).toBe(true);
			expect(results2.every(r => r === results2[0])).toBe(true);
			expect(results1[0]).not.toBe(results2[0]);
		});

		test('should correctly convert very large timespan values', () => {
			// Test with large but finite numbers
			const largeValue = 31536000000; // 365 days in milliseconds
			const daysResult = msToTimeUnit('days', largeValue);
			expect(daysResult).toBe(365);

			const hoursResult = msToTimeUnit('hours', largeValue);
			expect(hoursResult).toBe(365 * 24);

			const minutesResult = msToTimeUnit('minutes', largeValue);
			expect(minutesResult).toBe(365 * 24 * 60);
		});
	});
});

To edit these changes git checkout codeflash/optimize-msToTimeUnit-mm3trmjx and push.