smart-unit 1.0.4 → 2.0.0

package/dist/SmartUnitPrecision.d.ts

@@ -0,0 +1,82 @@
+import { type Decimal } from 'decimal.js';
+import { SmartUnitBase } from './SmartUnitBase';
+import { type FormattedValue, type FractionDigits, type InputNumber, type SmartUnitOptions } from './utils';
+export type DecimalOptions = Decimal.Config;
+export type NumPrecision = InputNumber | string | bigint | Decimal;
+export interface FormattedValuePrecision<U extends string> extends FormattedValue<U> {
+    decimal: Decimal;
+}
+export interface SmartUnitPrecisionOptions extends SmartUnitOptions {
+    /**
+     * Decimal.js configuration options
+     * - Creates an isolated Decimal class for this SmartUnit instance only
+     * - Used to customize precision and other parameters
+     */
+    decimalOptions?: DecimalOptions;
+}
+export declare class SmartUnitPrecision<U extends string = string> extends SmartUnitBase<U, true> {
+    private DecimalClass;
+    constructor(units: (U | number)[], option?: SmartUnitPrecisionOptions);
+    /**
+     * Gets the appropriate unit and adjusted value for the input number
+     *
+     * @param num - The input NumPrecision to determine the unit for
+     * @param fractionDigits - Decimal precision configuration
+     * @returns The FormattedValue object containing the number, unit, and decimal instance
+     */
+    getUnit(num: NumPrecision): FormattedValuePrecision<U>;
+    /**
+     * Formats a number as a string with unit and optional decimal place configuration
+     *
+     * @param num - The input number to format
+     * @param fractionDigits - Decimal precision configuration
+     * @returns The formatted string with number and unit
+     */
+    format(num: NumPrecision, fractionDigits?: FractionDigits): string;
+    /**
+     * Gets the chain of units for the input number
+     *
+     * @param num - The input number to determine the chain for
+     * @returns An array of FormattedValue objects representing the chain of units
+     */
+    getChainUnit(num: NumPrecision): FormattedValuePrecision<U>[];
+    /**
+     * Formats a number as a chain of units string
+     *
+     * @param num - The input number to format
+     * @returns The formatted chain string
+     */
+    formatChain(num: NumPrecision, separator?: string): string;
+    /**
+     * Converts a value from the specified unit to the base unit
+     *
+     * @param num - The number to convert
+     * @param unit - The original unit of the number
+     * @returns The converted value in base unit
+     */
+    toBase(num: NumPrecision, unit: U): Decimal;
+    /**
+     * Splits a string into its numeric part and unit
+     *
+     * @param str - Input string containing a number followed by a unit
+     * @returns An object containing the numeric value, unit, and Decimal instance
+     * @throws An error if no predefined unit is matched
+     */
+    splitUnit(str: string): FormattedValuePrecision<U>;
+    /**
+     * Parses a string with unit into a base unit numeric value
+     *
+     * @param str - Input string containing a number and unit
+     * @returns The value converted to base unit
+     */
+    parse(str: string): Decimal;
+    /**
+     * Converts a value from the original unit to the optimal unit with optional decimal precision
+     *
+     * @param num - The number to convert
+     * @param unit - The original unit
+     * @param fractionDigits - Optional decimal places for formatting output
+     * @returns The converted number as a formatted string
+     */
+    fromUnitFormat(num: NumPrecision, unit: U, fractionDigits?: FractionDigits): string;
+}

package/dist/index.cjs

