@svgrid/grid 2.6.21 → 2.7.0

package/src/date-string-column.test.ts

@@ -0,0 +1,87 @@
+/**
+ * `cellDataType: 'dateString'` columns, which hold an ISO date STRING
+ * ('2026-06-27') rather than a Date or a timestamp.
+ *
+ * Two bugs lived here, both reported from the same demo:
+ *
+ *  1. Committing an edit ran through `parseEditorValue('date', ...)`, which
+ *     does `new Date(v).toISOString()` - so '2026-12-25' was stored as
+ *     '2026-12-25T01:00:00.000Z'. The cell then showed a timestamp next to
+ *     neighbours showing plain dates. `dateString` resolves to
+ *     `editorType: 'date'`, so nothing downstream knew the difference.
+ *
+ *  2. That conversion goes through UTC. A local midnight either side of the
+ *     meridian lands on the previous or next day, so the stored CALENDAR DATE
+ *     depended on where the user was sitting.
+ */
+import { describe, expect, it } from 'vitest'
+import { parseEditorValue } from './editors/cell-editors'
+import { toIsoDateLocal, usesRichDateFilter } from './SvGrid.helpers'
+
+describe('parseEditorValue with dateOnly', () => {
+  it('keeps an ISO date exactly as picked', () => {
+    expect(parseEditorValue('date', '2026-12-25', { dateOnly: true })).toBe('2026-12-25')
+  })
+
+  it('trims a datetime down to its calendar date', () => {
+    expect(parseEditorValue('date', '2026-12-25T09:30', { dateOnly: true })).toBe('2026-12-25')
+  })
+
+  it('never sends the value through UTC', () => {
+    // The bug: a date whose UTC form is the day before. Whatever the runner's
+    // zone, the day the user picked has to be the day that is stored.
+    for (const raw of ['2026-01-01', '2026-12-31', '2026-06-15']) {
+      expect(parseEditorValue('date', raw, { dateOnly: true })).toBe(raw)
+    }
+  })
+
+  it('uses local parts when the input is not already ISO', () => {
+    const d = new Date(2026, 11, 25, 23, 30) // local 25 Dec, late evening
+    const out = parseEditorValue('date', d.toString(), { dateOnly: true })
+    expect(out).toBe('2026-12-25')
+  })
+
+  it('returns null for something that is not a date at all', () => {
+    expect(parseEditorValue('date', 'not a date', { dateOnly: true })).toBeNull()
+  })
+
+  it('leaves the normal date editor alone - it still stores a timestamp', () => {
+    // `cellDataType: 'date'` columns hold Date values and DO want the ISO
+    // timestamp. Only dateString opts out.
+    const out = parseEditorValue('date', '2026-12-25')
+    expect(String(out)).toMatch(/^2026-12-2[45]T/)
+  })
+})
+
+describe('toIsoDateLocal', () => {
+  it('formats from local parts, not UTC', () => {
+    expect(toIsoDateLocal(new Date(2026, 0, 1, 0, 30))).toBe('2026-01-01')
+    expect(toIsoDateLocal(new Date(2026, 11, 31, 23, 30))).toBe('2026-12-31')
+  })
+
+  it('is empty for no date', () => {
+    expect(toIsoDateLocal(null)).toBe('')
+    expect(toIsoDateLocal(undefined)).toBe('')
+    expect(toIsoDateLocal(new Date('nonsense'))).toBe('')
+  })
+})
+
+describe('usesRichDateFilter', () => {
+  it('is on for the date-ish editors', () => {
+    for (const t of ['date', 'datetime', 'time'] as const) {
+      expect(usesRichDateFilter(t), t).toBe(true)
+    }
+  })
+
+  it('honours the -native opt-out, same as the cell editor', () => {
+    for (const t of ['date-native', 'datetime-native', 'time-native'] as const) {
+      expect(usesRichDateFilter(t), t).toBe(false)
+    }
+  })
+
+  it('is off for everything else', () => {
+    for (const t of ['text', 'number', 'list', 'checkbox', undefined] as const) {
+      expect(usesRichDateFilter(t as never), String(t)).toBe(false)
+    }
+  })
+})

package/src/datetime/date-core.ts

