@gracefullight/saju 0.1.1 → 0.3.0

package/README.md

@@ -15,7 +15,13 @@
 - **태양시 보정** - 경도 기반 평균 태양시 조정 옵션
 - **트리쉐이킹 지원** - 필요한 것만 import
 - **완전한 타입 지원** - TypeScript 정의 완비
-- **풍부한 테스트** - 85개 이상 테스트, 91% 이상 커버리지
+- **풍부한 테스트** - 180개 이상 테스트, 91% 이상 커버리지
+- **십신 분석** - 장간(藏干)을 포함한 상세 십신 및 오행 분포 분석
+- **신강/신약 판정** - 월령 득령(得令), 통근(通根), 투간(透干), 본중여기(本中餘氣) 가중치를 고려한 9단계 신강도 분석
+- **합충형파해** - 천간합, 육합, 삼합, 방합 및 충, 해, 형, 파 분석. 합(合)과 화(化) 성립 조건 분리 표기
+- **대운/세운 계산** - 절기(節氣) 기반 정확한 기운(起運) 계산, 성별 및 연간 음양을 고려한 대운 및 연도별 세운 계산
+- **용신 추출** - 격국(格局), 억부(抑扶), 조후(調候) 순서로 용신 추천 및 개운법 가이드
+- **절기 분석** - 현재/다음 절기 정보 및 경과일 계산
 
 ## 사주(四柱)란?
 
@@ -56,6 +62,39 @@ pnpm add date-fns date-fns-tz
 
 ## 빠른 시작
 
+```typescript
+import { DateTime } from "luxon";
+import { createLuxonAdapter } from "@gracefullight/saju/adapters/luxon";
+import { getSaju, STANDARD_PRESET } from "@gracefullight/saju";
+
+const adapter = await createLuxonAdapter();
+
+const birthDateTime = DateTime.fromObject(
+  { year: 2000, month: 1, day: 1, hour: 18, minute: 0 },
+  { zone: "Asia/Seoul" }
+);
+
+// getSaju: 사주 팔자, 십신, 신강약, 합충, 용신, 절기, 대운, 세운을 한 번에 계산
+const result = getSaju(adapter, birthDateTime, {
+  longitudeDeg: 126.9778,
+  gender: "male",  // 필수: 대운 계산에 필요
+  preset: STANDARD_PRESET,
+  currentYear: 2024,  // 세운 기본 범위 계산용 (선택)
+  yearlyLuckRange: { from: 2024, to: 2030 },  // 세운 범위 직접 지정 (선택)
+});
+
+console.log(result.pillars);     // { year: "己卯", month: "丙子", ... }
+console.log(result.tenGods);     // 십신 및 장간 분석
+console.log(result.strength);    // 신강/신약 판정 (예: "신약")
+console.log(result.relations);   // 합충형파해 분석
+console.log(result.yongShen);    // 용신 및 개운법
+console.log(result.solarTerms);  // 절기 정보 (현재/다음 절기, 경과일)
+console.log(result.majorLuck);   // 대운 정보
+console.log(result.yearlyLuck);  // 세운 정보
+```
+
+### 사주 팔자만 계산하기
+
 ```typescript
 import { DateTime } from "luxon";
 import { createLuxonAdapter } from "@gracefullight/saju/adapters/luxon";
@@ -74,18 +113,6 @@ const result = getFourPillars(adapter, birthDateTime, {
 });
 
 console.log(result);
-// {
-//   year: "己卯",    // 연주 (천간 + 지지)
-//   month: "丙子",   // 월주
-//   day: "庚辰",     // 일주
-//   hour: "辛酉",    // 시주
-//   meta: {
-//     solarYear: 1999,
-//     sunLonDeg: 280.9,
-//     effectiveDayDate: { year: 2000, month: 1, day: 1 },
-//     adjustedHour: 18
-//   }
-// }
 ```
 
 ## 사용법
@@ -126,7 +153,7 @@ import { getFourPillars, STANDARD_PRESET } from "@gracefullight/saju";
 const adapter = await createDateFnsAdapter();
 
 const dt = {
-  date: new Date(1992, 9, 12, 19, 16), // 주의: 월은 0부터 시작
+  date: new Date(1985, 4, 15, 14, 30), // 주의: 월은 0부터 시작
   timeZone: "Asia/Seoul",
 };
 
