@gracefullight/saju 0.1.0

package/dist/__tests__/date-fns-adapter.test.js

@@ -0,0 +1,155 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { createDateFnsAdapter } from "@/adapters/date-fns";
+describe("date-fns Adapter", () => {
+    let adapter;
+    beforeAll(async () => {
+        adapter = await createDateFnsAdapter();
+    });
+    describe("Basic date getters", () => {
+        it("should get year correctly", () => {
+            const dt = { date: new Date(2000, 0, 1), timeZone: "Asia/Seoul" };
+            expect(adapter.getYear(dt)).toBe(2000);
+        });
+        it("should get month correctly (1-based)", () => {
+            const dt = { date: new Date(2000, 0, 1), timeZone: "Asia/Seoul" };
+            expect(adapter.getMonth(dt)).toBe(1);
+        });
+        it("should get day correctly", () => {
+            const dt = { date: new Date(2000, 0, 1), timeZone: "Asia/Seoul" };
+            expect(adapter.getDay(dt)).toBe(1);
+        });
+        it("should get hour correctly", () => {
+            const dt = { date: new Date(2000, 0, 1, 18, 0), timeZone: "Asia/Seoul" };
+            expect(adapter.getHour(dt)).toBe(18);
+        });
+        it("should get minute correctly", () => {
+            const dt = { date: new Date(2000, 0, 1, 18, 0), timeZone: "Asia/Seoul" };
+            expect(adapter.getMinute(dt)).toBe(0);
+        });
+        it("should get second correctly", () => {
+            const dt = { date: new Date(2000, 0, 1, 18, 0, 30), timeZone: "Asia/Seoul" };
+            expect(adapter.getSecond(dt)).toBe(30);
+        });
+        it("should get zone name correctly", () => {
+            const dt = { date: new Date(2000, 0, 1), timeZone: "Asia/Seoul" };
+            expect(adapter.getZoneName(dt)).toBe("Asia/Seoul");
+        });
+    });
+    describe("Date arithmetic", () => {
+        it("should add minutes correctly", () => {
+            const dt = { date: new Date(2000, 0, 1, 18, 0), timeZone: "Asia/Seoul" };
+            const result = adapter.plusMinutes(dt, 30);
+            expect(adapter.getMinute(result)).toBe(30);
+            expect(adapter.getHour(result)).toBe(18);
+        });
+        it("should add minutes with hour overflow", () => {
+            const dt = { date: new Date(2000, 0, 1, 23, 45), timeZone: "Asia/Seoul" };
+            const result = adapter.plusMinutes(dt, 30);
+            expect(adapter.getHour(result)).toBe(0);
+            expect(adapter.getMinute(result)).toBe(15);
+            expect(adapter.getDay(result)).toBe(2);
+        });
+        it("should add days correctly", () => {
+            const dt = { date: new Date(2000, 0, 1), timeZone: "Asia/Seoul" };
+            const result = adapter.plusDays(dt, 5);
+            expect(adapter.getDay(result)).toBe(6);
+            expect(adapter.getMonth(result)).toBe(1);
+        });
+        it("should add days with month overflow", () => {
+            const dt = { date: new Date(2000, 0, 30), timeZone: "Asia/Seoul" };
+            const result = adapter.plusDays(dt, 5);
+            expect(adapter.getDay(result)).toBe(4);
+            expect(adapter.getMonth(result)).toBe(2);
+        });
+        it("should subtract days correctly", () => {
+            const dt = { date: new Date(2000, 0, 10), timeZone: "Asia/Seoul" };
+            const result = adapter.minusDays(dt, 5);
+            expect(adapter.getDay(result)).toBe(5);
+            expect(adapter.getMonth(result)).toBe(1);
+        });
+        it("should subtract days with month underflow", () => {
+            const dt = { date: new Date(2000, 1, 3), timeZone: "Asia/Seoul" };
+            const result = adapter.minusDays(dt, 5);
+            expect(adapter.getDay(result)).toBe(29);
+            expect(adapter.getMonth(result)).toBe(1);
+        });
+    });
+    describe("Timezone operations", () => {
+        it("should convert to UTC correctly", () => {
+            const dt = { date: new Date(2000, 0, 1, 18, 0), timeZone: "Asia/Seoul" };
+            const utc = adapter.toUTC(dt);
+            expect(adapter.getZoneName(utc)).toBe("UTC");
+        });
+        it("should set zone correctly", () => {
+            const dt = { date: new Date(2000, 0, 1, 18, 0), timeZone: "Asia/Seoul" };
+            const ny = adapter.setZone(dt, "America/New_York");
+            expect(adapter.getZoneName(ny)).toBe("America/New_York");
+        });
+    });
+    describe("Conversion methods", () => {
+        it("should convert to ISO string", () => {
+            const dt = { date: new Date(2000, 0, 1, 18, 0), timeZone: "Asia/Seoul" };
+            const iso = adapter.toISO(dt);
+            expect(iso).toContain("2000-01-01");
+            expect(iso).toContain("18:00");
+        });
+        it("should convert to milliseconds", () => {
+            const dt = { date: new Date(2000, 0, 1, 18, 0), timeZone: "Asia/Seoul" };
+            const millis = adapter.toMillis(dt);
+            expect(typeof millis).toBe("number");
+            expect(millis).toBeGreaterThan(0);
+        });
+        it("should create date from milliseconds", () => {
+            const millis = new Date(2000, 0, 1, 18, 0).getTime();
+            const dt = adapter.fromMillis(millis, "Asia/Seoul");
+            expect(adapter.getYear(dt)).toBe(2000);
+            expect(adapter.getMonth(dt)).toBe(1);
+            expect(adapter.getDay(dt)).toBe(1);
+        });
+    });
+    describe("UTC date creation", () => {
+        it("should create UTC date correctly", () => {
+            const dt = adapter.createUTC(2000, 2, 5, 12, 30, 45);
+            expect(adapter.getZoneName(dt)).toBe("UTC");
+            expect(adapter.getYear(dt)).toBe(2000);
+            expect(adapter.getMonth(dt)).toBe(2);
+            expect(adapter.getDay(dt)).toBe(5);
+        });
+    });
+    describe("Date comparison", () => {
+        it("should compare dates correctly (greater than)", () => {
+            const dt1 = { date: new Date(2000, 0, 2), timeZone: "UTC" };
+            const dt2 = { date: new Date(2000, 0, 1), timeZone: "UTC" };
+            expect(adapter.isGreaterThanOrEqual(dt1, dt2)).toBe(true);
+        });
+        it("should compare dates correctly (equal)", () => {
+            const dt1 = { date: new Date(2000, 0, 1, 12, 0, 0), timeZone: "UTC" };
+            const dt2 = { date: new Date(2000, 0, 1, 12, 0, 0), timeZone: "UTC" };
+            expect(adapter.isGreaterThanOrEqual(dt1, dt2)).toBe(true);
+        });
+        it("should compare dates correctly (less than)", () => {
+            const dt1 = { date: new Date(1999, 11, 31), timeZone: "UTC" };
+            const dt2 = { date: new Date(2000, 0, 1), timeZone: "UTC" };
+            expect(adapter.isGreaterThanOrEqual(dt1, dt2)).toBe(false);
+        });
+    });
+    describe("Edge cases", () => {
+        it("should handle leap year correctly", () => {
+            const dt = { date: new Date(2000, 1, 29), timeZone: "UTC" };
+            expect(adapter.getDay(dt)).toBe(29);
+            expect(adapter.getMonth(dt)).toBe(2);
+        });
+        it("should handle year boundary", () => {
+            const dt = { date: new Date(1999, 11, 31, 23, 59), timeZone: "UTC" };
+            const result = adapter.plusMinutes(dt, 2);
+            expect(adapter.getYear(result)).toBe(2000);
+            expect(adapter.getMonth(result)).toBe(1);
+            expect(adapter.getDay(result)).toBe(1);
+        });
+        it("should preserve timeZone property after operations", () => {
+            const dt = { date: new Date(2000, 0, 1), timeZone: "Asia/Tokyo" };
+            const result = adapter.plusDays(dt, 1);
+            expect(adapter.getZoneName(result)).toBe("Asia/Tokyo");
+        });
+    });
+});

