chrono-node 2.3.0 → 2.3.4

package/test/en/en_month_name_little_endian.test.ts

@@ -364,6 +364,16 @@ test("Test - Forward Option", () => {
         expect(result.end.get("day")).toBe(23);
         expect(result.end.get("hour")).toBe(19);
     });
+
+    testSingleCase(chrono, "17 August 2013 - 19 August 2013", (result) => {
+        expect(result.start.get("year")).toBe(2013);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(17);
+
+        expect(result.end.get("year")).toBe(2013);
+        expect(result.end.get("month")).toBe(8);
+        expect(result.end.get("day")).toBe(19);
+    });
 });
 
 test("Test - Impossible Dates (Strict Mode)", function () {

package/test/en/en_relative.test.ts

@@ -230,4 +230,12 @@ test("Test - Relative date components' certainty and imply timezone", () => {
         expect(result).toBeDate(new Date("Sun Nov 29 2020 13:34:13 GMT+0900 (Japan Standard Time)"));
         expect(result).toBeDate(new Date("Sun Nov 29 2020 5:34:13 GMT+0100"));
     }
+
+    {
+        const text = "in 20 minutes";
+        const result = chrono.parse(text, { instant: refDate, timezone: null })[0] as ParsingResult;
+
+        expect(result.text).toBe(text);
+        expect(result.start.isCertain("timezoneOffset")).toBe(false);
+    }
 });

package/test/en/en_slash.test.ts

@@ -203,4 +203,15 @@ test("Test - forward dates only option", function () {
 
         expect(result.start).toBeDate(new Date(2000, 5 - 1, 31, 12));
     });
+
+    testSingleCase(chrono, "1/8 at 12pm", new Date("Sep 25 2021 12:00:00"), { forwardDate: true }, (result) => {
+        expect(result.text).toBe("1/8 at 12pm");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2022);
+        expect(result.start.get("month")).toBe(1);
+        expect(result.start.get("day")).toBe(8);
+
+        expect(result.start).toBeDate(new Date(2022, 1 - 1, 8, 12));
+    });
 });

package/test/en/en_timezone_exp.test.ts

@@ -81,20 +81,95 @@ test("Test - Parsing date with timezone abbreviation", function () {
 });
 
 test("Test - Not parsing timezone from relative time", function () {
-    const refDate = new Date(2020, 11 - 1, 14, 13, 48, 22);
+    {
+        const refInstant = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
+        const expectedInstant = new Date("Sun Nov 29 2020 14:24:13 GMT+0900 (Japan Standard Time)");
+
+        testSingleCase(chrono, "in 1 hour get eggs and milk", refInstant, (result, text) => {
+            expect(result.text).toBe("in 1 hour");
+            expect(result.start.get("timezoneOffset")).toBe(-refInstant.getTimezoneOffset());
+            expect(result.start).toBeDate(expectedInstant);
+        });
+    }
+
+    {
+        const refInstant = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
+        const expectedInstant = new Date("Sun Nov 29 2020 14:24:13 GMT+0900 (Japan Standard Time)");
+
+        testSingleCase(chrono, "in 1 hour GMT", refInstant, (result, text) => {
+            expect(result.text).toBe("in 1 hour");
+            expect(result.start).toBeDate(expectedInstant);
+        });
+    }
+
+    {
+        const refInstant = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
+        const expectedInstant = new Date("Sun Nov 29 2020 14:24:13 GMT+0900 (Japan Standard Time)");
+
+        testSingleCase(chrono, "in 1 hour GMT", { instant: refInstant, timezone: "JST" }, (result, text) => {
+            expect(result.text).toBe("in 1 hour");
+            expect(result.start).toBeDate(expectedInstant);
+        });
+    }
+
+    {
+        const refInstant = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
+        const expectedInstant = new Date("Sun Nov 29 2020 14:24:13 GMT+0900 (Japan Standard Time)");
+
+        testSingleCase(chrono, "in 1 hour GMT", { instant: refInstant, timezone: "BST" }, (result, text) => {
+            expect(result.text).toBe("in 1 hour");
+            expect(result.start).toBeDate(expectedInstant);
+        });
+    }
+});
 
