chrono-node 2.7.9 → 2.8.1

package/src/utils/dates.ts

@@ -0,0 +1,24 @@
+import { ParsingComponents } from "../results";
+
+/**
+ * Imply (weakly update) the parsing component to the same day as the `target`.
+ * @param component the component to be updated.
+ * @param target the target date with timezone adjusted.
+ */
+export function implySimilarDate(component: ParsingComponents, target: Date) {
+    component.imply("day", target.getDate());
+    component.imply("month", target.getMonth() + 1);
+    component.imply("year", target.getFullYear());
+}
+
+/**
+ * Imply (weakly update) the parsing component to the same time as the `target`.
+ * @param component the component to be updated.
+ * @param target the target date with timezone adjusted.
+ */
+export function implySimilarTime(component: ParsingComponents, target: Date) {
+    component.imply("hour", target.getHours());
+    component.imply("minute", target.getMinutes());
+    component.imply("second", target.getSeconds());
+    component.imply("millisecond", target.getMilliseconds());
+}

package/src/utils/dayjs.ts

@@ -32,12 +32,18 @@ export function assignSimilarTime(component: ParsingComponents, targetDayJs: day
     }
 }
 
+/**
+ * @deprecated Use `dates.implySimilarDate` with normal Javascript Date instead.
+ */
 export function implySimilarDate(component: ParsingComponents, targetDayJs: dayjs.Dayjs) {
     component.imply("day", targetDayJs.date());
     component.imply("month", targetDayJs.month() + 1);
     component.imply("year", targetDayJs.year());
 }
 
+/**
+ * @deprecated Use `dates.implySimilarTime` with normal Javascript Date instead.
+ */
 export function implySimilarTime(component: ParsingComponents, targetDayJs: dayjs.Dayjs) {
     component.imply("hour", targetDayJs.hour());
     component.imply("minute", targetDayJs.minute());

package/test/de/de_dash.test.ts

@@ -1,16 +1,32 @@
 import * as chrono from "../../src/";
 import { testSingleCase } from "../test_util";
 
-test("Test - Should handle de dayname dd-mm-yy", () => {
-    testSingleCase(chrono.de, "30.12.16", (result) => {
+test("Test - Single date expression with dash notation", () => {
+    testSingleCase(chrono.de, "30-12-16", (result) => {
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.start.get("day")).toBe(30);
+    });
+
+    testSingleCase(chrono.de, "Freitag 30-12-16", (result) => {
+        expect(result.text).toBe("Freitag 30-12-16");
         expect(result.start.get("year")).toBe(2016);
         expect(result.start.get("month")).toBe(12);
         expect(result.start.get("day")).toBe(30);
     });
 });
 
-test("Test - Should handle de weekday dd-mm-yy", () => {
+test("Test - Single date expression with dot notation", () => {
+    testSingleCase(chrono.de, "30.12.16", (result) => {
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.start.get("day")).toBe(30);
+    });
+
     testSingleCase(chrono.de, "Freitag 30.12.16", (result) => {
         expect(result.text).toBe("Freitag 30.12.16");
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.start.get("day")).toBe(30);
     });
 });

package/test/en/en_casual.test.ts

@@ -28,7 +28,10 @@ test("Test - Single Expression", () => {
         (result) => {
             expect(result.text).toBe("now");
             expect(result.start).toBeDate(new Date(1637674343000));
-            expect(result.start.isCertain("timezoneOffset")).toBe(false);
+
+            // Although the timezone is not specified, we need to assume it is similar to the system default.
+            // We also must allow the timezoneOffset to be overridden. Otherwise, the "now" meaning is incorrect.
+            // expect(result.start.isCertain("timezoneOffset")).toBe(false);
         }
     );
 

package/test/en/en_relative.test.ts

@@ -238,69 +238,156 @@ test("Test - Relative date components' certainty", () => {
     });
 });
 
-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)");
-
+test("Test - Relative date when the timezone is irrelevant", () => {
     {
+        // Sun Nov 29 2020 13:24:13 GMT+0900 (JST)
+        // Sun Nov 29 2020 05:24:13 GMT+0100 (BST)
+        const refInstant = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
+
+        // The "now" is always exactly the same as the reference instant (regardless of the timezone).
         const text = "now";
-        const result = chrono.parse(text, refDate)[0] as ParsingResult;
+        const result = chrono.parse(text, refInstant)[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (JST)"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 05:24:13 GMT+0100 (BST)"));
 
-        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"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (JST)"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 05:24:13 GMT+0100 (BST)"));
     }
-
     {
-        const text = "tomorrow at 5pm";
-        const result = chrono.parse(text, refDate)[0] as ParsingResult;
+        // Sun Nov 29 2020 13:24:13 GMT+0900 (JST)
+        // Sun Nov 29 2020 05:24:13 GMT+0100 (BST)
+        const refInstant = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
 
-        expect(result.text).toBe(text);
-        result.start.imply("timezoneOffset", 60);
+        // Always "10 minutes" from the reference instant (regardless of the target timezone).
+        const text = "in 10 minutes";
+        const result = chrono.parse(text, refInstant)[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 13:34:13 GMT+0900 (JST)"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 05:34:13 GMT+0100 (BST)"));
 
-        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"));
+        result.start.imply("timezoneOffset", 60);
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 13:34:13 GMT+0900 (JST)"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 05:34:13 GMT+0100 (BST)"));
     }