@@ -1,206 +1,206 @@
-/**
- * date-core - framework-free date math shared by SvCalendar, SvTimePicker and
- * SvDateTimePicker. No Svelte, no DOM: pure functions over the native `Date`
- * so it is trivially unit- and mutation-testable and reusable standalone.
- *
- * Conventions:
- * - A "day" is compared by local calendar date (year/month/date), ignoring the
- *   time-of-day, unless a helper says otherwise.
- * - `firstDayOfWeek` is 0-6 (0 = Sunday), matching `Date.getDay()` and Smart's
- *   `firstDayOfWeek`.
- */
-
-/** Anything the date helpers accept: a `Date`, epoch milliseconds, or a parseable string. */
-export type DateLike = Date | number | string
-
-/** Coerce a Date | epoch-ms | parseable string to a Date, or null if invalid. */
-export function toDate(value: DateLike | null | undefined): Date | null {
-  if (value == null) return null
-  const d = value instanceof Date ? new Date(value.getTime()) : new Date(value)
-  return isNaN(d.getTime()) ? null : d
-}
-
-/** A new Date at local midnight of the same calendar day (time stripped). */
-export function startOfDay(d: Date): Date {
-  return new Date(d.getFullYear(), d.getMonth(), d.getDate())
-}
-
-/** First day (midnight) of the month `d` falls in. */
-export function startOfMonth(d: Date): Date {
-  return new Date(d.getFullYear(), d.getMonth(), 1)
-}
-
-/** Last day (midnight) of the month `d` falls in. */
-export function endOfMonth(d: Date): Date {
-  return new Date(d.getFullYear(), d.getMonth() + 1, 0)
-}
-
-/** Number of days in the month `d` falls in. */
-export function daysInMonth(d: Date): number {
-  return endOfMonth(d).getDate()
-}
-
-/**
- * Start of the week containing `d`, honoring `firstDayOfWeek` (0-6). Returns a
- * local-midnight Date on or before `d`.
- */
-export function startOfWeek(d: Date, firstDayOfWeek = 0): Date {
-  const start = startOfDay(d)
-  const diff = (start.getDay() - firstDayOfWeek + 7) % 7
-  start.setDate(start.getDate() - diff)
-  return start
-}
-
-/** True when both dates are the same local calendar day. */
-export function isSameDay(a: Date | null, b: Date | null): boolean {
-  if (!a || !b) return false
-  return (
-    a.getFullYear() === b.getFullYear() &&
-    a.getMonth() === b.getMonth() &&
-    a.getDate() === b.getDate()
-  )
-}
-
-/** True when both dates are in the same year+month. */
-export function isSameMonth(a: Date | null, b: Date | null): boolean {
-  if (!a || !b) return false
-  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth()
-}
-
-/** -1 / 0 / 1 comparison by calendar day (time-of-day ignored). */
-export function compareDay(a: Date, b: Date): number {
-  const av = startOfDay(a).getTime()
-  const bv = startOfDay(b).getTime()
-  return av < bv ? -1 : av > bv ? 1 : 0
-}
-
-/** Add `n` days (can be negative), returning a new Date. */
-export function addDays(d: Date, n: number): Date {
-  const r = new Date(d.getTime())
-  r.setDate(r.getDate() + n)
-  return r
-}
-
-/**
- * Add `n` calendar months, clamping the day-of-month so 31 Jan + 1 month = 28/29
- * Feb rather than spilling into March (matches how calendars paginate).
- */
-export function addMonths(d: Date, n: number): Date {
-  const day = d.getDate()
-  const r = new Date(d.getFullYear(), d.getMonth() + n, 1, d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds())
-  r.setDate(Math.min(day, daysInMonth(r)))
-  return r
-}
-
-/** Add `n` years, clamping Feb-29 to Feb-28 on non-leap targets. */
-export function addYears(d: Date, n: number): Date {
-  return addMonths(d, n * 12)
-}
-
-/** Clamp `d` to the inclusive [min, max] range (either bound may be null). */
-export function clampDate(d: Date, min: Date | null, max: Date | null): Date {
-  if (min && d.getTime() < min.getTime()) return new Date(min.getTime())
-  if (max && d.getTime() > max.getTime()) return new Date(max.getTime())
-  return d
-}
-
-/**
- * ISO 8601 week number (1-53) for `d`. Week 1 is the week containing the first
- * Thursday of the year; weeks start Monday. Independent of `firstDayOfWeek`,
- * matching Smart's `weekNumbers` column which is always ISO.
- */
-export function isoWeek(d: Date): number {
-  // Shift to the Thursday of this week, then count weeks from Jan 1.
-  const date = startOfDay(d)
-  const day = (date.getDay() + 6) % 7 // Mon=0..Sun=6
-  date.setDate(date.getDate() - day + 3) // Thursday of this week
-  const firstThursday = new Date(date.getFullYear(), 0, 4)
-  const firstDay = (firstThursday.getDay() + 6) % 7
-  firstThursday.setDate(firstThursday.getDate() - firstDay + 3)
-  const diffMs = date.getTime() - firstThursday.getTime()
-  return 1 + Math.round(diffMs / (7 * 24 * 3600 * 1000))
-}
-
-/**
- * The [start, end] years of the decade block that `year` belongs to, as Smart
- * renders it: a 12-cell page running from the decade start minus 1 to plus 10
- * (one leading + one trailing year for context). We expose the canonical
- * decade [Y0, Y0+9] and let the view pad.
- */
-export function decadeRange(year: number): { start: number; end: number } {
-  const start = Math.floor(year / 10) * 10
-  return { start, end: start + 9 }
-}
-
-/** The [start, end] years of the century block (100-year) `year` belongs to. */
-export function centuryRange(year: number): { start: number; end: number } {
-  const start = Math.floor(year / 100) * 100
-  return { start, end: start + 99 }
-}
-
-/** One cell of a month grid, including the leading and trailing days from adjacent months. */
-export type MonthMatrixCell = {
-  date: Date
-  /** In the displayed month (vs. leading/trailing days of adjacent months). */
-  inMonth: boolean
-  /** ISO week number of the row this cell sits in. */
-  week: number
-}
-
-/**
- * Build a month grid of `weeks` rows x 7 columns starting at `firstDayOfWeek`,
- * padded with the trailing days of the previous month and leading days of the
- * next so every row is full. `weeks` defaults to 6 (the max any month needs),
- * matching Smart's fixed-height calendar.
- */
-export function monthMatrix(
-  monthDate: Date,
-  firstDayOfWeek = 0,
-  weeks = 6,
-): MonthMatrixCell[][] {
-  const first = startOfMonth(monthDate)
-  const gridStart = startOfWeek(first, firstDayOfWeek)
-  const rows: MonthMatrixCell[][] = []
-  let cursor = gridStart
-  for (let r = 0; r < weeks; r++) {
-    const row: MonthMatrixCell[] = []
-    const weekNo = isoWeek(cursor)
-    for (let c = 0; c < 7; c++) {
-      row.push({
-        date: cursor,
-        inMonth: cursor.getMonth() === first.getMonth() && cursor.getFullYear() === first.getFullYear(),
-        week: weekNo,
-      })
-      cursor = addDays(cursor, 1)
-    }
-    rows.push(row)
-  }
-  return rows
-}
-
-/**
- * Ordered weekday indexes (0-6) for a header row starting at `firstDayOfWeek`.
- * e.g. firstDayOfWeek=1 -> [1,2,3,4,5,6,0].
- */
-export function weekdayOrder(firstDayOfWeek = 0): number[] {
-  return Array.from({ length: 7 }, (_, i) => (firstDayOfWeek + i) % 7)
-}
-
-/** Merge a calendar day with a time-of-day taken from `time`, returning a new Date. */
-export function withTime(day: Date, time: Date): Date {
-  return new Date(
-    day.getFullYear(),
-    day.getMonth(),
-    day.getDate(),
-    time.getHours(),
-    time.getMinutes(),
-    time.getSeconds(),
-    time.getMilliseconds(),
-  )
-}
-
-/** Snap a minute value to the nearest lower multiple of `interval` (>=1). */
-export function snapMinute(minute: number, interval: number): number {
-  const step = Math.max(1, Math.floor(interval))
-  return Math.floor(minute / step) * step
-}
+/**
+ * date-core - framework-free date math shared by SvCalendar, SvTimePicker and
+ * SvDateTimePicker. No Svelte, no DOM: pure functions over the native `Date`
+ * so it is trivially unit- and mutation-testable and reusable standalone.
+ *
+ * Conventions:
+ * - A "day" is compared by local calendar date (year/month/date), ignoring the
+ *   time-of-day, unless a helper says otherwise.
+ * - `firstDayOfWeek` is 0-6 (0 = Sunday), matching `Date.getDay()` and Smart's
+ *   `firstDayOfWeek`.
+ */
+
+/** Anything the date helpers accept: a `Date`, epoch milliseconds, or a parseable string. */
+export type DateLike = Date | number | string
+
+/** Coerce a Date | epoch-ms | parseable string to a Date, or null if invalid. */
+export function toDate(value: DateLike | null | undefined): Date | null {
+  if (value == null) return null
+  const d = value instanceof Date ? new Date(value.getTime()) : new Date(value)
+  return isNaN(d.getTime()) ? null : d
+}
+
+/** A new Date at local midnight of the same calendar day (time stripped). */
+export function startOfDay(d: Date): Date {
+  return new Date(d.getFullYear(), d.getMonth(), d.getDate())
+}
+
+/** First day (midnight) of the month `d` falls in. */
+export function startOfMonth(d: Date): Date {
+  return new Date(d.getFullYear(), d.getMonth(), 1)
+}
+
+/** Last day (midnight) of the month `d` falls in. */
+export function endOfMonth(d: Date): Date {
+  return new Date(d.getFullYear(), d.getMonth() + 1, 0)
+}
+
+/** Number of days in the month `d` falls in. */
+export function daysInMonth(d: Date): number {
+  return endOfMonth(d).getDate()
+}
+
+/**
+ * Start of the week containing `d`, honoring `firstDayOfWeek` (0-6). Returns a
+ * local-midnight Date on or before `d`.
+ */
+export function startOfWeek(d: Date, firstDayOfWeek = 0): Date {
+  const start = startOfDay(d)
+  const diff = (start.getDay() - firstDayOfWeek + 7) % 7
+  start.setDate(start.getDate() - diff)
+  return start
+}
+
+/** True when both dates are the same local calendar day. */
+export function isSameDay(a: Date | null, b: Date | null): boolean {
+  if (!a || !b) return false
+  return (
+    a.getFullYear() === b.getFullYear() &&
+    a.getMonth() === b.getMonth() &&
+    a.getDate() === b.getDate()
+  )
+}
+
+/** True when both dates are in the same year+month. */
+export function isSameMonth(a: Date | null, b: Date | null): boolean {
+  if (!a || !b) return false
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth()
+}
+
+/** -1 / 0 / 1 comparison by calendar day (time-of-day ignored). */
+export function compareDay(a: Date, b: Date): number {
+  const av = startOfDay(a).getTime()
+  const bv = startOfDay(b).getTime()
+  return av < bv ? -1 : av > bv ? 1 : 0
+}
+
+/** Add `n` days (can be negative), returning a new Date. */
+export function addDays(d: Date, n: number): Date {
+  const r = new Date(d.getTime())
+  r.setDate(r.getDate() + n)
+  return r
+}
+
+/**
+ * Add `n` calendar months, clamping the day-of-month so 31 Jan + 1 month = 28/29
+ * Feb rather than spilling into March (matches how calendars paginate).
+ */
+export function addMonths(d: Date, n: number): Date {
+  const day = d.getDate()
+  const r = new Date(d.getFullYear(), d.getMonth() + n, 1, d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds())
+  r.setDate(Math.min(day, daysInMonth(r)))
+  return r
+}
+
+/** Add `n` years, clamping Feb-29 to Feb-28 on non-leap targets. */
+export function addYears(d: Date, n: number): Date {
+  return addMonths(d, n * 12)
+}
+
+/** Clamp `d` to the inclusive [min, max] range (either bound may be null). */
+export function clampDate(d: Date, min: Date | null, max: Date | null): Date {
+  if (min && d.getTime() < min.getTime()) return new Date(min.getTime())
+  if (max && d.getTime() > max.getTime()) return new Date(max.getTime())
+  return d
+}
+
+/**
+ * ISO 8601 week number (1-53) for `d`. Week 1 is the week containing the first
+ * Thursday of the year; weeks start Monday. Independent of `firstDayOfWeek`,
+ * matching Smart's `weekNumbers` column which is always ISO.
+ */
+export function isoWeek(d: Date): number {
+  // Shift to the Thursday of this week, then count weeks from Jan 1.
+  const date = startOfDay(d)
+  const day = (date.getDay() + 6) % 7 // Mon=0..Sun=6
+  date.setDate(date.getDate() - day + 3) // Thursday of this week
+  const firstThursday = new Date(date.getFullYear(), 0, 4)
+  const firstDay = (firstThursday.getDay() + 6) % 7
+  firstThursday.setDate(firstThursday.getDate() - firstDay + 3)
+  const diffMs = date.getTime() - firstThursday.getTime()
+  return 1 + Math.round(diffMs / (7 * 24 * 3600 * 1000))
+}
+
+/**
+ * The [start, end] years of the decade block that `year` belongs to, as Smart
+ * renders it: a 12-cell page running from the decade start minus 1 to plus 10
+ * (one leading + one trailing year for context). We expose the canonical
+ * decade [Y0, Y0+9] and let the view pad.
+ */
+export function decadeRange(year: number): { start: number; end: number } {
+  const start = Math.floor(year / 10) * 10
+  return { start, end: start + 9 }
+}
+
+/** The [start, end] years of the century block (100-year) `year` belongs to. */
+export function centuryRange(year: number): { start: number; end: number } {
+  const start = Math.floor(year / 100) * 100
+  return { start, end: start + 99 }
+}
+
+/** One cell of a month grid, including the leading and trailing days from adjacent months. */
+export type MonthMatrixCell = {
+  date: Date
+  /** In the displayed month (vs. leading/trailing days of adjacent months). */
+  inMonth: boolean
+  /** ISO week number of the row this cell sits in. */
+  week: number
+}
+
+/**
+ * Build a month grid of `weeks` rows x 7 columns starting at `firstDayOfWeek`,
+ * padded with the trailing days of the previous month and leading days of the
+ * next so every row is full. `weeks` defaults to 6 (the max any month needs),
+ * matching Smart's fixed-height calendar.
+ */
+export function monthMatrix(
+  monthDate: Date,
+  firstDayOfWeek = 0,
+  weeks = 6,
+): MonthMatrixCell[][] {
+  const first = startOfMonth(monthDate)
+  const gridStart = startOfWeek(first, firstDayOfWeek)
+  const rows: MonthMatrixCell[][] = []
+  let cursor = gridStart
+  for (let r = 0; r < weeks; r++) {
+    const row: MonthMatrixCell[] = []
+    const weekNo = isoWeek(cursor)
+    for (let c = 0; c < 7; c++) {
+      row.push({
+        date: cursor,
+        inMonth: cursor.getMonth() === first.getMonth() && cursor.getFullYear() === first.getFullYear(),
+        week: weekNo,
+      })
+      cursor = addDays(cursor, 1)
+    }
+    rows.push(row)
+  }
+  return rows
+}
+
+/**
+ * Ordered weekday indexes (0-6) for a header row starting at `firstDayOfWeek`.
+ * e.g. firstDayOfWeek=1 -> [1,2,3,4,5,6,0].
+ */
+export function weekdayOrder(firstDayOfWeek = 0): number[] {
+  return Array.from({ length: 7 }, (_, i) => (firstDayOfWeek + i) % 7)
+}
+
+/** Merge a calendar day with a time-of-day taken from `time`, returning a new Date. */
+export function withTime(day: Date, time: Date): Date {
+  return new Date(
+    day.getFullYear(),
+    day.getMonth(),
+    day.getDate(),
+    time.getHours(),
+    time.getMinutes(),
+    time.getSeconds(),
+    time.getMilliseconds(),
+  )
+}
+
+/** Snap a minute value to the nearest lower multiple of `interval` (>=1). */
+export function snapMinute(minute: number, interval: number): number {
+  const step = Math.max(1, Math.floor(interval))
+  return Math.floor(minute / step) * step
+}

