chrono-node 2.3.3 → 2.3.7

package/src/locales/en/index.ts

@@ -26,6 +26,7 @@ import { ParsedResult, ParsingOption } from "../../index";
 import { Chrono, Configuration } from "../../chrono";
 import SlashDateFormatParser from "../../common/parsers/SlashDateFormatParser";
 import ENTimeUnitCasualRelativeFormatParser from "./parsers/ENTimeUnitCasualRelativeFormatParser";
+import ENMergeRelativeDateRefiner from "./refiners/ENMergeRelativeDateRefiner";
 
 /**
  * Chrono object configured for parsing *casual* English
@@ -91,7 +92,7 @@ export function createConfiguration(strictMode = true, littleEndian = false): Co
                 new ENTimeUnitAgoFormatParser(strictMode),
                 new ENTimeUnitLaterFormatParser(strictMode),
             ],
-            refiners: [new ENMergeDateTimeRefiner(), new ENMergeDateRangeRefiner()],
+            refiners: [new ENMergeRelativeDateRefiner(), new ENMergeDateTimeRefiner(), new ENMergeDateRangeRefiner()],
         },
         strictMode
     );

package/src/locales/en/parsers/ENMonthNameLittleEndianParser.ts

@@ -36,8 +36,6 @@ export default class ENMonthNameLittleEndianParser extends AbstractParserWithWor
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {
-        //console.log(match)
-
         const result = context.createParsingResult(match.index, match[0]);
 
         const month = MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];

package/src/locales/en/parsers/ENRelativeDateFormatParser.ts

@@ -6,7 +6,7 @@ import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/
 import { matchAnyPattern } from "../../../utils/pattern";
 
 const PATTERN = new RegExp(
-    `(this|next|last|past)\\s*(${matchAnyPattern(TIME_UNIT_DICTIONARY)})(?=\\s*)` + "(?=\\W|$)",
+    `(this|last|past|next|after\\s*this)\\s*(${matchAnyPattern(TIME_UNIT_DICTIONARY)})(?=\\s*)` + "(?=\\W|$)",
     "i"
 );
 
@@ -23,7 +23,7 @@ export default class ENRelativeDateFormatParser extends AbstractParserWithWordBo
         const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();
         const timeunit = TIME_UNIT_DICTIONARY[unitWord];
 
-        if (modifier == "next") {
+        if (modifier == "next" || modifier.startsWith("after")) {
             const timeUnits = {};
             timeUnits[timeunit] = 1;
             return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);

package/src/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser.ts

@@ -4,7 +4,7 @@ import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { reverseTimeUnits } from "../../../utils/timeunits";
 
-const PATTERN = new RegExp(`(this|last|past|next|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+const PATTERN = new RegExp(`(this|last|past|next|after|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
 
 export default class ENTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern(): RegExp {

package/src/locales/en/refiners/ENMergeRelativeDateRefiner.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+(before|from)$/i) != null;
+}
+
+function hasImpliedLaterReferenceDate(result: ParsingResult): boolean {
+    return result.text.match(/\s+(after|since)$/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/zh/hans/constants.ts

@@ -0,0 +1,52 @@
+export const NUMBER = {
+    "零": 0,
+    "〇": 0,
+    "一": 1,
+    "二": 2,
+    "两": 2,
+    "三": 3,
+    "四": 4,
+    "五": 5,
+    "六": 6,
+    "七": 7,
+    "八": 8,
+    "九": 9,
+    "十": 10,
+};
+
+export const WEEKDAY_OFFSET = {
+    "天": 0,
+    "日": 0,
+    "一": 1,
+    "二": 2,
+    "三": 3,
+    "四": 4,
+    "五": 5,
+    "六": 6,
+};
+
+export function zhStringToNumber(text: string) {
+    let number = 0;
+
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (char === "十") {
+            number = number === 0 ? NUMBER[char] : number * NUMBER[char];
+        } else {
+            number += NUMBER[char];
+        }
+    }
+
+    return number;
+}
+
+export function zhStringToYear(text: string) {
+    let string = "";
+
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        string = string + NUMBER[char];
+    }
+
+    return parseInt(string);
+}

package/src/locales/zh/hans/index.ts

@@ -0,0 +1,62 @@
+/**
+ * Chrono components for zh support
+ */
+
+import { Chrono, Configuration } from "../../../chrono";
+import ExtractTimezoneOffsetRefiner from "../../../common/refiners/ExtractTimezoneOffsetRefiner";
+import { includeCommonConfiguration } from "../../../configurations";
+import { ParsedResult, ParsingOption } from "../../../index";
+import ZHHansCasualDateParser from "./parsers/ZHHansCasualDateParser";
+import ZHHansDateParser from "./parsers/ZHHansDateParser";
+import ZHHansDeadlineFormatParser from "./parsers/ZHHansDeadlineFormatParser";
+import ZHHansRelationWeekdayParser from "./parsers/ZHHansRelationWeekdayParser";
+import ZHHansTimeExpressionParser from "./parsers/ZHHansTimeExpressionParser";
+import ZHHansWeekdayParser from "./parsers/ZHHansWeekdayParser";
+import ZHHansMergeDateRangeRefiner from "./refiners/ZHHansMergeDateRangeRefiner";
+import ZHHansMergeDateTimeRefiner from "./refiners/ZHHansMergeDateTimeRefiner";
+
+// Shortcuts
+export const hans = new Chrono(createCasualConfiguration());
+
+export const casual = new Chrono(createCasualConfiguration());
+export const strict = new Chrono(createConfiguration());
+
+export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+    return casual.parse(text, ref, option);
+}
+
+export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+    return casual.parseDate(text, ref, option);
+}
+
+/**
+ * @ignore (to be documented later)
+ */
+export function createCasualConfiguration(): Configuration {
+    const option = createConfiguration();
+    option.parsers.unshift(new ZHHansCasualDateParser());
+    return option;
+}
+
+/**
+ * @ignore (to be documented later)
+ */
+export function createConfiguration(): Configuration {
+    const configuration = includeCommonConfiguration({
+        parsers: [
+            new ZHHansDateParser(),
+            new ZHHansRelationWeekdayParser(),
+            new ZHHansWeekdayParser(),
+            new ZHHansTimeExpressionParser(),
+            new ZHHansDeadlineFormatParser(),
+        ],
+        refiners: [new ZHHansMergeDateRangeRefiner(), new ZHHansMergeDateTimeRefiner()],
+    });
+
+    // REMOVE ExtractTimezoneOffsetRefiner
+    configuration.refiners = configuration.refiners.filter(
+        (refiner) => !(refiner instanceof ExtractTimezoneOffsetRefiner)
+    );
+
+    return configuration;
+}

