@mui/x-date-pickers 6.0.2 → 6.0.4

package/legacy/internals/hooks/useField/useFieldState.js

@@ -2,10 +2,10 @@ import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import * as React from 'react';
-import { useTheme } from '@mui/material/styles';
 import useControlled from '@mui/utils/useControlled';
+import { useTheme } from '@mui/material/styles';
 import { useUtils, useLocaleText, useLocalizationContext } from '../useUtils';
-import { addPositionPropertiesToSections, splitFormatIntoSections, clampDaySection, mergeDateIntoReferenceDate, getSectionsBoundaries, validateSections, getDateFromDateSections } from './useField.utils';
+import { addPositionPropertiesToSections, splitFormatIntoSections, clampDaySectionIfPossible, mergeDateIntoReferenceDate, getSectionsBoundaries, validateSections, getDateFromDateSections } from './useField.utils';
 export var useFieldState = function useFieldState(params) {
   var _ref;
   var utils = useUtils();
@@ -30,19 +30,21 @@ export var useFieldState = function useFieldState(params) {
   var sectionsValueBoundaries = React.useMemo(function () {
     return getSectionsBoundaries(utils);
   }, [utils]);
-  var sectionOrder = React.useMemo(function () {
-    return fieldValueManager.getSectionOrder(utils, localeText, format, isRTL);
-  }, [fieldValueManager, format, isRTL, localeText, utils]);
+  var getSectionsFromValue = React.useCallback(function (value) {
+    var fallbackSections = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    return fieldValueManager.getSectionsFromValue(utils, value, fallbackSections, isRTL, function (date) {
+      return splitFormatIntoSections(utils, localeText, format, date);
+    });
+  }, [fieldValueManager, format, localeText, isRTL, utils]);
   var placeholder = React.useMemo(function () {
-    return fieldValueManager.getValueStrFromSections(fieldValueManager.getSectionsFromValue(utils, localeText, null, valueManager.emptyValue, format));
-  }, [fieldValueManager, format, localeText, utils, valueManager.emptyValue]);
+    return fieldValueManager.getValueStrFromSections(getSectionsFromValue(valueManager.emptyValue), isRTL);
+  }, [fieldValueManager, getSectionsFromValue, valueManager.emptyValue, isRTL]);
   var _React$useState = React.useState(function () {
-      var sections = fieldValueManager.getSectionsFromValue(utils, localeText, null, valueFromTheOutside, format);
+      var sections = getSectionsFromValue(valueFromTheOutside);
       validateSections(sections, valueType);
       return {
         sections: sections,
         value: valueFromTheOutside,
-        placeholder: placeholder,
         referenceValue: fieldValueManager.updateReferenceValue(utils, valueFromTheOutside, valueManager.getTodayValue(utils)),
         tempValueStrAndroid: null
       };
@@ -98,12 +100,11 @@ export var useFieldState = function useFieldState(params) {
   }, [selectedSections, state.sections]);
   var publishValue = function publishValue(_ref2) {
     var value = _ref2.value,
-      referenceValue = _ref2.referenceValue;
-    var sections = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : state.sections;
-    var newSections = fieldValueManager.getSectionsFromValue(utils, localeText, sections, value, format);
+      referenceValue = _ref2.referenceValue,
+      sections = _ref2.sections;
     setState(function (prevState) {
       return _extends({}, prevState, {
-        sections: newSections,
+        sections: sections,
         value: value,
         referenceValue: referenceValue,
         tempValueStrAndroid: null
@@ -128,7 +129,7 @@ export var useFieldState = function useFieldState(params) {
       value: newSectionValue,
       modified: true
     });
-    return addPositionPropertiesToSections(newSections);
+    return addPositionPropertiesToSections(newSections, isRTL);
   };
   var clearValue = function clearValue() {
     if (valueManager.areValuesEqual(utils, state.value, valueManager.emptyValue)) {
@@ -136,8 +137,9 @@ export var useFieldState = function useFieldState(params) {
     }
     publishValue({
       value: valueManager.emptyValue,
-      referenceValue: state.referenceValue
-    }, null);
+      referenceValue: state.referenceValue,
+      sections: getSectionsFromValue(valueManager.emptyValue)
+    });
   };
   var clearActiveSection = function clearActiveSection() {
     if (selectedSectionIndexes == null) {
@@ -148,19 +150,20 @@ export var useFieldState = function useFieldState(params) {
       return;
     }
     var activeDateManager = fieldValueManager.getActiveDateManager(utils, state, activeSection);
-    var activeDateSections = fieldValueManager.getActiveDateSections(state.sections, activeSection);
-    var nonEmptySectionCountBefore = activeDateSections.filter(function (section) {
+    var nonEmptySectionCountBefore = activeDateManager.getSections(state.sections).filter(function (section) {
       return section.value !== '';
     }).length;
     var isTheOnlyNonEmptySection = nonEmptySectionCountBefore === 1;
     var newSections = setSectionValue(selectedSectionIndexes.startIndex, '');
     var newActiveDate = isTheOnlyNonEmptySection ? null : utils.date(new Date(''));
-    var newValue = activeDateManager.getNewValueFromNewActiveDate(newActiveDate);
-    if ((newActiveDate != null && !utils.isValid(newActiveDate)) !== (activeDateManager.activeDate != null && !utils.isValid(activeDateManager.activeDate))) {
-      publishValue(newValue, newSections);
+    var newValues = activeDateManager.getNewValuesFromNewActiveDate(newActiveDate);
+    if ((newActiveDate != null && !utils.isValid(newActiveDate)) !== (activeDateManager.date != null && !utils.isValid(activeDateManager.date))) {
+      publishValue(_extends({}, newValues, {
+        sections: newSections
+      }));
     } else {
       setState(function (prevState) {
-        return _extends({}, prevState, newValue, {
+        return _extends({}, prevState, newValues, {
           sections: newSections,
           tempValueStrAndroid: null
         });
@@ -180,61 +183,80 @@ export var useFieldState = function useFieldState(params) {
     var newReferenceValue = fieldValueManager.updateReferenceValue(utils, newValue, state.referenceValue);
     publishValue({
       value: newValue,
-      referenceValue: newReferenceValue
+      referenceValue: newReferenceValue,
+      sections: getSectionsFromValue(newValue, state.sections)
     });
   };
   var updateSectionValue = function updateSectionValue(_ref3) {
     var activeSection = _ref3.activeSection,
       newSectionValue = _ref3.newSectionValue,
       shouldGoToNextSection = _ref3.shouldGoToNextSection;
-    var commit = function commit(_ref4) {
-      var values = _ref4.values,
-        sections = _ref4.sections,
-        shouldPublish = _ref4.shouldPublish;
-      if (shouldGoToNextSection && selectedSectionIndexes && selectedSectionIndexes.startIndex < state.sections.length - 1) {
-        setSelectedSections(selectedSectionIndexes.startIndex + 1);
-      } else if (selectedSectionIndexes && selectedSectionIndexes.startIndex !== selectedSectionIndexes.endIndex) {
-        setSelectedSections(selectedSectionIndexes.startIndex);
-      }
-      if (shouldPublish) {
-        publishValue(values, sections);
-      } else {
-        setState(function (prevState) {
-          return _extends({}, prevState, values, {
-            sections: sections != null ? sections : state.sections,
-            tempValueStrAndroid: null
-          });
-        });
-      }
-    };
+    /**
+     * 1. Decide which section should be focused
+     */
+    if (shouldGoToNextSection && selectedSectionIndexes && selectedSectionIndexes.startIndex < state.sections.length - 1) {
+      setSelectedSections(selectedSectionIndexes.startIndex + 1);
+    } else if (selectedSectionIndexes && selectedSectionIndexes.startIndex !== selectedSectionIndexes.endIndex) {
+      setSelectedSections(selectedSectionIndexes.startIndex);
+    }
+
+    /**
+     * 2. Try to build a valid date from the new section value
+     */
     var activeDateManager = fieldValueManager.getActiveDateManager(utils, state, activeSection);
     var newSections = setSectionValue(selectedSectionIndexes.startIndex, newSectionValue);
-    var activeDateSections = fieldValueManager.getActiveDateSections(newSections, activeSection);
-    var newActiveDate = getDateFromDateSections(utils, activeDateSections);
+    var newActiveDateSections = activeDateManager.getSections(newSections);
+    var newActiveDate = getDateFromDateSections(utils, newActiveDateSections);
+    var shouldRegenSections = false;
 
-    // When all the sections are filled but the date is invalid, it can be because the month has fewer days than asked.
-    // We can try to set the day to the maximum boundary.
-    if (!utils.isValid(newActiveDate) && activeDateSections.every(function (section) {
-      return section.type === 'weekDay' || section.value !== '';
-    }) && activeDateSections.some(function (section) {
-      return section.type === 'day';
-    })) {
-      var cleanSections = clampDaySection(utils, activeDateSections, sectionsValueBoundaries);
-      if (cleanSections != null) {
-        newActiveDate = getDateFromDateSections(utils, cleanSections);
+    /**
+     * If the date is invalid,
+     * Then we can try to clamp the day section to see if that produces a valid date.
+     * This can be useful if the month has fewer days than the day value currently provided.
+     */
+    if (!utils.isValid(newActiveDate)) {
+      var clampedSections = clampDaySectionIfPossible(utils, newActiveDateSections, sectionsValueBoundaries);
+      if (clampedSections != null) {
+        shouldRegenSections = true;
+        newActiveDate = getDateFromDateSections(utils, clampedSections);
       }
     }
+    var values;
+    var shouldPublish;
+
+    /**
+     * If the new date is valid,
+     * Then we merge the value of the modified sections into the reference date.
+     * This makes sure that we don't lose some information of the initial date (like the time on a date field).
+     */
     if (newActiveDate != null && utils.isValid(newActiveDate)) {
-      var mergedDate = mergeDateIntoReferenceDate(utils, newActiveDate, activeDateSections, activeDateManager.referenceActiveDate, true);
-      return commit({
-        values: activeDateManager.getNewValueFromNewActiveDate(mergedDate),
-        shouldPublish: true
-      });
+      var mergedDate = mergeDateIntoReferenceDate(utils, newActiveDate, newActiveDateSections, activeDateManager.referenceDate, true);
+      values = activeDateManager.getNewValuesFromNewActiveDate(mergedDate);
+      shouldPublish = true;
+    } else {
+      values = activeDateManager.getNewValuesFromNewActiveDate(newActiveDate);
+      shouldPublish = (newActiveDate != null && !utils.isValid(newActiveDate)) !== (activeDateManager.date != null && !utils.isValid(activeDateManager.date));
+    }
+
+    /**
+     * If the value has been modified (to clamp the day).
+     * Then we need to re-generate the sections to make sure they also have this change.
+     */
+    var sections = shouldRegenSections ? getSectionsFromValue(values.value, state.sections) : newSections;
+
+    /**
+     * Publish or update the internal state with the new value and sections.
+     */
+    if (shouldPublish) {
+      return publishValue(_extends({}, values, {
+        sections: sections
+      }));
     }
-    return commit({
-      values: activeDateManager.getNewValueFromNewActiveDate(newActiveDate),
-      sections: newSections,
-      shouldPublish: (newActiveDate != null && !utils.isValid(newActiveDate)) !== (activeDateManager.activeDate != null && !utils.isValid(activeDateManager.activeDate))
+    return setState(function (prevState) {
+      return _extends({}, prevState, values, {
+        sections: sections,
+        tempValueStrAndroid: null
+      });
     });
   };
   var setTempAndroidValueStr = function setTempAndroidValueStr(tempValueStrAndroid) {
@@ -246,27 +268,25 @@ export var useFieldState = function useFieldState(params) {
   };
   React.useEffect(function () {
     if (!valueManager.areValuesEqual(utils, state.value, valueFromTheOutside)) {
-      var sections = fieldValueManager.getSectionsFromValue(utils, localeText, state.sections, valueFromTheOutside, format);
       setState(function (prevState) {
         return _extends({}, prevState, {
           value: valueFromTheOutside,
           referenceValue: fieldValueManager.updateReferenceValue(utils, valueFromTheOutside, prevState.referenceValue),
-          sections: sections
+          sections: getSectionsFromValue(valueFromTheOutside)
         });
       });
     }
   }, [valueFromTheOutside]); // eslint-disable-line react-hooks/exhaustive-deps
 
   React.useEffect(function () {
-    var sections = fieldValueManager.getSectionsFromValue(utils, localeText, null, state.value, format);
+    var sections = getSectionsFromValue(state.value);
     validateSections(sections, valueType);
     setState(function (prevState) {
       return _extends({}, prevState, {
-        sections: sections,
-        placeholder: placeholder
+        sections: sections
       });
     });
-  }, [format, utils.locale, placeholder]); // eslint-disable-line react-hooks/exhaustive-deps
+  }, [format, utils.locale]); // eslint-disable-line react-hooks/exhaustive-deps
 
   return {
     state: state,
@@ -277,7 +297,7 @@ export var useFieldState = function useFieldState(params) {
     updateSectionValue: updateSectionValue,
     updateValueFromValueStr: updateValueFromValueStr,
     setTempAndroidValueStr: setTempAndroidValueStr,
-    sectionOrder: sectionOrder,
-    sectionsValueBoundaries: sectionsValueBoundaries
+    sectionsValueBoundaries: sectionsValueBoundaries,
+    placeholder: placeholder
   };
 };

package/legacy/internals/hooks/usePicker/usePickerValue.js

@@ -31,11 +31,8 @@ export var usePickerValue = function usePickerValue(_ref) {
       state: 'value'
     }),
     _useControlled2 = _slicedToArray(_useControlled, 2),
-    rawValue = _useControlled2[0],
+    value = _useControlled2[0],
     setValue = _useControlled2[1];
-  var value = React.useMemo(function () {
-    return valueManager.cleanValue(utils, rawValue);
-  }, [valueManager, utils, rawValue]);
   var _useControlled3 = useControlled({
       controlled: selectedSectionsProp,
       default: null,
@@ -92,7 +89,7 @@ export var usePickerValue = function usePickerValue(_ref) {
           }
       }
     });
-    if (params.forceOnChangeCall || !params.skipOnChangeCall && !valueManager.areValuesEqual(utils, dateState.committed, params.value)) {
+    if (!params.skipOnChangeCall && !valueManager.areValuesEqual(utils, dateState.committed, params.value)) {
       setValue(params.value);
       if (onChange) {
         var _context = {
@@ -137,18 +134,14 @@ export var usePickerValue = function usePickerValue(_ref) {
     // Reset all date in state to the empty value and close picker.
     setDate({
       value: valueManager.emptyValue,
-      action: 'acceptAndClose',
-      // force `onChange` in cases like input (value) === `Invalid date`
-      forceOnChangeCall: !valueManager.areValuesEqual(utils, value, valueManager.emptyValue)
+      action: 'acceptAndClose'
     });
   });
   var handleAccept = useEventCallback(function () {
     // Set all date in state to equal the current draft value and close picker.
     setDate({
       value: dateState.draft,
-      action: 'acceptAndClose',
-      // force `onChange` in cases like input (value) === `Invalid date`
-      forceOnChangeCall: !valueManager.areValuesEqual(utils, dateState.committed, dateState.draft)
+      action: 'acceptAndClose'
     });
   });
   var handleDismiss = useEventCallback(function () {
@@ -248,8 +241,11 @@ export var usePickerValue = function usePickerValue(_ref) {
     selectedSections: selectedSections,
     onSelectedSectionsChange: handleFieldSelectedSectionsChange
   };
+  var viewValue = React.useMemo(function () {
+    return valueManager.cleanValue(utils, dateState.draft);
+  }, [utils, valueManager, dateState.draft]);
   var viewResponse = {
-    value: dateState.draft,
+    value: viewValue,
     onChange: handleChange,
     onClose: handleClose,
     open: isOpen,
@@ -268,7 +264,7 @@ export var usePickerValue = function usePickerValue(_ref) {
     }) : validationResponse === null;
   };
   var layoutResponse = _extends({}, actions, {
-    value: dateState.draft,
+    value: viewValue,
     onChange: handleChangeAndCommit,
     isValid: isValid
   });

package/legacy/internals/hooks/useViews.js

@@ -25,6 +25,8 @@ export function useViews(_ref) {
       }
     }
   }
+  var previousOpenTo = React.useRef(openTo);
+  var previousViews = React.useRef(views);
   var defaultView = React.useRef(views.includes(openTo) ? openTo : views[0]);
   var _useControlled = useControlled({
       name: 'useViews',
@@ -45,6 +47,14 @@ export function useViews(_ref) {
     _useControlled4 = _slicedToArray(_useControlled3, 2),
     focusedView = _useControlled4[0],
     setFocusedView = _useControlled4[1];
+  React.useEffect(function () {
+    // Update the current view when `openTo` or `views` props change
+    if (previousOpenTo.current && previousOpenTo.current !== openTo || previousViews.current && previousViews.current.some(function (previousView) {
+      return !views.includes(previousView);
+    })) {
+      setView(views.includes(openTo) ? openTo : views[0]);
+    }
+  }, [openTo, setView, view, views]);
   var viewIndex = views.indexOf(view);
   var previousView = (_views = views[viewIndex - 1]) != null ? _views : null;
   var nextView = (_views2 = views[viewIndex + 1]) != null ? _views2 : null;

package/legacy/internals/index.js

@@ -9,7 +9,7 @@ export { pickersArrowSwitcherClasses } from './components/PickersArrowSwitcher/p
 export { pickersPopperClasses } from './components/pickersPopperClasses';
 export { PickersToolbarButton } from './components/PickersToolbarButton';
 export { DAY_MARGIN, DIALOG_WIDTH } from './constants/dimensions';
-export { useField, createDateStrForInputFromSections, addPositionPropertiesToSections, splitFormatIntoSections, getSectionOrder } from './hooks/useField';
+export { useField, createDateStrForInputFromSections, addPositionPropertiesToSections } from './hooks/useField';
 export { usePicker } from './hooks/usePicker';
 export { useStaticPicker } from './hooks/useStaticPicker';
 export { useLocalizationContext, useDefaultDates, useUtils, useLocaleText, useNow } from './hooks/useUtils';
@@ -18,7 +18,7 @@ export { validateDate } from './hooks/validation/useDateValidation';
 export { validateTime } from './hooks/validation/useTimeValidation';
 export { validateDateTime } from './hooks/validation/useDateTimeValidation';
 export { usePreviousMonthDisabled, useNextMonthDisabled } from './hooks/date-helpers-hooks';
-export { applyDefaultDate, replaceInvalidDateByNull } from './utils/date-utils';
+export { applyDefaultDate, replaceInvalidDateByNull, areDatesEqual } from './utils/date-utils';
 export { executeInTheNextEventLoopTick, getActiveElement, onSpaceOrEnter, DEFAULT_DESKTOP_MODE_MEDIA_QUERY } from './utils/utils';
 export { defaultReduceAnimations } from './utils/defaultReduceAnimations';
 export { extractValidationProps } from './utils/validation';

package/legacy/internals/models/index.js

@@ -1,3 +1,2 @@
-export * from './views';
 export * from './fields';
 export * from './muiPickersAdapter';

package/legacy/internals/utils/date-utils.js

@@ -64,4 +64,10 @@ export var applyDefaultDate = function applyDefaultDate(utils, value, defaultVal
     return defaultValue;
   }
   return value;
+};
+export var areDatesEqual = function areDatesEqual(utils, a, b) {
+  if (!utils.isValid(a) && a != null && !utils.isValid(b) && b != null) {
+    return true;
+  }
+  return utils.isEqual(a, b);
 };

package/legacy/internals/utils/utils.js

@@ -7,7 +7,7 @@ export function arrayIncludes(array, itemOrItems) {
   }
   return array.indexOf(itemOrItems) !== -1;
 }
-export var onSpaceOrEnter = function onSpaceOrEnter(innerFn, onFocus) {
+export var onSpaceOrEnter = function onSpaceOrEnter(innerFn, externalEvent) {
   return function (event) {
     if (event.key === 'Enter' || event.key === ' ') {
       innerFn(event);
@@ -16,8 +16,8 @@ export var onSpaceOrEnter = function onSpaceOrEnter(innerFn, onFocus) {
       event.preventDefault();
       event.stopPropagation();
     }
-    if (onFocus) {
-      onFocus(event);
+    if (externalEvent) {
+      externalEvent(event);
     }
   };
 };

package/legacy/internals/utils/valueManagers.js

@@ -1,14 +1,12 @@
-import { replaceInvalidDateByNull } from './date-utils';
-import { addPositionPropertiesToSections, createDateStrForInputFromSections, splitFormatIntoSections, getSectionOrder as _getSectionOrder } from '../hooks/useField/useField.utils';
+import { areDatesEqual, replaceInvalidDateByNull } from './date-utils';
+import { addPositionPropertiesToSections, createDateStrForInputFromSections } from '../hooks/useField/useField.utils';
 export var singleItemValueManager = {
   emptyValue: null,
   getTodayValue: function getTodayValue(utils) {
     return utils.date();
   },
   cleanValue: replaceInvalidDateByNull,
-  areValuesEqual: function areValuesEqual(utils, a, b) {
-    return utils.isEqual(a, b);
-  },
+  areValuesEqual: areDatesEqual,
   isSameError: function isSameError(a, b) {
     return a === b;
   },
@@ -18,24 +16,22 @@ export var singleItemFieldValueManager = {
   updateReferenceValue: function updateReferenceValue(utils, value, prevReferenceValue) {
     return value == null || !utils.isValid(value) ? prevReferenceValue : value;
   },
-  getSectionsFromValue: function getSectionsFromValue(utils, localeText, prevSections, date, format) {
+  getSectionsFromValue: function getSectionsFromValue(utils, date, prevSections, isRTL, getSectionsFromDate) {
     var shouldReUsePrevDateSections = !utils.isValid(date) && !!prevSections;
     if (shouldReUsePrevDateSections) {
       return prevSections;
     }
-    return addPositionPropertiesToSections(splitFormatIntoSections(utils, localeText, format, date));
-  },
-  getValueStrFromSections: function getValueStrFromSections(sections) {
-    return createDateStrForInputFromSections(sections);
-  },
-  getActiveDateSections: function getActiveDateSections(sections) {
-    return sections;
+    return addPositionPropertiesToSections(getSectionsFromDate(date), isRTL);
   },
+  getValueStrFromSections: createDateStrForInputFromSections,
   getActiveDateManager: function getActiveDateManager(utils, state) {
     return {
-      activeDate: state.value,
-      referenceActiveDate: state.referenceValue,
-      getNewValueFromNewActiveDate: function getNewValueFromNewActiveDate(newActiveDate) {
+      date: state.value,
+      referenceDate: state.referenceValue,
+      getSections: function getSections(sections) {
+        return sections;
+      },
+      getNewValuesFromNewActiveDate: function getNewValuesFromNewActiveDate(newActiveDate) {
         return {
           value: newActiveDate,
           referenceValue: newActiveDate == null || !utils.isValid(newActiveDate) ? state.referenceValue : newActiveDate
@@ -48,8 +44,5 @@ export var singleItemFieldValueManager = {
   },
   hasError: function hasError(error) {
     return error != null;
-  },
-  getSectionOrder: function getSectionOrder(utils, localeText, format, isRTL) {
-    return _getSectionOrder(splitFormatIntoSections(utils, localeText, format, null), isRTL);
   }
 };

package/legacy/locales/daDK.js

@@ -0,0 +1,91 @@
+import { getPickersLocalization } from './utils/getPickersLocalization';
+
+// maps TimeView to its translation
+var timeViews = {
+  hours: 'Timer',
+  minutes: 'Minutter',
+  seconds: 'Sekunder'
+};
+var daDKPickers = {
+  // Calendar navigation
+  previousMonth: 'Forrige måned',
+  nextMonth: 'Næste måned',
+  // View navigation
+  openPreviousView: 'åben forrige visning',
+  openNextView: 'åben næste visning',
+  calendarViewSwitchingButtonAriaLabel: function calendarViewSwitchingButtonAriaLabel(view) {
+    return view === 'year' ? 'årsvisning er åben, skift til kalendervisning' : 'kalendervisning er åben, skift til årsvisning';
+  },
+  // DateRange placeholders
+  start: 'Start',
+  end: 'Slut',
+  // Action bar
+  cancelButtonLabel: 'Annuller',
+  clearButtonLabel: 'Ryd',
+  okButtonLabel: 'OK',
+  todayButtonLabel: 'I dag',
+  // Toolbar titles
+  datePickerToolbarTitle: 'Vælg dato',
+  dateTimePickerToolbarTitle: 'Vælg dato & tidspunkt',
+  timePickerToolbarTitle: 'Vælg tidspunkt',
+  dateRangePickerToolbarTitle: 'Vælg datointerval',
+  // Clock labels
+  clockLabelText: function clockLabelText(view, time, adapter) {
+    var _timeViews$view;
+    return "V\xE6lg ".concat((_timeViews$view = timeViews[view]) != null ? _timeViews$view : view, ". ").concat(time === null ? 'Intet tidspunkt valgt' : "Valgte tidspunkt er ".concat(adapter.format(time, 'fullTime')));
+  },
+  hoursClockNumberText: function hoursClockNumberText(hours) {
+    return "".concat(hours, " timer");
+  },
+  minutesClockNumberText: function minutesClockNumberText(minutes) {
+    return "".concat(minutes, " minutter");
+  },
+  secondsClockNumberText: function secondsClockNumberText(seconds) {
+    return "".concat(seconds, " sekunder");
+  },
+  // Calendar labels
+  calendarWeekNumberHeaderLabel: 'Ugenummer',
+  calendarWeekNumberHeaderText: '#',
+  calendarWeekNumberAriaLabelText: function calendarWeekNumberAriaLabelText(weekNumber) {
+    return "Uge ".concat(weekNumber);
+  },
+  calendarWeekNumberText: function calendarWeekNumberText(weekNumber) {
+    return "".concat(weekNumber);
+  },
+  // Open picker labels
+  openDatePickerDialogue: function openDatePickerDialogue(value, utils) {
+    return value !== null && utils.isValid(value) ? "V\xE6lg dato, valgte dato er ".concat(utils.format(value, 'fullDate')) : 'Vælg dato';
+  },
+  openTimePickerDialogue: function openTimePickerDialogue(value, utils) {
+    return value !== null && utils.isValid(value) ? "V\xE6lg tidspunkt, valgte tidspunkt er ".concat(utils.format(value, 'fullTime')) : 'Vælg tidspunkt';
+  },
+  // Table labels
+  timeTableLabel: 'vælg tidspunkt',
+  dateTableLabel: 'vælg dato',
+  // Field section placeholders
+  fieldYearPlaceholder: function fieldYearPlaceholder(params) {
+    return 'Y'.repeat(params.digitAmount);
+  },
+  fieldMonthPlaceholder: function fieldMonthPlaceholder(params) {
+    return params.contentType === 'letter' ? 'MMMM' : 'MM';
+  },
+  fieldDayPlaceholder: function fieldDayPlaceholder() {
+    return 'DD';
+  },
+  fieldWeekDayPlaceholder: function fieldWeekDayPlaceholder(params) {
+    return params.contentType === 'letter' ? 'EEEE' : 'EE';
+  },
+  fieldHoursPlaceholder: function fieldHoursPlaceholder() {
+    return 'hh';
+  },
+  fieldMinutesPlaceholder: function fieldMinutesPlaceholder() {
+    return 'mm';
+  },
+  fieldSecondsPlaceholder: function fieldSecondsPlaceholder() {
+    return 'ss';
+  },
+  fieldMeridiemPlaceholder: function fieldMeridiemPlaceholder() {
+    return 'aa';
+  }
+};
+export var daDK = getPickersLocalization(daDKPickers);

package/legacy/locales/faIR.js

@@ -36,11 +36,14 @@ var faIRPickers = {
     return "".concat(seconds, " \u062B\u0627\u0646\u06CC\u0647 \u0647\u0627");
   },
   // Calendar labels
-  // calendarWeekNumberHeaderLabel: 'Week number',
-  // calendarWeekNumberHeaderText: '#',
-  // calendarWeekNumberAriaLabelText: weekNumber => `Week ${weekNumber}`,
-  // calendarWeekNumberText: weekNumber => `${weekNumber}`,
-
+  calendarWeekNumberHeaderLabel: 'عدد هفته',
+  calendarWeekNumberHeaderText: '#',
+  calendarWeekNumberAriaLabelText: function calendarWeekNumberAriaLabelText(weekNumber) {
+    return "\u0647\u0641\u062A\u0647 ".concat(weekNumber);
+  },
+  calendarWeekNumberText: function calendarWeekNumberText(weekNumber) {
+    return "".concat(weekNumber);
+  },
   // Open picker labels
   openDatePickerDialogue: function openDatePickerDialogue(value, utils) {
     return value !== null && utils.isValid(value) ? "\u062A\u0627\u0631\u06CC\u062E \u0631\u0627 \u0627\u0646\u062A\u062E\u0627\u0628 \u06A9\u0646\u06CC\u062F\u060C \u062A\u0627\u0631\u06CC\u062E \u0627\u0646\u062A\u062E\u0627\u0628 \u0634\u062F\u0647 ".concat(utils.format(value, 'fullDate'), " \u0645\u06CC \u0628\u0627\u0634\u062F") : 'تاریخ را انتخاب کنید';
@@ -50,17 +53,31 @@ var faIRPickers = {
   },
   // Table labels
   timeTableLabel: 'انتخاب تاریخ',
-  dateTableLabel: 'انتخاب ساعت'
-
+  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',
+  fieldYearPlaceholder: function fieldYearPlaceholder(params) {
+    return 'Y'.repeat(params.digitAmount);
+  },
+  fieldMonthPlaceholder: function fieldMonthPlaceholder(params) {
+    return params.contentType === 'letter' ? 'MMMM' : 'MM';
+  },
+  fieldDayPlaceholder: function fieldDayPlaceholder() {
+    return 'DD';
+  },
+  fieldWeekDayPlaceholder: function fieldWeekDayPlaceholder(params) {
+    return params.contentType === 'letter' ? 'EEEE' : 'EE';
+  },
+  fieldHoursPlaceholder: function fieldHoursPlaceholder() {
+    return 'hh';
+  },
+  fieldMinutesPlaceholder: function fieldMinutesPlaceholder() {
+    return 'mm';
+  },
+  fieldSecondsPlaceholder: function fieldSecondsPlaceholder() {
+    return 'ss';
+  },
+  fieldMeridiemPlaceholder: function fieldMeridiemPlaceholder() {
+    return 'aa';
+  }
 };
-
 export var faIR = getPickersLocalization(faIRPickers);