chrono-node 2.7.8 → 2.7.9

package/src/locales/it/parsers/ITMonthNameParser.ts

@@ -0,0 +1,62 @@
+import { FULL_MONTH_NAME_DICTIONARY, MONTH_DICTIONARY } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { findYearClosestToRef } from "../../../calculation/years";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { YEAR_PATTERN, parseYear } from "../constants";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN = new RegExp(
+    `((?:in)\\s*)?` +
+        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+        `\\s*` +
+        `(?:` +
+        `[,-]?\\s*(${YEAR_PATTERN})?` +
+        ")?" +
+        "(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)",
+    "i"
+);
+
+const PREFIX_GROUP = 1;
+const MONTH_NAME_GROUP = 2;
+const YEAR_GROUP = 3;
+
+/**
+ * The parser for parsing month name and year.
+ * - January, 2012
+ * - January 2012
+ * - January
+ * (in) Jan
+ */
+export default class ENMonthNameParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const monthName = match[MONTH_NAME_GROUP].toLowerCase();
+
+        // skip some unlikely words "jan", "mar", ..
+        if (match[0].length <= 3 && !FULL_MONTH_NAME_DICTIONARY[monthName]) {
+            return null;
+        }
+
+        const result = context.createParsingResult(
+            match.index + (match[PREFIX_GROUP] || "").length,
+            match.index + match[0].length
+        );
+        result.start.imply("day", 1);
+
+        const month = MONTH_DICTIONARY[monthName];
+        result.start.assign("month", month);
+
+        if (match[YEAR_GROUP]) {
+            const year = parseYear(match[YEAR_GROUP]);
+            result.start.assign("year", year);
+        } else {
+            const year = findYearClosestToRef(context.refDate, 1, month);
+            result.start.imply("year", year);
+        }
+
+        return result;
+    }
+}

package/src/locales/it/parsers/ITRelativeDateFormatParser.ts

@@ -0,0 +1,71 @@
+import { TIME_UNIT_DICTIONARY } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import dayjs from "dayjs";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { matchAnyPattern } from "../../../utils/pattern";
+
+const PATTERN = new RegExp(
+    `(questo|ultimo|scorso|prossimo|dopo\\s*questo|questa|ultima|scorsa|prossima\\s*questa)\\s*(${matchAnyPattern(
+        TIME_UNIT_DICTIONARY
+    )})(?=\\s*)` + "(?=\\W|$)",
+    "i"
+);
+
+const MODIFIER_WORD_GROUP = 1;
+const RELATIVE_WORD_GROUP = 2;
+
+export default class ENRelativeDateFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const modifier = match[MODIFIER_WORD_GROUP].toLowerCase();
+        const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();
+        const timeunit = TIME_UNIT_DICTIONARY[unitWord];
+
+        if (modifier == "prossimo" || modifier.startsWith("dopo")) {
+            const timeUnits = {};
+            timeUnits[timeunit] = 1;
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+
+        if (modifier == "prima" || modifier == "precedente") {
+            const timeUnits = {};
+            timeUnits[timeunit] = -1;
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+
+        const components = context.createParsingComponents();
+        let date = dayjs(context.reference.instant);
+
+        // This week
+        if (unitWord.match(/settimana/i)) {
+            date = date.add(-date.get("d"), "d");
+            components.imply("day", date.date());
+            components.imply("month", date.month() + 1);
+            components.imply("year", date.year());
+        }
+
+        // This month
+        else if (unitWord.match(/mese/i)) {
+            date = date.add(-date.date() + 1, "d");
+            components.imply("day", date.date());
+            components.assign("year", date.year());
+            components.assign("month", date.month() + 1);
+        }
+
+        // This year
+        else if (unitWord.match(/anno/i)) {
+            date = date.add(-date.date() + 1, "d");
+            date = date.add(-date.month(), "month");
+
+            components.imply("day", date.date());
+            components.imply("month", date.month() + 1);
+            components.assign("year", date.year());
+        }
+
+        return components;
+    }
+}

package/src/locales/it/parsers/ITSlashMonthFormatParser.ts

@@ -0,0 +1,26 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN = new RegExp("([0-9]|0[1-9]|1[012])/([0-9]{4})" + "", "i");
+
+const MONTH_GROUP = 1;
+const YEAR_GROUP = 2;
+
+/**
+ * Month/Year date format with slash "/" (also "-" and ".") between numbers
+ * - 11/05
+ * - 06/2005
+ */
+export default class ENSlashMonthFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const year = parseInt(match[YEAR_GROUP]);
+        const month = parseInt(match[MONTH_GROUP]);
+
+        return context.createParsingComponents().imply("day", 1).assign("month", month).assign("year", year);
+    }
+}