package/dist/__tests__/four-pillars.test.d.ts

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

package/dist/__tests__/four-pillars.test.d.ts.map

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

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

@@ -0,0 +1,289 @@
+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";
+describe("Four Pillars Core", () => {
+    let adapter;
+    beforeAll(async () => {
+        adapter = await createLuxonAdapter();
+    });
+    describe("Constants", () => {
+        it("should have 10 stems", () => {
+            expect(STEMS).toHaveLength(10);
+            expect(STEMS[0]).toBe("甲");
+            expect(STEMS[9]).toBe("癸");
+        });
+        it("should have 12 branches", () => {
+            expect(BRANCHES).toHaveLength(12);
+            expect(BRANCHES[0]).toBe("子");
+            expect(BRANCHES[11]).toBe("亥");
+        });
+    });
+    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 handle 60-day cycle correctly", () => {
+            const start = dayPillarFromDate({ year: 1992, month: 10, day: 12 });
+            const after60 = dayPillarFromDate({ year: 1992, month: 12, day: 11 });
+            expect(start.idx60).toBe(after60.idx60);
+        });
+        it("should calculate day pillar for leap year date", () => {
+            const result = dayPillarFromDate({ year: 2000, month: 2, day: 29 });
+            expect(result.pillar).toMatch(/^[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]$/);
+        });
+        it("should calculate day pillar for year boundary", () => {
+            const dec31 = dayPillarFromDate({ year: 1999, month: 12, day: 31 });
+            const jan01 = dayPillarFromDate({ year: 2000, month: 1, day: 1 });
+            expect((jan01.idx60 - dec31.idx60 + 60) % 60).toBe(1);
+        });
+    });
+    describe("yearPillar", () => {
+        it("should calculate year pillar for 1984 (甲子)", () => {
+            const dt = DateTime.fromObject({ year: 1984, month: 3, day: 1 }, { zone: "Asia/Seoul" });
+            const result = yearPillar(adapter, dt);
+            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" });
+            const result = yearPillar(adapter, dt);
+            expect(result.pillar).toBe("壬申");
+            expect(result.solarYear).toBe(1992);
+        });
+        it("should handle date before Lichun (立春)", () => {
+            const dt = DateTime.fromObject({ year: 1992, month: 1, day: 15 }, { zone: "Asia/Seoul" });
+            const result = yearPillar(adapter, dt);
+            expect(result.solarYear).toBe(1991);
+        });
+        it("should handle date after Lichun", () => {
+            const dt = DateTime.fromObject({ year: 1992, month: 3, day: 1 }, { zone: "Asia/Seoul" });
+            const result = yearPillar(adapter, dt);
+            expect(result.solarYear).toBe(1992);
+        });
+        it("should follow 60-year cycle", () => {
+            const dt1 = DateTime.fromObject({ year: 1984, month: 3, day: 1 }, { zone: "Asia/Seoul" });
+            const dt2 = DateTime.fromObject({ year: 2044, month: 3, day: 1 }, { zone: "Asia/Seoul" });
+            const result1 = yearPillar(adapter, dt1);
+            const result2 = yearPillar(adapter, dt2);
+            expect(result1.pillar).toBe(result2.pillar);
+        });
+    });
+    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" });
+            const result = monthPillar(adapter, dt);
+            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 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 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 result1 = monthPillar(adapter, jan);
+            const result2 = monthPillar(adapter, jul);
+            expect(result1.pillar).not.toBe(result2.pillar);
+        });
+    });
+    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 result = effectiveDayDate(adapter, dt, { dayBoundary: "midnight" });
+            expect(result.year).toBe(1992);
+            expect(result.month).toBe(10);
+            expect(result.day).toBe(12);
+        });
+        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 result = effectiveDayDate(adapter, dt, { dayBoundary: "zi23" });
+            expect(result.year).toBe(1992);
+            expect(result.month).toBe(10);
+            expect(result.day).toBe(13);
+        });
+        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 result = effectiveDayDate(adapter, dt, { dayBoundary: "zi23" });
+            expect(result.year).toBe(1992);
+            expect(result.month).toBe(10);
+            expect(result.day).toBe(12);
+        });
+        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 result = effectiveDayDate(adapter, dt, { dayBoundary: "zi23" });
+            expect(result.year).toBe(1992);
+            expect(result.month).toBe(11);
+            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 result = effectiveDayDate(adapter, dt, {
+                dayBoundary: "zi23",
+                longitudeDeg: 126.9,
+                useMeanSolarTimeForBoundary: true,
+            });
+            expect(result.day).toBe(13);
+        });
+    });
+    describe("hourPillar", () => {
+        it("should calculate hour pillar for test case (2000-01-01 18:00)", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Seoul" });
+            const result = hourPillar(adapter, dt);
+            expect(result.pillar).toBe("辛酉");
+        });
+        it("should return valid stem-branch combination", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Seoul" });
+            const result = hourPillar(adapter, dt);
+            expect(result.pillar).toMatch(/^[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]$/);
+        });
+        it("should calculate different hours correctly", () => {
+            const morning = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 8, minute: 0 }, { zone: "Asia/Seoul" });
+            const evening = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 20, minute: 0 }, { zone: "Asia/Seoul" });
+            const result1 = hourPillar(adapter, morning);
+            const result2 = hourPillar(adapter, evening);
+            expect(result1.pillar).not.toBe(result2.pillar);
+        });
+        it("should apply mean solar time correction when enabled", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Seoul" });
+            const withCorrection = hourPillar(adapter, dt, {
+                longitudeDeg: 126.9,
+                useMeanSolarTimeForHour: true,
+            });
+            const withoutCorrection = hourPillar(adapter, dt, {
+                longitudeDeg: 126.9,
+                useMeanSolarTimeForHour: false,
+            });
+            expect(withCorrection.adjustedDt).not.toBe(withoutCorrection.adjustedDt);
+        });
+    });
+    describe("getFourPillars - Preset A", () => {
+        it("should calculate four pillars with preset A", () => {
+            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.year).toBe("己卯");
+            expect(result.month).toBe("丙子");
+            expect(result.day).toBe("庚辰");
+            expect(result.hour).toBe("辛酉");
+        });
+        it("should include metadata", () => {
+            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.meta.solarYearUsed).toBe(1999);
+            expect(result.meta.sunLonDeg).toBeGreaterThan(0);
+            expect(result.meta.effectiveDayDate).toEqual({ year: 2000, month: 1, day: 1 });
+            expect(result.meta.preset).toEqual(presetA);
+        });
+    });
+    describe("getFourPillars - Preset B", () => {
+        it("should calculate four pillars with preset B", () => {
+            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: presetB,
+            });
+            expect(result.year).toMatch(/^[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]$/);
+            expect(result.month).toMatch(/^[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]$/);
+            expect(result.day).toMatch(/^[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]$/);
+            expect(result.hour).toMatch(/^[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]$/);
+        });
+        it("should apply solar time corrections with preset B", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Seoul" });
+            const resultA = getFourPillars(adapter, dt, {
+                longitudeDeg: 126.9,
+                preset: presetA,
+            });
+            const resultB = getFourPillars(adapter, dt, {
+                longitudeDeg: 126.9,
+                preset: presetB,
+            });
+            expect(resultA).not.toEqual(resultB);
+        });
+    });
+    describe("getFourPillars - Edge cases", () => {
+        it("should handle date near 23:00 boundary", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 23, minute: 30 }, { zone: "Asia/Seoul" });
+            const resultA = getFourPillars(adapter, dt, {
+                longitudeDeg: 126.9,
+                preset: presetA,
+            });
+            const _resultB = getFourPillars(adapter, dt, {
+                longitudeDeg: 126.9,
+                preset: presetB,
+            });
+            expect(resultA.meta.effectiveDayDate.day).toBe(1);
+        });
+        it("should require longitudeDeg parameter", () => {
+            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");
+        });
+        it("should handle leap year dates", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 2, day: 29 }, { zone: "UTC" });
+            const result = getFourPillars(adapter, dt, {
+                longitudeDeg: 0,
+                preset: presetA,
+            });
+            expect(result.year).toMatch(/^[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]$/);
+            expect(result.month).toMatch(/^[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]$/);
+            expect(result.day).toMatch(/^[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]$/);
+            expect(result.hour).toMatch(/^[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]$/);
+        });
+        it("should handle year boundary", () => {
+            const dt = DateTime.fromObject({ year: 1999, month: 12, day: 31, hour: 23, minute: 59 }, { zone: "UTC" });
+            const result = getFourPillars(adapter, dt, {
+                longitudeDeg: 0,
+                preset: presetA,
+            });
+            expect(result.meta.effectiveDayDate.year).toBe(1999);
+            expect(result.meta.effectiveDayDate.month).toBe(12);
+            expect(result.meta.effectiveDayDate.day).toBe(31);
+        });
+        it("should handle different timezones", () => {
+            const seoul = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Seoul" });
+            const tokyo = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Tokyo" });
+            const resultSeoul = getFourPillars(adapter, seoul, {
+                longitudeDeg: 126.9,
+                preset: presetA,
+            });
+            const resultTokyo = getFourPillars(adapter, tokyo, {
+                longitudeDeg: 139.7,
+                preset: presetA,
+            });
+            expect(resultSeoul.year).toBe(resultTokyo.year);
+            expect(resultSeoul.month).toBe(resultTokyo.month);
+            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 westLong = getFourPillars(adapter, dt, {
+                longitudeDeg: -120,
+                preset: presetB,
+            });
+            const eastLong = getFourPillars(adapter, dt, {
+                longitudeDeg: 120,
+                preset: presetB,
+            });
+            expect(westLong.hour).not.toBe(eastLong.hour);
+        });
+    });
+});