@@ -0,0 +1,166 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('./utils-DqEXot5a.js');
+
+class SmartUnit extends utils.SmartUnitBase {
+    constructor(units, option = {}) {
+        super(units, option);
+    }
+    // 根据输入数值获取单位和调整后的值
+    /**
+     * Gets the appropriate unit and adjusted value for the input number
+     *
+     * @param num - The input number to determine the unit for
+     * @param fractionDigits - Decimal precision configuration
+     * @returns The FormattedValue object containing the number, unit, and formatted number string
+     */
+    getUnit(num, fractionDigits = this.fractionDigits) {
+        if (Number.isNaN(num))
+            throw new Error(utils.ERROR_NAN_INPUT);
+        const unitDigitsLen = this.unitDigits.length;
+        const isNegative = num < 0;
+        let absNum = isNegative ? -num : num;
+        let i = 0;
+        while (i < unitDigitsLen) {
+            const digit = this.unitDigits[i];
+            if (absNum < digit * this.threshold) {
+                break;
+            }
+            absNum /= digit;
+            i++;
+        }
+        const result = isNegative ? -absNum : absNum;
+        return {
+            num: result,
+            unit: this.unitNames[i],
+            numStr: this.formatNumber(result, fractionDigits),
+        };
+    }
+    // 将数字转换为字符串表示形式，并可选择配置小数位数
+    /**
+     * Formats a number as a string with unit and optional decimal place configuration
+     *
+     * @param num - The input number to format
+     * @param fractionDigits - Decimal precision configuration (defaults to instance setting)
+     *   - If a number, defines fixed decimal places
+     *   - If a string in "min-max" format, defines a range of decimal places
+     *   - If omitted, uses the instance's default decimal configuration
+     * @returns The formatted string with number and unit (e.g. "1.50KB")
+     */
+    format(num, fractionDigits = this.fractionDigits) {
+        const { numStr, unit } = this.getUnit(num, fractionDigits);
+        return this._format(numStr, unit);
+    }
+    // 根据输入数值获取链式单位数组
+    /**
+     * Gets the chain of units for the input number
+     * @param num - The input number to determine the chain for
+     * @returns An array of FormattedValue objects representing the chain of units
+     */
+    getChainUnit(num) {
+        if (Number.isNaN(num))
+            throw new Error(utils.ERROR_NAN_INPUT);
+        const result = [];
+        if (num === 0) {
+            return [{ num: 0, unit: this.unitNames[0], numStr: '0' }];
+        }
+        const isNegative = num < 0;
+        let absNum = isNegative ? -num : num;
+        const accDigLen = this.accumulatedDigits.length;
+        for (let i = accDigLen - 1; i >= 0; i--) {
+            const accDigit = this.accumulatedDigits[i];
+            if (absNum < accDigit)
+                continue;
+            const res = Math.floor(absNum / accDigit);
+            const val = isNegative ? -res : res;
+            result.push({
+                num: val,
+                unit: this.unitNames[i + 1],
+                numStr: val.toString(),
+            });
+            absNum %= accDigit;
+            if (absNum === 0)
+                break;
+        }
+        if (absNum !== 0) {
+            const val = isNegative ? -absNum : absNum;
+            result.push({
+                num: val,
+                unit: this.unitNames[0],
+                numStr: this.formatNumber(val, this.fractionDigits),
+            });
+        }
+        return result;
+    }
+    // 将数字格式化为链式单位字符串
+    /**
+     * Formats a number as a chain of units string
+     * @param num - The input number to format
+     * @returns The formatted chain string
+     */
+    formatChain(num, separator = this.separator) {
+        const chain = this.getChainUnit(num);
+        return this._formatChain(chain, separator);
+    }
+    // 将给定数值从指定单位转换为基本单位
+    /**
+     * Converts a value from the specified unit to the base unit
+     *
+     * @param num - The number to convert
+     * @param unit - The original unit of the number
+     * @returns The converted value in base unit
+     */
+    toBase(num, unit) {
+        if (Number.isNaN(num))
+            throw new Error(utils.ERROR_NAN_INPUT);
+        const unitDigitsLen = this.unitDigits.length;
+        let nn = num;
+        for (let i = 0; i < unitDigitsLen; i++) {
+            const digit = this.unitDigits[i];
+            if (this.unitNames[i] === unit) {
+                return nn;
+            }
+            nn *= digit;
+        }
+        if (unit === this.unitNames.at(-1)) {
+            return nn;
+        }
+        throw new Error(`Undefined unit: "${unit}".`);
+    }
+    // 将带单位的值转换为基础单位的数值
+    /**
+     * Parses a string with unit into a base unit numeric value
+     *
+     * @param str - Input string containing a number and unit
+     * @returns The value converted to base unit
+     */
+    parse(str) {
+        const { num, unit } = this.splitUnit(str);
+        return this.toBase(num, unit);
+    }
+    // 将给定数值从原单位转换为最佳单位，并可指定小数精度
+    /**
+     * Converts a value from the original unit to the optimal unit with optional decimal precision
+     *
+     * @param num - The number to convert
+     * @param unit - The original unit
+     * @param fractionDigits - Optional decimal places for formatting output
+     * @returns The converted number as a formatted string
+     */
+    fromUnitFormat(num, unit, fractionDigits) {
+        const nnum = this.toBase(num, unit);
+        return this.format(nnum, fractionDigits);
+    }
+}
+
+/*!
+ * smart-unit
+ * Copyright (c) [2026] [flycran]
+ * MIT License. See LICENSE for details.
+ */
+
+exports.ERROR_NAN_INPUT = utils.ERROR_NAN_INPUT;
+exports.SmartUnit = SmartUnit;
+exports.default = SmartUnit;

