@louis.jln/extract-date 3.0.1 → 4.0.0

package/src/normalizeInput.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (input: string) => string;
+export default _default;

package/src/normalizeInput.js

@@ -0,0 +1,17 @@
+export default (input) => {
+    let lastInput = input;
+    while (true) {
+        const result = lastInput
+            // 2019-02-12T00:00:00
+            .replace(/(\d+)T(\d+)/, '$1 $2')
+            .replace(/(\d+)\s\/\s(\d+)/, '$1/$2')
+            .replace(/[.:;] /g, ' ')
+            .trim()
+            .replace(/[.!#?]+$/g, '')
+            .replace(/ {2,}/g, ' ');
+        if (result === lastInput) {
+            return result;
+        }
+        lastInput = result;
+    }
+};

package/src/resolveLocalizedNames.d.ts

@@ -0,0 +1,2 @@
+export declare const replaceMonthName: (word: string, locale: string, accentless: boolean) => string | null;
+export declare const replaceDayName: (word: string, locale: string, accentless: boolean) => string | null;

package/src/resolveLocalizedNames.js

@@ -0,0 +1,82 @@
+import monthsData from '@/months.json';
+import daysData from '@/days.json';
+const stripDiacritics = (text) => text.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+const enMonths = monthsData.en;
+const enDays = daysData.en;
+// Cache: locale -> Map<lowercaseName, englishName>
+const monthLookupCache = {};
+const dayLookupCache = {};
+const buildMonthLookup = (locale) => {
+    if (monthLookupCache[locale]) {
+        return monthLookupCache[locale];
+    }
+    const localeData = monthsData[locale];
+    if (!localeData) {
+        monthLookupCache[locale] = {};
+        return monthLookupCache[locale];
+    }
+    const lookup = {};
+    for (const monthNum of Object.keys(localeData)) {
+        const names = localeData[monthNum];
+        const enNames = enMonths[monthNum];
+        for (let i = 0; i < names.length; i++) {
+            const enName = enNames[i < enNames.length ? i : 0];
+            lookup[names[i].toLowerCase()] = enName.charAt(0).toUpperCase() + enName.slice(1);
+        }
+    }
+    monthLookupCache[locale] = lookup;
+    return lookup;
+};
+const buildDayLookup = (locale) => {
+    if (dayLookupCache[locale]) {
+        return dayLookupCache[locale];
+    }
+    const localeData = daysData[locale];
+    if (!localeData) {
+        dayLookupCache[locale] = {};
+        return dayLookupCache[locale];
+    }
+    const lookup = {};
+    for (const dayNum of Object.keys(localeData)) {
+        const names = localeData[dayNum];
+        const enNames = enDays[dayNum];
+        for (let i = 0; i < names.length; i++) {
+            const enName = enNames[i < enNames.length ? i : 0];
+            lookup[names[i].toLowerCase()] = enName.charAt(0).toUpperCase() + enName.slice(1);
+        }
+    }
+    dayLookupCache[locale] = lookup;
+    return lookup;
+};
+export const replaceMonthName = (word, locale, accentless) => {
+    const lookup = buildMonthLookup(locale);
+    const lower = word.toLowerCase();
+    if (lookup[lower]) {
+        return lookup[lower];
+    }
+    if (accentless) {
+        const strippedWord = stripDiacritics(lower);
+        for (const key of Object.keys(lookup)) {
+            if (stripDiacritics(key) === strippedWord) {
+                return lookup[key];
+            }
+        }
+    }
+    return null;
+};
+export const replaceDayName = (word, locale, accentless) => {
+    const lookup = buildDayLookup(locale);
+    const lower = word.toLowerCase();
+    if (lookup[lower]) {
+        return lookup[lower];
+    }
+    if (accentless) {
+        const strippedWord = stripDiacritics(lower);
+        for (const key of Object.keys(lookup)) {
+            if (stripDiacritics(key) === strippedWord) {
+                return lookup[key];
+            }
+        }
+    }
+    return null;
+};

package/src/types.d.ts

@@ -0,0 +1,20 @@
+export type DateMatchType = {
+    readonly date: string;
+};
+export type DirectionType = 'DM' | 'DMY' | 'DYM' | 'MD' | 'YDM' | 'YMD' | 'MDY';
+export type UserConfigurationType = {
+    readonly translateAccentless?: boolean;
+    readonly direction?: DirectionType;
+    readonly locale?: string;
+    readonly maximumAge?: number;
+    readonly minimumAge?: number;
+    readonly timezone?: string;
+};
+export type ConfigurationType = {
+    readonly translateAccentless?: boolean;
+    readonly direction?: DirectionType;
+    readonly locale?: string;
+    readonly maximumAge: number;
+    readonly minimumAge: number;
+    readonly timezone?: string;
+};

package/src/types.js

@@ -0,0 +1 @@
+export {};

package/test/extract-date/calculateSpecificity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/test/extract-date/calculateSpecificity.test.js

@@ -0,0 +1,39 @@
+import { it, expect } from 'vitest';
+import cartesian from 'cartesian';
+import calculateSpecificity from '@/calculateSpecificity';
+it('tokens including yyyy, (MMMM, MM, MM, M), (dd, d, do) have the highest specificity', () => {
+    const formats = cartesian([
+        [
+            'yyyy',
+        ],
+        [
+            'MMMM',
+            'MMM',
+            'MM',
+            'M',
+        ],
+        [
+            'dd',
+            'd',
+            'do',
+        ],
+    ]);
+    for (const tokens of formats) {
+        const format = tokens.join(' ');
+        expect(calculateSpecificity(format)).toBe(80 + format.length);
+    }
+});
+it('tokens without year, month or month date have the lowest specificity', () => {
+    const formats = [
+        'EEEE',
+        'EEE',
+        'R',
+    ];
+    for (const format of formats) {
+        expect(calculateSpecificity(format)).toBe(format.length);
+    }
+});
+it('adds format length to the specificity', () => {
+    expect(calculateSpecificity('xxxx')).toBe(4);
+    expect(calculateSpecificity('xx')).toBe(2);
+});

package/test/extract-date/createMovingChunks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/test/extract-date/createMovingChunks.test.js

@@ -0,0 +1,28 @@
+import { it, expect } from 'vitest';
+import createMovingChunks from '@/createMovingChunks';
+it('creates an array of fixed length text slices, each offset by 1 character', () => {
+    expect(createMovingChunks(['a', 'b', 'c', 'd'], 2)).toEqual([
+        [
+            'a',
+            'b',
+        ],
+        [
+            'b',
+            'c',
+        ],
+        [
+            'c',
+            'd',
+        ],
+    ]);
+    expect(createMovingChunks(['a', 'b', 'c'], 2)).toEqual([
+        [
+            'a',
+            'b',
+        ],
+        [
+            'b',
+            'c',
+        ],
+    ]);
+});

package/test/extract-date/extractDate/configuration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/test/extract-date/extractDate/configuration.test.js

@@ -0,0 +1,36 @@
+import { it, expect, beforeEach, afterEach, vi } from 'vitest';
+import extractDate from '@/extractDate';
+beforeEach(() => {
+    vi.useFakeTimers();
+});
+afterEach(() => {
+    vi.useRealTimers();
+});
+it('throws an error if invalid `locale` is provided', () => {
+    expect(() => {
+        extractDate('foo', {
+            locale: 'bar',
+        });
+    }).toThrow('No translation available for the target locale.');
+});
+it('throws an error if invalid `timezone` is provided', () => {
+    expect(() => {
+        extractDate('foo', {
+            timezone: 'bar',
+        });
+    }).toThrow('Unrecognized timezone.');
+});
+it('throws an error if invalid `maximumAge` is a negative value', () => {
+    expect(() => {
+        extractDate('foo', {
+            maximumAge: -1,
+        });
+    }).toThrow('`maximumAge` must be a positive number.');
+});
+it('throws an error if invalid `minimumAge` is a negative value', () => {
+    expect(() => {
+        extractDate('foo', {
+            minimumAge: -1,
+        });
+    }).toThrow('`minimumAge` must be a positive number.');
+});

package/test/extract-date/extractDate/edge-cases.test.d.ts

@@ -0,0 +1 @@
+export {};

package/test/extract-date/extractDate/edge-cases.test.js

@@ -0,0 +1,23 @@
+import { it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { parse as parseDate, } from 'date-fns';
+import extractDate from '@/extractDate';
+beforeEach(() => {
+    vi.useFakeTimers();
+});
+afterEach(() => {
+    vi.useRealTimers();
+});
+it('parses ISO 8601 date-time format', () => {
+    vi.setSystemTime(parseDate('2000-01-02', 'yyyy-MM-dd', new Date()).getTime());
+    expect(extractDate('2000-01-02T00:00')).toEqual([{ date: '2000-01-02', originalText: '2000-01-02' }]);
+});
+it('extracts date matching multiple formats once', () => {
+    vi.setSystemTime(parseDate('2000-01-02', 'yyyy-MM-dd', new Date()).getTime());
+    // 'foo bar' prefix is required to ensure that substring matching is correctly advancing.
+    expect(extractDate('foo bar 02/01/2000', { direction: 'DMY' })).toEqual([{ date: '2000-01-02', originalText: '02/01/2000' }]);
+});
+it('full-year formats are used regardless of whether direction defines Y', () => {
+    vi.setSystemTime(parseDate('2000-01-02', 'yyyy-MM-dd', new Date()).getTime());
+    expect(extractDate('02/01/2020', { direction: 'DM' })).toEqual([{ date: '2020-01-02', originalText: '02/01/2020' }]);
+});
+it.todo('interprets 24:00 time as the next date');

package/test/extract-date/extractDate/fixtures.test.d.ts

@@ -0,0 +1 @@
+export {};

package/test/extract-date/extractDate/fixtures.test.js

@@ -0,0 +1,42 @@
+import { it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { parse as parseDate, } from 'date-fns';
+import fixtureDates from '@test/fixtures/dates.json';
+import extractDate from '@/extractDate';
+beforeEach(() => {
+    vi.useFakeTimers();
+});
+afterEach(() => {
+    vi.useRealTimers();
+});
+const normalizedFixtureDates = fixtureDates
+    .map((fixture) => {
+    return {
+        ...fixture,
+        subject: fixture.subject.trim(),
+    };
+})
+    .map((fixture) => {
+    return JSON.stringify(fixture);
+})
+    .filter((fixture, index, self) => {
+    return self.indexOf(fixture) === index;
+})
+    .map((fixture) => {
+    return JSON.parse(fixture);
+})
+    .map((fixture) => {
+    return {
+        ...fixture,
+        configuration: {
+            ...fixture.configuration,
+            maximumAge: Infinity,
+            minimumAge: Infinity,
+        },
+    };
+});
+for (const fixtureDate of normalizedFixtureDates) {
+    it('extracts dates from "' + fixtureDate.subject + '" fixture using ' + JSON.stringify(fixtureDate.configuration) + ' configuration on ' + fixtureDate.date + ' date', () => {
+        vi.setSystemTime(parseDate(fixtureDate.date, 'yyyy-MM-dd', new Date()).getTime());
+        expect(extractDate(fixtureDate.subject, fixtureDate.configuration)).toEqual(fixtureDate.matches);
+    });
+}

package/test/extract-date/extractDate/general-formats.test.d.ts

@@ -0,0 +1 @@
+export {};

package/test/extract-date/extractDate/general-formats.test.js

@@ -0,0 +1,45 @@
+import { it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { format as formatDate, parse as parseDate, } from 'date-fns';
+import extractDate from '@/extractDate';
+import createFormats from '@/createFormats';
+// https://en.wikipedia.org/wiki/Date_format_by_country
+// %w arbitrary white-space separated text
+const describeConfiguration = (userConfiguration) => {
+    const configuration = {};
+    if (userConfiguration.direction) {
+        configuration.direction = userConfiguration.direction;
+    }
+    return JSON.stringify(configuration);
+};
+const formats = createFormats();
+vi.useFakeTimers();
+vi.setSystemTime(parseDate('2000-06-01', 'yyyy-MM-dd', new Date()).getTime());
+const subjects = formats
+    .filter((format) => {
+    return format.test !== false;
+})
+    .map((format) => {
+    const currentDate = new Date();
+    return {
+        date: formatDate(currentDate, 'yyyy-MM-dd'),
+        dateFnsFormat: format.dateFnsFormat,
+        direction: format.direction,
+        input: formatDate(currentDate, format.dateFnsFormat),
+    };
+});
+vi.useRealTimers();
+beforeEach(() => {
+    vi.useFakeTimers();
+});
+afterEach(() => {
+    vi.useRealTimers();
+});
+for (const subject of subjects) {
+    it('extracts ' + subject.dateFnsFormat + ' from "' + subject.input + '" input using ' + describeConfiguration(subject) + ' configuration', () => {
+        vi.setSystemTime(parseDate('2000-06-01', 'yyyy-MM-dd', new Date()).getTime());
+        const actual = extractDate(subject.input, subject);
+        const expected = subject.date;
+        expect(actual.length).toBe(1);
+        expect(actual[0].date).toBe(expected);
+    });
+}

package/test/extract-date/extractDate/implied-year.test.d.ts

@@ -0,0 +1 @@
+export {};

package/test/extract-date/extractDate/implied-year.test.js

@@ -0,0 +1,105 @@
+import { it, expect, beforeEach, afterEach, vi } from 'vitest';
+import moment from 'moment';
+import extractDate from '@/extractDate';
+beforeEach(() => {
+    vi.useFakeTimers();
+});
+afterEach(() => {
+    vi.useRealTimers();
+});
+it('assumes last year if month difference is greater or equal to `maximumAge`', () => {
+    vi.setSystemTime(moment('2000-01-01').valueOf());
+    const configuration = {
+        direction: 'MD',
+        maximumAge: 10,
+    };
+    expect(extractDate('01-01', configuration)).toEqual([{ date: '2000-01-01', originalText: '01-01' }]);
+    expect(extractDate('02-01', configuration)).toEqual([{ date: '2000-02-01', originalText: '02-01' }]);
+    expect(extractDate('03-01', configuration)).toEqual([{ date: '2000-03-01', originalText: '03-01' }]);
+    expect(extractDate('04-01', configuration)).toEqual([{ date: '2000-04-01', originalText: '04-01' }]);
+    expect(extractDate('05-01', configuration)).toEqual([{ date: '2000-05-01', originalText: '05-01' }]);
+    expect(extractDate('06-01', configuration)).toEqual([{ date: '2000-06-01', originalText: '06-01' }]);
+    expect(extractDate('07-01', configuration)).toEqual([{ date: '2000-07-01', originalText: '07-01' }]);
+    expect(extractDate('08-01', configuration)).toEqual([{ date: '2000-08-01', originalText: '08-01' }]);
+    expect(extractDate('09-01', configuration)).toEqual([{ date: '2000-09-01', originalText: '09-01' }]);
+    expect(extractDate('10-01', configuration)).toEqual([{ date: '2000-10-01', originalText: '10-01' }]);
+    expect(extractDate('11-01', configuration)).toEqual([{ date: '1999-11-01', originalText: '11-01' }]);
+    expect(extractDate('12-01', configuration)).toEqual([{ date: '1999-12-01', originalText: '12-01' }]);
+});
+it('does not assume last year when `maximumAge` is `Infinity`', () => {
+    vi.setSystemTime(moment('2000-01-01').valueOf());
+    const configuration = {
+        direction: 'MD',
+        maximumAge: Infinity,
+    };
+    expect(extractDate('01-01', configuration)).toEqual([{ date: '2000-01-01', originalText: '01-01' }]);
+    expect(extractDate('02-01', configuration)).toEqual([{ date: '2000-02-01', originalText: '02-01' }]);
+    expect(extractDate('03-01', configuration)).toEqual([{ date: '2000-03-01', originalText: '03-01' }]);
+    expect(extractDate('04-01', configuration)).toEqual([{ date: '2000-04-01', originalText: '04-01' }]);
+    expect(extractDate('05-01', configuration)).toEqual([{ date: '2000-05-01', originalText: '05-01' }]);
+    expect(extractDate('06-01', configuration)).toEqual([{ date: '2000-06-01', originalText: '06-01' }]);
+    expect(extractDate('07-01', configuration)).toEqual([{ date: '2000-07-01', originalText: '07-01' }]);
+    expect(extractDate('08-01', configuration)).toEqual([{ date: '2000-08-01', originalText: '08-01' }]);
+    expect(extractDate('09-01', configuration)).toEqual([{ date: '2000-09-01', originalText: '09-01' }]);
+    expect(extractDate('10-01', configuration)).toEqual([{ date: '2000-10-01', originalText: '10-01' }]);
+    expect(extractDate('11-01', configuration)).toEqual([{ date: '2000-11-01', originalText: '11-01' }]);
+    expect(extractDate('12-01', configuration)).toEqual([{ date: '2000-12-01', originalText: '12-01' }]);
+});
+it('increments year value if month difference is greater or equal to `minimumAge`', () => {
+    vi.setSystemTime(moment('2000-12-01').valueOf());
+    const configuration = {
+        direction: 'MD',
+        minimumAge: 2,
+    };
+    expect(extractDate('01-01', configuration)).toEqual([{ date: '2001-01-01', originalText: '01-01' }]);
+    expect(extractDate('02-01', configuration)).toEqual([{ date: '2001-02-01', originalText: '02-01' }]);
+    expect(extractDate('03-01', configuration)).toEqual([{ date: '2001-03-01', originalText: '03-01' }]);
+    expect(extractDate('04-01', configuration)).toEqual([{ date: '2001-04-01', originalText: '04-01' }]);
+    expect(extractDate('05-01', configuration)).toEqual([{ date: '2001-05-01', originalText: '05-01' }]);
+    expect(extractDate('06-01', configuration)).toEqual([{ date: '2001-06-01', originalText: '06-01' }]);
+    expect(extractDate('07-01', configuration)).toEqual([{ date: '2001-07-01', originalText: '07-01' }]);
+    expect(extractDate('08-01', configuration)).toEqual([{ date: '2001-08-01', originalText: '08-01' }]);
+    expect(extractDate('09-01', configuration)).toEqual([{ date: '2001-09-01', originalText: '09-01' }]);
+    expect(extractDate('10-01', configuration)).toEqual([{ date: '2001-10-01', originalText: '10-01' }]);
+    expect(extractDate('11-01', configuration)).toEqual([{ date: '2000-11-01', originalText: '11-01' }]);
+    expect(extractDate('12-01', configuration)).toEqual([{ date: '2000-12-01', originalText: '12-01' }]);
+});
+it('does not increment year value if `minimumAge` is `Infinity`', () => {
+    vi.setSystemTime(moment('2000-12-01').valueOf());
+    const configuration = {
+        direction: 'MD',
+        minimumAge: Infinity,
+    };
+    expect(extractDate('01-01', configuration)).toEqual([{ date: '2000-01-01', originalText: '01-01' }]);
+    expect(extractDate('02-01', configuration)).toEqual([{ date: '2000-02-01', originalText: '02-01' }]);
+    expect(extractDate('03-01', configuration)).toEqual([{ date: '2000-03-01', originalText: '03-01' }]);
+    expect(extractDate('04-01', configuration)).toEqual([{ date: '2000-04-01', originalText: '04-01' }]);
+    expect(extractDate('05-01', configuration)).toEqual([{ date: '2000-05-01', originalText: '05-01' }]);
+    expect(extractDate('06-01', configuration)).toEqual([{ date: '2000-06-01', originalText: '06-01' }]);
+    expect(extractDate('07-01', configuration)).toEqual([{ date: '2000-07-01', originalText: '07-01' }]);
+    expect(extractDate('08-01', configuration)).toEqual([{ date: '2000-08-01', originalText: '08-01' }]);
+    expect(extractDate('09-01', configuration)).toEqual([{ date: '2000-09-01', originalText: '09-01' }]);
+    expect(extractDate('10-01', configuration)).toEqual([{ date: '2000-10-01', originalText: '10-01' }]);
+    expect(extractDate('11-01', configuration)).toEqual([{ date: '2000-11-01', originalText: '11-01' }]);
+    expect(extractDate('12-01', configuration)).toEqual([{ date: '2000-12-01', originalText: '12-01' }]);
+});
+it('`maximumAge` and `minimumAge` can be combined', () => {
+    vi.setSystemTime(moment('2000-06-01').valueOf());
+    const configuration = {
+        direction: 'MD',
+        maximumAge: 2,
+        minimumAge: 2,
+    };
+    expect(extractDate('01-01', configuration)).toEqual([{ date: '2001-01-01', originalText: '01-01' }]);
+    expect(extractDate('02-01', configuration)).toEqual([{ date: '2001-02-01', originalText: '02-01' }]);
+    expect(extractDate('03-01', configuration)).toEqual([{ date: '2001-03-01', originalText: '03-01' }]);
+    expect(extractDate('04-01', configuration)).toEqual([{ date: '2001-04-01', originalText: '04-01' }]);
+    expect(extractDate('05-01', configuration)).toEqual([{ date: '2000-05-01', originalText: '05-01' }]);
+    expect(extractDate('06-01', configuration)).toEqual([{ date: '2000-06-01', originalText: '06-01' }]);
+    expect(extractDate('07-01', configuration)).toEqual([{ date: '2000-07-01', originalText: '07-01' }]);
+    expect(extractDate('08-01', configuration)).toEqual([{ date: '1999-08-01', originalText: '08-01' }]);
+    expect(extractDate('09-01', configuration)).toEqual([{ date: '1999-09-01', originalText: '09-01' }]);
+    expect(extractDate('10-01', configuration)).toEqual([{ date: '1999-10-01', originalText: '10-01' }]);
+    expect(extractDate('11-01', configuration)).toEqual([{ date: '1999-11-01', originalText: '11-01' }]);
+    expect(extractDate('12-01', configuration)).toEqual([{ date: '1999-12-01', originalText: '12-01' }]);
+});

package/test/extract-date/extractDate/localised.test.d.ts

@@ -0,0 +1 @@
+export {};

package/test/extract-date/extractDate/localised.test.js

@@ -0,0 +1,75 @@
+import { it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { parse as parseDate, } from 'date-fns';
+import extractDate from '@/extractDate';
+beforeEach(() => {
+    vi.useFakeTimers();
+});
+afterEach(() => {
+    vi.useRealTimers();
+});
+it('extracts a localised date (English)', () => {
+    vi.setSystemTime(parseDate('2000-01-01', 'yyyy-MM-dd', new Date()).getTime());
+    const configuration = {
+        locale: 'en',
+    };
+    expect(extractDate('May 1, 2017', configuration)).toEqual([{ date: '2017-05-01', originalText: 'May 1, 2017' }]);
+});
+it('extracts a localised date (French)', () => {
+    vi.setSystemTime(parseDate('2000-01-01', 'yyyy-MM-dd', new Date()).getTime());
+    const configuration = {
+        locale: 'fr',
+    };
+    expect(extractDate('Mai 1, 2017', configuration)).toEqual([{ date: '2017-05-01', originalText: 'Mai 1, 2017' }]);
+});
+it('extracts a localised date with accentless mode (French)', () => {
+    vi.setSystemTime(parseDate('2000-01-01', 'yyyy-MM-dd', new Date()).getTime());
+    const configuration = {
+        translateAccentless: true,
+        locale: 'fr',
+    };
+    expect(extractDate('fevrier 1, 2017', configuration)).toEqual([{ date: '2017-02-01', originalText: 'fevrier 1, 2017' }]);
+});
+it('extracts a localised date for a non-date-fns locale (Afrikaans)', () => {
+    vi.setSystemTime(parseDate('2000-01-01', 'yyyy-MM-dd', new Date()).getTime());
+    const configuration = {
+        locale: 'af',
+    };
+    expect(extractDate('Januarie 1, 2017', configuration)).toEqual([{ date: '2017-01-01', originalText: 'Januarie 1, 2017' }]);
+});
+it('Translation works', () => {
+    vi.setSystemTime(parseDate('2018-01-01', 'yyyy-MM-dd', new Date()).getTime());
+    expect(extractDate('Va bene domani', {
+        translateAccentless: true,
+        locale: 'it',
+    })).toEqual([{ date: '2018-01-02', originalText: 'domani' }]);
+    expect(extractDate('Va bene domani', {
+        translateAccentless: true,
+        locale: 'fr',
+    })).toEqual([]);
+    expect(extractDate('Va bene domani', {
+        translateAccentless: true,
+        locale: 'en',
+    })).toEqual([]);
+});
+// Italian day names carry a grave accent (lunedì, martedì, venerdì…).
+// accentless:true lets callers omit the accent and still get a match.
+// 2018-02-05 is a Monday, so "lunedi 5 febbraio" unambiguously maps to that date.
+it('extracts Italian date with accentless day name', () => {
+    vi.setSystemTime(parseDate('2018-01-01', 'yyyy-MM-dd', new Date()).getTime());
+    expect(extractDate('lunedi 5 febbraio', {
+        translateAccentless: true,
+        locale: 'it',
+    })).toEqual([{ date: '2018-02-05', originalText: 'lunedi 5 febbraio' }]);
+    expect(extractDate('lunedi 5 febbraio', {
+        translateAccentless: false,
+        locale: 'it',
+    })).toEqual([{ date: '2018-02-05', originalText: '5 febbraio' }]);
+    expect(extractDate('lunedì 5 febbraio', {
+        translateAccentless: true,
+        locale: 'it',
+    })).toEqual([{ date: '2018-02-05', originalText: 'lunedi 5 febbraio' }]);
+    expect(extractDate('lunedì 5 febbraio', {
+        translateAccentless: false,
+        locale: 'it',
+    })).toEqual([{ date: '2018-02-05', originalText: 'lunedi 5 febbraio' }]);
+});

package/test/extract-date/extractDate/multiple-dates.test.d.ts

@@ -0,0 +1 @@
+export {};

package/test/extract-date/extractDate/multiple-dates.test.js

@@ -0,0 +1,24 @@
+import { it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { addDays, format as formatDate, parse as parseDate, } from 'date-fns';
+import extractDate from '@/extractDate';
+beforeEach(() => {
+    vi.useFakeTimers();
+});
+afterEach(() => {
+    vi.useRealTimers();
+});
+it('extracts multiple dates', () => {
+    vi.setSystemTime(parseDate('2000-06-01', 'yyyy-MM-dd', new Date()).valueOf());
+    const actual = extractDate(formatDate(new Date(), 'yyyy-MM-dd') + ' ' + formatDate(addDays(new Date(), 1), 'yyyy-MM-dd'));
+    const expected = [
+        {
+            date: formatDate(new Date(), 'yyyy-MM-dd'),
+            originalText: formatDate(new Date(), 'yyyy-MM-dd'),
+        },
+        {
+            date: formatDate(addDays(new Date(), 1), 'yyyy-MM-dd'),
+            originalText: formatDate(addDays(new Date(), 1), 'yyyy-MM-dd'),
+        },
+    ];
+    expect(actual).toEqual(expected);
+});

package/test/extract-date/extractDate/relative-dates.test.d.ts

@@ -0,0 +1 @@
+export {};

package/test/extract-date/extractDate/relative-dates.test.js

@@ -0,0 +1,47 @@
+import { it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { parse as parseDate, } from 'date-fns';
+import extractDate from '@/extractDate';
+beforeEach(() => {
+    vi.useFakeTimers();
+});
+afterEach(() => {
+    vi.useRealTimers();
+});
+it('does not extract relative dates when locale is undefined', () => {
+    vi.setSystemTime(parseDate('2000-01-01', 'yyyy-MM-dd', new Date()).getTime());
+    const configuration = {
+        timezone: 'Europe/London',
+    };
+    expect(extractDate('today', configuration)).toEqual([]);
+});
+it('extracts relative dates when timezone is undefined (uses local time)', () => {
+    vi.setSystemTime(parseDate('2000-01-01', 'yyyy-MM-dd', new Date()).getTime());
+    const configuration = {
+        locale: 'en',
+    };
+    expect(extractDate('today', configuration)).toEqual([{ date: '2000-01-01', originalText: 'today' }]);
+});
+it('extracts relative date (yesterday)', () => {
+    vi.setSystemTime(parseDate('2000-01-02', 'yyyy-MM-dd', new Date()).getTime());
+    const configuration = {
+        locale: 'en',
+        timezone: 'Europe/London',
+    };
+    expect(extractDate('yesterday', configuration)).toEqual([{ date: '2000-01-01', originalText: 'yesterday' }]);
+});
+it('extracts relative date (today)', () => {
+    vi.setSystemTime(parseDate('2000-01-01', 'yyyy-MM-dd', new Date()).getTime());
+    const configuration = {
+        locale: 'en',
+        timezone: 'Europe/London',
+    };
+    expect(extractDate('today', configuration)).toEqual([{ date: '2000-01-01', originalText: 'today' }]);
+});
+it('extracts relative date (tomorrow)', () => {
+    vi.setSystemTime(parseDate('2000-01-01', 'yyyy-MM-dd', new Date()).getTime());
+    const configuration = {
+        locale: 'en',
+        timezone: 'Europe/London',
+    };
+    expect(extractDate('tomorrow', configuration)).toEqual([{ date: '2000-01-02', originalText: 'tomorrow' }]);
+});

package/test/extract-date/extractRelativeDate.test.d.ts

@@ -0,0 +1 @@
+export {};