unitmaster 1.0.0 → 1.2.0

package/README.md

@@ -6,7 +6,7 @@ TypeScript 기반의 강력하고 유연한 단위 변환 라이브러리입니
 ## 설치 (Installation)
 
 ```bash
-npm install unitconvert
+npm install unitmaster
 ```
 
 ## 주요 기능 (Features)
@@ -24,7 +24,7 @@ npm install unitconvert
 Byte, KB, MB, GB, TB, PB, EB, ZB, YB 등을 지원합니다. (1024 배수 기준)
 
 ```typescript
-import { ComputerCapacityConverter } from 'unitconvert';
+import { ComputerCapacityConverter } from 'unitmaster';
 
 const converter = new ComputerCapacityConverter();
 
@@ -36,8 +36,8 @@ console.log(converter.convertTo(1024, 'Byte', 'KB')); // 1
 console.log(converter.convertTo(1, 'MB', 'Byte')); // 1048576
 
 // 2. 최적 단위 자동 포맷팅
-console.log(converter.formatBest(1048576)); // "1 MB"
-console.log(converter.formatBest(2048));    // "2 KB"
+console.log(converter.formatBest(1048576)); // { value: 1, unit: 'MB' }
+console.log(converter.formatBest(2048));    // { value: 2, unit: 'KB' }
 ```
 
 ### 2. 거리 변환 (Distance)
@@ -45,7 +45,7 @@ console.log(converter.formatBest(2048));    // "2 KB"
 mm, cm(10), m(100), km(1000) 단위를 지원합니다.
 
 ```typescript
-import { DistanceConverter } from 'unitconvert';
+import { DistanceConverter } from 'unitmaster';
 
 const distConverter = new DistanceConverter();
 
@@ -53,7 +53,8 @@ const distConverter = new DistanceConverter();
 console.log(distConverter.convertTo(1, 'km', 'm')); // 1000
 
 // 100 cm -> 1 m
-console.log(distConverter.formatBest(100, undefined)); // "10 cm" 가 아니라 최적 단위인 "1 m"로 변환 (로직에 따라 다름)
+// 100 cm -> 1 m
+console.log(distConverter.formatBest(100, undefined)); // { value: 1, unit: 'm' }
 // formatBest는 값이 1 이상이 되는 가장 큰 단위를 찾습니다.
 ```
 
@@ -63,10 +64,10 @@ console.log(distConverter.formatBest(100, undefined)); // "10 cm" 가 아니라
 - **PowerUsageConverter**: Wh, kWh, MWh, GWh, TWh (1000 배수)
 
 ```typescript
-import { PowerCapacityConverter } from 'unitconvert';
+import { PowerCapacityConverter } from 'unitmaster';
 
 const powerConverter = new PowerCapacityConverter();
-console.log(powerConverter.formatBest(1500)); // "1.5 kW" (기본 단위 W 기준)
+console.log(powerConverter.formatBest(1500)); // { value: 1.5, unit: 'kW' } (기본 단위 W 기준)
 ```
 
 ## 고급 사용법 (Advanced)
@@ -86,7 +87,7 @@ converter.registerUnit([{ unit: 'BB', unitValue: 1024 }]);
 `UnitConverter`를 상속받아 새로운 도메인의 변환기를 만들 수 있습니다.
 
 ```typescript
-import { UnitConverter } from 'unitconvert';
+import { UnitConverter } from 'unitmaster';
 
 class TimeConverter extends UnitConverter {
     constructor() {
@@ -101,7 +102,7 @@ class TimeConverter extends UnitConverter {
 }
 
 const timeConverter = new TimeConverter();
-console.log(timeConverter.formatBest(3600)); // "1 Hour"
+console.log(timeConverter.formatBest(3600)); // { value: 1, unit: 'Hour' }
 ```
 
 ### 복합 입력값 처리

package/dist/UnitConverter.d.ts

@@ -2,9 +2,9 @@
  * @file UnitConverter.ts
  * @author 김영찬
  * @since 2026-01-20
- * @description 단위 변환 기능 및 최적 단위 표시 기능을 제공하는 메인 클래스입니다.
+ * @description 단위 변환 기능 및 최적 단위 표시 기능을 제공하는 메인 클래스입니다. (상대적 배수 로직 적용)
  */
