@api-client/ui 0.5.5 → 0.5.6

package/src/md/date-picker/internals/DatePickerUtils.ts

@@ -0,0 +1,288 @@
+export interface DateRange {
+  start: Date | null
+  end: Date | null
+}
+
+export interface CalendarDay {
+  date: Date
+  isCurrentMonth: boolean
+  isToday: boolean
+  isSelected: boolean
+  isInRange: boolean
+  isRangeStart: boolean
+  isRangeEnd: boolean
+  isDisabled: boolean
+}
+
+export interface CalendarMonth {
+  year: number
+  month: number // 0-indexed (0 = January)
+  days: CalendarDay[]
+  weekdays: string[]
+}
+
+/**
+ * Get the current date with time set to midnight
+ */
+export function today(): Date {
+  const now = new Date()
+  return new Date(now.getFullYear(), now.getMonth(), now.getDate())
+}
+
+/**
+ * Create a new date with time set to midnight
+ */
+export function normalizeDate(date: Date): Date {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate())
+}
+
+/**
+ * Check if two dates are the same day
+ */
+export function isSameDay(date1: Date, date2: Date): boolean {
+  return (
+    date1.getFullYear() === date2.getFullYear() &&
+    date1.getMonth() === date2.getMonth() &&
+    date1.getDate() === date2.getDate()
+  )
+}
+
+/**
+ * Check if a date is between two other dates (inclusive)
+ */
+export function isBetween(date: Date, start: Date, end: Date): boolean {
+  const normalizedDate = normalizeDate(date)
+  const normalizedStart = normalizeDate(start)
+  const normalizedEnd = normalizeDate(end)
+  return normalizedDate >= normalizedStart && normalizedDate <= normalizedEnd
+}
+
+/**
+ * Add months to a date
+ */
+export function addMonths(date: Date, months: number): Date {
+  const result = new Date(date)
+  result.setMonth(result.getMonth() + months)
+  return result
+}
+
+/**
+ * Add days to a date
+ */
+export function addDays(date: Date, days: number): Date {
+  const result = new Date(date)
+  result.setDate(result.getDate() + days)
+  return result
+}
+
+/**
+ * Get the first day of the month
+ */
+export function getFirstDayOfMonth(year: number, month: number): Date {
+  return new Date(year, month, 1)
+}
+
+/**
+ * Get the last day of the month
+ */
+export function getLastDayOfMonth(year: number, month: number): Date {
+  return new Date(year, month + 1, 0)
+}
+
+/**
+ * Get the number of days in a month
+ */
+export function getDaysInMonth(year: number, month: number): number {
+  return new Date(year, month + 1, 0).getDate()
+}
+
+/**
+ * Get weekday names for the current locale
+ */
+export function getWeekdayNames(locale?: string): string[] {
+  const formatter = new Intl.DateTimeFormat(locale, { weekday: 'short' })
+  const days: string[] = []
+
+  // Start from Sunday and get all 7 days
+  const date = new Date(2024, 0, 7) // January 7, 2024 is a Sunday
+  for (let i = 0; i < 7; i++) {
+    days.push(formatter.format(new Date(date.getTime() + i * 24 * 60 * 60 * 1000)))
+  }
+
+  return days
+}
+
+/**
+ * Get month names for the current locale
+ */
+export function getMonthNames(locale?: string): string[] {
+  const formatter = new Intl.DateTimeFormat(locale, { month: 'short' })
+  const months: string[] = []
+
+  for (let i = 0; i < 12; i++) {
+    months.push(formatter.format(new Date(2024, i, 1)))
+  }
+
+  return months
+}
+
+/**
+ * Format a date according to locale
+ */
+export function formatDate(date: Date, locale?: string, options?: Intl.DateTimeFormatOptions): string {
+  const defaultOptions: Intl.DateTimeFormatOptions = {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+  }
+
+  return new Intl.DateTimeFormat(locale, { ...defaultOptions, ...options }).format(date)
+}
+
+/**
+ * Parse a date string in various formats
+ */
+export function parseDate(dateString: string): Date | null {
+  if (!dateString) return null
+
+  // Try ISO format first
+  const isoDate = new Date(dateString)
+  if (!isNaN(isoDate.getTime())) {
+    return normalizeDate(isoDate)
+  }
+
+  // Try other common formats
+  const formats = [
+    /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/, // MM/DD/YYYY or M/D/YYYY
+    /^(\d{1,2})-(\d{1,2})-(\d{4})$/, // MM-DD-YYYY or M-D-YYYY
+    /^(\d{4})-(\d{1,2})-(\d{1,2})$/, // YYYY-MM-DD or YYYY-M-D
+  ]
+
+  for (const format of formats) {
+    const match = dateString.match(format)
+    if (match) {
+      const [, part1, part2, part3] = match
+      let year: number, month: number, day: number
+
+      if (format === formats[2]) {
+        // YYYY-MM-DD
+        year = parseInt(part1, 10)
+        month = parseInt(part2, 10) - 1 // Convert to 0-indexed
+        day = parseInt(part3, 10)
+      } else {
+        // MM/DD/YYYY or MM-DD-YYYY
+        year = parseInt(part3, 10)
+        month = parseInt(part1, 10) - 1 // Convert to 0-indexed
+        day = parseInt(part2, 10)
+      }
+
+      const date = new Date(year, month, day)
+      if (!isNaN(date.getTime())) {
+        return date
+      }
+    }
+  }
+
+  return null
+}
+
+/**
+ * Generate calendar data for a specific month
+ */
+export function generateCalendarMonth(
+  year: number,
+  month: number,
+  selectedDate?: Date | null,
+  selectedRange?: DateRange | null,
+  disabledDates?: Date[],
+  locale?: string
+): CalendarMonth {
+  const firstDay = getFirstDayOfMonth(year, month)
+  const todayDate = today()
+
+  // Get the first day of the week (0 = Sunday, 1 = Monday)
+  const firstDayOfWeek = firstDay.getDay()
+
+  // Calculate start date (might be from previous month)
+  const startDate = addDays(firstDay, -firstDayOfWeek)
+
+  // Calculate end date (might be from next month)
+  const daysToShow = 42 // 6 weeks * 7 days
+  const endDate = addDays(startDate, daysToShow - 1)
+
+  const days: CalendarDay[] = []
+  const currentDate = new Date(startDate)
+
+  while (currentDate <= endDate) {
+    const isCurrentMonth = currentDate.getMonth() === month
+    const isToday = isSameDay(currentDate, todayDate)
+    const isSelected = selectedDate ? isSameDay(currentDate, selectedDate) : false
+
+    let isInRange = false
+    let isRangeStart = false
+    let isRangeEnd = false
+
+    if (selectedRange?.start && selectedRange?.end) {
+      isRangeStart = isSameDay(currentDate, selectedRange.start)
+      isRangeEnd = isSameDay(currentDate, selectedRange.end)
+      isInRange = isBetween(currentDate, selectedRange.start, selectedRange.end)
+    }
+
+    const isDisabled = disabledDates?.some((disabledDate) => isSameDay(currentDate, disabledDate)) || false
+
+    days.push({
+      date: new Date(currentDate),
+      isCurrentMonth,
+      isToday,
+      isSelected,
+      isInRange,
+      isRangeStart,
+      isRangeEnd,
+      isDisabled,
+    })
+
+    currentDate.setDate(currentDate.getDate() + 1)
+  }
+
+  return {
+    year,
+    month,
+    days,
+    weekdays: getWeekdayNames(locale),
+  }
+}
+
+/**
+ * Get the ISO string for a date (YYYY-MM-DD format)
+ */
+export function toISODateString(date: Date): string {
+  return date.toISOString().split('T')[0]
+}
+
+/**
+ * Create a date from ISO string (YYYY-MM-DD format)
+ */
+export function fromISODateString(isoString: string): Date | null {
+  const match = isoString.match(/^(\d{4})-(\d{2})-(\d{2})$/)
+  if (!match) return null
+
+  const [, year, month, day] = match
+  return new Date(parseInt(year, 10), parseInt(month, 10) - 1, parseInt(day, 10))
+}
+
+/**
+ * Validate if a date range is valid (start <= end)
+ */
+export function isValidRange(range: DateRange): boolean {
+  if (!range.start || !range.end) return true
+  return range.start <= range.end
+}
+
+/**
+ * Get the number of days between two dates
+ */
+export function getDaysBetween(start: Date, end: Date): number {
+  const startTime = normalizeDate(start).getTime()
+  const endTime = normalizeDate(end).getTime()
+  return Math.abs(Math.floor((endTime - startTime) / (24 * 60 * 60 * 1000)))
+}

