@lion/ui 0.23.0 → 0.25.0

package/components/localize/test/date/formatDate.test.js

@@ -1,7 +1,6 @@
 import { expect } from '@open-wc/testing';
 import { getLocalizeManager, formatDate, parseDate } from '@lion/ui/localize-no-side-effects.js';
 import { localizeTearDown } from '@lion/ui/localize-test-helpers.js';
-
 const SUPPORTED_LOCALES = {
   'bg-BG': 'Bulgarian',
   'cs-CZ': 'Czech',
@@ -45,25 +44,18 @@ describe('formatDate', () => {
   beforeEach(() => {
     localizeTearDown();
   });
-
   it('displays the appropriate date based on locale', async () => {
     const testDate = new Date('2012/05/21');
-
     expect(formatDate(testDate)).to.equal('21/05/2012');
-
     localizeManager.locale = 'nl-NL';
     expect(formatDate(testDate)).to.equal('21-05-2012');
-
     localizeManager.locale = 'fr-FR';
     expect(formatDate(testDate)).to.equal('21/05/2012');
-
     localizeManager.locale = 'de-DE';
     expect(formatDate(testDate)).to.equal('21.05.2012');
-
     localizeManager.locale = 'en-US';
     expect(formatDate(testDate)).to.equal('05/21/2012');
   });
-
   it('displays the date based on options', async () => {
     const testDate = new Date('2012/05/21');
     /** @type {FormatDateOptions} */
@@ -73,7 +65,6 @@ describe('formatDate', () => {
       month: 'long',
       day: '2-digit',
     };
-
     expect(formatDate(testDate, options)).to.equal('Monday, 21 May 2012');
     localizeManager.locale = 'nl-NL';
     expect(formatDate(testDate, options)).to.equal('maandag 21 mei 2012');
@@ -84,7 +75,6 @@ describe('formatDate', () => {
     localizeManager.locale = 'en-US';
     expect(formatDate(testDate, options)).to.equal('Monday, May 21, 2012');
   });
-
   it('displays Hungarian dates correctly', async () => {
     /** @type {FormatDateOptions} */
     const options = {
@@ -95,13 +85,11 @@ describe('formatDate', () => {
       locale: 'en-US',
     };
     localizeManager.locale = 'hu-HU';
-    let date = /** @type {Date} */ (parseDate('2018-5-28'));
+    let date = /** @type {Date} */ parseDate('2018-5-28');
     expect(formatDate(date)).to.equal('2018. 05. 28.');
-
-    date = /** @type {Date} */ (parseDate('1970-11-3'));
+    date = /** @type {Date} */ parseDate('1970-11-3');
     expect(formatDate(date, options)).to.equal('Tuesday, November 03, 1970');
   });
-
   it('displays Bulgarian dates correctly', async () => {
     /** @type {FormatDateOptions} */
     const options = {
@@ -112,16 +100,13 @@ describe('formatDate', () => {
       locale: 'en-US',
     };
     localizeManager.locale = 'bg-BG';
-    let date = /** @type {Date} */ (parseDate('29-12-2017'));
+    let date = /** @type {Date} */ parseDate('29-12-2017');
     expect(formatDate(date)).to.equal('29.12.2017 г.');
-
-    date = /** @type {Date} */ (parseDate('13-1-1940'));
+    date = /** @type {Date} */ parseDate('13-1-1940');
     expect(formatDate(date)).to.equal('13.01.1940 г.');
-
-    date = /** @type {Date} */ (parseDate('3-11-1970'));
+    date = /** @type {Date} */ parseDate('3-11-1970');
     expect(formatDate(date, options)).to.equal('Tuesday, November 03, 1970');
   });
-
   it('displays US dates correctly', async () => {
     /** @type {FormatDateOptions} */
     const options = {
@@ -132,16 +117,13 @@ describe('formatDate', () => {
       locale: 'en-US',
     };
     localizeManager.locale = 'en-US';
-    let date = /** @type {Date} */ (parseDate('12-29-1940'));
+    let date = /** @type {Date} */ parseDate('12-29-1940');
     expect(formatDate(date)).to.equal('12/29/1940');
-
-    date = /** @type {Date} */ (parseDate('1-13-1940'));
+    date = /** @type {Date} */ parseDate('1-13-1940');
     expect(formatDate(date)).to.equal('01/13/1940');
-
-    date = /** @type {Date} */ (parseDate('11-3-1970'));
+    date = /** @type {Date} */ parseDate('11-3-1970');
     expect(formatDate(date, options)).to.equal('Tuesday, November 03, 1970');
   });
-
   it('handles locales in options', async () => {
     /** @type {FormatDateOptions} */
     let options = {
@@ -151,10 +133,9 @@ describe('formatDate', () => {
       day: '2-digit',
       locale: 'en-US',
     };
-    let parsedDate = /** @type {Date} */ (parseDate('05.11.2017'));
+    let parsedDate = /** @type {Date} */ parseDate('05.11.2017');
     expect(formatDate(parsedDate, options)).to.equal('Sunday, November 05, 2017');
-
-    parsedDate = /** @type {Date} */ (parseDate('01-01-1940'));
+    parsedDate = /** @type {Date} */ parseDate('01-01-1940');
     options = {
       weekday: 'long',
       year: 'numeric',
@@ -164,7 +145,6 @@ describe('formatDate', () => {
     };
     expect(formatDate(parsedDate, options)).to.equal('maandag 01 januari 1940');
   });
-
   describe('Date format options without "year"', () => {
     const LOCALE_FORMATTED_DATE_MAP = {
       'bg-BG': 'събота, 12 октомври',
@@ -194,13 +174,13 @@ describe('formatDate', () => {
       'zh-Hans-HK': '10月12日星期六',
       'zh-Hans-MO': '10月12日星期六',
       'zh-Hans-SG': '10月12日星期六',
-      'zh-Hant': '10月12日星期六', // '10月12日 星期六',
+      'zh-Hant': '10月12日星期六',
+      // '10月12日 星期六',
       'zh-Hant-HK': '10月12日星期六',
       'zh-Hant-MO': '10月12日星期六',
       'zh-Hant-TW': '10月12日星期六', // '10月12日 星期六',
     };
-
-    Object.keys(SUPPORTED_LOCALES).forEach(locale => {
+    Object.keys(SUPPORTED_LOCALES).forEach((locale) => {
       it(`handles options without year for locale: ${locale}`, async () => {
         /** @type {FormatDateOptions} */
         const options = {
@@ -209,13 +189,12 @@ describe('formatDate', () => {
           day: '2-digit',
           locale,
         };
-        const parsedDate = /** @type {Date} */ (parseDate('12.10.2019'));
+        const parsedDate = /** @type {Date} */ parseDate('12.10.2019');
         // @ts-ignore [dynamic-key-access-in-test]
         expect(formatDate(parsedDate, options)).to.equal(LOCALE_FORMATTED_DATE_MAP[locale]);
       });
     });
   });
-
   it('handles options without month', async () => {
     /** @type {FormatDateOptions} */
     const options = {
@@ -223,10 +202,9 @@ describe('formatDate', () => {
       year: 'numeric',
       day: '2-digit',
     };
-    const parsedDate = /** @type {Date} */ (parseDate('12.10.2019'));
+    const parsedDate = /** @type {Date} */ parseDate('12.10.2019');
     expect(formatDate(parsedDate, options)).to.equal('Saturday 12 2019');
   });
-
   it('handles options without day', async () => {
     /** @type {FormatDateOptions} */
     const options = {
@@ -234,16 +212,14 @@ describe('formatDate', () => {
       year: 'numeric',
       month: 'long',
     };
-    const parsedDate = /** @type {Date} */ (parseDate('12.10.2019'));
+    const parsedDate = /** @type {Date} */ parseDate('12.10.2019');
     expect(formatDate(parsedDate, options)).to.equal('October 2019 Saturday');
   });
-
   it('returns empty string when input is not a Date object', async () => {
     const date = '1-1-2016';
     // @ts-ignore tests what happens if you use a wrong type
     expect(formatDate(date)).to.equal('');
   });
-
   describe('Date post processors', () => {
     /**
      * Uppercase processor
@@ -251,7 +227,7 @@ describe('formatDate', () => {
      * @param {string} str
      * @returns {string}
      */
-    const upperCaseProcessor = str => str.toUpperCase();
+    const upperCaseProcessor = (str) => str.toUpperCase();
 
     /**
      * Lowercase processor
@@ -259,8 +235,7 @@ describe('formatDate', () => {
      * @param {string} str
      * @returns {string}
      */
-    const lowerCaseProcessor = str => str.toLocaleLowerCase();
-
+    const lowerCaseProcessor = (str) => str.toLocaleLowerCase();
     it('displays the appropriate date after post processor set in options', async () => {
       const testDate = new Date('2012/05/21');
       const postProcessors = new Map();
@@ -285,7 +260,6 @@ describe('formatDate', () => {
       localizeManager.locale = 'en-US';
       expect(formatDate(testDate, options)).to.equal('Monday, May 21, 2012');
     });
-
     it('displays the appropriate date after post processor set in localize', async () => {
       const testDate = new Date('2012/05/21');
       /** @type {FormatDateOptions} */
@@ -303,7 +277,6 @@ describe('formatDate', () => {
         locale: 'de-DE',
         postProcessor: upperCaseProcessor,
       });
-
       expect(formatDate(testDate, options)).to.equal('Monday, 21 May 2012');
       localizeManager.locale = 'nl-NL';
       expect(formatDate(testDate, options)).to.equal('MAANDAG 21 MEI 2012');
@@ -312,7 +285,6 @@ describe('formatDate', () => {
       localizeManager.locale = 'en-US';
       expect(formatDate(testDate, options)).to.equal('Monday, May 21, 2012');
     });
-
     it('displays the appropriate date after post processors set in options and localize', async () => {
       const testDate = new Date('2012/05/21');
       const postProcessors = new Map();
@@ -327,12 +299,10 @@ describe('formatDate', () => {
         day: '2-digit',
         postProcessors,
       };
-
       localizeManager.setDatePostProcessorForLocale({
         locale: 'de-DE',
         postProcessor: lowerCaseProcessor,
       });
-
       expect(formatDate(testDate, options)).to.equal('Monday, 21 May 2012');
       localizeManager.locale = 'nl-NL';
       expect(formatDate(testDate, options)).to.equal('MAANDAG 21 MEI 2012');

package/components/localize/test/date/getDateFormatBasedOnLocale.test.js

@@ -4,20 +4,17 @@ import {
   getDateFormatBasedOnLocale,
 } from '@lion/ui/localize-no-side-effects.js';
 import { localizeTearDown } from '@lion/ui/localize-test-helpers.js';
-
 describe('getDateFormatBasedOnLocale()', () => {
   const localizeManager = getLocalizeManager();
   beforeEach(() => {
     localizeTearDown();
   });
-
   it('returns the positions of day, month and year with locale set globally', async () => {
     localizeManager.locale = 'en-GB';
     expect(getDateFormatBasedOnLocale()).to.equal('day-month-year');
     localizeManager.locale = 'en-US';
     expect(getDateFormatBasedOnLocale()).to.equal('month-day-year');
   });
-
   it('returns the positions of day, month and year with given locale', async () => {
     expect(getDateFormatBasedOnLocale('en-GB')).to.equal('day-month-year');
     expect(getDateFormatBasedOnLocale('en-US')).to.equal('month-day-year');

package/components/localize/test/date/getMonthNames.test.js

@@ -7,18 +7,27 @@ import { getMonthNames } from '@lion/ui/localize.js';
 function s(strings) {
   return strings[0].split(' ');
 }
-
 describe('getMonthNames', () => {
   it('generates month names for a given locale', () => {
-    expect(getMonthNames({ locale: 'en-GB' })).to.deep.equal(
+    expect(
+      getMonthNames({
+        locale: 'en-GB',
+      }),
+    ).to.deep.equal(
       s`January February March April May June July August September October November December`,
     );
-    expect(getMonthNames({ locale: 'nl-NL' })).to.deep.equal(
+    expect(
+      getMonthNames({
+        locale: 'nl-NL',
+      }),
+    ).to.deep.equal(
       s`januari februari maart april mei juni juli augustus september oktober november december`,
     );
-    expect(getMonthNames({ locale: 'zh-CH' })).to.deep.equal(
-      s`一月 二月 三月 四月 五月 六月 七月 八月 九月 十月 十一月 十二月`,
-    );
+    expect(
+      getMonthNames({
+        locale: 'zh-CH',
+      }),
+    ).to.deep.equal(s`一月 二月 三月 四月 五月 六月 七月 八月 九月 十月 十一月 十二月`);
   });
   it('supports "short" style', () => {
     // TODO: Chrome thinks it should be Sept, not Sep. Firefox/Webkit disagree. We could normalize it in lion.
@@ -26,11 +35,17 @@ describe('getMonthNames', () => {
     //   s`Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec`,
     // );
     // Chromium default is leading
-    expect(getMonthNames({ locale: 'nl-NL', style: 'short' })).to.deep.equal(
-      s`jan. feb. mrt. apr. mei jun. jul. aug. sep. okt. nov. dec.`,
-    );
-    expect(getMonthNames({ locale: 'zh-CH', style: 'short' })).to.deep.equal(
-      s`1月 2月 3月 4月 5月 6月 7月 8月 9月 10月 11月 12月`,
-    );
+    expect(
+      getMonthNames({
+        locale: 'nl-NL',
+        style: 'short',
+      }),
+    ).to.deep.equal(s`jan. feb. mrt. apr. mei jun. jul. aug. sep. okt. nov. dec.`);
+    expect(
+      getMonthNames({
+        locale: 'zh-CH',
+        style: 'short',
+      }),
+    ).to.deep.equal(s`1月 2月 3月 4月 5月 6月 7月 8月 9月 10月 11月 12月`);
   });
 });

package/components/localize/test/date/getWeekdayNames.test.js

@@ -1,5 +1,4 @@
 import { expect } from '@open-wc/testing';
-
 import { getWeekdayNames } from '@lion/ui/localize.js';
 
 /**
@@ -8,61 +7,106 @@ import { getWeekdayNames } from '@lion/ui/localize.js';
 function s(strings) {
   return strings[0].split(' ');
 }
-
 describe('getWeekdayNames', () => {
   it('generates weekday names for a given locale with defaults (from Sunday, long style)', () => {
-    expect(getWeekdayNames({ locale: 'en-GB' })).to.deep.equal(
-      s`Sunday Monday Tuesday Wednesday Thursday Friday Saturday`,
-    );
-    expect(getWeekdayNames({ locale: 'nl-NL' })).to.deep.equal(
-      s`zondag maandag dinsdag woensdag donderdag vrijdag zaterdag`,
-    );
-    expect(getWeekdayNames({ locale: 'zh-CH' })).to.deep.equal(
-      s`星期日 星期一 星期二 星期三 星期四 星期五 星期六`,
-    );
+    expect(
+      getWeekdayNames({
+        locale: 'en-GB',
+      }),
+    ).to.deep.equal(s`Sunday Monday Tuesday Wednesday Thursday Friday Saturday`);
+    expect(
+      getWeekdayNames({
+        locale: 'nl-NL',
+      }),
+    ).to.deep.equal(s`zondag maandag dinsdag woensdag donderdag vrijdag zaterdag`);
+    expect(
+      getWeekdayNames({
+        locale: 'zh-CH',
+      }),
+    ).to.deep.equal(s`星期日 星期一 星期二 星期三 星期四 星期五 星期六`);
   });
-
   it('allows to specify a day when a week starts', () => {
-    expect(getWeekdayNames({ locale: 'en-GB', firstDayOfWeek: 7 })).to.deep.equal(
-      s`Sunday Monday Tuesday Wednesday Thursday Friday Saturday`,
-    );
-    expect(getWeekdayNames({ locale: 'en-GB', firstDayOfWeek: 1 })).to.deep.equal(
-      s`Monday Tuesday Wednesday Thursday Friday Saturday Sunday`,
-    );
-    expect(getWeekdayNames({ locale: 'en-GB', firstDayOfWeek: 2 })).to.deep.equal(
-      s`Tuesday Wednesday Thursday Friday Saturday Sunday Monday`,
-    );
-    expect(getWeekdayNames({ locale: 'en-GB', firstDayOfWeek: 3 })).to.deep.equal(
-      s`Wednesday Thursday Friday Saturday Sunday Monday Tuesday`,
-    );
-    expect(getWeekdayNames({ locale: 'en-GB', firstDayOfWeek: 4 })).to.deep.equal(
-      s`Thursday Friday Saturday Sunday Monday Tuesday Wednesday`,
-    );
-    expect(getWeekdayNames({ locale: 'en-GB', firstDayOfWeek: 5 })).to.deep.equal(
-      s`Friday Saturday Sunday Monday Tuesday Wednesday Thursday`,
-    );
-    expect(getWeekdayNames({ locale: 'en-GB', firstDayOfWeek: 6 })).to.deep.equal(
-      s`Saturday Sunday Monday Tuesday Wednesday Thursday Friday`,
-    );
+    expect(
+      getWeekdayNames({
+        locale: 'en-GB',
+        firstDayOfWeek: 7,
+      }),
+    ).to.deep.equal(s`Sunday Monday Tuesday Wednesday Thursday Friday Saturday`);
+    expect(
+      getWeekdayNames({
+        locale: 'en-GB',
+        firstDayOfWeek: 1,
+      }),
+    ).to.deep.equal(s`Monday Tuesday Wednesday Thursday Friday Saturday Sunday`);
+    expect(
+      getWeekdayNames({
+        locale: 'en-GB',
+        firstDayOfWeek: 2,
+      }),
+    ).to.deep.equal(s`Tuesday Wednesday Thursday Friday Saturday Sunday Monday`);
+    expect(
+      getWeekdayNames({
+        locale: 'en-GB',
+        firstDayOfWeek: 3,
+      }),
+    ).to.deep.equal(s`Wednesday Thursday Friday Saturday Sunday Monday Tuesday`);
+    expect(
+      getWeekdayNames({
+        locale: 'en-GB',
+        firstDayOfWeek: 4,
+      }),
+    ).to.deep.equal(s`Thursday Friday Saturday Sunday Monday Tuesday Wednesday`);
+    expect(
+      getWeekdayNames({
+        locale: 'en-GB',
+        firstDayOfWeek: 5,
+      }),
+    ).to.deep.equal(s`Friday Saturday Sunday Monday Tuesday Wednesday Thursday`);
+    expect(
+      getWeekdayNames({
+        locale: 'en-GB',
+        firstDayOfWeek: 6,
+      }),
+    ).to.deep.equal(s`Saturday Sunday Monday Tuesday Wednesday Thursday Friday`);
   });
-
   it('supports "short" style', () => {
-    expect(getWeekdayNames({ locale: 'en-GB', style: 'short' })).to.deep.equal(
-      s`Sun Mon Tue Wed Thu Fri Sat`,
-    );
-    expect(getWeekdayNames({ locale: 'nl-NL', style: 'short' })).to.deep.equal(
-      s`zo ma di wo do vr za`,
-    );
-    expect(getWeekdayNames({ locale: 'zh-CH', style: 'short' })).to.deep.equal(
-      s`周日 周一 周二 周三 周四 周五 周六`,
-    );
+    expect(
+      getWeekdayNames({
+        locale: 'en-GB',
+        style: 'short',
+      }),
+    ).to.deep.equal(s`Sun Mon Tue Wed Thu Fri Sat`);
+    expect(
+      getWeekdayNames({
+        locale: 'nl-NL',
+        style: 'short',
+      }),
+    ).to.deep.equal(s`zo ma di wo do vr za`);
+    expect(
+      getWeekdayNames({
+        locale: 'zh-CH',
+        style: 'short',
+      }),
+    ).to.deep.equal(s`周日 周一 周二 周三 周四 周五 周六`);
   });
-
   it('supports "narrow" style', () => {
-    expect(getWeekdayNames({ locale: 'en-GB', style: 'narrow' })).to.deep.equal(s`S M T W T F S`);
-    expect(getWeekdayNames({ locale: 'nl-NL', style: 'narrow' })).to.deep.equal(s`Z M D W D V Z`);
-    expect(getWeekdayNames({ locale: 'zh-CH', style: 'narrow' })).to.deep.equal(
-      s`日 一 二 三 四 五 六`,
-    );
+    expect(
+      getWeekdayNames({
+        locale: 'en-GB',
+        style: 'narrow',
+      }),
+    ).to.deep.equal(s`S M T W T F S`);
+    expect(
+      getWeekdayNames({
+        locale: 'nl-NL',
+        style: 'narrow',
+      }),
+    ).to.deep.equal(s`Z M D W D V Z`);
+    expect(
+      getWeekdayNames({
+        locale: 'zh-CH',
+        style: 'narrow',
+      }),
+    ).to.deep.equal(s`日 一 二 三 四 五 六`);
   });
 });

package/components/localize/test/date/normalizeDateTime.test.js

@@ -1,10 +1,8 @@
 import { expect } from '@open-wc/testing';
 import { normalizeDateTime } from '@lion/ui/localize.js';
-
 describe('normalizeDateTime', () => {
   it('returns a date with hours, minutes and seconds set to 0', () => {
     const date = normalizeDateTime(new Date('2000-11-29T12:34:56'));
-
     expect(date.getFullYear()).to.equal(2000);
     expect(date.getMonth()).to.equal(10);
     expect(date.getDate()).to.equal(29);

package/components/localize/test/date/parseDate.test.js

@@ -9,40 +9,37 @@ import { localizeTearDown } from '@lion/ui/localize-test-helpers.js';
  */
 function equalsDate(value, date) {
   return (
-    Object.prototype.toString.call(value) === '[object Date]' && // is Date Object
+    Object.prototype.toString.call(value) === '[object Date]' &&
+    // is Date Object
     value &&
-    value.getDate() === date?.getDate() && // day
-    value.getMonth() === date.getMonth() && // month
+    value.getDate() === date?.getDate() &&
+    // day
+    value.getMonth() === date.getMonth() &&
+    // month
     value.getFullYear() === date.getFullYear() // year
   );
 }
-
 describe('parseDate()', () => {
   const localizeManager = getLocalizeManager();
   beforeEach(() => {
     localizeTearDown();
   });
-
   it('handles year correctly', () => {
     expect(equalsDate(parseDate('1/11/1'), new Date('2001/11/01'))).to.equal(true);
     expect(equalsDate(parseDate('1/11/49'), new Date('2049/11/01'))).to.equal(true);
     expect(equalsDate(parseDate('1/11/50'), new Date('1950/11/01'))).to.equal(true);
   });
-
   it('adds leading zeros', () => {
     expect(equalsDate(parseDate('1-1-1979'), new Date('1979/01/01'))).to.equal(true);
     expect(equalsDate(parseDate('1-11-1979'), new Date('1979/11/01'))).to.equal(true);
   });
-
   it('creates a date object', () => {
     expect(parseDate('10/10/2000') instanceof Date).to.equal(true);
   });
-
   it('returns a date object', () => {
     expect(equalsDate(parseDate('1-1-1979'), new Date('1979/01/01'))).to.equal(true);
     expect(equalsDate(parseDate('31.12.1970'), new Date('1970/12/31'))).to.equal(true);
   });
-
   it('handles all kind of delimiters', () => {
     expect(equalsDate(parseDate('12-12-1976'), new Date('1976/12/12'))).to.equal(true);
     expect(equalsDate(parseDate('13 12 1976'), new Date('1976/12/13'))).to.equal(true);
@@ -50,21 +47,22 @@ describe('parseDate()', () => {
     expect(equalsDate(parseDate('14. 12. 1976.'), new Date('1976/12/14'))).to.equal(true);
     expect(equalsDate(parseDate('14.12.1976 r.'), new Date('1976/12/14'))).to.equal(true);
   });
-
   it('handles different locales globally set', () => {
     localizeManager.locale = 'en-GB';
     expect(equalsDate(parseDate('31-12-1976'), new Date('1976/12/31'))).to.equal(true);
     localizeManager.locale = 'en-US';
     expect(equalsDate(parseDate('12-31-1976'), new Date('1976/12/31'))).to.equal(true);
   });
-
   it('handles different locales as option', () => {
-    const optionEnGb = { locale: 'en-GB' };
+    const optionEnGb = {
+      locale: 'en-GB',
+    };
     expect(equalsDate(parseDate('31-12-1976', optionEnGb), new Date('1976/12/31'))).to.equal(true);
-    const optionEnUs = { locale: 'en-US' };
+    const optionEnUs = {
+      locale: 'en-US',
+    };
     expect(equalsDate(parseDate('12-31-1976', optionEnUs), new Date('1976/12/31'))).to.equal(true);
   });
-
   it('handles timezones of the browser and parsed date correctly', () => {
     const referenceDate = new Date('2020/01/30');
     localizeManager.locale = 'nl-NL';
@@ -78,7 +76,6 @@ describe('parseDate()', () => {
     // Optional: verify we are dealing with the same date (this is already tested in other tests?)
     expect(equalsDate(referenceDate, parsedDate)).to.be.true;
   });
-
   it('return undefined when no valid date provided', () => {
     expect(parseDate('12.12.1976.,')).to.equal(undefined); // wrong delimiter
     expect(parseDate('foo')).to.equal(undefined); // no date
@@ -91,7 +88,6 @@ describe('parseDate()', () => {
     expect(parseDate('02.31.2020')).to.equal(undefined); // non existing date
     expect(parseDate('31.12.2020')).to.equal(undefined); // day & month switched places
   });
-
   it('returns undefined for incorrect year format', () => {
     // TODO: we need a `> 0` check for day and month, but maybe consider `>= 0` for year?
     expect(parseDate('12-12-0000')).to.equal(undefined);

package/components/localize/test/getLocalizeManager.test.js

@@ -11,7 +11,6 @@ describe('getLocalizeManager', () => {
     // @ts-ignore
     singletonManager._map.clear();
   });
-
   it('gets a default instance when nothing registered on singletonManager with "@lion/ui::localize::0.x"', () => {
     expect(singletonManager.get('@lion/ui::localize::0.x')).to.be.undefined;
     const /** @type {LocalizeManagerForTesting} */ localizeManager = getLocalizeManager();
@@ -19,7 +18,6 @@ describe('getLocalizeManager', () => {
       singletonManager.get('@lion/ui::localize::0.x'),
     );
   });
-
   it('gets the same instance when called multiple times', () => {
     const /** @type {LocalizeManagerForTesting} */ localizeManager = getLocalizeManager();
     const /** @type {LocalizeManagerForTesting} */ localizeManagerSecondCall = getLocalizeManager();
@@ -28,7 +26,6 @@ describe('getLocalizeManager', () => {
       localizeManagerSecondCall.__instance_for_testing,
     );
   });
-
   it('gets the instance that was registered on singletonManager with "@lion/ui::localize::0.x"', () => {
     // Set your own for custom behavior or for deduping purposes
     class MyLocalizeManager extends LocalizeManager {}

package/components/localize/test/isLocalizeESModule.test.js

@@ -1,31 +1,50 @@
 import { expect } from '@open-wc/testing';
-
 import isLocalizeESModule from '../src/isLocalizeESModule.js';
-
 describe('isLocalizeESModule', () => {
   it('detects a module by finding the "default" key containing an object', () => {
-    expect(isLocalizeESModule({ default: {} })).to.equal(true);
+    expect(
+      isLocalizeESModule({
+        default: {},
+      }),
+    ).to.equal(true);
   });
-
   it('detects a real ES module with a default export', async () => {
     const mod = await import('./test-esmodule-default.js');
     expect(isLocalizeESModule(mod)).to.equal(true);
   });
-
   it('ignores if the "default" key is a string', () => {
-    expect(isLocalizeESModule({ default: 'my string' })).to.equal(false);
+    expect(
+      isLocalizeESModule({
+        default: 'my string',
+      }),
+    ).to.equal(false);
   });
-
   it('ignores if there are extra keys to the "default" key', () => {
-    expect(isLocalizeESModule({ default: {}, otherKey: 'other key' })).to.equal(false);
-    expect(isLocalizeESModule({ default: {}, otherKey: {} })).to.equal(false);
+    expect(
+      isLocalizeESModule({
+        default: {},
+        otherKey: 'other key',
+      }),
+    ).to.equal(false);
+    expect(
+      isLocalizeESModule({
+        default: {},
+        otherKey: {},
+      }),
+    ).to.equal(false);
   });
-
   it('ignores if there is no "default" key', () => {
-    expect(isLocalizeESModule({ otherKey: 'other key' })).to.equal(false);
-    expect(isLocalizeESModule({ otherKey: {} })).to.equal(false);
+    expect(
+      isLocalizeESModule({
+        otherKey: 'other key',
+      }),
+    ).to.equal(false);
+    expect(
+      isLocalizeESModule({
+        otherKey: {},
+      }),
+    ).to.equal(false);
   });
-
   it('ignores if not an object', () => {
     // @ts-ignore passing a non-object is not allowed by ts, but we still want to test the outcome
     expect(isLocalizeESModule(undefined)).to.equal(false);