@design-system-rte/core 1.6.5-rc2 → 1.7.0-rc1

package/components/datepicker/datepicker.utils.js

@@ -0,0 +1,539 @@
+import { ARROW_DOWN_KEY, ARROW_LEFT_KEY, ARROW_RIGHT_KEY, ARROW_UP_KEY, } from "../../constants/keyboard/keyboard.constants";
+import { DATEPICKER_ARIA_CHANGE_DATE_PREFIX, DATEPICKER_ARIA_OPEN_CALENDAR, DATEPICKER_DEFAULT_LOCALE, DATEPICKER_MENU_REST_TAB_KEYS_COMPACT, DATEPICKER_MENU_REST_TAB_KEYS_DAY, DATEPICKER_YEAR_GRID_PAGE_SIZE, } from "./datepicker.constants";
+const DD_MM_YYYY_EMPTY_SLOT_MARKER = "\u200b";
+function stripDdMmYyyySegmentPart(part) {
+    return part.split(DD_MM_YYYY_EMPTY_SLOT_MARKER).join("").replace(/\D/g, "");
+}
+function parseDdMmYyyyTwoSlashParts(dayPart, secondPart) {
+    const dayDigits = stripDdMmYyyySegmentPart(dayPart).slice(0, 2);
+    const rest = stripDdMmYyyySegmentPart(secondPart).slice(0, 4);
+    if (rest.length > 2) {
+        return { dayDigits, monthDigits: "", yearDigits: rest };
+    }
+    if (rest.length === 1 || rest.length === 2) {
+        const monthNum = Number.parseInt(rest, 10);
+        if (!Number.isNaN(monthNum) && monthNum > 12) {
+            return { dayDigits, monthDigits: "", yearDigits: rest };
+        }
+    }
+    return { dayDigits, monthDigits: rest.slice(0, 2), yearDigits: "" };
+}
+function encodeDdMmYyyyDoubleSlashBoundaries(masked) {
+    let result = masked;
+    while (result.includes("//")) {
+        result = result.replace("//", `/${DD_MM_YYYY_EMPTY_SLOT_MARKER}/`);
+    }
+    return result;
+}
+export function parseDdMmYyyyMaskedString(value) {
+    const trimmed = value.trim();
+    if (trimmed.includes("/")) {
+        const rawParts = trimmed.split("/");
+        if (rawParts.length === 2) {
+            return parseDdMmYyyyTwoSlashParts(rawParts[0] ?? "", rawParts[1] ?? "");
+        }
+        return {
+            dayDigits: stripDdMmYyyySegmentPart(rawParts[0] ?? "").slice(0, 2),
+            monthDigits: stripDdMmYyyySegmentPart(rawParts[1] ?? "").slice(0, 2),
+            yearDigits: stripDdMmYyyySegmentPart(rawParts[2] ?? "").slice(0, 4),
+        };
+    }
+    const digitsOnly = trimmed.replace(/\D/g, "").slice(0, 8);
+    return {
+        dayDigits: digitsOnly.slice(0, 2),
+        monthDigits: digitsOnly.slice(2, 4),
+        yearDigits: digitsOnly.slice(4, 8),
+    };
+}
+export function buildMaskedDdMmYyyyFromDigitParts(parts) {
+    const { dayDigits, monthDigits, yearDigits } = parts;
+    const hasDay = dayDigits.length > 0;
+    const hasMonth = monthDigits.length > 0;
+    const hasYear = yearDigits.length > 0;
+    if (!hasDay && !hasMonth && !hasYear) {
+        return "";
+    }
+    if (hasDay && !hasMonth && !hasYear) {
+        return dayDigits;
+    }
+    if (!hasDay && hasMonth && !hasYear) {
+        return `/${monthDigits}`;
+    }
+    if (!hasDay && !hasMonth && hasYear) {
+        return encodeDdMmYyyyDoubleSlashBoundaries(`//${yearDigits}`);
+    }
+    if (hasDay && hasMonth && !hasYear) {
+        return `${dayDigits}/${monthDigits}`;
+    }
+    if (hasDay && !hasMonth && hasYear) {
+        return encodeDdMmYyyyDoubleSlashBoundaries(`${dayDigits}//${yearDigits}`);
+    }
+    if (!hasDay && hasMonth && hasYear) {
+        return `/${monthDigits}/${yearDigits}`;
+    }
+    return encodeDdMmYyyyDoubleSlashBoundaries(`${dayDigits}/${monthDigits}/${yearDigits}`);
+}
+export function getDatepickerMenuRestTabKeysInOrder(calendarType) {
+    if (calendarType === "day") {
+        return DATEPICKER_MENU_REST_TAB_KEYS_DAY;
+    }
+    return DATEPICKER_MENU_REST_TAB_KEYS_COMPACT;
+}
+export function resolveDatepickerMenuFocusableElement(element) {
+    if (element.tagName === "BUTTON") {
+        return element;
+    }
+    const innerButton = element.querySelector("button");
+    if (innerButton instanceof HTMLElement) {
+        return innerButton;
+    }
+    return element;
+}
+export function startOfMonth(date) {
+    return new Date(date.getFullYear(), date.getMonth(), 1);
+}
+function endOfMonth(date) {
+    return new Date(date.getFullYear(), date.getMonth() + 1, 0);
+}
+function monthHasSelectableDay(params) {
+    const { year, monthIndex, minDate, maxDate, disabledDates } = params;
+    const lastDay = endOfMonth(new Date(year, monthIndex, 1)).getDate();
+    for (let day = 1; day <= lastDay; day++) {
+        const date = startOfDay(new Date(year, monthIndex, day));
+        if (!isDateDisabled({ date, minDate, maxDate, disabledDates })) {
+            return true;
+        }
+    }
+    return false;
+}
+function yearHasSelectableDay(params) {
+    const { year, minDate, maxDate, disabledDates } = params;
+    for (let monthIndex = 0; monthIndex < 12; monthIndex++) {
+        if (monthHasSelectableDay({ year, monthIndex, minDate, maxDate, disabledDates })) {
+            return true;
+        }
+    }
+    return false;
+}
+function getMondayBasedWeekdayIndex(date) {
+    return (date.getDay() + 6) % 7;
+}
+function isSameMonth(first, second) {
+    return first.getFullYear() === second.getFullYear() && first.getMonth() === second.getMonth();
+}
+export function maskDateInput(value) {
+    const parts = parseDdMmYyyyMaskedString(value);
+    return buildMaskedDdMmYyyyFromDigitParts(parts);
+}
+export function formatDate(date) {
+    const day = `${date.getDate()}`.padStart(2, "0");
+    const month = `${date.getMonth() + 1}`.padStart(2, "0");
+    const year = `${date.getFullYear()}`.padStart(4, "0");
+    return `${day}/${month}/${year}`;
+}
+export function getDatepickerCalendarButtonAriaLabel(selectedDate) {
+    if (selectedDate === null) {
+        return DATEPICKER_ARIA_OPEN_CALENDAR;
+    }
+    return `${DATEPICKER_ARIA_CHANGE_DATE_PREFIX}${formatDate(selectedDate)}`;
+}
+export function parseDate(value) {
+    const trimmedValue = value.trim();
+    if (trimmedValue.length === 0) {
+        return null;
+    }
+    const datePartsMatch = /^(\d{2})\/(\d{2})\/(\d{4})$/.exec(trimmedValue);
+    if (!datePartsMatch) {
+        return null;
+    }
+    const day = Number(datePartsMatch[1]);
+    const month = Number(datePartsMatch[2]);
+    const year = Number(datePartsMatch[3]);
+    if (month < 1 || month > 12) {
+        return null;
+    }
+    const date = new Date(year, month - 1, day);
+    const isValidParsedDate = date.getFullYear() === year &&
+        date.getMonth() === month - 1 &&
+        date.getDate() === day &&
+        !Number.isNaN(date.valueOf());
+    return isValidParsedDate ? date : null;
+}
+export function isSameDay(first, second) {
+    return (first.getFullYear() === second.getFullYear() &&
+        first.getMonth() === second.getMonth() &&
+        first.getDate() === second.getDate());
+}
+export function isBeforeDay(first, second) {
+    return startOfDay(first).valueOf() < startOfDay(second).valueOf();
+}
+export function isAfterDay(first, second) {
+    return startOfDay(first).valueOf() > startOfDay(second).valueOf();
+}
+export function startOfDay(date) {
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+export function getLastDayOfMonth(year, monthIndex) {
+    return new Date(year, monthIndex + 1, 0).getDate();
+}
+export function projectDayToMonthAnchor(desiredDayOfMonth, year, monthIndex) {
+    const lastDayInMonth = getLastDayOfMonth(year, monthIndex);
+    const dayClampedToMonth = Math.min(Math.max(desiredDayOfMonth, 1), lastDayInMonth);
+    return startOfDay(new Date(year, monthIndex, dayClampedToMonth));
+}
+export function addDays(date, amount) {
+    const nextDate = new Date(date);
+    nextDate.setDate(nextDate.getDate() + amount);
+    return nextDate;
+}
+export function addMonths(date, amount) {
+    return new Date(date.getFullYear(), date.getMonth() + amount, 1);
+}
+export function addYears(date, amount) {
+    return new Date(date.getFullYear() + amount, date.getMonth(), 1);
+}
+export function getDecadeStartYear(year) {
+    return Math.floor(year / 10) * 10;
+}
+export function navigateViewDate(params) {
+    const { viewDate, calendarType } = params;
+    if (calendarType === "day") {
+        const action = params.dayAction;
+        if (!action) {
+            return viewDate;
+        }
+        if (["prevYear", "nextYear"].includes(action)) {
+            return addMonths(viewDate, action === "prevYear" ? -12 : 12);
+        }
+        return addMonths(viewDate, action === "prevMonth" ? -1 : 1);
+    }
+    if (calendarType === "month") {
+        const step = params.compactStep;
+        if (!step) {
+            return viewDate;
+        }
+        return addYears(viewDate, step === "previous" ? -1 : 1);
+    }
+    if (calendarType === "year") {
+        const step = params.compactStep;
+        if (!step) {
+            return viewDate;
+        }
+        const yearStep = DATEPICKER_YEAR_GRID_PAGE_SIZE;
+        return addYears(viewDate, step === "previous" ? -yearStep : yearStep);
+    }
+    return viewDate;
+}
+function isCalendarDayInDisabledDates(currentDay, disabledDates) {
+    if (!disabledDates || disabledDates.length === 0) {
+        return false;
+    }
+    return disabledDates.some((forbidden) => isSameDay(currentDay, startOfDay(forbidden)));
+}
+export function isDateDisabled(params) {
+    const { date, minDate, maxDate, disabledDates } = params;
+    const currentDay = startOfDay(date);
+    if (minDate && isBeforeDay(currentDay, minDate)) {
+        return true;
+    }
+    if (maxDate && isAfterDay(currentDay, maxDate)) {
+        return true;
+    }
+    return isCalendarDayInDisabledDates(currentDay, disabledDates);
+}
+export function getMonthLabel(date, locale = DATEPICKER_DEFAULT_LOCALE) {
+    return new Intl.DateTimeFormat(locale, { month: "long", year: "numeric" }).format(date);
+}
+export function getYearLabel(date, locale = DATEPICKER_DEFAULT_LOCALE) {
+    return new Intl.DateTimeFormat(locale, { year: "numeric" }).format(date);
+}
+export function getDecadeRangeLabel(date) {
+    const decadeStart = getDecadeStartYear(date.getFullYear());
+    const decadeEnd = decadeStart + DATEPICKER_YEAR_GRID_PAGE_SIZE - 1;
+    return `${decadeStart} – ${decadeEnd}`;
+}
+export function getWeekdayShortLabels(locale = DATEPICKER_DEFAULT_LOCALE) {
+    const monday = new Date(2021, 0, 4);
+    return Array.from({ length: 7 }).map((_, index) => {
+        const day = addDays(monday, index);
+        const label = new Intl.DateTimeFormat(locale, { weekday: "short" }).format(day);
+        const firstLetter = label.trim().charAt(0);
+        return firstLetter.toLocaleUpperCase(locale);
+    });
+}
+export function resolveInitialCalendarDay(params) {
+    const { pendingDate, selectedDate, dayCells } = params;
+    const candidate = startOfDay(pendingDate ?? selectedDate ?? new Date());
+    const fromCandidate = resolveEnabledDateForPreferredDay(dayCells, candidate);
+    if (fromCandidate !== null) {
+        return fromCandidate;
+    }
+    const today = startOfDay(new Date());
+    const fromToday = resolveEnabledDateForPreferredDay(dayCells, today);
+    if (fromToday !== null) {
+        return fromToday;
+    }
+    const firstEnabled = dayCells.find((cell) => !cell.isDisabled);
+    return firstEnabled ? firstEnabled.date : candidate;
+}
+function resolveEnabledDateForPreferredDay(dayCells, day) {
+    const match = dayCells.find((cell) => isSameDay(cell.date, day));
+    if (!match) {
+        return null;
+    }
+    if (!match.isDisabled) {
+        return match.date;
+    }
+    const resolved = findNextEnabledFromIndex(dayCells, dayCells.indexOf(match));
+    return resolved ? resolved.date : null;
+}
+function findNextEnabledFromIndex(dayCells, startIndex) {
+    for (let index = startIndex; index < dayCells.length; index++) {
+        const cell = dayCells[index];
+        if (!cell.isDisabled) {
+            return cell;
+        }
+    }
+    for (let index = 0; index < startIndex; index++) {
+        const cell = dayCells[index];
+        if (!cell.isDisabled) {
+            return cell;
+        }
+    }
+    return undefined;
+}
+export function getDayCellIndexForDate(dayCells, date) {
+    return dayCells.findIndex((cell) => isSameDay(cell.date, date));
+}
+export function getDayGridCellCountForViewMonth(viewDate) {
+    const firstMonthDay = startOfMonth(viewDate);
+    const leadingDaysFromPreviousMonth = getMondayBasedWeekdayIndex(firstMonthDay);
+    const daysInMonth = getLastDayOfMonth(viewDate.getFullYear(), viewDate.getMonth());
+    return Math.ceil((leadingDaysFromPreviousMonth + daysInMonth) / 7) * 7;
+}
+export function buildDayGrid(params) {
+    const { viewDate, selectedDate, minDate, maxDate, disabledDates } = params;
+    const firstMonthDay = startOfMonth(viewDate);
+    const leadingDaysFromPreviousMonth = getMondayBasedWeekdayIndex(firstMonthDay);
+    const gridStart = addDays(firstMonthDay, -leadingDaysFromPreviousMonth);
+    const cellCount = getDayGridCellCountForViewMonth(viewDate);
+    const today = startOfDay(new Date());
+    return Array.from({ length: cellCount }).map((_, index) => {
+        const cellDate = addDays(gridStart, index);
+        const isCurrentMonth = isSameMonth(cellDate, viewDate);
+        const isSelected = !!selectedDate && isSameDay(cellDate, selectedDate);
+        const isToday = isSameDay(cellDate, today);
+        let cellType = "default";
+        if (!isCurrentMonth) {
+            cellType = "prev/next";
+        }
+        else if (isSelected) {
+            cellType = "selected";
+        }
+        else if (isToday) {
+            cellType = "today";
+        }
+        return {
+            date: cellDate,
+            label: `${cellDate.getDate()}`,
+            cellType,
+            isDisabled: isDateDisabled({ date: cellDate, minDate, maxDate, disabledDates }),
+        };
+    });
+}
+export function buildMonthGrid(params) {
+    const { viewDate, selectedDate, minDate, maxDate, disabledDates, locale = DATEPICKER_DEFAULT_LOCALE } = params;
+    const selectedMonthDate = selectedDate ? startOfMonth(selectedDate) : null;
+    const currentMonthDate = startOfMonth(new Date());
+    const year = viewDate.getFullYear();
+    return Array.from({ length: 12 }).map((_, monthIndex) => {
+        const cellDate = new Date(year, monthIndex, 1);
+        return {
+            monthIndex,
+            label: new Intl.DateTimeFormat(locale, { month: "long" }).format(cellDate),
+            isDisabled: !monthHasSelectableDay({ year, monthIndex, minDate, maxDate, disabledDates }),
+            isCurrent: cellDate.getTime() === currentMonthDate.getTime(),
+            isSelected: !!selectedMonthDate && cellDate.getTime() === selectedMonthDate.getTime(),
+        };
+    });
+}
+export function buildYearGrid(params) {
+    const { viewDate, selectedDate, minDate, maxDate, disabledDates } = params;
+    const currentYear = new Date().getFullYear();
+    const selectedYear = selectedDate?.getFullYear() ?? null;
+    const startYear = getDecadeStartYear(viewDate.getFullYear());
+    return Array.from({ length: DATEPICKER_YEAR_GRID_PAGE_SIZE }).map((_, index) => {
+        const year = startYear + index;
+        return {
+            year,
+            label: `${year}`,
+            isDisabled: !yearHasSelectableDay({ year, minDate, maxDate, disabledDates }),
+            isCurrent: year === currentYear,
+            isSelected: selectedYear === year,
+        };
+    });
+}
+export function getNextGridCellIndex(params) {
+    const { currentIndex, key, columnCount, cellCount } = params;
+    if (key === ARROW_LEFT_KEY) {
+        return currentIndex > 0 ? currentIndex - 1 : null;
+    }
+    if (key === ARROW_RIGHT_KEY) {
+        return currentIndex < cellCount - 1 ? currentIndex + 1 : null;
+    }
+    if (key === ARROW_UP_KEY) {
+        const nextIndex = currentIndex - columnCount;
+        return nextIndex >= 0 ? nextIndex : null;
+    }
+    if (key === ARROW_DOWN_KEY) {
+        const nextIndex = currentIndex + columnCount;
+        return nextIndex < cellCount ? nextIndex : null;
+    }
+    return null;
+}
+const ARROW_KEY_TO_COLUMN_DELTA = {
+    [ARROW_LEFT_KEY]: -1,
+    [ARROW_RIGHT_KEY]: 1,
+};
+const DATEPICKER_GRID_VERTICAL_STEP = {
+    day: 7,
+    monthYear: 3,
+};
+export function getDatepickerGridArrowDelta(key, layout) {
+    if (key === ARROW_UP_KEY) {
+        return -DATEPICKER_GRID_VERTICAL_STEP[layout];
+    }
+    if (key === ARROW_DOWN_KEY) {
+        return DATEPICKER_GRID_VERTICAL_STEP[layout];
+    }
+    return ARROW_KEY_TO_COLUMN_DELTA[key] ?? 0;
+}
+export function getDayOfMonthOrNull(date) {
+    return date?.getDate() ?? null;
+}
+export function resolveDatepickerMenuOpenState(params) {
+    const { textValue, constraints, pendingDate, selectedDate } = params;
+    const fallbackViewDate = params.fallbackViewDate ?? new Date();
+    const trimmedText = textValue.trim();
+    const parsedFromField = trimmedText.length > 0 ? parseDate(trimmedText) : null;
+    const parsedNormalized = parsedFromField ? startOfDay(parsedFromField) : null;
+    const isParsedUsable = parsedNormalized !== null && !isDateDisabled({ date: parsedNormalized, ...constraints });
+    let viewDateForGrid;
+    let pendingForMenu;
+    if (isParsedUsable && parsedNormalized) {
+        pendingForMenu = parsedNormalized;
+        viewDateForGrid = startOfMonth(parsedNormalized);
+    }
+    else {
+        pendingForMenu = null;
+        viewDateForGrid = fallbackViewDate;
+    }
+    const dayCells = buildDayGrid({
+        viewDate: viewDateForGrid,
+        selectedDate: pendingForMenu,
+        ...constraints,
+    });
+    const menuInitialActiveDate = resolveInitialCalendarDay({
+        pendingDate: pendingForMenu,
+        selectedDate: pendingForMenu,
+        dayCells,
+    });
+    const monthNavigationAnchorDay = getDayOfMonthOrNull(pendingForMenu ?? pendingDate ?? selectedDate);
+    return {
+        viewDate: viewDateForGrid,
+        pendingForMenu,
+        menuInitialActiveDate,
+        monthNavigationAnchorDay,
+    };
+}
+export function applyDatepickerTextInputChange(params) {
+    const masked = maskDateInput(params.rawValue);
+    const trimmed = masked.trim();
+    const parsed = trimmed.length > 0 ? parseDate(trimmed) : null;
+    if (parsed) {
+        const normalized = startOfDay(parsed);
+        if (isDateDisabled({ date: normalized, ...params.constraints })) {
+            return { outcome: "partial", maskedValue: masked };
+        }
+        return {
+            outcome: "committed",
+            date: normalized,
+            monthAnchorDay: normalized.getDate(),
+            maskedValue: masked,
+        };
+    }
+    if (masked.length === 0) {
+        return { outcome: "cleared", maskedValue: masked };
+    }
+    return { outcome: "partial", maskedValue: masked };
+}
+export function tryProjectPendingDateToViewMonth(params) {
+    const { anchorDay, viewDate, constraints } = params;
+    if (anchorDay === null) {
+        return null;
+    }
+    const projectedDate = projectDayToMonthAnchor(anchorDay, viewDate.getFullYear(), viewDate.getMonth());
+    if (isDateDisabled({ date: projectedDate, ...constraints })) {
+        return null;
+    }
+    return projectedDate;
+}
+export function normalizeDatepickerMenuSelectionDate(params) {
+    const normalized = startOfDay(params.date);
+    if (isDateDisabled({ date: normalized, ...params.constraints })) {
+        return null;
+    }
+    return normalized;
+}
+export function resolveDatepickerMenuKeyboardDayNavigation(params) {
+    const normalized = startOfDay(params.focusTargetDay);
+    if (isDateDisabled({ date: normalized, ...params.constraints })) {
+        return null;
+    }
+    return {
+        viewDate: startOfMonth(normalized),
+        menuInitialActiveDate: normalized,
+    };
+}
+export function resolveDatepickerMenuKeyboardMonthNavigation(params) {
+    const monthStart = startOfMonth(params.focusTargetMonthStart);
+    if (!monthHasSelectableDay({
+        year: monthStart.getFullYear(),
+        monthIndex: monthStart.getMonth(),
+        ...params.constraints,
+    })) {
+        return null;
+    }
+    return {
+        viewDate: monthStart,
+        menuInitialActiveDate: monthStart,
+    };
+}
+export function resolveDatepickerMenuKeyboardYearNavigation(params) {
+    if (!yearHasSelectableDay({
+        year: params.focusTargetYear,
+        ...params.constraints,
+    })) {
+        return null;
+    }
+    const monthStart = new Date(params.focusTargetYear, 0, 1);
+    return {
+        viewDate: monthStart,
+        menuInitialActiveDate: monthStart,
+    };
+}
+export function buildRestoreCommittedDatepickerFieldState(params) {
+    const { selectedDate } = params;
+    return {
+        pendingDate: selectedDate,
+        textValue: selectedDate ? formatDate(selectedDate) : "",
+    };
+}
+export function alignViewDateToSelectedMonthIfNeeded(params) {
+    const viewMonthStart = startOfMonth(params.viewDate);
+    const selectedMonthStart = startOfMonth(params.selectedDate);
+    if (viewMonthStart.getTime() === selectedMonthStart.getTime()) {
+        return params.viewDate;
+    }
+    return selectedMonthStart;
+}

package/components/datepicker/index.d.ts

@@ -0,0 +1,6 @@
+export type * from "./datepicker.interface";
+export * from "./datepicker.constants";
+export * from "./datepicker.utils";
+export * from "./datepicker-menu-focus-order";
+export * from "./segmented-date-field";
+//# sourceMappingURL=index.d.ts.map

package/components/datepicker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../components/datepicker/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,wBAAwB,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC"}

package/components/datepicker/index.js

@@ -0,0 +1,4 @@
+export * from "./datepicker.constants";
+export * from "./datepicker.utils";
+export * from "./datepicker-menu-focus-order";
+export * from "./segmented-date-field";

package/components/datepicker/segmented-date-field.d.ts

@@ -0,0 +1,27 @@
+export type SegmentedDateActiveSegment = "day" | "month" | "year";
+export declare const SEGMENT_ORDER: readonly SegmentedDateActiveSegment[];
+export interface SegmentedDateFieldState {
+    dayDigits: string;
+    monthDigits: string;
+    yearDigits: string;
+    activeSegment: SegmentedDateActiveSegment;
+}
+export declare function getSegmentDisplayText(digits: string, segment: SegmentedDateActiveSegment, emptyPlaceholder: string): string;
+export declare function createEmptySegmentedDateFieldState(): SegmentedDateFieldState;
+export declare function segmentedStateFromDdMmYyyyString(value: string): SegmentedDateFieldState;
+export declare function segmentedStateFromIsoDate(date: Date): SegmentedDateFieldState;
+export declare function buildDigitsOnlyFromState(state: SegmentedDateFieldState): string;
+export declare function buildMaskedDdMmYyyyFromState(state: SegmentedDateFieldState): string;
+export declare function getParsedDateFromState(state: SegmentedDateFieldState): Date | null;
+export declare function isSegmentCompleteValid(segment: SegmentedDateActiveSegment, state: SegmentedDateFieldState): boolean;
+export declare function applySegmentLeaveWhenChangingActiveSegment(state: SegmentedDateFieldState, nextActiveSegment: SegmentedDateActiveSegment): SegmentedDateFieldState;
+export declare function resetIncompleteSegmentsOnBlur(state: SegmentedDateFieldState): SegmentedDateFieldState;
+export declare function firstIncompleteSegmentForState(state: SegmentedDateFieldState): SegmentedDateActiveSegment;
+export interface ReduceSegmentedDateFieldKeyParams {
+    state: SegmentedDateFieldState;
+    key: string;
+    isComposing: boolean;
+}
+export declare function reduceSegmentedDateFieldKey(params: ReduceSegmentedDateFieldKeyParams): SegmentedDateFieldState | null;
+export declare function shouldPreventDefaultSegmentedKey(key: string): boolean;
+//# sourceMappingURL=segmented-date-field.d.ts.map

package/components/datepicker/segmented-date-field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segmented-date-field.d.ts","sourceRoot":"","sources":["../../../components/datepicker/segmented-date-field.ts"],"names":[],"mappings":"AAgBA,MAAM,MAAM,0BAA0B,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,CAAC;AAElE,eAAO,MAAM,aAAa,EAAE,SAAS,0BAA0B,EAA6B,CAAC;AAE7F,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,0BAA0B,CAAC;CAC3C;AA8BD,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,0BAA0B,EACnC,gBAAgB,EAAE,MAAM,GACvB,MAAM,CASR;AAED,wBAAgB,kCAAkC,IAAI,uBAAuB,CAO5E;AAED,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,MAAM,GAAG,uBAAuB,CAQvF;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,IAAI,GAAG,uBAAuB,CAO7E;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,uBAAuB,GAAG,MAAM,CAE/E;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,uBAAuB,GAAG,MAAM,CAMnF;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,uBAAuB,GAAG,IAAI,GAAG,IAAI,CAElF;AAkED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,0BAA0B,EAAE,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAQnH;AAiBD,wBAAgB,0CAA0C,CACxD,KAAK,EAAE,uBAAuB,EAC9B,iBAAiB,EAAE,0BAA0B,GAC5C,uBAAuB,CAezB;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,uBAAuB,GAAG,uBAAuB,CAiBrG;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,uBAAuB,GAAG,0BAA0B,CAWzG;AA2GD,MAAM,WAAW,iCAAiC;IAChD,KAAK,EAAE,uBAAuB,CAAC;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,iCAAiC,GAAG,uBAAuB,GAAG,IAAI,CA2BrH;AAED,wBAAgB,gCAAgC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAQrE"}