@mui/x-date-pickers 8.0.0-alpha.11 → 8.0.0-alpha.12

package/esm/internals/utils/getDefaultReferenceDate.d.ts

@@ -0,0 +1,31 @@
+import { FieldSection, MuiPickersAdapter, PickersTimezone, PickerValidDate } from "../../models/index.js";
+export interface GetDefaultReferenceDateProps {
+  maxDate?: PickerValidDate;
+  minDate?: PickerValidDate;
+  minTime?: PickerValidDate;
+  maxTime?: PickerValidDate;
+  disableIgnoringDatePartForTimeValidation?: boolean;
+}
+export declare const SECTION_TYPE_GRANULARITY: {
+  year: number;
+  month: number;
+  day: number;
+  hours: number;
+  minutes: number;
+  seconds: number;
+  milliseconds: number;
+};
+export declare const getSectionTypeGranularity: (sections: FieldSection[]) => number;
+export declare const getDefaultReferenceDate: ({
+  props,
+  utils,
+  granularity,
+  timezone,
+  getTodayDate: inGetTodayDate
+}: {
+  props: GetDefaultReferenceDateProps;
+  utils: MuiPickersAdapter;
+  granularity: number;
+  timezone: PickersTimezone;
+  getTodayDate?: () => PickerValidDate;
+}) => PickerValidDate;

package/esm/internals/utils/getDefaultReferenceDate.js

@@ -0,0 +1,59 @@
+import { createIsAfterIgnoreDatePart } from "./time-utils.js";
+import { mergeDateAndTime, getTodayDate } from "./date-utils.js";
+export const SECTION_TYPE_GRANULARITY = {
+  year: 1,
+  month: 2,
+  day: 3,
+  hours: 4,
+  minutes: 5,
+  seconds: 6,
+  milliseconds: 7
+};
+export const getSectionTypeGranularity = sections => Math.max(...sections.map(section => SECTION_TYPE_GRANULARITY[section.type] ?? 1));
+const roundDate = (utils, granularity, date) => {
+  if (granularity === SECTION_TYPE_GRANULARITY.year) {
+    return utils.startOfYear(date);
+  }
+  if (granularity === SECTION_TYPE_GRANULARITY.month) {
+    return utils.startOfMonth(date);
+  }
+  if (granularity === SECTION_TYPE_GRANULARITY.day) {
+    return utils.startOfDay(date);
+  }
+
+  // We don't have startOfHour / startOfMinute / startOfSecond
+  let roundedDate = date;
+  if (granularity < SECTION_TYPE_GRANULARITY.minutes) {
+    roundedDate = utils.setMinutes(roundedDate, 0);
+  }
+  if (granularity < SECTION_TYPE_GRANULARITY.seconds) {
+    roundedDate = utils.setSeconds(roundedDate, 0);
+  }
+  if (granularity < SECTION_TYPE_GRANULARITY.milliseconds) {
+    roundedDate = utils.setMilliseconds(roundedDate, 0);
+  }
+  return roundedDate;
+};
+export const getDefaultReferenceDate = ({
+  props,
+  utils,
+  granularity,
+  timezone,
+  getTodayDate: inGetTodayDate
+}) => {
+  let referenceDate = inGetTodayDate ? inGetTodayDate() : roundDate(utils, granularity, getTodayDate(utils, timezone));
+  if (props.minDate != null && utils.isAfterDay(props.minDate, referenceDate)) {
+    referenceDate = roundDate(utils, granularity, props.minDate);
+  }
+  if (props.maxDate != null && utils.isBeforeDay(props.maxDate, referenceDate)) {
+    referenceDate = roundDate(utils, granularity, props.maxDate);
+  }
+  const isAfter = createIsAfterIgnoreDatePart(props.disableIgnoringDatePartForTimeValidation ?? false, utils);
+  if (props.minTime != null && isAfter(props.minTime, referenceDate)) {
+    referenceDate = roundDate(utils, granularity, props.disableIgnoringDatePartForTimeValidation ? props.minTime : mergeDateAndTime(utils, referenceDate, props.minTime));
+  }
+  if (props.maxTime != null && isAfter(referenceDate, props.maxTime)) {
+    referenceDate = roundDate(utils, granularity, props.disableIgnoringDatePartForTimeValidation ? props.maxTime : mergeDateAndTime(utils, referenceDate, props.maxTime));
+  }
+  return referenceDate;
+};

