@louis.jln/extract-date 3.0.1 → 4.0.0

package/src/extractDate.d.ts

@@ -0,0 +1,3 @@
+import type { DateMatchType, UserConfigurationType } from '@/types';
+declare const _default: (input: string, userConfiguration?: UserConfigurationType) => readonly DateMatchType[];
+export default _default;

package/src/extractDate.js

@@ -0,0 +1,157 @@
+import { format as formatDate, parse as parseDate, isValid as isValidDate, } from 'date-fns';
+import { enUS as dateFnsLocale } from 'date-fns/locale';
+import moment from 'moment-timezone';
+import dictionary from 'relative-date-names';
+import createMovingChunks from '@/createMovingChunks';
+import extractRelativeDate from '@/extractRelativeDate';
+import createFormats from '@/createFormats';
+import normalizeInput from '@/normalizeInput';
+import { replaceMonthName, replaceDayName } from '@/resolveLocalizedNames';
+import monthsData from '@/months.json';
+const defaultConfiguration = {
+    maximumAge: Infinity,
+    minimumAge: Infinity,
+};
+const stripDiacritics = (text) => text.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+const formats = createFormats();
+const translateChunk = (subject, locale, translateAccentless) => {
+    if (locale === 'en') {
+        return subject;
+    }
+    return subject.split(' ').map((word) => {
+        // Preserve trailing punctuation (e.g. commas)
+        const punctuationMatch = word.match(/^(.+?)([,]+)$/);
+        const cleanWord = punctuationMatch ? punctuationMatch[1] : word;
+        const punctuation = punctuationMatch ? punctuationMatch[2] : '';
+        const monthReplacement = replaceMonthName(cleanWord, locale, translateAccentless);
+        if (monthReplacement) {
+            return monthReplacement + punctuation;
+        }
+        const dayReplacement = replaceDayName(cleanWord, locale, translateAccentless);
+        if (dayReplacement) {
+            return dayReplacement + punctuation;
+        }
+        return word;
+    }).join(' ');
+};
+export default (input, userConfiguration = defaultConfiguration) => {
+    const normalizedInput = normalizeInput(input);
+    const configuration = {
+        ...defaultConfiguration,
+        ...userConfiguration,
+    };
+    const locale = configuration.locale || 'en';
+    const translateAccentless = Boolean(configuration.translateAccentless);
+    if (!monthsData[locale]) {
+        throw new Error('No translation available for the target locale.');
+    }
+    const hasRelativeDateSupport = Boolean(dictionary[locale]);
+    if (configuration.timezone && !moment.tz.zone(configuration.timezone)) {
+        throw new Error('Unrecognized timezone.');
+    }
+    if (configuration.maximumAge && configuration.maximumAge < 0) {
+        throw new Error('`maximumAge` must be a positive number.');
+    }
+    if (configuration.minimumAge && configuration.minimumAge < 0) {
+        throw new Error('`minimumAge` must be a positive number.');
+    }
+    let words = normalizedInput.split(' ');
+    const matches = [];
+    const baseDate = parseDate('12:00', 'HH:mm', new Date());
+    for (const format of formats) {
+        const movingChunks = createMovingChunks(words, format.wordCount);
+        let chunkIndex = 0;
+        for (const movingChunk of movingChunks) {
+            const wordOffset = ++chunkIndex * format.wordCount;
+            const subject = movingChunk.join(' ');
+            if (format.dateFnsFormat === 'R') {
+                if (!configuration.locale) {
+                }
+                else if (!hasRelativeDateSupport) {
+                }
+                else {
+                    const maybeDate = extractRelativeDate(subject, configuration.locale, configuration.timezone ?? '');
+                    if (maybeDate) {
+                        words = words.slice(wordOffset);
+                        matches.push({
+                            date: maybeDate,
+                            originalText: stripDiacritics(subject),
+                        });
+                    }
+                }
+            }
+            else if (format.dateFnsFormat === 'EEE' || format.dateFnsFormat === 'EEEE') {
+                const translatedSubject = translateChunk(subject, locale, translateAccentless);
+                const date = parseDate(translatedSubject, format.dateFnsFormat, baseDate, { locale: dateFnsLocale });
+                if (isValidDate(date)) {
+                    words = words.slice(wordOffset);
+                    matches.push({
+                        date: formatDate(date, 'yyyy-MM-dd'),
+                        originalText: stripDiacritics(subject),
+                    });
+                }
+            }
+            else {
+                const yearIsExplicit = typeof format.yearIsExplicit === 'boolean' ? format.yearIsExplicit : true;
+                const translatedSubject = format.localised ? translateChunk(subject, locale, translateAccentless) : subject;
+                if (yearIsExplicit) {
+                    const date = parseDate(translatedSubject, format.dateFnsFormat, baseDate, { locale: dateFnsLocale });
+                    if (!isValidDate(date)) {
+                        continue;
+                    }
+                    const formatDirection = format.direction;
+                    const configurationDirection = configuration.direction;
+                    if (formatDirection && configurationDirection && format.dateFnsFormat.includes('yyyy') && formatDirection.replace('Y', '') === configurationDirection.replace('Y', '')) {
+                    }
+                    else if (format.direction && format.direction !== configuration.direction) {
+                        continue;
+                    }
+                    if (format.direction && !configuration.direction) {
+                        continue;
+                    }
+                    words = words.slice(wordOffset);
+                    matches.push({
+                        date: formatDate(date, 'yyyy-MM-dd'),
+                        originalText: stripDiacritics(subject),
+                    });
+                }
+                else {
+                    const date = parseDate(translatedSubject, format.dateFnsFormat, baseDate, { locale: dateFnsLocale });
+                    if (!isValidDate(date)) {
+                        continue;
+                    }
+                    const currentYear = parseInt(formatDate(baseDate, 'yyyy'), 10);
+                    const currentMonth = parseInt(formatDate(baseDate, 'M'), 10) + currentYear * 12;
+                    const parsedMonth = parseInt(formatDate(date, 'M'), 10) + parseInt(formatDate(date, 'yyyy'), 10) * 12;
+                    const difference = parsedMonth - currentMonth;
+                    let useYear;
+                    if (difference >= configuration.maximumAge) {
+                        useYear = currentYear - 1;
+                    }
+                    else if (difference < 0 && Math.abs(difference) >= configuration.minimumAge) {
+                        useYear = currentYear + 1;
+                    }
+                    else {
+                        useYear = currentYear;
+                    }
+                    const maybeDate = parseDate(useYear + '-' + formatDate(date, 'MM-dd'), 'yyyy-MM-dd', baseDate, { locale: dateFnsLocale });
+                    if (!isValidDate(maybeDate)) {
+                        continue;
+                    }
+                    if (format.direction && format.direction !== configuration.direction) {
+                        continue;
+                    }
+                    if (format.direction && !configuration.direction) {
+                        continue;
+                    }
+                    words = words.slice(wordOffset);
+                    matches.push({
+                        date: formatDate(maybeDate, 'yyyy-MM-dd'),
+                        originalText: stripDiacritics(subject),
+                    });
+                }
+            }
+        }
+    }
+    return matches;
+};

