chrono-node 2.3.8 → 2.3.9

package/src/locales/ru/constants.ts

@@ -0,0 +1,344 @@
+import { OpUnitType, QUnitType } from "dayjs";
+import { matchAnyPattern, repeatedTimeunitPattern } from "../../utils/pattern";
+import { findMostLikelyADYear } from "../../calculation/years";
+import { TimeUnits } from "../../utils/timeunits";
+
+export const REGEX_PARTS = {
+    leftBoundary: "([^\\p{L}\\p{N}_]|^)",
+    rightBoundary: "(?=[^\\p{L}\\p{N}_]|$)",
+    flags: "iu",
+};
+
+export const WEEKDAY_DICTIONARY: { [word: string]: number } = {
+    воскресенье: 0,
+    воскресенья: 0,
+    вск: 0,
+    "вск.": 0,
+    понедельник: 1,
+    понедельника: 1,
+    пн: 1,
+    "пн.": 1,
+    вторник: 2,
+    вторника: 2,
+    вт: 2,
+    "вт.": 2,
+    среда: 3,
+    среды: 3,
+    среду: 3,
+    ср: 3,
+    "ср.": 3,
+    четверг: 4,
+    четверга: 4,
+    чт: 4,
+    "чт.": 4,
+    пятница: 5,
+    пятницу: 5,
+    пятницы: 5,
+    пт: 5,
+    "пт.": 5,
+    суббота: 6,
+    субботу: 6,
+    субботы: 6,
+    сб: 6,
+    "сб.": 6,
+};
+
+export const FULL_MONTH_NAME_DICTIONARY: { [word: string]: number } = {
+    январь: 1,
+    января: 1,
+    январе: 1,
+    февряль: 2,
+    февряля: 2,
+    февряле: 2,
+    март: 3,
+    марта: 3,
+    марте: 3,
+    апрель: 4,
+    апреля: 4,
+    апреле: 4,
+    май: 5,
+    мая: 5,
+    мае: 5,
+    июнь: 6,
+    июня: 6,
+    июне: 6,
+    июль: 7,
+    июля: 7,
+    июле: 7,
+    август: 8,
+    августа: 8,
+    августе: 8,
+    сентябрь: 9,
+    сентября: 9,
+    сентябре: 9,
+    октябрь: 10,
+    октября: 10,
+    октябре: 10,
+    ноябрь: 11,
+    ноября: 11,
+    ноябре: 11,
+    декабрь: 12,
+    декабря: 12,
+    декабре: 12,
+};
+
+export const MONTH_DICTIONARY: { [word: string]: number } = {
+    ...FULL_MONTH_NAME_DICTIONARY,
+    янв: 1,
+    "янв.": 1,
+    фев: 2,
+    "фев.": 2,
+    мар: 3,
+    "мар.": 3,
+    апр: 4,
+    "апр.": 4,
+    авг: 8,
+    "авг.": 8,
+    сен: 9,
+    "сен.": 9,
+    окт: 10,
+    "окт.": 10,
+    ноя: 11,
+    "ноя.": 11,
+    дек: 12,
+    "дек.": 12,
+};
+
+export const INTEGER_WORD_DICTIONARY: { [word: string]: number } = {
+    один: 1,
+    одна: 1,
+    одной: 1,
+    одну: 1,
+    две: 2,
+    два: 2,
+    двух: 2,
+    три: 3,
+    трех: 3,
+    трёх: 3,
+    четыре: 4,
+    четырех: 4,
+    четырёх: 4,
+    пять: 5,
+    пяти: 5,
+    шесть: 6,
+    шести: 6,
+    семь: 7,
+    семи: 7,
+    восемь: 8,
+    восемьми: 8,
+    девять: 9,
+    девяти: 9,
+    десять: 10,
+    десяти: 10,
+    одиннадцать: 11,
+    одиннадцати: 11,
+    двенадцать: 12,
+    двенадцати: 12,
+};
+
+export const ORDINAL_WORD_DICTIONARY: { [word: string]: number } = {
+    первое: 1,
+    первого: 1,
+    второе: 2,
+    второго: 2,
+    третье: 3,
+    третьего: 3,
+    четвертое: 4,
+    четвертого: 4,
+    пятое: 5,
+    пятого: 5,
+    шестое: 6,
+    шестого: 6,
+    седьмое: 7,
+    седьмого: 7,
+    восьмое: 8,
+    восьмого: 8,
+    девятое: 9,
+    девятого: 9,
+    десятое: 10,
+    десятого: 10,
+    одиннадцатое: 11,
+    одиннадцатого: 11,
+    двенадцатое: 12,
+    двенадцатого: 12,
+    тринадцатое: 13,
+    тринадцатого: 13,
+    четырнадцатое: 14,
+    четырнадцатого: 14,
+    пятнадцатое: 15,
+    пятнадцатого: 15,
+    шестнадцатое: 16,
+    шестнадцатого: 16,
+    семнадцатое: 17,
+    семнадцатого: 17,
+    восемнадцатое: 18,
+    восемнадцатого: 18,
+    девятнадцатое: 19,
+    девятнадцатого: 19,
+    двадцатое: 20,
+    двадцатого: 20,
+    "двадцать первое": 21,
+    "двадцать первого": 21,
+    "двадцать второе": 22,
+    "двадцать второго": 22,
+    "двадцать третье": 23,
+    "двадцать третьего": 23,
+    "двадцать четвертое": 24,
+    "двадцать четвертого": 24,
+    "двадцать пятое": 25,
+    "двадцать пятого": 25,
+    "двадцать шестое": 26,
+    "двадцать шестого": 26,
+    "двадцать седьмое": 27,
+    "двадцать седьмого": 27,
+    "двадцать восьмое": 28,
+    "двадцать восьмого": 28,
+    "двадцать девятое": 29,
+    "двадцать девятого": 29,
+    "тридцатое": 30,
+    "тридцатого": 30,
+    "тридцать первое": 31,
+    "тридцать первого": 31,
+};
+
+export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } = {
+    сек: "second",
+    секунда: "second",
+    секунд: "second",
+    секунды: "second",
+    секунду: "second",
+    секундочка: "second",
+    секундочки: "second",
+    секундочек: "second",
+    секундочку: "second",
+    мин: "minute",
+    минута: "minute",
+    минут: "minute",
+    минуты: "minute",
+    минуту: "minute",
+    минуток: "minute",
+    минутки: "minute",
+    минутку: "minute",
+    час: "hour",
+    часов: "hour",
+    часа: "hour",
+    часу: "hour",
+    часиков: "hour",
+    часика: "hour",
+    часике: "hour",
+    часик: "hour",
+    день: "d",
+    дня: "d",
+    дней: "d",
+    суток: "d",
+    сутки: "d",
+    неделя: "week",
+    неделе: "week",
+    недели: "week",
+    неделю: "week",
+    недель: "week",
+    недельке: "week",
+    недельки: "week",
+    неделек: "week",
+    месяц: "month",
+    месяце: "month",
+    месяцев: "month",
+    месяца: "month",
+    квартал: "quarter",
+    квартале: "quarter",
+    кварталов: "quarter",
+    год: "year",
+    года: "year",
+    году: "year",
+    годов: "year",
+    лет: "year",
+    годик: "year",
+    годика: "year",
+    годиков: "year",
+};
+
+//-----------------------------
+
+export const NUMBER_PATTERN = `(?:${matchAnyPattern(
+    INTEGER_WORD_DICTIONARY
+)}|[0-9]+|[0-9]+\\.[0-9]+|пол|несколько|пар(?:ы|у)|\\s{0,3})`;
+
+export function parseNumberPattern(match: string): number {
+    const num = match.toLowerCase();
+    if (INTEGER_WORD_DICTIONARY[num] !== undefined) {
+        return INTEGER_WORD_DICTIONARY[num];
+    }
+    if (num.match(/несколько/)) {
+        return 3;
+    } else if (num.match(/пол/)) {
+        return 0.5;
+    } else if (num.match(/пар/)) {
+        return 2;
+    } else if (num === "") {
+        return 1;
+    }
+    return parseFloat(num);
+}
+
+//-----------------------------
+
+export const ORDINAL_NUMBER_PATTERN = `(?:${matchAnyPattern(ORDINAL_WORD_DICTIONARY)}|[0-9]{1,2}(?:го|ого|е|ое)?)`;
+export function parseOrdinalNumberPattern(match: string): number {
+    let num = match.toLowerCase();
+    if (ORDINAL_WORD_DICTIONARY[num] !== undefined) {
+        return ORDINAL_WORD_DICTIONARY[num];
+    }
+
+    num = num.replace(/(?:st|nd|rd|th)$/i, "");
+    return parseInt(num);
+}
+
+//-----------------------------
+
+const year = "(?:\\s+(?:году|года|год|г|г.))?";
+export const YEAR_PATTERN = `(?:[1-9][0-9]{0,3}${year}\\s*(?:н.э.|до н.э.|н. э.|до н. э.)|[1-2][0-9]{3}${year}|[5-9][0-9]${year})`;
+export function parseYear(match: string): number {
+    if (/(год|года|г|г.)/i.test(match)) {
+        match = match.replace(/(год|года|г|г.)/i, "");
+    }
+
+    if (/(до н.э.|до н. э.)/i.test(match)) {
+        //Before Common Era
+        match = match.replace(/(до н.э.|до н. э.)/i, "");
+        return -parseInt(match);
+    }
+
+    if (/(н. э.|н.э.)/i.test(match)) {
+        //Common Era
+        match = match.replace(/(н. э.|н.э.)/i, "");
+        return parseInt(match);
+    }
+
+    const rawYearNumber = parseInt(match);
+    return findMostLikelyADYear(rawYearNumber);
+}
+
+//-----------------------------
+
+const SINGLE_TIME_UNIT_PATTERN = `(${NUMBER_PATTERN})\\s{0,3}(${matchAnyPattern(TIME_UNIT_DICTIONARY)})`;
+const SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, "i");
+
+export const TIME_UNITS_PATTERN = repeatedTimeunitPattern(`(?:(?:около|примерно)\\s{0,3})?`, SINGLE_TIME_UNIT_PATTERN);
+
+export function parseTimeUnits(timeunitText): TimeUnits {
+    const fragments = {};
+    let remainingText = timeunitText;
+    let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
+    while (match) {
+        collectDateTimeFragment(fragments, match);
+        remainingText = remainingText.substring(match[0].length).trim();
+        match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
+    }
+    return fragments;
+}
+
+function collectDateTimeFragment(fragments, match) {
+    const num = parseNumberPattern(match[1]);
+    const unit = TIME_UNIT_DICTIONARY[match[2].toLowerCase()];
+    fragments[unit] = num;
+}

