803 lines
26 KiB
JavaScript
803 lines
26 KiB
JavaScript
describe('options - date restrictions', function () {
|
|
const getDisabled = cells => filterCells(cells, '.disabled').map(el => [el, el.textContent]);
|
|
let input;
|
|
|
|
beforeEach(function () {
|
|
input = document.createElement('input');
|
|
testContainer.appendChild(input);
|
|
});
|
|
|
|
afterEach(function () {
|
|
testContainer.removeChild(input);
|
|
});
|
|
|
|
describe('datesDisabled', function () {
|
|
let clock;
|
|
|
|
beforeEach(function () {
|
|
clock = sinon.useFakeTimers({now: new Date(2020, 1, 14)});
|
|
});
|
|
|
|
afterEach(function () {
|
|
clock.restore();
|
|
});
|
|
|
|
it('specifies unselectable dates', function () {
|
|
const dp = new Datepicker(input, {
|
|
datesDisabled: [new Date(2020, 1, 12), '2/13/2020', new Date(2020, 1, 13), '2/20/2020'],
|
|
});
|
|
const picker = document.querySelector('.datepicker');
|
|
dp.show();
|
|
|
|
expect(picker.querySelector('.prev-btn').disabled, 'to be false');
|
|
expect(picker.querySelector('.next-btn').disabled, 'to be false');
|
|
|
|
let cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', [
|
|
[cells[17], '12'],
|
|
[cells[18], '13'],
|
|
[cells[25], '20'],
|
|
]);
|
|
|
|
cells[17].click();
|
|
expect(dp.dates, 'to equal', []);
|
|
expect(input.value, 'to be', '');
|
|
expect(filterCells(cells, '.selected'), 'to equal', []);
|
|
|
|
dp.setDate(new Date(2020, 1, 12));
|
|
expect(dp.dates, 'to equal', []);
|
|
expect(input.value, 'to be', '');
|
|
expect(filterCells(cells, '.selected'), 'to equal', []);
|
|
|
|
input.value = '2/12/2020';
|
|
dp.update();
|
|
expect(dp.dates, 'to equal', []);
|
|
expect(input.value, 'to be', '2/12/2020');
|
|
expect(filterCells(cells, '.selected'), 'to equal', []);
|
|
|
|
cells[16].click();
|
|
expect(dp.dates, 'to equal', [dateValue(2020, 1, 11)]);
|
|
expect(input.value, 'to be', '02/11/2020');
|
|
expect(filterCells(cells, '.selected'), 'to equal', [cells[16]]);
|
|
|
|
dp.enterEditMode();
|
|
input.value = '2/12/2020';
|
|
simulant.fire(input, 'keydown', {key: 'Enter'});
|
|
expect(dp.dates, 'to equal', [dateValue(2020, 1, 11)]);
|
|
expect(input.value, 'to be', '2/12/2020');
|
|
expect(filterCells(cells, '.selected'), 'to equal', [cells[16]]);
|
|
|
|
dp.destroy();
|
|
});
|
|
|
|
it('makes the picker prevent those dates becoming view date', function () {
|
|
const dp = new Datepicker(input, {
|
|
datesDisabled: ['2/11/2020', '2/12/2020', '2/13/2020', '2/20/2020'],
|
|
});
|
|
const picker = document.querySelector('.datepicker');
|
|
const cells = getCells(picker);
|
|
dp.show();
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[15]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight'});
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
// on 5th
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
// on 27th
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[24]]);
|
|
|
|
// on 19th
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[15]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight'});
|
|
// on 4th
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
|
|
|
|
dp.destroy();
|
|
});
|
|
|
|
it('can be updated with setOptions()', function () {
|
|
const {dp, picker} = createDP(input);
|
|
dp.setOptions({datesDisabled: [new Date(2020, 1, 11), new Date(2020, 1, 26)]});
|
|
dp.show();
|
|
|
|
let cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', [
|
|
[cells[16], '11'],
|
|
[cells[31], '26'],
|
|
]);
|
|
|
|
dp.setOptions({datesDisabled: []});
|
|
|
|
cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', []);
|
|
|
|
dp.destroy();
|
|
});
|
|
});
|
|
|
|
describe('daysOfWeekDisabled', function () {
|
|
let clock;
|
|
|
|
beforeEach(function () {
|
|
clock = sinon.useFakeTimers({now: new Date(2020, 1, 14)});
|
|
});
|
|
|
|
afterEach(function () {
|
|
clock.restore();
|
|
});
|
|
|
|
it('specifies unselectable days of week', function () {
|
|
const {dp, picker} = createDP(input, {daysOfWeekDisabled: [0, 6]});
|
|
dp.show();
|
|
|
|
expect(picker.querySelector('.prev-btn').disabled, 'to be false');
|
|
expect(picker.querySelector('.next-btn').disabled, 'to be false');
|
|
|
|
let cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', [
|
|
[cells[0], '26'],
|
|
[cells[6], '1'],
|
|
[cells[7], '2'],
|
|
[cells[13], '8'],
|
|
[cells[14], '9'],
|
|
[cells[20], '15'],
|
|
[cells[21], '16'],
|
|
[cells[27], '22'],
|
|
[cells[28], '23'],
|
|
[cells[34], '29'],
|
|
[cells[35], '1'],
|
|
[cells[41], '7'],
|
|
]);
|
|
|
|
cells[14].click();
|
|
expect(dp.dates, 'to equal', []);
|
|
expect(input.value, 'to be', '');
|
|
expect(filterCells(cells, '.selected'), 'to equal', []);
|
|
|
|
dp.setDate(new Date(2020, 1, 9));
|
|
expect(dp.dates, 'to equal', []);
|
|
expect(input.value, 'to be', '');
|
|
expect(filterCells(cells, '.selected'), 'to equal', []);
|
|
|
|
input.value = '2/9/2020';
|
|
dp.update();
|
|
expect(dp.dates, 'to equal', []);
|
|
expect(input.value, 'to be', '2/9/2020');
|
|
expect(filterCells(cells, '.selected'), 'to equal', []);
|
|
|
|
cells[15].click();
|
|
expect(dp.dates, 'to equal', [dateValue(2020, 1, 10)]);
|
|
expect(input.value, 'to be', '02/10/2020');
|
|
expect(filterCells(cells, '.selected'), 'to equal', [cells[15]]);
|
|
|
|
dp.enterEditMode();
|
|
input.value = '2/9/2020';
|
|
simulant.fire(input, 'keydown', {key: 'Enter'});
|
|
expect(dp.dates, 'to equal', [dateValue(2020, 1, 10)]);
|
|
expect(input.value, 'to be', '2/9/2020');
|
|
expect(filterCells(cells, '.selected'), 'to equal', [cells[15]]);
|
|
|
|
dp.destroy();
|
|
});
|
|
|
|
it('makes the picker prevent those dates becoming view date', function () {
|
|
const {dp, picker} = createDP(input, {daysOfWeekDisabled: [0, 6]});
|
|
const cells = getCells(picker);
|
|
dp.show();
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight'});
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[22]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
// on 7th
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight'});
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[15]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[12]]);
|
|
|
|
dp.destroy();
|
|
});
|
|
|
|
it('can be updated with setOptions()', function () {
|
|
const {dp, picker} = createDP(input);
|
|
dp.setOptions({daysOfWeekDisabled: [4]});
|
|
dp.show();
|
|
|
|
let cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', [
|
|
[cells[4], '30'],
|
|
[cells[11], '6'],
|
|
[cells[18], '13'],
|
|
[cells[25], '20'],
|
|
[cells[32], '27'],
|
|
[cells[39], '5'],
|
|
]);
|
|
|
|
dp.setOptions({daysOfWeekDisabled: []});
|
|
|
|
cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', []);
|
|
|
|
dp.destroy();
|
|
});
|
|
});
|
|
|
|
describe('maxDate', function () {
|
|
let clock;
|
|
|
|
beforeEach(function () {
|
|
clock = sinon.useFakeTimers({now: new Date(2020, 1, 14)});
|
|
});
|
|
|
|
afterEach(function () {
|
|
clock.restore();
|
|
});
|
|
|
|
it('specifies the maximum selectable date', function () {
|
|
const {dp, picker} = createDP(input, {maxDate: new Date(2020, 1, 25)});
|
|
const viewSwitch = getViewSwitch(picker);
|
|
dp.show();
|
|
|
|
let cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', [
|
|
[cells[31], '26'],
|
|
[cells[32], '27'],
|
|
[cells[33], '28'],
|
|
[cells[34], '29'],
|
|
[cells[35], '1'],
|
|
[cells[36], '2'],
|
|
[cells[37], '3'],
|
|
[cells[38], '4'],
|
|
[cells[39], '5'],
|
|
[cells[40], '6'],
|
|
[cells[41], '7'],
|
|
]);
|
|
|
|
viewSwitch.click();
|
|
cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', [
|
|
[cells[2], 'Mar'],
|
|
[cells[3], 'Apr'],
|
|
[cells[4], 'May'],
|
|
[cells[5], 'Jun'],
|
|
[cells[6], 'Jul'],
|
|
[cells[7], 'Aug'],
|
|
[cells[8], 'Sep'],
|
|
[cells[9], 'Oct'],
|
|
[cells[10], 'Nov'],
|
|
[cells[11], 'Dec'],
|
|
]);
|
|
|
|
viewSwitch.click();
|
|
cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', [
|
|
[cells[2], '2021'],
|
|
[cells[3], '2022'],
|
|
[cells[4], '2023'],
|
|
[cells[5], '2024'],
|
|
[cells[6], '2025'],
|
|
[cells[7], '2026'],
|
|
[cells[8], '2027'],
|
|
[cells[9], '2028'],
|
|
[cells[10], '2029'],
|
|
[cells[11], '2030'],
|
|
]);
|
|
|
|
viewSwitch.click();
|
|
cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', [
|
|
[cells[4], '2030'],
|
|
[cells[5], '2040'],
|
|
[cells[6], '2050'],
|
|
[cells[7], '2060'],
|
|
[cells[8], '2070'],
|
|
[cells[9], '2080'],
|
|
[cells[10], '2090'],
|
|
[cells[11], '2100'],
|
|
]);
|
|
|
|
dp.hide();
|
|
dp.show();
|
|
cells = getCells(picker);
|
|
|
|
cells[31].click();
|
|
expect(dp.dates, 'to equal', []);
|
|
expect(input.value, 'to be', '');
|
|
expect(filterCells(cells, '.selected'), 'to equal', []);
|
|
|
|
dp.setDate(new Date(2020, 1, 26));
|
|
expect(dp.dates, 'to equal', []);
|
|
expect(input.value, 'to be', '');
|
|
expect(filterCells(cells, '.selected'), 'to equal', []);
|
|
|
|
input.value = '2/26/2020';
|
|
dp.update();
|
|
expect(dp.dates, 'to equal', []);
|
|
expect(input.value, 'to be', '2/26/2020');
|
|
expect(filterCells(cells, '.selected'), 'to equal', []);
|
|
|
|
cells[30].click();
|
|
expect(dp.dates, 'to equal', [dateValue(2020, 1, 25)]);
|
|
expect(input.value, 'to be', '02/25/2020');
|
|
expect(filterCells(cells, '.selected'), 'to equal', [cells[30]]);
|
|
|
|
dp.enterEditMode();
|
|
input.value = '2/26/2020';
|
|
simulant.fire(input, 'keydown', {key: 'Enter'});
|
|
expect(dp.dates, 'to equal', [dateValue(2020, 1, 25)]);
|
|
expect(input.value, 'to be', '2/26/2020');
|
|
expect(filterCells(cells, '.selected'), 'to equal', [cells[30]]);
|
|
|
|
dp.destroy();
|
|
});
|
|
|
|
it('makes the picker disallow to navigate to after the max date', function () {
|
|
const {dp, picker} = createDP(input, {maxDate: '2/14/2020'});
|
|
const [viewSwitch, prevBtn, nextBtn] = getParts(picker, ['.view-switch', '.prev-btn', '.next-btn']);
|
|
dp.show();
|
|
|
|
expect(prevBtn.disabled, 'to be false');
|
|
expect(nextBtn.disabled, 'to be true');
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight'});
|
|
let cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight', ctrlKey: true});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[13]]);
|
|
|
|
prevBtn.click();
|
|
expect(prevBtn.disabled, 'to be false');
|
|
expect(nextBtn.disabled, 'to be false');
|
|
|
|
// move to Jan 22nd
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
nextBtn.click();
|
|
|
|
// view date is limited to the max date
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
|
|
|
|
// the same goes for ctrl + ArrowRight key
|
|
prevBtn.click();
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight', ctrlKey: true});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
|
|
|
|
// months view
|
|
viewSwitch.click();
|
|
expect(prevBtn.disabled, 'to be false');
|
|
expect(nextBtn.disabled, 'to be true');
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight'});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[1]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight'});
|
|
// on prev year's Nov
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[10]]);
|
|
|
|
prevBtn.click();
|
|
expect(prevBtn.disabled, 'to be false');
|
|
expect(nextBtn.disabled, 'to be false');
|
|
|
|
// move to Mar
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
nextBtn.click();
|
|
|
|
// view date is limited to the Feb
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[1]]);
|
|
|
|
// the same goes for ctrl + ArrowRight key
|
|
prevBtn.click();
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight', ctrlKey: true});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[1]]);
|
|
|
|
// years view
|
|
viewSwitch.click();
|
|
expect(prevBtn.disabled, 'to be false');
|
|
expect(nextBtn.disabled, 'to be true');
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight'});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[1]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight'});
|
|
// on 2017
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[8]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
|
|
prevBtn.click();
|
|
expect(prevBtn.disabled, 'to be false');
|
|
expect(nextBtn.disabled, 'to be false');
|
|
|
|
// move to 2011
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight'});
|
|
nextBtn.click();
|
|
|
|
// view year is limited to 2020
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[1]]);
|
|
|
|
// the same goes for ctrl + ArrowRight key
|
|
prevBtn.click();
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight', ctrlKey: true});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[1]]);
|
|
|
|
// decades view
|
|
viewSwitch.click();
|
|
expect(prevBtn.disabled, 'to be false');
|
|
expect(nextBtn.disabled, 'to be true');
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight'});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[3]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight'});
|
|
// on 1990
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[10]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
|
|
prevBtn.click();
|
|
expect(prevBtn.disabled, 'to be false');
|
|
expect(nextBtn.disabled, 'to be false');
|
|
|
|
// move to 1930
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight'});
|
|
nextBtn.click();
|
|
|
|
// view decade is limited to 2020
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[3]]);
|
|
|
|
// the same goes for ctrl + ArrowRight key
|
|
prevBtn.click();
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight', ctrlKey: true});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[3]]);
|
|
|
|
dp.destroy();
|
|
});
|
|
|
|
it('can be updated with setOptions()', function () {
|
|
const {dp, picker} = createDP(input);
|
|
dp.setOptions({maxDate: new Date(2020, 1, 28)});
|
|
dp.show();
|
|
|
|
let cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', [
|
|
[cells[34], '29'],
|
|
[cells[35], '1'],
|
|
[cells[36], '2'],
|
|
[cells[37], '3'],
|
|
[cells[38], '4'],
|
|
[cells[39], '5'],
|
|
[cells[40], '6'],
|
|
[cells[41], '7'],
|
|
]);
|
|
|
|
dp.setOptions({maxDate: null});
|
|
|
|
cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', []);
|
|
|
|
dp.destroy();
|
|
});
|
|
});
|
|
|
|
describe('minDate', function () {
|
|
let clock;
|
|
|
|
beforeEach(function () {
|
|
clock = sinon.useFakeTimers({now: new Date(2022, 6, 14)});
|
|
});
|
|
|
|
afterEach(function () {
|
|
clock.restore();
|
|
});
|
|
|
|
it('specifies the minimum selectable date', function () {
|
|
const {dp, picker} = createDP(input, {minDate: new Date(2022, 6, 4)});
|
|
const viewSwitch = getViewSwitch(picker);
|
|
dp.show();
|
|
|
|
let cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', [
|
|
[cells[0], '26'],
|
|
[cells[1], '27'],
|
|
[cells[2], '28'],
|
|
[cells[3], '29'],
|
|
[cells[4], '30'],
|
|
[cells[5], '1'],
|
|
[cells[6], '2'],
|
|
[cells[7], '3'],
|
|
]);
|
|
|
|
viewSwitch.click();
|
|
cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', [
|
|
[cells[0], 'Jan'],
|
|
[cells[1], 'Feb'],
|
|
[cells[2], 'Mar'],
|
|
[cells[3], 'Apr'],
|
|
[cells[4], 'May'],
|
|
[cells[5], 'Jun'],
|
|
]);
|
|
|
|
viewSwitch.click();
|
|
cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', [
|
|
[cells[0], '2019'],
|
|
[cells[1], '2020'],
|
|
[cells[2], '2021'],
|
|
]);
|
|
|
|
viewSwitch.click();
|
|
cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', [
|
|
[cells[0], '1990'],
|
|
[cells[1], '2000'],
|
|
[cells[2], '2010'],
|
|
]);
|
|
|
|
dp.hide();
|
|
dp.show();
|
|
cells = getCells(picker);
|
|
|
|
cells[7].click();
|
|
expect(dp.dates, 'to equal', []);
|
|
expect(input.value, 'to be', '');
|
|
expect(filterCells(cells, '.selected'), 'to equal', []);
|
|
|
|
dp.setDate(new Date(2022, 6, 3));
|
|
expect(dp.dates, 'to equal', []);
|
|
expect(input.value, 'to be', '');
|
|
expect(filterCells(cells, '.selected'), 'to equal', []);
|
|
|
|
input.value = '7/3/2022';
|
|
dp.update();
|
|
expect(dp.dates, 'to equal', []);
|
|
expect(input.value, 'to be', '7/3/2022');
|
|
expect(filterCells(cells, '.selected'), 'to equal', []);
|
|
|
|
cells[8].click();
|
|
expect(dp.dates, 'to equal', [dateValue(2022, 6, 4)]);
|
|
expect(input.value, 'to be', '07/04/2022');
|
|
expect(filterCells(cells, '.selected'), 'to equal', [cells[8]]);
|
|
|
|
dp.enterEditMode();
|
|
input.value = '7/3/2022';
|
|
simulant.fire(input, 'keydown', {key: 'Enter'});
|
|
expect(dp.dates, 'to equal', [dateValue(2022, 6, 4)]);
|
|
expect(input.value, 'to be', '7/3/2022');
|
|
expect(filterCells(cells, '.selected'), 'to equal', [cells[8]]);
|
|
|
|
dp.destroy();
|
|
});
|
|
|
|
it('makes the picker disallow to navigate to before the min date', function () {
|
|
const {dp, picker} = createDP(input, {minDate: '7/14/2022'});
|
|
const [viewSwitch, prevBtn, nextBtn] = getParts(picker, ['.view-switch', '.prev-btn', '.next-btn']);
|
|
dp.show();
|
|
|
|
expect(prevBtn.disabled, 'to be true');
|
|
expect(nextBtn.disabled, 'to be false');
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
let cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[18]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft', ctrlKey: true});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[18]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[24]]);
|
|
|
|
nextBtn.click();
|
|
expect(prevBtn.disabled, 'to be false');
|
|
expect(nextBtn.disabled, 'to be false');
|
|
|
|
// move to Aug 13th
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
prevBtn.click();
|
|
|
|
// view date is limited to min date
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[18]]);
|
|
|
|
// the same goes for ctrl + ArrowLeft key
|
|
prevBtn.click();
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft', ctrlKey: true});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[18]]);
|
|
|
|
// months view
|
|
viewSwitch.click();
|
|
expect(prevBtn.disabled, 'to be true');
|
|
expect(nextBtn.disabled, 'to be false');
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[6]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
// on Oct
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[9]]);
|
|
|
|
nextBtn.click();
|
|
expect(prevBtn.disabled, 'to be false');
|
|
expect(nextBtn.disabled, 'to be false');
|
|
|
|
// move to Jun
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
prevBtn.click();
|
|
|
|
// view date is limited to Jul
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[6]]);
|
|
|
|
// the same goes for ctrl + ArrowLeft key
|
|
prevBtn.click();
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft', ctrlKey: true});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[6]]);
|
|
|
|
// years view
|
|
viewSwitch.click();
|
|
expect(prevBtn.disabled, 'to be true');
|
|
expect(nextBtn.disabled, 'to be false');
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[3]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
// on 2025
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[6]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
|
|
nextBtn.click();
|
|
expect(prevBtn.disabled, 'to be false');
|
|
expect(nextBtn.disabled, 'to be false');
|
|
|
|
// move to 2031
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
prevBtn.click();
|
|
|
|
// view year is limited to 2022
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[3]]);
|
|
|
|
// the same goes for ctrl + ArrowLeft key
|
|
prevBtn.click();
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft', ctrlKey: true});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[3]]);
|
|
|
|
// decades view
|
|
viewSwitch.click();
|
|
expect(prevBtn.disabled, 'to be true');
|
|
expect(nextBtn.disabled, 'to be false');
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[3]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowDown'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
// on 2050
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[6]]);
|
|
|
|
simulant.fire(input, 'keydown', {key: 'ArrowRight'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
|
|
nextBtn.click();
|
|
expect(prevBtn.disabled, 'to be false');
|
|
expect(nextBtn.disabled, 'to be false');
|
|
|
|
// move to 2110
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
|
|
prevBtn.click();
|
|
|
|
// view decade is limited to 2020
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[3]]);
|
|
|
|
// the same goes for ctrl + ArrowLeft key
|
|
prevBtn.click();
|
|
simulant.fire(input, 'keydown', {key: 'ArrowUp'});
|
|
simulant.fire(input, 'keydown', {key: 'ArrowLeft', ctrlKey: true});
|
|
cells = getCells(picker);
|
|
expect(filterCells(cells, '.focused'), 'to equal', [cells[3]]);
|
|
|
|
dp.destroy();
|
|
});
|
|
|
|
it('can be updated with setOptions()', function () {
|
|
const {dp, picker} = createDP(input);
|
|
dp.setOptions({minDate: new Date(2022, 6, 2)});
|
|
dp.show();
|
|
|
|
let cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', [
|
|
[cells[0], '26'],
|
|
[cells[1], '27'],
|
|
[cells[2], '28'],
|
|
[cells[3], '29'],
|
|
[cells[4], '30'],
|
|
[cells[5], '1'],
|
|
]);
|
|
|
|
dp.setOptions({minDate: null});
|
|
|
|
cells = getCells(picker);
|
|
expect(getDisabled(cells), 'to equal', []);
|
|
|
|
dp.destroy();
|
|
});
|
|
});
|
|
});
|