package/src/locales/zh/hans/parsers/ZHHansCasualDateParser.ts

@@ -0,0 +1,128 @@
+import dayjs from "dayjs";
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+import { ParsingComponents, ParsingResult } from "../../../../results";
+
+const NOW_GROUP = 1;
+const DAY_GROUP_1 = 2;
+const TIME_GROUP_1 = 3;
+const TIME_GROUP_2 = 4;
+const DAY_GROUP_3 = 5;
+const TIME_GROUP_3 = 6;
+
+export default class ZHHansCasualDateParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(context: ParsingContext): RegExp {
+        return new RegExp(
+            "(现在|立(?:刻|即)|即刻)|" +
+                "(今|明|前|大前|后|大后|昨)(早|晚)|" +
+                "(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨))|" +
+                "(今|明|前|大前|后|大后|昨)(?:日|天)" +
+                "(?:[\\s|,|，]*)" +
+                "(?:(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?",
+            "i"
+        );
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
+        const index = match.index;
+        const result = context.createParsingResult(index, match[0]);
+
+        const refMoment = dayjs(context.refDate);
+        let startMoment = refMoment;
+
+        if (match[NOW_GROUP]) {
+            result.start.imply("hour", refMoment.hour());
+            result.start.imply("minute", refMoment.minute());
+            result.start.imply("second", refMoment.second());
+            result.start.imply("millisecond", refMoment.millisecond());
+        } else if (match[DAY_GROUP_1]) {
+            const day1 = match[DAY_GROUP_1];
+            const time1 = match[TIME_GROUP_1];
+
+            if (day1 == "明") {
+                // Check not "Tomorrow" on late night
+                if (refMoment.hour() > 1) {
+                    startMoment = startMoment.add(1, "day");
+                }
+            } else if (day1 == "昨") {
+                startMoment = startMoment.add(-1, "day");
+            } else if (day1 == "前") {
+                startMoment = startMoment.add(-2, "day");
+            } else if (day1 == "大前") {
+                startMoment = startMoment.add(-3, "day");
+            } else if (day1 == "后") {
+                startMoment = startMoment.add(2, "day");
+            } else if (day1 == "大后") {
+                startMoment = startMoment.add(3, "day");
+            }
+
+            if (time1 == "早") {
+                result.start.imply("hour", 6);
+            } else if (time1 == "晚") {
+                result.start.imply("hour", 22);
+                result.start.imply("meridiem", 1);
+            }
+        } else if (match[TIME_GROUP_2]) {
+            const timeString2 = match[TIME_GROUP_2];
+            const time2 = timeString2[0];
+            if (time2 == "早" || time2 == "上") {
+                result.start.imply("hour", 6);
+            } else if (time2 == "下") {
+                result.start.imply("hour", 15);
+                result.start.imply("meridiem", 1);
+            } else if (time2 == "中") {
+                result.start.imply("hour", 12);
+                result.start.imply("meridiem", 1);
+            } else if (time2 == "夜" || time2 == "晚") {
+                result.start.imply("hour", 22);
+                result.start.imply("meridiem", 1);
+            } else if (time2 == "凌") {
+                result.start.imply("hour", 0);
+            }
+        } else if (match[DAY_GROUP_3]) {
+            const day3 = match[DAY_GROUP_3];
+
+            if (day3 == "明") {
+                // Check not "Tomorrow" on late night
+                if (refMoment.hour() > 1) {
+                    startMoment = startMoment.add(1, "day");
+                }
+            } else if (day3 == "昨") {
+                startMoment = startMoment.add(-1, "day");
+            } else if (day3 == "前") {
+                startMoment = startMoment.add(-2, "day");
+            } else if (day3 == "大前") {
+                startMoment = startMoment.add(-3, "day");
+            } else if (day3 == "后") {
+                startMoment = startMoment.add(2, "day");
+            } else if (day3 == "大后") {
+                startMoment = startMoment.add(3, "day");
+            }
+
+            const timeString3 = match[TIME_GROUP_3];
+            if (timeString3) {
+                const time3 = timeString3[0];
+                if (time3 == "早" || time3 == "上") {
+                    result.start.imply("hour", 6);
+                } else if (time3 == "下") {
+                    result.start.imply("hour", 15);
+                    result.start.imply("meridiem", 1);
+                } else if (time3 == "中") {
+                    result.start.imply("hour", 12);
+                    result.start.imply("meridiem", 1);
+                } else if (time3 == "夜" || time3 == "晚") {
+                    result.start.imply("hour", 22);
+                    result.start.imply("meridiem", 1);
+                } else if (time3 == "凌") {
+                    result.start.imply("hour", 0);
+                }
+            }
+        }
+
+        result.start.assign("day", startMoment.date());
+        result.start.assign("month", startMoment.month() + 1);
+        result.start.assign("year", startMoment.year());
+
+        return result;
+    }
+}