package/esm/internals/utils/time-utils.d.ts

@@ -0,0 +1,19 @@
+import { MuiPickersAdapter, PickerValidDate, TimeView } from "../../models/index.js";
+import { DateOrTimeViewWithMeridiem, TimeViewWithMeridiem } from "../models/index.js";
+export declare const isTimeView: (view: DateOrTimeViewWithMeridiem) => boolean;
+export declare const isInternalTimeView: (view: DateOrTimeViewWithMeridiem) => view is TimeViewWithMeridiem;
+export type Meridiem = 'am' | 'pm';
+export declare const getMeridiem: (date: PickerValidDate | null, utils: MuiPickersAdapter) => Meridiem | null;
+export declare const convertValueToMeridiem: (value: number, meridiem: Meridiem | null, ampm: boolean) => number;
+export declare const convertToMeridiem: (time: PickerValidDate, meridiem: Meridiem, ampm: boolean, utils: MuiPickersAdapter) => PickerValidDate;
+export declare const getSecondsInDay: (date: PickerValidDate, utils: MuiPickersAdapter) => number;
+export declare const createIsAfterIgnoreDatePart: (disableIgnoringDatePartForTimeValidation: boolean, utils: MuiPickersAdapter) => (dateLeft: PickerValidDate, dateRight: PickerValidDate) => boolean;
+export declare const resolveTimeFormat: (utils: MuiPickersAdapter, {
+  format,
+  views,
+  ampm
+}: {
+  format?: string;
+  views: readonly TimeView[];
+  ampm: boolean;
+}) => string;

package/esm/internals/utils/time-utils.js

@@ -0,0 +1,58 @@
+import { areViewsEqual } from "./views.js";
+const timeViews = ['hours', 'minutes', 'seconds'];
+export const isTimeView = view => timeViews.includes(view);
+export const isInternalTimeView = view => timeViews.includes(view) || view === 'meridiem';
+export const getMeridiem = (date, utils) => {
+  if (!date) {
+    return null;
+  }
+  return utils.getHours(date) >= 12 ? 'pm' : 'am';
+};
+export const convertValueToMeridiem = (value, meridiem, ampm) => {
+  if (ampm) {
+    const currentMeridiem = value >= 12 ? 'pm' : 'am';
+    if (currentMeridiem !== meridiem) {
+      return meridiem === 'am' ? value - 12 : value + 12;
+    }
+  }
+  return value;
+};
+export const convertToMeridiem = (time, meridiem, ampm, utils) => {
+  const newHoursAmount = convertValueToMeridiem(utils.getHours(time), meridiem, ampm);
+  return utils.setHours(time, newHoursAmount);
+};
+export const getSecondsInDay = (date, utils) => {
+  return utils.getHours(date) * 3600 + utils.getMinutes(date) * 60 + utils.getSeconds(date);
+};
+export const createIsAfterIgnoreDatePart = (disableIgnoringDatePartForTimeValidation, utils) => (dateLeft, dateRight) => {
+  if (disableIgnoringDatePartForTimeValidation) {
+    return utils.isAfter(dateLeft, dateRight);
+  }
+  return getSecondsInDay(dateLeft, utils) > getSecondsInDay(dateRight, utils);
+};
+export const resolveTimeFormat = (utils, {
+  format,
+  views,
+  ampm
+}) => {
+  if (format != null) {
+    return format;
+  }
+  const formats = utils.formats;
+  if (areViewsEqual(views, ['hours'])) {
+    return ampm ? `${formats.hours12h} ${formats.meridiem}` : formats.hours24h;
+  }
+  if (areViewsEqual(views, ['minutes'])) {
+    return formats.minutes;
+  }
+  if (areViewsEqual(views, ['seconds'])) {
+    return formats.seconds;
+  }
+  if (areViewsEqual(views, ['minutes', 'seconds'])) {
+    return `${formats.minutes}:${formats.seconds}`;
+  }
+  if (areViewsEqual(views, ['hours', 'minutes', 'seconds'])) {
+    return ampm ? `${formats.hours12h}:${formats.minutes}:${formats.seconds} ${formats.meridiem}` : `${formats.hours24h}:${formats.minutes}:${formats.seconds}`;
+  }
+  return ampm ? `${formats.hours12h}:${formats.minutes} ${formats.meridiem}` : `${formats.hours24h}:${formats.minutes}`;
+};

