chrono-node 2.8.3 → 2.8.4

package/src/locales/sv/parsers/SVMonthNameLittleEndianParser.ts

@@ -0,0 +1,59 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+import { findYearClosestToRef } from "../../../calculation/years";
+import { MONTH_DICTIONARY } from "../constants";
+import { parseYear } from "../constants";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN = new RegExp(
+    "(?:den\\s*?)?" +
+        `([0-9]{1,2})` +
+        `(?:\\s*(?:till|\\-|\\–|\\s)\\s*([0-9]{1,2}))?\\s*` +
+        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+        `(?:(?:-|/|,?\\s*)([0-9]{4}(?![^\\s]\\d)))?` +
+        `(?=\\W|$)`,
+    "i"
+);
+
+const DATE_GROUP = 1;
+const DATE_TO_GROUP = 2;
+const MONTH_NAME_GROUP = 3;
+const YEAR_GROUP = 4;
+
+export default class SVMonthNameLittleEndianParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {
+        const result = context.createParsingResult(match.index, match[0]);
+
+        const month = MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];
+        const day = parseInt(match[DATE_GROUP]);
+        if (day > 31) {
+            // e.g. "[96 Aug]" => "9[6 Aug]", we need to shift away from the next number
+            match.index = match.index + match[DATE_GROUP].length;
+            return null;
+        }
+
+        result.start.assign("month", month);
+        result.start.assign("day", day);
+
+        if (match[YEAR_GROUP]) {
+            const yearNumber = parseYear(match[YEAR_GROUP]);
+            result.start.assign("year", yearNumber);
+        } else {
+            const year = findYearClosestToRef(context.refDate, day, month);
+            result.start.imply("year", year);
+        }
+
+        if (match[DATE_TO_GROUP]) {
+            const endDate = parseInt(match[DATE_TO_GROUP]);
+            result.end = result.start.clone();
+            result.end.assign("day", endDate);
+        }
+
+        return result;
+    }
+}

package/src/locales/sv/parsers/SVWeekdayParser.ts

@@ -0,0 +1,47 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { WEEKDAY_DICTIONARY } from "../constants";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { createParsingComponentsAtWeekday } from "../../../calculation/weekdays";
+
+const PATTERN = new RegExp(
+    "(?:(?:\\,|\\(|\\（)\\s*)?" +
+        "(?:på\\s*?)?" +
+        "(?:(förra|senaste|nästa|kommande)\\s*)?" +
+        `(${matchAnyPattern(WEEKDAY_DICTIONARY)})` +
+        "(?:\\s*(?:\\,|\\)|\\）))?" +
+        "(?:\\s*(förra|senaste|nästa|kommande)\\s*vecka)?" +
+        "(?=\\W|$)",
+    "i"
+);
+
+const PREFIX_GROUP = 1;
+const SUFFIX_GROUP = 3;
+const WEEKDAY_GROUP = 2;
+
+export default class SVWeekdayParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const dayOfWeek = match[WEEKDAY_GROUP].toLowerCase();
+        const offset = WEEKDAY_DICTIONARY[dayOfWeek];
+        const prefix = match[PREFIX_GROUP];
+        const postfix = match[SUFFIX_GROUP];
+
+        let modifierWord = prefix || postfix;
+        modifierWord = modifierWord || "";
+        modifierWord = modifierWord.toLowerCase();
+
+        let modifier = null;
+        if (modifierWord.match(/förra|senaste/)) {
+            modifier = "last";
+        } else if (modifierWord.match(/nästa|kommande/)) {
+            modifier = "next";
+        }
+
+        return createParsingComponentsAtWeekday(context.reference, offset, modifier);
+    }
+}

package/src/results.ts

@@ -1,4 +1,4 @@
-import { Component, ParsedComponents, ParsedResult, ParsingReference } from "./types";
+import { Component, ParsedComponents, ParsedResult, ParsingReference, TimezoneAbbrMap } from "./types";
 
 import quarterOfYear from "dayjs/plugin/quarterOfYear";
 import dayjs, { QUnitType } from "dayjs";