-import { UnitDefinition, ComplexValueInput } from './types';
+import { UnitDefinition, ComplexValueInput, UnitOutput } from './types';
 /**
  * 단위 변환기 클래스
  */
@@ -12,18 +12,18 @@ export declare class UnitConverter {
     private units;
     /**
      * 생성자
-     * @description 기본 컴퓨터 용량 단위(Byte, KB, MB, GB, TB, PB)를 초기화합니다.
+     * @description 빈 단위 목록으로 초기화합니다.
      */
     constructor();
-    /**
-     * 기본 컴퓨터 용량 단위 등록
-     */
-    private registerDefaultUnits;
     /**
      * 단위 등록 (Rule 5)
-     * @param units 단위 정의 목록
+     * @param units 단위 정의 목록 (기존 단위 목록 뒤에 추가됨)
      */
     registerUnit(units: UnitDefinition[]): void;
+    /**
+     * 단위 목록을 절대 값(Base 기준)으로 변환하여 반환
+     */
+    private getAbsoluteUnits;
     /**
      * 특정 단위로 값 변환 (Rule 1, Rule 4)
      * @param value 값
@@ -36,16 +36,12 @@ export declare class UnitConverter {
      * 입력 값을 받아 최적의 단위로 변환 (Rule 1, Rule 2, Rule 3)
      * @param input 복합 입력 값 ({value, unit[]}) 또는 단순 값
      * @param fixedUnits 사용할 단위 목록 (없으면 등록된 단위 사용)
-     * @returns 변환된 문자열 (예: "100 MB")
-     */
-    formatBest(input: number, fixedUnits?: UnitDefinition[]): string;
-    formatBest(input: ComplexValueInput): string;
-    /**
-     * 단위 정의 검색
+     * @returns 변환된 결과 객체 { value, unit }
      */
-    private findUnit;
+    formatBest(input: number, fixedUnits?: UnitDefinition[]): UnitOutput;
+    formatBest(input: ComplexValueInput): UnitOutput;
     /**
-     * 현재 등록된 단위 목록 반환
+     * 현재 등록된 단위 목록 반환 (원본, 상대적 값 포함)
      */
     getUnits(): UnitDefinition[];
 }

package/dist/UnitConverter.js

@@ -3,7 +3,7 @@
  * @file UnitConverter.ts
  * @author 김영찬
  * @since 2026-01-20