@@ -200,12 +227,27 @@ const myAdapter: DateAdapter<MyDateType> = {
 }
 ```
 
-#### 사용 중단된 별칭
-- `presetA` → `STANDARD_PRESET` 사용 권장
-- `presetB` → `TRADITIONAL_PRESET` 사용 권장
-
 ### 핵심 함수
 
+#### `getSaju(adapter, datetime, options)`
+
+사주 분석의 모든 결과(팔자, 십신, 신강약, 합충, 용신, 대운)를 한 번에 계산합니다.
+
+```typescript
+function getSaju<T>(
+  adapter: DateAdapter<T>,
+  dtLocal: T,
+  options: {
+    longitudeDeg: number;
+    gender: "male" | "female";  // 필수
+    tzOffsetHours?: number;
+    preset?: typeof STANDARD_PRESET;
+    currentYear?: number;  // 세운 기본 범위 계산용
+    yearlyLuckRange?: { from: number; to: number };  // 세운 범위 직접 지정
+  }
+): SajuResult;
+```
+
 #### `getFourPillars(adapter, datetime, options)`
 
 네 기둥(연주, 월주, 일주, 시주) 모두 계산
@@ -228,11 +270,17 @@ function getFourPillars<T>(
   month: string;
   day: string;
   hour: string;
+  lunar: {
+    lunarYear: number;
+    lunarMonth: number;
+    lunarDay: number;
+    isLeapMonth: boolean;
+  };
   meta: {
-    solarYear: number;
+    solarYearUsed: number;
     sunLonDeg: number;
     effectiveDayDate: { year: number; month: number; day: number };
-    adjustedHour: number;
+    adjustedDtForHour: string;
   };
 }
 ```