package/esm/internals/utils/utils.d.ts

@@ -0,0 +1,16 @@
+import { Theme } from '@mui/material/styles';
+import { SxProps, SystemStyleObject } from '@mui/system';
+import * as React from 'react';
+export declare function arrayIncludes<T>(array: T[] | readonly T[], itemOrItems: T | T[]): boolean;
+export declare const onSpaceOrEnter: (innerFn: (ev: React.MouseEvent<any> | React.KeyboardEvent<any>) => void, externalEvent?: (event: React.KeyboardEvent<any>) => void) => (event: React.KeyboardEvent) => void;
+export declare const executeInTheNextEventLoopTick: (fn: () => void) => void;
+export declare const getActiveElement: (root?: Document | ShadowRoot) => Element | null;
+/**
+ * Gets the index of the focused list item in a given ul list element.
+ *
+ * @param {HTMLUListElement} listElement - The list element to search within.
+ * @returns {number} The index of the focused list item, or -1 if none is focused.
+ */
+export declare const getFocusedListItemIndex: (listElement: HTMLUListElement) => number;
+export declare const DEFAULT_DESKTOP_MODE_MEDIA_QUERY = "@media (pointer: fine)";
+export declare function mergeSx(...sxProps: (SxProps<Theme> | undefined)[]): ReadonlyArray<boolean | SystemStyleObject<Theme> | ((theme: Theme) => SystemStyleObject<Theme>)>;

package/esm/internals/utils/utils.js

@@ -0,0 +1,56 @@
+/* Use it instead of .includes method for IE support */
+export function arrayIncludes(array, itemOrItems) {
+  if (Array.isArray(itemOrItems)) {
+    return itemOrItems.every(item => array.indexOf(item) !== -1);
+  }
+  return array.indexOf(itemOrItems) !== -1;
+}
+export const onSpaceOrEnter = (innerFn, externalEvent) => event => {
+  if (event.key === 'Enter' || event.key === ' ') {
+    innerFn(event);
+
+    // prevent any side effects
+    event.preventDefault();
+    event.stopPropagation();
+  }
+  if (externalEvent) {
+    externalEvent(event);
+  }
+};
+export const executeInTheNextEventLoopTick = fn => {
+  setTimeout(fn, 0);
+};
+
+// https://www.abeautifulsite.net/posts/finding-the-active-element-in-a-shadow-root/
+export const getActiveElement = (root = document) => {
+  const activeEl = root.activeElement;
+  if (!activeEl) {
+    return null;
+  }
+  if (activeEl.shadowRoot) {
+    return getActiveElement(activeEl.shadowRoot);
+  }
+  return activeEl;
+};
+
+/**
+ * Gets the index of the focused list item in a given ul list element.
+ *
+ * @param {HTMLUListElement} listElement - The list element to search within.
+ * @returns {number} The index of the focused list item, or -1 if none is focused.
+ */
+export const getFocusedListItemIndex = listElement => {
+  const children = Array.from(listElement.children);
+  return children.indexOf(getActiveElement(document));
+};
+export const DEFAULT_DESKTOP_MODE_MEDIA_QUERY = '@media (pointer: fine)';
+export function mergeSx(...sxProps) {
+  return sxProps.reduce((acc, sxProp) => {
+    if (Array.isArray(sxProp)) {
+      acc.push(...sxProp);
+    } else if (sxProp != null) {
+      acc.push(sxProp);
+    }
+    return acc;
+  }, []);
+}

