@gracefullight/saju 0.1.1 → 0.3.0

package/dist/__tests__/lunar.test.js

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+import { getLunarDate, getSolarDate } from "@/core/lunar";
+describe("Lunar Calendar", () => {
+    describe("getLunarDate", () => {
+        it("should convert solar date to lunar date (2000-01-01)", () => {
+            const result = getLunarDate(2000, 1, 1);
+            expect(result.lunarYear).toBe(1999);
+            expect(result.lunarMonth).toBe(11);
+            expect(result.lunarDay).toBe(25);
+            expect(result.isLeapMonth).toBe(false);
+        });
+        it("should convert solar date to lunar date (1985-05-15)", () => {
+            const result = getLunarDate(1985, 5, 15);
+            expect(result.lunarYear).toBe(1985);
+            expect(result.lunarMonth).toBe(3);
+            expect(result.lunarDay).toBe(26);
+            expect(result.isLeapMonth).toBe(false);
+        });
+        it("should handle leap month correctly (2023-03-22 is in leap 2nd month)", () => {
+            const result = getLunarDate(2023, 3, 22);
+            expect(result.lunarYear).toBe(2023);
+            expect(result.lunarMonth).toBe(2);
+            expect(result.isLeapMonth).toBe(true);
+        });
+        it("should convert first day of lunar year", () => {
+            const result = getLunarDate(2024, 2, 10);
+            expect(result.lunarYear).toBe(2024);
+            expect(result.lunarMonth).toBe(1);
+            expect(result.lunarDay).toBe(1);
+            expect(result.isLeapMonth).toBe(false);
+        });
+    });
+    describe("getSolarDate", () => {
+        it("should convert lunar date to solar date", () => {
+            const result = getSolarDate(1999, 11, 25, false);
+            expect(result.year).toBe(2000);
+            expect(result.month).toBe(1);
+            expect(result.day).toBe(1);
+        });
+        it("should convert lunar date (1985-03-26) to solar date", () => {
+            const result = getSolarDate(1985, 3, 26, false);
+            expect(result.year).toBe(1985);
+            expect(result.month).toBe(5);
+            expect(result.day).toBe(15);
+        });
+        it("should handle leap month in reverse conversion", () => {
+            const result = getSolarDate(2023, 2, 1, true);
+            expect(result.year).toBe(2023);
+            expect(result.month).toBe(3);
+            expect(result.day).toBe(22);
+        });
+        it("should convert first day of lunar year 2024", () => {
+            const result = getSolarDate(2024, 1, 1, false);
+            expect(result.year).toBe(2024);
+            expect(result.month).toBe(2);
+            expect(result.day).toBe(10);
+        });
+    });
+    describe("round-trip conversion", () => {
+        it("should convert solar -> lunar -> solar correctly", () => {
+            const original = { year: 2000, month: 6, day: 15 };
+            const lunar = getLunarDate(original.year, original.month, original.day);
+            const backToSolar = getSolarDate(lunar.lunarYear, lunar.lunarMonth, lunar.lunarDay, lunar.isLeapMonth);
+            expect(backToSolar.year).toBe(original.year);
+            expect(backToSolar.month).toBe(original.month);
+            expect(backToSolar.day).toBe(original.day);
+        });
+        it("should handle various dates in round-trip", () => {
+            const testDates = [
+                { year: 1990, month: 3, day: 20 },
+                { year: 2010, month: 8, day: 1 },
+                { year: 2020, month: 12, day: 31 },
+            ];
+            for (const date of testDates) {
+                const lunar = getLunarDate(date.year, date.month, date.day);
+                const backToSolar = getSolarDate(lunar.lunarYear, lunar.lunarMonth, lunar.lunarDay, lunar.isLeapMonth);
+                expect(backToSolar.year).toBe(date.year);
+                expect(backToSolar.month).toBe(date.month);
+                expect(backToSolar.day).toBe(date.day);
+            }
+        });
+    });
+});

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

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

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

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

