chrono-node 2.6.1 → 2.6.3

package/test/en/en_time_units_casual_relative.test.ts

@@ -1,5 +1,6 @@
 import * as chrono from "../../src";
 import { testSingleCase, testUnexpectedResult } from "../test_util";
+import ENTimeUnitCasualRelativeFormatParser from "../../src/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser";
 
 test("Test - Positive time units", () => {
     testSingleCase(chrono, "next 2 weeks", new Date(2016, 10 - 1, 1, 12), (result, text) => {
@@ -141,6 +142,23 @@ test("Test - Minus '-' sign", () => {
     });
 });
 
+test("Test - Without custom parser without abbreviations", function () {
+    const custom = chrono.en.strict.clone();
+    custom.parsers.push(new ENTimeUnitCasualRelativeFormatParser(false));
+
+    testUnexpectedResult(custom, "-3y");
+    testUnexpectedResult(custom, "last 2m");
+
+    testSingleCase(custom, "-2 hours 5 minutes", new Date(2016, 10 - 1, 1, 12), (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(9);
+        expect(result.start.get("minute")).toBe(55);
+    });
+});
+
 test("Test - Negative cases", () => {
     testUnexpectedResult(chrono.casual, "3y", new Date(2015, 7 - 1, 10, 12, 14));
     testUnexpectedResult(chrono.casual, "1 m", new Date(2015, 7 - 1, 10, 12, 14));

package/test/en/en_time_units_later.test.ts

@@ -1,5 +1,5 @@
 import * as chrono from "../../src/";
-import { testSingleCase } from "../test_util";
+import { testSingleCase, testUnexpectedResult } from "../test_util";
 import { Meridiem } from "../../src/";
 
 test("Test - Later Expression", function () {
@@ -262,6 +262,16 @@ test("Test - From now Expression", () => {
 });
 
 test("Test - Strict mode", function () {
+    testSingleCase(chrono, "the min after", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("the min after");
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(15);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 15));
+    });
+
     testSingleCase(chrono.strict, "15 minutes from now", new Date(2012, 7, 10, 12, 14), (result, text) => {
         expect(result.text).toBe(text);
         expect(result.start.get("hour")).toBe(12);
@@ -279,15 +289,8 @@ test("Test - Strict mode", function () {
         expect(result.start).toBeDate(new Date(2012, 7, 10, 13, 5));
     });
 
-    testSingleCase(chrono, "the min after", new Date(2012, 7, 10, 12, 14), (result) => {
-        expect(result.index).toBe(0);
-        expect(result.text).toBe("the min after");
-        expect(result.start.get("hour")).toBe(12);
-        expect(result.start.get("minute")).toBe(15);
-        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
-
-        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 15));
-    });
+    testUnexpectedResult(chrono.strict, "15m from now");
+    testUnexpectedResult(chrono.strict, "15s later");
 });
 
 test("Test - After with reference", () => {

package/test/en/en_time_units_within.test.ts

@@ -1,5 +1,6 @@
 import * as chrono from "../../src";
-import { testSingleCase } from "../test_util";
+import { testSingleCase, testUnexpectedResult } from "../test_util";
+import { Meridiem } from "../../src";
 
 test("Test - The normal within expression", () => {
     testSingleCase(chrono, "we have to make something in 5 days.", new Date(2012, 7, 10), (result) => {
@@ -327,3 +328,13 @@ test("Test - Time units' certainty", () => {
         expect(result.start.isCertain("minute")).toBeFalsy();
     });
 });
+
+test("Test - Strict mode", function () {
+    testSingleCase(chrono, "in 2hour", new Date(2016, 10 - 1, 1, 14, 52), (result, text) => {
+        expect(result.start.get("hour")).toBe(16);
+        expect(result.start.get("minute")).toBe(52);
+    });
+
+    testUnexpectedResult(chrono.strict, "in 15m");
+    testUnexpectedResult(chrono.strict, "within 5hr");
+});

package/test/en/en_timezone_exp.test.ts

@@ -1,4 +1,6 @@
 import * as chrono from "../../src";
+import { Month, Weekday } from "../../src";
+import { getLastWeekdayOfMonth } from "../../src/timezone";
 import { testSingleCase } from "../test_util";
 
 test("Test - Parsing date/time with UTC offset", function () {
@@ -100,6 +102,146 @@ test("Test - Parsing date/time with timezone abbreviation", function () {
     });
 });
 
+test("Test - Parsing date/time with ambiguous timezone abbreviations", function () {
+    // Test dates around transition to DST for ET
+    testSingleCase(chrono, "2022-03-12 23:00 ET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-5 * 60); // ET during standard time (EST) in 2022
+    });
+    testSingleCase(chrono, "2022-03-13 23:00 ET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-4 * 60); // ET during DST (EDT) in 2022
+    });
+    testSingleCase(chrono, "2021-03-13 23:00 ET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-5 * 60); // ET during standard time (EST) in 2021
+    });
+    testSingleCase(chrono, "2021-03-14 23:00 ET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-4 * 60); // ET during DST (EDT) in 2021
+    });
+
+    // Also test around transition *from* DST
+    testSingleCase(chrono, "2021-11-06 23:00 ET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-4 * 60); // ET during DST (EDT) in 2021
+    });
+    testSingleCase(chrono, "2021-11-07 23:00 ET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-5 * 60); // ET during standard time (EST) in 2021
+    });
+    testSingleCase(chrono, "2020-10-31 23:00 ET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-4 * 60); // ET during DST (EDT) in 2020
+    });
+    testSingleCase(chrono, "2020-11-01 23:00 ET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-5 * 60); // ET during standard time (EST) in 2020
+    });
+
+    // Same checks, but for CET (which transitions at different dates with different rules)
+    // Test dates around transition to DST for CET
+    testSingleCase(chrono, "2022-03-26 23:00 CET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(60); // CET during standard time (CET) in 2022
+    });
+    testSingleCase(chrono, "2022-03-27 23:00 CET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(2 * 60); // CET during DST (CEST) in 2022
+    });
+    testSingleCase(chrono, "2021-03-27 23:00 CET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(60); // CET during standard time (CET) in 2021
+    });
+    testSingleCase(chrono, "2021-03-28 23:00 CET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(2 * 60); // CET during DST (CEST) in 2021
+    });
+
+    // Also test around transition *from* DST for CET
+    testSingleCase(chrono, "2022-10-29 23:00 CET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(2 * 60); // CET during DST (CEST) in 2022
+    });
+    testSingleCase(chrono, "2022-10-30 23:00 CET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(60); // CET during standard time (CET) in 2022
+    });
+    testSingleCase(chrono, "2021-10-30 23:00 CET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(2 * 60); // CET during DST (CEST) in 2021
+    });
+    testSingleCase(chrono, "2021-10-31 23:00 CET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(60); // CET during standard time (CET) in 2021
+    });
+});
+
+test("Test - Timezone parsing overrides", function () {
+    // chrono.parse('at 10:00 XYZ', new Date(2023, 3, 20), {timezones: {XYZ: -180}})
+    // XYZ shouldn't be recognized or parsed as a timezone
+    testSingleCase(chrono, "Jan 1st 2023 at 10:00 XYZ", (result) => {
+        expect(result.text).toBe("Jan 1st 2023 at 10:00");
+        expect(result.start).toBeDate(new Date(2023, 1 - 1, 1, 10));
+    });
+    // Parse the correct tzoffset when XYZ is provided as a custom tz in parsingOptions
+    testSingleCase(
+        chrono,
+        "Jan 1st 2023 at 10:00 XYZ",
+        new Date(2023, 1, 1),
+        { timezones: { XYZ: -180 } },
+        (result) => {
+            expect(result.text).toBe("Jan 1st 2023 at 10:00 XYZ");
+            expect(result.start.get("timezoneOffset")).toBe(-180);
+        }
+    );
+    // Parse the correct tzoffset when XYZ is provided as a custom ambiguous tz in parsingOptions
+    const parseXYZAsAmbiguousTz = {
+        timezoneOffsetDuringDst: -120,
+        timezoneOffsetNonDst: -180,
+        dstStart: (year: number) => getLastWeekdayOfMonth(year, Month.MARCH, Weekday.SUNDAY, 2),
+        dstEnd: (year: number) => getLastWeekdayOfMonth(year, Month.OCTOBER, Weekday.SUNDAY, 3),
+    };
+    // Parsing a non-DST date
+    testSingleCase(
+        chrono,
+        "Jan 1st 2023 at 10:00 XYZ",
+        new Date(2023, 1, 1),
+        { timezones: { XYZ: parseXYZAsAmbiguousTz } },
+        (result) => {
+            expect(result.text).toBe("Jan 1st 2023 at 10:00 XYZ");
+            expect(result.start.get("timezoneOffset")).toBe(-180);
+        }
+    );
+    // Parsing a DST date
+    testSingleCase(
+        chrono,
+        "Jun 1st 2023 at 10:00 XYZ",
+        new Date(2023, 1, 1),
+        { timezones: { XYZ: parseXYZAsAmbiguousTz } },
+        (result) => {
+            expect(result.text).toBe("Jun 1st 2023 at 10:00 XYZ");
+            expect(result.start.get("timezoneOffset")).toBe(-120);
+        }
+    );
+});
+
 test("Test - Parsing date with timezone abbreviation", function () {
     testSingleCase(chrono, "Wednesday, September 16, 2020, EST", (result, text) => {
         expect(result.text).toBe(text);

package/test/en/en_weekday.test.ts

@@ -273,6 +273,32 @@ test("Test - Weekday Overlap", function () {
     });
 });
 
+test("Test - Weekday range", () => {
+    testSingleCase(chrono.casual, "Friday to Monday", new Date(2023, 4 - 1, 9) /*Sunday*/, (result) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(4);
+        expect(result.start.get("day")).toBe(7);
+        expect(result.start.get("weekday")).toBe(5);
+
+        expect(result.end.get("year")).toBe(2023);
+        expect(result.end.get("month")).toBe(4);
+        expect(result.end.get("day")).toBe(10);
+        expect(result.end.get("weekday")).toBe(1);
+    });
+
+    testSingleCase(chrono.casual, "Monday to Friday", new Date(2023, 4 - 1, 9) /*Sunday*/, (result) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(4);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("weekday")).toBe(1);
+
+        expect(result.end.get("year")).toBe(2023);
+        expect(result.end.get("month")).toBe(4);
+        expect(result.end.get("day")).toBe(14);
+        expect(result.end.get("weekday")).toBe(5);
+    });
+});
+
 test("Test - forward dates only option", () => {
     testSingleCase(
         chrono.casual,

package/test/en/negative_cases.test.ts

@@ -63,6 +63,8 @@ test("Test - Skip impossible dates/times", () => {
 
     testUnexpectedResult(chrono, "14PM");
     testUnexpectedResult(chrono, "25:12");
+
+    testUnexpectedResult(chrono, "An appointment on 13/31/2018");
 });
 
 test("Test - Skip version number pattern", () => {

package/test/fr/fr_time_exp.test.ts

@@ -488,13 +488,13 @@ test("Test - Timezone extraction", function () {
         expect(result.start.get("timezoneOffset")).toBe(-300);
     });
 
-    testSingleCase(chrono.fr, "vendredi 15h CET", new Date(2016, 3, 28), (result, text) => {
+    testSingleCase(chrono.fr, "vendredi 15h CET", new Date(2016, 1, 28), (result, text) => {
         expect(result.text).toBe(text);
         expect(result.start.isCertain("timezoneOffset")).toBe(true);
         expect(result.start.get("timezoneOffset")).toBe(60);
     });
 
-    testSingleCase(chrono.fr, "vendredi 15h cest", new Date(2016, 3, 28), (result, text) => {
+    testSingleCase(chrono.fr, "vendredi 15h cest", new Date(2016, 1, 28), (result, text) => {
         expect(result.text).toBe(text);
         expect(result.start.isCertain("timezoneOffset")).toBe(true);
         expect(result.start.get("timezoneOffset")).toBe(120);

package/test/system.test.ts

@@ -1,8 +1,10 @@
 import * as chrono from "../src/";
-import { testSingleCase } from "./test_util";
+import { testSingleCase, testUnexpectedResult } from "./test_util";
 import { Meridiem } from "../src";
 import UnlikelyFormatFilter from "../src/common/refiners/UnlikelyFormatFilter";
 import SlashDateFormatParser from "../src/common/parsers/SlashDateFormatParser";
+import ENWeekdayParser from "../src/locales/en/parsers/ENWeekdayParser";
+import ENTimeUnitCasualRelativeFormatParser from "../src/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser";
 
 //-------------------------------------
 
@@ -146,6 +148,26 @@ test("Test - Remove a refiner example", () => {
     });
 });
 
+test("Test - Replace a parser example", () => {
+    const custom = chrono.en.casual.clone();
+    testSingleCase(custom, "next 5m", new Date(2016, 10 - 1, 1, 14, 52), (result, text) => {
+        expect(result.start.get("hour")).toBe(14);
+        expect(result.start.get("minute")).toBe(57);
+    });
+    testSingleCase(custom, "next 5 minutes", new Date(2016, 10 - 1, 1, 14, 52), (result, text) => {
+        expect(result.start.get("hour")).toBe(14);
+        expect(result.start.get("minute")).toBe(57);
+    });
+
+    const index = custom.parsers.findIndex((r) => r instanceof ENTimeUnitCasualRelativeFormatParser);
+    custom.parsers[index] = new ENTimeUnitCasualRelativeFormatParser(false);
+    testUnexpectedResult(custom, "next 5m");
+    testSingleCase(custom, "next 5 minutes", new Date(2016, 10 - 1, 1, 14, 52), (result, text) => {
+        expect(result.start.get("hour")).toBe(14);
+        expect(result.start.get("minute")).toBe(57);
+    });
+});
+
 test("Test - Compare with native js", () => {
     const testByCompareWithNative = (text) => {
         const expectedDate = new Date(text);