@lion/ui 0.22.0 → 0.24.0

package/components/calendar/test/utils/createMonth.test.js

@@ -15,48 +15,87 @@ function compareMonth(obj) {
   });
   return obj;
 }
-
 describe('createMonth', () => {
   it('creates month data with Sunday as first day of week by default', () => {
     expect(compareMonth(createMonth(new Date('2018/12/01')))).to.deep.equal(
       compareMonth({
         weeks: [
-          createWeek(new Date('2018/11/25'), { firstDayOfWeek: 0 }),
-          createWeek(new Date('2018/12/02'), { firstDayOfWeek: 0 }),
-          createWeek(new Date('2018/12/09'), { firstDayOfWeek: 0 }),
-          createWeek(new Date('2018/12/16'), { firstDayOfWeek: 0 }),
-          createWeek(new Date('2018/12/23'), { firstDayOfWeek: 0 }),
-          createWeek(new Date('2018/12/30'), { firstDayOfWeek: 0 }),
+          createWeek(new Date('2018/11/25'), {
+            firstDayOfWeek: 0,
+          }),
+          createWeek(new Date('2018/12/02'), {
+            firstDayOfWeek: 0,
+          }),
+          createWeek(new Date('2018/12/09'), {
+            firstDayOfWeek: 0,
+          }),
+          createWeek(new Date('2018/12/16'), {
+            firstDayOfWeek: 0,
+          }),
+          createWeek(new Date('2018/12/23'), {
+            firstDayOfWeek: 0,
+          }),
+          createWeek(new Date('2018/12/30'), {
+            firstDayOfWeek: 0,
+          }),
         ],
       }),
     );
   });
-
   it('can create month data for different first day of week', () => {
-    expect(compareMonth(createMonth(new Date('2018/12/01'), { firstDayOfWeek: 1 }))).to.deep.equal(
+    expect(
+      compareMonth(
+        createMonth(new Date('2018/12/01'), {
+          firstDayOfWeek: 1,
+        }),
+      ),
+    ).to.deep.equal(
       compareMonth({
         weeks: [
-          createWeek(new Date('2018/11/26'), { firstDayOfWeek: 1 }),
-          createWeek(new Date('2018/12/03'), { firstDayOfWeek: 1 }),
-          createWeek(new Date('2018/12/10'), { firstDayOfWeek: 1 }),
-          createWeek(new Date('2018/12/17'), { firstDayOfWeek: 1 }),
-          createWeek(new Date('2018/12/24'), { firstDayOfWeek: 1 }),
-          createWeek(new Date('2018/12/31'), { firstDayOfWeek: 1 }),
+          createWeek(new Date('2018/11/26'), {
+            firstDayOfWeek: 1,
+          }),
+          createWeek(new Date('2018/12/03'), {
+            firstDayOfWeek: 1,
+          }),
+          createWeek(new Date('2018/12/10'), {
+            firstDayOfWeek: 1,
+          }),
+          createWeek(new Date('2018/12/17'), {
+            firstDayOfWeek: 1,
+          }),
+          createWeek(new Date('2018/12/24'), {
+            firstDayOfWeek: 1,
+          }),
+          createWeek(new Date('2018/12/31'), {
+            firstDayOfWeek: 1,
+          }),
         ],
       }),
     );
   });
-
   it('creates exactly 6 weeks in every months', () => {
     expect(compareMonth(createMonth(new Date('2026/02/12')))).to.deep.equal(
       compareMonth({
         weeks: [
-          createWeek(new Date('2026/02/01'), { firstDayOfWeek: 0 }),
-          createWeek(new Date('2026/02/08'), { firstDayOfWeek: 0 }),
-          createWeek(new Date('2026/02/15'), { firstDayOfWeek: 0 }),
-          createWeek(new Date('2026/02/22'), { firstDayOfWeek: 0 }),
-          createWeek(new Date('2026/03/01'), { firstDayOfWeek: 0 }),
-          createWeek(new Date('2026/03/08'), { firstDayOfWeek: 0 }),
+          createWeek(new Date('2026/02/01'), {
+            firstDayOfWeek: 0,
+          }),
+          createWeek(new Date('2026/02/08'), {
+            firstDayOfWeek: 0,
+          }),
+          createWeek(new Date('2026/02/15'), {
+            firstDayOfWeek: 0,
+          }),
+          createWeek(new Date('2026/02/22'), {
+            firstDayOfWeek: 0,
+          }),
+          createWeek(new Date('2026/03/01'), {
+            firstDayOfWeek: 0,
+          }),
+          createWeek(new Date('2026/03/08'), {
+            firstDayOfWeek: 0,
+          }),
         ],
       }),
     );

package/components/calendar/test/utils/createMultipleMonth.test.js

@@ -18,7 +18,6 @@ function compareMultipleMonth(obj) {
   });
   return obj;
 }
-
 describe('createMultipleMonth', () => {
   it('creates 1 month by default', () => {
     expect(compareMultipleMonth(createMultipleMonth(new Date('2018/12/01')))).to.deep.equal(
@@ -27,10 +26,13 @@ describe('createMultipleMonth', () => {
       }),
     );
   });
-
   it('can create extra months in the past', () => {
     expect(
-      compareMultipleMonth(createMultipleMonth(new Date('2018/12/01'), { pastMonths: 2 })),
+      compareMultipleMonth(
+        createMultipleMonth(new Date('2018/12/01'), {
+          pastMonths: 2,
+        }),
+      ),
     ).to.deep.equal(
       compareMultipleMonth({
         months: [
@@ -41,10 +43,13 @@ describe('createMultipleMonth', () => {
       }),
     );
   });
-
   it('can create extra months in the future', () => {
     expect(
-      compareMultipleMonth(createMultipleMonth(new Date('2018/12/01'), { futureMonths: 2 })),
+      compareMultipleMonth(
+        createMultipleMonth(new Date('2018/12/01'), {
+          futureMonths: 2,
+        }),
+      ),
     ).to.deep.equal(
       compareMultipleMonth({
         months: [
@@ -55,11 +60,13 @@ describe('createMultipleMonth', () => {
       }),
     );
   });
-
   it('can create extra months in the past and future', () => {
     expect(
       compareMultipleMonth(
-        createMultipleMonth(new Date('2018/12/01'), { pastMonths: 1, futureMonths: 1 }),
+        createMultipleMonth(new Date('2018/12/01'), {
+          pastMonths: 1,
+          futureMonths: 1,
+        }),
       ),
     ).to.deep.equal(
       compareMultipleMonth({

package/components/calendar/test/utils/createWeek.test.js

@@ -13,37 +13,71 @@ function compareWeek(obj) {
   }
   return obj;
 }
-
 describe('createWeek', () => {
   it('creates week data starting from Sunday by default', () => {
     // https://www.timeanddate.com/date/weeknumber.html?d1=30&m1=12&y1=2018&w2=&y2=&wncm=1&wncd=1&wncs=4&fdow=7
     expect(compareWeek(createWeek(new Date('2018/12/30')))).to.deep.equal(
       compareWeek({
         days: [
-          createDay(new Date('2018/12/30'), { weekOrder: 0, startOfWeek: true }),
-          createDay(new Date('2018/12/31'), { weekOrder: 1 }),
-          createDay(new Date('2019/01/01'), { weekOrder: 2 }),
-          createDay(new Date('2019/01/02'), { weekOrder: 3 }),
-          createDay(new Date('2019/01/03'), { weekOrder: 4 }),
-          createDay(new Date('2019/01/04'), { weekOrder: 5 }),
-          createDay(new Date('2019/01/05'), { weekOrder: 6 }),
+          createDay(new Date('2018/12/30'), {
+            weekOrder: 0,
+            startOfWeek: true,
+          }),
+          createDay(new Date('2018/12/31'), {
+            weekOrder: 1,
+          }),
+          createDay(new Date('2019/01/01'), {
+            weekOrder: 2,
+          }),
+          createDay(new Date('2019/01/02'), {
+            weekOrder: 3,
+          }),
+          createDay(new Date('2019/01/03'), {
+            weekOrder: 4,
+          }),
+          createDay(new Date('2019/01/04'), {
+            weekOrder: 5,
+          }),
+          createDay(new Date('2019/01/05'), {
+            weekOrder: 6,
+          }),
         ],
       }),
     );
   });
-
   it('can create week data starting from different day', () => {
     // https://www.timeanddate.com/date/weeknumber.html?d1=31&m1=12&y1=2018&w2=&y2=&wncm=1&wncd=1&wncs=4&fdow=0
-    expect(compareWeek(createWeek(new Date('2018/12/31'), { firstDayOfWeek: 1 }))).to.deep.equal(
+    expect(
+      compareWeek(
+        createWeek(new Date('2018/12/31'), {
+          firstDayOfWeek: 1,
+        }),
+      ),
+    ).to.deep.equal(
       compareWeek({
         days: [
-          createDay(new Date('2018/12/31'), { weekOrder: 0, startOfWeek: true }),
-          createDay(new Date('2019/01/01'), { weekOrder: 1 }),
-          createDay(new Date('2019/01/02'), { weekOrder: 2 }),
-          createDay(new Date('2019/01/03'), { weekOrder: 3 }),
-          createDay(new Date('2019/01/04'), { weekOrder: 4 }),
-          createDay(new Date('2019/01/05'), { weekOrder: 5 }),
-          createDay(new Date('2019/01/06'), { weekOrder: 6 }),
+          createDay(new Date('2018/12/31'), {
+            weekOrder: 0,
+            startOfWeek: true,
+          }),
+          createDay(new Date('2019/01/01'), {
+            weekOrder: 1,
+          }),
+          createDay(new Date('2019/01/02'), {
+            weekOrder: 2,
+          }),
+          createDay(new Date('2019/01/03'), {
+            weekOrder: 3,
+          }),
+          createDay(new Date('2019/01/04'), {
+            weekOrder: 4,
+          }),
+          createDay(new Date('2019/01/05'), {
+            weekOrder: 5,
+          }),
+          createDay(new Date('2019/01/06'), {
+            weekOrder: 6,
+          }),
         ],
       }),
     );

package/components/calendar/test/utils/dataTemplate.test.js

@@ -1,24 +1,23 @@
 /* eslint-disable no-unused-expressions */
 import { expect, fixture } from '@open-wc/testing';
-
 import { weekdayNames } from '@lion/ui/calendar-test-helpers.js';
 import { createMultipleMonth } from '../../src/utils/createMultipleMonth.js';
 import { dataTemplate } from '../../src/utils/dataTemplate.js';
 
 // eslint-disable-next-line camelcase
 import snapshot_enGB_Sunday_201812 from './snapshots/monthTemplate_en-GB_Sunday_2018-12.js';
-
 describe('dataTemplate', () => {
   it('renders one month table', async () => {
     const date = new Date('2018/12/01');
-    const month = createMultipleMonth(date, { firstDayOfWeek: 0 });
+    const month = createMultipleMonth(date, {
+      firstDayOfWeek: 0,
+    });
     const el = await fixture(
       dataTemplate(month, {
         weekdaysShort: weekdayNames['en-GB'].Sunday.short,
         weekdays: weekdayNames['en-GB'].Sunday.long,
       }),
     );
-
     expect(el).dom.to.equal(snapshot_enGB_Sunday_201812);
   });
 });

package/components/calendar/test/utils/dayTemplate.test.js

@@ -2,13 +2,17 @@
 import { expect, fixture } from '@open-wc/testing';
 import { createDay } from '../../src/utils/createDay.js';
 import { dayTemplate } from '../../src/utils/dayTemplate.js';
-
 const weekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
-
 describe('dayTemplate', () => {
   it('renders day cell', async () => {
-    const day = createDay(new Date('2019/04/19'), { weekOrder: 5 });
-    const el = await fixture(dayTemplate(day, { weekdays }));
+    const day = createDay(new Date('2019/04/19'), {
+      weekOrder: 5,
+    });
+    const el = await fixture(
+      dayTemplate(day, {
+        weekdays,
+      }),
+    );
     expect(el).dom.to.equal(`
       <td role="gridcell" class="calendar__day-cell">
         <div
@@ -26,61 +30,129 @@ describe('dayTemplate', () => {
       </td>
     `);
   });
-
   it('sets the first-day attribute', async () => {
     let day = createDay(new Date('2019/04/01'));
-    const el1 = await fixture(dayTemplate(day, { weekdays }));
+    const el1 = await fixture(
+      dayTemplate(day, {
+        weekdays,
+      }),
+    );
     expect(el1.hasAttribute('first-day')).to.be.true;
     day = createDay(new Date('2019/04/02'));
-    const el2 = await fixture(dayTemplate(day, { weekdays }));
+    const el2 = await fixture(
+      dayTemplate(day, {
+        weekdays,
+      }),
+    );
     expect(el2.hasAttribute('first-day')).to.be.false;
   });
-
   it('sets the end-of-first-week attribute', async () => {
-    let day = createDay(new Date('2019/04/06'), { weekOrder: 6 });
-    const el1 = await fixture(dayTemplate(day, { weekdays }));
+    let day = createDay(new Date('2019/04/06'), {
+      weekOrder: 6,
+    });
+    const el1 = await fixture(
+      dayTemplate(day, {
+        weekdays,
+      }),
+    );
     expect(el1.hasAttribute('end-of-first-week')).to.be.true;
-    day = createDay(new Date('2019/04/13'), { weekOrder: 6 });
-    const el2 = await fixture(dayTemplate(day, { weekdays }));
+    day = createDay(new Date('2019/04/13'), {
+      weekOrder: 6,
+    });
+    const el2 = await fixture(
+      dayTemplate(day, {
+        weekdays,
+      }),
+    );
     expect(el2.hasAttribute('end-of-first-week')).to.be.false;
   });
-
   it('sets the start-of-first-full-week attribute', async () => {
-    let day = createDay(new Date('2019/04/07'), { startOfWeek: true });
-    const el1 = await fixture(dayTemplate(day, { weekdays }));
+    let day = createDay(new Date('2019/04/07'), {
+      startOfWeek: true,
+    });
+    const el1 = await fixture(
+      dayTemplate(day, {
+        weekdays,
+      }),
+    );
     expect(el1.hasAttribute('start-of-first-full-week')).to.be.true;
-    day = createDay(new Date('2019/04/14'), { startOfWeek: true });
-    const el2 = await fixture(dayTemplate(day, { weekdays }));
+    day = createDay(new Date('2019/04/14'), {
+      startOfWeek: true,
+    });
+    const el2 = await fixture(
+      dayTemplate(day, {
+        weekdays,
+      }),
+    );
     expect(el2.hasAttribute('start-of-first-full-week')).to.be.false;
   });
-
   it('sets the end-of-last-full-week attribute', async () => {
-    let day = createDay(new Date('2019/04/27'), { weekOrder: 6 });
-    const el1 = await fixture(dayTemplate(day, { weekdays }));
+    let day = createDay(new Date('2019/04/27'), {
+      weekOrder: 6,
+    });
+    const el1 = await fixture(
+      dayTemplate(day, {
+        weekdays,
+      }),
+    );
     expect(el1.hasAttribute('end-of-last-full-week')).to.be.true;
-    day = createDay(new Date('2019/04/20'), { weekOrder: 6 });
-    const el2 = await fixture(dayTemplate(day, { weekdays }));
+    day = createDay(new Date('2019/04/20'), {
+      weekOrder: 6,
+    });
+    const el2 = await fixture(
+      dayTemplate(day, {
+        weekdays,
+      }),
+    );
     expect(el2.hasAttribute('end-of-last-full-week')).to.be.false;
   });
-
   it('sets the start-of-last-week attribute', async () => {
-    let day = createDay(new Date('2019/04/28'), { startOfWeek: true });
-    const el1 = await fixture(dayTemplate(day, { weekdays }));
+    let day = createDay(new Date('2019/04/28'), {
+      startOfWeek: true,
+    });
+    const el1 = await fixture(
+      dayTemplate(day, {
+        weekdays,
+      }),
+    );
     expect(el1.hasAttribute('start-of-last-week')).to.be.true;
-    day = createDay(new Date('2019/04/21'), { startOfWeek: true });
-    const el2 = await fixture(dayTemplate(day, { weekdays }));
+    day = createDay(new Date('2019/04/21'), {
+      startOfWeek: true,
+    });
+    const el2 = await fixture(
+      dayTemplate(day, {
+        weekdays,
+      }),
+    );
     expect(el2.hasAttribute('start-of-last-week')).to.be.false;
   });
-
   it('sets the last-day attribute', async () => {
-    let day = createDay(new Date('2019/04/30'), { startOfWeek: true });
-    const el1 = await fixture(dayTemplate(day, { weekdays }));
+    let day = createDay(new Date('2019/04/30'), {
+      startOfWeek: true,
+    });
+    const el1 = await fixture(
+      dayTemplate(day, {
+        weekdays,
+      }),
+    );
     expect(el1.hasAttribute('last-day')).to.be.true;
-    day = createDay(new Date('2019/03/30'), { startOfWeek: true });
-    const el2 = await fixture(dayTemplate(day, { weekdays }));
+    day = createDay(new Date('2019/03/30'), {
+      startOfWeek: true,
+    });
+    const el2 = await fixture(
+      dayTemplate(day, {
+        weekdays,
+      }),
+    );
     expect(el2.hasAttribute('last-day')).to.be.false;
-    day = createDay(new Date('2019/02/28'), { startOfWeek: true });
-    const el3 = await fixture(dayTemplate(day, { weekdays }));
+    day = createDay(new Date('2019/02/28'), {
+      startOfWeek: true,
+    });
+    const el3 = await fixture(
+      dayTemplate(day, {
+        weekdays,
+      }),
+    );
     expect(el3.hasAttribute('last-day')).to.be.true;
   });
 });

package/components/calendar/test/utils/getFirstDayNextMonth.test.js

@@ -1,7 +1,6 @@
 import { expect } from '@open-wc/testing';
 import { isSameDate } from '@lion/ui/calendar.js';
 import { getFirstDayNextMonth } from '../../src/utils/getFirstDayNextMonth.js';
-
 describe('getFirstDayNextMonth', () => {
   it('returns the first day of the next month', () => {
     expect(

package/components/calendar/test/utils/getLastDayPreviousMonth.test.js

@@ -1,7 +1,6 @@
 import { expect } from '@open-wc/testing';
 import { isSameDate } from '@lion/ui/calendar.js';
 import { getLastDayPreviousMonth } from '../../src/utils/getLastDayPreviousMonth.js';
-
 describe('getLastDayPreviousMonth', () => {
   it('returns the last day of the previous month', () => {
     expect(

package/components/calendar/test/utils/isSameDate.test.js

@@ -1,6 +1,5 @@
 import { expect } from '@open-wc/testing';
 import { isSameDate } from '@lion/ui/calendar.js';
-
 describe('isSameDate', () => {
   it('returns true if the same date is given', () => {
     const day1 = new Date('2001/01/01');

package/components/calendar/test/utils/snapshots/monthTemplate_en-GB_Sunday_2018-12.js

@@ -1,5 +1,4 @@
-const html = /** @param {TemplateStringsArray} strings */ strings => strings[0];
-
+const html = /** @param {TemplateStringsArray} strings */ (strings) => strings[0];
 export default html`
   <div id="js-content-wrapper">
     <table

package/components/calendar/test-helpers/CalendarObject.js

@@ -19,93 +19,68 @@ export class CalendarObject {
   get rootEl() {
     return this.el.shadowRoot?.querySelector('.calendar');
   }
-
   get headerEl() {
     return this.el.shadowRoot?.querySelector('.calendar__navigation');
   }
-
   get yearHeadingEl() {
     return this.el.shadowRoot?.querySelector('#year');
   }
-
   get monthHeadingEl() {
     return this.el.shadowRoot?.querySelector('#month');
   }
-
   get nextYearButtonEl() {
-    return /** @type {HTMLElement & { ariaLabel: string }} */ (
-      this.el.shadowRoot?.querySelectorAll('.calendar__next-button')[0]
-    );
+    return /** @type {HTMLElement & { ariaLabel: string }} */ this.el.shadowRoot?.querySelectorAll(
+      '.calendar__next-button',
+    )[0];
   }
-
   get previousYearButtonEl() {
-    return /** @type {HTMLElement & { ariaLabel: string }} */ (
-      this.el.shadowRoot?.querySelectorAll('.calendar__previous-button')[0]
-    );
+    return /** @type {HTMLElement & { ariaLabel: string }} */ this.el.shadowRoot?.querySelectorAll(
+      '.calendar__previous-button',
+    )[0];
   }
-
   get nextMonthButtonEl() {
     return this.el.shadowRoot?.querySelectorAll('.calendar__next-button')[1];
   }
-
   get previousMonthButtonEl() {
     return this.el.shadowRoot?.querySelectorAll('.calendar__previous-button')[1];
   }
-
   get gridEl() {
     return this.el.shadowRoot?.querySelector('.calendar__grid');
   }
-
   get weekdayHeaderEls() {
-    return /** @type {HTMLElement[]} */ (
-      Array.from(
-        /** @type {ShadowRoot} */ (this.el.shadowRoot).querySelectorAll(
-          '.calendar__weekday-header',
-        ),
-      )
+    return /** @type {HTMLElement[]} */ Array.from(
+      /** @type {ShadowRoot} */ this.el.shadowRoot.querySelectorAll('.calendar__weekday-header'),
     );
   }
-
   get dayEls() {
-    return /** @type {HTMLElement[]} */ (
-      Array.from(
-        /** @type {ShadowRoot} */ (this.el.shadowRoot).querySelectorAll(
-          '.calendar__day-button[current-month]',
-        ),
-      )
+    return /** @type {HTMLElement[]} */ Array.from(
+      /** @type {ShadowRoot} */ this.el.shadowRoot.querySelectorAll(
+        '.calendar__day-button[current-month]',
+      ),
     );
   }
-
   get previousMonthDayEls() {
-    return /** @type {HTMLElement[]} */ (
-      Array.from(
-        /** @type {ShadowRoot} */ (this.el.shadowRoot).querySelectorAll(
-          '.calendar__day-button[previous-month]',
-        ),
-      )
+    return /** @type {HTMLElement[]} */ Array.from(
+      /** @type {ShadowRoot} */ this.el.shadowRoot.querySelectorAll(
+        '.calendar__day-button[previous-month]',
+      ),
     );
   }
-
   get nextMonthDayEls() {
-    return /** @type {HTMLElement[]} */ (
-      Array.from(
-        /** @type {ShadowRoot} */ (this.el.shadowRoot).querySelectorAll(
-          '.calendar__day-button[next-month]',
-        ),
-      )
+    return /** @type {HTMLElement[]} */ Array.from(
+      /** @type {ShadowRoot} */ this.el.shadowRoot.querySelectorAll(
+        '.calendar__day-button[next-month]',
+      ),
     );
   }
-
   get dayObjs() {
-    return this.dayEls.map(d => new DayObject(d));
+    return this.dayEls.map((d) => new DayObject(d));
   }
-
   get previousMonthDayObjs() {
-    return this.previousMonthDayEls.map(d => new DayObject(d));
+    return this.previousMonthDayEls.map((d) => new DayObject(d));
   }
-
   get nextMonthDayObjs() {
-    return this.nextMonthDayEls.map(d => new DayObject(d));
+    return this.nextMonthDayEls.map((d) => new DayObject(d));
   }
 
   /**
@@ -113,30 +88,25 @@ export class CalendarObject {
    */
   getDayEl(monthDayNumber) {
     // Relies on the fact that empty cells don't have .calendar__day-button[current-month]
-    return /** @type {HTMLElement} */ (
-      this.el.shadowRoot?.querySelectorAll('.calendar__day-button[current-month]')[
-        monthDayNumber - 1
-      ]
-    );
+    return /** @type {HTMLElement} */ this.el.shadowRoot?.querySelectorAll(
+      '.calendar__day-button[current-month]',
+    )[monthDayNumber - 1];
   }
 
   /**
    * @param {number} monthDayNumber
    */
   getDayObj(monthDayNumber) {
-    return new DayObject(/** @type{HTMLElement} */ (this.getDayEl(monthDayNumber)));
+    return new DayObject(/** @type{HTMLElement} */ this.getDayEl(monthDayNumber));
   }
-
   get selectedDayObj() {
-    return this.dayObjs.find(d => d.isSelected);
+    return this.dayObjs.find((d) => d.isSelected);
   }
-
   get centralDayObj() {
-    return this.dayObjs.find(d => d.isCentral);
+    return this.dayObjs.find((d) => d.isCentral);
   }
-
   get focusedDayObj() {
-    return this.dayObjs.find(d => d.el === this.el.shadowRoot?.activeElement);
+    return this.dayObjs.find((d) => d.el === this.el.shadowRoot?.activeElement);
   }
 
   /**
@@ -149,7 +119,7 @@ export class CalendarObject {
    * - Example 2: "(dayNumber) => dayNumber === 15" (1 based ,not zero based)
    */
   checkForAllDayObjs(condition, filter) {
-    return this.dayEls.every(d => {
+    return this.dayEls.every((d) => {
       const dayObj = new DayObject(d);
       const dayNumber = dayObj.monthday;
       let shouldApply = true;
@@ -167,7 +137,6 @@ export class CalendarObject {
   get activeMonth() {
     return this.monthHeadingEl?.textContent?.trim();
   }
-
   get activeYear() {
     return this.yearHeadingEl?.textContent?.trim();
   }