package/dist/__tests__/relations.test.js

@@ -0,0 +1,90 @@
+import { describe, it, expect } from "vitest";
+import { analyzeRelations, findStemCombination, findBranchClash, findBranchSixCombination, } from "@/core/relations";
+describe("relations", () => {
+    describe("findStemCombination", () => {
+        it("finds 甲己 combination (earth)", () => {
+            const result = findStemCombination("甲", "己");
+            expect(result).not.toBeNull();
+            expect(result?.resultElement).toBe("earth");
+        });
+        it("finds 乙庚 combination (metal)", () => {
+            const result = findStemCombination("乙", "庚");
+            expect(result).not.toBeNull();
+            expect(result?.resultElement).toBe("metal");
+        });
+        it("returns null for non-combining stems", () => {
+            const result = findStemCombination("甲", "乙");
+            expect(result).toBeNull();
+        });
+    });
+    describe("findBranchClash", () => {
+        it("identifies 子午 clash", () => {
+            expect(findBranchClash("子", "午")).toBe(true);
+            expect(findBranchClash("午", "子")).toBe(true);
+        });
+        it("identifies 寅申 clash", () => {
+            expect(findBranchClash("寅", "申")).toBe(true);
+        });
+        it("returns false for non-clashing branches", () => {
+            expect(findBranchClash("子", "丑")).toBe(false);
+        });
+    });
+    describe("findBranchSixCombination", () => {
+        it("finds 子丑 combination (earth)", () => {
+            const result = findBranchSixCombination("子", "丑");
+            expect(result).not.toBeNull();
+            expect(result?.resultElement).toBe("earth");
+        });
+        it("finds 寅亥 combination (wood)", () => {
+            const result = findBranchSixCombination("寅", "亥");
+            expect(result).not.toBeNull();
+            expect(result?.resultElement).toBe("wood");
+        });
+        it("returns null for non-combining branches", () => {
+            const result = findBranchSixCombination("子", "寅");
+            expect(result).toBeNull();
+        });
+    });
+    describe("analyzeRelations", () => {
+        it("finds stem combinations in four pillars", () => {
+            const result = analyzeRelations("甲子", "己丑", "丙寅", "辛亥");
+            const stemCombos = result.combinations.filter((c) => c.type === "천간합");
+            expect(stemCombos.length).toBeGreaterThan(0);
+        });
+        it("finds branch clashes in four pillars", () => {
+            const result = analyzeRelations("甲子", "庚午", "丙寅", "壬申");
+            expect(result.clashes.length).toBe(2);
+        });
+        it("finds 삼합 (triple combination)", () => {
+            const result = analyzeRelations("甲寅", "丙午", "戊戌", "庚子");
+            const tripleCombos = result.combinations.filter((c) => c.type === "삼합");
+            expect(tripleCombos.length).toBeGreaterThan(0);
+            expect(tripleCombos[0].resultElement).toBe("fire");
+        });
+        it("finds 육합 (six combination)", () => {
+            const result = analyzeRelations("甲子", "乙丑", "丙寅", "丁卯");
+            const sixCombos = result.combinations.filter((c) => c.type === "육합");
+            expect(sixCombos.length).toBeGreaterThan(0);
+        });
+        it("finds 형 (punishment)", () => {
+            const result = analyzeRelations("甲寅", "丙巳", "戊申", "庚子");
+            expect(result.punishments.length).toBeGreaterThan(0);
+            expect(result.punishments[0].punishmentType).toBe("무은지형");
+        });
+        it("includes transformStatus and transformReason for combinations", () => {
+            const result = analyzeRelations("甲子", "己丑", "丙寅", "辛亥");
+            const stemCombos = result.combinations.filter((c) => c.type === "천간합");
+            expect(stemCombos.length).toBeGreaterThan(0);
+            expect(stemCombos[0]).toHaveProperty("transformStatus");
+            expect(stemCombos[0]).toHaveProperty("transformReason");
+        });
+        it("aggregates all relations", () => {
+            const result = analyzeRelations("甲子", "庚午", "丙寅", "壬申");
+            expect(result.all.length).toBe(result.combinations.length +
+                result.clashes.length +
+                result.harms.length +
+                result.punishments.length +
+                result.destructions.length);
+        });
+    });
+});

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

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

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

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