package/src/locales/ru/index.ts

@@ -0,0 +1,84 @@
+/**
+ * Chrono components for Russian support (*parsers*, *refiners*, and *configuration*)
+ *
+ * @module
+ */
+
+import RUTimeUnitWithinFormatParser from "./parsers/RUTimeUnitWithinFormatParser";
+import RUMonthNameLittleEndianParser from "./parsers/RUMonthNameLittleEndianParser";
+import RUMonthNameParser from "./parsers/RUMonthNameParser";
+import RUTimeExpressionParser from "./parsers/RUTimeExpressionParser";
+import RUTimeUnitAgoFormatParser from "./parsers/RUTimeUnitAgoFormatParser";
+import RUMergeDateRangeRefiner from "./refiners/RUMergeDateRangeRefiner";
+import RUMergeDateTimeRefiner from "./refiners/RUMergeDateTimeRefiner";
+
+import { includeCommonConfiguration } from "../../configurations";
+import RUCasualDateParser from "./parsers/RUCasualDateParser";
+import RUCasualTimeParser from "./parsers/RUCasualTimeParser";
+import RUWeekdayParser from "./parsers/RUWeekdayParser";
+import RURelativeDateFormatParser from "./parsers/RURelativeDateFormatParser";
+
+import { ParsedResult, ParsingOption } from "../../index";
+import { Chrono, Configuration } from "../../chrono";
+import SlashDateFormatParser from "../../common/parsers/SlashDateFormatParser";
+import RUTimeUnitCasualRelativeFormatParser from "./parsers/RUTimeUnitCasualRelativeFormatParser";
+
+/**
+ * Chrono object configured for parsing *casual* Russian
+ */
+export const casual = new Chrono(createCasualConfiguration());
+
+/**
+ * Chrono object configured for parsing *strict* Russian
+ */
+export const strict = new Chrono(createConfiguration(true));
+
+/**
+ * A shortcut for ru.casual.parse()
+ */
+export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+    return casual.parse(text, ref, option);
+}
+
+/**
+ * A shortcut for ru.casual.parseDate()
+ */
+export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+    return casual.parseDate(text, ref, option);
+}
+
+/**
+ * Create a default *casual* {@Link Configuration} for Russian chrono.
+ * It calls {@Link createConfiguration} and includes additional parsers.
+ */
+export function createCasualConfiguration(): Configuration {
+    const option = createConfiguration(false);
+    option.parsers.unshift(new RUCasualDateParser());
+    option.parsers.unshift(new RUCasualTimeParser());
+    option.parsers.unshift(new RUMonthNameParser());
+    option.parsers.unshift(new RURelativeDateFormatParser());
+    option.parsers.unshift(new RUTimeUnitCasualRelativeFormatParser());
+    return option;
+}
+
+/**
+ * Create a default {@Link Configuration} for Russian chrono
+ *
+ * @param strictMode If the timeunit mentioning should be strict, not casual
+ */
+export function createConfiguration(strictMode = true): Configuration {
+    return includeCommonConfiguration(
+        {
+            parsers: [
+                new SlashDateFormatParser(true),
+                new RUTimeUnitWithinFormatParser(),
+                new RUMonthNameLittleEndianParser(),
+                new RUWeekdayParser(),
+                new RUTimeExpressionParser(strictMode),
+                new RUTimeUnitAgoFormatParser(),
+            ],
+            refiners: [new RUMergeDateTimeRefiner(), new RUMergeDateRangeRefiner()],
+        },
+        strictMode
+    );
+}

