@mui/x-date-pickers 6.7.0 → 6.9.0

package/modern/internals/hooks/useValueWithTimezone.js

@@ -0,0 +1,68 @@
+import * as React from 'react';
+import useEventCallback from '@mui/utils/useEventCallback';
+import useControlled from '@mui/utils/useControlled';
+import { useUtils } from './useUtils';
+/**
+ * Hooks making sure that:
+ * - The value returned by `onChange` always have the timezone of `props.value` or `props.defaultValue` if defined
+ * - The value rendered is always the one from `props.timezone` if defined
+ */
+export const useValueWithTimezone = ({
+  timezone: timezoneProp,
+  value: valueProp,
+  defaultValue,
+  onChange,
+  valueManager
+}) => {
+  const utils = useUtils();
+  const firstDefaultValue = React.useRef(defaultValue);
+  const inputValue = valueProp ?? firstDefaultValue.current ?? valueManager.emptyValue;
+  const inputTimezone = React.useMemo(() => valueManager.getTimezone(utils, inputValue), [utils, valueManager, inputValue]);
+  const setInputTimezone = useEventCallback(newValue => {
+    if (inputTimezone == null) {
+      return newValue;
+    }
+    return valueManager.setTimezone(utils, inputTimezone, newValue);
+  });
+  const timezoneToRender = timezoneProp ?? inputTimezone ?? 'default';
+  const valueWithTimezoneToRender = React.useMemo(() => valueManager.setTimezone(utils, timezoneToRender, inputValue), [valueManager, utils, timezoneToRender, inputValue]);
+  const handleValueChange = useEventCallback((newValue, ...otherParams) => {
+    const newValueWithInputTimezone = setInputTimezone(newValue);
+    onChange?.(newValueWithInputTimezone, ...otherParams);
+  });
+  return {
+    value: valueWithTimezoneToRender,
+    handleValueChange,
+    timezone: timezoneToRender
+  };
+};
+
+/**
+ * Wrapper around `useControlled` and `useValueWithTimezone`
+ */
+export const useControlledValueWithTimezone = ({
+  name,
+  timezone: timezoneProp,
+  value: valueProp,
+  defaultValue,
+  onChange: onChangeProp,
+  valueManager
+}) => {
+  const [valueWithInputTimezone, setValue] = useControlled({
+    name,
+    state: 'value',
+    controlled: valueProp,
+    default: defaultValue ?? valueManager.emptyValue
+  });
+  const onChange = useEventCallback((newValue, ...otherParams) => {
+    setValue(newValue);
+    onChangeProp?.(newValue, ...otherParams);
+  });
+  return useValueWithTimezone({
+    timezone: timezoneProp,
+    value: valueWithInputTimezone,
+    defaultValue: undefined,
+    onChange,
+    valueManager
+  });
+};

package/modern/internals/index.js

@@ -9,6 +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 { useControlledValueWithTimezone } from './hooks/useValueWithTimezone';
 export { useField, createDateStrForInputFromSections, addPositionPropertiesToSections } from './hooks/useField';
 export { usePicker } from './hooks/usePicker';
 export { useStaticPicker } from './hooks/useStaticPicker';

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