-
     {
+        // Sun Nov 29 2020 13:24:13 GMT+0900 (JST)
+        // Sun Nov 29 2020 05:24:13 GMT+0100 (BST)
+        const refInstant = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
+
+        // Always "10 minutes" from the reference instant (regardless of the reference timezone).
         const text = "in 10 minutes";
-        const result = chrono.parse(text, refDate)[0] as ParsingResult;
+        {
+            const result = chrono.parse(text, { instant: refInstant, timezone: "BST" })[0] as ParsingResult;
+            expect(result).toBeDate(new Date("Sun Nov 29 2020 13:34:13 GMT+0900 (JST)"));
+            expect(result).toBeDate(new Date("Sun Nov 29 2020 05:34:13 GMT+0100 (BST)"));
+        }
+        {
+            const result = chrono.parse(text, { instant: refInstant, timezone: "JST" })[0] as ParsingResult;
+            expect(result).toBeDate(new Date("Sun Nov 29 2020 13:34:13 GMT+0900 (JST)"));
+            expect(result).toBeDate(new Date("Sun Nov 29 2020 05:34:13 GMT+0100 (BST)"));
+        }
+    }
+    {
+        // Sun Nov 29 2020 13:24:13 GMT+0900 (JST)
+        // Sun Nov 29 2020 05:24:13 GMT+0100 (BST)
+        const refInstant = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
 
-        expect(result.text).toBe(text);
-        result.start.imply("timezoneOffset", 60);
+        const text = "in 20 minutes";
+        const result = chrono.parse(text, { instant: refInstant, timezone: null })[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 13:44:13 GMT+0900 (JST)"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 05:44:13 GMT+0100 (BST)"));
 
-        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"));
+        // Although the timezone is not specified, we need to assume it is similar to the system default.
+        // We also must allow the timezoneOffset to be overridden. Otherwise, the relative meaning is incorrect.
+        // expect(result.start.isCertain("timezoneOffset")).toBe(false);
     }
+});
 
