@kalyx/core 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,9 +1,538 @@
-// @kalyx/core — 플랫폼 독립 날짜 로직
-// 어댑터
-export { DateFnsAdapter } from './adapters/date-fns.js';
-// 유틸
-export { getCalendarDays, isDateDisabled, minDate, maxDate } from './utils/calendar.js';
-export { normalizeISO, parseInputValue } from './utils/date.js';
-export { setTime, getTime, parseTimeString, formatTimeString, formatTimeFromISO, to12Hour, to24Hour, generateHours, generateMinutes, isSameTime, } from './utils/time.js';
-export { getMonthName, formatMonthYear, getWeekdayNames, formatFullDate, } from './utils/locale.js';
-//# sourceMappingURL=index.js.map
+// src/adapters/date-fns.ts
+import {
+  parseISO,
+  addDays as dfAddDays,
+  addMonths as dfAddMonths,
+  addYears as dfAddYears,
+  isBefore as dfIsBefore,
+  isAfter as dfIsAfter,
+  isValid as dfIsValid
+} from "date-fns";
+function toDate(iso) {
+  return parseISO(iso);
+}
+function toISO(date) {
+  return date.toISOString();
+}
+function normalize(value) {
+  if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+    return `${value}T00:00:00.000Z`;
+  }
+  return value;
+}
+function utcStartOfDay(d) {
+  return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
+}
+function utcStartOfMonth(d) {
+  return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), 1));
+}
+function utcEndOfMonth(d) {
+  return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + 1, 0, 23, 59, 59, 999));
+}
+function utcStartOfWeek(d, weekStartsOn) {
+  const day = d.getUTCDay();
+  const diff = (day - weekStartsOn + 7) % 7;
+  return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate() - diff));
+}
+function utcEndOfWeek(d, weekStartsOn) {
+  const start = utcStartOfWeek(d, weekStartsOn);
+  return new Date(Date.UTC(
+    start.getUTCFullYear(),
+    start.getUTCMonth(),
+    start.getUTCDate() + 6,
+    23,
+    59,
+    59,
+    999
+  ));
+}
+var DateFnsAdapter = {
+  parse(value) {
+    if (!value) return "";
+    return normalize(value);
+  },
+  format(iso, formatStr) {
+    const d = toDate(iso);
+    const tokens = {
+      yyyy: String(d.getUTCFullYear()),
+      MM: String(d.getUTCMonth() + 1).padStart(2, "0"),
+      dd: String(d.getUTCDate()).padStart(2, "0"),
+      HH: String(d.getUTCHours()).padStart(2, "0"),
+      mm: String(d.getUTCMinutes()).padStart(2, "0"),
+      ss: String(d.getUTCSeconds()).padStart(2, "0"),
+      M: String(d.getUTCMonth() + 1),
+      d: String(d.getUTCDate())
+    };
+    let result = formatStr;
+    for (const [token, value] of Object.entries(tokens).sort((a, b) => b[0].length - a[0].length)) {
+      result = result.split(token).join(value);
+    }
+    return result;
+  },
+  addDays(iso, n) {
+    return toISO(dfAddDays(toDate(iso), n));
+  },
+  addMonths(iso, n) {
+    return toISO(dfAddMonths(toDate(iso), n));
+  },
+  addYears(iso, n) {
+    return toISO(dfAddYears(toDate(iso), n));
+  },
+  isBefore(a, b) {
+    return dfIsBefore(toDate(a), toDate(b));
+  },
+  isAfter(a, b) {
+    return dfIsAfter(toDate(a), toDate(b));
+  },
+  isSameDay(a, b) {
+    if (!a || !b) return false;
+    const da = toDate(a);
+    const db = toDate(b);
+    return da.getUTCFullYear() === db.getUTCFullYear() && da.getUTCMonth() === db.getUTCMonth() && da.getUTCDate() === db.getUTCDate();
+  },
+  isSameMonth(a, b) {
+    const da = toDate(a);
+    const db = toDate(b);
+    return da.getUTCFullYear() === db.getUTCFullYear() && da.getUTCMonth() === db.getUTCMonth();
+  },
+  startOfDay(iso) {
+    return toISO(utcStartOfDay(toDate(iso)));
+  },
+  startOfMonth(iso) {
+    return toISO(utcStartOfMonth(toDate(iso)));
+  },
+  endOfMonth(iso) {
+    return toISO(utcEndOfMonth(toDate(iso)));
+  },
+  startOfWeek(iso, weekStartsOn = 0) {
+    return toISO(utcStartOfWeek(toDate(iso), weekStartsOn));
+  },
+  endOfWeek(iso, weekStartsOn = 0) {
+    return toISO(utcEndOfWeek(toDate(iso), weekStartsOn));
+  },
+  now() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  },
+  today() {
+    return toISO(utcStartOfDay(/* @__PURE__ */ new Date()));
+  },
+  isValid(value) {
+    if (!value) return false;
+    const normalized = normalize(value);
+    const date = parseISO(normalized);
+    return dfIsValid(date);
+  },
+  getYear(iso) {
+    return toDate(iso).getUTCFullYear();
+  },
+  getMonth(iso) {
+    return toDate(iso).getUTCMonth();
+  },
+  getDate(iso) {
+    return toDate(iso).getUTCDate();
+  },
+  getDay(iso) {
+    return toDate(iso).getUTCDay();
+  }
+};
+
+// src/utils/calendar.ts
+function getCalendarDays(monthISO, adapter, options = {}) {
+  const {
+    weekStartsOn = 0,
+    today,
+    selected,
+    focusedDate,
+    disabled = [],
+    range,
+    rangeHover
+  } = options;
+  const todayISO = today ?? adapter.today();
+  const monthStart = adapter.startOfMonth(monthISO);
+  const gridStart = adapter.startOfWeek(monthStart, weekStartsOn);
+  const normalizedRange = normalizeRangeForDisplay(range, rangeHover, adapter);
+  const weeks = [];
+  let current = gridStart;
+  for (let week = 0; week < 6; week++) {
+    const days = [];
+    for (let day = 0; day < 7; day++) {
+      const isCurrentMonth = adapter.isSameMonth(current, monthISO);
+      const isTodayDate = adapter.isSameDay(current, todayISO);
+      const isSelected_ = selected ? adapter.isSameDay(current, selected) : false;
+      const isFocused_ = focusedDate ? adapter.isSameDay(current, focusedDate) : false;
+      const isDisabled_ = isDateDisabled(current, disabled, adapter);
+      const rangeFlags = computeRangeFlags(current, normalizedRange, adapter);
+      days.push({
+        isoString: current,
+        dayNumber: adapter.getDate(current),
+        isCurrentMonth,
+        isToday: isTodayDate,
+        isSelected: isSelected_,
+        isDisabled: isDisabled_,
+        isFocused: isFocused_,
+        ...rangeFlags
+      });
+      current = adapter.addDays(current, 1);
+    }
+    weeks.push(days);
+    if (!adapter.isSameMonth(current, monthISO) && week >= 3) {
+      break;
+    }
+  }
+  return weeks;
+}
+function normalizeRangeForDisplay(range, hover, adapter) {
+  if (!range) return { start: null, end: null };
+  const { start, end } = range;
+  if (start && end) {
+    if (adapter.isAfter(start, end)) {
+      return { start: end, end: start };
+    }
+    return { start, end };
+  }
+  if (start && !end && hover) {
+    if (adapter.isAfter(start, hover)) {
+      return { start: hover, end: start };
+    }
+    return { start, end: hover };
+  }
+  if (start && !end) {
+    return { start, end: null };
+  }
+  return { start: null, end: null };
+}
+function computeRangeFlags(iso, range, adapter) {
+  const { start, end } = range;
+  if (!start) {
+    return { isRangeStart: false, isRangeEnd: false, isInRange: false };
+  }
+  const isRangeStart = adapter.isSameDay(iso, start);
+  if (!end) {
+    return { isRangeStart, isRangeEnd: false, isInRange: false };
+  }
+  const isRangeEnd = adapter.isSameDay(iso, end);
+  const isInRange = !isRangeStart && !isRangeEnd && adapter.isAfter(iso, start) && adapter.isBefore(iso, end);
+  return { isRangeStart, isRangeEnd, isInRange };
+}
+function isDateDisabled(iso, rules, adapter) {
+  for (const rule of rules) {
+    if ("date" in rule) {
+      if (adapter.isSameDay(iso, rule.date)) return true;
+    } else if ("before" in rule) {
+      if (adapter.isBefore(iso, rule.before)) return true;
+    } else if ("after" in rule) {
+      if (adapter.isAfter(iso, rule.after)) return true;
+    } else if ("dayOfWeek" in rule) {
+      if (rule.dayOfWeek.includes(adapter.getDay(iso))) return true;
+    }
+  }
+  return false;
+}
+function minDate(a, b, adapter) {
+  return adapter.isBefore(a, b) ? a : b;
+}
+function maxDate(a, b, adapter) {
+  return adapter.isAfter(a, b) ? a : b;
+}
+
+// src/utils/date.ts
+var ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+var ISO_DATETIME_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+function normalizeISO(value) {
+  if (!value) return "";
+  if (ISO_DATETIME_REGEX.test(value)) return value;
+  if (ISO_DATE_REGEX.test(value)) return `${value}T00:00:00.000Z`;
+  return value;
+}
+function parseInputValue(input, adapter) {
+  if (!input.trim()) return null;
+  const cleaned = input.replace(/\//g, "-").trim();
+  if (ISO_DATE_REGEX.test(cleaned)) {
+    const normalized = normalizeISO(cleaned);
+    if (adapter.isValid(normalized)) {
+      return normalized;
+    }
+  }
+  if (/^\d{8}$/.test(cleaned)) {
+    const formatted = `${cleaned.slice(0, 4)}-${cleaned.slice(4, 6)}-${cleaned.slice(6, 8)}`;
+    const normalized = normalizeISO(formatted);
+    if (adapter.isValid(normalized)) {
+      return normalized;
+    }
+  }
+  return null;
+}
+
+// src/utils/time.ts
+function setTime(iso, time) {
+  const date = new Date(iso);
+  if (time.hours !== void 0) date.setUTCHours(time.hours);
+  if (time.minutes !== void 0) date.setUTCMinutes(time.minutes);
+  if (time.seconds !== void 0) date.setUTCSeconds(time.seconds);
+  return date.toISOString();
+}
+function getTime(iso) {
+  const date = new Date(iso);
+  return {
+    hours: date.getUTCHours(),
+    minutes: date.getUTCMinutes(),
+    seconds: date.getUTCSeconds()
+  };
+}
+function parseTimeString(input) {
+  if (!input) return null;
+  const match = input.trim().match(/^(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?$/);
+  if (!match) return null;
+  const hours = parseInt(match[1], 10);
+  const minutes = parseInt(match[2], 10);
+  const seconds = match[3] ? parseInt(match[3], 10) : 0;
+  if (hours < 0 || hours > 23) return null;
+  if (minutes < 0 || minutes > 59) return null;
+  if (seconds < 0 || seconds > 59) return null;
+  return { hours, minutes, seconds };
+}
+function formatTimeString(time, withSeconds = false) {
+  const hh = String(time.hours).padStart(2, "0");
+  const mm = String(time.minutes).padStart(2, "0");
+  if (withSeconds) {
+    const ss = String(time.seconds).padStart(2, "0");
+    return `${hh}:${mm}:${ss}`;
+  }
+  return `${hh}:${mm}`;
+}
+function to12Hour(hours24) {
+  const period = hours24 >= 12 ? "PM" : "AM";
+  let hours12 = hours24 % 12;
+  if (hours12 === 0) hours12 = 12;
+  return { hours12, period };
+}
+function to24Hour(hours12, period) {
+  if (period === "AM") {
+    return hours12 === 12 ? 0 : hours12;
+  }
+  return hours12 === 12 ? 12 : hours12 + 12;
+}
+function generateHours(format = "24h") {
+  if (format === "12h") {
+    return Array.from({ length: 12 }, (_, i) => i + 1);
+  }
+  return Array.from({ length: 24 }, (_, i) => i);
+}
+function generateMinutes(step = 1) {
+  if (step < 1 || step > 30) {
+    throw new Error(`[generateMinutes] step must be between 1 and 30, got ${step}`);
+  }
+  const result = [];
+  for (let i = 0; i < 60; i += step) {
+    result.push(i);
+  }
+  return result;
+}
+function isSameTime(a, b) {
+  return a.hours === b.hours && a.minutes === b.minutes && a.seconds === b.seconds;
+}
+function formatTimeFromISO(iso, format) {
+  const time = getTime(iso);
+  if (format === "h:mm a" || format === "h:mm:ss a") {
+    const { hours12, period } = to12Hour(time.hours);
+    const mm = String(time.minutes).padStart(2, "0");
+    if (format === "h:mm a") {
+      return `${hours12}:${mm} ${period}`;
+    }
+    const ss = String(time.seconds).padStart(2, "0");
+    return `${hours12}:${mm}:${ss} ${period}`;
+  }
+  return formatTimeString(time, format === "HH:mm:ss");
+}
+
+// src/utils/locale.ts
+var formatterCache = /* @__PURE__ */ new Map();
+function getCachedFormatter(locale, options) {
+  const key = `${locale}:${JSON.stringify(options)}`;
+  let fmt = formatterCache.get(key);
+  if (!fmt) {
+    fmt = new Intl.DateTimeFormat(locale, options);
+    formatterCache.set(key, fmt);
+  }
+  return fmt;
+}
+var REFERENCE_YEAR = 2026;
+function getMonthName(month, locale = "en-US") {
+  const date = new Date(Date.UTC(REFERENCE_YEAR, month, 1));
+  return getCachedFormatter(locale, { month: "long", timeZone: "UTC" }).format(date);
+}
+function formatMonthYear(year, month, locale = "en-US") {
+  const date = new Date(Date.UTC(year, month, 1));
+  return getCachedFormatter(locale, {
+    year: "numeric",
+    month: "long",
+    timeZone: "UTC"
+  }).format(date);
+}
+function getWeekdayNames(locale = "en-US", weekStartsOn = 0) {
+  const shortFormatter = getCachedFormatter(locale, { weekday: "short", timeZone: "UTC" });
+  const fullFormatter = getCachedFormatter(locale, { weekday: "long", timeZone: "UTC" });
+  const days = [];
+  for (let i = 0; i < 7; i++) {
+    const date = new Date(Date.UTC(REFERENCE_YEAR, 0, 4 + i));
+    days.push({
+      short: shortFormatter.format(date),
+      full: fullFormatter.format(date)
+    });
+  }
+  if (weekStartsOn === 1) {
+    const sunday = days.shift();
+    days.push(sunday);
+  }
+  return days;
+}
+function formatFullDate(iso, locale = "en-US") {
+  const date = new Date(iso);
+  return getCachedFormatter(locale, {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    weekday: "long",
+    timeZone: "UTC"
+  }).format(date);
+}
+
+// src/utils/timezone.ts
+import { parseISO as parseISO2 } from "date-fns";
+var formatterCache2 = /* @__PURE__ */ new Map();
+function getCachedPartsFormatter(timeZone) {
+  const key = `parts:${timeZone}`;
+  let fmt = formatterCache2.get(key);
+  if (!fmt) {
+    fmt = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hourCycle: "h23"
+    });
+    formatterCache2.set(key, fmt);
+  }
+  return fmt;
+}
+function partsInTimezone(utc, timeZone) {
+  const dtf = getCachedPartsFormatter(timeZone);
+  const parts = Object.fromEntries(
+    dtf.formatToParts(utc).map((p) => [p.type, p.value])
+  );
+  return {
+    year: Number(parts.year),
+    month: Number(parts.month),
+    day: Number(parts.day),
+    // Some locales/engines return '24' instead of '0' at midnight
+    hour: parts.hour === "24" ? 0 : Number(parts.hour),
+    minute: Number(parts.minute),
+    second: Number(parts.second)
+  };
+}
+function formatInTimezone(iso, formatStr, timeZone) {
+  const p = partsInTimezone(parseISO2(iso), timeZone);
+  const tokens = {
+    yyyy: String(p.year),
+    MM: String(p.month).padStart(2, "0"),
+    dd: String(p.day).padStart(2, "0"),
+    HH: String(p.hour).padStart(2, "0"),
+    mm: String(p.minute).padStart(2, "0"),
+    ss: String(p.second).padStart(2, "0")
+  };
+  let result = formatStr;
+  for (const [token, value] of Object.entries(tokens).sort((a, b) => b[0].length - a[0].length)) {
+    result = result.split(token).join(value);
+  }
+  return result;
+}
+function getTimezoneOffsetMinutes(iso, timeZone) {
+  const utc = parseISO2(iso);
+  const p = partsInTimezone(utc, timeZone);
+  const asUtcEpoch = Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second);
+  return Math.round((asUtcEpoch - utc.getTime()) / 6e4);
+}
+function startOfDayInTimezone(iso, timeZone) {
+  const utc = parseISO2(iso);
+  const p = partsInTimezone(utc, timeZone);
+  const civilMidnightUtc = Date.UTC(p.year, p.month - 1, p.day, 0, 0, 0);
+  const midnightProbe = new Date(civilMidnightUtc).toISOString();
+  const offsetMinutes = getTimezoneOffsetMinutes(midnightProbe, timeZone);
+  return new Date(civilMidnightUtc - offsetMinutes * 6e4).toISOString();
+}
+function isSameDayInTimezone(a, b, timeZone) {
+  const pa = partsInTimezone(parseISO2(a), timeZone);
+  const pb = partsInTimezone(parseISO2(b), timeZone);
+  return pa.year === pb.year && pa.month === pb.month && pa.day === pb.day;
+}
+function todayInTimezone(timeZone) {
+  return startOfDayInTimezone((/* @__PURE__ */ new Date()).toISOString(), timeZone);
+}
+
+// src/utils/labels.ts
+var DEFAULT_DATEPICKER_LABELS = {
+  triggerOpen: "Open calendar",
+  triggerClose: "Close calendar",
+  popoverLabel: "Choose date",
+  prevMonth: "Previous month",
+  nextMonth: "Next month",
+  prevYear: "Previous year",
+  nextYear: "Next year",
+  prevDecade: "Previous decade",
+  nextDecade: "Next decade"
+};
+var DEFAULT_RANGEPICKER_LABELS = {
+  ...DEFAULT_DATEPICKER_LABELS,
+  popoverLabel: "Choose date range",
+  startInput: "Start date",
+  endInput: "End date",
+  presetsGroup: "Date range presets"
+};
+var DEFAULT_TIMEPICKER_LABELS = {
+  timeInput: "Time",
+  hourList: "Hour",
+  minuteList: "Minute",
+  amPmToggle: "AM/PM",
+  hourOption: (hour) => `${hour} hours`,
+  minuteOption: (minute) => `${minute} minutes`
+};
+var DEFAULT_DATETIMEPICKER_LABELS = {
+  ...DEFAULT_DATEPICKER_LABELS,
+  ...DEFAULT_TIMEPICKER_LABELS,
+  dateTimeInput: "Date and time"
+};
+export {
+  DEFAULT_DATEPICKER_LABELS,
+  DEFAULT_DATETIMEPICKER_LABELS,
+  DEFAULT_RANGEPICKER_LABELS,
+  DEFAULT_TIMEPICKER_LABELS,
+  DateFnsAdapter,
+  formatFullDate,
+  formatInTimezone,
+  formatMonthYear,
+  formatTimeFromISO,
+  formatTimeString,
+  generateHours,
+  generateMinutes,
+  getCalendarDays,
+  getMonthName,
+  getTime,
+  getTimezoneOffsetMinutes,
+  getWeekdayNames,
+  isDateDisabled,
+  isSameDayInTimezone,
+  isSameTime,
+  maxDate,
+  minDate,
+  normalizeISO,
+  parseInputValue,
+  parseTimeString,
+  setTime,
+  startOfDayInTimezone,
+  to12Hour,
+  to24Hour,
+  todayInTimezone
+};