package/dist/__tests__/saju.test.js

@@ -0,0 +1,133 @@
+import { describe, it, expect } from "vitest";
+import { DateTime } from "luxon";
+import { createLuxonAdapter } from "@/adapters/luxon";
+import { getSaju, STANDARD_PRESET } from "@/index";
+describe("getSaju integration", () => {
+    it("returns complete saju analysis with all required fields", async () => {
+        const adapter = await createLuxonAdapter();
+        const dt = DateTime.fromObject({ year: 1990, month: 2, day: 1, hour: 12, minute: 10 }, { zone: "Asia/Seoul" });
+        const result = getSaju(adapter, dt, {
+            longitudeDeg: 126.9778,
+            gender: "male",
+            preset: STANDARD_PRESET,
+        });
+        expect(result.pillars.year).toBeDefined();
+        expect(result.pillars.month).toBeDefined();
+        expect(result.pillars.day).toBeDefined();
+        expect(result.pillars.hour).toBeDefined();
+        expect(result.tenGods).toBeDefined();
+        expect(result.strength).toBeDefined();
+        expect(result.relations).toBeDefined();
+        expect(result.yongShen).toBeDefined();
+        expect(result.lunar).toBeDefined();
+        expect(result.solarTerms).toBeDefined();
+        expect(result.majorLuck).toBeDefined();
+        expect(result.yearlyLuck).toBeDefined();
+    });
+    it("includes solar terms with current and next term info", async () => {
+        const adapter = await createLuxonAdapter();
+        const dt = DateTime.fromObject({ year: 2024, month: 1, day: 15, hour: 12 }, { zone: "Asia/Seoul" });
+        const result = getSaju(adapter, dt, {
+            longitudeDeg: 126.9778,
+            gender: "female",
+            preset: STANDARD_PRESET,
+        });
+        expect(result.solarTerms.current.name).toBe("소한");
+        expect(result.solarTerms.next.name).toBe("대한");
+        expect(result.solarTerms.daysSinceCurrent).toBeGreaterThanOrEqual(0);
+        expect(result.solarTerms.daysUntilNext).toBeGreaterThan(0);
+        expect(result.solarTerms.currentDate).toBeDefined();
+        expect(result.solarTerms.nextDate).toBeDefined();
+    });
+    it("includes major luck by default", async () => {
+        const adapter = await createLuxonAdapter();
+        const dt = DateTime.fromObject({ year: 1990, month: 2, day: 1, hour: 12, minute: 10 }, { zone: "Asia/Seoul" });
+        const result = getSaju(adapter, dt, {
+            longitudeDeg: 126.9778,
+            gender: "male",
+            preset: STANDARD_PRESET,
+        });
+        expect(result.majorLuck).toBeDefined();
+        expect(result.majorLuck.pillars.length).toBeGreaterThan(0);
+        expect(result.majorLuck.startAge).toBeGreaterThanOrEqual(0);
+    });
+    it("includes yearly luck by default with custom range", async () => {
+        const adapter = await createLuxonAdapter();
+        const dt = DateTime.fromObject({ year: 1990, month: 2, day: 1, hour: 12, minute: 10 }, { zone: "Asia/Seoul" });
+        const result = getSaju(adapter, dt, {
+            longitudeDeg: 126.9778,
+            gender: "female",
+            preset: STANDARD_PRESET,
+            yearlyLuckRange: { from: 2024, to: 2026 },
+        });
+        expect(result.yearlyLuck).toBeDefined();
+        expect(result.yearlyLuck.length).toBe(3);
+        expect(result.yearlyLuck[0].year).toBe(2024);
+        expect(result.yearlyLuck[2].year).toBe(2026);
+    });
+    it("uses default yearly luck range when not specified", async () => {
+        const adapter = await createLuxonAdapter();
+        const dt = DateTime.fromObject({ year: 1990, month: 2, day: 1, hour: 12, minute: 10 }, { zone: "Asia/Seoul" });
+        const result = getSaju(adapter, dt, {
+            longitudeDeg: 126.9778,
+            gender: "male",
+            currentYear: 2024,
+        });
+        expect(result.yearlyLuck.length).toBe(16);
+        expect(result.yearlyLuck[0].year).toBe(2019);
+        expect(result.yearlyLuck[15].year).toBe(2034);
+    });
+    it("calculates known test case correctly", async () => {
+        const adapter = await createLuxonAdapter();
+        const dt = DateTime.fromObject({ year: 1990, month: 2, day: 1, hour: 12, minute: 10 }, { zone: "Asia/Seoul" });
+        const result = getSaju(adapter, dt, {
+            longitudeDeg: 126.9778,
+            gender: "male",
+            preset: STANDARD_PRESET,
+        });
+        expect(result.pillars.year).toBe("己巳");
+        expect(result.pillars.month).toBe("丁丑");
+        expect(result.pillars.day).toBe("丁酉");
+        expect(result.pillars.hour).toBe("丙午");
+    });
+    it("identifies day master in ten gods analysis", async () => {
+        const adapter = await createLuxonAdapter();
+        const dt = DateTime.fromObject({ year: 1990, month: 2, day: 1, hour: 12, minute: 10 }, { zone: "Asia/Seoul" });
+        const result = getSaju(adapter, dt, {
+            longitudeDeg: 126.9778,
+            gender: "female",
+            preset: STANDARD_PRESET,
+        });
+        expect(result.tenGods.dayMaster).toBe("丁");
+        expect(result.tenGods.day.stem.tenGod).toBe("일간");
+    });
+    it("calculates major luck start age based on actual solar terms (not fixed 10)", async () => {
+        const adapter = await createLuxonAdapter();
+        const dt = DateTime.fromObject({ year: 1990, month: 2, day: 1, hour: 12, minute: 10 }, { zone: "Asia/Seoul" });
+        const result = getSaju(adapter, dt, {
+            longitudeDeg: 126.9778,
+            gender: "male",
+            preset: STANDARD_PRESET,
+        });
+        expect(result.majorLuck.startAge).not.toBe(10);
+        expect(result.majorLuck.startAgeDetail).toBeDefined();
+        expect(result.majorLuck.startAgeDetail.years).toBeGreaterThanOrEqual(0);
+        expect(result.majorLuck.startAgeDetail.months).toBeGreaterThanOrEqual(0);
+        expect(result.majorLuck.daysToTerm).toBeGreaterThan(0);
+    });
+    it("includes Jie (節) solar term info for major luck calculation", async () => {
+        const adapter = await createLuxonAdapter();
+        const dt = DateTime.fromObject({ year: 2024, month: 3, day: 15, hour: 12 }, { zone: "Asia/Seoul" });
+        const result = getSaju(adapter, dt, {
+            longitudeDeg: 126.9778,
+            gender: "female",
+            preset: STANDARD_PRESET,
+        });
+        expect(result.solarTerms.prevJie).toBeDefined();
+        expect(result.solarTerms.nextJie).toBeDefined();
+        expect(result.solarTerms.prevJieMillis).toBeGreaterThan(0);
+        expect(result.solarTerms.nextJieMillis).toBeGreaterThan(0);
+        expect(result.solarTerms.prevJieDate).toBeDefined();
+        expect(result.solarTerms.nextJieDate).toBeDefined();
+    });
+});

