@gracefullight/saju 0.2.0 → 0.4.1

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

@@ -1,7 +1,7 @@
 import { DateTime } from "luxon";
 import { beforeAll, describe, expect, it } from "vitest";
-import { createLuxonAdapter } from "@/adapters/luxon";
-import { BRANCHES, dayPillarFromDate, effectiveDayDate, getFourPillars, hourPillar, monthPillar, presetA, presetB, STEMS, yearPillar, } from "@/core/four-pillars";
+import { createLuxonAdapter } from "../adapters/luxon";
+import { BRANCHES, dayPillarFromDate, effectiveDayDate, getFourPillars, hourPillar, monthPillar, presetA, presetB, STEMS, yearPillar, } from "../core/four-pillars";
 describe("Four Pillars Core", () => {
     let adapter;
     beforeAll(async () => {
@@ -240,14 +240,15 @@ describe("Four Pillars Core", () => {
             });
             expect(resultA.meta.effectiveDayDate.day).toBe(1);
         });
-        it("should require longitudeDeg parameter", () => {
+        it("should use default longitude from timezone offset when longitudeDeg is omitted", () => {
             const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Seoul" });
-            expect(() => {
-                getFourPillars(adapter, dt, {
-                    longitudeDeg: undefined,
-                    preset: presetA,
-                });
-            }).toThrow("longitudeDeg is required");
+            const result = getFourPillars(adapter, dt, {
+                preset: presetA,
+            });
+            expect(result.year).toBeDefined();
+            expect(result.month).toBeDefined();
+            expect(result.day).toBeDefined();
+            expect(result.hour).toBeDefined();
         });
         it("should handle leap year dates", () => {
             const dt = DateTime.fromObject({ year: 2000, month: 2, day: 29 }, { zone: "UTC" });

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, expect, it } 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.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { getLunarDate, getSolarDate } from "@/core/lunar";
+import { getLunarDate, getSolarDate } from "../core/lunar";
 describe("Lunar Calendar", () => {
     describe("getLunarDate", () => {
         it("should convert solar date to lunar date (2000-01-01)", () => {

package/dist/__tests__/luxon-adapter.test.js

@@ -1,6 +1,6 @@
 import { DateTime } from "luxon";
 import { beforeAll, describe, expect, it } from "vitest";
-import { createLuxonAdapter } from "@/adapters/luxon";
+import { createLuxonAdapter } from "../adapters/luxon";
 describe("Luxon Adapter", () => {
     let adapter;
     beforeAll(async () => {

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, expect, it } from "vitest";
+import { analyzeRelations, findBranchClash, findBranchSixCombination, findStemCombination, } 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 { DateTime } from "luxon";
+import { describe, expect, it } from "vitest";
+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__/sinsals.test.d.ts

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

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

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

package/dist/__tests__/sinsals.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import { analyzeSinsals, SINSAL_INFO, SINSALS } from "../core/sinsals";
+describe("sinsals", () => {
+    describe("analyzeSinsals", () => {
+        it("should detect peach blossom (도화살)", () => {
+            const result = analyzeSinsals("甲寅", "丙寅", "戊卯", "庚午");
+            const peachBlossoms = result.matches.filter((m) => m.sinsal === "peachBlossom");
+            expect(peachBlossoms.length).toBeGreaterThan(0);
+        });
+        it("should detect sky horse (역마살)", () => {
+            const result = analyzeSinsals("甲寅", "丙寅", "戊申", "庚午");
+            const skyHorses = result.matches.filter((m) => m.sinsal === "skyHorse");
+            expect(skyHorses.length).toBeGreaterThan(0);
+        });
+        it("should detect flowery canopy (화개살)", () => {
+            const result = analyzeSinsals("甲寅", "丙戌", "戊子", "庚午");
+            const floweryCanopies = result.matches.filter((m) => m.sinsal === "floweryCanopy");
+            expect(floweryCanopies.length).toBeGreaterThan(0);
+        });
+        it("should return summary grouped by sinsal", () => {
+            const result = analyzeSinsals("甲子", "丙寅", "戊辰", "庚午");
+            expect(result.summary).toBeDefined();
+            for (const [sinsal, positions] of Object.entries(result.summary)) {
+                expect(SINSALS).toContain(sinsal);
+                expect(Array.isArray(positions)).toBe(true);
+            }
+        });
+        it("should not have duplicate matches", () => {
+            const result = analyzeSinsals("甲子", "丙寅", "戊辰", "庚午");
+            const seen = new Set();
+            for (const match of result.matches) {
+                const key = `${match.sinsal}-${match.position}`;
+                expect(seen.has(key)).toBe(false);
+                seen.add(key);
+            }
+        });
+        it("should detect sky noble (천을귀인)", () => {
+            const result = analyzeSinsals("甲丑", "丙寅", "甲子", "庚午");
+            const skyNobles = result.matches.filter((m) => m.sinsal === "skyNoble");
+            expect(skyNobles.length).toBeGreaterThan(0);
+        });
+    });
+    describe("SINSAL_INFO", () => {
+        it("should have info for all sinsals", () => {
+            for (const sinsal of SINSALS) {
+                expect(SINSAL_INFO[sinsal]).toBeDefined();
+                expect(SINSAL_INFO[sinsal].korean).toBeDefined();
+                expect(SINSAL_INFO[sinsal].hanja).toBeDefined();
+                expect(SINSAL_INFO[sinsal].meaning).toBeDefined();
+                expect(["auspicious", "inauspicious", "neutral"]).toContain(SINSAL_INFO[sinsal].type);
+            }
+        });
+        it("should have correct korean names", () => {
+            expect(SINSAL_INFO.peachBlossom.korean).toBe("도화살");
+            expect(SINSAL_INFO.skyHorse.korean).toBe("역마살");
+            expect(SINSAL_INFO.skyNoble.korean).toBe("천을귀인");
+        });
+        it("should have correct type classifications", () => {
+            expect(SINSAL_INFO.peachBlossom.type).toBe("neutral");
+            expect(SINSAL_INFO.skyNoble.type).toBe("auspicious");
+            expect(SINSAL_INFO.ghostGate.type).toBe("inauspicious");
+        });
+    });
+});

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, expect, it } 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":""}