chrono-node 2.8.3 → 2.8.5

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

@@ -0,0 +1,42 @@
+import { TIME_UNITS_PATTERN, parseDuration, TIME_UNITS_NO_ABBR_PATTERN } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { reverseDuration } from "../../../calculation/duration";
+
+const PATTERN = new RegExp(
+    `(denna|den här|förra|passerade|nästa|kommande|efter|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`,
+    "i"
+);
+const PATTERN_NO_ABBR = new RegExp(
+    `(denna|den här|förra|passerade|nästa|kommande|efter|\\+|-)\\s*(${TIME_UNITS_NO_ABBR_PATTERN})(?=\\W|$)`,
+    "i"
+);
+
+export default class SVTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private allowAbbreviations: boolean = true) {
+        super();
+    }
+
+    innerPattern(): RegExp {
+        return this.allowAbbreviations ? PATTERN : PATTERN_NO_ABBR;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const prefix = match[1].toLowerCase();
+        let duration = parseDuration(match[2]);
+        if (!duration) {
+            return null;
+        }
+
+        switch (prefix) {
+            case "förra":
+            case "passerade":
+            case "-":
+                duration = reverseDuration(duration);
+                break;
+        }
+
+        return ParsingComponents.createRelativeFromReference(context.reference, duration);
+    }
+}

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/locales/uk/constants.ts

@@ -1,7 +1,7 @@
-import { OpUnitType, QUnitType } from "dayjs";
 import { matchAnyPattern, repeatedTimeunitPattern } from "../../utils/pattern";
 import { findMostLikelyADYear } from "../../calculation/years";