package/src/locales/it/parsers/ITTimeExpressionParser.ts

@@ -0,0 +1,55 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { Meridiem } from "../../../index";
+import { AbstractTimeExpressionParser } from "../../../common/parsers/AbstractTimeExpressionParser";
+
+export default class ENTimeExpressionParser extends AbstractTimeExpressionParser {
+    constructor(strictMode) {
+        super(strictMode);
+    }
+
+    followingPhase(): string {
+        return "\\s*(?:\\-|\\–|\\~|\\〜|to|\\?)\\s*";
+    }
+
+    primaryPrefix(): string {
+        return "(?:(?:alle|dalle)\\s*)??";
+    }
+
+    primarySuffix(): string {
+        return "(?:\\s*(?:o\\W*in punto|alle\\s*sera|in\\s*del\\s*(?:mattina|pomeriggio)))?(?!/)(?=\\W|$)";
+    }
+
+    extractPrimaryTimeComponents(context: ParsingContext, match: RegExpMatchArray): null | ParsingComponents {
+        const components = super.extractPrimaryTimeComponents(context, match);
+        if (components) {
+            if (match[0].endsWith("sera")) {
+                const hour = components.get("hour");
+                if (hour >= 6 && hour < 12) {
+                    components.assign("hour", components.get("hour") + 12);
+                    components.assign("meridiem", Meridiem.PM);
+                } else if (hour < 6) {
+                    components.assign("meridiem", Meridiem.AM);
+                }
+            }
+
+            if (match[0].endsWith("pomeriggio")) {
+                components.assign("meridiem", Meridiem.PM);
+                const hour = components.get("hour");
+                if (hour >= 0 && hour <= 6) {
+                    components.assign("hour", components.get("hour") + 12);
+                }
+            }
+
+            if (match[0].endsWith("mattina")) {
+                components.assign("meridiem", Meridiem.AM);
+                const hour = components.get("hour");
+                if (hour < 12) {
+                    components.assign("hour", components.get("hour"));
+                }
+            }
+        }
+
+        return components;
+    }
+}

package/src/locales/it/parsers/ITTimeUnitAgoFormatParser.ts

@@ -0,0 +1,25 @@
+import { ParsingContext } from "../../../chrono";
+import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { reverseTimeUnits } from "../../../utils/timeunits";
+
+const PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}(?:fa|prima|precedente)(?=(?:\\W|$))`, "i");
+const STRICT_PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}fa(?=(?:\\W|$))`, "i");
+
+export default class ENTimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private strictMode: boolean) {
+        super();
+    }
+
+    innerPattern(): RegExp {
+        return this.strictMode ? STRICT_PATTERN : PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const timeUnits = parseTimeUnits(match[1]);
+        const outputTimeUnits = reverseTimeUnits(timeUnits);
+
+        return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
+    }
+}

package/src/locales/it/parsers/ITTimeUnitCasualRelativeFormatParser.ts

@@ -0,0 +1,30 @@
+import { TIME_UNITS_PATTERN, parseTimeUnits } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { reverseTimeUnits } from "../../../utils/timeunits";
+
+const PATTERN = new RegExp(
+    `(questo|ultimo|passato|prossimo|dopo|questa|ultima|passata|prossima|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`,
+    "i"
+);
+
+export default class ENTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const prefix = match[1].toLowerCase();
+        let timeUnits = parseTimeUnits(match[2]);
+        switch (prefix) {
+            case "last":
+            case "past":
+            case "-":
+                timeUnits = reverseTimeUnits(timeUnits);
+                break;
+        }
+
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}

package/src/locales/it/parsers/ITTimeUnitLaterFormatParser.ts

@@ -0,0 +1,27 @@
+import { ParsingContext } from "../../../chrono";
+import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN = new RegExp(
+    `(${TIME_UNITS_PATTERN})\\s{0,5}(?:dopo|più tardi|da adesso|avanti|oltre|a seguire)` + "(?=(?:\\W|$))",
+    "i"
+);
+
+const STRICT_PATTERN = new RegExp("" + "(" + TIME_UNITS_PATTERN + ")" + "(dopo|più tardi)" + "(?=(?:\\W|$))", "i");
+const GROUP_NUM_TIMEUNITS = 1;
+
+export default class ENTimeUnitLaterFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private strictMode: boolean) {
+        super();
+    }
+
+    innerPattern(): RegExp {
+        return this.strictMode ? STRICT_PATTERN : PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const fragments = parseTimeUnits(match[GROUP_NUM_TIMEUNITS]);
+        return ParsingComponents.createRelativeFromReference(context.reference, fragments);
+    }
+}

