@mui/x-date-pickers 6.1.0 → 6.2.0

package/node/tests/describeGregorianAdapter/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "TEST_DATE_ISO", {
+  enumerable: true,
+  get: function () {
+    return _describeGregorianAdapter.TEST_DATE_ISO;
+  }
+});
+Object.defineProperty(exports, "describeGregorianAdapter", {
+  enumerable: true,
+  get: function () {
+    return _describeGregorianAdapter.describeGregorianAdapter;
+  }
+});
+var _describeGregorianAdapter = require("./describeGregorianAdapter");

package/node/tests/describeGregorianAdapter/testCalculations.js

@@ -0,0 +1,279 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.testCalculations = void 0;
+var _chai = require("chai");
+const testCalculations = ({
+  adapter,
+  testDate,
+  testDateISO,
+  formatDateTime
+}) => {
+  it('Method: date', () => {
+    // ISO string
+    (0, _chai.expect)(adapter.isEqual(testDate, adapter.date(testDateISO))).to.equal(true);
+
+    // Native Date
+    (0, _chai.expect)(adapter.isEqual(testDate, adapter.date(new Date(testDateISO)))).to.equal(true);
+
+    // Parse already date-specific object
+    (0, _chai.expect)(adapter.isEqual(testDate, adapter.date(adapter.date(testDateISO)))).to.equal(true);
+
+    // Parse null inputs
+    (0, _chai.expect)(adapter.date(null)).to.equal(null);
+
+    // Undefined
+    (0, _chai.expect)(!!adapter.date(undefined)).to.equal(true);
+  });
+  it('Method: isValid', () => {
+    const invalidDate = adapter.date('2018-42-30T11:60:00.000Z');
+    (0, _chai.expect)(adapter.isValid(testDate)).to.equal(true);
+    (0, _chai.expect)(adapter.isValid(invalidDate)).to.equal(false);
+    (0, _chai.expect)(adapter.isValid(undefined)).to.equal(true);
+    (0, _chai.expect)(adapter.isValid(null)).to.equal(false);
+    (0, _chai.expect)(adapter.isValid('2018-42-30T11:60:00.000Z')).to.equal(false);
+  });
+  it('Method: addYears', () => {
+    (0, _chai.expect)(adapter.format(adapter.addYears(testDate, 2), 'year')).to.equal('2020');
+    (0, _chai.expect)(adapter.format(adapter.addYears(testDate, -2), 'year')).to.equal('2016');
+  });
+  it('Method: addMonths', () => {
+    (0, _chai.expect)(adapter.format(adapter.addMonths(testDate, 2), 'monthAndYear')).to.equal('December 2018');
+    (0, _chai.expect)(adapter.format(adapter.addMonths(testDate, -2), 'monthAndYear')).to.equal('August 2018');
+  });
+  it('Method: addWeeks', () => {
+    (0, _chai.expect)(adapter.getDiff(adapter.addWeeks(testDate, 1), testDate, 'weeks')).to.equal(1);
+    (0, _chai.expect)(adapter.getDiff(adapter.addWeeks(testDate, -1), testDate, 'weeks')).to.equal(-1);
+  });
+  it('Method: addDays', () => {
+    (0, _chai.expect)(adapter.format(adapter.addDays(testDate, 1), 'dayOfMonth')).to.equal('31');
+    (0, _chai.expect)(adapter.format(adapter.addDays(testDate, -1), 'dayOfMonth')).to.equal('29');
+  });
+  it('Method: addHours', () => {
+    (0, _chai.expect)(adapter.format(adapter.addHours(testDate, 65), 'hours24h')).to.equal('04');
+    (0, _chai.expect)(adapter.format(adapter.addHours(testDate, -5), 'hours24h')).to.equal('06');
+  });
+  it('Method: addMinutes', () => {
+    (0, _chai.expect)(adapter.format(adapter.addMinutes(testDate, 65), 'minutes')).to.equal('49');
+    (0, _chai.expect)(adapter.format(adapter.addMinutes(testDate, -5), 'minutes')).to.equal('39');
+  });
+  it('Method: addSeconds', () => {
+    (0, _chai.expect)(adapter.format(adapter.addSeconds(testDate, 65), 'seconds')).to.equal('05');
+    (0, _chai.expect)(adapter.format(adapter.addSeconds(testDate, -5), 'seconds')).to.equal('55');
+  });
+  it('Method: startOfYear', () => {
+    (0, _chai.expect)(adapter.formatByString(adapter.startOfYear(testDate), formatDateTime)).to.equal('2018-01-01 00:00:00');
+  });
+  it('Method: startOfMonth', () => {
+    (0, _chai.expect)(adapter.formatByString(adapter.startOfMonth(testDate), formatDateTime)).to.equal('2018-10-01 00:00:00');
+  });
+  it('Method: startOfWeek', () => {
+    (0, _chai.expect)(adapter.formatByString(adapter.startOfWeek(testDate), formatDateTime)).to.equal(adapter.lib === 'luxon' ? '2018-10-29 00:00:00' : '2018-10-28 00:00:00');
+
+    // Non ISO
+    (0, _chai.expect)(adapter.formatByString(adapter.startOfWeek(adapter.date('2018-10-28T00:00:00.000Z')), formatDateTime)).to.equal(adapter.lib === 'luxon' ? '2018-10-22 00:00:00' : '2018-10-28 00:00:00');
+  });
+  it('Method: startOfDay', () => {
+    (0, _chai.expect)(adapter.formatByString(adapter.startOfDay(testDate), formatDateTime)).to.equal('2018-10-30 00:00:00');
+  });
+  it('Method: endOfYear', () => {
+    (0, _chai.expect)(adapter.formatByString(adapter.endOfYear(testDate), formatDateTime)).to.equal('2018-12-31 23:59:59');
+  });
+  it('Method: endOfMonth', () => {
+    (0, _chai.expect)(adapter.formatByString(adapter.endOfMonth(testDate), formatDateTime)).to.equal('2018-10-31 23:59:59');
+  });
+  it('Method: endOfWeek', () => {
+    (0, _chai.expect)(adapter.formatByString(adapter.endOfWeek(testDate), formatDateTime)).to.equal(adapter.lib === 'luxon' ? '2018-11-04 23:59:59' : '2018-11-03 23:59:59');
+
+    // Non ISO
+    (0, _chai.expect)(adapter.formatByString(adapter.endOfWeek(adapter.date('2018-10-28T00:00:00.000Z')), formatDateTime)).to.equal(adapter.lib === 'luxon' ? '2018-10-28 23:59:59' : '2018-11-03 23:59:59');
+  });
+  it('Method: endOfDay', () => {
+    (0, _chai.expect)(adapter.formatByString(adapter.endOfDay(testDate), formatDateTime)).to.equal('2018-10-30 23:59:59');
+  });
+  it('Method:getPreviousMonth', () => {
+    (0, _chai.expect)(adapter.formatByString(adapter.getPreviousMonth(testDate), formatDateTime)).to.equal('2018-09-30 11:44:00');
+  });
+  it('Method:getMonthArray', () => {
+    (0, _chai.expect)(adapter.getMonthArray(testDate).map(date => adapter.formatByString(date, formatDateTime))).to.deep.equal(['2018-01-01 00:00:00', '2018-02-01 00:00:00', '2018-03-01 00:00:00', '2018-04-01 00:00:00', '2018-05-01 00:00:00', '2018-06-01 00:00:00', '2018-07-01 00:00:00', '2018-08-01 00:00:00', '2018-09-01 00:00:00', '2018-10-01 00:00:00', '2018-11-01 00:00:00', '2018-12-01 00:00:00']);
+  });
+  it('Method:getNextMonth', () => {
+    (0, _chai.expect)(adapter.formatByString(adapter.getNextMonth(testDate), formatDateTime)).to.equal('2018-11-30 11:44:00');
+  });
+  it('Method:getHours', () => {
+    (0, _chai.expect)(adapter.getHours(testDate)).to.equal(new Date(testDateISO).getHours());
+  });
+  it('Method:getMinutes', () => {
+    (0, _chai.expect)(adapter.getMinutes(testDate)).to.equal(44);
+  });
+  it('Method:getSeconds', () => {
+    (0, _chai.expect)(adapter.getSeconds(testDate)).to.equal(0);
+  });
+  it('Method:getDate', () => {
+    (0, _chai.expect)(adapter.getDate(testDate)).to.equal(30);
+  });
+  it('Method:getYear', () => {
+    (0, _chai.expect)(adapter.getYear(testDate)).to.equal(2018);
+  });
+  it('Method:getMonth', () => {
+    (0, _chai.expect)(adapter.getMonth(testDate)).to.equal(9);
+  });
+  it('Method:getDaysInMonth', () => {
+    (0, _chai.expect)(adapter.getDaysInMonth(testDate)).to.equal(31);
+  });
+  it('Method:setMonth', () => {
+    const updatedTime = adapter.formatByString(adapter.setMonth(testDate, 4), formatDateTime);
+    (0, _chai.expect)(updatedTime).to.equal('2018-05-30 11:44:00');
+  });
+  it('Method:setHours', () => {
+    const updatedTime = adapter.formatByString(adapter.setHours(testDate, 0), formatDateTime);
+    (0, _chai.expect)(updatedTime).to.equal('2018-10-30 00:44:00');
+  });
+  it('Method:setMinutes', () => {
+    const updatedTime = adapter.formatByString(adapter.setMinutes(testDate, 12), formatDateTime);
+    (0, _chai.expect)(updatedTime).to.equal('2018-10-30 11:12:00');
+  });
+  it('Method:setMinutes', () => {
+    const updatedTime = adapter.formatByString(adapter.setMinutes(testDate, 12), formatDateTime);
+    (0, _chai.expect)(updatedTime).to.equal('2018-10-30 11:12:00');
+  });
+  it('Method:setYear', () => {
+    const updatedTime = adapter.formatByString(adapter.setYear(testDate, 2011), formatDateTime);
+    (0, _chai.expect)(updatedTime).to.equal('2011-10-30 11:44:00');
+  });
+  it('Method:setDate', () => {
+    const updatedTime = adapter.formatByString(adapter.setDate(testDate, 15), formatDateTime);
+    (0, _chai.expect)(updatedTime).to.equal('2018-10-15 11:44:00');
+  });
+  it('Method:setSeconds', () => {
+    const updatedValue = adapter.formatByString(adapter.setSeconds(testDate, 11), formatDateTime);
+    (0, _chai.expect)(updatedValue).to.equal('2018-10-30 11:44:11');
+  });
+  it('Method:isAfter', () => {
+    (0, _chai.expect)(adapter.isAfter(adapter.date(), testDate)).to.equal(true);
+    (0, _chai.expect)(adapter.isAfter(testDate, adapter.date())).to.equal(false);
+  });
+  it('Method:isBefore', () => {
+    (0, _chai.expect)(adapter.isBefore(testDate, adapter.date())).to.equal(true);
+    (0, _chai.expect)(adapter.isBefore(adapter.date(), testDate)).to.equal(false);
+  });
+  it('Method:isAfterDay', () => {
+    const nextDay = adapter.addDays(testDate, 1);
+    (0, _chai.expect)(adapter.isAfterDay(nextDay, testDate)).to.equal(true);
+    (0, _chai.expect)(adapter.isAfterDay(testDate, nextDay)).to.equal(false);
+  });
+  it('Method:isBeforeDay', () => {
+    const previousDay = adapter.addDays(testDate, -1);
+    (0, _chai.expect)(adapter.isBeforeDay(testDate, previousDay)).to.equal(false);
+    (0, _chai.expect)(adapter.isBeforeDay(previousDay, testDate)).to.equal(true);
+  });
+  it('Method:isAfterYear', () => {
+    const nextYear = adapter.setYear(testDate, 2019);
+    (0, _chai.expect)(adapter.isAfterYear(nextYear, testDate)).to.equal(true);
+    (0, _chai.expect)(adapter.isAfterYear(testDate, nextYear)).to.equal(false);
+  });
+  it('Method:isBeforeYear', () => {
+    const previousYear = adapter.setYear(testDate, 2017);
+    (0, _chai.expect)(adapter.isBeforeYear(testDate, previousYear)).to.equal(false);
+    (0, _chai.expect)(adapter.isBeforeYear(previousYear, testDate)).to.equal(true);
+  });
+  it('Method:getWeekArray', () => {
+    const weekArray = adapter.getWeekArray(testDate);
+    (0, _chai.expect)(weekArray).to.have.length(5);
+    weekArray.forEach(week => {
+      (0, _chai.expect)(week).to.have.length(7);
+    });
+  });
+  it('Method:getYearRange', () => {
+    const yearRange = adapter.getYearRange(testDate, adapter.setYear(testDate, 2124));
+    (0, _chai.expect)(yearRange).to.have.length(107);
+    (0, _chai.expect)(adapter.getYear(yearRange[yearRange.length - 1])).to.equal(2124);
+    const emptyYearRange = adapter.getYearRange(testDate, adapter.setYear(testDate, adapter.getYear(testDate) - 1));
+    (0, _chai.expect)(emptyYearRange).to.have.length(0);
+  });
+  it('Method: getDiff', () => {
+    (0, _chai.expect)(adapter.getDiff(testDate, adapter.date('2018-10-29T11:44:00.000Z'))).to.equal(86400000);
+    (0, _chai.expect)(adapter.getDiff(testDate, adapter.date('2018-10-31T11:44:00.000Z'))).to.equal(-86400000);
+    (0, _chai.expect)(adapter.getDiff(testDate, '2018-10-31T11:44:00.000Z')).to.equal(-86400000);
+
+    // With units
+    (0, _chai.expect)(adapter.getDiff(testDate, adapter.date('2017-09-29T11:44:00.000Z'), 'years')).to.equal(1);
+    (0, _chai.expect)(adapter.getDiff(testDate, adapter.date('2018-08-29T11:44:00.000Z'), 'months')).to.equal(2);
+    (0, _chai.expect)(adapter.getDiff(testDate, adapter.date('2018-05-29T11:44:00.000Z'), 'quarters')).to.equal(1);
+    (0, _chai.expect)(adapter.getDiff(testDate, adapter.date('2018-09-29T11:44:00.000Z'), 'days')).to.equal(31);
+    (0, _chai.expect)(adapter.getDiff(testDate, adapter.date('2018-09-29T11:44:00.000Z'), 'weeks')).to.equal(4);
+    (0, _chai.expect)(adapter.getDiff(testDate, adapter.date('2018-09-29T11:44:00.000Z'), 'hours')).to.equal(744);
+    (0, _chai.expect)(adapter.getDiff(testDate, adapter.date('2018-09-29T11:44:00.000Z'), 'minutes')).to.equal(44640);
+    (0, _chai.expect)(adapter.getDiff(testDate, adapter.date('2018-10-30T10:44:00.000Z'), 'seconds')).to.equal(3600);
+    (0, _chai.expect)(adapter.getDiff(testDate, adapter.date('2018-10-30T10:44:00.000Z'), 'milliseconds')).to.equal(3600000);
+  });
+  it('Method: mergeDateAndTime', () => {
+    const mergedDate = adapter.mergeDateAndTime(testDate, adapter.date('2018-01-01T14:15:16.000Z'));
+    (0, _chai.expect)(adapter.toJsDate(mergedDate).toISOString()).to.equal('2018-10-30T14:15:16.000Z');
+  });
+  it('Method: isEqual', () => {
+    (0, _chai.expect)(adapter.isEqual(adapter.date(null), null)).to.equal(true);
+    (0, _chai.expect)(adapter.isEqual(testDate, adapter.date(testDateISO))).to.equal(true);
+    (0, _chai.expect)(adapter.isEqual(null, adapter.date(testDateISO))).to.equal(false);
+  });
+  it('Method: parseISO', () => {
+    const parsedDate = adapter.parseISO(testDateISO);
+    const outputtedISO = adapter.toISO(parsedDate);
+    if (adapter.lib === 'date-fns') {
+      // date-fns never suppress useless milliseconds in the end
+      (0, _chai.expect)(outputtedISO).to.equal(testDateISO.replace('.000Z', 'Z'));
+    } else if (adapter.lib === 'luxon') {
+      // luxon does not shorthand +00:00 to Z, which is also valid ISO string
+      (0, _chai.expect)(outputtedISO).to.equal(testDateISO.replace('Z', '+00:00'));
+    } else {
+      (0, _chai.expect)(outputtedISO).to.equal(testDateISO);
+    }
+  });
+  it('Method: parse', () => {
+    const parsedDate = adapter.parse('2018-10-30 11:44:00', formatDateTime);
+    (0, _chai.expect)(adapter.isEqual(parsedDate, testDate)).to.equal(true);
+    (0, _chai.expect)(adapter.parse('', formatDateTime)).to.equal(null);
+
+    // Invalid input
+    const invalidateParsedDate = adapter.parse('99-99-9999', formatDateTime);
+    (0, _chai.expect)(adapter.isValid(invalidateParsedDate)).to.equal(false);
+  });
+  it('Method: isNull', () => {
+    (0, _chai.expect)(adapter.isNull(null)).to.equal(true);
+    (0, _chai.expect)(adapter.isNull(testDate)).to.equal(false);
+  });
+  it('Method: isSameDay', () => {
+    (0, _chai.expect)(adapter.isSameDay(testDate, adapter.date('2018-10-30T00:00:00.000Z'))).to.equal(true);
+    (0, _chai.expect)(adapter.isSameDay(testDate, adapter.date('2019-10-30T00:00:00.000Z'))).to.equal(false);
+  });
+  it('Method: isSameMonth', () => {
+    (0, _chai.expect)(adapter.isSameMonth(testDate, adapter.date('2018-10-01T00:00:00.000Z'))).to.equal(true);
+    (0, _chai.expect)(adapter.isSameMonth(testDate, adapter.date('2019-10-01T00:00:00.000Z'))).to.equal(false);
+  });
+  it('Method: isSameYear', () => {
+    (0, _chai.expect)(adapter.isSameYear(testDate, adapter.date('2018-10-01T00:00:00.000Z'))).to.equal(true);
+    (0, _chai.expect)(adapter.isSameYear(testDate, adapter.date('2019-10-01T00:00:00.000Z'))).to.equal(false);
+  });
+  it('Method: isSameHour', () => {
+    (0, _chai.expect)(adapter.isSameHour(testDate, adapter.date(testDateISO))).to.equal(true);
+    (0, _chai.expect)(adapter.isSameHour(testDate, adapter.addDays(adapter.date(testDateISO), 5))).to.equal(false);
+  });
+  it('Method: getCurrentLocaleCode', () => {
+    // Returns the default location
+    (0, _chai.expect)(adapter.getCurrentLocaleCode()).to.match(/en/);
+  });
+  it('Method: toJsDate', () => {
+    (0, _chai.expect)(adapter.toJsDate(testDate)).to.be.instanceOf(Date);
+  });
+  it('Method: isWithinRange', () => {
+    (0, _chai.expect)(adapter.isWithinRange(adapter.date('2019-10-01T00:00:00.000Z'), [adapter.date('2019-09-01T00:00:00.000Z'), adapter.date('2019-11-01T00:00:00.000Z')])).to.equal(true);
+    (0, _chai.expect)(adapter.isWithinRange(adapter.date('2019-12-01T00:00:00.000Z'), [adapter.date('2019-09-01T00:00:00.000Z'), adapter.date('2019-11-01T00:00:00.000Z')])).to.equal(false);
+
+    // Should use inclusivity of range
+    (0, _chai.expect)(adapter.isWithinRange(adapter.date('2019-09-01T00:00:00.000Z'), [adapter.date('2019-09-01T00:00:00.000Z'), adapter.date('2019-12-01T00:00:00.000Z')])).to.equal(true);
+    (0, _chai.expect)(adapter.isWithinRange(adapter.date('2019-12-01T00:00:00.000Z'), [adapter.date('2019-09-01T00:00:00.000Z'), adapter.date('2019-12-01T00:00:00.000Z')])).to.equal(true);
+  });
+};
+exports.testCalculations = testCalculations;