package/src/md/date-picker/ui-date-picker-input.ts

@@ -0,0 +1,272 @@
+import { LitElement, html, TemplateResult } from 'lit'
+import { customElement, property, state, query } from 'lit/decorators.js'
+import { inputStyles } from './internals/DatePicker.styles.js'
+import { formatDate, parseDate } from './internals/DatePickerUtils.js'
+import type { DateSelectEvent } from './internals/DatePickerCalendar.js'
+import './internals/DatePickerCalendar.js'
+import '../../md/text-field/ui-outlined-text-field.js'
+import '../../md/icons/ui-icon.js'
+
+/**
+ * A docked date picker that opens from a text field input.
+ * Ideal for forms and date selection in medium to large layouts.
+ *
+ * ## Usage
+ *
+ * ```html
+ * <ui-date-picker-input
+ *   label="Select date"
+ *   placeholder="MM/DD/YYYY"
+ *   .value=${new Date()}
+ * ></ui-date-picker-input>
+ * ```
+ *
+ * ### Custom date format
+ * ```html
+ * <ui-date-picker-input
+ *   label="Birth date"
+ *   .dateFormat=${date => date.toLocaleDateString('en-GB')}
+ * ></ui-date-picker-input>
+ * ```
+ */
+@customElement('ui-date-picker-input')
+export class UiDatePickerInput extends LitElement {
+  static override styles = inputStyles
+  static override shadowRootOptions: ShadowRootInit = {
+    mode: 'open',
+    delegatesFocus: true,
+  }
+
+  /**
+   * The label for the input field
+   */
+  @property({ type: String }) accessor label = ''
+
+  /**
+   * Placeholder text for the input
+   */
+  @property({ type: String }) accessor placeholder = 'MM/DD/YYYY'
+
+  /**
+   * The currently selected date
+   */
+  @property({ type: Object }) accessor value: Date | null = null
+
+  /**
+   * Whether the date picker is disabled
+   */
+  @property({ type: Boolean }) accessor disabled = false
+
+  /**
+   * Whether the input is required
+   */
+  @property({ type: Boolean }) accessor required = false
+
+  /**
+   * Error message to display
+   */
+  @property({ type: String }) accessor errorMessage = ''
+
+  /**
+   * Whether the input has an error state
+   */
+  @property({ type: Boolean }) accessor error = false
+
+  /**
+   * Minimum selectable date
+   */
+  @property({ type: Object }) accessor minDate: Date | undefined = undefined
+
+  /**
+   * Maximum selectable date
+   */
+  @property({ type: Object }) accessor maxDate: Date | undefined = undefined
+
+  /**
+   * Array of disabled dates
+   */
+  @property({ type: Array }) accessor disabledDates: Date[] | undefined = undefined
+
+  /**
+   * Locale for date formatting
+   */
+  @property({ type: String }) accessor locale: string | undefined = undefined
+
+  /**
+   * Custom date format function
+   */
+  @property({ type: Object }) accessor dateFormat: ((date: Date) => string) | undefined = undefined
+
+  @state() private accessor _isOpen = false
+
+  @state() private accessor _inputValue = ''
+
+  @query('ui-outlined-text-field') private accessor _textField!: HTMLElement
+
+  override connectedCallback(): void {
+    super.connectedCallback()
+    this._updateInputValue()
+    document.addEventListener('click', this._handleDocumentClick.bind(this))
+  }
+
+  override disconnectedCallback(): void {
+    super.disconnectedCallback()
+    document.removeEventListener('click', this._handleDocumentClick.bind(this))
+  }
+
+  override willUpdate(changedProperties: Map<string | number | symbol, unknown>): void {
+    if (changedProperties.has('value')) {
+      this._updateInputValue()
+    }
+  }
+
+  override updated(changedProperties: Map<string | number | symbol, unknown>): void {
+    if (changedProperties.has('_isOpen') && this._isOpen) {
+      // Set anchor name on text field for CSS Anchor Positioning API
+      if (this._textField) {
+        // Using setProperty since anchorName is not in TypeScript types yet
+        this._textField.style.setProperty('anchor-name', '--ui-date-picker-anchor')
+      }
+    }
+  }
+
+  private _updateInputValue(): void {
+    if (this.value) {
+      this._inputValue = this.dateFormat ? this.dateFormat(this.value) : formatDate(this.value, this.locale)
+    } else {
+      this._inputValue = ''
+    }
+  }
+
+  private _handleDocumentClick(event: Event): void {
+    if (!this.contains(event.target as Node)) {
+      this._isOpen = false
+    }
+  }
+
+  private _handleInputClick(): void {
+    if (!this.disabled) {
+      this._isOpen = !this._isOpen
+    }
+  }
+
+  private _handleInputChange(event: Event): void {
+    const target = event.target as HTMLInputElement
+    this._inputValue = target.value
+
+    const parsedDate = parseDate(this._inputValue)
+    if (parsedDate) {
+      this.value = parsedDate
+      this._dispatchChangeEvent()
+    }
+  }
+
+  private _handleCalendarDateSelect(event: CustomEvent<DateSelectEvent>): void {
+    this.value = event.detail.date
+    this._isOpen = false
+    this._dispatchChangeEvent()
+  }
+
+  private _handleCalendarDateCancel(): void {
+    this._isOpen = false
+  }
+
+  private _handleKeyDown(event: KeyboardEvent): void {
+    switch (event.key) {
+      case 'Escape':
+        this._isOpen = false
+        break
+      case 'ArrowDown':
+        if (!this._isOpen) {
+          event.preventDefault()
+          this._isOpen = true
+        }
+        break
+      case 'Enter':
+        if (this._isOpen) {
+          event.preventDefault()
+          this._isOpen = false
+        }
+        break
+    }
+  }
+
+  private _dispatchChangeEvent(): void {
+    this.dispatchEvent(
+      new CustomEvent('change', {
+        detail: {
+          value: this.value,
+          formattedValue: this._inputValue,
+        },
+        bubbles: true,
+        composed: true,
+      })
+    )
+  }
+
+  private _renderCalendarIcon(): TemplateResult {
+    return html`
+      <ui-icon slot="suffix" icon="calendarToday" @click=${this._handleInputClick} style="cursor: pointer;"></ui-icon>
+    `
+  }
+
+  private _renderDropdown(): TemplateResult | null {
+    if (!this._isOpen) return null
+
+    const currentDate = this.value || new Date()
+
+    return html`
+      <div class="dropdown-container">
+        <ui-date-picker-calendar
+          .year=${currentDate.getFullYear()}
+          .month=${currentDate.getMonth()}
+          .selectedDate=${this.value}
+          .minDate=${this.minDate}
+          .maxDate=${this.maxDate}
+          .disabledDates=${this.disabledDates}
+          .locale=${this.locale}
+          showActions
+          @date-select=${this._handleCalendarDateSelect}
+          @date-cancel=${this._handleCalendarDateCancel}
+        ></ui-date-picker-calendar>
+      </div>
+    `
+  }
+
+  override render(): TemplateResult {
+    return html`
+      <div class="input-container">
+        ${this._isOpen ? html`<div class="backdrop" @click=${() => (this._isOpen = false)}></div>` : ''}
+        <ui-outlined-text-field
+          .label=${this.label}
+          .placeholder=${this.placeholder}
+          .value=${this._inputValue}
+          .disabled=${this.disabled}
+          .required=${this.required}
+          .errorMessage=${this.errorMessage}
+          .error=${this.error}
+          readonly
+          @click=${this._handleInputClick}
+          @input=${this._handleInputChange}
+          @keydown=${this._handleKeyDown}
+        >
+          ${this._renderCalendarIcon()}
+        </ui-outlined-text-field>
+        ${this._renderDropdown()}
+      </div>
+    `
+  }
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'ui-date-picker-input': UiDatePickerInput
+  }
+
+  interface HTMLElementEventMap {
+    change: CustomEvent<{
+      value: Date | null
+      formattedValue: string
+    }>
+  }
+}