@@ -245,7 +293,7 @@ function getFourPillars<T>(
   - `preset`: 설정 프리셋 (`STANDARD_PRESET` 또는 `TRADITIONAL_PRESET` 사용)
   - `tzOffsetHours`: 타임존 오프셋(시간 단위), 선택사항 (기본값: 9, KST)
 
-**반환값:** 연월일시 기둥과 메타데이터를 포함한 객체
+**반환값:** 연월일시 기둥, 음력 날짜, 메타데이터를 포함한 객체
 
 #### `yearPillar(adapter, datetime)`
 
@@ -291,6 +339,58 @@ function dayPillarFromDate(date: {
 }
 ```
 
+### 음력 변환 함수
+
+#### `getLunarDate(year, month, day)`
+
+양력(그레고리력) 날짜를 음력 날짜로 변환
+
+```typescript
+function getLunarDate(
+  year: number,
+  month: number,
+  day: number
+): {
+  lunarYear: number;
+  lunarMonth: number;
+  lunarDay: number;
+  isLeapMonth: boolean;
+}
+```
+
+**예시:**
+```typescript
+import { getLunarDate } from "@gracefullight/saju";
+
+const lunar = getLunarDate(2000, 1, 1);
+// { lunarYear: 1999, lunarMonth: 11, lunarDay: 25, isLeapMonth: false }
+```
+
+#### `getSolarDate(lunarYear, lunarMonth, lunarDay, isLeapMonth)`
+
+음력 날짜를 양력(그레고리력) 날짜로 변환
+
+```typescript
+function getSolarDate(
+  lunarYear: number,
+  lunarMonth: number,
+  lunarDay: number,
+  isLeapMonth?: boolean
+): {
+  year: number;
+  month: number;
+  day: number;
+}
+```
+
+**예시:**
+```typescript
+import { getSolarDate } from "@gracefullight/saju";
+
+const solar = getSolarDate(1999, 11, 25, false);
+// { year: 2000, month: 1, day: 1 }
+```
+
 #### `hourPillar(adapter, datetime, options)`
 
 태양시 보정 옵션과 함께 시주만 계산
@@ -361,6 +461,109 @@ function effectiveDayDate<T>(
 }
 ```
 
+### 분석 함수
+
+#### `analyzeTenGods(year, month, day, hour)`
+
+사주 팔자의 십신과 지장간을 분석합니다.
+
+```typescript
+function analyzeTenGods(
+  year: string,
+  month: string,
+  day: string,
+  hour: string
+): FourPillarsTenGods;
+```
+
+#### `analyzeStrength(year, month, day, hour)`
+
+사주의 신강/신약을 9단계로 판정합니다.
+
+```typescript
+function analyzeStrength(
+  year: string,
+  month: string,
+  day: string,
+  hour: string
+): StrengthResult;
+```
+
+#### `analyzeRelations(year, month, day, hour)`
+
+천간과 지지의 합, 충, 형, 파, 해 관계를 분석합니다.
+
+```typescript
+function analyzeRelations(
+  year: string,
+  month: string,
+  day: string,
+  hour: string
+): RelationsResult;
+```
+
+#### `calculateMajorLuck(adapter, datetime, gender, year, month)`
+
+대운의 흐름과 시작 연령을 계산합니다.
+
+```typescript
+function calculateMajorLuck<T>(
+  adapter: DateAdapter<T>,
+  birthDateTime: T,
+  gender: "male" | "female",
+  yearPillar: string,
+  monthPillar: string
+): MajorLuckResult;
+```
+
+#### `analyzeYongShen(year, month, day, hour)`
+
+억부와 조후를 고려하여 용신과 희신을 추출합니다.
+
+```typescript
+function analyzeYongShen(
+  year: string,
+  month: string,
+  day: string,
+  hour: string
+): YongShenResult;
+```
+
+#### `analyzeSolarTerms(adapter, datetime)`
+
+현재 및 다음 절기 정보와 경과일을 계산합니다.
+
+```typescript
+function analyzeSolarTerms<T>(
+  adapter: DateAdapter<T>,
+  dtLocal: T
+): SolarTermInfo;
+```
+
+**반환값:**
+```typescript
+{
+  current: { name: "소한", hanja: "小寒", longitude: 285 },
+  currentDate: { year: 2024, month: 1, day: 6, hour: 5, minute: 30 },
+  daysSinceCurrent: 5,
+  next: { name: "대한", hanja: "大寒", longitude: 300 },
+  nextDate: { year: 2024, month: 1, day: 20, hour: 12, minute: 15 },
+  daysUntilNext: 10
+}
+```
+
+#### `getSolarTermsForYear(adapter, year, timezone)`
+
+특정 연도의 24절기 날짜를 모두 계산합니다.
+
+```typescript
+function getSolarTermsForYear<T>(
+  adapter: DateAdapter<T>,
+  year: number,
+  timezone: string
+): Array<{ term: SolarTerm; date: {...} }>;
+```
+
 ## 고급 사용법
 
 ### 태양시 보정
@@ -435,6 +638,85 @@ const result = getFourPillars(adapter, dt, {
 
 ## 예제
 
+### 대운과 세운 계산
+
+```typescript
+const saju = getSaju(adapter, dt, {
+  longitudeDeg: 126.9778,
+  gender: "female",
+  yearlyLuckRange: { from: 2024, to: 2030 }
+});
+
+// 대운 확인
+console.log(saju.majorLuck.pillars); // 대운 목록
+console.log(saju.majorLuck.startAge); // 대운 시작 나이
+
+// 세운 확인
+saju.yearlyLuck.forEach(luck => {
+  console.log(`${luck.year}년(${luck.pillar}): ${luck.age}세`);
+});
+```
+
+### 절기 정보 확인
+
+```typescript
+const saju = getSaju(adapter, dt, {
+  longitudeDeg: 126.9778,
+  gender: "male",
+});
+
+// 현재 절기
+console.log(saju.solarTerms.current.name);  // "소한"
+console.log(saju.solarTerms.current.hanja); // "小寒"
+console.log(saju.solarTerms.daysSinceCurrent); // 5 (절기 경과일)
+
+// 다음 절기
+console.log(saju.solarTerms.next.name);     // "대한"
+console.log(saju.solarTerms.daysUntilNext); // 10 (다음 절기까지 남은 일)
+
+// 절기 시작 날짜
+console.log(saju.solarTerms.currentDate);   // { year: 2024, month: 1, day: 6, ... }
+console.log(saju.solarTerms.nextDate);      // { year: 2024, month: 1, day: 20, ... }
+```
+
+### 십신 및 오행 분석
+
+```typescript
+import { analyzeTenGods, countElements } from "@gracefullight/saju";
+
+const tenGods = analyzeTenGods("己卯", "丙子", "辛巳", "戊戌");
+console.log(tenGods.dayMaster); // "辛"
+
+const elements = countElements(tenGods);
+console.log(elements); // { wood: 1, fire: 1, earth: 3, metal: 1, water: 2 }
+```
+
+### 신강약 및 용신 분석
+
+```typescript
+import { analyzeStrength, analyzeYongShen, getElementRecommendations } from "@gracefullight/saju";
+
+const strength = analyzeStrength("己卯", "丙子", "辛巳", "戊戌");
+console.log(strength.level); // "신약"
+
+const yongShen = analyzeYongShen("己卯", "丙子", "辛巳", "戊戌");
+console.log(yongShen.primary); // 용신 오행 (예: "earth")
+
+const tips = getElementRecommendations(yongShen);
+console.log(tips.colors); // 행운의 색상
+```
+
+### 합충형파해 분석
+
+```typescript
+import { analyzeRelations } from "@gracefullight/saju";
+
+const relations = analyzeRelations("己卯", "丙子", "辛巳", "戊戌");
+relations.clashes.forEach(c => {
+  console.log(`${c.positions[0]}-${c.positions[1]} 지지 충: ${c.pair[0]}-${c.pair[1]}`);
+});
+```
+
 ### 다양한 타임존에서 계산
 
 ```typescript
@@ -445,7 +727,7 @@ const adapter = await createLuxonAdapter();
 
 // 뉴욕 출생 시간
 const nyTime = DateTime.fromObject(
-  { year: 1992, month: 10, day: 12, hour: 6, minute: 16 },
+  { year: 1985, month: 5, day: 15, hour: 6, minute: 30 },
   { zone: "America/New_York" }
 );
 
@@ -470,7 +752,7 @@ const month = monthPillar(adapter, dt);
 console.log(month.pillar, month.sunLonDeg);
 
 // 일주 (어댑터 불필요)
-const day = dayPillarFromDate({ year: 1992, month: 10, day: 12 });
+const day = dayPillarFromDate({ year: 1985, month: 5, day: 15 });
 console.log(day.pillar);
 
 // 태양시를 사용한 시주
@@ -542,7 +824,15 @@ packages/saju/
 │   │   ├── luxon.ts        # Luxon 어댑터
 │   │   └── date-fns.ts     # date-fns 어댑터
 │   ├── core/               # 핵심 계산 로직
-│   │   └── four-pillars.ts # 메인 알고리즘
+│   │   ├── four-pillars.ts # 사주 팔자 계산
+│   │   ├── ten-gods.ts     # 십신 분석
+│   │   ├── strength.ts     # 신강/신약 판정
+│   │   ├── relations.ts    # 합충형파해 분석
+│   │   ├── luck.ts         # 대운/세운 계산
+│   │   ├── yongshen.ts     # 용신 추출
+│   │   ├── solar-terms.ts  # 절기 계산
+│   │   └── lunar.ts        # 음력 변환
+│   ├── types/              # 타입 정의
 │   ├── __tests__/          # 테스트 스위트
 │   └── index.ts            # 공개 API
 ├── dist/                   # 컴파일된 출력
@@ -659,7 +949,3 @@ MIT © [gracefullight](https://github.com/gracefullight)
 - [문서](https://github.com/gracefullight/saju#readme)
 - [이슈 트래커](https://github.com/gracefullight/saju/issues)
 - [토론](https://github.com/gracefullight/saju/discussions)
-
----
-
-Made by [gracefullight](https://github.com/gracefullight)

package/dist/__tests__/four-pillars.test.js

@@ -20,14 +20,14 @@ describe("Four Pillars Core", () => {
         });
     });
     describe("dayPillarFromDate", () => {
-        it("should calculate day pillar for test case (1992-10-12 = 甲申)", () => {
-            const result = dayPillarFromDate({ year: 1992, month: 10, day: 12 });
-            expect(result.pillar).toBe("甲申");
-            expect(result.idx60).toBe(20);
+        it("should calculate day pillar for test case (1985-05-15 = 甲寅)", () => {
+            const result = dayPillarFromDate({ year: 1985, month: 5, day: 15 });
+            expect(result.pillar).toBe("甲寅");
+            expect(result.idx60).toBe(50);
         });
         it("should handle 60-day cycle correctly", () => {
-            const start = dayPillarFromDate({ year: 1992, month: 10, day: 12 });
-            const after60 = dayPillarFromDate({ year: 1992, month: 12, day: 11 });
+            const start = dayPillarFromDate({ year: 1985, month: 5, day: 15 });
+            const after60 = dayPillarFromDate({ year: 1985, month: 7, day: 14 });
             expect(start.idx60).toBe(after60.idx60);
         });
         it("should calculate day pillar for leap year date", () => {
@@ -47,21 +47,21 @@ describe("Four Pillars Core", () => {
             expect(result.pillar).toBe("甲子");
             expect(result.solarYear).toBe(1984);
         });
-        it("should calculate year pillar for 1992 (壬申)", () => {
-            const dt = DateTime.fromObject({ year: 1992, month: 10, day: 12 }, { zone: "Asia/Seoul" });
+        it("should calculate year pillar for 1985 (乙丑)", () => {
+            const dt = DateTime.fromObject({ year: 1985, month: 5, day: 15 }, { zone: "Asia/Seoul" });
             const result = yearPillar(adapter, dt);
-            expect(result.pillar).toBe("壬申");
-            expect(result.solarYear).toBe(1992);
+            expect(result.pillar).toBe("乙丑");
+            expect(result.solarYear).toBe(1985);
         });
         it("should handle date before Lichun (立春)", () => {
-            const dt = DateTime.fromObject({ year: 1992, month: 1, day: 15 }, { zone: "Asia/Seoul" });
+            const dt = DateTime.fromObject({ year: 1985, month: 1, day: 15 }, { zone: "Asia/Seoul" });
             const result = yearPillar(adapter, dt);
-            expect(result.solarYear).toBe(1991);
+            expect(result.solarYear).toBe(1984);
         });
         it("should handle date after Lichun", () => {
-            const dt = DateTime.fromObject({ year: 1992, month: 3, day: 1 }, { zone: "Asia/Seoul" });
+            const dt = DateTime.fromObject({ year: 1985, month: 3, day: 1 }, { zone: "Asia/Seoul" });
             const result = yearPillar(adapter, dt);
-            expect(result.solarYear).toBe(1992);
+            expect(result.solarYear).toBe(1985);
         });
         it("should follow 60-year cycle", () => {
             const dt1 = DateTime.fromObject({ year: 1984, month: 3, day: 1 }, { zone: "Asia/Seoul" });
@@ -72,25 +72,25 @@ describe("Four Pillars Core", () => {
         });
     });
     describe("monthPillar", () => {
-        it("should calculate month pillar for test case (1992-10-12)", () => {
-            const dt = DateTime.fromObject({ year: 1992, month: 10, day: 12 }, { zone: "Asia/Seoul" });
+        it("should calculate month pillar for test case (1985-05-15)", () => {
+            const dt = DateTime.fromObject({ year: 1985, month: 5, day: 15 }, { zone: "Asia/Seoul" });
             const result = monthPillar(adapter, dt);
-            expect(result.pillar).toBe("庚戌");
+            expect(result.pillar).toBe("辛巳");
         });
         it("should return valid stem-branch combination", () => {
-            const dt = DateTime.fromObject({ year: 1992, month: 10, day: 12 }, { zone: "Asia/Seoul" });
+            const dt = DateTime.fromObject({ year: 1985, month: 5, day: 15 }, { zone: "Asia/Seoul" });
             const result = monthPillar(adapter, dt);
             expect(result.pillar).toMatch(/^[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]$/);
         });
         it("should include sun longitude in result", () => {
-            const dt = DateTime.fromObject({ year: 1992, month: 10, day: 12 }, { zone: "Asia/Seoul" });
+            const dt = DateTime.fromObject({ year: 1985, month: 5, day: 15 }, { zone: "Asia/Seoul" });
             const result = monthPillar(adapter, dt);
             expect(result.sunLonDeg).toBeGreaterThanOrEqual(0);
             expect(result.sunLonDeg).toBeLessThan(360);
         });
         it("should calculate different months correctly", () => {
-            const jan = DateTime.fromObject({ year: 1992, month: 1, day: 15 }, { zone: "Asia/Seoul" });
-            const jul = DateTime.fromObject({ year: 1992, month: 7, day: 15 }, { zone: "Asia/Seoul" });
+            const jan = DateTime.fromObject({ year: 1985, month: 1, day: 15 }, { zone: "Asia/Seoul" });
+            const jul = DateTime.fromObject({ year: 1985, month: 7, day: 15 }, { zone: "Asia/Seoul" });
             const result1 = monthPillar(adapter, jan);
             const result2 = monthPillar(adapter, jul);
             expect(result1.pillar).not.toBe(result2.pillar);
@@ -98,41 +98,41 @@ describe("Four Pillars Core", () => {
     });
     describe("effectiveDayDate", () => {
         it("should return same date for midnight boundary before 23:00", () => {
-            const dt = DateTime.fromObject({ year: 1992, month: 10, day: 12, hour: 22, minute: 30 }, { zone: "Asia/Seoul" });
+            const dt = DateTime.fromObject({ year: 1985, month: 5, day: 15, hour: 22, minute: 30 }, { zone: "Asia/Seoul" });
             const result = effectiveDayDate(adapter, dt, { dayBoundary: "midnight" });
-            expect(result.year).toBe(1992);
-            expect(result.month).toBe(10);
-            expect(result.day).toBe(12);
+            expect(result.year).toBe(1985);
+            expect(result.month).toBe(5);
+            expect(result.day).toBe(15);
         });
         it("should advance date for zi23 boundary after 23:00", () => {
-            const dt = DateTime.fromObject({ year: 1992, month: 10, day: 12, hour: 23, minute: 30 }, { zone: "Asia/Seoul" });
+            const dt = DateTime.fromObject({ year: 1985, month: 5, day: 15, hour: 23, minute: 30 }, { zone: "Asia/Seoul" });
             const result = effectiveDayDate(adapter, dt, { dayBoundary: "zi23" });
-            expect(result.year).toBe(1992);
-            expect(result.month).toBe(10);
-            expect(result.day).toBe(13);
+            expect(result.year).toBe(1985);
+            expect(result.month).toBe(5);
+            expect(result.day).toBe(16);
         });
         it("should not advance date for zi23 boundary before 23:00", () => {
-            const dt = DateTime.fromObject({ year: 1992, month: 10, day: 12, hour: 22, minute: 59 }, { zone: "Asia/Seoul" });
+            const dt = DateTime.fromObject({ year: 1985, month: 5, day: 15, hour: 22, minute: 59 }, { zone: "Asia/Seoul" });
             const result = effectiveDayDate(adapter, dt, { dayBoundary: "zi23" });
-            expect(result.year).toBe(1992);
-            expect(result.month).toBe(10);
-            expect(result.day).toBe(12);
+            expect(result.year).toBe(1985);
+            expect(result.month).toBe(5);
+            expect(result.day).toBe(15);
         });
         it("should handle month boundary with zi23", () => {
-            const dt = DateTime.fromObject({ year: 1992, month: 10, day: 31, hour: 23, minute: 30 }, { zone: "Asia/Seoul" });
+            const dt = DateTime.fromObject({ year: 1985, month: 5, day: 31, hour: 23, minute: 30 }, { zone: "Asia/Seoul" });
             const result = effectiveDayDate(adapter, dt, { dayBoundary: "zi23" });
-            expect(result.year).toBe(1992);
-            expect(result.month).toBe(11);
+            expect(result.year).toBe(1985);
+            expect(result.month).toBe(6);
             expect(result.day).toBe(1);
         });
         it("should apply mean solar time correction when enabled", () => {
-            const dt = DateTime.fromObject({ year: 1992, month: 10, day: 12, hour: 23, minute: 50 }, { zone: "Asia/Seoul" });
+            const dt = DateTime.fromObject({ year: 1985, month: 5, day: 15, hour: 23, minute: 50 }, { zone: "Asia/Seoul" });
             const result = effectiveDayDate(adapter, dt, {
                 dayBoundary: "zi23",
                 longitudeDeg: 126.9,
                 useMeanSolarTimeForBoundary: true,
             });
-            expect(result.day).toBe(13);
+            expect(result.day).toBe(16);
         });
     });
     describe("hourPillar", () => {
@@ -175,7 +175,7 @@ describe("Four Pillars Core", () => {
             });
             expect(result.year).toBe("己卯");
             expect(result.month).toBe("丙子");
-            expect(result.day).toBe("庚辰");
+            expect(result.day).toBe("戊午");
             expect(result.hour).toBe("辛酉");
         });
         it("should include metadata", () => {
@@ -189,6 +189,18 @@ describe("Four Pillars Core", () => {
             expect(result.meta.effectiveDayDate).toEqual({ year: 2000, month: 1, day: 1 });
             expect(result.meta.preset).toEqual(presetA);
         });
+        it("should include lunar date information", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Seoul" });
+            const result = getFourPillars(adapter, dt, {
+                longitudeDeg: 126.9,
+                preset: presetA,
+            });
+            expect(result.lunar).toBeDefined();
+            expect(result.lunar.lunarYear).toBe(1999);
+            expect(result.lunar.lunarMonth).toBe(11);
+            expect(result.lunar.lunarDay).toBe(25);
+            expect(result.lunar.isLeapMonth).toBe(false);
+        });
     });
     describe("getFourPillars - Preset B", () => {
         it("should calculate four pillars with preset B", () => {
@@ -274,7 +286,7 @@ describe("Four Pillars Core", () => {
             expect(resultSeoul.day).toBe(resultTokyo.day);
         });
         it("should handle different longitudes affecting hour pillar", () => {
-            const dt = DateTime.fromObject({ year: 1992, month: 10, day: 12, hour: 0, minute: 30 }, { zone: "UTC" });
+            const dt = DateTime.fromObject({ year: 1985, month: 5, day: 15, hour: 0, minute: 30 }, { zone: "UTC" });
             const westLong = getFourPillars(adapter, dt, {
                 longitudeDeg: -120,
                 preset: presetB,

package/dist/__tests__/luck.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=luck.test.d.ts.map

package/dist/__tests__/luck.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"luck.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/luck.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/luck.test.js

@@ -0,0 +1,33 @@
+import { describe, it, expect } from "vitest";
+import { calculateYearlyLuck, getYearPillar } from "@/core/luck";
+describe("luck", () => {
+    describe("getYearPillar", () => {
+        it("returns correct pillar for 1984 (甲子)", () => {
+            expect(getYearPillar(1984)).toBe("甲子");
+        });
+        it("returns correct pillar for 2024 (甲辰)", () => {
+            expect(getYearPillar(2024)).toBe("甲辰");
+        });
+        it("returns correct pillar for 2000 (庚辰)", () => {
+            expect(getYearPillar(2000)).toBe("庚辰");
+        });
+    });
+    describe("calculateYearlyLuck", () => {
+        it("calculates yearly luck for a range", () => {
+            const result = calculateYearlyLuck(1990, 2020, 2025);
+            expect(result).toHaveLength(6);
+            expect(result[0].year).toBe(2020);
+            expect(result[5].year).toBe(2025);
+        });
+        it("includes correct age calculation", () => {
+            const result = calculateYearlyLuck(1990, 2020, 2020);
+            expect(result[0].age).toBe(31);
+        });
+        it("returns pillar, stem, and branch for each year", () => {
+            const result = calculateYearlyLuck(1990, 2024, 2024);
+            expect(result[0].pillar).toBe("甲辰");
+            expect(result[0].stem).toBe("甲");
+            expect(result[0].branch).toBe("辰");
+        });
+    });
+});

package/dist/__tests__/lunar.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lunar.test.d.ts.map

package/dist/__tests__/lunar.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lunar.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/lunar.test.ts"],"names":[],"mappings":""}