package/dist/__tests__/luxon-adapter.test.d.ts

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

package/dist/__tests__/luxon-adapter.test.d.ts.map

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

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

@@ -0,0 +1,166 @@
+import { DateTime } from "luxon";
+import { beforeAll, describe, expect, it } from "vitest";
+import { createLuxonAdapter } from "@/adapters/luxon";
+describe("Luxon Adapter", () => {
+    let adapter;
+    beforeAll(async () => {
+        adapter = await createLuxonAdapter();
+    });
+    describe("Basic date getters", () => {
+        it("should get year correctly", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1 }, { zone: "Asia/Seoul" });
+            expect(adapter.getYear(dt)).toBe(2000);
+        });
+        it("should get month correctly (1-based)", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1 }, { zone: "Asia/Seoul" });
+            expect(adapter.getMonth(dt)).toBe(1);
+        });
+        it("should get day correctly", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1 }, { zone: "Asia/Seoul" });
+            expect(adapter.getDay(dt)).toBe(1);
+        });
+        it("should get hour correctly", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Seoul" });
+            expect(adapter.getHour(dt)).toBe(18);
+        });
+        it("should get minute correctly", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Seoul" });
+            expect(adapter.getMinute(dt)).toBe(0);
+        });
+        it("should get second correctly", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0, second: 30 }, { zone: "Asia/Seoul" });
+            expect(adapter.getSecond(dt)).toBe(30);
+        });
+        it("should get zone name correctly", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1 }, { zone: "Asia/Seoul" });
+            expect(adapter.getZoneName(dt)).toBe("Asia/Seoul");
+        });
+    });
+    describe("Date arithmetic", () => {
+        it("should add minutes correctly", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Seoul" });
+            const result = adapter.plusMinutes(dt, 30);
+            expect(adapter.getMinute(result)).toBe(30);
+            expect(adapter.getHour(result)).toBe(18);
+        });
+        it("should add minutes with hour overflow", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 23, minute: 45 }, { zone: "Asia/Seoul" });
+            const result = adapter.plusMinutes(dt, 30);
+            expect(adapter.getHour(result)).toBe(0);
+            expect(adapter.getMinute(result)).toBe(15);
+            expect(adapter.getDay(result)).toBe(2);
+        });
+        it("should add days correctly", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1 }, { zone: "Asia/Seoul" });
+            const result = adapter.plusDays(dt, 5);
+            expect(adapter.getDay(result)).toBe(6);
+            expect(adapter.getMonth(result)).toBe(1);
+        });
+        it("should add days with month overflow", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 30 }, { zone: "Asia/Seoul" });
+            const result = adapter.plusDays(dt, 5);
+            expect(adapter.getDay(result)).toBe(4);
+            expect(adapter.getMonth(result)).toBe(2);
+        });
+        it("should subtract days correctly", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 10 }, { zone: "Asia/Seoul" });
+            const result = adapter.minusDays(dt, 5);
+            expect(adapter.getDay(result)).toBe(5);
+            expect(adapter.getMonth(result)).toBe(1);
+        });
+        it("should subtract days with month underflow", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 2, day: 3 }, { zone: "Asia/Seoul" });
+            const result = adapter.minusDays(dt, 5);
+            expect(adapter.getDay(result)).toBe(29);
+            expect(adapter.getMonth(result)).toBe(1);
+        });
+    });
+    describe("Timezone operations", () => {
+        it("should convert to UTC correctly", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Seoul" });
+            const utc = adapter.toUTC(dt);
+            expect(adapter.getZoneName(utc)).toBe("UTC");
+            expect(adapter.getHour(utc)).toBe(9);
+        });
+        it("should set zone correctly", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Seoul" });
+            const ny = adapter.setZone(dt, "America/New_York");
+            expect(adapter.getZoneName(ny)).toBe("America/New_York");
+            expect(adapter.getHour(ny)).toBe(4);
+        });
+        it("should preserve instant when setting zone", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Seoul" });
+            const ny = adapter.setZone(dt, "America/New_York");
+            expect(adapter.toMillis(dt)).toBe(adapter.toMillis(ny));
+        });
+    });
+    describe("Conversion methods", () => {
+        it("should convert to ISO string", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Seoul" });
+            const iso = adapter.toISO(dt);
+            expect(iso).toContain("2000-01-01");
+            expect(iso).toContain("18:00");
+        });
+        it("should convert to milliseconds", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Seoul" });
+            const millis = adapter.toMillis(dt);
+            expect(typeof millis).toBe("number");
+            expect(millis).toBeGreaterThan(0);
+        });
+        it("should create date from milliseconds", () => {
+            const millis = 946717200000;
+            const dt = adapter.fromMillis(millis, "Asia/Seoul");
+            expect(adapter.getYear(dt)).toBe(2000);
+            expect(adapter.getMonth(dt)).toBe(1);
+            expect(adapter.getDay(dt)).toBe(1);
+        });
+    });
+    describe("UTC date creation", () => {
+        it("should create UTC date correctly", () => {
+            const dt = adapter.createUTC(2000, 2, 5, 12, 30, 45);
+            expect(adapter.getYear(dt)).toBe(2000);
+            expect(adapter.getMonth(dt)).toBe(2);
+            expect(adapter.getDay(dt)).toBe(5);
+            expect(adapter.getHour(dt)).toBe(12);
+            expect(adapter.getMinute(dt)).toBe(30);
+            expect(adapter.getSecond(dt)).toBe(45);
+            expect(adapter.getZoneName(dt)).toBe("UTC");
+        });
+    });
+    describe("Date comparison", () => {
+        it("should compare dates correctly (greater than)", () => {
+            const dt1 = DateTime.fromObject({ year: 2000, month: 1, day: 2 }, { zone: "UTC" });
+            const dt2 = DateTime.fromObject({ year: 2000, month: 1, day: 1 }, { zone: "UTC" });
+            expect(adapter.isGreaterThanOrEqual(dt1, dt2)).toBe(true);
+        });
+        it("should compare dates correctly (equal)", () => {
+            const dt1 = DateTime.fromObject({ year: 2000, month: 1, day: 1 }, { zone: "UTC" });
+            const dt2 = DateTime.fromObject({ year: 2000, month: 1, day: 1 }, { zone: "UTC" });
+            expect(adapter.isGreaterThanOrEqual(dt1, dt2)).toBe(true);
+        });
+        it("should compare dates correctly (less than)", () => {
+            const dt1 = DateTime.fromObject({ year: 1999, month: 12, day: 31 }, { zone: "UTC" });
+            const dt2 = DateTime.fromObject({ year: 2000, month: 1, day: 1 }, { zone: "UTC" });
+            expect(adapter.isGreaterThanOrEqual(dt1, dt2)).toBe(false);
+        });
+    });
+    describe("Edge cases", () => {
+        it("should handle leap year correctly", () => {
+            const dt = DateTime.fromObject({ year: 2000, month: 2, day: 29 }, { zone: "UTC" });
+            expect(adapter.getDay(dt)).toBe(29);
+            expect(adapter.getMonth(dt)).toBe(2);
+        });
+        it("should handle year boundary", () => {
+            const dt = DateTime.fromObject({ year: 1999, month: 12, day: 31, hour: 23, minute: 59 }, { zone: "UTC" });
+            const result = adapter.plusMinutes(dt, 2);
+            expect(adapter.getYear(result)).toBe(2000);
+            expect(adapter.getMonth(result)).toBe(1);
+            expect(adapter.getDay(result)).toBe(1);
+        });
+        it("should handle different timezones at same instant", () => {
+            const seoul = DateTime.fromObject({ year: 2000, month: 1, day: 1, hour: 18, minute: 0 }, { zone: "Asia/Seoul" });
+            const utc = adapter.toUTC(seoul);
+            expect(adapter.toMillis(seoul)).toBe(adapter.toMillis(utc));
+        });
+    });
+});