chrono-node 2.3.6 → 2.3.7

package/README.md

@@ -133,7 +133,7 @@ For example:
 ```js
 const results = chrono.parse('I have an appointment tomorrow from 10 to 11 AM');
 
-results[0].index;     // 15
+results[0].index;     // 22
 results[0].text;      // 'tomorrow from 10 to 11 AM'
 results[0].refDate;   // Sat Dec 13 2014 21:50:14 GMT-0600 (CST)
 

package/dist/locales/en/index.js

@@ -23,6 +23,7 @@ const ENRelativeDateFormatParser_1 = __importDefault(require("./parsers/ENRelati
 const chrono_1 = require("../../chrono");
 const SlashDateFormatParser_1 = __importDefault(require("../../common/parsers/SlashDateFormatParser"));
 const ENTimeUnitCasualRelativeFormatParser_1 = __importDefault(require("./parsers/ENTimeUnitCasualRelativeFormatParser"));
+const ENMergeRelativeDateRefiner_1 = __importDefault(require("./refiners/ENMergeRelativeDateRefiner"));
 exports.casual = new chrono_1.Chrono(createCasualConfiguration(false));
 exports.strict = new chrono_1.Chrono(createConfiguration(true, false));
 exports.GB = new chrono_1.Chrono(createConfiguration(false, true));
@@ -58,7 +59,7 @@ function createConfiguration(strictMode = true, littleEndian = false) {
             new ENTimeUnitAgoFormatParser_1.default(strictMode),
             new ENTimeUnitLaterFormatParser_1.default(strictMode),
         ],
-        refiners: [new ENMergeDateTimeRefiner_1.default(), new ENMergeDateRangeRefiner_1.default()],
+        refiners: [new ENMergeRelativeDateRefiner_1.default(), new ENMergeDateTimeRefiner_1.default(), new ENMergeDateRangeRefiner_1.default()],
     }, strictMode);
 }
 exports.createConfiguration = createConfiguration;

package/dist/locales/en/parsers/ENRelativeDateFormatParser.js

@@ -8,7 +8,7 @@ const results_1 = require("../../../results");
 const dayjs_1 = __importDefault(require("dayjs"));
 const AbstractParserWithWordBoundary_1 = require("../../../common/parsers/AbstractParserWithWordBoundary");
 const pattern_1 = require("../../../utils/pattern");
-const PATTERN = new RegExp(`(this|next|last|past)\\s*(${pattern_1.matchAnyPattern(constants_1.TIME_UNIT_DICTIONARY)})(?=\\s*)` + "(?=\\W|$)", "i");
+const PATTERN = new RegExp(`(this|last|past|next|after\\s*this)\\s*(${pattern_1.matchAnyPattern(constants_1.TIME_UNIT_DICTIONARY)})(?=\\s*)` + "(?=\\W|$)", "i");
 const MODIFIER_WORD_GROUP = 1;
 const RELATIVE_WORD_GROUP = 2;
 class ENRelativeDateFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {
@@ -19,7 +19,7 @@ class ENRelativeDateFormatParser extends AbstractParserWithWordBoundary_1.Abstra
         const modifier = match[MODIFIER_WORD_GROUP].toLowerCase();
         const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();
         const timeunit = constants_1.TIME_UNIT_DICTIONARY[unitWord];
-        if (modifier == "next") {
+        if (modifier == "next" || modifier.startsWith("after")) {
             const timeUnits = {};
             timeUnits[timeunit] = 1;
             return results_1.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);

package/dist/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser.js

@@ -4,7 +4,7 @@ const constants_1 = require("../constants");
 const results_1 = require("../../../results");
 const AbstractParserWithWordBoundary_1 = require("../../../common/parsers/AbstractParserWithWordBoundary");
 const timeunits_1 = require("../../../utils/timeunits");
-const PATTERN = new RegExp(`(this|last|past|next|\\+|-)\\s*(${constants_1.TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+const PATTERN = new RegExp(`(this|last|past|next|after|\\+|-)\\s*(${constants_1.TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
 class ENTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {
     innerPattern() {
         return PATTERN;

package/dist/locales/en/refiners/ENMergeRelativeDateRefiner.d.ts

@@ -0,0 +1,7 @@
+import { MergingRefiner } from "../../../common/abstractRefiners";
+import { ParsingResult } from "../../../results";
+export default class ENMergeRelativeDateRefiner extends MergingRefiner {
+    patternBetween(): RegExp;
+    shouldMergeResults(textBetween: string, currentResult: ParsingResult, nextResult: ParsingResult): boolean;
+    mergeResults(textBetween: string, currentResult: ParsingResult, nextResult: ParsingResult): ParsingResult;
+}

package/dist/locales/en/refiners/ENMergeRelativeDateRefiner.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const abstractRefiners_1 = require("../../../common/abstractRefiners");
+const results_1 = require("../../../results");
+const constants_1 = require("../constants");
+const timeunits_1 = require("../../../utils/timeunits");
+function hasImpliedEarlierReferenceDate(result) {
+    return result.text.match(/\s+(before|from)$/i) != null;
+}
+function hasImpliedLaterReferenceDate(result) {
+    return result.text.match(/\s+(after|since)$/i) != null;
+}
+class ENMergeRelativeDateRefiner extends abstractRefiners_1.MergingRefiner {
+    patternBetween() {
+        return /^\s*$/i;
+    }
+    shouldMergeResults(textBetween, currentResult, nextResult) {
+        if (!textBetween.match(this.patternBetween())) {
+            return false;
+        }
+        if (!hasImpliedEarlierReferenceDate(currentResult) && !hasImpliedLaterReferenceDate(currentResult)) {
+            return false;
+        }
+        return !!nextResult.start.get("day") && !!nextResult.start.get("month") && !!nextResult.start.get("year");
+    }
+    mergeResults(textBetween, currentResult, nextResult) {
+        let timeUnits = constants_1.parseTimeUnits(currentResult.text);
+        if (hasImpliedEarlierReferenceDate(currentResult)) {
+            timeUnits = timeunits_1.reverseTimeUnits(timeUnits);
+        }
+        const components = results_1.ParsingComponents.createRelativeFromReference(new results_1.ReferenceWithTimezone(nextResult.start.date()), timeUnits);
+        return new results_1.ParsingResult(nextResult.reference, currentResult.index, `${currentResult.text}${textBetween}${nextResult.text}`, components);
+    }
+}
+exports.default = ENMergeRelativeDateRefiner;

package/dist/timezone.js

@@ -117,7 +117,7 @@ exports.TIMEZONE_ABBR_MAP = {
     MHT: 720,
     MMT: 390,
     MSD: 240,
-    MSK: 240,
+    MSK: 180,
     MST: -420,
     MUT: 240,
     MVT: 300,

package/package.json

@@ -15,7 +15,7 @@
     "preset": "ts-jest"
   },
   "license": "MIT",
-  "version": "2.3.6",
+  "version": "2.3.7",
   "directories": {
     "source": "./src",
     "test": "./test"

package/src/locales/en/index.ts

@@ -26,6 +26,7 @@ import { ParsedResult, ParsingOption } from "../../index";
 import { Chrono, Configuration } from "../../chrono";
 import SlashDateFormatParser from "../../common/parsers/SlashDateFormatParser";
 import ENTimeUnitCasualRelativeFormatParser from "./parsers/ENTimeUnitCasualRelativeFormatParser";
+import ENMergeRelativeDateRefiner from "./refiners/ENMergeRelativeDateRefiner";
 
 /**
  * Chrono object configured for parsing *casual* English
@@ -91,7 +92,7 @@ export function createConfiguration(strictMode = true, littleEndian = false): Co
                 new ENTimeUnitAgoFormatParser(strictMode),
                 new ENTimeUnitLaterFormatParser(strictMode),
             ],
-            refiners: [new ENMergeDateTimeRefiner(), new ENMergeDateRangeRefiner()],
+            refiners: [new ENMergeRelativeDateRefiner(), new ENMergeDateTimeRefiner(), new ENMergeDateRangeRefiner()],
         },
         strictMode
     );

package/src/locales/en/parsers/ENRelativeDateFormatParser.ts

@@ -6,7 +6,7 @@ import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/
 import { matchAnyPattern } from "../../../utils/pattern";
 
 const PATTERN = new RegExp(
-    `(this|next|last|past)\\s*(${matchAnyPattern(TIME_UNIT_DICTIONARY)})(?=\\s*)` + "(?=\\W|$)",
+    `(this|last|past|next|after\\s*this)\\s*(${matchAnyPattern(TIME_UNIT_DICTIONARY)})(?=\\s*)` + "(?=\\W|$)",
     "i"
 );
 
@@ -23,7 +23,7 @@ export default class ENRelativeDateFormatParser extends AbstractParserWithWordBo
         const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();
         const timeunit = TIME_UNIT_DICTIONARY[unitWord];
 
-        if (modifier == "next") {
+        if (modifier == "next" || modifier.startsWith("after")) {
             const timeUnits = {};
             timeUnits[timeunit] = 1;
             return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);

package/src/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser.ts

@@ -4,7 +4,7 @@ import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { reverseTimeUnits } from "../../../utils/timeunits";
 
-const PATTERN = new RegExp(`(this|last|past|next|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+const PATTERN = new RegExp(`(this|last|past|next|after|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
 
 export default class ENTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern(): RegExp {

package/src/locales/en/refiners/ENMergeRelativeDateRefiner.ts

@@ -0,0 +1,58 @@
+import { MergingRefiner } from "../../../common/abstractRefiners";
+import { ParsingComponents, ParsingResult, ReferenceWithTimezone } from "../../../results";
+import { parseTimeUnits } from "../constants";
+import { reverseTimeUnits } from "../../../utils/timeunits";
+
+function hasImpliedEarlierReferenceDate(result: ParsingResult): boolean {
+    return result.text.match(/\s+(before|from)$/i) != null;
+}
+
+function hasImpliedLaterReferenceDate(result: ParsingResult): boolean {
+    return result.text.match(/\s+(after|since)$/i) != null;
+}
+
+/**
+ * Merges an absolute date with a relative date.
+ * - 2 weeks before 2020-02-13
+ * - 2 days after next Friday
+ */
+export default class ENMergeRelativeDateRefiner extends MergingRefiner {
+    patternBetween(): RegExp {
+        return /^\s*$/i;
+    }
+
+    shouldMergeResults(textBetween: string, currentResult: ParsingResult, nextResult: ParsingResult): boolean {
+        // Dates need to be next to each other to get merged
+        if (!textBetween.match(this.patternBetween())) {
+            return false;
+        }
+
+        // Check if any relative tokens were swallowed by the first date.
+        // E.g. [<relative_date1> from] [<date2>]
+        if (!hasImpliedEarlierReferenceDate(currentResult) && !hasImpliedLaterReferenceDate(currentResult)) {
+            return false;
+        }
+
+        // make sure that <date2> implies an absolute date
+        return !!nextResult.start.get("day") && !!nextResult.start.get("month") && !!nextResult.start.get("year");
+    }
+
+    mergeResults(textBetween: string, currentResult: ParsingResult, nextResult: ParsingResult): ParsingResult {
+        let timeUnits = parseTimeUnits(currentResult.text);
+        if (hasImpliedEarlierReferenceDate(currentResult)) {
+            timeUnits = reverseTimeUnits(timeUnits);
+        }
+
+        const components = ParsingComponents.createRelativeFromReference(
+            new ReferenceWithTimezone(nextResult.start.date()),
+            timeUnits
+        );
+
+        return new ParsingResult(
+            nextResult.reference,
+            currentResult.index,
+            `${currentResult.text}${textBetween}${nextResult.text}`,
+            components
+        );
+    }
+}

package/src/timezone.ts

@@ -114,7 +114,7 @@ export const TIMEZONE_ABBR_MAP = {
     MHT: 720,
     MMT: 390,
     MSD: 240,
-    MSK: 240,
+    MSK: 180,
     MST: -420,
     MUT: 240,
     MVT: 300,

package/test/en/en_merging_relative_dates.test.ts

@@ -0,0 +1,51 @@
+import * as chrono from "../../src";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", function () {
+    testSingleCase(chrono.casual, "2 weeks after yesterday", new Date(2022, 2 - 1, 2), (result) => {
+        expect(result.text).toBe("2 weeks after yesterday");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2022);
+        expect(result.start.get("month")).toBe(2);
+        expect(result.start.get("day")).toBe(15);
+        expect(result.start.get("weekday")).toBe(2);
+
+        expect(result.start.isCertain("day")).toBe(false);
+        expect(result.start.isCertain("month")).toBe(false);
+        expect(result.start.isCertain("year")).toBe(false);
+        expect(result.start.isCertain("weekday")).toBe(false);
+
+        expect(result.start).toBeDate(new Date(2022, 2 - 1, 15, 0));
+    });
+
+    testSingleCase(chrono.casual, "2 months before 02/02", new Date(2022, 2 - 1, 2), (result) => {
+        expect(result.text).toBe("2 months before 02/02");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2021);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.start.get("day")).toBe(2);
+
+        expect(result.start.isCertain("day")).toBe(false);
+        expect(result.start.isCertain("month")).toBe(true);
+        expect(result.start.isCertain("year")).toBe(true);
+
+        expect(result.start).toBeDate(new Date(2021, 12 - 1, 2, 12));
+    });
+
+    testSingleCase(chrono.casual, "2 days after next Friday", new Date(2022, 2 - 1, 2), (result) => {
+        expect(result.text).toBe("2 days after next Friday");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2022);
+        expect(result.start.get("month")).toBe(2);
+        expect(result.start.get("day")).toBe(13);
+
+        expect(result.start.isCertain("day")).toBe(true);
+        expect(result.start.isCertain("month")).toBe(true);
+        expect(result.start.isCertain("year")).toBe(true);
+
+        expect(result.start).toBeDate(new Date(2022, 2 - 1, 13, 12));
+    });
+});

package/test/en/en_relative.test.ts

@@ -135,6 +135,26 @@ test("Test - Future relative expressions", () => {
         expect(result.start.isCertain("millisecond")).toBe(false);
         expect(result.start.isCertain("timezoneOffset")).toBe(false);
     });
+
+    testSingleCase(chrono, "after this year", new Date(2020, 11 - 1, 22, 12, 11, 32, 6), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2021);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(22);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(11);
+        expect(result.start.get("second")).toBe(32);
+        expect(result.start.get("millisecond")).toBe(6);
+
+        expect(result.start.isCertain("year")).toBe(true);
+        expect(result.start.isCertain("month")).toBe(false);
+        expect(result.start.isCertain("day")).toBe(false);
+        expect(result.start.isCertain("hour")).toBe(false);
+        expect(result.start.isCertain("minute")).toBe(false);
+        expect(result.start.isCertain("second")).toBe(false);
+        expect(result.start.isCertain("millisecond")).toBe(false);
+        expect(result.start.isCertain("timezoneOffset")).toBe(false);
+    });
 });
 
 test("Test - Relative date components' certainty", () => {

package/test/en/en_time_units_casual_relative.test.ts

@@ -32,6 +32,22 @@ test("Test - Positive time units", () => {
         expect(result.start.get("day")).toBe(18);
         expect(result.start.get("hour")).toBe(12);
     });
+
+    testSingleCase(chrono, "after a year", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        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);
+    });
+
+    testSingleCase(chrono, "after an hour", new Date(2016, 10 - 1, 1, 15), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(16);
+    });
 });
 
 test("Test - Negative time units", () => {