package/src/locales/ru/parsers/RUCasualDateParser.ts

@@ -0,0 +1,44 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents, ParsingResult } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import * as references from "../../../common/casualReferences";
+import { REGEX_PARTS } from "../constants";
+
+const PATTERN = new RegExp(
+    `(?:с|со)?\\s*(сегодня|вчера|завтра|послезавтра|позавчера)${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+
+export default class RUCasualDateParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(context: ParsingContext): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
+        const lowerText = match[1].toLowerCase();
+        const component = context.createParsingComponents();
+
+        switch (lowerText) {
+            case "сегодня":
+                return references.today(context.reference);
+
+            case "вчера":
+                return references.yesterday(context.reference);
+
+            case "завтра":
+                return references.tomorrow(context.reference);
+
+            case "послезавтра":
+                return references.theDayAfter(context.reference, 2);
+
+            case "позавчера":
+                return references.theDayBefore(context.reference, 2);
+        }
+
+        return component;
+    }
+}

package/src/locales/ru/parsers/RUCasualTimeParser.ts

@@ -0,0 +1,56 @@
+import { ParsingContext } from "../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import * as references from "../../../common/casualReferences";
+import { assignSimilarDate } from "../../../utils/dayjs";
+import dayjs from "dayjs";
+import { REGEX_PARTS } from "../constants";
+
+const PATTERN = new RegExp(
+    `(сейчас|прошлым\\s*вечером|прошлой\\s*ночью|следующей\\s*ночью|сегодня\\s*ночью|этой\\s*ночью|ночью|этим утром|утром|утра|в\\s*полдень|вечером|вечера|в\\s*полночь)` +
+        `${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+export default class RUCasualTimeParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern() {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        let targetDate = dayjs(context.refDate);
+        const lowerText = match[0].toLowerCase();
+        const component = context.createParsingComponents();
+
+        if (lowerText === "сейчас") {
+            return references.now(context.reference);
+        }
+        if (lowerText === "вечером" || lowerText === "вечера") {
+            return references.evening(context.reference);
+        }
+        if (lowerText.endsWith("утром") || lowerText.endsWith("утра")) {
+            return references.morning(context.reference);
+        }
+        if (lowerText.match(/в\s*полдень/)) {
+            return references.noon(context.reference);
+        }
+        if (lowerText.match(/прошлой\s*ночью/)) {
+            return references.lastNight(context.reference);
+        }
+        if (lowerText.match(/прошлым\s*вечером/)) {
+            return references.yesterdayEvening(context.reference);
+        }
+        if (lowerText.match(/следующей\s*ночью/)) {
+            const daysToAdd = targetDate.hour() < 22 ? 1 : 2;
+            targetDate = targetDate.add(daysToAdd, "day");
+            assignSimilarDate(component, targetDate);
+            component.imply("hour", 0);
+        }
+        if (lowerText.match(/в\s*полночь/) || lowerText.endsWith("ночью")) {
+            return references.midnight(context.reference);
+        }
+        return component;
+    }
+}

package/src/locales/ru/parsers/RUMonthNameLittleEndianParser.ts

@@ -0,0 +1,72 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+import { findYearClosestToRef } from "../../../calculation/years";
+import { MONTH_DICTIONARY, REGEX_PARTS } from "../constants";
+import { YEAR_PATTERN, parseYear } from "../constants";
+import { ORDINAL_NUMBER_PATTERN, parseOrdinalNumberPattern } from "../constants";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+// prettier-ignore
+const PATTERN = new RegExp(
+    `(?:с)?\\s*(${ORDINAL_NUMBER_PATTERN})` +
+        `(?:` +
+            `\\s{0,3}(?:по|-|–|до)?\\s{0,3}` +
+            `(${ORDINAL_NUMBER_PATTERN})` +
+        `)?` +
+        `(?:-|\\/|\\s{0,3}(?:of)?\\s{0,3})` +
+        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+        `(?:` +
+            `(?:-|\\/|,?\\s{0,3})` +
+            `(${YEAR_PATTERN}(?![^\\s]\\d))` +
+        `)?` +
+    `${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+
+const DATE_GROUP = 1;
+const DATE_TO_GROUP = 2;
+const MONTH_NAME_GROUP = 3;
+const YEAR_GROUP = 4;
+
+export default class RUMonthNameLittleEndianParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    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 = parseOrdinalNumberPattern(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 = parseOrdinalNumberPattern(match[DATE_TO_GROUP]);
+
+            result.end = result.start.clone();
+            result.end.assign("day", endDate);
+        }
+
+        return result;
+    }
+}

package/src/locales/ru/parsers/RUMonthNameParser.ts

@@ -0,0 +1,61 @@
+import { FULL_MONTH_NAME_DICTIONARY, MONTH_DICTIONARY, REGEX_PARTS } 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(
+    `((?:в)\\s*)?` +
+        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+        `\\s*` +
+        `(?:` +
+        `[,-]?\\s*(${YEAR_PATTERN})?` +
+        `)?` +
+        `(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)`,
+    REGEX_PARTS.flags
+);
+
+const MONTH_NAME_GROUP = 2;
+const YEAR_GROUP = 3;
+
+/**
+ * The parser for parsing month name and year.
+ * - Январь, 2012
+ * - Январь 2012
+ * - Январь
+ */
+export default class RUMonthNameParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const monthName = match[MONTH_NAME_GROUP].toLowerCase();
+
+        // skip some unlikely words "янв", "фер", ..
+        if (match[0].length <= 3 && !FULL_MONTH_NAME_DICTIONARY[monthName]) {
+            return null;
+        }
+
+        const result = context.createParsingResult(match.index, 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;
+    }
+}