chrono-node 2.2.7 → 2.3.3

package/test/nl/nl_time_units_later.test.ts

@@ -0,0 +1,250 @@
+import * as chrono from "../../src/";
+import { testSingleCase } from "../test_util";
+
+test("Test - Later Expression", function () {
+    // 2 days later
+    testSingleCase(chrono.nl, "2 dagen later", new Date(2012, 7, 10, 12), (result) => {
+        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(12);
+
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("2 dagen later");
+
+        expect(result.start.isCertain("day")).toBe(true);
+        expect(result.start.isCertain("month")).toBe(true);
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 12, 12));
+    });
+
+    // 5 minutes later
+    testSingleCase(chrono.nl, "5 minuten later", new Date(2012, 7, 10, 10, 0), (result) => {
+        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(10);
+        expect(result.start.get("hour")).toBe(10);
+        expect(result.start.get("minute")).toBe(5);
+
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("5 minuten later");
+
+        expect(result.start.isCertain("hour")).toBe(true);
+        expect(result.start.isCertain("minute")).toBe(true);
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 10, 5));
+    });
+
+    // 3 week later
+    testSingleCase(chrono.nl, "3 weken later", new Date(2012, 7 - 1, 10, 10, 0), (result) => {
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(7);
+        expect(result.start.get("day")).toBe(31);
+
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("3 weken later");
+
+        expect(result.start).toBeDate(new Date(2012, 7 - 1, 31, 10, 0));
+    });
+});
+
+test("Test - From now Expression", () => {
+    // 5 days from now, we did something
+    testSingleCase(chrono.nl, "5 dagen vanaf nu we hebben iets gedaan", new Date(2012, 7, 10), (result) => {
+        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(15);
+
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("5 dagen vanaf nu");
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 15));
+    });
+
+    // 10 days from now, we did something
+    testSingleCase(chrono.nl, "10 dagen vanaf nu we hebben iets gedaan", new Date(2012, 7, 10), (result) => {
+        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(20);
+
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("10 dagen vanaf nu");
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 20));
+    });
+
+    // 15 minute from now
+    testSingleCase(chrono.nl, "15 minuten vanaf nu", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("15 minuten vanaf nu");
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(29);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 29));
+    });
+
+    // 15 minutes earlier
+    testSingleCase(chrono.nl, "15 minuten eerder", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("15 minuten eerder");
+        expect(result.start.get("hour")).toBe(11);
+        expect(result.start.get("minute")).toBe(59);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 11, 59));
+    });
+
+    // 15 minute out
+    testSingleCase(chrono.nl, "15 minuten uit", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("15 minuten uit");
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(29);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 29));
+    });
+
+    //    12 hours from now
+    testSingleCase(chrono.nl, "   12 uur vanaf nu", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(3);
+        expect(result.text).toBe("12 uur vanaf nu");
+        expect(result.start.get("day")).toBe(11);
+        expect(result.start.get("hour")).toBe(0);
+        expect(result.start.get("minute")).toBe(14);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 11, 0, 14));
+    });
+
+    // half an hour from now
+    testSingleCase(chrono.nl, "   half uur vanaf nu", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.text).toBe("half uur vanaf nu");
+        expect(result.index).toBe(3);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(44);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 44));
+    });
+
+    // 12 hours from now I did something
+    testSingleCase(chrono.nl, "Over 12 uur heb ik iets gedaan", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Over 12 uur");
+        expect(result.start.get("day")).toBe(11);
+        expect(result.start.get("hour")).toBe(0);
+        expect(result.start.get("minute")).toBe(14);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 11, 0, 14));
+    });
+
+    // 12 seconds from now I did something
+    testSingleCase(chrono.nl, "Over 12 seconden heb ik iets gedaan", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Over 12 seconden");
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(14);
+        expect(result.start.get("second")).toBe(12);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 14, 12));
+    });
+
+    // three seconds from now I did something
+    testSingleCase(chrono.nl, "over drie seconden heb ik iets gedaan", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("over drie seconden");
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(14);
+        expect(result.start.get("second")).toBe(3);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 14, 3));
+    });
+
+    // 5 Days from now, we did something
+    testSingleCase(chrono.nl, "Over 5 dagen hebben we iets gedaan", new Date(2012, 7, 10), (result) => {
+        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(15);
+
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Over 5 dagen");
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 15));
+    });
+
+    // half An hour from now
+    testSingleCase(chrono.nl, "   half uur vanaf nu", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(3);
+        expect(result.text).toBe("half uur vanaf nu");
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(44);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 44));
+    });
+
+    // A days from now, we did something
+    testSingleCase(chrono.nl, "Over een dag hebben we iets gedaan", new Date(2012, 7, 10), (result) => {
+        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(11);
+
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Over een dag");
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 11));
+    });
+
+    // a min out
+    testSingleCase(chrono.nl, "een minuutje uit", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("een minuutje uit");
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(15);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 15));
+    });
+
+    // in 1 hour
+    testSingleCase(chrono.nl, "in 1 uur", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("in 1 uur");
+        expect(result.start.get("hour")).toBe(13);
+        expect(result.start.get("minute")).toBe(14);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 13, 14));
+    });
+
+    // in 1.5 hours
+    testSingleCase(chrono.nl, "over 1,5 uur", new Date(2012, 7, 10, 12, 40), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("over 1,5 uur");
+        expect(result.start.get("hour")).toBe(14);
+        expect(result.start.get("minute")).toBe(10);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 14, 10));
+    });
+});
+
+test("Test - Strict mode", function () {
+    // 15 minutes from now
+    testSingleCase(chrono.nl.strict, "15 minuten vanaf nu", new Date(2012, 7, 10, 12, 14), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(29);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 29));
+    });
+
+    // 25 minutes later
+    testSingleCase(chrono.nl.strict, "25 minuten later", new Date(2012, 7, 10, 12, 40), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("25 minuten later");
+        expect(result.start.get("hour")).toBe(13);
+        expect(result.start.get("minute")).toBe(5);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 13, 5));
+    });
+});

