@mui/x-date-pickers 6.18.6 → 6.19.0

package/AdapterDateFnsV3/AdapterDateFnsV3.js

@@ -0,0 +1,357 @@
+/* eslint-disable class-methods-use-this */
+// TODO remove when date-fns-v3 is the default
+// @ts-nocheck
+import { addDays } from 'date-fns/addDays';
+import { addSeconds } from 'date-fns/addSeconds';
+import { addMinutes } from 'date-fns/addMinutes';
+import { addHours } from 'date-fns/addHours';
+import { addWeeks } from 'date-fns/addWeeks';
+import { addMonths } from 'date-fns/addMonths';
+import { addYears } from 'date-fns/addYears';
+import { differenceInYears } from 'date-fns/differenceInYears';
+import { differenceInQuarters } from 'date-fns/differenceInQuarters';
+import { differenceInMonths } from 'date-fns/differenceInMonths';
+import { differenceInWeeks } from 'date-fns/differenceInWeeks';
+import { differenceInDays } from 'date-fns/differenceInDays';
+import { differenceInHours } from 'date-fns/differenceInHours';
+import { differenceInMinutes } from 'date-fns/differenceInMinutes';
+import { differenceInSeconds } from 'date-fns/differenceInSeconds';
+import { differenceInMilliseconds } from 'date-fns/differenceInMilliseconds';
+import { eachDayOfInterval } from 'date-fns/eachDayOfInterval';
+import { endOfDay } from 'date-fns/endOfDay';
+import { endOfWeek } from 'date-fns/endOfWeek';
+import { endOfYear } from 'date-fns/endOfYear';
+// @ts-ignore TODO remove when date-fns-v3 is the default
+import { format as dateFnsFormat, longFormatters } from 'date-fns/format';
+import { getDate } from 'date-fns/getDate';
+import { getDaysInMonth } from 'date-fns/getDaysInMonth';
+import { getHours } from 'date-fns/getHours';
+import { getMinutes } from 'date-fns/getMinutes';
+import { getMonth } from 'date-fns/getMonth';
+import { getSeconds } from 'date-fns/getSeconds';
+import { getMilliseconds } from 'date-fns/getMilliseconds';
+import { getWeek } from 'date-fns/getWeek';
+import { getYear } from 'date-fns/getYear';
+import { isAfter } from 'date-fns/isAfter';
+import { isBefore } from 'date-fns/isBefore';
+import { isEqual } from 'date-fns/isEqual';
+import { isSameDay } from 'date-fns/isSameDay';
+import { isSameYear } from 'date-fns/isSameYear';
+import { isSameMonth } from 'date-fns/isSameMonth';
+import { isSameHour } from 'date-fns/isSameHour';
+import { isValid } from 'date-fns/isValid';
+import { parse as dateFnsParse } from 'date-fns/parse';
+import { setDate } from 'date-fns/setDate';
+import { setHours } from 'date-fns/setHours';
+import { setMinutes } from 'date-fns/setMinutes';
+import { setMonth } from 'date-fns/setMonth';
+import { setSeconds } from 'date-fns/setSeconds';
+import { setMilliseconds } from 'date-fns/setMilliseconds';
+import { setYear } from 'date-fns/setYear';
+import { startOfDay } from 'date-fns/startOfDay';
+import { startOfMonth } from 'date-fns/startOfMonth';
+import { endOfMonth } from 'date-fns/endOfMonth';
+import { startOfWeek } from 'date-fns/startOfWeek';
+import { startOfYear } from 'date-fns/startOfYear';
+import { formatISO } from 'date-fns/formatISO';
+import { parseISO } from 'date-fns/parseISO';
+import { isWithinInterval } from 'date-fns/isWithinInterval';
+import { enUS } from 'date-fns/locale/en-US';
+// date-fns v2 does not export types
+// @ts-ignore TODO remove when date-fns-v3 is the default
+import { AdapterDateFnsBase } from '../AdapterDateFnsBase';
+
+/**
+ * Based on `@date-io/date-fns`
+ *
+ * MIT License
+ *
+ * Copyright (c) 2017 Dmitriy Kovalenko
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+export class AdapterDateFns extends AdapterDateFnsBase {
+  constructor({
+    locale,
+    formats
+  } = {}) {
+    if (typeof addDays !== 'function') {
+      throw new Error([`MUI: The \`date-fns\` package v2.x is not compatible with this adapter.`, 'Please, install v3.x of the package or use the `AdapterDateFns` instead.'].join('\n'));
+    }
+    if (!longFormatters) {
+      throw new Error('MUI: The minimum supported `date-fns` package version compatible with this adapter is `3.2.x`.');
+    }
+    super({
+      locale: locale != null ? locale : enUS,
+      formats,
+      longFormatters
+    });
+    this.parseISO = isoString => {
+      return parseISO(isoString);
+    };
+    this.toISO = value => {
+      return formatISO(value, {
+        format: 'extended'
+      });
+    };
+    this.parse = (value, format) => {
+      if (value === '') {
+        return null;
+      }
+      return dateFnsParse(value, format, new Date(), {
+        locale: this.locale
+      });
+    };
+    this.isValid = value => {
+      return isValid(this.date(value));
+    };
+    this.format = (value, formatKey) => {
+      return this.formatByString(value, this.formats[formatKey]);
+    };
+    this.formatByString = (value, formatString) => {
+      return dateFnsFormat(value, formatString, {
+        locale: this.locale
+      });
+    };
+    this.getDiff = (value, comparing, unit) => {
+      switch (unit) {
+        case 'years':
+          return differenceInYears(value, this.date(comparing));
+        case 'quarters':
+          return differenceInQuarters(value, this.date(comparing));
+        case 'months':
+          return differenceInMonths(value, this.date(comparing));
+        case 'weeks':
+          return differenceInWeeks(value, this.date(comparing));
+        case 'days':
+          return differenceInDays(value, this.date(comparing));
+        case 'hours':
+          return differenceInHours(value, this.date(comparing));
+        case 'minutes':
+          return differenceInMinutes(value, this.date(comparing));
+        case 'seconds':
+          return differenceInSeconds(value, this.date(comparing));
+        default:
+          {
+            return differenceInMilliseconds(value, this.date(comparing));
+          }
+      }
+    };
+    this.isEqual = (value, comparing) => {
+      if (value === null && comparing === null) {
+        return true;
+      }
+      return isEqual(value, comparing);
+    };
+    this.isSameYear = (value, comparing) => {
+      return isSameYear(value, comparing);
+    };
+    this.isSameMonth = (value, comparing) => {
+      return isSameMonth(value, comparing);
+    };
+    this.isSameDay = (value, comparing) => {
+      return isSameDay(value, comparing);
+    };
+    this.isSameHour = (value, comparing) => {
+      return isSameHour(value, comparing);
+    };
+    this.isAfter = (value, comparing) => {
+      return isAfter(value, comparing);
+    };
+    this.isAfterYear = (value, comparing) => {
+      return isAfter(value, endOfYear(comparing));
+    };
+    this.isAfterDay = (value, comparing) => {
+      return isAfter(value, endOfDay(comparing));
+    };
+    this.isBefore = (value, comparing) => {
+      return isBefore(value, comparing);
+    };
+    this.isBeforeYear = (value, comparing) => {
+      return isBefore(value, this.startOfYear(comparing));
+    };
+    this.isBeforeDay = (value, comparing) => {
+      return isBefore(value, this.startOfDay(comparing));
+    };
+    this.isWithinRange = (value, [start, end]) => {
+      return isWithinInterval(value, {
+        start,
+        end
+      });
+    };
+    this.startOfYear = value => {
+      return startOfYear(value);
+    };
+    this.startOfMonth = value => {
+      return startOfMonth(value);
+    };
+    this.startOfWeek = value => {
+      return startOfWeek(value, {
+        locale: this.locale
+      });
+    };
+    this.startOfDay = value => {
+      return startOfDay(value);
+    };
+    this.endOfYear = value => {
+      return endOfYear(value);
+    };
+    this.endOfMonth = value => {
+      return endOfMonth(value);
+    };
+    this.endOfWeek = value => {
+      return endOfWeek(value, {
+        locale: this.locale
+      });
+    };
+    this.endOfDay = value => {
+      return endOfDay(value);
+    };
+    this.addYears = (value, amount) => {
+      return addYears(value, amount);
+    };
+    this.addMonths = (value, amount) => {
+      return addMonths(value, amount);
+    };
+    this.addWeeks = (value, amount) => {
+      return addWeeks(value, amount);
+    };
+    this.addDays = (value, amount) => {
+      return addDays(value, amount);
+    };
+    this.addHours = (value, amount) => {
+      return addHours(value, amount);
+    };
+    this.addMinutes = (value, amount) => {
+      return addMinutes(value, amount);
+    };
+    this.addSeconds = (value, amount) => {
+      return addSeconds(value, amount);
+    };
+    this.getYear = value => {
+      return getYear(value);
+    };
+    this.getMonth = value => {
+      return getMonth(value);
+    };
+    this.getDate = value => {
+      return getDate(value);
+    };
+    this.getHours = value => {
+      return getHours(value);
+    };
+    this.getMinutes = value => {
+      return getMinutes(value);
+    };
+    this.getSeconds = value => {
+      return getSeconds(value);
+    };
+    this.getMilliseconds = value => {
+      return getMilliseconds(value);
+    };
+    this.setYear = (value, year) => {
+      return setYear(value, year);
+    };
+    this.setMonth = (value, month) => {
+      return setMonth(value, month);
+    };
+    this.setDate = (value, date) => {
+      return setDate(value, date);
+    };
+    this.setHours = (value, hours) => {
+      return setHours(value, hours);
+    };
+    this.setMinutes = (value, minutes) => {
+      return setMinutes(value, minutes);
+    };
+    this.setSeconds = (value, seconds) => {
+      return setSeconds(value, seconds);
+    };
+    this.setMilliseconds = (value, milliseconds) => {
+      return setMilliseconds(value, milliseconds);
+    };
+    this.getDaysInMonth = value => {
+      return getDaysInMonth(value);
+    };
+    this.getNextMonth = value => {
+      return addMonths(value, 1);
+    };
+    this.getPreviousMonth = value => {
+      return addMonths(value, -1);
+    };
+    this.getMonthArray = value => {
+      const firstMonth = startOfYear(value);
+      const monthArray = [firstMonth];
+      while (monthArray.length < 12) {
+        const prevMonth = monthArray[monthArray.length - 1];
+        monthArray.push(this.getNextMonth(prevMonth));
+      }
+      return monthArray;
+    };
+    this.mergeDateAndTime = (dateParam, timeParam) => {
+      return this.setSeconds(this.setMinutes(this.setHours(dateParam, this.getHours(timeParam)), this.getMinutes(timeParam)), this.getSeconds(timeParam));
+    };
+    this.getWeekdays = () => {
+      const now = new Date();
+      return eachDayOfInterval({
+        start: startOfWeek(now, {
+          locale: this.locale
+        }),
+        end: endOfWeek(now, {
+          locale: this.locale
+        })
+      }).map(day => this.formatByString(day, 'EEEEEE'));
+    };
+    this.getWeekArray = value => {
+      const start = startOfWeek(startOfMonth(value), {
+        locale: this.locale
+      });
+      const end = endOfWeek(endOfMonth(value), {
+        locale: this.locale
+      });
+      let count = 0;
+      let current = start;
+      const nestedWeeks = [];
+      while (isBefore(current, end)) {
+        const weekNumber = Math.floor(count / 7);
+        nestedWeeks[weekNumber] = nestedWeeks[weekNumber] || [];
+        nestedWeeks[weekNumber].push(current);
+        current = addDays(current, 1);
+        count += 1;
+      }
+      return nestedWeeks;
+    };
+    this.getWeekNumber = value => {
+      return getWeek(value, {
+        locale: this.locale
+      });
+    };
+    this.getYearRange = (start, end) => {
+      const startDate = startOfYear(start);
+      const endDate = endOfYear(end);
+      const years = [];
+      let current = startDate;
+      while (isBefore(current, endDate)) {
+        years.push(current);
+        current = addYears(current, 1);
+      }
+      return years;
+    };
+  }
+}

package/AdapterDateFnsV3/index.d.ts

@@ -0,0 +1 @@
+export { AdapterDateFns } from './AdapterDateFnsV3';

package/AdapterDateFnsV3/index.js

@@ -0,0 +1 @@
+export { AdapterDateFns } from './AdapterDateFnsV3';

package/AdapterDateFnsV3/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/AdapterDateFnsV3/index.js",
+  "types": "./index.d.ts"
+}

package/AdapterLuxon/AdapterLuxon.d.ts

@@ -38,14 +38,14 @@ export declare class AdapterLuxon implements MuiPickersAdapter<DateTime, string>
     formatTokenMap: FieldFormatTokenMap;
     constructor({ locale, formats }?: AdapterOptions<string, never>);
     private setLocaleToValue;
-    date: (value?: any) => DateTime | null;
-    dateWithTimezone: <T extends string | null | undefined>(value: T, timezone: PickersTimezone) => DateBuilderReturnType<T, DateTime>;
+    date: (value?: any) => DateTime<true> | DateTime<false> | null;
+    dateWithTimezone: <T extends string | null | undefined>(value: T, timezone: PickersTimezone) => DateBuilderReturnType<T, DateTime<boolean>>;
     getTimezone: (value: DateTime) => string;
     setTimezone: (value: DateTime, timezone: PickersTimezone) => DateTime;
     toJsDate: (value: DateTime) => Date;
-    parseISO: (isoString: string) => DateTime;
+    parseISO: (isoString: string) => DateTime<true> | DateTime<false>;
     toISO: (value: DateTime) => string;
-    parse: (value: string, formatString: string) => DateTime | null;
+    parse: (value: string, formatString: string) => DateTime<true> | DateTime<false> | null;
     getCurrentLocaleCode: () => string;
     is12HourCycleInCurrentLocale: () => boolean;
     expandFormat: (format: string) => string;
@@ -68,21 +68,21 @@ export declare class AdapterLuxon implements MuiPickersAdapter<DateTime, string>
     isBeforeYear: (value: DateTime, comparing: DateTime) => boolean;
     isBeforeDay: (value: DateTime, comparing: DateTime) => boolean;
     isWithinRange: (value: DateTime, [start, end]: [DateTime, DateTime]) => boolean;
-    startOfYear: (value: DateTime) => DateTime;
-    startOfMonth: (value: DateTime) => DateTime;
-    startOfWeek: (value: DateTime) => DateTime;
-    startOfDay: (value: DateTime) => DateTime;
-    endOfYear: (value: DateTime) => DateTime;
-    endOfMonth: (value: DateTime) => DateTime;
-    endOfWeek: (value: DateTime) => DateTime;
-    endOfDay: (value: DateTime) => DateTime;
-    addYears: (value: DateTime, amount: number) => DateTime;
-    addMonths: (value: DateTime, amount: number) => DateTime;
-    addWeeks: (value: DateTime, amount: number) => DateTime;
-    addDays: (value: DateTime, amount: number) => DateTime;
-    addHours: (value: DateTime, amount: number) => DateTime;
-    addMinutes: (value: DateTime, amount: number) => DateTime;
-    addSeconds: (value: DateTime, amount: number) => DateTime;
+    startOfYear: (value: DateTime) => DateTime<boolean>;
+    startOfMonth: (value: DateTime) => DateTime<boolean>;
+    startOfWeek: (value: DateTime) => DateTime<boolean>;
+    startOfDay: (value: DateTime) => DateTime<boolean>;
+    endOfYear: (value: DateTime) => DateTime<boolean>;
+    endOfMonth: (value: DateTime) => DateTime<boolean>;
+    endOfWeek: (value: DateTime) => DateTime<boolean>;
+    endOfDay: (value: DateTime) => DateTime<boolean>;
+    addYears: (value: DateTime, amount: number) => DateTime<boolean>;
+    addMonths: (value: DateTime, amount: number) => DateTime<boolean>;
+    addWeeks: (value: DateTime, amount: number) => DateTime<boolean>;
+    addDays: (value: DateTime, amount: number) => DateTime<boolean>;
+    addHours: (value: DateTime, amount: number) => DateTime<boolean>;
+    addMinutes: (value: DateTime, amount: number) => DateTime<boolean>;
+    addSeconds: (value: DateTime, amount: number) => DateTime<boolean>;
     getYear: (value: DateTime) => number;
     getMonth: (value: DateTime) => number;
     getDate: (value: DateTime) => number;
@@ -90,21 +90,21 @@ export declare class AdapterLuxon implements MuiPickersAdapter<DateTime, string>
     getMinutes: (value: DateTime) => number;
     getSeconds: (value: DateTime) => number;
     getMilliseconds: (value: DateTime) => number;
-    setYear: (value: DateTime, year: number) => DateTime;
-    setMonth: (value: DateTime, month: number) => DateTime;
-    setDate: (value: DateTime, date: number) => DateTime;
-    setHours: (value: DateTime, hours: number) => DateTime;
-    setMinutes: (value: DateTime, minutes: number) => DateTime;
-    setSeconds: (value: DateTime, seconds: number) => DateTime;
-    setMilliseconds: (value: DateTime, milliseconds: number) => DateTime;
+    setYear: (value: DateTime, year: number) => DateTime<boolean>;
+    setMonth: (value: DateTime, month: number) => DateTime<boolean>;
+    setDate: (value: DateTime, date: number) => DateTime<boolean>;
+    setHours: (value: DateTime, hours: number) => DateTime<boolean>;
+    setMinutes: (value: DateTime, minutes: number) => DateTime<boolean>;
+    setSeconds: (value: DateTime, seconds: number) => DateTime<boolean>;
+    setMilliseconds: (value: DateTime, milliseconds: number) => DateTime<boolean>;
     getDaysInMonth: (value: DateTime) => import("luxon").PossibleDaysInMonth;
-    getNextMonth: (value: DateTime) => DateTime;
-    getPreviousMonth: (value: DateTime) => DateTime;
-    getMonthArray: (value: DateTime) => DateTime[];
-    mergeDateAndTime: (dateParam: DateTime, timeParam: DateTime) => DateTime;
+    getNextMonth: (value: DateTime) => DateTime<boolean>;
+    getPreviousMonth: (value: DateTime) => DateTime<boolean>;
+    getMonthArray: (value: DateTime) => DateTime<boolean>[];
+    mergeDateAndTime: (dateParam: DateTime, timeParam: DateTime) => DateTime<boolean>;
     getWeekdays: () => string[];
-    getWeekArray: (value: DateTime) => DateTime[][];
+    getWeekArray: (value: DateTime) => DateTime<boolean>[][];
     getWeekNumber: (value: DateTime) => number;
-    getYearRange: (start: DateTime, end: DateTime) => DateTime[];
+    getYearRange: (start: DateTime, end: DateTime) => DateTime<boolean>[];
     getMeridiemText: (ampm: 'am' | 'pm') => string;
 }

package/CHANGELOG.md

@@ -3,6 +3,90 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## 6.19.0
+
+_Jan 11, 2024_
+
+We'd like to offer a big thanks to the 3 contributors who made this release possible. Here are some highlights ✨:
+
+- ⏰ Support date-fns v3 (#11659) @LukasTy
+  Pickers support both v2 and v3 of date-fns. For v3 use `AdapterDateFnsV3`.
+  ```js
+  // with date-fns v2.x
+  import { AdapterDateFns } from '@mui/x-date-pickers/AdapterDateFns';
+  import de from 'date-fns/locale/de';
+  ```
+  ```js
+  // with date-fns v3.x
+  import { AdapterDateFns } from '@mui/x-date-pickers/AdapterDateFnsV3';
+  import { de } from 'date-fns/locale/de';
+  ```
+
+### Date Pickers
+
+#### `@mui/x-date-pickers@6.19.0`
+
+- [pickers] Add date-fns@3.x adapter (#11659) @LukasTy
+- [pickers] Fix clearable behavior blocking focus return to `OpenPickerButton` (#11643) @noraleonte
+- [l10n] Add missing Danish (da-DK) locale export (#11641) @etlos
+
+#### `@mui/x-date-pickers-pro@6.19.0` [![pro](https://mui.com/r/x-pro-svg)](https://mui.com/r/x-pro-svg-link 'Pro plan')
+
+Same changes as in `@mui/x-date-pickers@6.19.0`.
+
+### Docs
+
+- [docs] Add missing component @oliviertassinari
+- [docs] Fix parsing of `x-date-pickers-pro` demo adapter imports (#11637) @LukasTy
+- [docs] Push up the MUI X brand (#11533) @oliviertassinari
+- [docs] Improve Server-side data grid docs (#11589) @oliviertassinari
+- [docs] Add demo to the charts overview page (#11586) @danilo-leal
+- [docs] Fix 404 links in the docs @oliviertassinari
+- [docs] Improve landing page (#11570) @oliviertassinari
+- [docs] Give a general revision to the docs (#11249) @danilo-leal
+
+## 6.18.7
+
+_Jan 5, 2024_
+
+We'd like to offer a big thanks to the 4 contributors who made this release possible. Here are some highlights ✨:
+
+- 🌍 Improve Czech (cs-CZ) locale on Data Grid (#11429) @wensiet
+- 🐞 Bugfixes
+
+### Data Grid
+
+#### `@mui/x-data-grid@6.18.7`
+
+- [DataGrid] Don't evaluate `hasEval` when `disableEval` is set (#11553) @reihwald
+- [l10n] Update Czech (cs-CZ) locale (#11498) @fdebef
+
+#### `@mui/x-data-grid-pro@6.18.7` [![pro](https://mui.com/r/x-pro-svg)](https://mui.com/r/x-pro-svg-link 'Pro plan')
+
+Same changes as in `@mui/x-data-grid@6.18.7`.
+
+#### `@mui/x-data-grid-premium@6.18.7` [![premium](https://mui.com/r/x-premium-svg)](https://mui.com/r/x-premium-svg-link 'Premium plan')
+
+Same changes as in `@mui/x-data-grid-pro@6.18.7`.
+
+### Date Pickers
+
+#### `@mui/x-date-pickers@6.18.7`
+
+- [pickers] Fix views management (@LukasTy) (#11572)
+
+#### `@mui/x-date-pickers-pro@6.18.7` [![pro](https://mui.com/r/x-pro-svg)](https://mui.com/r/x-pro-svg-link 'Pro plan')
+
+Same changes as in `@mui/x-date-pickers@6.18.7`.
+
+### Charts / `@mui/x-charts@6.18.7`
+
+- [charts] Fix `null` in line chart using dataset (@alexfauquette) (#11561)
+
+### Docs
+
+- [docs] Clarify Pickers usage with Luxon (#11566) @LukasTy
+
 ## 6.18.6
 
 _Dec 22, 2023_
@@ -37,7 +121,7 @@ Same changes as in `@mui/x-data-grid-pro@6.18.6`.
 
 Same changes as in `@mui/x-date-pickers@6.18.6`.
 
-### Charts / `@mui/x-charts@6.18.6`
+### Charts / `@mui/x-charts@6.18.4`
 
 - [charts] Allow percentage values for pie chart center and radius (#11464) @alexfauquette
 - [charts] Make error message more explicit (#11457) @alexfauquette

package/DateCalendar/DateCalendar.js

@@ -258,9 +258,9 @@ export const DateCalendar = /*#__PURE__*/React.forwardRef(function DateCalendar(
   const handleSelectedDayChange = useEventCallback(day => {
     if (day) {
       // If there is a date already selected, then we want to keep its time
-      return handleValueChange(mergeDateAndTime(utils, day, value != null ? value : referenceDate), 'finish');
+      return handleValueChange(mergeDateAndTime(utils, day, value != null ? value : referenceDate), 'finish', view);
     }
-    return handleValueChange(day, 'finish');
+    return handleValueChange(day, 'finish', view);
   });
   React.useEffect(() => {
     if (value != null && utils.isValid(value)) {
@@ -449,9 +449,11 @@ process.env.NODE_ENV !== "production" ? DateCalendar.propTypes = {
   monthsPerRow: PropTypes.oneOf([3, 4]),
   /**
    * Callback fired when the value changes.
-   * @template TDate
-   * @param {TDate | null} value The new value.
+   * @template TValue The value type. Will be either the same type as `value` or `null`. Can be in `[start, end]` format in case of range value.
+   * @template TView The view type. Will be one of date or time views.
+   * @param {TValue} value The new value.
    * @param {PickerSelectionState | undefined} selectionState Indicates if the date selection is complete.
+   * @param {TView | undefined} selectedView Indicates the view in which the selection has been made.
    */
   onChange: PropTypes.func,
   /**

package/DateCalendar/DateCalendar.types.d.ts

@@ -6,7 +6,6 @@ import { PickersCalendarHeader, PickersCalendarHeaderProps, PickersCalendarHeade
 import { DayCalendarSlotsComponent, DayCalendarSlotsComponentsProps, ExportedDayCalendarProps } from './DayCalendar';
 import { DateCalendarClasses } from './dateCalendarClasses';
 import { BaseDateValidationProps, YearValidationProps, MonthValidationProps, DayValidationProps } from '../internals/models/validation';
-import { PickerSelectionState } from '../internals/hooks/usePicker/usePickerValue.types';
 import { ExportedUseViewsOptions } from '../internals/hooks/useViews';
 import { DateView, TimezoneProps } from '../models';
 import { DefaultizedProps } from '../internals/models/helpers';
@@ -80,13 +79,6 @@ export interface DateCalendarProps<TDate> extends ExportedDateCalendarProps<TDat
      * @default The closest valid date using the validation props, except callbacks such as `shouldDisableDate`.
      */
     referenceDate?: TDate;
-    /**
-     * Callback fired when the value changes.
-     * @template TDate
-     * @param {TDate | null} value The new value.
-     * @param {PickerSelectionState | undefined} selectionState Indicates if the date selection is complete.
-     */
-    onChange?: (value: TDate | null, selectionState?: PickerSelectionState) => void;
     className?: string;
     classes?: Partial<DateCalendarClasses>;
     /**

package/DigitalClock/DigitalClock.js

@@ -340,8 +340,9 @@ process.env.NODE_ENV !== "production" ? DigitalClock.propTypes = {
   minutesStep: PropTypes.number,
   /**
    * Callback fired when the value changes.
-   * @template TDate, TView
-   * @param {TDate | null} value The new value.
+   * @template TValue The value type. Will be either the same type as `value` or `null`. Can be in `[start, end]` format in case of range value.
+   * @template TView The view type. Will be one of date or time views.
+   * @param {TValue} value The new value.
    * @param {PickerSelectionState | undefined} selectionState Indicates if the date selection is complete.
    * @param {TView | undefined} selectedView Indicates the view in which the selection has been made.
    */