-import { TimeUnits } from "../../utils/timeunits";
+import { Duration } from "../../calculation/duration";
+import { Timeunit } from "../../types";
 
 export const REGEX_PARTS = {
     leftBoundary: "([^\\p{L}\\p{N}_]|^)",
@@ -211,7 +211,7 @@ export const ORDINAL_WORD_DICTIONARY: { [word: string]: number } = {
     "тридцять першого": 31,
 };
 
-export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } = {
+export const TIME_UNIT_DICTIONARY: { [word: string]: Timeunit } = {
     сек: "second",
     секунда: "second",
     секунд: "second",
@@ -240,12 +240,12 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } =
     годинок: "hour",
     годинки: "hour",
     годинку: "hour",
-    день: "d",
-    дня: "d",
-    днів: "d",
-    дні: "d",
-    доба: "d",
-    добу: "d",
+    день: "day",
+    дня: "day",
+    днів: "day",
+    дні: "day",
+    доба: "day",
+    добу: "day",
     тиждень: "week",
     тижню: "week",
     тижня: "week",
@@ -330,7 +330,7 @@ export const TIME_UNITS_PATTERN = repeatedTimeunitPattern(
     SINGLE_TIME_UNIT_PATTERN
 );
 
-export function parseTimeUnits(timeunitText): TimeUnits {
+export function parseDuration(timeunitText): Duration {
     const fragments = {};
     let remainingText = timeunitText;
     let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
@@ -339,7 +339,7 @@ export function parseTimeUnits(timeunitText): TimeUnits {
         remainingText = remainingText.substring(match[0].length).trim();
         match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
     }
-    return fragments;
+    return fragments as Duration;
 }
 
 function collectDateTimeFragment(fragments, match) {

package/src/locales/uk/parsers/UKCasualTimeParser.ts

@@ -1,7 +1,6 @@
 import { ParsingContext } from "../../../chrono";
 import * as references from "../../../common/casualReferences";
-import { assignSimilarDate } from "../../../utils/dayjs";
-import dayjs from "dayjs";
+import { assignSimilarDate } from "../../../utils/dates";
 import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
 export default class UKCasualTimeParser extends AbstractParserWithLeftRightBoundaryChecking {
@@ -10,7 +9,7 @@ export default class UKCasualTimeParser extends AbstractParserWithLeftRightBound
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        let targetDate = dayjs(context.reference.instant);
+        let targetDate = context.refDate;
         const lowerText = match[0].toLowerCase();
         const component = context.createParsingComponents();
 
@@ -33,9 +32,10 @@ export default class UKCasualTimeParser extends AbstractParserWithLeftRightBound
             return references.yesterdayEvening(context.reference);
         }
         if (lowerText.match(/наступної\s*ночі/)) {
-            const daysToAdd = targetDate.hour() < 22 ? 1 : 2;
-            targetDate = targetDate.add(daysToAdd, "day");
-            assignSimilarDate(component, targetDate);
+            const daysToAdd = targetDate.getHours() < 22 ? 1 : 2;
+            const nextDay = new Date(targetDate.getTime());
+            nextDay.setDate(nextDay.getDate() + daysToAdd);
+            assignSimilarDate(component, nextDay);
             component.imply("hour", 1);
         }
         if (lowerText.match(/цієї\s*ночі/)) {

package/src/locales/uk/parsers/UKRelativeDateFormatParser.ts

@@ -1,7 +1,6 @@
 import { TIME_UNIT_DICTIONARY } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
-import dayjs from "dayjs";
 import { matchAnyPattern } from "../../../utils/pattern";
 import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
@@ -44,32 +43,31 @@ export default class UKRelativeDateFormatParser extends AbstractParserWithLeftRi
         }
 
         const components = context.createParsingComponents();
-        let date = dayjs(context.reference.instant);
+        let date = new Date(context.reference.instant.getTime());
 
         // This week
         if (timeunit.match(/week/i)) {
-            date = date.add(-date.get("d"), "d");
-            components.imply("day", date.date());
-            components.imply("month", date.month() + 1);
-            components.imply("year", date.year());
+            date.setDate(date.getDate() - date.getDay());
+            components.imply("day", date.getDate());
+            components.imply("month", date.getMonth() + 1);
+            components.imply("year", date.getFullYear());
         }
 
         // This month
         else if (timeunit.match(/month/i)) {
-            date = date.add(-date.date() + 1, "d");
-            components.imply("day", date.date());
-            components.assign("year", date.year());
-            components.assign("month", date.month() + 1);
+            date.setDate(1);
+            components.imply("day", date.getDate());
+            components.assign("year", date.getFullYear());
+            components.assign("month", date.getMonth() + 1);
         }
 
         // This year
         else if (timeunit.match(/year/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());
+            date.setDate(1);
+            date.setMonth(0);
+            components.imply("day", date.getDate());
+            components.imply("month", date.getMonth() + 1);
+            components.assign("year", date.getFullYear());
         }
 
         return components;

package/src/locales/uk/parsers/UKTimeUnitAgoFormatParser.ts

@@ -1,8 +1,8 @@
 import { ParsingContext } from "../../../chrono";
-import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
+import { parseDuration, TIME_UNITS_PATTERN } from "../constants";
 import { ParsingComponents } from "../../../results";
-import { reverseTimeUnits } from "../../../utils/timeunits";
 import { AbstractParserWithLeftBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
+import { reverseDuration } from "../../../calculation/duration";
 
 export default class UKTimeUnitAgoFormatParser extends AbstractParserWithLeftBoundaryChecking {
     innerPatternString(context: ParsingContext): string {
@@ -10,8 +10,8 @@ export default class UKTimeUnitAgoFormatParser extends AbstractParserWithLeftBou
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        const timeUnits = parseTimeUnits(match[1]);
-        const outputTimeUnits = reverseTimeUnits(timeUnits);
+        const timeUnits = parseDuration(match[1]);
+        const outputTimeUnits = reverseDuration(timeUnits);
 
         return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
     }

package/src/locales/uk/parsers/UKTimeUnitCasualRelativeFormatParser.ts

@@ -1,8 +1,8 @@
-import { TIME_UNITS_PATTERN, parseTimeUnits, REGEX_PARTS } from "../constants";
+import { TIME_UNITS_PATTERN, parseDuration, REGEX_PARTS } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
-import { reverseTimeUnits } from "../../../utils/timeunits";
 import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
+import { reverseDuration } from "../../../calculation/duration";
 
 export default class UKTimeUnitCasualRelativeFormatParser extends AbstractParserWithLeftRightBoundaryChecking {
     innerPatternString(context: ParsingContext): string {
@@ -11,12 +11,12 @@ export default class UKTimeUnitCasualRelativeFormatParser extends AbstractParser
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
         const prefix = match[1].toLowerCase();
-        let timeUnits = parseTimeUnits(match[3]);
+        let timeUnits = parseDuration(match[3]);
         switch (prefix) {
             case "останні":
             case "минулі":
             case "-":
-                timeUnits = reverseTimeUnits(timeUnits);
+                timeUnits = reverseDuration(timeUnits);
                 break;
         }
 

package/src/locales/uk/parsers/UKTimeUnitWithinFormatParser.ts

@@ -1,4 +1,4 @@
-import { TIME_UNITS_PATTERN, parseTimeUnits, REGEX_PARTS } from "../constants";
+import { TIME_UNITS_PATTERN, parseDuration, REGEX_PARTS } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
@@ -17,7 +17,7 @@ export default class UKTimeUnitWithinFormatParser extends AbstractParserWithWord
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
-        const timeUnits = parseTimeUnits(match[1]);
+        const timeUnits = parseDuration(match[1]);
         return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

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

@@ -1,4 +1,3 @@
-import dayjs from "dayjs";
 import { ParsingContext } from "../../../../chrono";
 import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
 import { ParsingComponents, ParsingResult } from "../../../../results";
@@ -27,33 +26,33 @@ export default class ZHHansCasualDateParser extends AbstractParserWithWordBounda
         const index = match.index;
         const result = context.createParsingResult(index, match[0]);
 
-        const refMoment = dayjs(context.refDate);
-        let startMoment = refMoment;
+        const refDate = context.refDate;
+        let date = new Date(refDate.getTime());
 
         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());
+            result.start.imply("hour", refDate.getHours());
+            result.start.imply("minute", refDate.getMinutes());
+            result.start.imply("second", refDate.getSeconds());
+            result.start.imply("millisecond", refDate.getMilliseconds());
         } 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");
+                if (refDate.getHours() > 1) {
+                    date.setDate(date.getDate() + 1);
                 }
             } else if (day1 == "昨") {
-                startMoment = startMoment.add(-1, "day");
+                date.setDate(date.getDate() - 1);
             } else if (day1 == "前") {
-                startMoment = startMoment.add(-2, "day");
+                date.setDate(date.getDate() - 2);
             } else if (day1 == "大前") {
-                startMoment = startMoment.add(-3, "day");
+                date.setDate(date.getDate() - 3);
             } else if (day1 == "后") {
-                startMoment = startMoment.add(2, "day");
+                date.setDate(date.getDate() + 2);
             } else if (day1 == "大后") {
-                startMoment = startMoment.add(3, "day");
+                date.setDate(date.getDate() + 3);
             }
 
             if (time1 == "早") {
@@ -84,19 +83,19 @@ export default class ZHHansCasualDateParser extends AbstractParserWithWordBounda
 
             if (day3 == "明") {
                 // Check not "Tomorrow" on late night
-                if (refMoment.hour() > 1) {
-                    startMoment = startMoment.add(1, "day");
+                if (refDate.getHours() > 1) {
+                    date.setDate(date.getDate() + 1);
                 }
             } else if (day3 == "昨") {
-                startMoment = startMoment.add(-1, "day");
+                date.setDate(date.getDate() - 1);
             } else if (day3 == "前") {
-                startMoment = startMoment.add(-2, "day");
+                date.setDate(date.getDate() - 2);
             } else if (day3 == "大前") {
-                startMoment = startMoment.add(-3, "day");
+                date.setDate(date.getDate() - 3);
             } else if (day3 == "后") {
-                startMoment = startMoment.add(2, "day");
+                date.setDate(date.getDate() + 2);
             } else if (day3 == "大后") {
-                startMoment = startMoment.add(3, "day");
+                date.setDate(date.getDate() + 3);
             }
 
             const timeString3 = match[TIME_GROUP_3];
@@ -119,9 +118,9 @@ export default class ZHHansCasualDateParser extends AbstractParserWithWordBounda
             }
         }
 
-        result.start.assign("day", startMoment.date());
-        result.start.assign("month", startMoment.month() + 1);
-        result.start.assign("year", startMoment.year());
+        result.start.assign("day", date.getDate());
+        result.start.assign("month", date.getMonth() + 1);
+        result.start.assign("year", date.getFullYear());
 
         return result;
     }

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

@@ -1,4 +1,3 @@
-import dayjs from "dayjs";
 import { ParsingContext } from "../../../../chrono";
 import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
 import { NUMBER, zhStringToNumber, zhStringToYear } from "../constants";
@@ -44,7 +43,6 @@ export default class ZHHansDateParser extends AbstractParserWithWordBoundaryChec
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        const startMoment = dayjs(context.refDate);
         const result = context.createParsingResult(match.index, match[0]);
 
         //Month
@@ -58,7 +56,7 @@ export default class ZHHansDateParser extends AbstractParserWithWordBoundaryChec
             if (isNaN(day)) day = zhStringToNumber(match[DAY_GROUP]);
             result.start.assign("day", day);
         } else {
-            result.start.imply("day", startMoment.date());
+            result.start.imply("day", context.refDate.getDate());
         }
 
         //Year
@@ -67,7 +65,7 @@ export default class ZHHansDateParser extends AbstractParserWithWordBoundaryChec
             if (isNaN(year)) year = zhStringToYear(match[YEAR_GROUP]);
             result.start.assign("year", year);
         } else {
-            result.start.imply("year", startMoment.year());
+            result.start.imply("year", context.refDate.getFullYear());
         }
 
         return result;

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

@@ -1,6 +1,6 @@
-import dayjs from "dayjs";
 import { ParsingContext } from "../../../../chrono";
 import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+import { addDuration, Duration } from "../../../../calculation/duration";
 import { NUMBER, zhStringToNumber } from "../constants";
 
 const PATTERN = new RegExp(
@@ -41,41 +41,43 @@ export default class ZHHansDeadlineFormatParser extends AbstractParserWithWordBo
             }
         }
 