package/dist/__tests__/solar-terms.test.d.ts

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

package/dist/__tests__/solar-terms.test.d.ts.map

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

package/dist/__tests__/solar-terms.test.js

@@ -0,0 +1,121 @@
+import { DateTime } from "luxon";
+import { describe, expect, it } from "vitest";
+import { createLuxonAdapter } from "@/adapters/luxon";
+import { analyzeSolarTerms, getSolarTermsForYear, SOLAR_TERMS } from "@/core/solar-terms";
+describe("solar-terms", async () => {
+    const adapter = await createLuxonAdapter();
+    describe("SOLAR_TERMS", () => {
+        it("should have 24 terms", () => {
+            expect(SOLAR_TERMS).toHaveLength(24);
+        });
+        it("should have terms at 15-degree intervals", () => {
+            for (let i = 0; i < SOLAR_TERMS.length; i++) {
+                const expectedLon = (285 + i * 15) % 360;
+                expect(SOLAR_TERMS[i].longitude).toBe(expectedLon);
+            }
+        });
+        it("should start with 소한 at 285°", () => {
+            expect(SOLAR_TERMS[0]).toEqual({ name: "소한", hanja: "小寒", longitude: 285 });
+        });
+        it("should have 입춘 at 315°", () => {
+            const ipchun = SOLAR_TERMS.find((t) => t.name === "입춘");
+            expect(ipchun).toEqual({ name: "입춘", hanja: "立春", longitude: 315 });
+        });
+    });
+    describe("analyzeSolarTerms", () => {
+        it("should return current and next solar terms for mid-January", () => {
+            const dt = DateTime.fromObject({ year: 2024, month: 1, day: 15 }, { zone: "Asia/Seoul" });
+            const result = analyzeSolarTerms(adapter, dt);
+            expect(result.current.name).toBe("소한");
+            expect(result.next.name).toBe("대한");
+            expect(result.daysSinceCurrent).toBeGreaterThanOrEqual(0);
+            expect(result.daysUntilNext).toBeGreaterThan(0);
+        });
+        it("should return current and next solar terms for early February", () => {
+            const dt = DateTime.fromObject({ year: 2024, month: 2, day: 3 }, { zone: "Asia/Seoul" });
+            const result = analyzeSolarTerms(adapter, dt);
+            expect(result.current.name).toBe("대한");
+            expect(result.next.name).toBe("입춘");
+        });
+        it("should return current and next solar terms for summer solstice period", () => {
+            const dt = DateTime.fromObject({ year: 2024, month: 6, day: 25 }, { zone: "Asia/Seoul" });
+            const result = analyzeSolarTerms(adapter, dt);
+            expect(result.current.name).toBe("하지");
+            expect(result.next.name).toBe("소서");
+        });
+        it("should return current and next solar terms for winter solstice period", () => {
+            const dt = DateTime.fromObject({ year: 2024, month: 12, day: 25 }, { zone: "Asia/Seoul" });
+            const result = analyzeSolarTerms(adapter, dt);
+            expect(result.current.name).toBe("동지");
+            expect(result.next.name).toBe("소한");
+        });
+        it("should calculate days since current term correctly", () => {
+            const dt = DateTime.fromObject({ year: 2024, month: 3, day: 25 }, { zone: "Asia/Seoul" });
+            const result = analyzeSolarTerms(adapter, dt);
+            expect(result.current.name).toBe("춘분");
+            expect(result.daysSinceCurrent).toBeGreaterThanOrEqual(0);
+            expect(result.daysSinceCurrent).toBeLessThan(16);
+        });
+        it("should calculate days until next term correctly", () => {
+            const dt = DateTime.fromObject({ year: 2024, month: 4, day: 1 }, { zone: "Asia/Seoul" });
+            const result = analyzeSolarTerms(adapter, dt);
+            expect(result.next.name).toBe("청명");
+            expect(result.daysUntilNext).toBeGreaterThan(0);
+            expect(result.daysUntilNext).toBeLessThan(16);
+        });
+        it("should include date information for current and next terms", () => {
+            const dt = DateTime.fromObject({ year: 2024, month: 5, day: 10 }, { zone: "Asia/Seoul" });
+            const result = analyzeSolarTerms(adapter, dt);
+            expect(result.currentDate).toHaveProperty("year");
+            expect(result.currentDate).toHaveProperty("month");
+            expect(result.currentDate).toHaveProperty("day");
+            expect(result.currentDate).toHaveProperty("hour");
+            expect(result.currentDate).toHaveProperty("minute");
+            expect(result.nextDate).toHaveProperty("year");
+            expect(result.nextDate).toHaveProperty("month");
+            expect(result.nextDate).toHaveProperty("day");
+            expect(result.nextDate).toHaveProperty("hour");
+            expect(result.nextDate).toHaveProperty("minute");
+        });
+    });
+    describe("getSolarTermsForYear", () => {
+        it("should return 24 terms for a year", () => {
+            const terms = getSolarTermsForYear(adapter, 2024, "Asia/Seoul");
+            expect(terms).toHaveLength(24);
+        });
+        it("should have all terms in order", () => {
+            const terms = getSolarTermsForYear(adapter, 2024, "Asia/Seoul");
+            const names = terms.map((t) => t.term.name);
+            expect(names[0]).toBe("소한");
+            expect(names[2]).toBe("입춘");
+            expect(names[5]).toBe("춘분");
+            expect(names[11]).toBe("하지");
+            expect(names[17]).toBe("추분");
+            expect(names[23]).toBe("동지");
+        });
+        it("should have dates in chronological order within months", () => {
+            const terms = getSolarTermsForYear(adapter, 2024, "Asia/Seoul");
+            for (const term of terms) {
+                expect(term.date.year).toBe(2024);
+                expect(term.date.month).toBeGreaterThanOrEqual(1);
+                expect(term.date.month).toBeLessThanOrEqual(12);
+                expect(term.date.day).toBeGreaterThanOrEqual(1);
+                expect(term.date.day).toBeLessThanOrEqual(31);
+            }
+        });
+        it("should have 입춘 around February 4", () => {
+            const terms = getSolarTermsForYear(adapter, 2024, "Asia/Seoul");
+            const ipchun = terms.find((t) => t.term.name === "입춘");
+            expect(ipchun?.date.month).toBe(2);
+            expect(ipchun?.date.day).toBeGreaterThanOrEqual(3);
+            expect(ipchun?.date.day).toBeLessThanOrEqual(5);
+        });
+        it("should have 하지 around June 21", () => {
+            const terms = getSolarTermsForYear(adapter, 2024, "Asia/Seoul");
+            const haji = terms.find((t) => t.term.name === "하지");
+            expect(haji?.date.month).toBe(6);
+            expect(haji?.date.day).toBeGreaterThanOrEqual(20);
+            expect(haji?.date.day).toBeLessThanOrEqual(22);
+        });
+    });
+});

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

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

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

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

