nhb-toolbox/dist/esm/number/Unit.js

A versatile collection of smart, efficient, and reusable utility functions, classes and types for everyday development needs.

import { PREFIX_MULTIPLIERS } from './constants.js';
export class Unit {
    #value;
    #unit;
    constructor(value, unit) {
        this.#value = value;
        this.#unit = unit;
    }
    toString() {
        return ` ${this.#value} ${this.#unit ?? ''}`.trim();
    }
    convertByPrefix(fromPrefix, toPrefix) {
        return Unit.convertByPrefix(this.#value, fromPrefix, toPrefix);
    }
    convertFromTo(from, to) {
        return Unit.convertFromTo(this.#value, from, to);
    }
    convert(methodName) {
        const method = Unit[methodName];
        if (typeof method !== 'function') {
            throw new Error(`Method ${methodName} is not a valid method!`);
        }
        return method(this.#value);
    }
    static convertByPrefix(value, fromPrefix, toPrefix) {
        const fromMultiplier = PREFIX_MULTIPLIERS[fromPrefix];
        const toMultiplier = PREFIX_MULTIPLIERS[toPrefix];
        return (value * fromMultiplier) / toMultiplier;
    }
    static convertFromTo(value, from, to) {
        const extractPrefix = (str) => {
            const match = str.match(/^(da|[yzafpnμumcdhkMGTPEZY]?)(.+)$/);
            if (!match)
                throw new Error(`Invalid unit format: ${str}`);
            return [match[1], match[2]];
        };
        const [fromPrefix, fromUnit] = extractPrefix(from);
        const [toPrefix, toUnit] = extractPrefix(to);
        if (fromUnit !== toUnit) {
            throw new Error(`Mismatched units: ${fromUnit} vs ${toUnit}`);
        }
        return Unit.convertByPrefix(value, fromPrefix, toPrefix);
    }
    static metersToFeet(m) {
        return m * 3.28084;
    }
    static feetToMeters(ft) {
        return ft / 3.28084;
    }
    static kmToMiles(km) {
        return km * 0.621371;
    }
    static milesToKm(mi) {
        return mi / 0.621371;
    }
    static kgToLbs(kg) {
        return kg * 2.20462;
    }
    static lbsToKg(lbs) {
        return lbs / 2.20462;
    }
    static gramsToOunces(g) {
        return g * 0.035274;
    }
    static ouncesToGrams(oz) {
        return oz / 0.035274;
    }
    static celsiusToFahrenheit(c) {
        return (c * 9) / 5 + 32;
    }
    static fahrenheitToCelsius(f) {
        return ((f - 32) * 5) / 9;
    }
    static celsiusToKelvin(c) {
        return c + 273.15;
    }
    static kelvinToCelsius(k) {
        return k - 273.15;
    }
    static fahrenheitToKelvin(f) {
        return ((f - 32) * 5) / 9 + 273.15;
    }
    static kelvinToFahrenheit(k) {
        return ((k - 273.15) * 9) / 5 + 32;
    }
    static mlToLiters(ml) {
        return ml / 1000;
    }
    static litersToMl(l) {
        return l * 1000;
    }
    static gallonsToMl(gal) {
        return gal * 3785.41;
    }
    static mlToGallons(ml) {
        return ml / 3785.41;
    }
    static litersToGallons(l) {
        return l * 0.264172;
    }
    static gallonsToLiters(gal) {
        return gal / 0.264172;
    }
    static sqmToSqft(sqm) {
        return sqm * 10.7639;
    }
    static sqftToSqm(sqft) {
        return sqft / 10.7639;
    }
    static kmphToMph(kmph) {
        return kmph * 0.621371;
    }
    static mphToKmph(mph) {
        return mph / 0.621371;
    }
    static minutesToHours(min) {
        return min / 60;
    }
    static secondsToMinutes(sec) {
        return sec / 60;
    }
    static hoursToDays(hr) {
        return hr / 24;
    }
    static hoursToMinutes(h) {
        return h * 60;
    }
    static minutesToSeconds(m) {
        return m * 60;
    }
    static daysToHours(d) {
        return d * 24;
    }
    static mbToGb(mb) {
        return mb / 1024;
    }
    static gbToMb(gb) {
        return gb * 1024;
    }
    static kbToMb(kb) {
        return kb / 1024;
    }
    static kbToGb(kb) {
        return kb / (1024 * 1024);
    }
    static gbToKb(gb) {
        return gb * 1024 * 1024;
    }
    static bytesToKb(bytes) {
        return bytes / 1024;
    }
    static kbToBytes(kb) {
        return kb * 1024;
    }
    static mbToKb(mb) {
        return mb * 1024;
    }
    static gbToTb(gb) {
        return gb / 1024;
    }
    static tbToGb(tb) {
        return tb * 1024;
    }
    static joulesToCalories(j) {
        return j * 0.239006;
    }
    static caloriesToJoules(cal) {
        return cal / 0.239006;
    }
    static caloriesToKJoules(cal) {
        return cal / 0.239006 / 1000;
    }
    static kJoulesToCalories(kj) {
        return kj * 1000 * 0.239006;
    }
    static atmToPascal(atm) {
        return atm * 101325;
    }
    static pascalToAtm(pa) {
        return pa / 101325;
    }
    static barToPascal(bar) {
        return bar * 100000;
    }
    static pascalToBar(pa) {
        return pa / 100000;
    }
    static hzToKHz(hz) {
        return hz / 1000;
    }
    static kHzToHz(khz) {
        return khz * 1000;
    }
    static hzToMHz(hz) {
        return hz / 1_000_000;
    }
    static mHzToHz(mhz) {
        return mhz * 1_000_000;
    }
    static kHzToMHz(khz) {
        return khz / 1000;
    }
    static mHzToKHz(mhz) {
        return mhz * 1000;
    }
    static cmToMeters(cm) {
        return cm / 100;
    }
    static metersToCm(m) {
        return m * 100;
    }
    static mmToMeters(mm) {
        return mm / 1000;
    }
    static metersToMm(m) {
        return m * 1000;
    }
    static sqkmToSqm(sqkm) {
        return sqkm * 1_000_000;
    }
    static sqmToSqkm(sqm) {
        return sqm / 1_000_000;
    }
    static sqftToSqin(sqft) {
        return sqft * 144;
    }
    static sqinToSqft(sqin) {
        return sqin / 144;
    }
    static wattsToKw(w) {
        return w / 1000;
    }
    static kwToWatts(kw) {
        return kw * 1000;
    }
}