chrono-node 2.9.2 → 2.10.1

package/test/system_timezone.test.ts

@@ -1,284 +0,0 @@
-import * as chrono from "../src/";
-import { testSingleCase } from "./test_util";
-
-test("Test - Using reference with timezone", function () {
-    testSingleCase(
-        chrono,
-        "Friday at 4pm",
-        {
-            instant: new Date("Wed Jun 09 2021 07:00:00 GMT-0500 (CDT)"),
-            timezone: "CDT",
-        },
-        (result) => {
-            expect(result).toBeDate(new Date("Fri Jun 11 2021 16:00:00 GMT-0500 (CDT)"));
-            expect(result).toBeDate(new Date("Sat Jun 12 2021 06:00:00 GMT+0900 (JST)"));
-        }
-    );
-    testSingleCase(
-        chrono,
-        "1am",
-        {
-            instant: new Date("Wed May 26 2022 01:57:00 GMT-0500 (CDT)"),
-            timezone: "CDT",
-        },
-        (result) => {
-            expect(result.start.get("year")).toBe(2022);
-            expect(result.start.get("month")).toBe(5);
-            expect(result.start.get("day")).toBe(26);
-            expect(result.start.get("hour")).toBe(1);
-        }
-    );
-});
-
-test("Test - Using reference with missing/default timezone", function () {
-    const INPUT = "Friday at 4pm";
-    const REF_INSTANT = new Date(2021, 6 - 1, 9, 7, 0, 0);
-    const EXPECTED_INSTANT = new Date(2021, 6 - 1, 11, 16, 0, 0);
-
-    testSingleCase(chrono, INPUT, REF_INSTANT, (result) => {
-        expect(result).toBeDate(EXPECTED_INSTANT);
-    });
-
-    testSingleCase(chrono, INPUT, { instant: REF_INSTANT }, (result) => {
-        expect(result).toBeDate(EXPECTED_INSTANT);
-    });
-
-    testSingleCase(chrono, INPUT, { instant: REF_INSTANT, timezone: null }, (result) => {
-        expect(result).toBeDate(EXPECTED_INSTANT);
-    });
-
-    testSingleCase(chrono, INPUT, { instant: REF_INSTANT, timezone: "" }, (result) => {
-        expect(result).toBeDate(EXPECTED_INSTANT);
-    });
-});
-
-test("Test - Using reference instance with different timezone", function () {
-    // Sun Jun 06 2021 19:00:00 GMT+0900 (JST)
-    // Sun Jun 06 2021 11:00:00 GMT+0100 (BST)
-    const refInstant = new Date("Sun Jun 06 2021 19:00:00 GMT+0900 (JST)");
-
-    // "At 4pm tomorrow" at "Sun Jun 06 2021 11:00:00 (BST)"
-    testSingleCase(chrono, "At 4pm tomorrow", { instant: refInstant, timezone: "BST" }, (result) => {
-        const expectedInstant = new Date("Mon Jun 07 2021 16:00:00 GMT+0100 (BST)");
-        expect(result).toBeDate(expectedInstant);
-    });
-
-    // "At 4pm tomorrow" at "Sun Jun 06 2021 19:00:00 (JST)"
-    testSingleCase(chrono, "At 4pm tomorrow", { instant: refInstant, timezone: "JST" }, (result) => {
-        const expectedInstant = new Date("Mon Jun 07 2021 16:00:00 GMT+0900 (JST)");
-        expect(result).toBeDate(expectedInstant);
-    });
-});
-
-test("Test - Using reference instance with custom timezones", function () {
-    // Sun Jun 06 2021 19:00:00 GMT+0900 (JST)
-    // Sun Jun 06 2021 11:00:00 GMT+0100 (BST)
-    const refInstant = new Date("Sun Jun 06 2021 19:00:00 GMT+0900 (JST)");
-
-    // Fictional timezones
-    const timezones = {
-        "JJJ": 540, // JJJ => GMT+0900 JST
-        "BBB": 60, // BBB => GMT+0100 BST
-    };
-
-    // "At 4pm tomorrow" at "Sun Jun 06 2021 11:00:00 (BBB = BST)"
-    testSingleCase(
-        chrono,
-        "At 4pm tomorrow",
-        { instant: refInstant, timezone: "BBB" },
-        { timezones: timezones },
-        (result) => {
-            const expectedInstant = new Date("Mon Jun 07 2021 16:00:00 GMT+0100 (BST)");
-            expect(result).toBeDate(expectedInstant);
-        }
-    );
-
-    // "At 4pm tomorrow" at "Sun Jun 06 2021 19:00:00 (JJJ = JST)"
-    testSingleCase(
-        chrono,
-        "At 4pm tomorrow",
-        { instant: refInstant, timezone: "JJJ" },
-        { timezones: timezones },
-        (result) => {
-            const expectedInstant = new Date("Mon Jun 07 2021 16:00:00 GMT+0900 (JST)");
-            expect(result).toBeDate(expectedInstant);
-        }
-    );
-});
-
-test("Test - Timezone difference on reference date #2", function () {
-    const refInstant = new Date("2024-02-21T10:00:00+1300");
-
-    testSingleCase(chrono, "yesterday 18:00", { instant: refInstant, timezone: 780 }, (result) => {
-        // expect(result.start.get("year")).toBe(2024);
-        // expect(result.start.get("month")).toBe(2);
-        // expect(result.start.get("day")).toBe(20);
-        // expect(result).toBeDate(new Date("2024-02-20T18:00:00+1300"));
-    });
-});
-
-test("Test - Timezone difference on written date", function () {
-    // Sun Jun 06 2021 19:00:00 GMT+0900 (JST)
-    // Sun Jun 06 2021 11:00:00 GMT+0100 (BST)
-    const refInstant = new Date("Sun Jun 06 2021 19:00:00 GMT+0900 (JST)");
-
-    testSingleCase(chrono, "Sun Jun 06 2021 19:00:00", { timezone: "JST" }, (result) => {
-        expect(result).toBeDate(refInstant);
-    });
-
-    testSingleCase(chrono, "Sun Jun 06 2021 11:00:00", { timezone: "BST" }, (result) => {
-        expect(result).toBeDate(refInstant);
-    });
-
-    testSingleCase(chrono, "Sun Jun 06 2021 11:00:00", { timezone: 60 }, (result) => {
-        expect(result).toBeDate(refInstant);
-    });
-});
-
-test("Test - Precise [now] mentioned", function () {
-    const refDate = new Date("Sat Mar 13 2021 14:22:14 GMT+0900 (Japan Standard Time)");
-
-    testSingleCase(chrono, "now", refDate, (result) => {
-        expect(result).toBeDate(refDate);
-    });
-
-    testSingleCase(chrono, "now", { instant: refDate }, (result) => {
-        expect(result).toBeDate(refDate);
-    });
-
-    testSingleCase(chrono, "now", { instant: refDate, timezone: 540 }, (result) => {
-        expect(result).toBeDate(refDate);
-    });
-
-    testSingleCase(chrono, "now", { instant: refDate, timezone: "JST" }, (result) => {
-        expect(result).toBeDate(refDate);
-    });
-
-    testSingleCase(chrono, "now", { instant: refDate, timezone: -300 }, (result) => {
-        expect(result).toBeDate(refDate);
-    });
-});
-
-test("Test - Precise date/time mentioned", function () {
-    const text = "Sat Mar 13 2021 14:22:14 GMT+0900";
-    const refDate = new Date();
-
-    testSingleCase(chrono, text, refDate, (result, text) => {
-        expect(result).toBeDate(new Date(text));
-    });
-
-    testSingleCase(chrono, text, { instant: refDate }, (result) => {
-        expect(result).toBeDate(new Date(text));
-    });
-
-    testSingleCase(chrono, text, { instant: refDate, timezone: 540 }, (result) => {
-        expect(result).toBeDate(new Date(text));
-    });
-
-    testSingleCase(chrono, text, { instant: refDate, timezone: "JST" }, (result) => {
-        expect(result).toBeDate(new Date(text));
-    });
-
-    testSingleCase(chrono, text, { instant: refDate, timezone: -300 }, (result) => {
-        expect(result).toBeDate(new Date(text));
-    });
-});
-
-test("Test - Minimize diff because of local timezone (pre-1900)", () => {
-    // Because of Local mean time (LMT), the local/system timezone my work differently before 1900
-    // For example:
-    //  - Shanghai LMT in 1900 was +08:05:43
-    // We expect Chrono to parse this within a few hours precision
-
-    testSingleCase(chrono, "1900-01-01T00:00:00-00:00", (result) => {
-        const expectedDate = new Date("1900-01-01T00:00:00-00:00");
-        const differenceMinutes = Math.abs(result.date().getTime() - expectedDate.getTime()) / (1000 * 60);
-        expect(differenceMinutes).toBeLessThanOrEqual(60);
-    });
-
-    testSingleCase(chrono, "1900-01-01T00:00:00-01:00", (result) => {
-        const expectedDate = new Date("1900-01-01T00:00:00-01:00");
-        const differenceMinutes = Math.abs(result.date().getTime() - expectedDate.getTime()) / (1000 * 60);
-        expect(differenceMinutes).toBeLessThanOrEqual(60 * 2);
-    });
-
-    testSingleCase(chrono, "1900-01-01T00:00:00+08:00", (result) => {
-        const expectedDate = new Date("1900-01-01T00:00:00+08:00");
-        const differenceMinutes = Math.abs(result.date().getTime() - expectedDate.getTime()) / (1000 * 60);
-        expect(differenceMinutes).toBeLessThanOrEqual(60 * 2);
-    });
-
-    testSingleCase(chrono, "1900-01-01T00:00", { timezone: "JST" }, (result) => {
-        const expectedDate = new Date("1900-01-01T00:00:00+08:00");
-        const differenceMinutes = Math.abs(result.date().getTime() - expectedDate.getTime()) / (1000 * 60);
-        expect(differenceMinutes).toBeLessThanOrEqual(60 * 2);
-    });
-});
-
-test("Test - Timezone DST transitions", function () {
-    // CT (Central Time) transitions:
-    // - DST starts: 2nd Sunday of March at 2am
-    // - DST ends: 1st Sunday of November at 2am
-    testSingleCase(chrono, "2022-03-12 23:00 CT", (result, text) => {
-        // Before DST transition, expected: -360
-        expect(result.text).toBe(text);
-        expect(result.start.get("hour")).toBe(23);
-        expect(result.start.get("timezoneOffset")).toBe(-6 * 60);
-    });
-    testSingleCase(chrono, "2022-03-13 23:00 CT", (result, text) => {
-        // Within DST, expect -300 minutes
-        expect(result.text).toBe(text);
-        expect(result.start.get("hour")).toBe(23);
-        expect(result.start.get("timezoneOffset")).toBe(-5 * 60);
-    });
-    testSingleCase(chrono, "2022-11-06 23:00 CT", (result, text) => {
-        // After DST transition, expected: -360
-        expect(result.text).toBe(text);
-        expect(result.start.get("hour")).toBe(23);
-        expect(result.start.get("timezoneOffset")).toBe(-6 * 60);
-    });
-
-    // MT (Mountain Time) transitions:
-    // - DST starts: 2nd Sunday of March at 2am
-    // - DST ends: 1st Sunday of November at 2am
-    testSingleCase(chrono, "2022-03-12 23:00 MT", (result, text) => {
-        // Before DST transition, expected: -420
-        expect(result.text).toBe(text);
-        expect(result.start.get("hour")).toBe(23);
-        expect(result.start.get("timezoneOffset")).toBe(-7 * 60);
-    });
-    testSingleCase(chrono, "2022-03-13 23:00 MT", (result, text) => {
-        // Within DST, expected: -360
-        expect(result.text).toBe(text);
-        expect(result.start.get("hour")).toBe(23);
-        expect(result.start.get("timezoneOffset")).toBe(-6 * 60);
-    });
-    testSingleCase(chrono, "2022-11-06 23:00 MT", (result, text) => {
-        // After DST transition, expected: -420
-        expect(result.text).toBe(text);
-        expect(result.start.get("hour")).toBe(23);
-        expect(result.start.get("timezoneOffset")).toBe(-7 * 60);
-    });
-
-    // PT (Pacific Time) transitions:
-    // - DST starts: 2nd Sunday of March at 2am
-    // - DST ends: 1st Sunday of November at 2am
-    testSingleCase(chrono, "2022-03-12 23:00 PT", (result, text) => {
-        // Before DST transition, expected: -480
-        expect(result.text).toBe(text);
-        expect(result.start.get("hour")).toBe(23);
-        expect(result.start.get("timezoneOffset")).toBe(-8 * 60);
-    });
-    testSingleCase(chrono, "2022-03-13 23:00 PT", (result, text) => {
-        // Within DST, expected: -420
-        expect(result.text).toBe(text);
-        expect(result.start.get("hour")).toBe(23);
-        expect(result.start.get("timezoneOffset")).toBe(-7 * 60);
-    });
-    testSingleCase(chrono, "2022-11-06 23:00 PT", (result, text) => {
-        // After DST transition, expected: -480
-        expect(result.text).toBe(text);
-        expect(result.start.get("hour")).toBe(23);
-        expect(result.start.get("timezoneOffset")).toBe(-8 * 60);
-    });
-});