package/dist/__tests__/strength.test.js

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+import { analyzeStrength } from "@/core/strength";
+describe("strength", () => {
+    describe("analyzeStrength", () => {
+        it("returns a strength level", () => {
+            const result = analyzeStrength("甲子", "丙寅", "甲辰", "乙亥");
+            expect(result.level).toBeDefined();
+            expect(result.score).toBeDefined();
+            expect(result.factors).toBeDefined();
+            expect(result.description).toBeDefined();
+        });
+        it("identifies 득령 when month supports day master", () => {
+            // 甲木 day master in 寅月 (wood month) = 득령 (1.0 multiplier)
+            const result = analyzeStrength("甲子", "丙寅", "甲辰", "乙亥");
+            expect(result.factors.deukryeong).toBeGreaterThanOrEqual(0.7);
+        });
+        it("identifies 실령 when month does not support day master", () => {
+            // 甲木 day master in 申月 (metal month) = 실령 (0.1 multiplier)
+            const result = analyzeStrength("甲子", "庚申", "甲辰", "乙亥");
+            expect(result.factors.deukryeong).toBeLessThanOrEqual(0.3);
+        });
+        it("calculates 득지 from day and hour branches", () => {
+            const result = analyzeStrength("甲子", "丙寅", "甲寅", "甲寅");
+            expect(result.factors.deukji).toBeGreaterThan(0);
+        });
+        it("calculates 득세 from year, month, hour stems", () => {
+            const result = analyzeStrength("甲子", "甲寅", "甲辰", "甲寅");
+            expect(result.factors.deukse).toBeGreaterThan(0);
+        });
+        it("returns 신강 for strong day master", () => {
+            const result = analyzeStrength("甲子", "甲寅", "甲寅", "甲寅");
+            expect(["신강", "태강", "극왕", "중화신강"]).toContain(result.level);
+        });
+        it("returns 신약 for weak day master", () => {
+            const result = analyzeStrength("庚申", "庚申", "甲申", "庚申");
+            expect(["신약", "태약", "극약", "중화신약"]).toContain(result.level);
+        });
+        it("includes description with day master info", () => {
+            const result = analyzeStrength("甲子", "丙寅", "甲辰", "乙亥");
+            expect(result.description).toContain("甲");
+            expect(result.description).toContain("wood");
+        });
+    });
+});

