@tylertech/forge 3.9.2 → 3.10.1

package/dist/vscode.html-custom-data.json

@@ -672,6 +672,11 @@
           "description": "Whether the mask format is displayed in the input or not. Only applies if `masked` is `true`.",
           "values": []
         },
+        {
+          "name": "date-format",
+          "description": "The date format to use for the date picker.",
+          "values": [{ "name": "DatePickerDateFormat" }]
+        },
         {
           "name": "show-today",
           "description": "Whether the today button is visible in the popup.",
@@ -682,6 +687,11 @@
           "description": "The type for the `value` property and `forge-date-picker-change` event.",
           "values": [{ "name": "DatePickerValueMode" }]
         },
+        {
+          "name": "shortcuts",
+          "description": "When specifies as an attribute you can only use the `off` value to disable shortcuts. Otherwise, you can use the `shortcuts` property to set your own shortcuts.",
+          "values": [{ "name": "DatePickerShortcuts" }]
+        },
         { "name": "year-range", "description": "The year range.", "values": [] }
       ],
       "references": []
@@ -751,6 +761,11 @@
           "description": "Whether the mask format is displayed in the input or not. Only applies if `masked` is `true`.",
           "values": []
         },
+        {
+          "name": "date-format",
+          "description": "The date format to use for the date picker.",
+          "values": [{ "name": "DatePickerDateFormat" }]
+        },
         {
           "name": "show-today",
           "description": "Whether the today button is visible in the popup.",
@@ -761,6 +776,11 @@
           "description": "The type for the `value` property and `forge-date-picker-change` event.",
           "values": [{ "name": "DatePickerValueMode" }]
         },
+        {
+          "name": "shortcuts",
+          "description": "When specifies as an attribute you can only use the `off` value to disable shortcuts. Otherwise, you can use the `shortcuts` property to set your own shortcuts.",
+          "values": [{ "name": "DatePickerShortcuts" }]
+        },
         { "name": "year-range", "description": "The year range.", "values": [] }
       ],
       "references": []

package/esm/app-bar/profile-button/app-bar-profile-button-adapter.js

