chrono-node 2.7.0 → 2.7.2

package/src/locales/ru/parsers/RUCasualTimeParser.ts

@@ -1,22 +1,12 @@
 import { ParsingContext } from "../../../chrono";
-import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import * as references from "../../../common/casualReferences";
 import { assignSimilarDate } from "../../../utils/dayjs";
 import dayjs from "dayjs";
-import { REGEX_PARTS } from "../constants";
+import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
-const PATTERN = new RegExp(
-    `(сейчас|прошлым\\s*вечером|прошлой\\s*ночью|следующей\\s*ночью|сегодня\\s*ночью|этой\\s*ночью|ночью|этим утром|утром|утра|в\\s*полдень|вечером|вечера|в\\s*полночь)` +
-        `${REGEX_PARTS.rightBoundary}`,
-    REGEX_PARTS.flags
-);
-export default class RUCasualTimeParser extends AbstractParserWithWordBoundaryChecking {
-    patternLeftBoundary(): string {
-        return REGEX_PARTS.leftBoundary;
-    }
-
-    innerPattern() {
-        return PATTERN;
+export default class RUCasualTimeParser extends AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context: ParsingContext): string {
+        return `(сейчас|прошлым\\s*вечером|прошлой\\s*ночью|следующей\\s*ночью|сегодня\\s*ночью|этой\\s*ночью|ночью|этим утром|утром|утра|в\\s*полдень|вечером|вечера|в\\s*полночь)`;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {

package/src/locales/ru/parsers/RUMonthNameLittleEndianParser.ts

@@ -1,41 +1,31 @@
 import { ParsingContext } from "../../../chrono";
 import { ParsingResult } from "../../../results";
 import { findYearClosestToRef } from "../../../calculation/years";
-import { MONTH_DICTIONARY, REGEX_PARTS } from "../constants";
+import { MONTH_DICTIONARY } from "../constants";
 import { YEAR_PATTERN, parseYear } from "../constants";
 import { ORDINAL_NUMBER_PATTERN, parseOrdinalNumberPattern } from "../constants";
 import { matchAnyPattern } from "../../../utils/pattern";
-import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-
-// prettier-ignore
-const PATTERN = new RegExp(
-    `(?:с)?\\s*(${ORDINAL_NUMBER_PATTERN})` +
-        `(?:` +
-            `\\s{0,3}(?:по|-|–|до)?\\s{0,3}` +
-            `(${ORDINAL_NUMBER_PATTERN})` +
-        `)?` +
-        `(?:-|\\/|\\s{0,3}(?:of)?\\s{0,3})` +
-        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
-        `(?:` +
-            `(?:-|\\/|,?\\s{0,3})` +
-            `(${YEAR_PATTERN}(?![^\\s]\\d))` +
-        `)?` +
-    `${REGEX_PARTS.rightBoundary}`,
-    REGEX_PARTS.flags
-);
+import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
 const DATE_GROUP = 1;
 const DATE_TO_GROUP = 2;
 const MONTH_NAME_GROUP = 3;
 const YEAR_GROUP = 4;
 
-export default class RUMonthNameLittleEndianParser extends AbstractParserWithWordBoundaryChecking {
-    patternLeftBoundary(): string {
-        return REGEX_PARTS.leftBoundary;
-    }
-
-    innerPattern(): RegExp {
-        return PATTERN;
+export default class RUMonthNameLittleEndianParser extends AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context: ParsingContext): string {
+        // prettier-ignore
+        return `(?:с)?\\s*(${ORDINAL_NUMBER_PATTERN})` +
+            `(?:` +
+                `\\s{0,3}(?:по|-|–|до)?\\s{0,3}` +
+                `(${ORDINAL_NUMBER_PATTERN})` +
+            `)?` +
+                `(?:-|\\/|\\s{0,3}(?:of)?\\s{0,3})` +
+                `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+            `(?:` +
+                `(?:-|\\/|,?\\s{0,3})` +
+                `(${YEAR_PATTERN}(?![^\\s]\\d))` +
+            `)?`;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {

package/src/locales/ru/parsers/RUMonthNameParser.ts

@@ -1,20 +1,9 @@
-import { FULL_MONTH_NAME_DICTIONARY, MONTH_DICTIONARY, REGEX_PARTS } from "../constants";
+import { FULL_MONTH_NAME_DICTIONARY, MONTH_DICTIONARY } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { findYearClosestToRef } from "../../../calculation/years";
 import { matchAnyPattern } from "../../../utils/pattern";
 import { YEAR_PATTERN, parseYear } from "../constants";
-import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-
-const PATTERN = new RegExp(
-    `((?:в)\\s*)?` +
-        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
-        `\\s*` +
-        `(?:` +
-        `[,-]?\\s*(${YEAR_PATTERN})?` +
-        `)?` +
-        `(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)`,
-    REGEX_PARTS.flags
-);
+import { AbstractParserWithLeftBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
 const MONTH_NAME_GROUP = 2;
 const YEAR_GROUP = 3;
@@ -25,13 +14,17 @@ const YEAR_GROUP = 3;
  * - Январь 2012
  * - Январь
  */
-export default class RUMonthNameParser extends AbstractParserWithWordBoundaryChecking {
-    patternLeftBoundary(): string {
-        return REGEX_PARTS.leftBoundary;
-    }
-
-    innerPattern(): RegExp {
-        return PATTERN;
+export default class RUMonthNameParser extends AbstractParserWithLeftBoundaryChecking {
+    innerPatternString(context: ParsingContext): string {
+        return (
+            `((?:в)\\s*)?` +
+            `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+            `\\s*` +
+            `(?:` +
+            `[,-]?\\s*(${YEAR_PATTERN})?` +
+            `)?` +
+            `(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)`
+        );
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {

package/src/locales/ru/parsers/RURelativeDateFormatParser.ts

@@ -4,24 +4,16 @@ import { ParsingComponents } from "../../../results";
 import dayjs from "dayjs";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { matchAnyPattern } from "../../../utils/pattern";
-
-const PATTERN = new RegExp(
-    `(в прошлом|на прошлой|на следующей|в следующем|на этой|в этом)\\s*(${matchAnyPattern(
-        TIME_UNIT_DICTIONARY
-    )})(?=\\s*)${REGEX_PARTS.rightBoundary}`,
-    REGEX_PARTS.flags
-);
+import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
 const MODIFIER_WORD_GROUP = 1;
 const RELATIVE_WORD_GROUP = 2;
 
-export default class RURelativeDateFormatParser extends AbstractParserWithWordBoundaryChecking {
-    patternLeftBoundary(): string {
-        return REGEX_PARTS.leftBoundary;
-    }
-
-    innerPattern(): RegExp {
-        return PATTERN;
+export default class RURelativeDateFormatParser extends AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context: ParsingContext): string {
+        return `(в прошлом|на прошлой|на следующей|в следующем|на этой|в этом)\\s*(${matchAnyPattern(
+            TIME_UNIT_DICTIONARY
+        )})`;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {

package/src/locales/ru/parsers/RUTimeUnitAgoFormatParser.ts

@@ -1,18 +1,12 @@
 import { ParsingContext } from "../../../chrono";
-import { parseTimeUnits, REGEX_PARTS, TIME_UNITS_PATTERN } from "../constants";
+import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
 import { ParsingComponents } from "../../../results";
-import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { reverseTimeUnits } from "../../../utils/timeunits";
+import { AbstractParserWithLeftBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
-const PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}назад(?=(?:\\W|$))`, REGEX_PARTS.flags);
-
-export default class RUTimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
-    patternLeftBoundary(): string {
-        return REGEX_PARTS.leftBoundary;
-    }
-
-    innerPattern(): RegExp {
-        return PATTERN;
+export default class RUTimeUnitAgoFormatParser extends AbstractParserWithLeftBoundaryChecking {
+    innerPatternString(context: ParsingContext): string {
+        return `(${TIME_UNITS_PATTERN})\\s{0,5}назад(?=(?:\\W|$))`;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {

package/src/locales/ru/parsers/RUTimeUnitCasualRelativeFormatParser.ts

@@ -1,21 +1,12 @@
 import { TIME_UNITS_PATTERN, parseTimeUnits, REGEX_PARTS } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
-import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { reverseTimeUnits } from "../../../utils/timeunits";
+import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
-const PATTERN = new RegExp(
-    `(эти|последние|прошлые|следующие|после|спустя|через|\\+|-)\\s*(${TIME_UNITS_PATTERN})${REGEX_PARTS.rightBoundary}`,
-    REGEX_PARTS.flags
-);
-
-export default class RUTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
-    patternLeftBoundary(): string {
-        return REGEX_PARTS.leftBoundary;
-    }
-
-    innerPattern(): RegExp {
-        return PATTERN;
+export default class RUTimeUnitCasualRelativeFormatParser extends AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context: ParsingContext): string {
+        return `(эти|последние|прошлые|следующие|после|спустя|через|\\+|-)\\s*(${TIME_UNITS_PATTERN})`;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {

package/src/locales/ru/parsers/RUTimeUnitWithinFormatParser.ts

@@ -4,9 +4,6 @@ import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 
 const PATTERN = `(?:(?:около|примерно)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})${REGEX_PARTS.rightBoundary}`;
-const PATTERN_WITH_PREFIX = new RegExp(`(?:в течение|в течении)\\s*${PATTERN}`, REGEX_PARTS.flags);
-
-const PATTERN_WITHOUT_PREFIX = new RegExp(PATTERN, "i");
 
 export default class RUTimeUnitWithinFormatParser extends AbstractParserWithWordBoundaryChecking {
     patternLeftBoundary(): string {
@@ -14,7 +11,9 @@ export default class RUTimeUnitWithinFormatParser extends AbstractParserWithWord
     }
 
     innerPattern(context: ParsingContext): RegExp {
-        return context.option.forwardDate ? PATTERN_WITHOUT_PREFIX : PATTERN_WITH_PREFIX;
+        return context.option.forwardDate
+            ? new RegExp(PATTERN, REGEX_PARTS.flags)
+            : new RegExp(`(?:в течение|в течении)\\s*${PATTERN}`, REGEX_PARTS.flags);
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {

package/src/locales/ru/parsers/RUWeekdayParser.ts

@@ -1,32 +1,24 @@
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
-import { REGEX_PARTS, WEEKDAY_DICTIONARY } from "../constants";
+import { WEEKDAY_DICTIONARY } from "../constants";
 import { matchAnyPattern } from "../../../utils/pattern";
-import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { createParsingComponentsAtWeekday } from "../../../common/calculation/weekdays";
-
-const PATTERN = new RegExp(
-    `(?:(?:,|\\(|（)\\s*)?` +
-        `(?:в\\s*?)?` +
-        `(?:(эту|этот|прошлый|прошлую|следующий|следующую|следующего)\\s*)?` +
-        `(${matchAnyPattern(WEEKDAY_DICTIONARY)})` +
-        `(?:\\s*(?:,|\\)|）))?` +
-        `(?:\\s*на\\s*(этой|прошлой|следующей)\\s*неделе)?` +
-        `${REGEX_PARTS.rightBoundary}`,
-    REGEX_PARTS.flags
-);
+import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
 const PREFIX_GROUP = 1;
 const WEEKDAY_GROUP = 2;
 const POSTFIX_GROUP = 3;
 
-export default class RUWeekdayParser extends AbstractParserWithWordBoundaryChecking {
-    innerPattern(): RegExp {
-        return PATTERN;
-    }
-
-    patternLeftBoundary(): string {
-        return REGEX_PARTS.leftBoundary;
+export default class RUWeekdayParser extends AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context: ParsingContext): string {
+        return (
+            `(?:(?:,|\\(|（)\\s*)?` +
+            `(?:в\\s*?)?` +
+            `(?:(эту|этот|прошлый|прошлую|следующий|следующую|следующего)\\s*)?` +
+            `(${matchAnyPattern(WEEKDAY_DICTIONARY)})` +
+            `(?:\\s*(?:,|\\)|）))?` +
+            `(?:\\s*на\\s*(этой|прошлой|следующей)\\s*неделе)?`
+        );
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {

package/test/en/en.test.ts

@@ -107,10 +107,10 @@ test("Test - Random text", function () {
         expect(result.end.get("month")).toBe(7);
     });
 
-    testSingleCase(chrono, "03-27-2022, 02:00 AM", new Date(2017, 7 - 1, 7), (result) => {
-        expect(result.text).toBe("03-27-2022, 02:00 AM");
+    testSingleCase(chrono, "07-27-2022, 02:00 AM", new Date(2017, 7 - 1, 7), (result) => {
+        expect(result.text).toBe("07-27-2022, 02:00 AM");
         expect(result.start.get("day")).toBe(27);
-        expect(result.start.get("month")).toBe(3);
+        expect(result.start.get("month")).toBe(7);
         expect(result.start.get("year")).toBe(2022);
         expect(result.start.get("hour")).toBe(2);
         expect(result.start.get("meridiem")).toBe(Meridiem.AM);

package/test/result.test.ts

@@ -146,3 +146,32 @@ test("Test - Calendar Checking", () => {
         expect(components.isValidDate()).toBe(false);
     }
 });
+
+test("Test - Checking non-existing date during DST skip", () => {
+    // Only CET (or CEST) timezones where the DST starts on "Sunday, March 27, 2022" at "02:00 (2 am) local time"
+    const dateDstPre = new Date(2022, 3 - 1, 27, 2);
+    const dateDstPost = new Date(2022, 3 - 1, 27, 3);
+    if (dateDstPre.getTime() == dateDstPost.getTime()) {
+        const reference = new ReferenceWithTimezone(new Date());
+
+        // On "Sunday, March 27, 2022" at "02:00 local time", the clock is moved forward to "03:00 local time".
+        // Thus, the time between "02:00 and 02:59:59" does not exist.
+        expect(
+            new ParsingComponents(reference, { year: 2022, month: 3, day: 27, hour: 2, minute: 0 }).isValidDate()
+        ).toBe(false);
+        expect(
+            new ParsingComponents(reference, { year: 2022, month: 3, day: 27, hour: 2, minute: 1 }).isValidDate()
+        ).toBe(false);
+        expect(
+            new ParsingComponents(reference, { year: 2022, month: 3, day: 27, hour: 2, minute: 59 }).isValidDate()
+        ).toBe(false);
+
+        // Otherwise, it
+        expect(
+            new ParsingComponents(reference, { year: 2022, month: 3, day: 27, hour: 1, minute: 59 }).isValidDate()
+        ).toBe(true);
+        expect(
+            new ParsingComponents(reference, { year: 2022, month: 3, day: 27, hour: 3, minute: 0 }).isValidDate()
+        ).toBe(true);
+    }
+});

package/test/ru/ru_relative.test.ts

@@ -5,25 +5,37 @@ test("Test - 'This' expressions", () => {
     testSingleCase(chrono.ru, "на этой неделе", new Date(2017, 11 - 1, 19, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 11 - 1, 19, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(19);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "в этом месяце", new Date(2017, 11 - 1, 19, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 11 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "в этом месяце", new Date(2017, 11 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 11 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "в этом году", new Date(2017, 11 - 1, 19, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 1 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(1);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 });
 
@@ -31,19 +43,28 @@ test("Test - Past relative expressions", () => {
     testSingleCase(chrono.ru, "на прошлой неделе", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 9 - 1, 24, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(24);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "в прошлом месяце", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 9 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "в прошлом году", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2015, 10 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2015);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 });
 
@@ -51,24 +72,36 @@ test("Test - Future relative expressions", () => {
     testSingleCase(chrono.ru, "на следующей неделе", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 10 - 1, 8, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(8);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "в следующем месяце", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 11 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "в следующем квартале", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 1 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(1);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "в следующем году", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 10 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 });