@@ -6,9 +6,10 @@ export const findClosestEnabledDate = ({
   maxDate,
   minDate,
   isDateDisabled,
-  utils
+  utils,
+  timezone
 }) => {
-  const today = utils.startOfDay(utils.date());
+  const today = utils.startOfDay(utils.dateWithTimezone(undefined, timezone));
   if (disablePast && utils.isBefore(minDate, today)) {
     minDate = today;
   }
@@ -49,15 +50,6 @@ export const findClosestEnabledDate = ({
   }
   return null;
 };
-export const clamp = (utils, value, minDate, maxDate) => {
-  if (utils.isBefore(value, minDate)) {
-    return minDate;
-  }
-  if (utils.isAfter(value, maxDate)) {
-    return maxDate;
-  }
-  return value;
-};
 export const replaceInvalidDateByNull = (utils, value) => value == null || !utils.isValid(value) ? null : value;
 export const applyDefaultDate = (utils, value, defaultValue) => {
   if (value == null || !utils.isValid(value)) {
@@ -87,7 +79,7 @@ export const mergeDateAndTime = (utils, dateParam, timeParam) => {
   mergedDate = utils.setSeconds(mergedDate, utils.getSeconds(timeParam));
   return mergedDate;
 };
-export const getTodayDate = (utils, valueType) => valueType === 'date' ? utils.startOfDay(utils.date()) : utils.date();
+export const getTodayDate = (utils, timezone, valueType) => valueType === 'date' ? utils.startOfDay(utils.dateWithTimezone(undefined, timezone)) : utils.dateWithTimezone(undefined, timezone);
 const dateViews = ['year', 'month', 'day'];
 export const isDatePickerView = view => dateViews.includes(view);
 export const resolveDateFormat = (utils, {

package/modern/internals/utils/fields.js

@@ -1,6 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import { DATE_TIME_VALIDATION_PROP_NAMES, DATE_VALIDATION_PROP_NAMES, TIME_VALIDATION_PROP_NAMES } from './validation/extractValidationProps';
-const SHARED_FIELD_INTERNAL_PROP_NAMES = ['value', 'defaultValue', 'referenceDate', 'format', 'formatDensity', 'onChange', 'readOnly', 'onError', 'shouldRespectLeadingZeros', 'selectedSections', 'onSelectedSectionsChange', 'unstableFieldRef'];
+const SHARED_FIELD_INTERNAL_PROP_NAMES = ['value', 'defaultValue', 'referenceDate', 'format', 'formatDensity', 'onChange', 'timezone', 'readOnly', 'onError', 'shouldRespectLeadingZeros', 'selectedSections', 'onSelectedSectionsChange', 'unstableFieldRef'];
 export const splitFieldInternalAndForwardedProps = (props, valueType) => {
   const forwardedProps = _extends({}, props);
   const internalProps = {};

package/modern/internals/utils/getDefaultReferenceDate.js

@@ -1,6 +1,6 @@
 import { createIsAfterIgnoreDatePart } from './time-utils';
 import { mergeDateAndTime, getTodayDate } from './date-utils';
-const SECTION_TYPE_GRANULARITY = {
+export const SECTION_TYPE_GRANULARITY = {
   year: 1,
   month: 2,
   day: 3,
@@ -37,10 +37,10 @@ const roundDate = (utils, granularity, date) => {
 export const getDefaultReferenceDate = ({
   props,
   utils,
-  valueType,
-  granularity
+  granularity,
+  timezone
 }) => {
-  let referenceDate = roundDate(utils, granularity, getTodayDate(utils, valueType));
+  let referenceDate = roundDate(utils, granularity, getTodayDate(utils, timezone));
   if (props.minDate != null && utils.isAfterDay(props.minDate, referenceDate)) {
     referenceDate = roundDate(utils, granularity, props.minDate);
   }

package/modern/internals/utils/validation/validateDate.js

@@ -7,21 +7,29 @@ export const validateDate = ({
   if (value === null) {
     return null;
   }
-  const now = adapter.utils.date();
+  const {
+    shouldDisableDate,
+    shouldDisableMonth,
+    shouldDisableYear,
+    disablePast,
+    disableFuture,
+    timezone
+  } = props;
+  const now = adapter.utils.dateWithTimezone(undefined, timezone);
   const minDate = applyDefaultDate(adapter.utils, props.minDate, adapter.defaultDates.minDate);
   const maxDate = applyDefaultDate(adapter.utils, props.maxDate, adapter.defaultDates.maxDate);
   switch (true) {
     case !adapter.utils.isValid(value):
       return 'invalidDate';
-    case Boolean(props.shouldDisableDate && props.shouldDisableDate(value)):
+    case Boolean(shouldDisableDate && shouldDisableDate(value)):
       return 'shouldDisableDate';
-    case Boolean(props.shouldDisableMonth && props.shouldDisableMonth(value)):
+    case Boolean(shouldDisableMonth && shouldDisableMonth(value)):
       return 'shouldDisableMonth';
-    case Boolean(props.shouldDisableYear && props.shouldDisableYear(value)):
+    case Boolean(shouldDisableYear && shouldDisableYear(value)):
       return 'shouldDisableYear';
-    case Boolean(props.disableFuture && adapter.utils.isAfterDay(value, now)):
+    case Boolean(disableFuture && adapter.utils.isAfterDay(value, now)):
       return 'disableFuture';
-    case Boolean(props.disablePast && adapter.utils.isBeforeDay(value, now)):
+    case Boolean(disablePast && adapter.utils.isBeforeDay(value, now)):
       return 'disablePast';
     case Boolean(minDate && adapter.utils.isBeforeDay(value, minDate)):
       return 'minDate';

package/modern/internals/utils/validation/validateTime.js

@@ -4,6 +4,9 @@ export const validateTime = ({
   value,
   props
 }) => {
+  if (value === null) {
+    return null;
+  }
   const {
     minTime,
     maxTime,
@@ -12,14 +15,11 @@ export const validateTime = ({
     shouldDisableTime,
     disableIgnoringDatePartForTimeValidation = false,
     disablePast,
-    disableFuture
+    disableFuture,
+    timezone
   } = props;
-  const now = adapter.utils.date();
-  const date = adapter.utils.date(value);
+  const now = adapter.utils.dateWithTimezone(undefined, timezone);
   const isAfter = createIsAfterIgnoreDatePart(disableIgnoringDatePartForTimeValidation, adapter.utils);
-  if (value === null) {
-    return null;
-  }
   switch (true) {
     case !adapter.utils.isValid(value):
       return 'invalidDate';
@@ -27,9 +27,9 @@ export const validateTime = ({
       return 'minTime';
     case Boolean(maxTime && isAfter(value, maxTime)):
       return 'maxTime';
-    case Boolean(disableFuture && adapter.utils.isAfter(date, now)):
+    case Boolean(disableFuture && adapter.utils.isAfter(value, now)):
       return 'disableFuture';
-    case Boolean(disablePast && adapter.utils.isBefore(date, now)):
+    case Boolean(disablePast && adapter.utils.isBefore(value, now)):
       return 'disablePast';
     case Boolean(shouldDisableTime && shouldDisableTime(value, 'hours')):
       return 'shouldDisableTime-hours';

package/modern/internals/utils/valueManagers.js

@@ -25,7 +25,8 @@ export const singleItemValueManager = {
   isSameError: (a, b) => a === b,
   hasError: error => error != null,
   defaultErrorState: null,
-  getTimezone: (utils, value) => value == null ? null : utils.getTimezone(value)
+  getTimezone: (utils, value) => value == null ? null : utils.getTimezone(value),
+  setTimezone: (utils, timezone, value) => value == null ? null : utils.setTimezone(value, timezone)
 };
 export const singleItemFieldValueManager = {
   updateReferenceValue: (utils, value, prevReferenceValue) => value == null || !utils.isValid(value) ? prevReferenceValue : value,

package/modern/locales/csCZ.js

@@ -8,8 +8,8 @@ const timeViews = {
 };
 const csCZPickers = {
   // Calendar navigation
-  previousMonth: 'Další měsíc',
-  nextMonth: 'Předchozí měsíc',
+  previousMonth: 'Předchozí měsíc',
+  nextMonth: 'Další měsíc',
   // View navigation
   openPreviousView: 'otevřít předchozí zobrazení',
   openNextView: 'otevřít další zobrazení',

package/modern/locales/elGR.js

@@ -0,0 +1,57 @@
+import { getPickersLocalization } from './utils/getPickersLocalization';
+const views = {
+  hours: 'ώρες',
+  minutes: 'λεπτά',
+  seconds: 'δευτερόλεπτα',
+  meridiem: 'μεσημβρία'
+};
+const elGRPickers = {
+  // Calendar navigation
+  previousMonth: 'Προηγούμενος μήνας',
+  nextMonth: 'Επόμενος μήνας',
+  // View navigation
+  openPreviousView: 'ανοίγμα προηγούμενης προβολή',
+  openNextView: 'ανοίγμα επόμενης προβολή',
+  calendarViewSwitchingButtonAriaLabel: view => view === 'year' ? 'η προβολή έτους είναι ανοιχτή, μεταβείτε στην προβολή ημερολογίου' : 'η προβολή ημερολογίου είναι ανοιχτή, μεταβείτε στην προβολή έτους',
+  // DateRange placeholders
+  start: 'Αρχή',
+  end: 'Τέλος',
+  // Action bar
+  cancelButtonLabel: 'Άκυρο',
+  clearButtonLabel: 'Καθαρισμός',
+  okButtonLabel: 'OK',
+  todayButtonLabel: 'Σήμερα',
+  // Toolbar titles
+  datePickerToolbarTitle: 'Επιλέξτε ημερομηνία',
+  dateTimePickerToolbarTitle: 'Επιλέξτε ημερομηνία και ώρα',
+  timePickerToolbarTitle: 'Επιλέξτε ώρα',
+  dateRangePickerToolbarTitle: 'Επιλέξτε εύρος ημερομηνιών',
+  // Clock labels
+  clockLabelText: (view, time, adapter) => `Επιλέξτε ${views[view]}. ${time === null ? 'Δεν έχει επιλεγεί ώρα' : `Η επιλεγμένη ώρα είναι ${adapter.format(time, 'fullTime')}`}`,
+  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: (value, utils) => value !== null && utils.isValid(value) ? `Επιλέξτε ημερομηνία, η επιλεγμένη ημερομηνία είναι ${utils.format(value, 'fullDate')}` : 'Επιλέξτε ημερομηνία',
+  openTimePickerDialogue: (value, utils) => value !== null && utils.isValid(value) ? `Επιλέξτε ώρα, η επιλεγμένη ώρα είναι ${utils.format(value, 'fullTime')}` : 'Επιλέξτε ώρα',
+  // 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'
+};
+export const elGR = getPickersLocalization(elGRPickers);

package/modern/locales/index.js

@@ -2,6 +2,7 @@ export * from './beBY';
 export * from './caES';
 export * from './csCZ';
 export * from './deDE';
+export * from './elGR';
 export * from './enUS';
 export * from './esES';
 export * from './faIR';

package/modern/tests/describeAdapters/describeAdapters.js

@@ -1,5 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import moment from 'moment';
+import momentTZ from 'moment-timezone';
 import createDescribe from '@mui/monorepo/test/utils/createDescribe';
 import { buildFieldInteractions, createPickerRenderer } from 'test/utils/pickers-utils';
 const ADAPTERS = ['dayjs', 'date-fns', 'luxon', 'moment'];
@@ -13,7 +14,8 @@ function innerDescribeAdapters(title, FieldComponent, testRunner) {
       const pickerRendererResponse = createPickerRenderer({
         adapterName,
         clock: 'fake',
-        clockConfig: new Date(2022, 5, 15)
+        clockConfig: new Date(2022, 5, 15),
+        instance: adapterName === 'moment' ? momentTZ : undefined
       });
       const fieldInteractions = buildFieldInteractions({
         clock: pickerRendererResponse.clock,

package/modern/tests/describeGregorianAdapter/testCalculations.js

@@ -1,10 +1,12 @@
 import { expect } from 'chai';
+import { getDateOffset } from 'test/utils/pickers-utils';
 import { TEST_DATE_ISO_STRING, TEST_DATE_LOCALE_STRING } from './describeGregorianAdapter.utils';
 export const testCalculations = ({
   adapter,
   adapterTZ,
   adapterFr,
-  setDefaultTimezone
+  setDefaultTimezone,
+  getLocaleFromDate
 }) => {
   const testDateIso = adapter.date(TEST_DATE_ISO_STRING);
   const testDateLocale = adapter.date(TEST_DATE_LOCALE_STRING);
@@ -113,25 +115,27 @@ export const testCalculations = ({
     testTimezone('default', 'America/Chicago');
     setDefaultTimezone(undefined);
   });
-  describe('Method: setTimezone', () => {
-    it('should support "default"', () => {
-      if (adapter.isTimezoneCompatible) {
-        const test = timezone => {
-          setDefaultTimezone(timezone);
-          const dateWithLocaleTimezone = adapter.dateWithTimezone(undefined, 'system');
-          const dateWithDefaultTimezone = adapter.setTimezone(dateWithLocaleTimezone, 'default');
-          expect(adapter.getTimezone(dateWithDefaultTimezone)).to.equal(timezone);
-        };
-        test('America/New_York');
-        test('Europe/Paris');
+  it('Method: setTimezone', () => {
+    if (adapter.isTimezoneCompatible) {
+      const test = timezone => {
+        setDefaultTimezone(timezone);
+        const dateWithLocaleTimezone = adapter.dateWithTimezone(TEST_DATE_ISO_STRING, 'system');
+        const dateWithDefaultTimezone = adapter.setTimezone(dateWithLocaleTimezone, 'default');
+        expect(adapter.getTimezone(dateWithDefaultTimezone)).to.equal(timezone);
+      };
+      test('America/New_York');
+      test('Europe/Paris');
 
-        // Reset to the default timezone
-        setDefaultTimezone(undefined);
-      } else {
-        const localeDate = adapter.dateWithTimezone(undefined, 'system');
-        expect(adapter.setTimezone(localeDate, 'default')).to.equal(localeDate);
-      }
-    });
+      // Reset to the default timezone
+      setDefaultTimezone(undefined);
+    } else {
+      const systemDate = adapter.dateWithTimezone(TEST_DATE_ISO_STRING, 'system');
+      expect(adapter.setTimezone(systemDate, 'default')).toEqualDateTime(systemDate);
+      expect(adapter.setTimezone(systemDate, 'system')).toEqualDateTime(systemDate);
+      const defaultDate = adapter.dateWithTimezone(TEST_DATE_ISO_STRING, 'default');
+      expect(adapter.setTimezone(systemDate, 'default')).toEqualDateTime(defaultDate);
+      expect(adapter.setTimezone(systemDate, 'system')).toEqualDateTime(defaultDate);
+    }
   });
   it('Method: toJsDate', () => {
     expect(adapter.toJsDate(testDateIso)).to.be.instanceOf(Date);
@@ -145,9 +149,6 @@ export const testCalculations = ({
     if (adapter.lib === 'date-fns') {
       // date-fns never suppress useless milliseconds in the end
       expect(outputtedISO).to.equal(TEST_DATE_ISO_STRING.replace('.000Z', 'Z'));
-    } else if (adapter.lib === 'luxon') {
-      // luxon does not shorthand +00:00 to Z, which is also valid ISO string
-      expect(outputtedISO).to.equal(TEST_DATE_ISO_STRING.replace('Z', '+00:00'));
     } else {
       expect(outputtedISO).to.equal(TEST_DATE_ISO_STRING);
     }
@@ -548,6 +549,9 @@ export const testCalculations = ({
   it('Method: getSeconds', () => {
     expect(adapter.getSeconds(testDateIso)).to.equal(0);
   });
+  it('Method: getMilliseconds', () => {
+    expect(adapter.getMilliseconds(testDateIso)).to.equal(0);
+  });
   it('Method: setYear', () => {
     expect(adapter.setYear(testDateIso, 2011)).toEqualDateTime('2011-10-30T11:44:00.000Z');
   });
@@ -566,6 +570,9 @@ export const testCalculations = ({
   it('Method: setSeconds', () => {
     expect(adapter.setSeconds(testDateIso, 11)).toEqualDateTime('2018-10-30T11:44:11.000Z');
   });
+  it('Method: setMilliseconds', () => {
+    expect(adapter.setMilliseconds(testDateIso, 11)).toEqualDateTime('2018-10-30T11:44:00.011Z');
+  });
   it('Method: getDaysInMonth', () => {
     expect(adapter.getDaysInMonth(testDateIso)).to.equal(31);
     expect(adapter.getDaysInMonth(testDateLocale)).to.equal(31);
@@ -597,11 +604,46 @@ export const testCalculations = ({
       date = adapter.addDays(date, 1);
     });
   });
-  it('Method: getWeekArray', () => {
-    const weekArray = adapter.getWeekArray(testDateIso);
-    expect(weekArray).to.have.length(5);
-    weekArray.forEach(week => {
-      expect(week).to.have.length(7);
+  describe('Method: getWeekArray', () => {
+    it('should work without timezones', () => {
+      const weekArray = adapter.getWeekArray(testDateIso);
+      let expectedDate = adapter.startOfWeek(adapter.startOfMonth(testDateIso));
+      expect(weekArray).to.have.length(5);
+      weekArray.forEach(week => {
+        expect(week).to.have.length(7);
+        week.forEach(day => {
+          expect(day).toEqualDateTime(expectedDate);
+          expectedDate = adapter.addDays(expectedDate, 1);
+        });
+      });
+    });
+    it('should respect the DST', function test() {
+      if (!adapterTZ.isTimezoneCompatible) {
+        this.skip();
+      }
+      const referenceDate = adapterTZ.dateWithTimezone('2022-03-17', 'Europe/Paris');
+      const weekArray = adapterTZ.getWeekArray(referenceDate);
+      let expectedDate = adapter.startOfWeek(adapter.startOfMonth(referenceDate));
+      const lastNonDSTDay = adapterTZ.dateWithTimezone('2022-03-27', 'Europe/Paris');
+      expect(weekArray).to.have.length(5);
+      weekArray.forEach(week => {
+        expect(week).to.have.length(7);
+        week.forEach(day => {
+          expect(adapterTZ.startOfDay(day)).toEqualDateTime(adapterTZ.startOfDay(expectedDate));
+          expectedDate = adapterTZ.addDays(expectedDate, 1);
+          expect(getDateOffset(adapterTZ, day)).to.equal(adapterTZ.isAfter(day, lastNonDSTDay) ? 120 : 60);
+        });
+      });
+    });
+    it('should respect the locale of the adapter, not the locale of the date', function test() {
+      const dateFr = adapterFr.dateWithTimezone('2022-03-17', 'default');
+      const weekArray = adapter.getWeekArray(dateFr);
+      if (getLocaleFromDate) {
+        expect(getLocaleFromDate(weekArray[0][0])).to.match(/en/);
+      }
+
+      // Week should start on Monday (28th of March) for adapters supporting locale-based week start.
+      expect(adapter.getDate(weekArray[0][0])).to.equal(adapter.lib === 'luxon' ? 28 : 27);
     });
   });
   it('Method: getWeekNumber', () => {

package/modern/tests/describeJalaliAdapter/testCalculations.js

@@ -163,6 +163,15 @@ export const testCalculations = ({
   it('Method: getDate', () => {
     expect(adapter.getDate(testDateIso)).to.equal(8);
   });
+  it('Method: getMinutes', () => {
+    expect(adapter.getMinutes(testDateIso)).to.equal(44);
+  });
+  it('Method: getSeconds', () => {
+    expect(adapter.getSeconds(testDateIso)).to.equal(0);
+  });
+  it('Method: getMilliseconds', () => {
+    expect(adapter.getMilliseconds(testDateIso)).to.equal(0);
+  });
   it('Method: setYear', () => {
     expect(adapter.setYear(testDateIso, 1398)).toEqualDateTime('2019-10-30T11:44:00.000Z');
   });
@@ -172,6 +181,18 @@ export const testCalculations = ({
   it('Method: setDate', () => {
     expect(adapter.setDate(testDateIso, 9)).toEqualDateTime('2018-10-31T11:44:00.000Z');
   });
+  it('Method: setHours', () => {
+    expect(adapter.setHours(testDateIso, 0)).toEqualDateTime('2018-10-30T00:44:00.000Z');
+  });
+  it('Method: setMinutes', () => {
+    expect(adapter.setMinutes(testDateIso, 12)).toEqualDateTime('2018-10-30T11:12:00.000Z');
+  });
+  it('Method: setSeconds', () => {
+    expect(adapter.setSeconds(testDateIso, 11)).toEqualDateTime('2018-10-30T11:44:11.000Z');
+  });
+  it('Method: setMilliseconds', () => {
+    expect(adapter.setMilliseconds(testDateIso, 11)).toEqualDateTime('2018-10-30T11:44:00.011Z');
+  });
   it('Method: getNextMonth', () => {
     expect(adapter.getNextMonth(testDateIso)).toEqualDateTime('2018-11-29T11:44:00.000Z');
   });

package/modern/timeViewRenderers/timeViewRenderers.js

@@ -33,7 +33,8 @@ export const renderTimeViewClock = ({
   sx,
   autoFocus,
   showViewSwitcher,
-  disableIgnoringDatePartForTimeValidation
+  disableIgnoringDatePartForTimeValidation,
+  timezone
 }) => /*#__PURE__*/_jsx(TimeClock, {
   view: view,
   onViewChange: onViewChange,
@@ -63,7 +64,8 @@ export const renderTimeViewClock = ({
   sx: sx,
   autoFocus: autoFocus,
   showViewSwitcher: showViewSwitcher,
-  disableIgnoringDatePartForTimeValidation: disableIgnoringDatePartForTimeValidation
+  disableIgnoringDatePartForTimeValidation: disableIgnoringDatePartForTimeValidation,
+  timezone: timezone
 });
 export const renderDigitalClockTimeView = ({
   view,
@@ -94,7 +96,8 @@ export const renderDigitalClockTimeView = ({
   autoFocus,
   disableIgnoringDatePartForTimeValidation,
   timeSteps,
-  skipDisabled
+  skipDisabled,
+  timezone
 }) => /*#__PURE__*/_jsx(DigitalClock, {
   view: view,
   onViewChange: onViewChange,
@@ -124,7 +127,8 @@ export const renderDigitalClockTimeView = ({
   autoFocus: autoFocus,
   disableIgnoringDatePartForTimeValidation: disableIgnoringDatePartForTimeValidation,
   timeStep: timeSteps?.minutes,
-  skipDisabled: skipDisabled
+  skipDisabled: skipDisabled,
+  timezone: timezone
 });
 export const renderMultiSectionDigitalClockTimeView = ({
   view,
@@ -155,7 +159,8 @@ export const renderMultiSectionDigitalClockTimeView = ({
   autoFocus,
   disableIgnoringDatePartForTimeValidation,
   timeSteps,
-  skipDisabled
+  skipDisabled,
+  timezone
 }) => /*#__PURE__*/_jsx(MultiSectionDigitalClock, {
   view: view,
   onViewChange: onViewChange,
@@ -185,5 +190,6 @@ export const renderMultiSectionDigitalClockTimeView = ({
   autoFocus: autoFocus,
   disableIgnoringDatePartForTimeValidation: disableIgnoringDatePartForTimeValidation,
   timeSteps: timeSteps,
-  skipDisabled: skipDisabled
+  skipDisabled: skipDisabled,
+  timezone: timezone
 });