package/package.json

@@ -1,8 +1,27 @@
 {
   "name": "@kalyx/core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Kalyx core — platform-agnostic date logic",
   "license": "MIT",
+  "author": "jiji-hoon96",
+  "homepage": "https://github.com/jiji-hoon96/kalyx#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jiji-hoon96/kalyx.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/jiji-hoon96/kalyx/issues"
+  },
+  "keywords": [
+    "date",
+    "datepicker",
+    "calendar",
+    "timezone",
+    "iso8601",
+    "utc",
+    "date-fns"
+  ],
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

package/dist/adapters/date-fns.d.ts

@@ -1,16 +0,0 @@
-import type { DateAdapter } from '../types.js';
-/**
- * date-fns 기반 DateAdapter 구현체.
- * 모든 연산은 UTC 기준으로 동작하여 timezone 간섭을 방지한다.
- *
- * @example
- * ```ts
- * import { DateFnsAdapter } from '@kalyx/core';
- *
- * DateFnsAdapter.format('2026-01-15T00:00:00.000Z', 'yyyy-MM-dd'); // "2026-01-15"
- * DateFnsAdapter.addDays('2026-01-15T00:00:00.000Z', 7);           // "2026-01-22T..."
- * DateFnsAdapter.isSameDay('2026-01-15T00:00:00.000Z', '2026-01-15T23:59:59.000Z'); // true
- * ```
- */
-export declare const DateFnsAdapter: DateAdapter;
-//# sourceMappingURL=date-fns.d.ts.map

package/dist/adapters/date-fns.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"date-fns.d.ts","sourceRoot":"","sources":["../../src/adapters/date-fns.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAmD/C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,EAAE,WAsH5B,CAAC"}