chrono-node 2.6.6 → 2.7.0

package/src/locales/en/parsers/ENTimeUnitWithinFormatParser.ts

@@ -3,8 +3,9 @@ import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 
-const PATTERN_WITHOUT_PREFIX = new RegExp(
-    `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`,
+const PATTERN_WITH_OPTIONAL_PREFIX = new RegExp(
+    `(?:(?:within|in|for)\\s*)?` +
+        `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`,
     "i"
 );
 
@@ -29,7 +30,7 @@ export default class ENTimeUnitWithinFormatParser extends AbstractParserWithWord
         if (this.strictMode) {
             return PATTERN_WITH_PREFIX_STRICT;
         }
-        return context.option.forwardDate ? PATTERN_WITHOUT_PREFIX : PATTERN_WITH_PREFIX;
+        return context.option.forwardDate ? PATTERN_WITH_OPTIONAL_PREFIX : PATTERN_WITH_PREFIX;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {

package/src/results.ts

@@ -50,6 +50,7 @@ export class ParsingComponents implements ParsedComponents {
     private knownValues: { [c in Component]?: number };
     private impliedValues: { [c in Component]?: number };
     private reference: ReferenceWithTimezone;
+    private _tags = new Set<string>();
 
     constructor(reference: ReferenceWithTimezone, knownComponents?: { [c in Component]?: number }) {
         this.reference = reference;
@@ -155,9 +156,11 @@ export class ParsingComponents implements ParsedComponents {
     }
 
     toString() {
-        return `[ParsingComponents {knownValues: ${JSON.stringify(this.knownValues)}, impliedValues: ${JSON.stringify(
-            this.impliedValues
-        )}}, reference: ${JSON.stringify(this.reference)}]`;
+        return `[ParsingComponents {
+            tags: ${JSON.stringify(Array.from(this._tags).sort())}, 
+            knownValues: ${JSON.stringify(this.knownValues)}, 
+            impliedValues: ${JSON.stringify(this.impliedValues)}}, 
+            reference: ${JSON.stringify(this.reference)}]`;
     }
 
     dayjs() {
@@ -170,6 +173,22 @@ export class ParsingComponents implements ParsedComponents {
         return new Date(date.getTime() + timezoneAdjustment * 60000);
     }
 
+    addTag(tag: string): ParsingComponents {
+        this._tags.add(tag);
+        return this;
+    }
+
+    addTags(tags: string[] | Set<string>): ParsingComponents {
+        for (const tag of tags) {
+            this._tags.add(tag);
+        }
+        return this;
+    }
+
+    tags(): Set<string> {
+        return new Set(this._tags);
+    }
+
     private dateWithoutTimezoneAdjustment() {
         const date = new Date(
             this.get("year"),
@@ -271,7 +290,18 @@ export class ParsingResult implements ParsedResult {
         return this.start.date();
     }
 
+    tags(): Set<string> {
+        const combinedTags: Set<string> = new Set(this.start.tags());
+        if (this.end) {
+            for (const tag of this.end.tags()) {
+                combinedTags.add(tag);
+            }
+        }
+        return combinedTags;
+    }
+
     toString() {
-        return `[ParsingResult {index: ${this.index}, text: '${this.text}', ...}]`;
+        const tags = Array.from(this.tags()).sort();
+        return `[ParsingResult {index: ${this.index}, text: '${this.text}', tags: ${JSON.stringify(tags)} ...}]`;
     }
 }

package/src/types.ts

@@ -77,9 +77,14 @@ export interface ParsedResult {
     readonly end?: ParsedComponents;
 
     /**
-     * Create a javascript date object (from the result.start).
+     * @return a javascript date object created from the `result.start`.
      */
     date(): Date;
+
+    /**
+     * @return debugging tags combined of the `result.start` and `result.end`.
+     */
+    tags(): Set<string>;
 }
 
 /**
@@ -105,6 +110,11 @@ export interface ParsedComponents {
      * @return a javascript date object.
      */
     date(): Date;
+
+    /**
+     * @return debugging tags of the parsed component.
+     */
+    tags(): Set<string>;
 }
 
 export type Component =

package/test/en/en_time_units_within.test.ts

@@ -336,7 +336,7 @@ test("Test - Time units' certainty", () => {
     });
 });
 
-test("Test - Strict mode", function () {
+test("Test - Strict mode", () => {
     testSingleCase(chrono, "in 2hour", new Date(2016, 10 - 1, 1, 14, 52), (result, text) => {
         expect(result.start.get("hour")).toBe(16);
         expect(result.start.get("minute")).toBe(52);
@@ -345,3 +345,24 @@ test("Test - Strict mode", function () {
     testUnexpectedResult(chrono.strict, "in 15m");
     testUnexpectedResult(chrono.strict, "within 5hr");
 });
+
+test("Test - Forward date option", () => {
+    testSingleCase(chrono, "1 hour", new Date(2012, 7, 10, 12, 14), { forwardDate: true }, (result) => {
+        expect(result.text).toBe("1 hour");
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 13, 14));
+    });
+
+    testSingleCase(chrono, "1 month", new Date(2016, 10 - 1, 1, 14, 52), { forwardDate: true }, (result, text) => {
+        expect(result.text).toBe("1 month");
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(1);
+    });
+
+    testSingleCase(chrono, "in 1 month", new Date(2016, 10 - 1, 1, 14, 52), { forwardDate: true }, (result, text) => {
+        expect(result.text).toBe("in 1 month");
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(1);
+    });
+});

package/test/result.test.ts

@@ -1,6 +1,6 @@
-import { ParsingComponents, ReferenceWithTimezone } from "../src/results";
+import { ParsingComponents, ParsingResult, ReferenceWithTimezone } from "../src/results";
 
-test("Test - Create & manipulate date results", () => {
+test("Test - Create & manipulate parsing components", () => {
     const reference = new ReferenceWithTimezone(new Date());
     const components = new ParsingComponents(reference, { year: 2014, month: 11, day: 24 });
 
@@ -8,6 +8,7 @@ test("Test - Create & manipulate date results", () => {
     expect(components.get("month")).toBe(11);
     expect(components.get("day")).toBe(24);
     expect(components.date()).toBeDefined();
+    expect(components.tags().size).toBe(0);
 
     // null
     expect(components.get("weekday")).toBeNull();
@@ -23,13 +24,45 @@ test("Test - Create & manipulate date results", () => {
     expect(components.get("weekday")).toBe(2);
     expect(components.isCertain("weekday")).toBe(true);
 
-    // "imply" doesn't overrides "assign"
+    // "imply" doesn't override "assign"
     components.imply("year", 2013);
     expect(components.get("year")).toBe(2014);
 
     // "assign" overrides "assign"
     components.assign("year", 2013);
     expect(components.get("year")).toBe(2013);
+
+    components.addTag("custom/testing_component_tag");
+    expect(components.tags().size).toBe(1);
+    expect(components.tags()).toContain("custom/testing_component_tag");
+    expect(components.toString()).toContain("custom/testing_component_tag");
+});
+
+test("Test - Create & manipulate parsing results", () => {
+    const reference = new ReferenceWithTimezone(new Date());
+    const text = "1 - 2 hour later";
+
+    const startComponents = ParsingComponents.createRelativeFromReference(reference, { "hour": 1 }).addTag(
+        "custom/testing_start_component_tag"
+    );
+
+    const endComponents = ParsingComponents.createRelativeFromReference(reference, { "hour": 2 }).addTag(
+        "custom/testing_end_component_tag"
+    );
+
+    const result = new ParsingResult(reference, 0, text, startComponents, endComponents);
+
+    // The result's date() should be the same as the start components' date()
+    expect(result.date()).toStrictEqual(startComponents.date());
+
+    // The result's tags should include both the start and end components' tags
+    expect(result.tags()).toContain("custom/testing_start_component_tag");
+    expect(result.tags()).toContain("custom/testing_end_component_tag");
+
+    // The result's toString() should include the text and tags
+    expect(result.toString()).toContain(text);
+    expect(result.toString()).toContain("custom/testing_start_component_tag");
+    expect(result.toString()).toContain("custom/testing_end_component_tag");
 });
 
 test("Test - Calendar checking with implied components", () => {

package/test/system.test.ts

@@ -5,6 +5,7 @@ import UnlikelyFormatFilter from "../src/common/refiners/UnlikelyFormatFilter";
 import SlashDateFormatParser from "../src/common/parsers/SlashDateFormatParser";
 import ENWeekdayParser from "../src/locales/en/parsers/ENWeekdayParser";
 import ENTimeUnitCasualRelativeFormatParser from "../src/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser";
+import { ParsingComponents } from "../src/";
 
 //-------------------------------------
 
@@ -124,6 +125,42 @@ test("Test - Add custom refiner example", () => {
     });
 });
 
+test("Test - Add custom parser with tags example", () => {
+    const custom = chrono.casual.clone();
+    custom.parsers.push({
+        pattern: () => {
+            return /\bChristmas\b/i;
+        },
+        extract: (context) => {
+            return context
+                .createParsingComponents({
+                    day: 25,
+                    month: 12,
+                })
+                .addTag("parser/ChristmasDayParser");
+        },
+    });
+
+    testSingleCase(custom, "Doing something tomorrow", (result) => {
+        expect(result.text).toBe("tomorrow");
+        expect(result.tags()).toContain("parser/ENCasualDateParser");
+    });
+
+    testSingleCase(custom, "I'll arrive at 2.30AM on Christmas", (result) => {
+        expect(result.text).toBe("at 2.30AM on Christmas");
+        expect(result.tags()).toContain("parser/ChristmasDayParser");
+        expect(result.tags()).toContain("parser/ENTimeExpressionParser");
+    });
+
+    testSingleCase(custom, "I'll arrive at Christmas night", (result) => {
+        expect(result.text).toBe("Christmas night");
+        expect(result.tags()).toContain("parser/ChristmasDayParser");
+        expect(result.tags()).toContain("parser/ENCasualTimeParser");
+    });
+
+    // TODO: Check if the merge date range combine tags correctly
+});
+
 test("Test - Remove a parser example", () => {
     const custom = chrono.en.strict.clone();
     custom.parsers = custom.parsers.filter((r) => !(r instanceof SlashDateFormatParser));