package/src/locales/it/parsers/ITTimeUnitWithinFormatParser.ts

@@ -0,0 +1,26 @@
+import { TIME_UNITS_PATTERN, parseTimeUnits } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN_WITH_PREFIX = new RegExp(
+    `(?:within|in|for)\\s*` +
+        `(?:(?:più o meno|intorno|approssimativamente|verso|verso le)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`,
+    "i"
+);
+
+const PATTERN_WITHOUT_PREFIX = new RegExp(
+    `(?:(?:più o meno|intorno|approssimativamente|verso|verso le)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`,
+    "i"
+);
+
+export default class ENTimeUnitWithinFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(context: ParsingContext): RegExp {
+        return context.option.forwardDate ? PATTERN_WITHOUT_PREFIX : PATTERN_WITH_PREFIX;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const timeUnits = parseTimeUnits(match[1]);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}

package/src/locales/it/parsers/ITWeekdayParser.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 "../../../common/calculation/weekdays";
+
+const PATTERN = new RegExp(
+    "(?:(?:\\,|\\(|\\（)\\s*)?" +
+        "(?:il\\s*?)?" +
+        "(?:(questa|l'ultima|scorsa|prossima)\\s*)?" +
+        `(${matchAnyPattern(WEEKDAY_DICTIONARY)})` +
+        "(?:\\s*(?:\\,|\\)|\\）))?" +
+        "(?:\\s*(questa|l'ultima|scorsa|prossima)\\s*settimana)?" +
+        "(?=\\W|$)",
+    "i"
+);
+
+const PREFIX_GROUP = 1;
+const WEEKDAY_GROUP = 2;
+const POSTFIX_GROUP = 3;
+
+export default class ITWeekdayParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const dayOfWeek = match[WEEKDAY_GROUP].toLowerCase();
+        const weekday = WEEKDAY_DICTIONARY[dayOfWeek];
+        const prefix = match[PREFIX_GROUP];
+        const postfix = match[POSTFIX_GROUP];
+        let modifierWord = prefix || postfix;
+        modifierWord = modifierWord || "";
+        modifierWord = modifierWord.toLowerCase();
+
+        let modifier = null;
+        if (modifierWord == "ultima" || modifierWord == "scorsa") {
+            modifier = "ultima";
+        } else if (modifierWord == "prossima") {
+            modifier = "prossima";
+        } else if (modifierWord == "questa") {
+            modifier = "questa";
+        }
+        return createParsingComponentsAtWeekday(context.reference, weekday, modifier);
+    }
+}

package/src/locales/it/refiners/ITMergeDateRangeRefiner.ts

@@ -0,0 +1,17 @@
+/*
+  
+*/
+
+import AbstractMergeDateRangeRefiner from "../../../common/refiners/AbstractMergeDateRangeRefiner";
+
+/**
+ * Merging before and after results (see. AbstractMergeDateRangeRefiner)
+ * This implementation should provide English connecting phases
+ * - 2020-02-13 [to] 2020-02-13
+ * - Wednesday [-] Friday
+ */
+export default class ENMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner {
+    patternBetween(): RegExp {
+        return /^\s*(to|-)\s*$/i;
+    }
+}

package/src/locales/it/refiners/ITMergeDateTimeRefiner.ts

@@ -0,0 +1,13 @@
+import AbstractMergeDateTimeRefiner from "../../../common/refiners/AbstractMergeDateTimeRefiner";
+
+/**
+ * Merging date-only result and time-only result (see. AbstractMergeDateTimeRefiner).
+ * This implementation should provide English connecting phases
+ * - 2020-02-13 [at] 6pm
+ * - Tomorrow [after] 7am
+ */
+export default class ENMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner {
+    patternBetween(): RegExp {
+        return new RegExp("^\\s*(T|alle|dopo|prima|il|di|del|delle|,|-)?\\s*$");
+    }
+}

package/src/locales/it/refiners/ITMergeRelativeDateRefiner.ts