package/src/locales/zh/hans/parsers/ZHHansDateParser.ts

@@ -0,0 +1,75 @@
+import dayjs from "dayjs";
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+import { NUMBER, zhStringToNumber, zhStringToYear } from "../constants";
+
+const YEAR_GROUP = 1;
+const MONTH_GROUP = 2;
+const DAY_GROUP = 3;
+
+export default class ZHHansDateParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        // prettier-ignore
+        return new RegExp(
+            "(" +
+                "\\d{2,4}|" +
+                "[" +
+                Object.keys(NUMBER).join("") +
+                "]{4}|" +
+                "[" +
+                Object.keys(NUMBER).join("") +
+                "]{2}" +
+                ")?" +
+                "(?:\\s*)" +
+                "(?:年)?" +
+                "(?:[\\s|,|，]*)" +
+                "(" +
+                "\\d{1,2}|" +
+                "[" +
+                Object.keys(NUMBER).join("") +
+                "]{1,3}" +
+                ")" +
+                "(?:\\s*)" +
+                "(?:月)" +
+                "(?:\\s*)" +
+                "(" +
+                "\\d{1,2}|" +
+                "[" +
+                Object.keys(NUMBER).join("") +
+                "]{1,3}" +
+                ")?" +
+                "(?:\\s*)" +
+                "(?:日|号)?"
+        );
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const startMoment = dayjs(context.refDate);
+        const result = context.createParsingResult(match.index, match[0]);
+
+        //Month
+        let month = parseInt(match[MONTH_GROUP]);
+        if (isNaN(month)) month = zhStringToNumber(match[MONTH_GROUP]);
+        result.start.assign("month", month);
+
+        //Day
+        if (match[DAY_GROUP]) {
+            let day = parseInt(match[DAY_GROUP]);
+            if (isNaN(day)) day = zhStringToNumber(match[DAY_GROUP]);
+            result.start.assign("day", day);
+        } else {
+            result.start.imply("day", startMoment.date());
+        }
+
+        //Year
+        if (match[YEAR_GROUP]) {
+            let year = parseInt(match[YEAR_GROUP]);
+            if (isNaN(year)) year = zhStringToYear(match[YEAR_GROUP]);
+            result.start.assign("year", year);
+        } else {
+            result.start.imply("year", startMoment.year());
+        }
+
+        return result;
+    }
+}

package/src/locales/zh/hans/parsers/ZHHansDeadlineFormatParser.ts