package/node/tests/describeGregorianAdapter/testFormat.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.testFormat = void 0;
+var _chai = require("chai");
+const testFormat = ({
+  adapter
+}) => {
+  const expectDate = (format, expected) => {
+    const date = adapter.date('2020-01-01T23:44:00.000Z');
+    const result = adapter.format(date, format);
+    (0, _chai.expect)(result).to.equal(expected);
+  };
+  it('should correctly format standalone hardcoded formats', () => {
+    expectDate('normalDate', '1 January');
+    expectDate('normalDateWithWeekday', 'Wed, Jan 1');
+    expectDate('shortDate', 'Jan 1');
+    expectDate('year', '2020');
+    expectDate('month', 'January');
+    expectDate('monthAndDate', 'January 1');
+    expectDate('weekday', 'Wednesday');
+    expectDate('weekdayShort', 'Wed');
+    expectDate('dayOfMonth', '1');
+    expectDate('fullTime12h', '11:44 PM');
+    expectDate('fullTime24h', '23:44');
+    expectDate('hours12h', '11');
+    expectDate('hours24h', '23');
+    expectDate('minutes', '44');
+    expectDate('seconds', '00');
+  });
+};
+exports.testFormat = testFormat;

package/node/tests/describeGregorianAdapter/testLocalization.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.testLocalization = void 0;
+var _chai = require("chai");
+const testLocalization = ({
+  adapter
+}) => {
+  it('Method: formatNumber', () => {
+    (0, _chai.expect)(adapter.formatNumber('1')).to.equal('1');
+  });
+  it('Method: getMeridiemText', () => {
+    (0, _chai.expect)(adapter.getMeridiemText('am')).to.equal('AM');
+    (0, _chai.expect)(adapter.getMeridiemText('pm')).to.equal('PM');
+  });
+  it('Method: getFormatHelperText', () => {
+    (0, _chai.expect)(adapter.getFormatHelperText(adapter.formats.keyboardDate)).to.equal('mm/dd/yyyy');
+    (0, _chai.expect)(adapter.getFormatHelperText(adapter.formats.keyboardDateTime12h)).to.equal('mm/dd/yyyy hh:mm (a|p)m');
+  });
+};
+exports.testLocalization = testLocalization;