package/dist/index.d.ts

@@ -3,108 +3,7 @@
  * Copyright (c) [2026] [flycran]
  * MIT License. See LICENSE for details.
  */
-import { type Decimal } from 'decimal.js';
-export type FractionDigits = number | `-${number}` | `${number}-` | `${number}-${number}` | undefined;
-export type DecimalOptions = Decimal.Config;
-export interface SmartUnitOptions<HP extends boolean = false> {
-    /** Base digit for auto-generating unit conversions */
-    baseDigit?: number;
-    /**
-     * Threshold for unit switching
-     * The comparison value is multiplied by this threshold
-     */
-    threshold?: number;
-    /**
-     * Number of decimal places to preserve in the result
-     * Can be a fixed number or a range like "min-max"
-     */
-    fractionDigits?: FractionDigits;
-    /**
-     * Enable high-precision calculation using decimal.js
-     * - Uses decimal.js for high-precision floating-point calculations
-     * - Supports calculations beyond JavaScript's safe integer limit
-     * - Enables string, BigInt, and Decimal inputs for format and other methods
-     */
-    useDecimal?: HP;
-    /**
-     * Decimal.js configuration options
-     * - Creates an isolated Decimal class for this SmartUnit instance only
-     * - Used to customize precision and other parameters
-     */
-    decimalOptions?: DecimalOptions;
-}
-export interface NumUnit {
-    /** The numeric value */
-    num: number;
-    /** The Decimal instance for high-precision mode */
-    decimal?: Decimal;
-    /** The unit string */
-    unit: string;
-}
-export type Num<DS extends boolean = false> = DS extends true ? number | bigint | string | Decimal : number;
-export declare const ERROR_NAN_INPUT = "Accepting NaN as an argument may be unintentional and could lead to invalid results. If this is intentional, please set `SmartUnit.ignoreNaNInputs` to `true`.";
-export declare const ERROR_HIGH_PRECISION_NOT_ENABLED = "By default, only number input is supported. To enable high-precision calculations, explicitly set the decimalSafety parameter to true.";
-export declare class SmartUnit<HP extends boolean = false> {
-    readonly units: (string | number)[];
-    static ignoreNaNInputs: boolean;
-    readonly threshold: number;
-    readonly decimal?: FractionDigits;
-    readonly unitsStr: string[];
-    readonly highPrecision: HP;
-    private DecimalClass;
-    constructor(units: (string | number)[], option?: SmartUnitOptions<HP>);
-    /**
-     * Gets the appropriate unit and adjusted value for the input number
-     *
-     * @param num - The input number to determine the unit for
-     * @returns An object containing the adjusted number and its corresponding unit
-     */
-    getUnit(num: Num<HP>): NumUnit;
-    /**
-     * Formats a number as a string with optional decimal place configuration
-     *
-     * @param num - The number to convert to string
-     * @param decimal - Decimal precision configuration (defaults to instance setting)
-     *   - If a number, defines fixed decimal places
-     *   - If a string in "min-max" format, defines a range of decimal places
-     *   - If omitted, uses the instance's default decimal configuration
-     * @returns The formatted string representation with unit
-     */
-    format(num: Num<HP>, decimal?: FractionDigits): string;
-    /**
-     * Converts a value from the specified unit to the base unit
-     *
-     * @param num - The number to convert
-     * @param unit - The original unit of the number
-     * @returns The converted value in base unit
-     *   - Returns Decimal if high-precision mode is enabled
-     */
-    toBase(num: Num<HP>, unit: string): HP extends true ? Decimal : number;
-    /**
-     * Splits a string into its numeric part and unit
-     *
-     * @param str - Input string containing a number followed by a unit
-     * @returns An object containing the numeric value and unit
-     * Only supports predefined units
-     * Throws an error if no match is found
-     */
-    splitUnit(str: string): NumUnit;
-    /**
-     * Parses a string with unit into a base unit numeric value
-     *
-     * @param str - Input string containing a number and unit
-     * @returns The value converted to base unit
-     *   - Returns Decimal if high-precision mode is enabled
-     */
-    parse(str: string): HP extends true ? Decimal : number;
-    /**
-     * Converts a value from the original unit to the optimal unit with optional decimal precision
-     *
-     * @param num - The number to convert
-     * @param unit - The original unit
-     * @param decimal - Optional decimal places for formatting output
-     * @returns The converted number as a formatted string
-     */
-    fromUnitFormat(num: Num<HP>, unit: string, decimal?: FractionDigits): string;
-}
+export * from './SmartUnit';
+export * from './utils';
+import { SmartUnit } from './SmartUnit';
 export default SmartUnit;

