fix(saju): support plain Date in date-fns adapter

Author: gracefullight

packages/saju/README.ko.md

@@ -151,16 +151,20 @@ import { getFourPillars, STANDARD_PRESET } from "@gracefullight/saju";
 
 const adapter = await createDateFnsAdapter();
 
-const dt = {
-  date: new Date(1985, 4, 15, 14, 30), // 주의: 월은 0부터 시작
-  timeZone: "Asia/Seoul",
-};
+// 일반 Date를 바로 사용할 수 있습니다
+const dt = new Date(1985, 4, 15, 14, 30); // 주의: 월은 0부터 시작
 
 const result = getFourPillars(dt, {
   adapter,
   longitudeDeg: 126.9778,
   preset: STANDARD_PRESET,
 });
+
+// 명시적인 타임존 메타데이터가 필요하면 래퍼 객체도 계속 사용할 수 있습니다
+const zonedDt = {
+  date: new Date(1985, 4, 15, 14, 30),
+  timeZone: "Asia/Seoul",
+};
 ```
 
 ### 커스텀 날짜 어댑터

packages/saju/README.md

@@ -151,16 +151,20 @@ import { getFourPillars, STANDARD_PRESET } from "@gracefullight/saju";
 
 const adapter = await createDateFnsAdapter();
 
-const dt = {
-  date: new Date(1985, 4, 15, 14, 30), // Note: month is 0-indexed
-  timeZone: "Asia/Seoul",
-};
+// Plain Date works directly
+const dt = new Date(1985, 4, 15, 14, 30); // Note: month is 0-indexed
 
 const result = getFourPillars(dt, {
   adapter,
   longitudeDeg: 126.9778,
   preset: STANDARD_PRESET,
 });
+
+// If you need explicit timezone metadata, you can still pass a wrapper object
+const zonedDt = {
+  date: new Date(1985, 4, 15, 14, 30),
+  timeZone: "Asia/Seoul",
+};
 ```
 
 ### Custom Date Adapter

packages/saju/src/__tests__/date-fns-adapter.test.ts

@@ -1,11 +1,6 @@
 import { beforeAll, describe, expect, it } from "vitest";
 import type { DateAdapter } from "@/adapters/date-adapter";