package/node/tests/describeValidation/describeValidation.js

@@ -11,9 +11,10 @@ var _testDayViewValidation = require("./testDayViewValidation");
 var _testMonthViewValidation = require("./testMonthViewValidation");
 var _testTextFieldValidation = require("./testTextFieldValidation");
 var _testYearViewValidation = require("./testYearViewValidation");
+var _testMinutesViewValidation = require("./testMinutesViewValidation");
 /* eslint-env mocha */
 
-const TEST_SUITES = [_testYearViewValidation.testYearViewValidation, _testMonthViewValidation.testMonthViewValidation, _testDayViewValidation.testDayViewValidation, _testTextFieldValidation.testTextFieldValidation];
+const TEST_SUITES = [_testYearViewValidation.testYearViewValidation, _testMonthViewValidation.testMonthViewValidation, _testDayViewValidation.testDayViewValidation, _testMinutesViewValidation.testMinutesViewValidation, _testTextFieldValidation.testTextFieldValidation];
 function innerDescribeValidation(ElementToTest, getOptions) {
   const {
     after: runAfterHook = () => {},

package/node/tests/describeValidation/testMinutesViewValidation.js

@@ -0,0 +1,210 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.testMinutesViewValidation = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _chai = require("chai");
+var React = _interopRequireWildcard(require("react"));
+var _utils = require("@mui/monorepo/test/utils");
+var _pickersUtils = require("test/utils/pickers-utils");
+var _jsxRuntime = require("react/jsx-runtime");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+const toMinutesLabel = minutes => `${Number(minutes) < 10 ? `0${minutes}` : minutes} minutes`;
+const testMinutesViewValidation = (ElementToTest, getOption) => {
+  const {
+    componentFamily,
+    views,
+    render,
+    clock,
+    withDate,
+    withTime,
+    variant
+  } = getOption();
+  if (!views.includes('minutes') || !variant || componentFamily !== 'picker' || variant === 'desktop') {
+    return;
+  }
+  describe('minutes view:', () => {
+    const defaultProps = (0, _extends2.default)({
+      onChange: () => {},
+      open: true,
+      view: 'minutes',
+      openTo: 'minutes',
+      reduceAnimations: true
+    }, componentFamily.includes('legacy-') ? {
+      componentsProps: {
+        toolbar: {
+          hidden: true
+        }
+      }
+    } : {
+      slotProps: {
+        toolbar: {
+          hidden: true
+        }
+      }
+    });
+    it('should apply shouldDisableTime', function test() {
+      render( /*#__PURE__*/(0, _jsxRuntime.jsx)(ElementToTest, (0, _extends2.default)({}, defaultProps, {
+        value: _pickersUtils.adapterToUse.date(new Date(2018, 2, 12, 8, 15, 0)),
+        shouldDisableTime: date => _pickersUtils.adapterToUse.isAfter(date, _pickersUtils.adapterToUse.date(new Date(2018, 2, 12, 8, 20, 0)))
+      })));
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel('10')
+      })).not.to.have.attribute('aria-disabled');
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel('15')
+      })).not.to.have.attribute('aria-disabled');
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel('20')
+      })).not.to.have.attribute('aria-disabled');
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel('25')
+      })).to.have.attribute('aria-disabled');
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel('30')
+      })).to.have.attribute('aria-disabled');
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel('55')
+      })).to.have.attribute('aria-disabled');
+    });
+    it('should apply disablePast', function test() {
+      let now;
+      function WithFakeTimer(props) {
+        now = _pickersUtils.adapterToUse.date(new Date());
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(ElementToTest, (0, _extends2.default)({
+          value: now
+        }, props));
+      }
+      const {
+        setProps
+      } = render( /*#__PURE__*/(0, _jsxRuntime.jsx)(WithFakeTimer, (0, _extends2.default)({}, defaultProps, {
+        disablePast: true
+      })));
+      const tomorrow = _pickersUtils.adapterToUse.addDays(now, 1);
+      const currentMinutes = _pickersUtils.adapterToUse.getMinutes(now);
+      const closestNowMinutesOptionValue = Math.floor(currentMinutes / 5) * 5;
+      const previousMinutesOptionValue = Math.floor(currentMinutes / 5) * 5 - 5;
+      const nextMinutesOptionValue = Math.floor(currentMinutes / 5) * 5 + 5;
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel(previousMinutesOptionValue)
+      })).to.have.attribute('aria-disabled');
+      if (currentMinutes <= closestNowMinutesOptionValue) {
+        (0, _chai.expect)(_utils.screen.getByRole('option', {
+          name: toMinutesLabel(closestNowMinutesOptionValue)
+        })).not.to.have.attribute('aria-disabled');
+      } else {
+        (0, _chai.expect)(_utils.screen.getByRole('option', {
+          name: toMinutesLabel(closestNowMinutesOptionValue)
+        })).to.have.attribute('aria-disabled');
+      }
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel(nextMinutesOptionValue)
+      })).not.to.have.attribute('aria-disabled');
+
+      // following validation is relevant only for DateTimePicker
+      if (!withDate || !withTime) {
+        return;
+      }
+      setProps({
+        value: tomorrow
+      });
+      clock.runToLast();
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel(previousMinutesOptionValue)
+      })).not.to.have.attribute('aria-disabled');
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel(closestNowMinutesOptionValue)
+      })).not.to.have.attribute('aria-disabled');
+    });
+    it('should apply disableFuture', function test() {
+      let now;
+      function WithFakeTimer(props) {
+        now = _pickersUtils.adapterToUse.date(new Date());
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(ElementToTest, (0, _extends2.default)({
+          value: now
+        }, props));
+      }
+      const {
+        setProps
+      } = render( /*#__PURE__*/(0, _jsxRuntime.jsx)(WithFakeTimer, (0, _extends2.default)({}, defaultProps, {
+        disableFuture: true
+      })));
+      const yesterday = _pickersUtils.adapterToUse.addDays(now, -1);
+      const currentMinutes = _pickersUtils.adapterToUse.getMinutes(now);
+      const closestNowMinutesOptionValue = Math.floor(currentMinutes / 5) * 5;
+      const previousMinutesOptionValue = Math.floor(currentMinutes / 5) * 5 - 5;
+      const nextMinutesOptionValue = Math.floor(currentMinutes / 5) * 5 + 5;
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel(previousMinutesOptionValue)
+      })).not.to.have.attribute('aria-disabled');
+      if (currentMinutes < closestNowMinutesOptionValue) {
+        (0, _chai.expect)(_utils.screen.getByRole('option', {
+          name: toMinutesLabel(closestNowMinutesOptionValue)
+        })).to.have.attribute('aria-disabled');
+      } else {
+        (0, _chai.expect)(_utils.screen.getByRole('option', {
+          name: toMinutesLabel(closestNowMinutesOptionValue)
+        })).not.to.have.attribute('aria-disabled');
+      }
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel(nextMinutesOptionValue)
+      })).to.have.attribute('aria-disabled');
+
+      // following validation is relevant only for DateTimePicker
+      if (!withDate || !withTime) {
+        return;
+      }
+      setProps({
+        value: yesterday
+      });
+      clock.runToLast();
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel(previousMinutesOptionValue)
+      })).not.to.have.attribute('aria-disabled');
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel(closestNowMinutesOptionValue)
+      })).not.to.have.attribute('aria-disabled');
+    });
+    it('should apply maxTime', function test() {
+      render( /*#__PURE__*/(0, _jsxRuntime.jsx)(ElementToTest, (0, _extends2.default)({}, defaultProps, {
+        value: _pickersUtils.adapterToUse.date(new Date(2019, 5, 15, 11, 15, 0)),
+        maxTime: _pickersUtils.adapterToUse.date(new Date(2019, 5, 15, 11, 20, 0))
+      })));
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel('10')
+      })).not.to.have.attribute('aria-disabled');
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel('15')
+      })).not.to.have.attribute('aria-disabled');
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel('20')
+      })).not.to.have.attribute('aria-disabled');
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel('25')
+      })).to.have.attribute('aria-disabled');
+    });
+    it('should apply minTime', function test() {
+      render( /*#__PURE__*/(0, _jsxRuntime.jsx)(ElementToTest, (0, _extends2.default)({}, defaultProps, {
+        value: _pickersUtils.adapterToUse.date(new Date(2019, 5, 15, 11, 15, 0)),
+        minTime: _pickersUtils.adapterToUse.date(new Date(2019, 5, 15, 11, 10, 0))
+      })));
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel('0')
+      })).to.have.attribute('aria-disabled');
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel('5')
+      })).to.have.attribute('aria-disabled');
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel('10')
+      })).not.to.have.attribute('aria-disabled');
+      (0, _chai.expect)(_utils.screen.getByRole('option', {
+        name: toMinutesLabel('15')
+      })).not.to.have.attribute('aria-disabled');
+    });
+  });
+};
+exports.testMinutesViewValidation = testMinutesViewValidation;