package/esm/internals/utils/valueManagers.d.ts

@@ -0,0 +1,7 @@
+import type { PickerValueManager } from '../hooks/usePicker';
+import { DateValidationError, TimeValidationError, DateTimeValidationError } from "../../models/index.js";
+import type { FieldValueManager } from '../hooks/useField';
+import { PickerValue } from "../models/index.js";
+export type SingleItemPickerValueManager<TError extends DateValidationError | TimeValidationError | DateTimeValidationError = any> = PickerValueManager<PickerValue, TError>;
+export declare const singleItemValueManager: SingleItemPickerValueManager;
+export declare const singleItemFieldValueManager: FieldValueManager<PickerValue>;

package/esm/internals/utils/valueManagers.js

@@ -0,0 +1,52 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["value", "referenceDate"];
+import { areDatesEqual, getTodayDate, replaceInvalidDateByNull } from "./date-utils.js";
+import { getDefaultReferenceDate } from "./getDefaultReferenceDate.js";
+import { createDateStrForV7HiddenInputFromSections, createDateStrForV6InputFromSections } from "../hooks/useField/useField.utils.js";
+export const singleItemValueManager = {
+  emptyValue: null,
+  getTodayValue: getTodayDate,
+  getInitialReferenceValue: _ref => {
+    let {
+        value,
+        referenceDate
+      } = _ref,
+      params = _objectWithoutPropertiesLoose(_ref, _excluded);
+    if (params.utils.isValid(value)) {
+      return value;
+    }
+    if (referenceDate != null) {
+      return referenceDate;
+    }
+    return getDefaultReferenceDate(params);
+  },
+  cleanValue: replaceInvalidDateByNull,
+  areValuesEqual: areDatesEqual,
+  isSameError: (a, b) => a === b,
+  hasError: error => error != null,
+  defaultErrorState: null,
+  getTimezone: (utils, value) => utils.isValid(value) ? utils.getTimezone(value) : null,
+  setTimezone: (utils, timezone, value) => value == null ? null : utils.setTimezone(value, timezone)
+};
+export const singleItemFieldValueManager = {
+  updateReferenceValue: (utils, value, prevReferenceValue) => !utils.isValid(value) ? prevReferenceValue : value,
+  getSectionsFromValue: (utils, date, prevSections, getSectionsFromDate) => {
+    const shouldReUsePrevDateSections = !utils.isValid(date) && !!prevSections;
+    if (shouldReUsePrevDateSections) {
+      return prevSections;
+    }
+    return getSectionsFromDate(date);
+  },
+  getV7HiddenInputValueFromSections: createDateStrForV7HiddenInputFromSections,
+  getV6InputValueFromSections: createDateStrForV6InputFromSections,
+  getActiveDateManager: (utils, state) => ({
+    date: state.value,
+    referenceDate: state.referenceValue,
+    getSections: sections => sections,
+    getNewValuesFromNewActiveDate: newActiveDate => ({
+      value: newActiveDate,
+      referenceValue: utils.isValid(newActiveDate) ? newActiveDate : state.referenceValue
+    })
+  }),
+  parseValueStr: (valueStr, referenceValue, parseDate) => parseDate(valueStr.trim(), referenceValue)
+};

package/esm/internals/utils/views.d.ts

@@ -0,0 +1,17 @@
+import { DateOrTimeView } from "../../models/index.js";
+import { DateOrTimeViewWithMeridiem } from "../models/index.js";
+export declare const areViewsEqual: <TView extends DateOrTimeView>(views: ReadonlyArray<DateOrTimeView>, expectedViews: TView[]) => views is ReadonlyArray<TView>;
+export declare const applyDefaultViewProps: <TView extends DateOrTimeViewWithMeridiem>({
+  openTo,
+  defaultOpenTo,
+  views,
+  defaultViews
+}: {
+  openTo: TView | undefined;
+  defaultOpenTo: TView;
+  views: readonly TView[] | undefined;
+  defaultViews: readonly TView[];
+}) => {
+  views: readonly TView[];
+  openTo: TView;
+};

package/esm/internals/utils/views.js