package/dist/index.mjs

@@ -0,0 +1,160 @@
+import { S as SmartUnitBase, E as ERROR_NAN_INPUT } from './utils-C1byK7Uk.js';
+
+class SmartUnit extends SmartUnitBase {
+    constructor(units, option = {}) {
+        super(units, option);
+    }
+    // 根据输入数值获取单位和调整后的值
+    /**
+     * Gets the appropriate unit and adjusted value for the input number
+     *
+     * @param num - The input number to determine the unit for
+     * @param fractionDigits - Decimal precision configuration
+     * @returns The FormattedValue object containing the number, unit, and formatted number string
+     */
+    getUnit(num, fractionDigits = this.fractionDigits) {
+        if (Number.isNaN(num))
+            throw new Error(ERROR_NAN_INPUT);
+        const unitDigitsLen = this.unitDigits.length;
+        const isNegative = num < 0;
+        let absNum = isNegative ? -num : num;
+        let i = 0;
+        while (i < unitDigitsLen) {
+            const digit = this.unitDigits[i];
+            if (absNum < digit * this.threshold) {
+                break;
+            }
+            absNum /= digit;
+            i++;
+        }
+        const result = isNegative ? -absNum : absNum;
+        return {
+            num: result,
+            unit: this.unitNames[i],
+            numStr: this.formatNumber(result, fractionDigits),
+        };
+    }
+    // 将数字转换为字符串表示形式，并可选择配置小数位数
+    /**
+     * Formats a number as a string with unit and optional decimal place configuration
+     *
+     * @param num - The input number to format
+     * @param fractionDigits - Decimal precision configuration (defaults to instance setting)
+     *   - If a number, defines fixed decimal places
+     *   - If a string in "min-max" format, defines a range of decimal places
+     *   - If omitted, uses the instance's default decimal configuration
+     * @returns The formatted string with number and unit (e.g. "1.50KB")
+     */
+    format(num, fractionDigits = this.fractionDigits) {
+        const { numStr, unit } = this.getUnit(num, fractionDigits);
+        return this._format(numStr, unit);
+    }
+    // 根据输入数值获取链式单位数组
+    /**
+     * Gets the chain of units for the input number
+     * @param num - The input number to determine the chain for
+     * @returns An array of FormattedValue objects representing the chain of units
+     */
+    getChainUnit(num) {
+        if (Number.isNaN(num))
+            throw new Error(ERROR_NAN_INPUT);
+        const result = [];
+        if (num === 0) {
+            return [{ num: 0, unit: this.unitNames[0], numStr: '0' }];
+        }
+        const isNegative = num < 0;
+        let absNum = isNegative ? -num : num;
+        const accDigLen = this.accumulatedDigits.length;
+        for (let i = accDigLen - 1; i >= 0; i--) {
+            const accDigit = this.accumulatedDigits[i];
+            if (absNum < accDigit)
+                continue;
+            const res = Math.floor(absNum / accDigit);
+            const val = isNegative ? -res : res;
+            result.push({
+                num: val,
+                unit: this.unitNames[i + 1],
+                numStr: val.toString(),
+            });
+            absNum %= accDigit;
+            if (absNum === 0)
+                break;
+        }
+        if (absNum !== 0) {
+            const val = isNegative ? -absNum : absNum;
+            result.push({
+                num: val,
+                unit: this.unitNames[0],
+                numStr: this.formatNumber(val, this.fractionDigits),
+            });
+        }
+        return result;
+    }
+    // 将数字格式化为链式单位字符串
+    /**
+     * Formats a number as a chain of units string
+     * @param num - The input number to format
+     * @returns The formatted chain string
+     */
+    formatChain(num, separator = this.separator) {
+        const chain = this.getChainUnit(num);
+        return this._formatChain(chain, separator);
+    }
+    // 将给定数值从指定单位转换为基本单位
+    /**
+     * Converts a value from the specified unit to the base unit
+     *
+     * @param num - The number to convert
+     * @param unit - The original unit of the number
+     * @returns The converted value in base unit
+     */
+    toBase(num, unit) {
+        if (Number.isNaN(num))
+            throw new Error(ERROR_NAN_INPUT);
+        const unitDigitsLen = this.unitDigits.length;
+        let nn = num;
+        for (let i = 0; i < unitDigitsLen; i++) {
+            const digit = this.unitDigits[i];
+            if (this.unitNames[i] === unit) {
+                return nn;
+            }
+            nn *= digit;
+        }
+        if (unit === this.unitNames.at(-1)) {
+            return nn;
+        }
+        throw new Error(`Undefined unit: "${unit}".`);
+    }
+    // 将带单位的值转换为基础单位的数值
+    /**
+     * Parses a string with unit into a base unit numeric value
+     *
+     * @param str - Input string containing a number and unit
+     * @returns The value converted to base unit
+     */
+    parse(str) {
+        const { num, unit } = this.splitUnit(str);
+        return this.toBase(num, unit);
+    }
+    // 将给定数值从原单位转换为最佳单位，并可指定小数精度
+    /**
+     * Converts a value from the original unit to the optimal unit with optional decimal precision
+     *
+     * @param num - The number to convert
+     * @param unit - The original unit
+     * @param fractionDigits - Optional decimal places for formatting output
+     * @returns The converted number as a formatted string
+     */
+    fromUnitFormat(num, unit, fractionDigits) {
+        const nnum = this.toBase(num, unit);
+        return this.format(nnum, fractionDigits);
+    }
+}
+
+/*!
+ * smart-unit
+ * Copyright (c) [2026] [flycran]
+ * MIT License. See LICENSE for details.
+ */
+
+export { ERROR_NAN_INPUT, SmartUnit, SmartUnit as default };