chrono-node 2.3.5 → 2.3.8

package/dist/locales/zh/hans/parsers/ZHHansCasualDateParser.d.ts

@@ -0,0 +1,7 @@
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+import { ParsingComponents, ParsingResult } from "../../../../results";
+export default class ZHHansCasualDateParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(context: ParsingContext): RegExp;
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult;
+}

package/dist/locales/zh/hans/parsers/ZHHansCasualDateParser.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dayjs_1 = __importDefault(require("dayjs"));
+const AbstractParserWithWordBoundary_1 = require("../../../../common/parsers/AbstractParserWithWordBoundary");
+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;
+class ZHHansCasualDateParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {
+    innerPattern(context) {
+        return new RegExp("(现在|立(?:刻|即)|即刻)|" +
+            "(今|明|前|大前|后|大后|昨)(早|晚)|" +
+            "(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨))|" +
+            "(今|明|前|大前|后|大后|昨)(?:日|天)" +
+            "(?:[\\s|,|，]*)" +
+            "(?:(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?", "i");
+    }
+    innerExtract(context, match) {
+        const index = match.index;
+        const result = context.createParsingResult(index, match[0]);
+        const refMoment = dayjs_1.default(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 == "明") {
+                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 == "明") {
+                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;
+    }
+}
+exports.default = ZHHansCasualDateParser;

package/dist/locales/zh/hans/parsers/ZHHansDateParser.d.ts

@@ -0,0 +1,6 @@
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+export default class ZHHansDateParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp;
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): import("../../../../results").ParsingResult;
+}

package/dist/locales/zh/hans/parsers/ZHHansDateParser.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dayjs_1 = __importDefault(require("dayjs"));
+const AbstractParserWithWordBoundary_1 = require("../../../../common/parsers/AbstractParserWithWordBoundary");
+const constants_1 = require("../constants");
+const YEAR_GROUP = 1;
+const MONTH_GROUP = 2;
+const DAY_GROUP = 3;
+class ZHHansDateParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return new RegExp("(" +
+            "\\d{2,4}|" +
+            "[" +
+            Object.keys(constants_1.NUMBER).join("") +
+            "]{4}|" +
+            "[" +
+            Object.keys(constants_1.NUMBER).join("") +
+            "]{2}" +
+            ")?" +
+            "(?:\\s*)" +
+            "(?:年)?" +
+            "(?:[\\s|,|，]*)" +
+            "(" +
+            "\\d{1,2}|" +
+            "[" +
+            Object.keys(constants_1.NUMBER).join("") +
+            "]{1,3}" +
+            ")" +
+            "(?:\\s*)" +
+            "(?:月)" +
+            "(?:\\s*)" +
+            "(" +
+            "\\d{1,2}|" +
+            "[" +
+            Object.keys(constants_1.NUMBER).join("") +
+            "]{1,3}" +
+            ")?" +
+            "(?:\\s*)" +
+            "(?:日|号)?");
+    }
+    innerExtract(context, match) {
+        const startMoment = dayjs_1.default(context.refDate);
+        const result = context.createParsingResult(match.index, match[0]);
+        let month = parseInt(match[MONTH_GROUP]);
+        if (isNaN(month))
+            month = constants_1.zhStringToNumber(match[MONTH_GROUP]);
+        result.start.assign("month", month);
+        if (match[DAY_GROUP]) {
+            let day = parseInt(match[DAY_GROUP]);
+            if (isNaN(day))
+                day = constants_1.zhStringToNumber(match[DAY_GROUP]);
+            result.start.assign("day", day);
+        }
+        else {
+            result.start.imply("day", startMoment.date());
+        }
+        if (match[YEAR_GROUP]) {
+            let year = parseInt(match[YEAR_GROUP]);
+            if (isNaN(year))
+                year = constants_1.zhStringToYear(match[YEAR_GROUP]);
+            result.start.assign("year", year);
+        }
+        else {
+            result.start.imply("year", startMoment.year());
+        }
+        return result;
+    }
+}
+exports.default = ZHHansDateParser;

package/dist/locales/zh/hans/parsers/ZHHansDeadlineFormatParser.d.ts

@@ -0,0 +1,6 @@
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+export default class ZHHansDeadlineFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp;
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): import("../../../../results").ParsingResult;
+}

package/dist/locales/zh/hans/parsers/ZHHansDeadlineFormatParser.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dayjs_1 = __importDefault(require("dayjs"));
+const AbstractParserWithWordBoundary_1 = require("../../../../common/parsers/AbstractParserWithWordBoundary");
+const constants_1 = require("../constants");
+const PATTERN = new RegExp("(\\d+|[" +
+    Object.keys(constants_1.NUMBER).join("") +
+    "]+|半|几)(?:\\s*)" +
+    "(?:个)?" +
+    "(秒(?:钟)?|分钟|小时|钟|日|天|星期|礼拜|月|年)" +
+    "(?:(?:之|过)?后|(?:之)?内)", "i");
+const NUMBER_GROUP = 1;
+const UNIT_GROUP = 2;
+class ZHHansDeadlineFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return PATTERN;
+    }
+    innerExtract(context, match) {
+        const result = context.createParsingResult(match.index, match[0]);
+        let number = parseInt(match[NUMBER_GROUP]);
+        if (isNaN(number)) {
+            number = constants_1.zhStringToNumber(match[NUMBER_GROUP]);
+        }
+        if (isNaN(number)) {
+            const string = match[NUMBER_GROUP];
+            if (string === "几") {
+                number = 3;
+            }
+            else if (string === "半") {
+                number = 0.5;
+            }
+            else {
+                return null;
+            }
+        }
+        let date = dayjs_1.default(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;
+    }
+}
+exports.default = ZHHansDeadlineFormatParser;

package/dist/locales/zh/hans/parsers/ZHHansRelationWeekdayParser.d.ts

@@ -0,0 +1,7 @@
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+import { ParsingResult } from "../../../../results";
+export default class ZHHansRelationWeekdayParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp;
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingResult;
+}

package/dist/locales/zh/hans/parsers/ZHHansRelationWeekdayParser.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dayjs_1 = __importDefault(require("dayjs"));
+const AbstractParserWithWordBoundary_1 = require("../../../../common/parsers/AbstractParserWithWordBoundary");
+const constants_1 = require("../constants");
+const PATTERN = new RegExp("(?<prefix>上|下|这)(?:个)?(?:星期|礼拜|周)(?<weekday>" + Object.keys(constants_1.WEEKDAY_OFFSET).join("|") + ")");
+class ZHHansRelationWeekdayParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return PATTERN;
+    }
+    innerExtract(context, match) {
+        const result = context.createParsingResult(match.index, match[0]);
+        const dayOfWeek = match.groups.weekday;
+        const offset = constants_1.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_1.default(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;
+    }
+}
+exports.default = ZHHansRelationWeekdayParser;

package/dist/locales/zh/hans/parsers/ZHHansTimeExpressionParser.d.ts

@@ -0,0 +1,6 @@
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+export default class ZHHansTimeExpressionParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp;
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): import("../../../../results").ParsingResult;
+}