@@ -0,0 +1,28 @@
+export const areViewsEqual = (views, expectedViews) => {
+  if (views.length !== expectedViews.length) {
+    return false;
+  }
+  return expectedViews.every(expectedView => views.includes(expectedView));
+};
+export const applyDefaultViewProps = ({
+  openTo,
+  defaultOpenTo,
+  views,
+  defaultViews
+}) => {
+  const viewsWithDefault = views ?? defaultViews;
+  let openToWithDefault;
+  if (openTo != null) {
+    openToWithDefault = openTo;
+  } else if (viewsWithDefault.includes(defaultOpenTo)) {
+    openToWithDefault = defaultOpenTo;
+  } else if (viewsWithDefault.length > 0) {
+    openToWithDefault = viewsWithDefault[0];
+  } else {
+    throw new Error('MUI X: The `views` prop must contain at least one view.');
+  }
+  return {
+    views: viewsWithDefault,
+    openTo: openToWithDefault
+  };
+};

package/esm/locales/beBY.d.ts

@@ -0,0 +1,80 @@
+import { TimeViewWithMeridiem } from "../internals/models/index.js";
+export declare const beBY: {
+  components: {
+    MuiLocalizationProvider: {
+      defaultProps: {
+        localeText: {
+          previousMonth?: string | undefined;
+          nextMonth?: string | undefined;
+          calendarWeekNumberHeaderLabel?: string | undefined;
+          calendarWeekNumberHeaderText?: string | undefined;
+          calendarWeekNumberAriaLabelText?: ((weekNumber: number) => string) | undefined;
+          calendarWeekNumberText?: ((weekNumber: number) => string) | undefined;
+          openPreviousView?: string | undefined;
+          openNextView?: string | undefined;
+          calendarViewSwitchingButtonAriaLabel?: ((currentView: import("@mui/x-date-pickers/models").DateView) => string) | undefined;
+          start?: string | undefined;
+          end?: string | undefined;
+          startDate?: string | undefined;
+          startTime?: string | undefined;
+          endDate?: string | undefined;
+          endTime?: string | undefined;
+          cancelButtonLabel?: string | undefined;
+          clearButtonLabel?: string | undefined;
+          okButtonLabel?: string | undefined;
+          todayButtonLabel?: string | undefined;
+          clockLabelText?: ((view: import("@mui/x-date-pickers/models").TimeView, formattedTime: string | null) => string) | undefined;
+          hoursClockNumberText?: ((hours: string) => string) | undefined;
+          minutesClockNumberText?: ((minutes: string) => string) | undefined;
+          secondsClockNumberText?: ((seconds: string) => string) | undefined;
+          selectViewText?: ((view: TimeViewWithMeridiem) => string) | undefined;
+          openDatePickerDialogue?: ((formattedDate: string | null) => string) | undefined;
+          openTimePickerDialogue?: ((formattedTime: string | null) => string) | undefined;
+          fieldClearLabel?: string | undefined;
+          timeTableLabel?: string | undefined;
+          dateTableLabel?: string | undefined;
+          fieldYearPlaceholder?: ((params: {
+            digitAmount: number;
+            format: string;
+          }) => string) | undefined;
+          fieldMonthPlaceholder?: ((params: {
+            contentType: import("@mui/x-date-pickers/models").FieldSectionContentType;
+            format: string;
+          }) => string) | undefined;
+          fieldDayPlaceholder?: ((params: {
+            format: string;
+          }) => string) | undefined;
+          fieldWeekDayPlaceholder?: ((params: {
+            contentType: import("@mui/x-date-pickers/models").FieldSectionContentType;
+            format: string;
+          }) => string) | undefined;
+          fieldHoursPlaceholder?: ((params: {
+            format: string;
+          }) => string) | undefined;
+          fieldMinutesPlaceholder?: ((params: {
+            format: string;
+          }) => string) | undefined;
+          fieldSecondsPlaceholder?: ((params: {
+            format: string;
+          }) => string) | undefined;
+          fieldMeridiemPlaceholder?: ((params: {
+            format: string;
+          }) => string) | undefined;
+          year?: string | undefined;
+          month?: string | undefined;
+          day?: string | undefined;
+          weekDay?: string | undefined;
+          hours?: string | undefined;
+          minutes?: string | undefined;
+          seconds?: string | undefined;
+          meridiem?: string | undefined;
+          empty?: string | undefined;
+          datePickerToolbarTitle?: string | undefined;
+          timePickerToolbarTitle?: string | undefined;
+          dateTimePickerToolbarTitle?: string | undefined;
+          dateRangePickerToolbarTitle?: string | undefined;
+        };
+      };
+    };
+  };
+};