package/src/extractRelativeDate.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (subject: string, locale: string, timezone: string) => string | null;
+export default _default;

package/src/extractRelativeDate.js

@@ -0,0 +1,23 @@
+import moment from 'moment-timezone';
+import dictionary from 'relative-date-names';
+export default (subject, locale, timezone) => {
+    const translation = dictionary[locale];
+    if (!translation) {
+        throw new Error('No translation available for the target locale.');
+    }
+    if (timezone && !moment.tz.zone(timezone)) {
+        throw new Error('Unrecognized timezone.');
+    }
+    const normalizedSubject = subject.toLowerCase();
+    const now = moment();
+    if (normalizedSubject === translation.day.relative.yesterday) {
+        return now.subtract(1, 'day').format('YYYY-MM-DD');
+    }
+    if (normalizedSubject === translation.day.relative.today) {
+        return now.format('YYYY-MM-DD');
+    }
+    if (normalizedSubject === translation.day.relative.tomorrow) {
+        return now.add(1, 'day').format('YYYY-MM-DD');
+    }
+    return null;
+};

package/src/index.d.ts

@@ -0,0 +1,2 @@
+import extractDate from '@/extractDate';
+export default extractDate;

package/src/index.js

@@ -0,0 +1,2 @@
+import extractDate from '@/extractDate';
+export default extractDate;