package/dist/__tests__/ten-gods.test.d.ts

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

package/dist/__tests__/ten-gods.test.d.ts.map

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

package/dist/__tests__/ten-gods.test.js

@@ -0,0 +1,119 @@
+import { describe, it, expect } from "vitest";
+import { getTenGod, getStemElement, getStemPolarity, getBranchElement, getHiddenStems, analyzeTenGods, countTenGods, countElements, } from "@/core/ten-gods";
+describe("ten-gods", () => {
+    describe("getStemElement", () => {
+        it("returns correct element for each stem", () => {
+            expect(getStemElement("甲")).toBe("wood");
+            expect(getStemElement("乙")).toBe("wood");
+            expect(getStemElement("丙")).toBe("fire");
+            expect(getStemElement("丁")).toBe("fire");
+            expect(getStemElement("戊")).toBe("earth");
+            expect(getStemElement("己")).toBe("earth");
+            expect(getStemElement("庚")).toBe("metal");
+            expect(getStemElement("辛")).toBe("metal");
+            expect(getStemElement("壬")).toBe("water");
+            expect(getStemElement("癸")).toBe("water");
+        });
+    });
+    describe("getStemPolarity", () => {
+        it("returns correct polarity for each stem", () => {
+            expect(getStemPolarity("甲")).toBe("yang");
+            expect(getStemPolarity("乙")).toBe("yin");
+            expect(getStemPolarity("丙")).toBe("yang");
+            expect(getStemPolarity("丁")).toBe("yin");
+        });
+    });
+    describe("getBranchElement", () => {
+        it("returns correct element for each branch", () => {
+            expect(getBranchElement("子")).toBe("water");
+            expect(getBranchElement("丑")).toBe("earth");
+            expect(getBranchElement("寅")).toBe("wood");
+            expect(getBranchElement("卯")).toBe("wood");
+            expect(getBranchElement("午")).toBe("fire");
+            expect(getBranchElement("酉")).toBe("metal");
+        });
+    });
+    describe("getHiddenStems", () => {
+        it("returns correct hidden stems for each branch", () => {
+            expect(getHiddenStems("子")).toEqual(["癸"]);
+            expect(getHiddenStems("丑")).toEqual(["己", "癸", "辛"]);
+            expect(getHiddenStems("寅")).toEqual(["甲", "丙", "戊"]);
+            expect(getHiddenStems("卯")).toEqual(["乙"]);
+            expect(getHiddenStems("午")).toEqual(["丁", "己"]);
+        });
+    });
+    describe("getTenGod", () => {
+        it("correctly identifies 비견 (same element, same polarity)", () => {
+            expect(getTenGod("甲", "甲")).toBe("비견");
+            expect(getTenGod("乙", "乙")).toBe("비견");
+        });
+        it("correctly identifies 겁재 (same element, different polarity)", () => {
+            expect(getTenGod("甲", "乙")).toBe("겁재");
+            expect(getTenGod("乙", "甲")).toBe("겁재");
+        });
+        it("correctly identifies 식신 (I generate, same polarity)", () => {
+            expect(getTenGod("甲", "丙")).toBe("식신");
+            expect(getTenGod("丙", "戊")).toBe("식신");
+        });
+        it("correctly identifies 상관 (I generate, different polarity)", () => {
+            expect(getTenGod("甲", "丁")).toBe("상관");
+            expect(getTenGod("丙", "己")).toBe("상관");
+        });
+        it("correctly identifies 편재 (I control, same polarity)", () => {
+            expect(getTenGod("甲", "戊")).toBe("편재");
+            expect(getTenGod("丙", "庚")).toBe("편재");
+        });
+        it("correctly identifies 정재 (I control, different polarity)", () => {
+            expect(getTenGod("甲", "己")).toBe("정재");
+            expect(getTenGod("丙", "辛")).toBe("정재");
+        });
+        it("correctly identifies 편관 (controls me, same polarity)", () => {
+            expect(getTenGod("甲", "庚")).toBe("편관");
+            expect(getTenGod("丙", "壬")).toBe("편관");
+        });
+        it("correctly identifies 정관 (controls me, different polarity)", () => {
+            expect(getTenGod("甲", "辛")).toBe("정관");
+            expect(getTenGod("丙", "癸")).toBe("정관");
+        });
+        it("correctly identifies 편인 (generates me, same polarity)", () => {
+            expect(getTenGod("甲", "壬")).toBe("편인");
+            expect(getTenGod("丙", "甲")).toBe("편인");
+        });
+        it("correctly identifies 정인 (generates me, different polarity)", () => {
+            expect(getTenGod("甲", "癸")).toBe("정인");
+            expect(getTenGod("丙", "乙")).toBe("정인");
+        });
+    });
+    describe("analyzeTenGods", () => {
+        it("analyzes four pillars correctly", () => {
+            const result = analyzeTenGods("甲子", "丙寅", "甲辰", "乙亥");
+            expect(result.dayMaster).toBe("甲");
+            expect(result.year.stem.tenGod).toBe("비견");
+            expect(result.month.stem.tenGod).toBe("식신");
+            expect(result.day.stem.tenGod).toBe("일간");
+            expect(result.hour.stem.tenGod).toBe("겁재");
+        });
+        it("includes hidden stems analysis", () => {
+            const result = analyzeTenGods("甲子", "丙寅", "甲辰", "乙亥");
+            expect(result.year.branch.hiddenStems).toHaveLength(1);
+            expect(result.year.branch.hiddenStems[0].stem).toBe("癸");
+            expect(result.month.branch.hiddenStems).toHaveLength(3);
+        });
+    });
+    describe("countTenGods", () => {
+        it("counts ten gods correctly", () => {
+            const analysis = analyzeTenGods("甲子", "丙寅", "甲辰", "乙亥");
+            const counts = countTenGods(analysis);
+            expect(counts["비견"]).toBeGreaterThanOrEqual(1);
+            expect(counts["식신"]).toBeGreaterThanOrEqual(1);
+        });
+    });
+    describe("countElements", () => {
+        it("counts elements correctly", () => {
+            const analysis = analyzeTenGods("甲子", "丙寅", "甲辰", "乙亥");
+            const counts = countElements(analysis);
+            expect(counts.wood).toBeGreaterThanOrEqual(3);
+            expect(counts.fire).toBeGreaterThanOrEqual(1);
+        });
+    });
+});

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

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

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

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