smart-unit 2.0.0 → 2.1.0

package/dist/index.cjs

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var utils = require('./utils-DqEXot5a.js');
+var utils = require('./utils-4mK2MBi1.js');
 
 class SmartUnit extends utils.SmartUnitBase {
     constructor(units, option = {}) {
@@ -129,7 +129,7 @@ class SmartUnit extends utils.SmartUnitBase {
         }
         throw new Error(`Undefined unit: "${unit}".`);
     }
-    // 将带单位的值转换为基础单位的数值
+    // 将带单位的字符串转换为基础单位的数值
     /**
      * Parses a string with unit into a base unit numeric value
      *
@@ -140,6 +140,21 @@ class SmartUnit extends utils.SmartUnitBase {
         const { num, unit } = this.splitUnit(str);
         return this.toBase(num, unit);
     }
+    // 将带链式单位的字符串转换为基础单位的数值
+    /**
+     * Parses a string with chain units into a base unit numeric value
+     *
+     * @param str - Input string containing a number and unit
+     * @returns The value converted to base unit
+     */
+    parseChain(str, separator = this.separator) {
+        const units = this.splitChainUnit(str, separator);
+        let sum = 0;
+        for (const unit of units) {
+            sum += this.toBase(unit.num, unit.unit);
+        }
+        return sum;
+    }
     // 将给定数值从原单位转换为最佳单位，并可指定小数精度
     /**
      * Converts a value from the original unit to the optimal unit with optional decimal precision

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { S as SmartUnitBase, E as ERROR_NAN_INPUT } from './utils-C1byK7Uk.js';
+import { S as SmartUnitBase, E as ERROR_NAN_INPUT } from './utils-biRhOw5Y.js';
 
 class SmartUnit extends SmartUnitBase {
     constructor(units, option = {}) {
@@ -125,7 +125,7 @@ class SmartUnit extends SmartUnitBase {
         }
         throw new Error(`Undefined unit: "${unit}".`);
     }
-    // 将带单位的值转换为基础单位的数值
+    // 将带单位的字符串转换为基础单位的数值
     /**
      * Parses a string with unit into a base unit numeric value
      *
@@ -136,6 +136,21 @@ class SmartUnit extends SmartUnitBase {
         const { num, unit } = this.splitUnit(str);
         return this.toBase(num, unit);
     }
+    // 将带链式单位的字符串转换为基础单位的数值
+    /**
+     * Parses a string with chain units into a base unit numeric value
+     *
+     * @param str - Input string containing a number and unit
+     * @returns The value converted to base unit
+     */
+    parseChain(str, separator = this.separator) {
+        const units = this.splitChainUnit(str, separator);
+        let sum = 0;
+        for (const unit of units) {
+            sum += this.toBase(unit.num, unit.unit);
+        }
+        return sum;
+    }
     // 将给定数值从原单位转换为最佳单位，并可指定小数精度
     /**
      * Converts a value from the original unit to the optimal unit with optional decimal precision

package/dist/precision.cjs

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var DecimalConstructor = require('decimal.js');
-var utils = require('./utils-DqEXot5a.js');
+var utils = require('./utils-4mK2MBi1.js');
 
 class SmartUnitPrecision extends utils.SmartUnitBase {
     constructor(units, option = {}) {
@@ -158,6 +158,17 @@ class SmartUnitPrecision extends utils.SmartUnitBase {
             numStr,
         };
     }
+    // 从给定链式单位字符串中分离出数字部分和单位
+    /**
+     * 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
+     */
+    splitChainUnit(str, separator = this.separator) {
+        return super.splitChainUnit(str, separator).map((unit) => (Object.assign(Object.assign({}, unit), { decimal: new this.DecimalClass(unit.numStr) })));
+    }
     // 将带单位的值转换为基础单位的数值
     /**
      * Parses a string with unit into a base unit numeric value
@@ -169,6 +180,21 @@ class SmartUnitPrecision extends utils.SmartUnitBase {
         const { decimal, unit } = this.splitUnit(str);
         return this.toBase(decimal, unit);
     }
+    // 将带链式单位的字符串转换为基础单位的数值
+    /**
+     * Parses a string with chain units into a base unit numeric value
+     *
+     * @param str - Input string containing a number and unit
+     * @returns The value converted to base unit
+     */
+    parseChain(str) {
+        const units = this.splitChainUnit(str);
+        let sum = new this.DecimalClass(0);
+        for (const unit of units) {
+            sum = sum.plus(this.toBase(unit.num, unit.unit));
+        }
+        return sum;
+    }
     // 将给定数值从原单位转换为最佳单位，并可指定小数精度
     /**
      * Converts a value from the original unit to the optimal unit with optional decimal precision

package/dist/precision.mjs

@@ -1,5 +1,5 @@
 import DecimalConstructor from 'decimal.js';
-import { S as SmartUnitBase, E as ERROR_NAN_INPUT } from './utils-C1byK7Uk.js';
+import { S as SmartUnitBase, E as ERROR_NAN_INPUT } from './utils-biRhOw5Y.js';
 
 class SmartUnitPrecision extends SmartUnitBase {
     constructor(units, option = {}) {
@@ -154,6 +154,17 @@ class SmartUnitPrecision extends SmartUnitBase {
             numStr,
         };
     }
+    // 从给定链式单位字符串中分离出数字部分和单位
+    /**
+     * 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
+     */
+    splitChainUnit(str, separator = this.separator) {
+        return super.splitChainUnit(str, separator).map((unit) => (Object.assign(Object.assign({}, unit), { decimal: new this.DecimalClass(unit.numStr) })));
+    }
     // 将带单位的值转换为基础单位的数值
     /**
      * Parses a string with unit into a base unit numeric value
@@ -165,6 +176,21 @@ class SmartUnitPrecision extends SmartUnitBase {
         const { decimal, unit } = this.splitUnit(str);
         return this.toBase(decimal, unit);
     }
+    // 将带链式单位的字符串转换为基础单位的数值
+    /**
+     * Parses a string with chain units into a base unit numeric value
+     *
+     * @param str - Input string containing a number and unit
+     * @returns The value converted to base unit
+     */
+    parseChain(str) {
+        const units = this.splitChainUnit(str);
+        let sum = new this.DecimalClass(0);
+        for (const unit of units) {
+            sum = sum.plus(this.toBase(unit.num, unit.unit));
+        }
+        return sum;
+    }
     // 将给定数值从原单位转换为最佳单位，并可指定小数精度
     /**
      * Converts a value from the original unit to the optimal unit with optional decimal precision

package/dist/{SmartUnit.d.ts → src/SmartUnit.d.ts}

@@ -48,6 +48,13 @@ export declare class SmartUnit<U extends string = string> extends SmartUnitBase<
      * @returns The value converted to base unit
      */
     parse(str: string): number;
+    /**
+     * Parses a string with chain units into a base unit numeric value
+     *
+     * @param str - Input string containing a number and unit
+     * @returns The value converted to base unit
+     */
+    parseChain(str: string, separator?: string): number;
     /**
      * Converts a value from the original unit to the optimal unit with optional decimal precision
      *

package/dist/{SmartUnitBase.d.ts → src/SmartUnitBase.d.ts}

@@ -12,6 +12,7 @@ export declare abstract class SmartUnitBase<U extends string = string, D extends
     _sortedUnitNames?: U[];
     /** Sorted unit names by length for efficient lookup */
     get sortedUnitNames(): U[];
+    /** Unit conversion function */
     convert?: (str: U) => string;
     constructor(units: (U | number)[], option?: SmartUnitOptions);
     withConvert(convert: (str: U) => string): this;
@@ -28,27 +29,9 @@ export declare abstract class SmartUnitBase<U extends string = string, D extends
     abstract getUnit(num: InputNumber, fractionDigits?: FractionDigits): FormattedValue<U>;
     protected _format(numStr: string, unit: U): string;
     abstract format(num: InputNumber, 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
-     */
     abstract getChainUnit(num: InputNumber): FormattedValue<U>[];
     protected _formatChain(chain: FormattedValue<U>[], separator?: string): string;
-    /**
-     * Formats a number as a chain of units string
-     * @param num - The input number to format
-     * @returns The formatted chain string
-     */
     formatChain(num: InputNumber, 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
-     */
     abstract toBase(num: InputNumber, unit: U): D extends true ? Decimal : number;
     /**
      * Splits a string into its numeric part and unit
@@ -59,19 +42,14 @@ export declare abstract class SmartUnitBase<U extends string = string, D extends
      */
     splitUnit(str: string): FormattedValue<U>;
     /**
-     * Parses a string with unit into a base unit numeric value
+     * Splits a string into its numeric part and unit
      *
-     * @param str - Input string containing a number and unit
-     * @returns The value converted to base 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
      */
+    splitChainUnit(str: string, separator?: string): FormattedValue<U>[];
     abstract parse(str: string): D 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 fractionDigits - Optional decimal places for formatting output
-     * @returns The converted number as a formatted string
-     */
+    abstract parseChain(str: string): D extends true ? Decimal : number;
     abstract fromUnitFormat(num: InputNumber, unit: U, fractionDigits?: FractionDigits): string;
 }

package/dist/{SmartUnitPrecision.d.ts → src/SmartUnitPrecision.d.ts}

@@ -63,6 +63,14 @@ export declare class SmartUnitPrecision<U extends string = string> extends Smart
      * @throws An error if no predefined unit is matched
      */
     splitUnit(str: string): FormattedValuePrecision<U>;
+    /**
+     * 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
+     */
+    splitChainUnit(str: string, separator?: string): FormattedValuePrecision<U>[];
     /**
      * Parses a string with unit into a base unit numeric value
      *
@@ -70,6 +78,13 @@ export declare class SmartUnitPrecision<U extends string = string> extends Smart
      * @returns The value converted to base unit
      */
     parse(str: string): Decimal;
+    /**
+     * Parses a string with chain units into a base unit numeric value
+     *
+     * @param str - Input string containing a number and unit
+     * @returns The value converted to base unit
+     */
+    parseChain(str: string): Decimal;
     /**
      * Converts a value from the original unit to the optimal unit with optional decimal precision
      *

package/dist/{utils-DqEXot5a.js → utils-4mK2MBi1.js}

@@ -107,11 +107,6 @@ class SmartUnitBase {
         return chain.map(({ numStr, unit }) => this._format(numStr, unit)).join(separator);
     }
     // 将数字格式化为链式单位字符串
-    /**
-     * 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);
@@ -127,8 +122,9 @@ class SmartUnitBase {
     splitUnit(str) {
         const sortedUnits = this.sortedUnitNames;
         for (const unit of sortedUnits) {
-            if (str.endsWith(unit)) {
-                const numStr = str.slice(0, -unit.length);
+            const matchUnit = this.convert ? this.convert(unit) : unit;
+            if (str.endsWith(matchUnit)) {
+                const numStr = str.slice(0, -matchUnit.length);
                 const num = +numStr;
                 if (Number.isNaN(num))
                     throw new Error(`Invalid number: "${numStr}".`);
@@ -141,6 +137,42 @@ class SmartUnitBase {
         }
         throw new Error(`Undefined unit: "${str}".`);
     }
+    // 从给定链式单位字符串中分离出数字部分和单位
+    /**
+     * 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
+     */
+    splitChainUnit(str, separator = this.separator) {
+        const results = [];
+        const sortedUnits = this.sortedUnitNames;
+        const strLen = str.length;
+        let start = 0;
+        for (let i = 0; i < strLen; i++) {
+            for (const unit of sortedUnits) {
+                const matchUnit = this.convert ? this.convert(unit) : unit;
+                if (str.slice(i, i + matchUnit.length) === matchUnit) {
+                    const numStr = str.slice(start, i);
+                    const num = +numStr;
+                    if (Number.isNaN(num))
+                        throw new Error(`Invalid number: "${numStr}".`);
+                    results.push({
+                        num,
+                        unit,
+                        numStr,
+                    });
+                    i += matchUnit.length + separator.length;
+                    start = i;
+                    break;
+                }
+            }
+        }
+        if (results.length > 0)
+            return results;
+        throw new Error(`Undefined unit: "${str}".`);
+    }
 }
 
 const ERROR_NAN_INPUT = 'Accepting NaN as an argument may be unintentional and could lead to invalid results.';

package/dist/{utils-C1byK7Uk.js → utils-biRhOw5Y.js}

@@ -105,11 +105,6 @@ class SmartUnitBase {
         return chain.map(({ numStr, unit }) => this._format(numStr, unit)).join(separator);
     }
     // 将数字格式化为链式单位字符串
-    /**
-     * 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);
@@ -125,8 +120,9 @@ class SmartUnitBase {
     splitUnit(str) {
         const sortedUnits = this.sortedUnitNames;
         for (const unit of sortedUnits) {
-            if (str.endsWith(unit)) {
-                const numStr = str.slice(0, -unit.length);
+            const matchUnit = this.convert ? this.convert(unit) : unit;
+            if (str.endsWith(matchUnit)) {
+                const numStr = str.slice(0, -matchUnit.length);
                 const num = +numStr;
                 if (Number.isNaN(num))
                     throw new Error(`Invalid number: "${numStr}".`);
@@ -139,6 +135,42 @@ class SmartUnitBase {
         }
         throw new Error(`Undefined unit: "${str}".`);
     }
+    // 从给定链式单位字符串中分离出数字部分和单位
+    /**
+     * 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
+     */
+    splitChainUnit(str, separator = this.separator) {
+        const results = [];
+        const sortedUnits = this.sortedUnitNames;
+        const strLen = str.length;
+        let start = 0;
+        for (let i = 0; i < strLen; i++) {
+            for (const unit of sortedUnits) {
+                const matchUnit = this.convert ? this.convert(unit) : unit;
+                if (str.slice(i, i + matchUnit.length) === matchUnit) {
+                    const numStr = str.slice(start, i);
+                    const num = +numStr;
+                    if (Number.isNaN(num))
+                        throw new Error(`Invalid number: "${numStr}".`);
+                    results.push({
+                        num,
+                        unit,
+                        numStr,
+                    });
+                    i += matchUnit.length + separator.length;
+                    start = i;
+                    break;
+                }
+            }
+        }
+        if (results.length > 0)
+            return results;
+        throw new Error(`Undefined unit: "${str}".`);
+    }
 }
 
 const ERROR_NAN_INPUT = 'Accepting NaN as an argument may be unintentional and could lead to invalid results.';

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "smart-unit",
-  "version": "2.0.0",
+  "type": "module",
+  "version": "2.1.0",
   "author": "flycran",
   "scripts": {
     "build": "rollup -c",
     "test": "vitest run",
     "test:watch": "vitest",
+    "test:performance": "node scripts/src/performance.ts",
     "format": "biome format --fix .",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",