@louis.jln/extract-date 3.0.0 → 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

@@ -1,214 +1,157 @@
-// @flow
-
-/* eslint-disable no-continue, no-negated-condition, import/no-namespace */
-
-import {
-  format as formatDate,
-  parse as parseDate,
-  isValid as isValidDate,
-} from 'date-fns';
-import * as locales from 'date-fns/locale';
+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 type {
-  ConfigurationType,
-  DateMatchType,
-  UserConfigurationType,
-} from './types';
-
+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,
+    maximumAge: Infinity,
+    minimumAge: Infinity,
 };
-
+const stripDiacritics = (text) => text.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
 const formats = createFormats();
-
-const dateFnsLocaleMap = {
-  en: 'enUS',
-};
-
-// eslint-disable-next-line complexity
-export default (input: string, userConfiguration: UserConfigurationType = defaultConfiguration): $ReadOnlyArray<DateMatchType> => {
-  const normalizedInput = normalizeInput(input);
-
-  const configuration: ConfigurationType = {
-    ...defaultConfiguration,
-    ...userConfiguration,
-  };
-
-  const locale = configuration.locale || 'en';
-
-  const dateFnsLocale = locales[dateFnsLocaleMap[locale] || locale];
-
-  if (!dateFnsLocale) {
-    throw new Error('No translation available for the target locale (date-fns).');
-  }
-
-  if (!dictionary[locale]) {
-    throw new Error('No translation available for the target locale (relative dates).');
-  }
-
-  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 (!configuration.timezone) {
-        } else {
-          const maybeDate = extractRelativeDate(subject, configuration.locale, configuration.timezone);
-
-          if (maybeDate) {
-            words = words.slice(wordOffset);
-
-            matches.push({
-              date: maybeDate,
-              originalText: subject,
-            });
-          }
+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;
         }
-      } else if (format.dateFnsFormat === 'EEE' || format.dateFnsFormat === 'EEEE') {
-        const date = parseDate(
-          subject,
-          format.dateFnsFormat,
-          baseDate,
-          {
-            locale: dateFnsLocale,
-          },
-        );
-
-        if (isValidDate(date)) {
-          words = words.slice(wordOffset);
-
-          matches.push({
-            date: formatDate(date, 'yyyy-MM-dd'),
-            originalText: subject,
-          });
+        const dayReplacement = replaceDayName(cleanWord, locale, translateAccentless);
+        if (dayReplacement) {
+            return dayReplacement + punctuation;
         }
-      } else {
-        const yearIsExplicit = typeof format.yearIsExplicit === 'boolean' ? format.yearIsExplicit : true;
-
-        if (yearIsExplicit) {
-          const date = parseDate(
-            subject,
-            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: subject,
-          });
-        } else {
-          const date = parseDate(
-            subject,
-            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: subject,
-          });
+        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;
+    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

@@ -1,34 +1,23 @@
-// @flow
-
 import moment from 'moment-timezone';
 import dictionary from 'relative-date-names';
-
-export default (subject: string, locale: string, timezone: string): ?string => {
-  const translation = dictionary[locale];
-
-  if (!translation) {
-    throw new Error('No translation available for the target locale.');
-  }
-
-  if (!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;
+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

@@ -1,6 +1,2 @@
-// @flow
-
-/* eslint-disable filenames/match-exported */
-import extractDate from './extractDate';
-
+import extractDate from '@/extractDate';
 export default extractDate;