-        let date = dayjs(context.refDate);
+        const duration: Duration = {};
         const unit = match[UNIT_GROUP];
         const unitAbbr = unit[0];
 
         if (unitAbbr.match(/[日天星礼月年]/)) {
             if (unitAbbr == "日" || unitAbbr == "天") {
-                date = date.add(number, "d");
+                duration.day = number;
             } else if (unitAbbr == "星" || unitAbbr == "礼") {
-                date = date.add(number * 7, "d");
+                duration.week = number;
             } else if (unitAbbr == "月") {
-                date = date.add(number, "month");
+                duration.month = number;
             } else if (unitAbbr == "年") {
-                date = date.add(number, "year");
+                duration.year = number;
             }
 
-            result.start.assign("year", date.year());
-            result.start.assign("month", date.month() + 1);
-            result.start.assign("day", date.date());
+            const date = addDuration(context.refDate, duration);
+            result.start.assign("year", date.getFullYear());
+            result.start.assign("month", date.getMonth() + 1);
+            result.start.assign("day", date.getDate());
             return result;
         }
 
         if (unitAbbr == "秒") {
-            date = date.add(number, "second");
+            duration.second = number;
         } else if (unitAbbr == "分") {
-            date = date.add(number, "minute");
+            duration.minute = number;
         } else if (unitAbbr == "小" || unitAbbr == "钟") {
-            date = date.add(number, "hour");
+            duration.hour = number;
         }
 