@@ -11,15 +11,22 @@ export class ReferenceWithTimezone {
     readonly instant: Date;
     readonly timezoneOffset?: number | null;
 
-    constructor(input?: ParsingReference | Date) {
-        input = input ?? new Date();
+    constructor(instant?: Date, timezoneOffset?: number) {
+        this.instant = instant ?? new Date();
+        this.timezoneOffset = timezoneOffset ?? null;
+    }
+
+    static fromDate(date: Date): ReferenceWithTimezone {
+        return new ReferenceWithTimezone(date);
+    }
+
+    static fromInput(input?: ParsingReference | Date, timezoneOverrides?: TimezoneAbbrMap) {
         if (input instanceof Date) {
-            this.instant = input;
-            this.timezoneOffset = null;
-        } else {
-            this.instant = input.instant ?? new Date();
-            this.timezoneOffset = toTimezoneOffset(input.timezone, this.instant);
+            return ReferenceWithTimezone.fromDate(input);
         }
+        const instant: Date = input?.instant ?? new Date();
+        const timezoneOffset = toTimezoneOffset(input?.timezone, instant, timezoneOverrides);
+        return new ReferenceWithTimezone(instant, timezoneOffset);
     }
 
     /**

package/test/result.test.ts

@@ -1,7 +1,7 @@
 import { ParsingComponents, ParsingResult, ReferenceWithTimezone } from "../src/results";
 
 test("Test - Create & manipulate parsing components", () => {
-    const reference = new ReferenceWithTimezone(new Date());
+    const reference = ReferenceWithTimezone.fromDate(new Date());
     const components = new ParsingComponents(reference, { year: 2014, month: 11, day: 24 });
 
     expect(components.get("year")).toBe(2014);
@@ -178,21 +178,21 @@ test("Test - Checking non-existing date during DST skip", () => {
 
 test("Test - Getting timezone adjust date from references", () => {
     {
-        const reference = new ReferenceWithTimezone({
+        const reference = ReferenceWithTimezone.fromInput({
             instant: new Date("Wed Jun 09 2021 07:21:32 GMT+0900 (JST)"),
             timezone: 9 * 60,
         });
         expect(reference.getDateWithAdjustedTimezone()).toStrictEqual(new Date(2021, 6 - 1, 9, 7, 21, 32));
     }
     {
-        const reference = new ReferenceWithTimezone({
+        const reference = ReferenceWithTimezone.fromInput({
             instant: new Date("Wed Jun 09 2021 07:21:32 GMT+0900 (JST)"),
             timezone: "JST",
         });
         expect(reference.getDateWithAdjustedTimezone()).toStrictEqual(new Date(2021, 6 - 1, 9, 7, 21, 32));
     }
     {
-        const reference = new ReferenceWithTimezone({
+        const reference = ReferenceWithTimezone.fromInput({
             instant: new Date("Wed Jun 09 2021 07:21:32 GMT-0500 (CDT)"),
             timezone: "CDT",
         });

package/test/sv/sv_casual.test.ts

@@ -0,0 +1,45 @@
+import * as chrono from "../../src/locales/sv";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", function () {
+    testSingleCase(chrono, "idag", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+    });
+
+    testSingleCase(chrono, "imorgon", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(11);
+    });
+
+    testSingleCase(chrono, "igår", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(9);
+    });
+
+    testSingleCase(chrono, "förrgår", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(8);
+    });
+});
+
+test("Test - Combined Expression", function () {
+    testSingleCase(chrono, "idag på morgonen", new Date(2012, 7, 10), (result) => {
+        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(6);
+    });
+
+    // Denna funktionalitet behöver ytterligare utveckling
+    // testSingleCase(chrono, "imorgon kväll", new Date(2012, 7, 10), (result) => {
+    //     expect(result.start.get("year")).toBe(2012);
+    //     expect(result.start.get("month")).toBe(8);
+    //     expect(result.start.get("day")).toBe(11);
+    //     expect(result.start.get("hour")).toBe(20);
+    // });
+});

package/test/sv/sv_weekday.test.ts

@@ -0,0 +1,68 @@
+import * as chrono from "../../src/locales/sv";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", function () {
+    testSingleCase(chrono, "måndag", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("måndag");
+
+        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(6);
+        expect(result.start.get("weekday")).toBe(1);
+    });
+
+    testSingleCase(chrono, "på måndag", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("på måndag");
+
+        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(6);
+        expect(result.start.get("weekday")).toBe(1);
+    });
+});
+
+test("Test - Next/Last Week Expression", function () {
+    testSingleCase(chrono, "nästa måndag", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("nästa måndag");
+
+        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);
+    });
+
+    testSingleCase(chrono, "förra måndag", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("förra måndag");
+
+        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(6);
+        expect(result.start.get("weekday")).toBe(1);
+    });
+});
+
+test("Test - Weekday variations", function () {
+    testSingleCase(chrono, "söndag", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(0);
+    });
+
+    testSingleCase(chrono, "tisdag", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(2);
+    });
+
+    testSingleCase(chrono, "fredag", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(5);
+    });
+
+    testSingleCase(chrono, "lördag", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(6);
+    });
+});

package/test/system_timezone.test.ts

@@ -70,6 +70,42 @@ test("Test - Using reference instance with different timezone", function () {
     });
 });
 
+test("Test - Using reference instance with custom timezones", 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)");
+
+    // Fictional timezones
+    const timezones = {
+        "JJJ": 540, // JJJ => GMT+0900 JST
+        "BBB": 60, // BBB => GMT+0100 BST
+    };
+
+    // "At 4pm tomorrow" at "Sun Jun 06 2021 11:00:00 (BBB = BST)"
+    testSingleCase(
+        chrono,
+        "At 4pm tomorrow",
+        { instant: refInstant, timezone: "BBB" },
+        { timezones: timezones },
+        (result) => {
+            const expectedInstant = new Date("Mon Jun 07 2021 16:00:00 GMT+0100 (BST)");
+            expect(result).toBeDate(expectedInstant);
+        }
+    );
+
+    // "At 4pm tomorrow" at "Sun Jun 06 2021 19:00:00 (JJJ = JST)"
+    testSingleCase(
+        chrono,
+        "At 4pm tomorrow",
+        { instant: refInstant, timezone: "JJJ" },
+        { timezones: timezones },
+        (result) => {
+            const expectedInstant = new Date("Mon Jun 07 2021 16:00:00 GMT+0900 (JST)");
+            expect(result).toBeDate(expectedInstant);
+        }
+    );
+});
+
 test("Test - Timezone difference on reference date #2", function () {
     const refInstant = new Date("2024-02-21T10:00:00+1300");