package/test/result.test.ts

@@ -1,8 +1,8 @@
-import { ParsingComponents } from "../src/results";
+import { ParsingComponents, ReferenceWithTimezone } from "../src/results";
 
 test("Test - Create & manipulate date results", () => {
-    const refDate = new Date();
-    const components = new ParsingComponents(refDate, { year: 2014, month: 11, day: 24 });
+    const reference = new ReferenceWithTimezone(new Date());
+    const components = new ParsingComponents(reference, { year: 2014, month: 11, day: 24 });
 
     expect(components.get("year")).toBe(2014);
     expect(components.get("month")).toBe(11);
@@ -32,26 +32,45 @@ test("Test - Create & manipulate date results", () => {
     expect(components.get("year")).toBe(2013);
 });
 
+test("Test - Calendar checking with implied components", () => {
+    const reference = new ReferenceWithTimezone(new Date());
+
+    {
+        const components = new ParsingComponents(reference, {
+            "day": 13,
+            "month": 3,
+            "year": 2021,
+            "hour": 14,
+            "minute": 22,
+            "second": 14,
+            "millisecond": 0,
+        });
+        components.imply("timezoneOffset", -300);
+
+        expect(components.isValidDate()).toBe(true);
+    }
+});
+
 test("Test - Calendar Checking", () => {
-    const refDate = new Date();
+    const reference = new ReferenceWithTimezone(new Date());
 
     {
-        const components = new ParsingComponents(refDate, { year: 2014, month: 11, day: 24 });
+        const components = new ParsingComponents(reference, { year: 2014, month: 11, day: 24 });
         expect(components.isValidDate()).toBe(true);
     }
 
     {
-        const components = new ParsingComponents(refDate, { year: 2014, month: 11, day: 24, hour: 12 });
+        const components = new ParsingComponents(reference, { year: 2014, month: 11, day: 24, hour: 12 });
         expect(components.isValidDate()).toBe(true);
     }
 
     {
-        const components = new ParsingComponents(refDate, { year: 2014, month: 11, day: 24, hour: 12, minute: 30 });
+        const components = new ParsingComponents(reference, { year: 2014, month: 11, day: 24, hour: 12, minute: 30 });
         expect(components.isValidDate()).toBe(true);
     }
 
     {
-        const components = new ParsingComponents(refDate, {
+        const components = new ParsingComponents(reference, {
             year: 2014,
             month: 11,
             day: 24,
@@ -63,27 +82,27 @@ test("Test - Calendar Checking", () => {
     }
 
     {
-        const components = new ParsingComponents(refDate, { year: 2014, month: 13, day: 24 });
+        const components = new ParsingComponents(reference, { year: 2014, month: 13, day: 24 });
         expect(components.isValidDate()).toBe(false);
     }
 
     {
-        const components = new ParsingComponents(refDate, { year: 2014, month: 11, day: 32 });
+        const components = new ParsingComponents(reference, { year: 2014, month: 11, day: 32 });
         expect(components.isValidDate()).toBe(false);
     }
 
     {
-        const components = new ParsingComponents(refDate, { year: 2014, month: 11, day: 24, hour: 24 });
+        const components = new ParsingComponents(reference, { year: 2014, month: 11, day: 24, hour: 24 });
         expect(components.isValidDate()).toBe(false);
     }
 
     {
-        const components = new ParsingComponents(refDate, { year: 2014, month: 11, day: 24, hour: 12, minute: 60 });
+        const components = new ParsingComponents(reference, { year: 2014, month: 11, day: 24, hour: 12, minute: 60 });
         expect(components.isValidDate()).toBe(false);
     }
 
     {
-        const components = new ParsingComponents(refDate, {
+        const components = new ParsingComponents(reference, {
             year: 2014,
             month: 11,
             day: 24,

package/test/system_timezone.test.ts

@@ -0,0 +1,100 @@
+import * as chrono from "../src/";
+import { testSingleCase } from "./test_util";
+
+test("Test - Timezone difference on reference example", function () {
+    testSingleCase(
+        chrono,
+        "Friday at 4pm",
+        {
+            instant: new Date("Wed Jun 09 2021 07:00:00 GMT-0500 (CDT)"),
+            timezone: "CDT",
+        },
+        (result) => {
+            expect(result).toBeDate(new Date("Fri Jun 11 2021 16:00:00 GMT-0500 (CDT)"));
+            expect(result).toBeDate(new Date("Fri Jun 12 2021 06:00:00 GMT+0900 (JST)"));
+        }
+    );
+});
+
+test("Test - Timezone difference on reference date", function () {
+    // Sun Jun 06 2021 19:00:00 GMT+0900 (JST)
+    // Sun Jun 06 2021 11:00:00 GMT+0100 (BST)
+    const refInstant = new Date("Sun Jun 06 2021 19:00:00 GMT+0900 (JST)");
+
+    testSingleCase(chrono, "At 4pm tomorrow", { instant: refInstant, timezone: "BST" }, (result) => {
+        const expectedInstant = new Date("Mon Jun 07 2021 16:00:00 GMT+0100 (BST)");
+        expect(result).toBeDate(expectedInstant);
+    });
+
+    testSingleCase(chrono, "At 4pm tomorrow", { instant: refInstant, timezone: "JST" }, (result) => {
+        const expectedInstant = new Date("Mon Jun 07 2021 16:00:00 GMT+0900 (JST)");
+        expect(result).toBeDate(expectedInstant);
+    });
+});
+
+test("Test - Timezone difference on written date", function () {
+    // Sun Jun 06 2021 19:00:00 GMT+0900 (JST)
+    // Sun Jun 06 2021 11:00:00 GMT+0100 (BST)
+    const refInstant = new Date("Sun Jun 06 2021 19:00:00 GMT+0900 (JST)");
+
+    testSingleCase(chrono, "Sun Jun 06 2021 19:00:00", { timezone: "JST" }, (result) => {
+        expect(result).toBeDate(refInstant);
+    });
+
+    testSingleCase(chrono, "Sun Jun 06 2021 11:00:00", { timezone: "BST" }, (result) => {
+        expect(result).toBeDate(refInstant);
+    });
+
+    testSingleCase(chrono, "Sun Jun 06 2021 11:00:00", { timezone: 60 }, (result) => {
+        expect(result).toBeDate(refInstant);
+    });
+});
+
+test("Test - Precise [now] mentioned", function () {
+    const refDate = new Date("Sat Mar 13 2021 14:22:14 GMT+0900 (Japan Standard Time)");
+
+    testSingleCase(chrono, "now", refDate, (result) => {
+        expect(result).toBeDate(refDate);
+    });
+
+    testSingleCase(chrono, "now", { instant: refDate }, (result) => {
+        expect(result).toBeDate(refDate);
+    });
+
+    testSingleCase(chrono, "now", { instant: refDate, timezone: 540 }, (result) => {
+        expect(result).toBeDate(refDate);
+    });
+
+    testSingleCase(chrono, "now", { instant: refDate, timezone: "JST" }, (result) => {
+        expect(result).toBeDate(refDate);
+    });
+
+    testSingleCase(chrono, "now", { instant: refDate, timezone: -300 }, (result) => {
+        expect(result).toBeDate(refDate);
+    });
+});
+
+test("Test - Precise date/time mentioned", function () {
+    const text = "Sat Mar 13 2021 14:22:14 GMT+0900";
+    const refDate = new Date();
+
+    testSingleCase(chrono, text, refDate, (result, text) => {
+        expect(result).toBeDate(new Date(text));
+    });
+
+    testSingleCase(chrono, text, { instant: refDate }, (result) => {
+        expect(result).toBeDate(new Date(text));
+    });
+
+    testSingleCase(chrono, text, { instant: refDate, timezone: 540 }, (result) => {
+        expect(result).toBeDate(new Date(text));
+    });
+
+    testSingleCase(chrono, text, { instant: refDate, timezone: "JST" }, (result) => {
+        expect(result).toBeDate(new Date(text));
+    });
+
+    testSingleCase(chrono, text, { instant: refDate, timezone: -300 }, (result) => {
+        expect(result).toBeDate(new Date(text));
+    });
+});

package/test/test_util.ts

@@ -1,8 +1,8 @@
 import { BufferedDebugHandler } from "../src/debugging";
-import { en, ParsedResult, ParsingOption } from "../src";
+import { en, ParsedResult, ParsingOption, ParsingReference } from "../src";
 
 interface ChronoLike {
-    parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[];
+    parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[];
 }
 
 type CheckResult = (p: ParsedResult, text: string) => void;
@@ -11,20 +11,20 @@ export function testSingleCase(chrono: ChronoLike, text: string, checkResult?: C
 export function testSingleCase(
     chrono: ChronoLike,
     text: string,
-    refDateOrCheckResult?: Date | CheckResult,
+    refDateOrCheckResult?: ParsingReference | Date | CheckResult,
     checkResult?: CheckResult
 );
 export function testSingleCase(
     chrono: ChronoLike,
     text: string,
-    refDateOrCheckResult?: Date | CheckResult,
+    refDateOrCheckResult?: ParsingReference | Date | CheckResult,
     optionOrCheckResult?: ParsingOption | CheckResult,
     checkResult?: CheckResult
 );
 export function testSingleCase(
     chrono: ChronoLike,
     text: string,
-    refDateOrCheckResult?: Date | CheckResult,
+    refDateOrCheckResult?: ParsingReference | Date | CheckResult,
     optionOrCheckResult?: ParsingOption | CheckResult,
     checkResult?: CheckResult
 ) {
@@ -61,10 +61,13 @@ export function testWithExpectedDate(chrono: ChronoLike, text: string, expectedD
     });
 }
 
-export function testUnexpectedResult(chrono: ChronoLike, text: string, refDate?: Date) {
+export function testUnexpectedResult(chrono: ChronoLike, text: string, refDate?: Date, options?: ParsingOption) {
     const debugHandler = new BufferedDebugHandler();
+    options = options || {};
+    options.debug = debugHandler;
+
     try {
-        const results = chrono.parse(text, refDate, { debug: debugHandler });
+        const results = chrono.parse(text, refDate, options);
         expect(results).toHaveLength(0);
     } catch (e) {
         debugHandler.executeBufferedBlocks();