@@ -0,0 +1,81 @@
+import dayjs from "dayjs";
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+import { NUMBER, zhStringToNumber } from "../constants";
+
+const PATTERN = new RegExp(
+    "(\\d+|[" +
+        Object.keys(NUMBER).join("") +
+        "]+|半|几)(?:\\s*)" +
+        "(?:个)?" +
+        "(秒(?:钟)?|分钟|小时|钟|日|天|星期|礼拜|月|年)" +
+        "(?:(?:之|过)?后|(?:之)?内)",
+    "i"
+);
+
+const NUMBER_GROUP = 1;
+const UNIT_GROUP = 2;
+
+export default class ZHHansDeadlineFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const result = context.createParsingResult(match.index, match[0]);
+
+        let number = parseInt(match[NUMBER_GROUP]);
+        if (isNaN(number)) {
+            number = zhStringToNumber(match[NUMBER_GROUP]);
+        }
+
+        if (isNaN(number)) {
+            const string = match[NUMBER_GROUP];
+            if (string === "几") {
+                number = 3;
+            } else if (string === "半") {
+                number = 0.5;
+            } else {
+                //just in case
+                return null;
+            }
+        }
+
+        let date = dayjs(context.refDate);
+        const unit = match[UNIT_GROUP];
+        const unitAbbr = unit[0];
+
+        if (unitAbbr.match(/[日天星礼月年]/)) {
+            if (unitAbbr == "日" || unitAbbr == "天") {
+                date = date.add(number, "d");
+            } else if (unitAbbr == "星" || unitAbbr == "礼") {
+                date = date.add(number * 7, "d");
+            } else if (unitAbbr == "月") {
+                date = date.add(number, "month");
+            } else if (unitAbbr == "年") {
+                date = date.add(number, "year");
+            }
+
+            result.start.assign("year", date.year());
+            result.start.assign("month", date.month() + 1);
+            result.start.assign("day", date.date());
+            return result;
+        }
+
+        if (unitAbbr == "秒") {
+            date = date.add(number, "second");
+        } else if (unitAbbr == "分") {
+            date = date.add(number, "minute");
+        } else if (unitAbbr == "小" || unitAbbr == "钟") {
+            date = date.add(number, "hour");
+        }
+
+        result.start.imply("year", date.year());
+        result.start.imply("month", date.month() + 1);
+        result.start.imply("day", date.date());
+        result.start.assign("hour", date.hour());
+        result.start.assign("minute", date.minute());
+        result.start.assign("second", date.second());
+        return result;
+    }
+}

package/src/locales/zh/hans/parsers/ZHHansRelationWeekdayParser.ts

@@ -0,0 +1,69 @@
+import dayjs from "dayjs";
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+import { ParsingResult } from "../../../../results";
+import { WEEKDAY_OFFSET } from "../constants";
+
+const PATTERN = new RegExp(
+    "(?<prefix>上|下|这)(?:个)?(?:星期|礼拜|周)(?<weekday>" + Object.keys(WEEKDAY_OFFSET).join("|") + ")"
+);
+
+export default class ZHHansRelationWeekdayParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {
+        const result = context.createParsingResult(match.index, match[0]);
+
+        const dayOfWeek = match.groups.weekday;
+        const offset = WEEKDAY_OFFSET[dayOfWeek];
+        if (offset === undefined) return null;
+
+        let modifier = null;
+        const prefix = match.groups.prefix;
+
+        if (prefix == "上") {
+            modifier = "last";
+        } else if (prefix == "下") {
+            modifier = "next";
+        } else if (prefix == "这") {
+            modifier = "this";
+        }
+
+        let startMoment = dayjs(context.refDate);
+        let startMomentFixed = false;
+        const refOffset = startMoment.day();
+
+        if (modifier == "last" || modifier == "past") {
+            startMoment = startMoment.day(offset - 7);
+            startMomentFixed = true;
+        } else if (modifier == "next") {
+            startMoment = startMoment.day(offset + 7);
+            startMomentFixed = true;
+        } else if (modifier == "this") {
+            startMoment = startMoment.day(offset);
+        } else {
+            if (Math.abs(offset - 7 - refOffset) < Math.abs(offset - refOffset)) {
+                startMoment = startMoment.day(offset - 7);
+            } else if (Math.abs(offset + 7 - refOffset) < Math.abs(offset - refOffset)) {
+                startMoment = startMoment.day(offset + 7);
+            } else {
+                startMoment = startMoment.day(offset);
+            }
+        }
+
+        result.start.assign("weekday", offset);
+        if (startMomentFixed) {
+            result.start.assign("day", startMoment.date());
+            result.start.assign("month", startMoment.month() + 1);
+            result.start.assign("year", startMoment.year());
+        } else {
+            result.start.imply("day", startMoment.date());
+            result.start.imply("month", startMoment.month() + 1);
+            result.start.imply("year", startMoment.year());
+        }
+
+        return result;
+    }
+}