package/esm/locales/beBY.js

@@ -0,0 +1,78 @@
+import { getPickersLocalization } from "./utils/getPickersLocalization.js";
+const views = {
+  // maps TimeView to its translation
+  hours: 'гадзіны',
+  minutes: 'хвіліны',
+  seconds: 'секунды',
+  meridiem: 'мерыдыем'
+};
+const beBYPickers = {
+  // Calendar navigation
+  previousMonth: 'Папярэдні месяц',
+  nextMonth: 'Наступны месяц',
+  // View navigation
+  openPreviousView: 'Aдкрыць папярэдні выгляд',
+  openNextView: 'Aдкрыць наступны выгляд',
+  calendarViewSwitchingButtonAriaLabel: view => view === 'year' ? 'гадавы выгляд адкрыты, перайсці да каляндарнага выгляду' : 'каляндарны выгляд адкрыты, перайсці да гадавога выгляду',
+  // DateRange labels
+  start: 'Пачатак',
+  end: 'Канец',
+  // startDate: 'Start date',
+  // startTime: 'Start time',
+  // endDate: 'End date',
+  // endTime: 'End time',
+
+  // Action bar
+  cancelButtonLabel: 'Адмена',
+  clearButtonLabel: 'Ачысціць',
+  okButtonLabel: 'OK',
+  todayButtonLabel: 'Сёння',
+  // Toolbar titles
+  datePickerToolbarTitle: 'Абраць дату',
+  dateTimePickerToolbarTitle: 'Абраць дату і час',
+  timePickerToolbarTitle: 'Абраць час',
+  dateRangePickerToolbarTitle: 'Абраць каляндарны перыяд',
+  // Clock labels
+  clockLabelText: (view, formattedTime) => `Абярыце ${views[view]}. ${!formattedTime ? 'Час не абраны' : `Абраны час ${formattedTime}`}`,
+  hoursClockNumberText: hours => `${hours} гадзін`,
+  minutesClockNumberText: minutes => `${minutes} хвілін`,
+  secondsClockNumberText: seconds => `${seconds} секунд`,
+  // Digital clock labels
+  selectViewText: view => `Абярыце ${views[view]}`,
+  // Calendar labels
+  calendarWeekNumberHeaderLabel: 'Нумар тыдня',
+  calendarWeekNumberHeaderText: '#',
+  calendarWeekNumberAriaLabelText: weekNumber => `Тыдзень ${weekNumber}`,
+  calendarWeekNumberText: weekNumber => `${weekNumber}`,
+  // Open picker labels
+  openDatePickerDialogue: formattedDate => formattedDate ? `Абраць дату, абрана дата  ${formattedDate}` : 'Абраць дату',
+  openTimePickerDialogue: formattedTime => formattedTime ? `Абраць час, абрыны час  ${formattedTime}` : 'Абраць час',
+  // fieldClearLabel: 'Clear',
+
+  // Table labels
+  timeTableLabel: 'абраць час',
+  dateTableLabel: 'абраць дату',
+  // Field section placeholders
+  fieldYearPlaceholder: params => 'Y'.repeat(params.digitAmount),
+  fieldMonthPlaceholder: params => params.contentType === 'letter' ? 'MMMM' : 'MM',
+  fieldDayPlaceholder: () => 'DD',
+  // fieldWeekDayPlaceholder: params => params.contentType === 'letter' ? 'EEEE' : 'EE',
+  fieldHoursPlaceholder: () => 'hh',
+  fieldMinutesPlaceholder: () => 'mm',
+  fieldSecondsPlaceholder: () => 'ss',
+  fieldMeridiemPlaceholder: () => 'aa'
+
+  // View names
+  // year: 'Year',
+  // month: 'Month',
+  // day: 'Day',
+  // weekDay: 'Week day',
+  // hours: 'Hours',
+  // minutes: 'Minutes',
+  // seconds: 'Seconds',
+  // meridiem: 'Meridiem',
+
+  // Common
+  // empty: 'Empty',
+};
+export const beBY = getPickersLocalization(beBYPickers);

