chrono-node 2.6.3 → 2.6.4

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

@@ -0,0 +1,85 @@
+import { REGEX_PARTS, 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(
+    `(в минулому|у минулому|на минулому|минулого|на наступному|в наступному|у наступному|наступного|на цьому|в цьому|у цьому|цього)\\s*(${matchAnyPattern(
+        TIME_UNIT_DICTIONARY
+    )})(?=\\s*)${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+
+const MODIFIER_WORD_GROUP = 1;
+const RELATIVE_WORD_GROUP = 2;
+
+export default class UKRelativeDateFormatParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    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 == "на наступному" ||
+            modifier == "в наступному" ||
+            modifier == "у наступному" ||
+            modifier == "наступного"
+        ) {
+            const timeUnits = {};
+            timeUnits[timeunit] = 1;
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+
+        if (
+            modifier == "на минулому" ||
+            modifier == "в минулому" ||
+            modifier == "у минулому" ||
+            modifier == "минулого"
+        ) {
+            const timeUnits = {};
+            timeUnits[timeunit] = -1;
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+
+        const components = context.createParsingComponents();
+        let date = dayjs(context.reference.instant);
+
+        // 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());
+        }
+
+        // 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);
+        }
+
+        // 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());
+        }
+
+        return components;
+    }
+}

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

@@ -0,0 +1,64 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { Meridiem } from "../../../types";
+import { AbstractTimeExpressionParser } from "../../../common/parsers/AbstractTimeExpressionParser";
+import { REGEX_PARTS } from "../constants";
+
+export default class UKTimeExpressionParser extends AbstractTimeExpressionParser {
+    constructor(strictMode) {
+        super(strictMode);
+    }
+
+    patternFlags(): string {
+        return REGEX_PARTS.flags;
+    }
+
+    primaryPatternLeftBoundary(): string {
+        return `(^|\\s|T|(?:[^\\p{L}\\p{N}_]))`;
+    }
+
+    followingPhase(): string {
+        return `\\s*(?:\\-|\\–|\\~|\\〜|до|і|по|\\?)\\s*`;
+    }
+
+    primaryPrefix(): string {
+        return `(?:(?:в|у|о|об|з|із|від)\\s*)??`;
+    }
+
+    primarySuffix(): string {
+        return `(?:\\s*(?:ранку|вечора|по обіді|після обіду))?(?!\\/)${REGEX_PARTS.rightBoundary}`;
+    }
+
+    extractPrimaryTimeComponents(context: ParsingContext, match: RegExpMatchArray): null | ParsingComponents {
+        const components = super.extractPrimaryTimeComponents(context, match);
+        if (components) {
+            if (match[0].endsWith("вечора")) {
+                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("по обіді") || match[0].endsWith("після обіду")) {
+                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("ранку")) {
+                components.assign("meridiem", Meridiem.AM);
+                const hour = components.get("hour");
+                if (hour < 12) {
+                    components.assign("hour", components.get("hour"));
+                }
+            }
+        }
+
+        return components;
+    }
+}

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

@@ -0,0 +1,24 @@
+import { ParsingContext } from "../../../chrono";
+import { parseTimeUnits, REGEX_PARTS, 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}тому(?=(?:\\W|$))`, REGEX_PARTS.flags);
+
+export default class UKTimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const timeUnits = parseTimeUnits(match[1]);
+        const outputTimeUnits = reverseTimeUnits(timeUnits);
+
+        return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
+    }
+}

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