@@ -0,0 +1,58 @@
+import { MergingRefiner } from "../../../common/abstractRefiners";
+import { ParsingComponents, ParsingResult, ReferenceWithTimezone } from "../../../results";
+import { parseTimeUnits } from "../constants";
+import { reverseTimeUnits } from "../../../utils/timeunits";
+
+function hasImpliedEarlierReferenceDate(result: ParsingResult): boolean {
+    return result.text.match(/\s+(prima|dal)$/i) != null;
+}
+
+function hasImpliedLaterReferenceDate(result: ParsingResult): boolean {
+    return result.text.match(/\s+(dopo|dal|fino)$/i) != null;
+}
+
+/**
+ * Merges an absolute date with a relative date.
+ * - 2 weeks before 2020-02-13
+ * - 2 days after next Friday
+ */
+export default class ENMergeRelativeDateRefiner extends MergingRefiner {
+    patternBetween(): RegExp {
+        return /^\s*$/i;
+    }
+
+    shouldMergeResults(textBetween: string, currentResult: ParsingResult, nextResult: ParsingResult): boolean {
+        // Dates need to be next to each other to get merged
+        if (!textBetween.match(this.patternBetween())) {
+            return false;
+        }
+
+        // Check if any relative tokens were swallowed by the first date.
+        // E.g. [<relative_date1> from] [<date2>]
+        if (!hasImpliedEarlierReferenceDate(currentResult) && !hasImpliedLaterReferenceDate(currentResult)) {
+            return false;
+        }
+
+        // make sure that <date2> implies an absolute date
+        return !!nextResult.start.get("day") && !!nextResult.start.get("month") && !!nextResult.start.get("year");
+    }
+
+    mergeResults(textBetween: string, currentResult: ParsingResult, nextResult: ParsingResult): ParsingResult {
+        let timeUnits = parseTimeUnits(currentResult.text);
+        if (hasImpliedEarlierReferenceDate(currentResult)) {
+            timeUnits = reverseTimeUnits(timeUnits);
+        }
+
+        const components = ParsingComponents.createRelativeFromReference(
+            new ReferenceWithTimezone(nextResult.start.date()),
+            timeUnits
+        );
+
+        return new ParsingResult(
+            nextResult.reference,
+            currentResult.index,
+            `${currentResult.text}${textBetween}${nextResult.text}`,
+            components
+        );
+    }
+}

package/src/locales/ja/parsers/JPCasualDateParser.ts

@@ -3,14 +3,14 @@ import dayjs from "dayjs";
 import { Meridiem } from "../../../types";
 import * as references from "../../../common/casualReferences";
 
-const PATTERN = /今日|きょう|当日|とうじつ|昨日|きのう|明日|あした|今夜|こんや|今夕|こんゆう|今晩|こんばん|今朝|けさ/i;
+const PATTERN = /今日|きょう|本日|ほんじつ|昨日|きのう|明日|あした|今夜|こんや|今夕|こんゆう|今晩|こんばん|今朝|けさ/i;
 
 function normalizeTextToKanji(text: string) {
     switch (text) {
         case "きょう":
             return "今日";
-        case "とうじつ":
-            return "当日";
+        case "ほんじつ":
+            return "本日";
         case "きのう":
             return "昨日";
         case "あした":
@@ -46,8 +46,8 @@ export default class JPCasualDateParser implements Parser {
             case "明日":
                 return references.tomorrow(context.reference);
 
+            case "本日":
             case "今日":
-            case "当日":
                 return references.today(context.reference);
         }
 

package/src/locales/ja/refiners/JPMergeDateRangeRefiner.ts

@@ -8,6 +8,6 @@ import AbstractMergeDateRangeRefiner from "../../../common/refiners/AbstractMerg
  */
 export default class JPMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner {
     patternBetween(): RegExp {
-        return /^\s*(から|ー|-)\s*$/i;
+        return /^\s*(から|ー|-|～|~)\s*$/i;
     }
 }

package/test/ja/ja_casual.test.ts

@@ -10,6 +10,14 @@ test("Test - Single Expression", function () {
         expect(result.text).toBe("きょう");
         expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 12));
     });
+    testSingleCase(chrono.ja, "本日はお日柄もよく", new Date(2012, 8 - 1, 10, 12), (result) => {
+        expect(result.text).toBe("本日");
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 12));
+    });
+    testSingleCase(chrono.ja, "ほんじつはお日柄もよく", new Date(2012, 8 - 1, 10, 12), (result) => {
+        expect(result.text).toBe("ほんじつ");
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 12));
+    });
 
     testSingleCase(chrono.ja, "昨日の全国観測値ランキング", new Date(2012, 8 - 1, 10, 12), (result) => {
         expect(result.text).toBe("昨日");

package/test/ja/ja_standard.test.ts

@@ -213,4 +213,23 @@ test("Test - Range Expression", function () {
 
         expect(result.end).toBeDate(new Date(2014, 1 - 1, 7, 12));
     });
+
+    testSingleCase(chrono.ja, "2013年12月26日 ～ ２０１４年１月７日", new Date(2012, 8 - 1, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("2013年12月26日 ～ ２０１４年１月７日");
+
+        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));
+    });
 });