package/node/tests/describeValue/testPickerActionBar.js

@@ -81,7 +81,8 @@ const testPickerActionBar = (ElementToTest, getOptions) => {
             actionBar: {
               actions: ['clear']
             }
-          }
+          },
+          value: emptyValue
         }));
 
         // Clear the date
@@ -101,7 +102,7 @@ const testPickerActionBar = (ElementToTest, getOptions) => {
           onAccept: onAccept,
           onClose: onClose,
           open: true,
-          defaultValue: values[0],
+          value: values[0],
           componentsProps: {
             actionBar: {
               actions: ['cancel']
@@ -137,7 +138,7 @@ const testPickerActionBar = (ElementToTest, getOptions) => {
           onAccept: onAccept,
           onClose: onClose,
           open: true,
-          defaultValue: values[0],
+          value: values[0],
           componentsProps: {
             actionBar: {
               actions: ['cancel']
@@ -183,6 +184,54 @@ const testPickerActionBar = (ElementToTest, getOptions) => {
         (0, _chai.expect)(onAccept.callCount).to.equal(1);
         (0, _chai.expect)(onClose.callCount).to.equal(1);
       });
+      it('should call onChange, onClose and onAccept when validating the default value', () => {
+        const onChange = (0, _sinon.spy)();
+        const onAccept = (0, _sinon.spy)();
+        const onClose = (0, _sinon.spy)();
+        render( /*#__PURE__*/(0, _jsxRuntime.jsx)(ElementToTest, {
+          onChange: onChange,
+          onAccept: onAccept,
+          onClose: onClose,
+          open: true,
+          defaultValue: values[0],
+          componentsProps: {
+            actionBar: {
+              actions: ['accept']
+            }
+          },
+          closeOnSelect: false
+        }));
+
+        // Accept the modifications
+        _utils.userEvent.mousePress(_utils.screen.getByText(/ok/i));
+        (0, _chai.expect)(onChange.callCount).to.equal(1);
+        (0, _chai.expect)(onAccept.callCount).to.equal(1);
+        (0, _chai.expect)(onClose.callCount).to.equal(1);
+      });
+      it('should call onClose but not onAccept when validating an already validated value', () => {
+        const onChange = (0, _sinon.spy)();
+        const onAccept = (0, _sinon.spy)();
+        const onClose = (0, _sinon.spy)();
+        render( /*#__PURE__*/(0, _jsxRuntime.jsx)(ElementToTest, {
+          onChange: onChange,
+          onAccept: onAccept,
+          onClose: onClose,
+          open: true,
+          value: values[0],
+          componentsProps: {
+            actionBar: {
+              actions: ['accept']
+            }
+          },
+          closeOnSelect: false
+        }));
+
+        // Accept the modifications
+        _utils.userEvent.mousePress(_utils.screen.getByText(/ok/i));
+        (0, _chai.expect)(onChange.callCount).to.equal(0);
+        (0, _chai.expect)(onAccept.callCount).to.equal(0);
+        (0, _chai.expect)(onClose.callCount).to.equal(1);
+      });
     });
   });
 };