@@ -87,7 +87,7 @@ export class AppBarProfileButtonAdapter extends BaseAdapter {
     async closePopup() {
         if (this._popupElement) {
             await this._popupElement.hideAsync();
-            this._popupElement.remove();
+            this._popupElement?.remove();
             this._popupElement = undefined;
             this._profileCardElement = undefined;
         }

package/esm/core/mask/date-input-mask.js

@@ -4,7 +4,7 @@
  * License: Apache-2.0
  */
 import { isNumeric } from '@tylertech/forge-core';
-import { InputMask, MaskedRange, createMask } from 'imask';
+import { InputMask, MaskedEnum, MaskedRange, createMask } from 'imask';
 export const DEFAULT_DATE_MASK = '0`0{/}`0`0{/}`0`0`0`0';
 export class DateInputMask {
     constructor(_element, _options = {}) {
@@ -49,6 +49,16 @@ export class DateInputMask {
                     to: 12,
                     maxLength: 2
                 },
+                Mmm: {
+                    mask: MaskedEnum,
+                    enum: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
+                    matchValue: (enumStr, inputStr, matchFrom) => MaskedEnum.DEFAULTS.matchValue(enumStr.toLowerCase(), inputStr.toLowerCase(), matchFrom)
+                },
+                MMM: {
+                    mask: MaskedEnum,
+                    enum: ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC'],
+                    matchValue: (enumStr, inputStr, matchFrom) => MaskedEnum.DEFAULTS.matchValue(enumStr.toLowerCase(), inputStr.toLowerCase(), matchFrom)
+                },
                 DD: {
                     mask: MaskedRange,
                     autofix: true,
@@ -62,6 +72,13 @@ export class DateInputMask {
                     from: 0,
                     to: 9999,
                     maxLength: 4
+                },
+                YY: {
+                    mask: MaskedRange,
+                    autofix: true,
+                    from: 0,
+                    to: 99,
+                    maxLength: 2
                 }
             }
         };

package/esm/core/utils/date-utils.d.ts

@@ -3,18 +3,27 @@
  * Copyright Tyler Technologies, Inc. 
  * License: Apache-2.0
  */
+export type SupportedDateFormats = 'MM/DD/YYYY' | 'MM/DD/YY' | 'DD/MMM/YYYY' | 'MM-DD-YYYY' | 'MM-DD-YY' | 'DD-MMM-YYYY' | 'YYYY-MM-DD' | 'YYYY-MMM-DD' | 'DD.MM.YYYY' | 'DD.MM.YY';
 export declare const ISO_8601_REGEX: RegExp;
 export declare const ISO_TIMEZONE_REGEX: RegExp;
 /**
  * Parses a date string value to a `Date` object in local time.
- * @param str The date string value.
+ * Supports multiple formats as defined in SupportedDateFormats.
+ *
+ * @param value The date string value to parse
+ * @param format Optional format hint for better parsing accuracy
+ * @returns Parsed Date object or null if parsing fails
  */
-export declare function parseDateString(value: string): Date | null;
+export declare function parseDateString(value: string, format?: SupportedDateFormats): Date | null;
 /**
- * Formats a `Date` to a specified format.
- * @param str The date string value.
+ * Formats a Date object to a specified string format.
+ *
+ * @param date The Date object to format
+ * @param format The desired output format (defaults to 'MM/DD/YYYY')
+ * @returns Formatted date string
+ * @throws Error if date is invalid or format is unsupported
  */
-export declare function formatDate(date: Date): string;
+export declare function formatDate(date: Date, format?: SupportedDateFormats): string;
 /**
  * Determines if two date objects are equal.
  *

package/esm/core/utils/date-utils.js

@@ -7,89 +7,248 @@ import { isValidDate } from '@tylertech/forge-core';
 export const ISO_8601_REGEX = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([.,]\d+(?!:))?)?(\17[0-5]\d([.,]\d+)?)?([zZ]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
 export const ISO_TIMEZONE_REGEX = /a-z/i;
 const FUTURE_YEAR_COERCION = 10; // The number of years in the future to coerce two-digit years into current century
-/**
- * Parses a date string value to a `Date` object in local time.
- * @param str The date string value.
- */
-export function parseDateString(value) {
-    value = value.replace(/_|\s/g, ''); // Remove potential extraneous characters
-    // We first check if this is a valid date in ISO 8601 format and return it if so
-    if (ISO_8601_REGEX.test(value)) {
-        const iso8601Date = new Date(value);
-        // This is an ISO string, but does it have a timezone? If not, we add current timezone offset
-        if (!ISO_TIMEZONE_REGEX.test(value)) {
-            iso8601Date.setMinutes(iso8601Date.getMinutes() + iso8601Date.getTimezoneOffset());
-        }
-        if (isValidDate(iso8601Date)) {
-            return iso8601Date;
-        }
+const MONTH_ABBREVIATIONS = {
+    JAN: 1,
+    FEB: 2,
+    MAR: 3,
+    APR: 4,
+    MAY: 5,
+    JUN: 6,
+    JUL: 7,
+    AUG: 8,
+    SEP: 9,
+    OCT: 10,
+    NOV: 11,
+    DEC: 12
+};
+const MONTH_NAMES = {
+    1: 'JAN',
+    2: 'FEB',
+    3: 'MAR',
+    4: 'APR',
+    5: 'MAY',
+    6: 'JUN',
+    7: 'JUL',
+    8: 'AUG',
+    9: 'SEP',
+    10: 'OCT',
+    11: 'NOV',
+    12: 'DEC'
+};
+const DATE_PATTERNS = [
+    // YYYY-MM-DD (ISO-like numeric)
+    {
+        regex: /^(\d{4})-(\d{1,2})-(\d{1,2})$/,
+        parser: ([year, month, day]) => parseNumericDate(year, month, day, 'YMD')
+    },
+    // YYYY-MMM-DD
+    {
+        regex: /^(\d{4})-([A-Za-z]{3})-(\d{1,2})$/,
+        parser: ([year, monthAbbr, day]) => parseWithMonthAbbr(year, monthAbbr, day, 'YMD')
+    },
+    // MM/DD/YYYY or MM/DD/YY
+    {
+        regex: /^(\d{1,2})\/(\d{1,2})\/(\d{2,4})$/,
+        parser: ([month, day, year]) => parseNumericDate(month, day, year, 'MDY')
+    },
+    // MM-DD-YYYY or MM-DD-YY
+    {
+        regex: /^(\d{1,2})-(\d{1,2})-(\d{2,4})$/,
+        parser: ([month, day, year]) => parseNumericDate(month, day, year, 'MDY')
+    },
+    // DD/MMM/YYYY
+    {
+        regex: /^(\d{1,2})\/([A-Za-z]{3})\/(\d{2,4})$/,
+        parser: ([day, monthAbbr, year]) => parseWithMonthAbbr(day, monthAbbr, year, 'DMY')
+    },
+    // DD-MMM-YYYY
+    {
+        regex: /^(\d{1,2})-([A-Za-z]{3})-(\d{2,4})$/,
+        parser: ([day, monthAbbr, year]) => parseWithMonthAbbr(day, monthAbbr, year, 'DMY')
+    },
+    // Numeric without separators (MMDDYYYY or MMDDYY)
+    {
+        regex: /^(\d{2})(\d{2})(\d{2,4})$/,
+        parser: ([month, day, year]) => parseNumericDate(month, day, year, 'MDY')
+    },
+    // DD.MM.YYYY or DD.MM.YY
+    {
+        regex: /^(\d{1,2})\.(\d{1,2})\.(\d{2,4})$/,
+        parser: ([day, month, year]) => parseNumericDate(day, month, year, 'DMY')
     }
-    let values = [];
-    // We accept dates with a "/" or "-" separator and in the format of MM/DD/YYYY
-    if (value.indexOf('/') !== -1) {
-        values = value.split('/');
+];
+const FORMAT_CONFIGS = {
+    'MM/DD/YYYY': {
+        pattern: 'MM/DD/YYYY',
+        formatter: date => `${pad(date.getMonth() + 1)}/${pad(date.getDate())}/${date.getFullYear()}`
+    },
+    'MM/DD/YY': {
+        pattern: 'MM/DD/YY',
+        formatter: date => `${pad(date.getMonth() + 1)}/${pad(date.getDate())}/${String(date.getFullYear()).slice(-2)}`
+    },
+    'DD/MMM/YYYY': {
+        pattern: 'DD/MMM/YYYY',
+        formatter: date => `${pad(date.getDate())}/${MONTH_NAMES[(date.getMonth() + 1)]}/${date.getFullYear()}`
+    },
+    'MM-DD-YYYY': {
+        pattern: 'MM-DD-YYYY',
+        formatter: date => `${pad(date.getMonth() + 1)}-${pad(date.getDate())}-${date.getFullYear()}`
+    },
+    'MM-DD-YY': {
+        pattern: 'MM-DD-YY',
+        formatter: date => `${pad(date.getMonth() + 1)}-${pad(date.getDate())}-${String(date.getFullYear()).slice(-2)}`
+    },
+    'DD-MMM-YYYY': {
+        pattern: 'DD-MMM-YYYY',
+        formatter: date => `${pad(date.getDate())}-${MONTH_NAMES[(date.getMonth() + 1)]}-${date.getFullYear()}`
+    },
+    'YYYY-MM-DD': {
+        pattern: 'YYYY-MM-DD',
+        formatter: date => `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`
+    },
+    'YYYY-MMM-DD': {
+        pattern: 'YYYY-MMM-DD',
+        formatter: date => `${date.getFullYear()}-${MONTH_NAMES[(date.getMonth() + 1)]}-${pad(date.getDate())}`
+    },
+    'DD.MM.YYYY': {
+        pattern: 'DD.MM.YYYY',
+        formatter: date => `${pad(date.getDate())}.${pad(date.getMonth() + 1)}.${date.getFullYear()}`
+    },
+    'DD.MM.YY': {
+        pattern: 'DD.MM.YY',
+        formatter: date => `${pad(date.getDate())}.${pad(date.getMonth() + 1)}.${String(date.getFullYear()).slice(-2)}`
     }
-    else if (value.indexOf('-') !== -1) {
-        values = value.split('-');
+};
+function pad(num) {
+    return String(num).padStart(2, '0');
+}
+function normalizeYear(year) {
+    if (year.length === 3) {
+        year = year.padStart(4, '0');
     }
-    else if ((value.length === 6 || value.length === 8) && !isNaN(+value)) {
-        values = [value.substring(0, 2), value.substring(2, 4), value.substring(4)];
+    if (year.length === 2) {
+        const currentYear = new Date().getFullYear();
+        const minYear = currentYear - (100 - FUTURE_YEAR_COERCION);
+        const maxYear = currentYear + FUTURE_YEAR_COERCION;
+        const minCentury = String(minYear).slice(0, 2);
+        const maxCentury = String(maxYear).slice(0, 2);
+        const maxYearLastTwo = +String(maxYear).slice(2);
+        return +year <= maxYearLastTwo ? +`${maxCentury}${year}` : +`${minCentury}${year}`;
     }
-    const hasMonthDayYear = values.length === 3;
-    let [month, day, year] = values;
-    // Ensure are month and year values are coerced from 0 to 1 in case of incomplete entry
-    if (month === '0') {
-        month = '1';
+    return +year;
+}
+function validateAndClampDate(month, day, year) {
+    const clampedMonth = Math.min(Math.max(month, 1), 12);
+    const maxDaysInMonth = new Date(year, clampedMonth, 0).getDate();
+    const clampedDay = Math.min(Math.max(day, 1), maxDaysInMonth);
+    return { month: clampedMonth, day: clampedDay, year };
+}
+function parseMonthAbbreviation(abbr) {
+    const upperAbbr = abbr.toUpperCase();
+    return MONTH_ABBREVIATIONS[upperAbbr] || null;
+}
+function parseNumericDate(part1, part2, part3, order) {
+    let monthStr;
+    let dayStr;
+    let yearStr;
+    if (order === 'MDY') {
+        [monthStr, dayStr, yearStr] = [part1, part2, part3];
     }
-    if (day === '0') {
-        day = '1';
+    else if (order === 'YMD') {
+        [yearStr, monthStr, dayStr] = [part1, part2, part3];
     }
-    // Trap for the case where only 3 digit years are entered
-    if (typeof year === 'string' && year.length === 3) {
-        year = year.padStart(4, '0');
+    else {
+        // DMY
+        [dayStr, monthStr, yearStr] = [part1, part2, part3];
     }
-    if (hasMonthDayYear) {
-        const isValidMonthLength = month.length === 1 || month.length === 2;
-        const isValidDayLength = day.length === 1 || day.length === 2;
-        const isValidYearLength = year.length === 2 || year.length === 4;
-        if (!isValidMonthLength || !isValidDayLength || !isValidYearLength) {
-            return null;
-        }
+    // Handle edge cases for incomplete input
+    if (monthStr === '0') {
+        monthStr = '1';
+    }
+    if (dayStr === '0') {
+        dayStr = '1';
+    }
+    const year = normalizeYear(yearStr);
+    const month = +monthStr;
+    const day = +dayStr;
+    const { month: validMonth, day: validDay, year: validYear } = validateAndClampDate(month, day, year);
+    const date = new Date(validYear, validMonth - 1, validDay, 0, 0, 0, 0);
+    return isValidDate(date) ? date : null;
+}
+function parseWithMonthAbbr(part1, monthAbbr, part3, order) {
+    const monthNum = parseMonthAbbreviation(monthAbbr);
+    if (!monthNum) {
+        return null;
+    }
+    let dayStr;
+    let yearStr;
+    if (order === 'DMY') {
+        [dayStr, yearStr] = [part1, part3];
     }
     else {
+        [yearStr, dayStr] = [part1, part3];
+    }
+    const year = normalizeYear(yearStr);
+    const day = +dayStr;
+    const { day: validDay, year: validYear } = validateAndClampDate(monthNum, day, year);
+    const date = new Date(validYear, monthNum - 1, validDay, 0, 0, 0, 0);
+    return isValidDate(date) ? date : null;
+}
+function parseISO8601(value) {
+    if (!ISO_8601_REGEX.test(value)) {
         return null;
     }
-    // Check if we need to coerce two-digit years to the four-digit equivalent
-    if (year.length === 2) {
-        const minYear = new Date().getFullYear() - (100 - FUTURE_YEAR_COERCION);
-        const maxYear = new Date().getFullYear() + FUTURE_YEAR_COERCION;
-        const minYearCentury = String(minYear).slice(0, 2);
-        const maxYearCentury = String(maxYear).slice(0, 2);
-        const normalizedMaxYear = +String(maxYear).slice(2);
-        year = +year <= normalizedMaxYear ? `${maxYearCentury}${year}` : `${minYearCentury}${year}`;
-    }
-    let numMonth = +month;
-    let numDay = +day;
-    const numYear = +year;
-    if (numMonth > 12) {
-        numMonth = 12;
-    }
-    const maxDaysInMonth = new Date(numYear, numMonth, 0).getDate();
-    if (numDay > maxDaysInMonth) {
-        numDay = maxDaysInMonth;
-    }
-    const parsedDate = new Date(numYear, numMonth - 1, numDay, 0, 0, 0, 0);
-    return isValidDate(parsedDate) ? parsedDate : null;
+    const date = new Date(value);
+    // Handle timezone offset for ISO strings without explicit timezone
+    if (!ISO_TIMEZONE_REGEX.test(value)) {
+        date.setMinutes(date.getMinutes() + date.getTimezoneOffset());
+    }
+    return isValidDate(date) ? date : null;
 }
 /**
- * Formats a `Date` to a specified format.
- * @param str The date string value.
+ * Parses a date string value to a `Date` object in local time.
+ * Supports multiple formats as defined in SupportedDateFormats.
+ *
+ * @param value The date string value to parse
+ * @param format Optional format hint for better parsing accuracy
+ * @returns Parsed Date object or null if parsing fails
  */
-export function formatDate(date) {
-    const month = String(date.getMonth() + 1).padStart(2, '0');
-    const day = String(date.getDate()).padStart(2, '0');
-    const year = String(date.getFullYear()).padStart(4, '0');
-    return [month, day, year].join('/');
+export function parseDateString(value, format) {
+    const cleanValue = value.replace(/[_\s]/g, '');
+    // Try ISO 8601 first
+    const isoDate = parseISO8601(cleanValue);
+    if (isoDate) {
+        return isoDate;
+    }
+    // Try each pattern until one matches
+    for (const pattern of DATE_PATTERNS) {
+        const match = cleanValue.match(pattern.regex);
+        if (match) {
+            const result = pattern.parser(match.slice(1));
+            if (result) {
+                return result;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Formats a Date object to a specified string format.
+ *
+ * @param date The Date object to format
+ * @param format The desired output format (defaults to 'MM/DD/YYYY')
+ * @returns Formatted date string
+ * @throws Error if date is invalid or format is unsupported
+ */
+export function formatDate(date, format = 'MM/DD/YYYY') {
+    if (!isValidDate(date)) {
+        throw new Error('Invalid date provided');
+    }
+    const config = FORMAT_CONFIGS[format];
+    if (!config) {
+        throw new Error(`Unsupported format: ${format}`);
+    }
+    return config.formatter(date);
 }
 /**
  * Determines if two date objects are equal.

package/esm/date-picker/base/base-date-picker-constants.d.ts

@@ -5,10 +5,19 @@
  */
 import { Masked, InputMask, type AppendFlags, type FactoryArg } from 'imask';
 import { DayOfWeek, ICalendarDateSelectEventData } from '../../calendar';
-export declare type DatePickerParseCallback = (value: string) => Date | null;
-export declare type DatePickerFormatCallback = (value: Date | null) => string;
-export declare type DatePickerPrepareMaskCallback = (value: string, masked: Masked<string>, flags: AppendFlags, maskInstance: InputMask<FactoryArg>) => string;
-export declare type DatePickerValueMode = 'object' | 'string' | 'iso-string';
+import { type IDatePickerComponent } from '../date-picker';
+import { SupportedDateFormats } from '../../core/utils/date-utils';
+export type DatePickerParseCallback = (value: string) => Date | null;
+export type DatePickerFormatCallback = (value: Date | null) => string | null;
+export type DatePickerPrepareMaskCallback = (value: string, masked: Masked<string>, flags: AppendFlags, maskInstance: InputMask<FactoryArg>) => string;
+export type DatePickerValueMode = 'object' | 'string' | 'iso-string';
+export type DatePickerShortcuts = IDatePickerShortcuts | 'off' | undefined;
+export type DatePickerDateFormat = SupportedDateFormats;
+export interface IDatePickerShortcuts {
+    [key: string]: (context: {
+        instance: IDatePickerComponent;
+    }) => Date | null | undefined | void;
+}
 export interface IDatePickerCalendarDropdownConfig<T> {
     value?: T | null;
     min?: Date | null;
@@ -45,7 +54,9 @@ export declare const BASE_DATE_PICKER_CONSTANTS: {
         MASKED: string;
         MASK_FORMAT: string;
         SHOW_MASK_FORMAT: string;
+        DATE_FORMAT: string;
         VALUE_MODE: string;
+        SHORTCUTS: string;
         ALLOW_INVALID_DATE: string;
         SHOW_TODAY: string;
         SHOW_CLEAR: string;
@@ -61,4 +72,8 @@ export declare const BASE_DATE_PICKER_CONSTANTS: {
         INPUT: string;
         TOGGLE: string;
     };
+    defaults: {
+        DATE_FORMAT: DatePickerDateFormat;
+    };
+    supportedDateFormats: SupportedDateFormats[];
 };

package/esm/date-picker/base/base-date-picker-constants.js

@@ -12,7 +12,9 @@ const observedAttributes = {
     MASKED: 'masked',
     MASK_FORMAT: 'mask-format',
     SHOW_MASK_FORMAT: 'show-mask-format',
+    DATE_FORMAT: 'date-format',
     VALUE_MODE: 'value-mode',
+    SHORTCUTS: 'shortcuts',
     ALLOW_INVALID_DATE: 'allow-invalid-date',
     SHOW_TODAY: 'show-today',
     SHOW_CLEAR: 'show-clear',
@@ -28,8 +30,25 @@ const selectors = {
     INPUT: 'input',
     TOGGLE: '[forge-date-picker-toggle],[data-forge-date-picker-toggle]'
 };
+const defaults = {
+    DATE_FORMAT: 'MM/DD/YYYY'
+};
+const supportedDateFormats = [
+    'MM/DD/YYYY',
+    'MM/DD/YY',
+    'DD/MMM/YYYY',
+    'MM-DD-YYYY',
+    'MM-DD-YY',
+    'DD-MMM-YYYY',
+    'YYYY-MM-DD',
+    'YYYY-MMM-DD',
+    'DD.MM.YYYY',
+    'DD.MM.YY'
+];
 export const BASE_DATE_PICKER_CONSTANTS = {
     observedAttributes,
     attributes,
-    selectors
+    selectors,
+    defaults,
+    supportedDateFormats
 };

package/esm/date-picker/base/base-date-picker-core.d.ts

@@ -5,7 +5,7 @@
  */
 import { CalendarMode, DayOfWeek, ICalendarDateSelectEventData } from '../../calendar/calendar-constants';
 import { IBaseDatePickerAdapter } from './base-date-picker-adapter';
-import { DatePickerFormatCallback, DatePickerParseCallback, DatePickerPrepareMaskCallback, DatePickerValueMode, IDatePickerCalendarDropdownText } from './base-date-picker-constants';
+import { DatePickerFormatCallback, DatePickerParseCallback, DatePickerPrepareMaskCallback, IDatePickerShortcuts, DatePickerValueMode, IDatePickerCalendarDropdownText, DatePickerShortcuts, DatePickerDateFormat } from './base-date-picker-constants';
 export interface IBaseDatePickerCore<TValue> {
     value: TValue | null | undefined;
     min: Date | string | null | undefined;
@@ -20,6 +20,7 @@ export interface IBaseDatePickerCore<TValue> {
     masked: boolean;
     maskFormat: string;
     showMaskFormat: boolean;
+    dateFormat: DatePickerDateFormat;
     valueMode: DatePickerValueMode;
     notifyInputValueChanges: boolean;
     allowInvalidDate: boolean;
@@ -45,7 +46,9 @@ export declare abstract class BaseDatePickerCore<TAdapter extends IBaseDatePicke
     protected _masked: boolean;
     protected _maskFormat: string;
     protected _showMaskFormat: boolean;
+    protected _dateFormat: DatePickerDateFormat;
     protected _valueMode: DatePickerValueMode;
+    protected _shortcuts: IDatePickerShortcuts | undefined;
     protected _notifyInputValueChanges: boolean;
     protected _allowInvalidDate: boolean;
     protected _showToday: boolean;
@@ -95,6 +98,7 @@ export declare abstract class BaseDatePickerCore<TAdapter extends IBaseDatePicke
     protected _onInputBlur(evt: FocusEvent): void;
     protected _openCalendar(emitOpenEvent?: boolean): void;
     protected _closeCalendar(emitCloseEvent?: boolean): void;
+    private _getDefaultShortcuts;
     protected _onInputKeydown(evt: KeyboardEvent): void;
     protected _getSanitizedDateString(value: string): string;
     private _onToggleMousedown;
@@ -102,19 +106,21 @@ export declare abstract class BaseDatePickerCore<TAdapter extends IBaseDatePicke
     private _onMonthChanged;
     private _onActiveDescendantChanged;
     protected _formatInputValue(): void;
-    protected _formatDate(date: Date | null | undefined): string;
+    protected _formatDate(date: Date | null | undefined): string | null;
     protected _parseDateString(value: string): Date | null;
     protected _coerceDateValue(value?: Date | string | null): Date | null | undefined;
     protected _getTypedValue(value: Date | null | undefined): Date | string | null | undefined;
     protected _isDateValueAcceptable(value?: Date | null): boolean;
     protected _initializeMask(): void;
-    private _applyMask;
+    protected _applyMask(): void;
     protected _applyMin(): void;
     protected _applyMax(): void;
     private _applyDisableDayCallback;
     private _applyDisabled;
     get valueMode(): DatePickerValueMode;
     set valueMode(value: DatePickerValueMode);
+    get shortcuts(): DatePickerShortcuts;
+    set shortcuts(value: DatePickerShortcuts);
     get min(): Date | string | null | undefined;
     set min(value: Date | string | null | undefined);
     get max(): Date | string | null | undefined;
@@ -133,6 +139,8 @@ export declare abstract class BaseDatePickerCore<TAdapter extends IBaseDatePicke
     set maskFormat(value: string);
     get showMaskFormat(): boolean;
     set showMaskFormat(value: boolean);
+    get dateFormat(): DatePickerDateFormat;
+    set dateFormat(value: DatePickerDateFormat);
     get notifyInputValueChanges(): boolean;
     set notifyInputValueChanges(value: boolean);
     get allowInvalidDate(): boolean;