package/esm/locales/bgBG.d.ts

@@ -0,0 +1,80 @@
+import { TimeViewWithMeridiem } from "../internals/models/index.js";
+export declare const bgBG: {
+  components: {
+    MuiLocalizationProvider: {
+      defaultProps: {
+        localeText: {
+          previousMonth?: string | undefined;
+          nextMonth?: string | undefined;
+          calendarWeekNumberHeaderLabel?: string | undefined;
+          calendarWeekNumberHeaderText?: string | undefined;
+          calendarWeekNumberAriaLabelText?: ((weekNumber: number) => string) | undefined;
+          calendarWeekNumberText?: ((weekNumber: number) => string) | undefined;
+          openPreviousView?: string | undefined;
+          openNextView?: string | undefined;
+          calendarViewSwitchingButtonAriaLabel?: ((currentView: import("@mui/x-date-pickers/models").DateView) => string) | undefined;
+          start?: string | undefined;
+          end?: string | undefined;
+          startDate?: string | undefined;
+          startTime?: string | undefined;
+          endDate?: string | undefined;
+          endTime?: string | undefined;
+          cancelButtonLabel?: string | undefined;
+          clearButtonLabel?: string | undefined;
+          okButtonLabel?: string | undefined;
+          todayButtonLabel?: string | undefined;
+          clockLabelText?: ((view: import("@mui/x-date-pickers/models").TimeView, formattedTime: string | null) => string) | undefined;
+          hoursClockNumberText?: ((hours: string) => string) | undefined;
+          minutesClockNumberText?: ((minutes: string) => string) | undefined;
+          secondsClockNumberText?: ((seconds: string) => string) | undefined;
+          selectViewText?: ((view: TimeViewWithMeridiem) => string) | undefined;
+          openDatePickerDialogue?: ((formattedDate: string | null) => string) | undefined;
+          openTimePickerDialogue?: ((formattedTime: string | null) => string) | undefined;
+          fieldClearLabel?: string | undefined;
+          timeTableLabel?: string | undefined;
+          dateTableLabel?: string | undefined;
+          fieldYearPlaceholder?: ((params: {
+            digitAmount: number;
+            format: string;
+          }) => string) | undefined;
+          fieldMonthPlaceholder?: ((params: {
+            contentType: import("@mui/x-date-pickers/models").FieldSectionContentType;
+            format: string;
+          }) => string) | undefined;
+          fieldDayPlaceholder?: ((params: {
+            format: string;
+          }) => string) | undefined;
+          fieldWeekDayPlaceholder?: ((params: {
+            contentType: import("@mui/x-date-pickers/models").FieldSectionContentType;
+            format: string;
+          }) => string) | undefined;
+          fieldHoursPlaceholder?: ((params: {
+            format: string;
+          }) => string) | undefined;
+          fieldMinutesPlaceholder?: ((params: {
+            format: string;
+          }) => string) | undefined;
+          fieldSecondsPlaceholder?: ((params: {
+            format: string;
+          }) => string) | undefined;
+          fieldMeridiemPlaceholder?: ((params: {
+            format: string;
+          }) => string) | undefined;
+          year?: string | undefined;
+          month?: string | undefined;
+          day?: string | undefined;
+          weekDay?: string | undefined;
+          hours?: string | undefined;
+          minutes?: string | undefined;
+          seconds?: string | undefined;
+          meridiem?: string | undefined;
+          empty?: string | undefined;
+          datePickerToolbarTitle?: string | undefined;
+          timePickerToolbarTitle?: string | undefined;
+          dateTimePickerToolbarTitle?: string | undefined;
+          dateRangePickerToolbarTitle?: string | undefined;
+        };
+      };
+    };
+  };
+};