-import { createDateFnsAdapter } from "@/adapters/date-fns";
-
-interface DateFnsDate {
-  date: Date;
-  timeZone: string;
-}
+import { createDateFnsAdapter, type DateFnsDate } from "@/adapters/date-fns";
 
 describe("date-fns Adapter", () => {
   let adapter: DateAdapter<DateFnsDate>;
@@ -15,6 +10,14 @@ describe("date-fns Adapter", () => {
   });
 
   describe("Basic date getters", () => {
+    it("should accept plain Date values", () => {
+      const dt = new Date(2000, 0, 1, 18, 0);
+      expect(adapter.getYear(dt)).toBe(2000);
+      expect(adapter.getMonth(dt)).toBe(1);
+      expect(adapter.getDay(dt)).toBe(1);
+      expect(adapter.getHour(dt)).toBe(18);
+    });
+
     it("should get year correctly", () => {
       const dt = { date: new Date(2000, 0, 1), timeZone: "Asia/Seoul" };
       expect(adapter.getYear(dt)).toBe(2000);
@@ -49,6 +52,11 @@ describe("date-fns Adapter", () => {
       const dt = { date: new Date(2000, 0, 1), timeZone: "Asia/Seoul" };
       expect(adapter.getZoneName(dt)).toBe("Asia/Seoul");
     });
+
+    it("should fall back to system timezone for plain Date values", () => {
+      const dt = new Date(2000, 0, 1);
+      expect(adapter.getZoneName(dt)).toBe(Intl.DateTimeFormat().resolvedOptions().timeZone);
+    });
   });
 
   describe("Date arithmetic", () => {

packages/saju/src/__tests__/saju.test.ts

@@ -1,5 +1,6 @@
 import { DateTime } from "luxon";
 import { describe, expect, it } from "vitest";
+import { createDateFnsAdapter } from "@/adapters/date-fns";
 import { createLuxonAdapter } from "@/adapters/luxon";
 import { getSaju, STANDARD_PRESET } from "@/index";
 
@@ -194,4 +195,31 @@ describe("getSaju integration", () => {
     expect(result.solarTerms.prevJieDate).toBeDefined();
     expect(result.solarTerms.nextJieDate).toBeDefined();
   });
+
+  it("accepts plain Date with the date-fns adapter (Issue #64 regression)", async () => {
+    const adapter = await createDateFnsAdapter();
+    const dt = new Date(1990, 1, 1, 12, 10);
+
+    expect(() =>
+      getSaju(dt, {
+        adapter,
+        longitudeDeg: 126.9778,
+        gender: "male",
+        preset: STANDARD_PRESET,
+      }),
+    ).not.toThrow();
+
+    const result = getSaju(dt, {
+      adapter,
+      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.lunar.lunarYear).toBeGreaterThan(0);
+  });
 });

packages/saju/src/adapters/date-fns.ts

@@ -1,10 +1,42 @@
 import type { DateAdapter } from "@/adapters/date-adapter";
 
-interface DateFnsDate {
+export interface ZonedDateFnsDate {
   date: Date;
   timeZone: string;
 }
 
+export type DateFnsDate = Date | ZonedDateFnsDate;
+
+function isZonedDate(date: DateFnsDate): date is ZonedDateFnsDate {
+  return (
+    typeof date === "object" &&
+    date !== null &&
+    "date" in date &&
+    date.date instanceof Date &&
+    typeof date.timeZone === "string"
+  );
+}
+
+function getNativeDate(date: DateFnsDate): Date {
+  return isZonedDate(date) ? date.date : date;
+}
+
+function getSystemTimeZone(): string {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+}
+
+function getTimeZone(date: DateFnsDate): string {
+  return isZonedDate(date) ? date.timeZone : getSystemTimeZone();
+}
+
+function cloneWithTimeZone(date: Date, timeZone: string): ZonedDateFnsDate {
+  return { date, timeZone };
+}
+
+function preserveInputShape(input: DateFnsDate, date: Date): DateFnsDate {
+  return isZonedDate(input) ? cloneWithTimeZone(date, input.timeZone) : date;
+}
+
 export async function createDateFnsAdapter(): Promise<DateAdapter<DateFnsDate>> {
   let addMinutes: typeof import("date-fns").addMinutes;
   let addDays: typeof import("date-fns").addDays;
@@ -42,43 +74,27 @@ export async function createDateFnsAdapter(): Promise<DateAdapter<DateFnsDate>>
   }
 
   return {
-    getYear: (dateFns) => getYear(dateFns.date),
-    getMonth: (dateFns) => getMonth(dateFns.date) + 1,
-    getDay: (dateFns) => getDate(dateFns.date),
-    getHour: (dateFns) => getHours(dateFns.date),
-    getMinute: (dateFns) => getMinutes(dateFns.date),
-    getSecond: (dateFns) => getSeconds(dateFns.date),
-    getZoneName: (dateFns) => dateFns.timeZone,
-    plusMinutes: (dateFns, minutes) => ({
-      date: addMinutes(dateFns.date, minutes),
-      timeZone: dateFns.timeZone,
-    }),
-    plusDays: (dateFns, days) => ({
-      date: addDays(dateFns.date, days),
-      timeZone: dateFns.timeZone,
-    }),
-    minusDays: (dateFns, days) => ({
-      date: subDays(dateFns.date, days),
-      timeZone: dateFns.timeZone,
-    }),
-    toUTC: (dateFns) => ({
-      date: fromZonedTime(dateFns.date, dateFns.timeZone),
-      timeZone: "UTC",
-    }),
-    toISO: (dateFns) => formatISO(dateFns.date),
-    toMillis: (dateFns) => dateFns.date.getTime(),
-    fromMillis: (millis, zone) => ({
-      date: new Date(millis),
-      timeZone: zone,
-    }),
-    createUTC: (year, month, day, hour, minute, second) => ({
-      date: new Date(Date.UTC(year, month - 1, day, hour, minute, second)),
-      timeZone: "UTC",
-    }),
-    setZone: (dateFns, zoneName) => ({
-      date: toZonedTime(dateFns.date, zoneName),
-      timeZone: zoneName,
-    }),
-    isGreaterThanOrEqual: (date1, date2) => date1.date >= date2.date,
+    getYear: (dateFns) => getYear(getNativeDate(dateFns)),
+    getMonth: (dateFns) => getMonth(getNativeDate(dateFns)) + 1,
+    getDay: (dateFns) => getDate(getNativeDate(dateFns)),
+    getHour: (dateFns) => getHours(getNativeDate(dateFns)),
+    getMinute: (dateFns) => getMinutes(getNativeDate(dateFns)),
+    getSecond: (dateFns) => getSeconds(getNativeDate(dateFns)),
+    getZoneName: (dateFns) => getTimeZone(dateFns),
+    plusMinutes: (dateFns, minutes) =>
+      preserveInputShape(dateFns, addMinutes(getNativeDate(dateFns), minutes)),
+    plusDays: (dateFns, days) => preserveInputShape(dateFns, addDays(getNativeDate(dateFns), days)),
+    minusDays: (dateFns, days) =>
+      preserveInputShape(dateFns, subDays(getNativeDate(dateFns), days)),
+    toUTC: (dateFns) =>
+      cloneWithTimeZone(fromZonedTime(getNativeDate(dateFns), getTimeZone(dateFns)), "UTC"),
+    toISO: (dateFns) => formatISO(getNativeDate(dateFns)),
+    toMillis: (dateFns) => getNativeDate(dateFns).getTime(),
+    fromMillis: (millis, zone) => cloneWithTimeZone(new Date(millis), zone),
+    createUTC: (year, month, day, hour, minute, second) =>
+      cloneWithTimeZone(new Date(Date.UTC(year, month - 1, day, hour, minute, second)), "UTC"),
+    setZone: (dateFns, zoneName) =>
+      cloneWithTimeZone(toZonedTime(getNativeDate(dateFns), zoneName), zoneName),
+    isGreaterThanOrEqual: (date1, date2) => getNativeDate(date1) >= getNativeDate(date2),
   };
 }