@@ -0,0 +1,34 @@
+import { TIME_UNITS_PATTERN, parseTimeUnits, REGEX_PARTS } 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(
+    `(ці|останні|минулі|майбутні|наступні|після|через|\\+|-)\\s*(${TIME_UNITS_PATTERN})${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+
+export default class UKTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const prefix = match[1].toLowerCase();
+        let timeUnits = parseTimeUnits(match[3]);
+        switch (prefix) {
+            case "останні":
+            case "минулі":
+            case "-":
+                timeUnits = reverseTimeUnits(timeUnits);
+                break;
+        }
+
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}

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

@@ -0,0 +1,27 @@
+import { TIME_UNITS_PATTERN, parseTimeUnits, REGEX_PARTS } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN = `(?:(?:приблизно|орієнтовно)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})${REGEX_PARTS.rightBoundary}`;
+const PATTERN_WITH_PREFIX = new RegExp(
+    `(?:протягом|на протязі|протягом|упродовж|впродовж)\\s*${PATTERN}`,
+    REGEX_PARTS.flags
+);
+
+const PATTERN_WITHOUT_PREFIX = new RegExp(PATTERN, "i");
+
+export default class UKTimeUnitWithinFormatParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    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/uk/parsers/UKWeekdayParser.ts

@@ -0,0 +1,59 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+// TODO: ADD REGEX_PARTS below
+import { REGEX_PARTS, 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*)?` +
+        `(?:в\\s*?)?` +
+        `(?:у\\s*?)?` +
+        `(?:(цей|минулого|минулий|попередній|попереднього|наступного|наступний|наступному)\\s*)?` +
+        `(${matchAnyPattern(WEEKDAY_DICTIONARY)})` +
+        `(?:\\s*(?:,|\\)|）))?` +
+        `(?:\\s*(на|у|в)\\s*(цьому|минулому|наступному)\\s*тижні)?` +
+        `${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+
+const PREFIX_GROUP = 1;
+const WEEKDAY_GROUP = 2;
+const POSTFIX_GROUP = 3;
+
+export default class UKWeekdayParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const dayOfWeek = match[WEEKDAY_GROUP].toLocaleLowerCase();
+        const weekday = WEEKDAY_DICTIONARY[dayOfWeek];
+        const prefix = match[PREFIX_GROUP];
+        const postfix = match[POSTFIX_GROUP];
+        let modifierWord = prefix || postfix;
+        modifierWord = modifierWord || "";
+        modifierWord = modifierWord.toLocaleLowerCase();
+
+        let modifier = null;
+        if (
+            modifierWord == "минулого" ||
+            modifierWord == "минулий" ||
+            modifierWord == "попередній" ||
+            modifierWord == "попереднього"
+        ) {
+            modifier = "last";
+        } else if (modifierWord == "наступного" || modifierWord == "наступний") {
+            modifier = "next";
+        } else if (modifierWord == "цей" || modifierWord == "цього" || modifierWord == "цьому") {
+            modifier = "this";
+        }
+
+        return createParsingComponentsAtWeekday(context.reference, weekday, modifier);
+    }
+}

package/src/locales/uk/refiners/UKMergeDateRangeRefiner.ts

@@ -0,0 +1,13 @@
+import AbstractMergeDateRangeRefiner from "../../../common/refiners/AbstractMergeDateRangeRefiner";
+
+/**
+ * Merging before and after results (see. AbstractMergeDateRangeRefiner)
+ * This implementation should provide Russian connecting phases
+ * - [з|із] 06.09.1989 [до|по] 11.12.1996
+ * - [з|із] п'ятниці і до середи
+ */
+export default class UKMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner {
+    patternBetween(): RegExp {
+        return /^\s*(і до|і по|до|по|-)\s*$/i;
+    }
+}

package/src/locales/uk/refiners/UKMergeDateTimeRefiner.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 Ukrainian connecting phases
+ * - 2020-02-13 [в/у/о] 6:00
+ * - Завтра [,] 7:00
+ */
+export default class UKMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner {
+    patternBetween(): RegExp {
+        return new RegExp(`^\\s*(T|в|у|о|,|-)?\\s*$`);
+    }
+}

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

@@ -2,10 +2,11 @@
  * 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 { Chrono, Configuration, Parser, Refiner } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday } from "../../../types";
 import ZHHansCasualDateParser from "./parsers/ZHHansCasualDateParser";
 import ZHHansDateParser from "./parsers/ZHHansDateParser";
 import ZHHansDeadlineFormatParser from "./parsers/ZHHansDeadlineFormatParser";
@@ -15,6 +16,9 @@ import ZHHansWeekdayParser from "./parsers/ZHHansWeekdayParser";
 import ZHHansMergeDateRangeRefiner from "./refiners/ZHHansMergeDateRangeRefiner";
 import ZHHansMergeDateTimeRefiner from "./refiners/ZHHansMergeDateTimeRefiner";
 
+export { Chrono, Parser, Refiner, ParsingResult };
+export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday };
+
 // Shortcuts
 export const hans = new Chrono(createCasualConfiguration());
 

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

@@ -3,10 +3,11 @@
  * TODO: Complete general zh support (current support only zh-Hant)
  */
 
-import { Chrono, Configuration } from "../../../chrono";
 import ExtractTimezoneOffsetRefiner from "../../../common/refiners/ExtractTimezoneOffsetRefiner";
 import { includeCommonConfiguration } from "../../../configurations";
-import { ParsedResult, ParsingOption } from "../../../index";
+import { Chrono, Configuration, Parser, Refiner } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday } from "../../../types";
 import ZHHantCasualDateParser from "./parsers/ZHHantCasualDateParser";
 import ZHHantDateParser from "./parsers/ZHHantDateParser";
 import ZHHantDeadlineFormatParser from "./parsers/ZHHantDeadlineFormatParser";
@@ -16,6 +17,9 @@ import ZHHantWeekdayParser from "./parsers/ZHHantWeekdayParser";
 import ZHHantMergeDateRangeRefiner from "./refiners/ZHHantMergeDateRangeRefiner";
 import ZHHantMergeDateTimeRefiner from "./refiners/ZHHantMergeDateTimeRefiner";
 
+export { Chrono, Parser, Refiner, ParsingResult };
+export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday };
+
 // Shortcuts
 export const hant = new Chrono(createCasualConfiguration());
 

package/src/results.ts

@@ -1,4 +1,4 @@
-import { Component, ParsedComponents, ParsedResult, ParsingReference } from "./index";
+import { Component, ParsedComponents, ParsedResult, ParsingReference } from "./types";
 
 import quarterOfYear from "dayjs/plugin/quarterOfYear";
 import dayjs, { QUnitType } from "dayjs";

package/src/timezone.ts

@@ -1,5 +1,5 @@
 import dayjs from "dayjs";
-import { TimezoneAbbrMap, Weekday, Month } from "./index";
+import { TimezoneAbbrMap, Weekday, Month } from "./types";
 
 export const TIMEZONE_ABBR_MAP: TimezoneAbbrMap = {
     ACDT: 630,

package/src/types.ts

@@ -0,0 +1,150 @@
+import { DebugConsume, DebugHandler } from "./debugging";
+
+export interface ParsingOption {
+    /**
+     * To parse only forward dates (the results should be after the reference date).
+     * This effects date/time implication (e.g. weekday or time mentioning)
+     */
+    forwardDate?: boolean;
+
+    /**
+     * Additional timezone keywords for the parsers to recognize.
+     * Any value provided will override the default handling of that value.
+     */
+    timezones?: TimezoneAbbrMap;
+
+    /**
+     * Internal debug event handler.
+     * @internal
+     */
+    debug?: DebugHandler | DebugConsume;
+}
+
+/**
+ * Some timezone abbreviations are ambiguous in that they refer to different offsets
+ * depending on the time of year — daylight savings time (DST), or non-DST. This interface
+ * allows defining such timezones
+ */
+export interface AmbiguousTimezoneMap {
+    timezoneOffsetDuringDst: number;
+    timezoneOffsetNonDst: number;
+    /**
+     * Return the start date of DST for the given year.
+     * timezone.ts contains helper methods for common such rules.
+     */
+    dstStart: (year: number) => Date;
+    /**
+     * Return the end date of DST for the given year.
+     * timezone.ts contains helper methods for common such rules.
+     */
+    dstEnd: (year: number) => Date;
+}
+
+/**
+ * A map describing how timezone abbreviations should map to time offsets.
+ * Supports both unambigous mappings abbreviation => offset,
+ * and ambiguous mappings, where the offset will depend on whether the
+ * time in question is during daylight savings time or not.
+ */
+export type TimezoneAbbrMap = { [key: string]: number | AmbiguousTimezoneMap };
+
+export interface ParsingReference {
+    /**
+     * Reference date. The instant (JavaScript Date object) when the input is written or mention.
+     * This effect date/time implication (e.g. weekday or time mentioning).
+     * (default = now)
+     */
+    instant?: Date;
+
+    /**
+     * Reference timezone. The timezone where the input is written or mention.
+     * Date/time implication will account the difference between input timezone and the current system timezone.
+     * (default = current timezone)
+     */
+    timezone?: string | number;
+}
+
+/**
+ * Parsed result or final output.
+ * Each result object represents a date/time (or date/time-range) mentioning in the input.
+ */
+export interface ParsedResult {
+    readonly refDate: Date;
+    readonly index: number;
+    readonly text: string;
+
+    readonly start: ParsedComponents;
+    readonly end?: ParsedComponents;
+
+    /**
+     * Create a javascript date object (from the result.start).
+     */
+    date(): Date;
+}
+
+/**
+ * A collection of parsed date/time components (e.g. day, hour, minute, ..., etc).
+ *
+ * Each parsed component has three different levels of certainty.
+ * - *Certain* (or *Known*): The component is directly mentioned and parsed.
+ * - *Implied*: The component is not directly mentioned, but implied by other parsed information.
+ * - *Unknown*: Completely no mention of the component.
+ */
+export interface ParsedComponents {
+    /**
+     * Check the component certainly if the component is *Certain* (or *Known*)
+     */
+    isCertain(component: Component): boolean;
+
+    /**
+     * Get the component value for either *Certain* or *Implied* value.
+     */
+    get(component: Component): number | null;
+
+    /**
+     * @return a javascript date object.
+     */
+    date(): Date;
+}
+
+export type Component =
+    | "year"
+    | "month"
+    | "day"
+    | "weekday"
+    | "hour"
+    | "minute"
+    | "second"
+    | "millisecond"
+    | "meridiem"
+    | "timezoneOffset";
+
+export enum Meridiem {
+    AM = 0,
+    PM = 1,
+}
+
+export enum Weekday {
+    SUNDAY = 0,
+    MONDAY = 1,
+    TUESDAY = 2,
+    WEDNESDAY = 3,
+    THURSDAY = 4,
+    FRIDAY = 5,
+    SATURDAY = 6,
+}
+
+export enum Month {
+    JANUARY = 1,
+    FEBRUARY = 2,
+    MARCH = 3,
+    APRIL = 4,
+    MAY = 5,
+    JUNE = 6,
+    JULY = 7,
+    AUGUST = 8,
+    SEPTEMBER = 9,
+    OCTOBER = 10,
+    NOVEMBER = 11,
+    DECEMBER = 12,
+}

package/src/utils/dayjs.ts

@@ -1,6 +1,6 @@
 import { ParsingComponents } from "../results";
 import dayjs from "dayjs";
-import { Meridiem } from "../index";
+import { Meridiem } from "../types";
 
 export function assignTheNextDay(component: ParsingComponents, targetDayJs: dayjs.Dayjs) {
     targetDayJs = targetDayJs.add(1, "day");

package/test/debugging.test.ts

@@ -0,0 +1,17 @@
+import { BufferedDebugHandler } from "../src/debugging";
+
+test("Test - BufferedDebugHandler", () => {
+    const debugHandler = new BufferedDebugHandler();
+
+    const debugBlockA = jest.fn();
+    debugHandler.debug(() => debugBlockA());
+    expect(debugBlockA).not.toBeCalled();
+
+    const debugBlockB = jest.fn();
+    debugHandler.debug(() => debugBlockB());
+    expect(debugBlockB).not.toBeCalled();
+
+    debugHandler.executeBufferedBlocks();
+    expect(debugBlockA).toBeCalled();
+    expect(debugBlockB).toBeCalled();
+});

package/test/en/en_month_name_little_endian.test.ts

@@ -211,6 +211,18 @@ test("Test - Range expression", () => {
 
         expect(result.end).toBeDate(new Date(2013, 9 - 1, 12, 12));
     });
+
+    testSingleCase(chrono, " 17 August 2013 to 19 August 2013", new Date(2012, 7, 10), (result) => {
+        expect(result.text).toBe("17 August 2013 to 19 August 2013");
+
+        expect(result.start.get("year")).toBe(2013);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(17);
+
+        expect(result.end.get("year")).toBe(2013);
+        expect(result.end.get("month")).toBe(8);
+        expect(result.end.get("day")).toBe(19);
+    });
 });
 
 test("Test - Combined expression", () => {

package/test/en/en_timezone_exp.test.ts

@@ -1,5 +1,5 @@
 import * as chrono from "../../src";
-import { Month, Weekday } from "../../src";
+import { Month, Weekday } from "../../src/types";
 import { getLastWeekdayOfMonth } from "../../src/timezone";
 import { testSingleCase } from "../test_util";