-    testSingleCase(chrono, "in 1 hour get eggs and milk", refDate, (result, text) => {
-        expect(result.text).toBe("in 1 hour");
-        expect(result.start.get("timezoneOffset")).toBe(-refDate.getTimezoneOffset());
+test("Test - Relative time (Now) is not effected by timezone setting", function () {
+    const refInstant = new Date(1637674343000);
+
+    testSingleCase(chrono, "now", { instant: refInstant }, (result) => {
+        expect(result.text).toBe("now");
+        expect(result.start).toBeDate(refInstant);
+    });
+
+    testSingleCase(chrono, "now", { instant: refInstant, timezone: null }, (result) => {
+        expect(result.text).toBe("now");
+        expect(result.start).toBeDate(refInstant);
+    });
+
+    testSingleCase(chrono, "now", { instant: refInstant, timezone: "BST" }, (result) => {
+        expect(result.text).toBe("now");
+        expect(result.start).toBeDate(refInstant);
+    });
+
+    testSingleCase(chrono, "now", { instant: refInstant, timezone: "JST" }, (result) => {
+        expect(result.text).toBe("now");
+        expect(result.start).toBeDate(refInstant);
     });
+});
 
-    // This test fail when the system/assume timezone is exactly similar to the mentioned timezone
-    // Temporary disable this test
+test("Test - Relative time (2 hour later) is not effected by timezone setting", function () {
+    const refInstant = new Date(1637674343000);
+    const expectedInstant = new Date(1637674343000 + 2 * 60 * 60 * 1000);
 
-    // testSingleCase(chrono, "in 3 hours GMT", refDate, (result, text) => {
-    //     expect(result.text).toBe("in 3 hours");
-    //     expect(result.start.get("timezoneOffset")).toBe(-refDate.getTimezoneOffset());
-    // });
+    testSingleCase(chrono, "2 hour later", { instant: refInstant }, (result) => {
+        expect(result.text).toBe("2 hour later");
+        expect(result.start).toBeDate(expectedInstant);
+    });
+
+    testSingleCase(chrono, "2 hour later", { instant: refInstant, timezone: null }, (result) => {
+        expect(result.text).toBe("2 hour later");
+        expect(result.start).toBeDate(expectedInstant);
+    });
+
+    testSingleCase(chrono, "2 hour later", { instant: refInstant, timezone: "BST" }, (result) => {
+        expect(result.text).toBe("2 hour later");
+        expect(result.start).toBeDate(expectedInstant);
+    });
+
+    testSingleCase(chrono, "2 hour later", { instant: refInstant, timezone: "JST" }, (result) => {
+        expect(result.text).toBe("2 hour later");
+        expect(result.start).toBeDate(expectedInstant);
+    });
 });
 
 test("Test - Parsing timezone from relative date when valid", function () {

package/test/en/en_weekday.test.ts

@@ -20,30 +20,6 @@ test("Test - Single Expression", function () {
         expect(result.start).toBeDate(new Date(2012, 7, 6, 12));
     });
 
-    testSingleCase(
-        chrono.casual,
-        "Monday (forward dates only)",
-        new Date(2012, 7, 9),
-        { forwardDate: true },
-        (result) => {
-            expect(result.index).toBe(0);
-            expect(result.text).toBe("Monday");
-
-            expect(result.start).not.toBeNull();
-            expect(result.start.get("year")).toBe(2012);
-            expect(result.start.get("month")).toBe(8);
-            expect(result.start.get("day")).toBe(13);
-            expect(result.start.get("weekday")).toBe(1);
-
-            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(true);
-
-            expect(result.start).toBeDate(new Date(2012, 7, 13, 12));
-        }
-    );
-
     testSingleCase(chrono.casual, "Thursday", new Date(2012, 7, 9), (result) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe("Thursday");
@@ -182,7 +158,31 @@ test("Test - Weekday Overlap", function () {
     });
 });
 
-test("Test - forward dates only option", function () {
+test("Test - forward dates only option", () => {
+    testSingleCase(
+        chrono.casual,
+        "Monday (forward dates only)",
+        new Date(2012, 7, 9),
+        { forwardDate: true },
+        (result) => {
+            expect(result.index).toBe(0);
+            expect(result.text).toBe("Monday");
+
+            expect(result.start).not.toBeNull();
+            expect(result.start.get("year")).toBe(2012);
+            expect(result.start.get("month")).toBe(8);
+            expect(result.start.get("day")).toBe(13);
+            expect(result.start.get("weekday")).toBe(1);
+
+            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(true);
+
+            expect(result.start).toBeDate(new Date(2012, 7, 13, 12));
+        }
+    );
+
     testSingleCase(
         chrono.casual,
         "this Friday to this Monday",
@@ -219,4 +219,48 @@ test("Test - forward dates only option", function () {
             expect(result.end).toBeDate(new Date(2016, 8 - 1, 8, 12));
         }
     );
+
+    testSingleCase(
+        chrono.casual,
+        "sunday morning",
+        new Date("August 15, 2021, 20:00"),
+        { forwardDate: true },
+        (result) => {
+            expect(result.index).toBe(0);
+            expect(result.text).toBe("sunday morning");
+
+            expect(result.start).not.toBeNull();
+            expect(result.start.get("year")).toBe(2021);
+            expect(result.start.get("month")).toBe(8);
+            expect(result.start.get("day")).toBe(22);
+            expect(result.start.get("weekday")).toBe(0);
+
+            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(true);
+
+            expect(result.start).toBeDate(new Date(2021, 8 - 1, 22, 6));
+        }
+    );
+
+    testSingleCase(
+        chrono.casual,
+        "vacation monday - friday",
+        new Date("thursday 13 June 2019"),
+        { forwardDate: true },
+        (result) => {
+            expect(result.text).toBe("monday - friday");
+
+            expect(result.start).not.toBeNull();
+            expect(result.start.get("year")).toBe(2019);
+            expect(result.start.get("month")).toBe(6);
+            expect(result.start.get("day")).toBe(17);
+
+            expect(result.end).not.toBeNull();
+            expect(result.end.get("year")).toBe(2019);
+            expect(result.end.get("month")).toBe(6);
+            expect(result.end.get("day")).toBe(21);
+        }
+    );
 });

package/test/en/negative_cases.test.ts

@@ -21,6 +21,8 @@ test("Test - Skip random non-date patterns", function () {
     testUnexpectedResult(chrono, "Total: $1,194.09 [image: View Reservation");
 
     testUnexpectedResult(chrono, "at 6.5 kilograms");
+
+    testUnexpectedResult(chrono, "ah that is unusual", null, { forwardDate: true });
 });
 
 test("Test - URLs % encoded", function () {

package/test/nl/nl_relative.test.ts

@@ -0,0 +1,212 @@
+import * as chrono from "../../src";
+import { testSingleCase } from "../test_util";
+import { ParsingResult } from "../../src/results";
+
+test("Test - 'This' expressions", () => {
+    // this week
+    testSingleCase(chrono.nl, "deze week", new Date(2017, 11 - 1, 19, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        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);
+    });
+
+    // this month
+    testSingleCase(chrono.nl, "deze maand", new Date(2017, 11 - 1, 19, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        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);
+    });
+
+    // this year
+    testSingleCase(chrono.nl, "dit jaar", new Date(2017, 11 - 1, 19, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        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);
+    });
+});
+
+test("Test - Past relative expressions", () => {
+    // last week
+    testSingleCase(chrono.nl, "afgelopen week", 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(9);
+        expect(result.start.get("day")).toBe(24);
+        expect(result.start.get("hour")).toBe(12);
+    });
+
+    // last month
+    testSingleCase(chrono.nl, "afgelopen maand", 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(9);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
+    });
+
+    // last day
+    testSingleCase(chrono.nl, "afgelopen dag", 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(9);
+        expect(result.start.get("day")).toBe(30);
+        expect(result.start.get("hour")).toBe(12);
+    });
+
+    // past week
+    testSingleCase(chrono.nl, "vorige week", 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(9);
+        expect(result.start.get("day")).toBe(24);
+        expect(result.start.get("hour")).toBe(12);
+    });
+});
+
+test("Test - Future relative expressions", () => {
+    // next hour
+    testSingleCase(chrono.nl, "komende uur", 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(13);
+    });
+
+    // next week
+    testSingleCase(chrono.nl, "volgende week", 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(8);
+        expect(result.start.get("hour")).toBe(12);
+    });
+
+    // next day
+    testSingleCase(chrono.nl, "volgende dag", 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(2);
+        expect(result.start.get("hour")).toBe(12);
+    });
+
+    // next month
+    testSingleCase(chrono.nl, "volgende maand", 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(11);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
+
+        expect(result.start.isCertain("year")).toBe(true);
+        expect(result.start.isCertain("month")).toBe(true);
+        expect(result.start.isCertain("day")).toBe(false);
+        expect(result.start.isCertain("hour")).toBe(false);
+    });
+
+    // next year
+    testSingleCase(chrono.nl, "volgend jaar", 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", () => {
+    const refDate = new Date(2016, 10 - 1, 7, 12);
+
+    // next hour
+    testSingleCase(chrono.nl, "komende uur", refDate, (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(7);
+        expect(result.start.get("hour")).toBe(13);
+        expect(result.start.get("timezoneOffset")).toBe(refDate.getTimezoneOffset() * -1);
+
+        expect(result.start.isCertain("year")).toBe(true);
+        expect(result.start.isCertain("month")).toBe(true);
+        expect(result.start.isCertain("day")).toBe(true);
+        expect(result.start.isCertain("hour")).toBe(true);
+        expect(result.start.isCertain("timezoneOffset")).toBe(true);
+    });
+
+    // next month
+    testSingleCase(chrono.nl, "volgende maand", refDate, (result, text) => {
+        const expectedDate = new Date(2016, 11, 7, 12);
+
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(7);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("timezoneOffset")).toBe(-expectedDate.getTimezoneOffset());
+
+        expect(result.start.isCertain("year")).toBe(true);
+        expect(result.start.isCertain("month")).toBe(true);
+        expect(result.start.isCertain("day")).toBe(false);
+        expect(result.start.isCertain("hour")).toBe(false);
+        expect(result.start.isCertain("timezoneOffset")).toBe(false);
+    });
+});
+
+test("Test - Relative date components' certainty and imply timezone", () => {
+    const refDate = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
+
+    {
+        // now
+        const text = "nu";
+        const result = chrono.nl.parse(text, refDate)[0] as ParsingResult;
+
+        expect(result.text).toBe(text);
+        result.start.imply("timezoneOffset", 60);
+
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 5:24:13 GMT+0100"));
+    }
+
+    {
+        // tomorrow at 5pm
+        const text = "morgen om 17 uur";
+        const result = chrono.nl.parse(text, refDate)[0] as ParsingResult;
+
+        expect(result.text).toBe(text);
+        result.start.imply("timezoneOffset", 60);
+
+        expect(result).toBeDate(new Date("Sun Dec 1 2020 1:00:00 GMT+0900 (Japan Standard Time)"));
+        expect(result).toBeDate(new Date("Sun Nov 30 2020 17:00:00 GMT+0100"));
+    }
+
+    {
+        // in 10 minutes
+        const text = "binnen 10 minuten";
+        const result = chrono.nl.parse(text, refDate)[0] as ParsingResult;
+
+        expect(result.text).toBe(text);
+        result.start.imply("timezoneOffset", 60);
+
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 13:34:13 GMT+0900 (Japan Standard Time)"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 5:34:13 GMT+0100"));
+    }
+});