package/test/test_util.ts

@@ -1,135 +0,0 @@
-import { BufferedDebugHandler } from "../src/debugging";
-import { en, ParsedResult, ParsingOption, ParsingReference } from "../src";
-
-interface ChronoLike {
-    parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[];
-}
-
-type CheckResult = (p: ParsedResult, text: string) => void;
-
-export function testSingleCase(chrono: ChronoLike, text: string, checkResult?: CheckResult);
-export function testSingleCase(
-    chrono: ChronoLike,
-    text: string,
-    refDateOrCheckResult?: ParsingReference | Date | CheckResult,
-    checkResult?: CheckResult
-);
-export function testSingleCase(
-    chrono: ChronoLike,
-    text: string,
-    refDateOrCheckResult?: ParsingReference | Date | CheckResult,
-    optionOrCheckResult?: ParsingOption | CheckResult,
-    checkResult?: CheckResult
-);
-export function testSingleCase(
-    chrono: ChronoLike,
-    text: string,
-    refDateOrCheckResult?: ParsingReference | Date | CheckResult,
-    optionOrCheckResult?: ParsingOption | CheckResult,
-    checkResult?: CheckResult
-) {
-    if (checkResult === undefined && typeof optionOrCheckResult === "function") {
-        checkResult = optionOrCheckResult;
-        optionOrCheckResult = undefined;
-    }
-
-    if (optionOrCheckResult === undefined && typeof refDateOrCheckResult === "function") {
-        checkResult = refDateOrCheckResult;
-        refDateOrCheckResult = undefined;
-    }
-
-    const debugHandler = new BufferedDebugHandler();
-    optionOrCheckResult = (optionOrCheckResult as ParsingOption) || {};
-    optionOrCheckResult.debug = debugHandler;
-
-    try {
-        const results = chrono.parse(text, refDateOrCheckResult as Date, optionOrCheckResult);
-        expect(results).toBeSingleOnText(text);
-        if (checkResult) {
-            checkResult(results[0], text);
-        }
-    } catch (e) {
-        debugHandler.executeBufferedBlocks();
-        e.stack = e.stack.replace(/[^\n]*at .*test_util.*\n/g, "");
-        throw e;
-    }
-}
-
-export function testWithExpectedDate(chrono: ChronoLike, text: string, expectedDate: Date) {
-    testSingleCase(chrono, text, (result) => {
-        expect(result.start).toBeDate(expectedDate);
-    });
-}
-
-export function testUnexpectedResult(chrono: ChronoLike, text: string, refDate?: Date, options?: ParsingOption) {
-    const debugHandler = new BufferedDebugHandler();
-    options = options || {};
-    options.debug = debugHandler;
-
-    try {
-        const results = chrono.parse(text, refDate, options);
-        expect(results).toHaveLength(0);
-    } catch (e) {
-        debugHandler.executeBufferedBlocks();
-        e.stack = e.stack.replace(/[^\n]*at .*test_util.*\n/g, "");
-        throw e;
-    }
-}
-
-export function measureMilliSec(block: () => void): number {
-    const startTime = new Date().getMilliseconds();
-    block();
-    const endTime = new Date().getMilliseconds();
-    return endTime - startTime;
-}
-
-// --------------------------------------------------
-
-declare global {
-    // eslint-disable-next-line @typescript-eslint/no-namespace
-    namespace jest {
-        // noinspection JSUnusedGlobalSymbols
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        interface Matchers<R> {
-            toBeDate(date: Date): CustomMatcherResult;
-            toBeSingleOnText(text: string): CustomMatcherResult;
-        }
-    }
-}
-
-// noinspection JSUnusedGlobalSymbols
-expect.extend({
-    toBeDate(resultOrComponent, date) {
-        if (typeof resultOrComponent.date !== "function") {
-            return {
-                message: () => `${resultOrComponent} is not a ParsedResult or ParsedComponent`,
-                pass: false,
-            };
-        }
-
-        const actualDate = resultOrComponent.date();
-        const actualTime = actualDate.getTime();
-        const expectedTime = date.getTime();
-        return {
-            message: () => `Expected date to be: ${date} Received: ${actualDate} (${resultOrComponent})`,
-            pass: actualTime === expectedTime,
-        };
-    },
-
-    toBeSingleOnText(results, text) {
-        if (results.length === 1) {
-            return {
-                message: () => `Got single result from '${text}'`,
-                pass: true,
-            };
-        }
-
-        return {
-            message: () =>
-                `Got ${results.length} results from '${text}'\n${results
-                    .map((result) => JSON.stringify(result))
-                    .join("\n")}`,
-            pass: false,
-        };
-    },
-});