- * @description 단위 변환 기능 및 최적 단위 표시 기능을 제공하는 메인 클래스입니다.
+ * @description 단위 변환 기능 및 최적 단위 표시 기능을 제공하는 메인 클래스입니다. (상대적 배수 로직 적용)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnitConverter = void 0;
@@ -13,33 +13,37 @@ exports.UnitConverter = void 0;
 class UnitConverter {
     /**
      * 생성자
-     * @description 기본 컴퓨터 용량 단위(Byte, KB, MB, GB, TB, PB)를 초기화합니다.
+     * @description 빈 단위 목록으로 초기화합니다.
      */
     constructor() {
         this.units = [];
-        this.registerDefaultUnits();
-    }
-    /**
-     * 기본 컴퓨터 용량 단위 등록
-     */
-    registerDefaultUnits() {
-        this.units = [
-            { unit: 'Byte', unitValue: 1 },
-            { unit: 'KB', unitValue: 1024 },
-            { unit: 'MB', unitValue: 1024 * 1024 },
-            { unit: 'GB', unitValue: 1024 * 1024 * 1024 },
-            { unit: 'TB', unitValue: 1024 * 1024 * 1024 * 1024 },
-            { unit: 'PB', unitValue: 1024 * 1024 * 1024 * 1024 * 1024 }
-        ];
+        // 기본 단위 없음 (서브 클래스 또는 registerUnit으로 등록)
     }
     /**
      * 단위 등록 (Rule 5)
-     * @param units 단위 정의 목록
+     * @param units 단위 정의 목록 (기존 단위 목록 뒤에 추가됨)
      */
     registerUnit(units) {
         this.units = [...this.units, ...units];
-        // unitValue 기준으로 오름차순 정렬 (계산 편의성)
-        this.units.sort((a, b) => a.unitValue - b.unitValue);
+        // 정렬하지 않음 (순서가 계산 로직에 중요함)
+    }
+    /**
+     * 단위 목록을 절대 값(Base 기준)으로 변환하여 반환
+     */
+    getAbsoluteUnits(units) {
+        let currentMultiplier = 1;
+        return units.map((u, index) => {
+            if (index === 0) {
+                currentMultiplier = u.unitValue;
+            }
+            else {
+                currentMultiplier *= u.unitValue;
+            }
+            return {
+                unit: u.unit,
+                unitValue: currentMultiplier
+            };
+        });
     }
     /**
      * 특정 단위로 값 변환 (Rule 1, Rule 4)
@@ -49,67 +53,54 @@ class UnitConverter {
      * @returns 변환된 값
      */
     convertTo(value, fromUnit, toUnit) {
-        const fromDef = this.findUnit(fromUnit);
-        const toDef = this.findUnit(toUnit);
+        const absoluteUnits = this.getAbsoluteUnits(this.units);
+        const fromDef = absoluteUnits.find(u => u.unit === fromUnit);
+        const toDef = absoluteUnits.find(u => u.unit === toUnit);
         if (!fromDef || !toDef) {
             throw new Error(`Unit not found: ${!fromDef ? fromUnit : toUnit}`);
         }
-        // 기본 단위 값으로 변환 후 목표 단위로 변환
-        // 예: 1 KB (1024) -> MB (1024*1024)
-        // 1 * 1024 / (1024*1024) = 0.0009765625
         const baseValue = value * fromDef.unitValue;
         return baseValue / toDef.unitValue;
     }
     formatBest(input, fixedUnits) {
         let value;
-        let unitDefs;
+        let originalUnitDefs;
         if (typeof input === 'object' && 'unit' in input) {
-            // Rule 2 Case
-            // 입력값은 기본 단위(unitValue:1 또는 가장 작은 단위) 기준이라고 가정하거나,
-            // 아니면 입력 구조에 대한 명확한 정의가 필요함.
-            // 여기서는 입력된 value가 제공된 unit[0] (혹은 unitValue=1)이 아니라,
-            // 제공된 unit 리스트를 '사용할 단위 체계'로 보고, 
-            // value는 그 체계의 가장 작은 단위(혹은 기준 값)라고 가정함.
-            // *주의*: 요구사항의 예시가 모호하므로, 값은 Base Unit 기준이라고 가정.
             value = input.value;
-            unitDefs = input.unit;
-            // 정렬
-            unitDefs.sort((a, b) => a.unitValue - b.unitValue);
+            originalUnitDefs = input.unit;
         }
         else {
             value = input;
-            unitDefs = fixedUnits || this.units;
+            originalUnitDefs = fixedUnits || this.units;
+        }
+        if (originalUnitDefs.length === 0) {
+            return { value, unit: '' };
         }
-        if (unitDefs.length === 0)
-            return `${value}`;
-        // 가장 큰 단위부터 확인하여 값이 >= 1 인지 확인 (혹은 가장 적절한 단위)
-        // 오름차순 정렬되어 있다고 가정
-        // 예: 1000 Byte -> Byte (1000 >= 1)
-        // 1024 Byte -> KB (1024 >= 1024) => 1 KB
-        // 뒤(큰 단위)에서부터 탐색
-        for (let i = unitDefs.length - 1; i >= 0; i--) {
-            const unit = unitDefs[i];
-            if (value >= unit.unitValue) {
+        // 절대 값으로 변환하여 계산
+        const absoluteUnits = this.getAbsoluteUnits(originalUnitDefs);
+        // 가장 큰 단위부터 확인
+        for (let i = absoluteUnits.length - 1; i >= 0; i--) {
+            const unit = absoluteUnits[i];
+            // 값이 해당 단위의 '단위 값'보다 크거나 같으면 사용
+            // 단, 절대값 기준
+            if (Math.abs(value) >= unit.unitValue) {
                 const converted = value / unit.unitValue;
-                // 정수로 딱 떨어지거나, 소수점 2자리까지 표시
-                const formatted = Number.isInteger(converted) ? converted : converted.toFixed(2);
-                return `${formatted} ${unit.unit}`;
+                const formattedValue = Number.isInteger(converted)
+                    ? converted
+                    : parseFloat(converted.toFixed(2));
+                return { value: formattedValue, unit: unit.unit };
             }
         }
-        // 가장 작은 단위보다도 작을 경우, 가장 작은 단위로 표시
-        const smallest = unitDefs[0];
+        // 가장 작은 단위보다도 작을 경우 (가장 작은 단위로 표시)
+        const smallest = absoluteUnits[0];
         const converted = value / smallest.unitValue;
-        const formatted = Number.isInteger(converted) ? converted : converted.toFixed(2);
-        return `${formatted} ${smallest.unit}`;
-    }
-    /**
-     * 단위 정의 검색
-     */
-    findUnit(unitName) {
-        return this.units.find(u => u.unit === unitName);
+        const formattedValue = Number.isInteger(converted)
+            ? converted
+            : parseFloat(converted.toFixed(2));
+        return { value: formattedValue, unit: smallest.unit };
     }
     /**
-     * 현재 등록된 단위 목록 반환
+     * 현재 등록된 단위 목록 반환 (원본, 상대적 값 포함)
      */
     getUnits() {
         return this.units;

package/dist/converters/ComputerCapacityConverter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file ComputerCapacityConverter.ts
+ * @author 김영찬
+ * @since 2026-01-20
+ * @description 컴퓨터 용량 단위 변환기 구현체
+ */
+import { UnitConverter } from '../UnitConverter';
+export declare class ComputerCapacityConverter extends UnitConverter {
+    constructor();
+}

package/dist/converters/ComputerCapacityConverter.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * @file ComputerCapacityConverter.ts
+ * @author 김영찬
+ * @since 2026-01-20
+ * @description 컴퓨터 용량 단위 변환기 구현체
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComputerCapacityConverter = void 0;
+const UnitConverter_1 = require("../UnitConverter");
+class ComputerCapacityConverter extends UnitConverter_1.UnitConverter {
+    constructor() {
+        super();
+        this.registerUnit([
+            { unit: 'Byte', unitValue: 1 },
+            { unit: 'KB', unitValue: 1024 },
+            { unit: 'MB', unitValue: 1024 },
+            { unit: 'GB', unitValue: 1024 },
+            { unit: 'TB', unitValue: 1024 },
+            { unit: 'PB', unitValue: 1024 },
+            { unit: 'EB', unitValue: 1024 },
+            { unit: 'ZB', unitValue: 1024 },
+            { unit: 'YB', unitValue: 1024 }
+        ]);
+    }
+}
+exports.ComputerCapacityConverter = ComputerCapacityConverter;

package/dist/converters/DistanceConverter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file DistanceConverter.ts
+ * @author 김영찬
+ * @since 2026-01-20
+ * @description 거리(Distance) 단위 변환기 (mm, cm, m, km)
+ */
+import { UnitConverter } from '../UnitConverter';
+export declare class DistanceConverter extends UnitConverter {
+    constructor();
+}

package/dist/converters/DistanceConverter.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * @file DistanceConverter.ts
+ * @author 김영찬
+ * @since 2026-01-20
+ * @description 거리(Distance) 단위 변환기 (mm, cm, m, km)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistanceConverter = void 0;
+const UnitConverter_1 = require("../UnitConverter");
+class DistanceConverter extends UnitConverter_1.UnitConverter {
+    constructor() {
+        super();
+        this.registerUnit([
+            { unit: 'mm', unitValue: 1 },
+            { unit: 'cm', unitValue: 10 }, // 1 cm = 10 mm
+            { unit: 'm', unitValue: 100 }, // 1 m = 100 cm
+            { unit: 'km', unitValue: 1000 } // 1 km = 1000 m
+        ]);
+    }
+}
+exports.DistanceConverter = DistanceConverter;

package/dist/converters/PowerCapacityConverter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file PowerCapacityConverter.ts
+ * @author 김영찬
+ * @since 2026-01-20
+ * @description 전력 용량(Power Capacity) 단위 변환기 (W, kW 등)
+ */
+import { UnitConverter } from '../UnitConverter';
+export declare class PowerCapacityConverter extends UnitConverter {
+    constructor();
+}

package/dist/converters/PowerCapacityConverter.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * @file PowerCapacityConverter.ts
+ * @author 김영찬
+ * @since 2026-01-20
+ * @description 전력 용량(Power Capacity) 단위 변환기 (W, kW 등)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PowerCapacityConverter = void 0;
+const UnitConverter_1 = require("../UnitConverter");
+class PowerCapacityConverter extends UnitConverter_1.UnitConverter {
+    constructor() {
+        super();
+        this.registerUnit([
+            { unit: 'W', unitValue: 1 },
+            { unit: 'kW', unitValue: 1000 },
+            { unit: 'MW', unitValue: 1000 },
+            { unit: 'GW', unitValue: 1000 },
+            { unit: 'TW', unitValue: 1000 }
+        ]);
+    }
+}
+exports.PowerCapacityConverter = PowerCapacityConverter;

package/dist/converters/PowerUsageConverter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file PowerUsageConverter.ts
+ * @author 김영찬
+ * @since 2026-01-20
+ * @description 전력 사용량(Power Usage) 단위 변환기 (Wh, kWh 등)
+ */
+import { UnitConverter } from '../UnitConverter';
+export declare class PowerUsageConverter extends UnitConverter {
+    constructor();
+}

package/dist/converters/PowerUsageConverter.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * @file PowerUsageConverter.ts
+ * @author 김영찬
+ * @since 2026-01-20
+ * @description 전력 사용량(Power Usage) 단위 변환기 (Wh, kWh 등)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PowerUsageConverter = void 0;
+const UnitConverter_1 = require("../UnitConverter");
+class PowerUsageConverter extends UnitConverter_1.UnitConverter {
+    constructor() {
+        super();
+        this.registerUnit([
+            { unit: 'Wh', unitValue: 1 },
+            { unit: 'kWh', unitValue: 1000 },
+            { unit: 'MWh', unitValue: 1000 },
+            { unit: 'GWh', unitValue: 1000 },
+            { unit: 'TWh', unitValue: 1000 }
+        ]);
+    }
+}
+exports.PowerUsageConverter = PowerUsageConverter;

package/dist/index.d.ts

@@ -6,3 +6,7 @@
  */
 export * from './types';
 export * from './UnitConverter';
+export * from './converters/ComputerCapacityConverter';
+export * from './converters/PowerCapacityConverter';
+export * from './converters/PowerUsageConverter';
+export * from './converters/DistanceConverter';

package/dist/index.js

@@ -22,3 +22,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types"), exports);
 __exportStar(require("./UnitConverter"), exports);
+__exportStar(require("./converters/ComputerCapacityConverter"), exports);
+__exportStar(require("./converters/PowerCapacityConverter"), exports);
+__exportStar(require("./converters/PowerUsageConverter"), exports);
+__exportStar(require("./converters/DistanceConverter"), exports);

package/dist/types.d.ts

@@ -14,7 +14,7 @@ export interface UnitDefinition {
      */
     unit: string;
     /**
-     * 단위 값 (기준 단위 대비 배수)
+     * 단위 값 (이전 단위 기준 배수, 첫 번째 단위는 절대 값)
      */
     unitValue: number;
 }
@@ -32,3 +32,17 @@ export interface ComplexValueInput {
      */
     unit: UnitDefinition[];
 }
+/**
+ * 단위 변환 출력 구조
+ * @interface UnitOutput
+ */
+export interface UnitOutput {
+    /**
+     * 변환된 값
+     */
+    value: number;
+    /**
+     * 단위 명칭
+     */
+    unit: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unitmaster",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Unit Converter Library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,8 +8,9 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc",
-    "test": "mocha -r ts-node/register test/**/*.test.ts"
+    "build": "npm version minor && tsc",
+    "test": "mocha -r ts-node/register test/**/*.test.ts",
+    "publish": "npm version minor && npm publish"
   },
   "keywords": [
     "unit",