@nova-ui/bits
Version:
SolarWinds Nova Framework
219 lines • 30.5 kB
JavaScript
// © 2022 SolarWinds Worldwide, LLC. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
import { Injectable } from "@angular/core";
import { LoggerService } from "./log-service";
import { UnitBase, unitConversionConstants, } from "../constants/unit-conversion.constants";
import * as i0 from "@angular/core";
import * as i1 from "./log-service";
/**
* <example-url>./../examples/index.html#/common/unit-conversion-service</example-url>
*
* Service for converting a raw value to a larger unit approximation of the value--for example, 1024 B to 1 MB, 12345 Hz to 12.35 kHz, etc.
*/
export class UnitConversionService {
constructor(logger) {
this.logger = logger;
}
/**
* Converts a raw value to a larger unit approximation of the value. For example, 1024 B to 1 KB, 12345 Hz to 12.35 kHz, etc.
*
* @param value The value to convert
* @param base The base to use for the exponential expression when calculating the conversion result
*
* @returns {{ [Key in keyof Pick<IUnitConversionResult, "value" | "order">]: number }} The value and order of conversion
*/
convertLinear(value, base) {
let resultValue;
let resultOrder;
if (value === 0) {
return {
value: 0,
order: 0,
};
}
resultOrder = Math.floor(Math.log(Math.abs(value)) / Math.log(base));
resultValue = value / Math.pow(base, Math.floor(resultOrder));
if (Math.abs(value) > 0 && Math.abs(value) < 1) {
return {
value: value,
order: 0,
};
}
// fix the precision edge case
const valueCeiled = Math.ceil(resultValue);
if (valueCeiled % base === 0) {
resultValue = valueCeiled / base;
resultOrder += 1;
}
return {
value: resultValue,
order: resultOrder,
};
}
/**
* Converts a raw value to a larger unit approximation of the value. For example, 1100ms to 1.1s, 66000ms to 1.1m, etc.
*
* @param value The value to convert
* @param factors Array of factors to use for calculating smallest possible not zero result
*
* @returns {{ [Key in keyof Pick<IUnitConversionResult, "value" | "order">]: number }} The value and order of conversion
*/
convertNonLinear(value, factors) {
const sortedFactors = factors.sort((a, b) => a > b ? -1 : a < b ? 1 : 0);
const highestFactorIndex = sortedFactors.findIndex((factor) => value / factor >= 1);
const highestFactor = factors[highestFactorIndex];
if (Math.abs(value) > 0 && Math.abs(value) < 1) {
return {
value: value,
order: 0,
};
}
return {
value: value / highestFactor,
order: highestFactorIndex === -1 ? 0 : factors.length - highestFactorIndex - 1,
};
}
/**
* Converts a raw value to a larger unit approximation of the value. For example, 1024 B to 1 KB, 12345 Hz to 12.35 kHz, 66000ms to 1.1m, etc.
*
* @param value The value to convert
* @param base The base or array of factors to use for calculating the conversion result
* @param scale The number of significant digits to the right of the decimal to include in the resulting converted value
*
* @returns {IUnitConversionResult} The conversion result
*/
convert(value, base = UnitBase.Standard, scale = 1) {
const result = Array.isArray(base) ?
this.convertNonLinear(value, base) :
this.convertLinear(value, base);
let strValue;
if (value !== 0) {
strValue = parseFloat(result.value.toFixed(scale)).toString();
}
else {
result.order = 0;
strValue = value.toString();
}
return {
value: strValue,
order: result.order,
scientificNotation: value?.toExponential(scale),
scale,
};
}
/**
* Gets the display string of a conversion result
*
* @param conversion The result of an invocation of this service's convert method
* @param unit The unit used in the conversion
* @param plusSign Whether to prepend the display string with a '+'
* @param nanDisplay The string to display in case the conversion result is NaN or Infinity
*
* @returns {string} The display string of the conversion result
*/
getFullDisplay(conversion, unit, plusSign = false, nanDisplay = "---") {
const isValidNumber = this.isValidNumber(conversion.value);
const spacing = unit !== "generic" && isValidNumber ? " " : "";
let unitDisplay = isValidNumber
? this.getUnitDisplay(conversion, unit)
: "";
// The generic unit is not currently i18n friendly
const localizeValue = unit !== "generic";
let displayValue;
if (!unitDisplay && isValidNumber && conversion.order) {
unitDisplay = this.getUnitDisplayBaseValue(unit);
displayValue = this.getScientificDisplay(conversion, plusSign, nanDisplay);
}
else {
displayValue = this.getValueDisplay(conversion, plusSign, nanDisplay, localizeValue);
}
return `${displayValue}${spacing}${unitDisplay}`;
}
/**
* Gets the converted value display string
*
* @param conversion The result of an invocation of this service's convert method
* @param plusSign Whether to prepend the display string with a '+'
* @param nanDisplay The string to display in case the conversion result is NaN or Infinity
* @param localize Whether to localize the value for display. Note: It's not recommended to localize values for
* the "generic" unit, e.g. "1.1K" for 1100, as the "generic" unit is currently not i18n friendly
*
* @returns {string} The converted value display string
*/
getValueDisplay(conversion, plusSign = false, nanDisplay = "---", localize = true) {
if (!this.isValidNumber(conversion.value)) {
return nanDisplay;
}
const outputValue = localize
? parseFloat(conversion.value).toLocaleString(undefined, {
maximumFractionDigits: conversion.scale,
})
: conversion.value;
const prefix = plusSign && parseInt(conversion.value, 10) > 0 ? "+" : "";
return `${prefix}${outputValue}`;
}
/**
* Gets the converted unit display string
*
* @param conversion The result of an invocation of this service's convert method
* @param unit The basic unit used in the conversion
*
* @returns {string} The converted unit display string
*/
getUnitDisplay(conversion, unit) {
return unitConversionConstants[unit][conversion.order];
}
/**
* Gets the base value of the converted unit
*
* @param unit The basic unit used in the conversion
*
* @returns {string} The abbreviation for the smallest unit of the provided UnitOption
*/
getUnitDisplayBaseValue(unit) {
return unitConversionConstants[unit][0];
}
/**
* Gets the converted value display string in scientific notation
*
* @param conversion The result of an invocation of this service's convert method
* @param plusSign Whether to prepend the display string with a '+'
* @param nanDisplay The string to display in case the conversion result is NaN or Infinity
*
* @returns {string} The converted value display string in scientific notation
*/
getScientificDisplay(conversion, plusSign = false, nanDisplay = "---") {
if (!this.isValidNumber(conversion.value)) {
return nanDisplay;
}
const prefix = plusSign && parseInt(conversion.value, 10) > 0 ? "+" : "";
return `${prefix}${conversion.scientificNotation}`;
}
isValidNumber(value) {
return !isNaN(parseFloat(value)) && isFinite(parseInt(value, 10));
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UnitConversionService, deps: [{ token: i1.LoggerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UnitConversionService, providedIn: "root" }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UnitConversionService, decorators: [{
type: Injectable,
args: [{ providedIn: "root" }]
}], ctorParameters: () => [{ type: i1.LoggerService }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"unit-conversion.service.js","sourceRoot":"","sources":["../../../src/services/unit-conversion.service.ts"],"names":[],"mappings":"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","sourcesContent":["// © 2022 SolarWinds Worldwide, LLC. All rights reserved.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n//  of this software and associated documentation files (the \"Software\"), to\n//  deal in the Software without restriction, including without limitation the\n//  rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n//  sell copies of the Software, and to permit persons to whom the Software is\n//  furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n//  all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n//  THE SOFTWARE.\n\nimport { Injectable } from \"@angular/core\";\n\nimport { LoggerService } from \"./log-service\";\nimport { IUnitConversionResult } from \"./public-api\";\nimport {\n    UnitBase,\n    unitConversionConstants,\n    UnitOption,\n} from \"../constants/unit-conversion.constants\";\n\n/**\n * <example-url>./../examples/index.html#/common/unit-conversion-service</example-url>\n *\n * Service for converting a raw value to a larger unit approximation of the value--for example, 1024 B to 1 MB, 12345 Hz to 12.35 kHz, etc.\n */\n@Injectable({ providedIn: \"root\" })\nexport class UnitConversionService {\n    constructor(private logger: LoggerService) {}\n\n    /**\n     * Converts a raw value to a larger unit approximation of the value. For example, 1024 B to 1 KB, 12345 Hz to 12.35 kHz, etc.\n     *\n     * @param value The value to convert\n     * @param base The base to use for the exponential expression when calculating the conversion result\n     *\n     * @returns {{ [Key in keyof Pick<IUnitConversionResult, \"value\" | \"order\">]: number }} The value and order of conversion\n     */\n    private convertLinear(\n        value: number,\n        base: number\n    ): { [Key in keyof Pick<IUnitConversionResult, \"value\" | \"order\">]: number } {\n        let resultValue: number;\n        let resultOrder: number;\n\n        if (value === 0) {\n            return {\n                value: 0,\n                order: 0,\n            };\n        }\n\n        resultOrder = Math.floor(\n            Math.log(Math.abs(value)) / Math.log(base)\n        );\n        resultValue = value / Math.pow(base, Math.floor(resultOrder));\n\n        if (Math.abs(value) > 0 && Math.abs(value) < 1) {\n            return {\n                value: value,\n                order: 0,\n            };\n        }\n\n        // fix the precision edge case\n        const valueCeiled = Math.ceil(resultValue);\n        if (valueCeiled % base === 0) {\n            resultValue = valueCeiled / base;\n            resultOrder += 1;\n        }\n\n        return {\n            value: resultValue,\n            order: resultOrder,\n        };\n    }\n\n    /**\n     * Converts a raw value to a larger unit approximation of the value. For example, 1100ms to 1.1s, 66000ms to 1.1m, etc.\n     *\n     * @param value The value to convert\n     * @param factors Array of factors to use for calculating smallest possible not zero result\n     *\n     * @returns {{ [Key in keyof Pick<IUnitConversionResult, \"value\" | \"order\">]: number }} The value and order of conversion\n     */\n    private convertNonLinear(\n        value: number,\n        factors: number[]\n    ): { [Key in keyof Pick<IUnitConversionResult, \"value\" | \"order\">]: number } {\n        const sortedFactors = factors.sort((a, b) => a > b ? -1 : a < b ? 1 : 0);\n        const highestFactorIndex = sortedFactors.findIndex((factor) => value / factor >= 1);\n        const highestFactor = factors[highestFactorIndex];\n\n        if (Math.abs(value) > 0 && Math.abs(value) < 1) {\n            return {\n                value: value,\n                order: 0,\n            };\n        }\n\n        return {\n            value: value / highestFactor,\n            order: highestFactorIndex === -1 ? 0 : factors.length - highestFactorIndex - 1,\n        };\n    }\n\n    /**\n     * Converts a raw value to a larger unit approximation of the value. For example, 1024 B to 1 KB, 12345 Hz to 12.35 kHz, 66000ms to 1.1m, etc.\n     *\n     * @param value The value to convert\n     * @param base The base or array of factors to use for calculating the conversion result\n     * @param scale The number of significant digits to the right of the decimal to include in the resulting converted value\n     *\n     * @returns {IUnitConversionResult} The conversion result\n     */\n    convert(\n        value: number,\n        base: number | number[] = UnitBase.Standard,\n        scale: number = 1\n    ): IUnitConversionResult {\n        const result = Array.isArray(base) ?\n            this.convertNonLinear(value, base) :\n            this.convertLinear(value, base);\n\n        let strValue: string;\n\n        if (value !== 0) {\n            strValue = parseFloat(result.value.toFixed(scale)).toString();\n        } else {\n            result.order = 0;\n            strValue = value.toString();\n        }\n\n        return {\n            value: strValue,\n            order: result.order,\n            scientificNotation: value?.toExponential(scale),\n            scale,\n        };\n    }\n\n    /**\n     * Gets the display string of a conversion result\n     *\n     * @param conversion The result of an invocation of this service's convert method\n     * @param unit The unit used in the conversion\n     * @param plusSign Whether to prepend the display string with a '+'\n     * @param nanDisplay The string to display in case the conversion result is NaN or Infinity\n     *\n     * @returns {string} The display string of the conversion result\n     */\n    public getFullDisplay(\n        conversion: IUnitConversionResult,\n        unit: UnitOption,\n        plusSign = false,\n        nanDisplay = \"---\"\n    ): string {\n        const isValidNumber = this.isValidNumber(conversion.value);\n        const spacing = unit !== \"generic\" && isValidNumber ? \" \" : \"\";\n        let unitDisplay = isValidNumber\n            ? this.getUnitDisplay(conversion, unit)\n            : \"\";\n\n        // The generic unit is not currently i18n friendly\n        const localizeValue = unit !== \"generic\";\n\n        let displayValue: string;\n\n        if (!unitDisplay && isValidNumber && conversion.order) {\n            unitDisplay = this.getUnitDisplayBaseValue(unit);\n            displayValue = this.getScientificDisplay(\n                conversion,\n                plusSign,\n                nanDisplay\n            );\n        } else {\n            displayValue = this.getValueDisplay(\n                conversion,\n                plusSign,\n                nanDisplay,\n                localizeValue\n            );\n        }\n        return `${displayValue}${spacing}${unitDisplay}`;\n    }\n\n    /**\n     * Gets the converted value display string\n     *\n     * @param conversion The result of an invocation of this service's convert method\n     * @param plusSign Whether to prepend the display string with a '+'\n     * @param nanDisplay The string to display in case the conversion result is NaN or Infinity\n     * @param localize Whether to localize the value for display. Note: It's not recommended to localize values for\n     *                 the \"generic\" unit, e.g. \"1.1K\" for 1100, as the \"generic\" unit is currently not i18n friendly\n     *\n     * @returns {string} The converted value display string\n     */\n    public getValueDisplay(\n        conversion: IUnitConversionResult,\n        plusSign = false,\n        nanDisplay = \"---\",\n        localize = true\n    ): string {\n        if (!this.isValidNumber(conversion.value)) {\n            return nanDisplay;\n        }\n\n        const outputValue = localize\n            ? parseFloat(conversion.value).toLocaleString(undefined, {\n                  maximumFractionDigits: conversion.scale,\n              })\n            : conversion.value;\n        const prefix =\n            plusSign && parseInt(conversion.value, 10) > 0 ? \"+\" : \"\";\n        return `${prefix}${outputValue}`;\n    }\n\n    /**\n     * Gets the converted unit display string\n     *\n     * @param conversion The result of an invocation of this service's convert method\n     * @param unit The basic unit used in the conversion\n     *\n     * @returns {string} The converted unit display string\n     */\n    public getUnitDisplay(\n        conversion: IUnitConversionResult,\n        unit: UnitOption\n    ): string {\n        return unitConversionConstants[unit][conversion.order];\n    }\n\n    /**\n     * Gets the base value of the converted unit\n     *\n     * @param unit The basic unit used in the conversion\n     *\n     * @returns {string} The abbreviation for the smallest unit of the provided UnitOption\n     */\n    public getUnitDisplayBaseValue(unit: UnitOption): string {\n        return unitConversionConstants[unit][0];\n    }\n\n    /**\n     * Gets the converted value display string in scientific notation\n     *\n     * @param conversion The result of an invocation of this service's convert method\n     * @param plusSign Whether to prepend the display string with a '+'\n     * @param nanDisplay The string to display in case the conversion result is NaN or Infinity\n     *\n     * @returns {string} The converted value display string in scientific notation\n     */\n    public getScientificDisplay(\n        conversion: IUnitConversionResult,\n        plusSign = false,\n        nanDisplay = \"---\"\n    ): string {\n        if (!this.isValidNumber(conversion.value)) {\n            return nanDisplay;\n        }\n        const prefix =\n            plusSign && parseInt(conversion.value, 10) > 0 ? \"+\" : \"\";\n\n        return `${prefix}${conversion.scientificNotation}`;\n    }\n\n    private isValidNumber(value: any): boolean {\n        return !isNaN(parseFloat(value)) && isFinite(parseInt(value, 10));\n    }\n}\n"]}