package/esm/locales/bgBG.js

@@ -0,0 +1,73 @@
+import { getPickersLocalization } from "./utils/getPickersLocalization.js";
+const views = {
+  hours: 'часове',
+  minutes: 'минути',
+  seconds: 'секунди',
+  meridiem: 'преди обяд/след обяд'
+};
+const bgBGPickers = {
+  // Calendar navigation
+  previousMonth: 'Предишен месец',
+  nextMonth: 'Следващ месец',
+  // View navigation
+  openPreviousView: 'Отвори предишен изглед',
+  openNextView: 'Отвори следващ изглед',
+  calendarViewSwitchingButtonAriaLabel: view => view === 'year' ? 'отворен е изглед на година, премини на изглед на календар' : 'отворен е изглед на календар, премини на изглед на година',
+  // DateRange labels
+  start: 'Начало',
+  end: 'Край',
+  startDate: 'Начална дата',
+  startTime: 'Начален час',
+  endDate: 'Крайна дата',
+  endTime: 'Краен час',
+  // Action bar
+  cancelButtonLabel: 'Отказ',
+  clearButtonLabel: 'Изчисти',
+  okButtonLabel: 'ОК',
+  todayButtonLabel: 'Днес',
+  // Toolbar titles
+  datePickerToolbarTitle: 'Избери дата',
+  dateTimePickerToolbarTitle: 'Избери дата и час',
+  timePickerToolbarTitle: 'Избери час',
+  dateRangePickerToolbarTitle: 'Избери времеви период',
+  // Clock labels
+  clockLabelText: (view, formattedTime) => `Избери ${views[view]}. ${!formattedTime ? 'Не е избран час' : `Избраният час е ${formattedTime}`}`,
+  hoursClockNumberText: hours => `${hours} часа`,
+  minutesClockNumberText: minutes => `${minutes} минути`,
+  secondsClockNumberText: seconds => `${seconds} секунди`,
+  // Digital clock labels
+  selectViewText: view => `Избери ${views[view]}`,
+  // Calendar labels
+  calendarWeekNumberHeaderLabel: 'Седмица',
+  calendarWeekNumberHeaderText: '#',
+  calendarWeekNumberAriaLabelText: weekNumber => `Седмица ${weekNumber}`,
+  calendarWeekNumberText: weekNumber => `${weekNumber}`,
+  // Open picker labels
+  openDatePickerDialogue: formattedDate => formattedDate ? `Избери дата, избраната дата е ${formattedDate}` : 'Избери дата',
+  openTimePickerDialogue: formattedTime => formattedTime ? `Избери час, избраният час е ${formattedTime}` : 'Избери час',
+  fieldClearLabel: 'Изчисти стойност',
+  // Table labels
+  timeTableLabel: 'избери час',
+  dateTableLabel: 'избери дата',
+  // Field section placeholders
+  fieldYearPlaceholder: params => 'Г'.repeat(params.digitAmount),
+  fieldMonthPlaceholder: params => params.contentType === 'letter' ? 'ММММ' : 'ММ',
+  fieldDayPlaceholder: () => 'ДД',
+  fieldWeekDayPlaceholder: params => params.contentType === 'letter' ? 'СССС' : 'СС',
+  fieldHoursPlaceholder: () => 'чч',
+  fieldMinutesPlaceholder: () => 'мм',
+  fieldSecondsPlaceholder: () => 'сс',
+  fieldMeridiemPlaceholder: () => 'пс',
+  // View names
+  year: 'Година',
+  month: 'Месец',
+  day: 'Ден',
+  weekDay: 'Ден от седмицата',
+  hours: 'Часове',
+  minutes: 'Минути',
+  seconds: 'Секунди',
+  meridiem: 'Преди обяд/след обяд',
+  // Common
+  empty: 'Празно'
+};
+export const bgBG = getPickersLocalization(bgBGPickers);