package/test/uk/uk_casual.test.ts

@@ -1,153 +0,0 @@
-import * as chrono from "../../src/";
-import { testSingleCase, testUnexpectedResult } from "../test_util";
-
-test("Test - Single Expression", () => {
-    testSingleCase(chrono.uk.casual, "Дедлайн сьогодні", new Date(2012, 7, 10, 17, 10), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("сьогодні");
-        expect(result.start).toBeDate(new Date(2012, 7, 10, 17, 10));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн завтра", new Date(2012, 7, 10, 17, 10), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("завтра");
-        expect(result.start).toBeDate(new Date(2012, 7, 11, 17, 10));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн післязавтра", new Date(2012, 7, 10, 17, 10), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("післязавтра");
-        expect(result.start).toBeDate(new Date(2012, 7, 12, 17, 10));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн післяпіслязавтра", new Date(2012, 7, 10, 17, 10), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("післяпіслязавтра");
-        expect(result.start).toBeDate(new Date(2012, 7, 13, 17, 10));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн вчора", new Date(2012, 7, 10, 17, 10), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("вчора");
-        expect(result.start).toBeDate(new Date(2012, 7, 9, 17, 10));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн позавчора", new Date(2012, 7, 10, 17, 10), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("позавчора");
-        expect(result.start).toBeDate(new Date(2012, 7, 8, 17, 10));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн позапозавчора", new Date(2012, 7, 10, 17, 10), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("позапозавчора");
-        expect(result.start).toBeDate(new Date(2012, 7, 7, 17, 10));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн зараз", new Date(2012, 7, 10, 8, 9, 10, 11), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("зараз");
-        expect(result.start).toBeDate(result.refDate);
-        expect(result.start).toBeDate(new Date(2012, 7, 10, 8, 9, 10, 11));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн вранці", new Date(2012, 7, 10, 8, 9, 10, 11), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("вранці");
-        expect(result.start).toBeDate(new Date(2012, 7, 10, 6, 0, 0, 0));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн цього ранку", new Date(2012, 7, 10, 8, 9, 10, 11), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("цього ранку");
-        expect(result.start).toBeDate(new Date(2012, 7, 10, 6, 0, 0, 0));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн опівдні", new Date(2012, 7, 10, 8, 9, 10, 11), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("опівдні");
-        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 0, 0, 0));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн минулого вечора", new Date(2012, 7, 10, 8, 9, 10, 11), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("минулого вечора");
-        expect(result.start).toBeDate(new Date(2012, 7, 9, 20, 0, 0, 0));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн ввечері", new Date(2012, 7, 10, 8, 9, 10, 11), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("ввечері");
-        expect(result.start).toBeDate(new Date(2012, 7, 10, 20, 0, 0, 0));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн минулої ночі", new Date(2012, 7, 10, 8, 9, 10, 11), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("минулої ночі");
-        expect(result.start).toBeDate(new Date(2012, 7, 10, 0, 0, 0, 0));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн сьогодні вночі", new Date(2012, 7, 10, 2, 9, 10, 11), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("сьогодні вночі");
-        expect(result.start).toBeDate(new Date(2012, 7, 10, 0, 0, 0, 0));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн цієї ночі", new Date(2012, 7, 10, 2, 9, 10, 11), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("цієї ночі");
-        expect(result.start).toBeDate(new Date(2012, 7, 10, 0, 0, 0, 0));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн вночі", new Date(2012, 7, 10, 2, 9, 10, 11), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("вночі");
-        expect(result.start).toBeDate(new Date(2012, 7, 10, 0, 0, 0, 0));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн опівночі", new Date(2012, 7, 10, 2, 9, 10, 11), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("опівночі");
-        expect(result.start).toBeDate(new Date(2012, 7, 10, 0, 0, 0, 0));
-    });
-});
-
-test("Test - Combined Expression", () => {
-    testSingleCase(chrono.uk.casual, "Дедлайн вчора ввечері", new Date(2012, 7, 10, 12), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("вчора ввечері");
-        expect(result.start).toBeDate(new Date(2012, 7, 9, 20));
-    });
-
-    testSingleCase(chrono.uk.casual, "Дедлайн завтра вранці", new Date(2012, 8, 10, 14), (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("завтра вранці");
-        expect(result.start).toBeDate(new Date(2012, 8, 11, 6));
-    });
-});
-
-test("Test - Casual date range", () => {
-    testSingleCase(chrono.uk.casual, "Подія від сьогодні і до післязавтра", new Date(2012, 7, 4, 12), (result) => {
-        expect(result.index).toBe(6);
-        expect(result.text).toBe("від сьогодні і до післязавтра");
-        expect(result.start).toBeDate(new Date(2012, 7, 4, 12));
-        expect(result.end).toBeDate(new Date(2012, 7, 6, 12));
-    });
-
-    testSingleCase(chrono.uk.casual, "Подія сьогодні-завтра", new Date(2012, 7, 10, 12), (result) => {
-        expect(result.index).toBe(6);
-        expect(result.text).toBe("сьогодні-завтра");
-        expect(result.start).toBeDate(new Date(2012, 7, 10, 12));
-        expect(result.end).toBeDate(new Date(2012, 7, 11, 12));
-    });
-});
-
-test("Test - Random negative text", () => {
-    testUnexpectedResult(chrono.uk, "несьогодні");
-
-    testUnexpectedResult(chrono.uk, "звтра");
-
-    testUnexpectedResult(chrono.uk, "ввчора");
-
-    testUnexpectedResult(chrono.uk, "січен");
-});