+test("Test - Relative date when the timezone is relevant but unknown", () => {
+    // Sun Nov 29 2020 13:24:13 (unknown timezone = system timezone)
+    const refInstant = new Date(2020, 11 - 1, 29, 13, 24, 13, 0);
+
+    // In the same (system) timezone, the "tomorrow" is 'Nov 30 2020'
+    const text = "tomorrow at 5pm";
+    const result = chrono.parse(text, refInstant)[0] as ParsingResult;
+    expect(result).toBeDate(new Date(2020, 11 - 1, 30, 17, 0, 0, 0));
+    expect(result.start.get("month")).toBe(11);
+    expect(result.start.get("day")).toBe(30);
+    expect(result.start.get("hour")).toBe(17);
+});
+
+test("Test - Relative date when the timezone is relevant and known", () => {
+    // Sun Nov 29 2020 13:24:13 GMT+0900 (JST)
+    // Sun Nov 29 2020 05:24:13 GMT+0100 (BST)
+    // Sat Nov 28 2020 21:24:13 GMT-0700 (PDT)
+    const refInstant = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
     {
-        const text = "in 10 minutes";
-        const result = chrono.parse(text, { instant: refDate, timezone: "BST" })[0] as ParsingResult;
+        // In JST (Nov 29 2020 13:24:13 GMT+0900), the "tomorrow" is 'Nov 30 2020'
+        const text = "tomorrow at 5pm";
+        const result = chrono.parse(text, { instant: refInstant, timezone: "JST" })[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Mon Nov 30 2020 17:00:00 GMT+0900 (JST)"));
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(30);
+        expect(result.start.get("hour")).toBe(17);
 
-        expect(result.text).toBe(text);
+        // However, when implying the output timezone to be GMT+0100,
         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"));
+        expect(result).toBeDate(new Date("Mon Nov 30 2020 17:00:00 GMT+0100 (BST)"));
     }
-
     {
-        const text = "in 10 minutes";
-        const result = chrono.parse(text, { instant: refDate, timezone: "JST" })[0] as ParsingResult;
+        // In BST (Nov 29 2020 05:24:13 GMT+0100), the "tomorrow" is 'Nov 30 2020'
+        const text = "tomorrow at 5pm";
+        const result = chrono.parse(text, { instant: refInstant, timezone: "BST" })[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Mon Nov 30 2020 17:00:00 GMT+0100 (BST)"));
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(30);
+        expect(result.start.get("hour")).toBe(17);
 
-        expect(result.text).toBe(text);
-        result.start.imply("timezoneOffset", 60);
+        // However, when implying the output timezone to be GMT+0900,
+        result.start.imply("timezoneOffset", 540);
+        expect(result).toBeDate(new Date("Mon Nov 30 2020 17:00:00 GMT+0900 (JST)"));
+    }
+    {
+        // In PST (Sat Nov 28 2020 21:24:13 GMT-0700), the "tomorrow" is 'Nov 29 2020'
+        const text = "tomorrow at 5pm";
+        const result = chrono.parse(text, { instant: refInstant, timezone: -7 * 60 })[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 17:00:00 GMT-0700 (PST)"));
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(29);
+        expect(result.start.get("hour")).toBe(17);
 
-        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"));
+        // However, when implying the output timezone to be GMT+0900,
+        result.start.imply("timezoneOffset", 540);
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 17:00:00 GMT+0900 (JST)"));
     }
+});
 
+test("Test - Relative date when the timezone is relevant and known (2nd scenario)", () => {
+    // Thu Feb 27 2025 17:00:00 GMT+0000
+    // Thu Feb 27 2025 09:00:00 GMT-0800 (PST)
+    const refInstant = new Date("2025-02-27T17:00:00.000Z");
     {
-        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);
+        const text = "tomorrow at 9am";
+        const result = chrono.parse(text, { instant: refInstant, timezone: "PST" })[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Fri Feb 28 2025 09:00:00 GMT-0800 (PST)"));
+        expect(result).toBeDate(new Date("2025-02-28T17:00:00.000Z"));
+    }
+    {
+        const text = "in 2 weeks at 9am";
+        const result = chrono.parse(text, { instant: refInstant, timezone: "PST" })[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Thu Mar 13 2025 09:00:00 GMT-0800 (PST)"));
+        expect(result).toBeDate(new Date("2025-03-13T17:00:00.000Z"));
+    }
+    {
+        const text = "2 weeks ago at 9am";
+        const result = chrono.parse(text, { instant: refInstant, timezone: "PST" })[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Thu Feb 13 2025 09:00:00 GMT-0800 (PST)"));
+        expect(result).toBeDate(new Date("2025-02-13T17:00:00.000Z"));
+    }
+    {
+        const text = "next friday at 9am";
+        const result = chrono.parse(text, { instant: refInstant, timezone: "PST" })[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Fri Mar 07 2025 09:00:00 GMT-0800 (PST)"));
+        expect(result).toBeDate(new Date("2025-03-07T17:00:00.000Z"));
     }
 });

package/test/en/en_slash.test.ts

@@ -274,3 +274,11 @@ test("Test - forward dates only option", function () {
         expect(result.start).toBeDate(new Date(2022, 1 - 1, 8, 12));
     });
 });
+
+test("Test - Slash date with an extra chunk", () => {
+    testSingleCase(chrono, "14/4 90", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(4);
+        expect(result.start.get("day")).toBe(14);
+    });
+});

package/test/en/en_time_exp.test.ts

@@ -456,24 +456,13 @@ test("Test - Parsing negative cases : 'at [some numbers] - [some numbers]' (Stri
     testUnexpectedResult(chrono.strict, "7-730");
 });
 
-test("Test - forward dates only option", function () {
-    testSingleCase(
-        chrono,
-        "1am",
-        {
-            instant: new Date("Wed May 26 2022 01:57:00 GMT-0500 (CDT)"),
-            timezone: "CDT",
-        },
-        {
-            forwardDate: true,
-        },
-        (result) => {
-            expect(result.start.get("year")).toBe(2022);
-            expect(result.start.get("month")).toBe(5);
-            expect(result.start.get("day")).toBe(27);
-            expect(result.start.get("hour")).toBe(1);
-        }
-    );
+test("Test - Forward time calculation 'forwardDate' flag", () => {
+    testSingleCase(chrono, "1am", new Date(2022, 5 - 1, 26, 1, 57), { forwardDate: true }, (result) => {
+        expect(result.start.get("year")).toBe(2022);
+        expect(result.start.get("month")).toBe(5);
+        expect(result.start.get("day")).toBe(27);
+        expect(result.start.get("hour")).toBe(1);
+    });
 
     testSingleCase(chrono, "11am", new Date(2016, 10 - 1, 1, 12), { forwardDate: true }, (result) => {
         expect(result.start.get("year")).toBe(2016);
@@ -508,3 +497,23 @@ test("Test - forward dates only option", function () {
         expect(result.end.get("hour")).toBe(12);
     });
 });
+
+test("Test - Test - Forward time calculation 'forwardDate' flag in different timezones", () => {
+    testSingleCase(
+        chrono,
+        "1am",
+        {
+            instant: new Date("Wed May 26 2022 01:57:00 GMT-0500 (CDT)"),
+            timezone: "CDT",
+        },
+        {
+            forwardDate: true,
+        },
+        (result) => {
+            expect(result.start.get("year")).toBe(2022);
+            expect(result.start.get("month")).toBe(5);
+            expect(result.start.get("day")).toBe(27);
+            expect(result.start.get("hour")).toBe(1);
+        }
+    );
+});

package/test/ja/ja_slash_date_format.test.ts

@@ -0,0 +1,60 @@
+import * as chrono from "../../src";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", function () {
+    testSingleCase(chrono.ja, "2012/3/31", new Date(2012, 8 - 1, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("2012/3/31");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(3);
+        expect(result.start.get("day")).toBe(31);
+
+        expect(result.start).toBeDate(new Date(2012, 3 - 1, 31, 12));
+    });
+    testSingleCase(chrono.ja, "12/31", new Date(2012, 8 - 1, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("12/31");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.start.get("day")).toBe(31);
+
+        expect(result.start).toBeDate(new Date(2012, 12 - 1, 31, 12));
+    });
+
+    testSingleCase(chrono.ja, "8/5", new Date(2012, 8 - 1, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("8/5");
+
+        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(5);
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 5, 12));
+    });
+});
+
+test("Test - Range Expression", function () {
+    testSingleCase(chrono.ja, "2013/12/26~2014/1/7", new Date(2012, 8 - 1, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("2013/12/26~2014/1/7");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2013);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.start.get("day")).toBe(26);
+
+        expect(result.start).toBeDate(new Date(2013, 12 - 1, 26, 12));
+
+        expect(result.end).not.toBeNull();
+        expect(result.end.get("year")).toBe(2014);
+        expect(result.end.get("month")).toBe(1);
+        expect(result.end.get("day")).toBe(7);
+
+        expect(result.end).toBeDate(new Date(2014, 1 - 1, 7, 12));
+    });
+});