package/src/datetime/date-restrict.ts

@@ -1,61 +1,61 @@
-/**
- * date-restrict - predicates for calendar constraints: min/max bounds,
- * `restrictedDates` (non-selectable), and `importantDates` (highlighted but
- * still selectable). Mirrors Smart's calendar constraint model. Framework-free.
- */
-import { compareDay, isSameDay, toDate, type DateLike } from './date-core'
-
-/** Which dates a picker allows: bounds, an explicit disabled set, and disabled weekdays. */
-export type RestrictOptions = {
-  min?: DateLike | null
-  max?: DateLike | null
-  /** Individual dates (or predicate) that cannot be selected. */
-  restrictedDates?: ReadonlyArray<DateLike> | ((d: Date) => boolean) | null
-}
-
-function normalizeList(list: ReadonlyArray<DateLike> | null | undefined): Date[] {
-  if (!list) return []
-  const out: Date[] = []
-  for (const item of list) {
-    const d = toDate(item)
-    if (d) out.push(d)
-  }
-  return out
-}
-
-/** True when `d` is outside the inclusive [min, max] day range. */
-export function isOutOfRange(d: Date, min?: DateLike | null, max?: DateLike | null): boolean {
-  const lo = toDate(min ?? null)
-  const hi = toDate(max ?? null)
-  if (lo && compareDay(d, lo) < 0) return true
-  if (hi && compareDay(d, hi) > 0) return true
-  return false
-}
-
-/** True when `d` is explicitly restricted (by list membership or predicate). */
-export function isRestricted(
-  d: Date,
-  restrictedDates?: ReadonlyArray<DateLike> | ((day: Date) => boolean) | null,
-): boolean {
-  if (!restrictedDates) return false
-  if (typeof restrictedDates === 'function') return restrictedDates(d)
-  return normalizeList(restrictedDates).some((r) => isSameDay(r, d))
-}
-
-/**
- * True when `d` cannot be selected: out of [min, max] OR restricted. This is
- * the single predicate the calendar/pickers use to disable a day.
- */
-export function isDisabledDay(d: Date, opts: RestrictOptions): boolean {
-  return isOutOfRange(d, opts.min, opts.max) || isRestricted(d, opts.restrictedDates)
-}
-
-/** True when `d` is flagged important (highlighted). Never affects selectability. */
-export function isImportant(
-  d: Date,
-  importantDates?: ReadonlyArray<DateLike> | ((day: Date) => boolean) | null,
-): boolean {
-  if (!importantDates) return false
-  if (typeof importantDates === 'function') return importantDates(d)
-  return normalizeList(importantDates).some((r) => isSameDay(r, d))
-}
+/**
+ * date-restrict - predicates for calendar constraints: min/max bounds,
+ * `restrictedDates` (non-selectable), and `importantDates` (highlighted but
+ * still selectable). Mirrors Smart's calendar constraint model. Framework-free.
+ */
+import { compareDay, isSameDay, toDate, type DateLike } from './date-core'
+
+/** Which dates a picker allows: bounds, an explicit disabled set, and disabled weekdays. */
+export type RestrictOptions = {
+  min?: DateLike | null
+  max?: DateLike | null
+  /** Individual dates (or predicate) that cannot be selected. */
+  restrictedDates?: ReadonlyArray<DateLike> | ((d: Date) => boolean) | null
+}
+
+function normalizeList(list: ReadonlyArray<DateLike> | null | undefined): Date[] {
+  if (!list) return []
+  const out: Date[] = []
+  for (const item of list) {
+    const d = toDate(item)
+    if (d) out.push(d)
+  }
+  return out
+}
+
+/** True when `d` is outside the inclusive [min, max] day range. */
+export function isOutOfRange(d: Date, min?: DateLike | null, max?: DateLike | null): boolean {
+  const lo = toDate(min ?? null)
+  const hi = toDate(max ?? null)
+  if (lo && compareDay(d, lo) < 0) return true
+  if (hi && compareDay(d, hi) > 0) return true
+  return false
+}
+
+/** True when `d` is explicitly restricted (by list membership or predicate). */
+export function isRestricted(
+  d: Date,
+  restrictedDates?: ReadonlyArray<DateLike> | ((day: Date) => boolean) | null,
+): boolean {
+  if (!restrictedDates) return false
+  if (typeof restrictedDates === 'function') return restrictedDates(d)
+  return normalizeList(restrictedDates).some((r) => isSameDay(r, d))
+}
+
+/**
+ * True when `d` cannot be selected: out of [min, max] OR restricted. This is
+ * the single predicate the calendar/pickers use to disable a day.
+ */
+export function isDisabledDay(d: Date, opts: RestrictOptions): boolean {
+  return isOutOfRange(d, opts.min, opts.max) || isRestricted(d, opts.restrictedDates)
+}
+
+/** True when `d` is flagged important (highlighted). Never affects selectability. */
+export function isImportant(
+  d: Date,
+  importantDates?: ReadonlyArray<DateLike> | ((day: Date) => boolean) | null,
+): boolean {
+  if (!importantDates) return false
+  if (typeof importantDates === 'function') return importantDates(d)
+  return normalizeList(importantDates).some((r) => isSameDay(r, d))
+}