package/test/uk/uk_month.test.ts

@@ -1,70 +0,0 @@
-import * as chrono from "../../src";
-import { testSingleCase } from "../test_util";
-
-test("Test - Month-Year expression", function () {
-    testSingleCase(chrono.uk, "Вересень 2012", (result) => {
-        expect(result.index).toBe(0);
-        expect(result.text).toBe("Вересень 2012");
-        expect(result.start).toBeDate(new Date(2012, 9 - 1, 1, 12));
-    });
-
-    testSingleCase(chrono.uk, "верес 2012", (result) => {
-        expect(result.index).toBe(0);
-        expect(result.text).toBe("верес 2012");
-        expect(result.start).toBeDate(new Date(2012, 9 - 1, 1, 12));
-    });
-
-    testSingleCase(chrono.uk, "верес. 2012", (result) => {
-        expect(result.index).toBe(0);
-        expect(result.text).toBe("верес. 2012");
-        expect(result.start).toBeDate(new Date(2012, 9 - 1, 1, 12));
-    });
-
-    testSingleCase(chrono.uk, "верес-2012", (result) => {
-        expect(result.index).toBe(0);
-        expect(result.text).toBe("верес-2012");
-        expect(result.start).toBeDate(new Date(2012, 9 - 1, 1, 12));
-    });
-});
-
-test("Test - Month-Only expression", function () {
-    testSingleCase(chrono.uk, "в січні", new Date(2020, 11 - 1, 22), (result) => {
-        expect(result.index).toBe(0);
-        expect(result.text).toBe("в січні");
-        expect(result.start).toBeDate(new Date(2021, 1 - 1, 1, 12));
-    });
-
-    testSingleCase(chrono.uk, "в січ", new Date(2020, 11 - 1, 22), (result) => {
-        expect(result.index).toBe(0);
-        expect(result.text).toBe("в січ");
-        expect(result.start).toBeDate(new Date(2021, 1 - 1, 1, 12));
-    });
-
-    testSingleCase(chrono.uk, "травень", new Date(2020, 11 - 1, 22), (result) => {
-        expect(result.index).toBe(0);
-        expect(result.text).toBe("травень");
-        expect(result.start).toBeDate(new Date(2021, 5 - 1, 1, 12));
-    });
-});
-
-test("Test - Month expression in context", function () {
-    testSingleCase(chrono.uk, "Це було у вересні 2012 перед новим роком", (result) => {
-        expect(result.index).toBe(8);
-        expect(result.text).toBe("у вересні 2012");
-        expect(result.start).toBeDate(new Date(2012, 9 - 1, 1, 12));
-    });
-});
-
-test("Test - year 90's parsing", () => {
-    testSingleCase(chrono.uk, "сер 96", new Date(2012, 7, 10), (result) => {
-        expect(result.index).toBe(0);
-        expect(result.text).toBe("сер 96");
-        expect(result.start).toBeDate(new Date(1996, 8 - 1, 1, 12));
-    });
-
-    testSingleCase(chrono.uk, "96 сер 96", new Date(2012, 7, 10), (result) => {
-        expect(result.index).toBe(3);
-        expect(result.text).toBe("сер 96");
-        expect(result.start).toBeDate(new Date(1996, 8 - 1, 1, 12));
-    });
-});