-        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());
+        const date = addDuration(context.refDate, duration);
+        result.start.imply("year", date.getFullYear());
+        result.start.imply("month", date.getMonth() + 1);
+        result.start.imply("day", date.getDate());
+        result.start.assign("hour", date.getHours());
+        result.start.assign("minute", date.getMinutes());
+        result.start.assign("second", date.getSeconds());
         return result;
     }
 }

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

@@ -1,4 +1,3 @@
-import dayjs from "dayjs";
 import { ParsingContext } from "../../../../chrono";
 import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
 import { ParsingResult } from "../../../../results";
@@ -31,37 +30,38 @@ export default class ZHHansRelationWeekdayParser extends AbstractParserWithWordB
             modifier = "this";
         }
 
-        let startMoment = dayjs(context.refDate);
+        const date = new Date(context.refDate.getTime());
         let startMomentFixed = false;
-        const refOffset = startMoment.day();
+        const refOffset = date.getDay();
 
         if (modifier == "last" || modifier == "past") {
-            startMoment = startMoment.day(offset - 7);
+            date.setDate(date.getDate() + (offset - 7 - refOffset));
             startMomentFixed = true;
         } else if (modifier == "next") {
-            startMoment = startMoment.day(offset + 7);
+            date.setDate(date.getDate() + (offset + 7 - refOffset));
             startMomentFixed = true;
         } else if (modifier == "this") {
-            startMoment = startMoment.day(offset);
+            date.setDate(date.getDate() + (offset - refOffset));
         } 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);
+            let diff = offset - refOffset;
+            if (Math.abs(diff - 7) < Math.abs(diff)) {
+                diff -= 7;
             }
+            if (Math.abs(diff + 7) < Math.abs(diff)) {
+                diff += 7;
+            }
+            date.setDate(date.getDate() + diff);
         }
 
         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());
+            result.start.assign("day", date.getDate());
+            result.start.assign("month", date.getMonth() + 1);
+            result.start.assign("year", date.getFullYear());
         } else {
-            result.start.imply("day", startMoment.date());
-            result.start.imply("month", startMoment.month() + 1);
-            result.start.imply("year", startMoment.year());
+            result.start.imply("day", date.getDate());
+            result.start.imply("month", date.getMonth() + 1);
+            result.start.imply("year", date.getFullYear());
         }
 
         return result;