Skip to content

Commit 0cfef4e

Browse files
wanasitwanasit
authoredJun 18, 2021
Merge pull request #398 from jebbench/enhance-dutch-support
Added more support for Dutch.
·
v2.7.8v2.3.1
2 parents 405a27b + 7bb00af commit 0cfef4e

11 files changed

+1012
-8
lines changed
 

‎src/locales/nl/constants.ts

+11-5
Original file line numberDiff line numberDiff line change
@@ -141,11 +141,14 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType } = {
141141
min: "minute",
142142
mins: "minute",
143143
minute: "minute",
144+
minuut: "minute",
144145
minuten: "minute",
146+
minuutje: "minute",
145147
h: "hour",
146148
hr: "hour",
147149
hrs: "hour",
148150
uur: "hour",
151+
u: "hour",
149152
uren: "hour",
150153
dag: "d",
151154
dagen: "d",
@@ -160,18 +163,21 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType } = {
160163

161164
//-----------------------------
162165

163-
export const NUMBER_PATTERN = `(?:${matchAnyPattern(INTEGER_WORD_DICTIONARY)}|[0-9]+|[0-9]+\\.[0-9]+|een?|halve?)`;
166+
export const NUMBER_PATTERN = `(?:${matchAnyPattern(
167+
INTEGER_WORD_DICTIONARY
168+
)}|[0-9]+|[0-9]+[\\.,][0-9]+|halve?|half|paar)`;
164169

165170
export function parseNumberPattern(match: string): number {
166171
const num = match.toLowerCase();
167172
if (INTEGER_WORD_DICTIONARY[num] !== undefined) {
168173
return INTEGER_WORD_DICTIONARY[num];
169-
} else if (num === "een") {
170-
return 1;
171-
} else if (num.match(/halve?/)) {
174+
} else if (num === "paar") {
175+
return 2;
176+
} else if (num === "half" || num.match(/halve?/)) {
172177
return 0.5;
173178
}
174-
return parseFloat(num);
179+
// Replace "," with "." to support some European languages
180+
return parseFloat(num.replace(",", "."));
175181
}
176182

177183
//-----------------------------

‎src/locales/nl/index.ts

+12-3
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,10 @@ import NLSlashMonthFormatParser from "./parsers/NLSlashMonthFormatParser";
2020
import NLTimeExpressionParser from "./parsers/NLTimeExpressionParser";
2121
import NLCasualYearMonthDayParser from "./parsers/NLCasualYearMonthDayParser";
2222
import NLCasualDateTimeParser from "./parsers/NLCasualDateTimeParser";
23+
import NLTimeUnitCasualRelativeFormatParser from "./parsers/NLTimeUnitCasualRelativeFormatParser";
24+
import NLRelativeDateFormatParser from "./parsers/NLRelativeDateFormatParser";
25+
import NLTimeUnitAgoFormatParser from "./parsers/NLTimeUnitAgoFormatParser";
26+
import NLTimeUnitLaterFormatParser from "./parsers/NLTimeUnitLaterFormatParser";
2327

2428
// Shortcuts
2529
export const casual = new Chrono(createCasualConfiguration());
@@ -38,6 +42,9 @@ export function createCasualConfiguration(littleEndian = true): Configuration {
3842
option.parsers.unshift(new NLCasualDateParser());
3943
option.parsers.unshift(new NLCasualTimeParser());
4044
option.parsers.unshift(new NLCasualDateTimeParser());
45+
option.parsers.unshift(new NLMonthNameParser());
46+
option.parsers.unshift(new NLRelativeDateFormatParser());
47+
option.parsers.unshift(new NLTimeUnitCasualRelativeFormatParser());
4148
return option;
4249
}
4350

@@ -49,13 +56,15 @@ export function createConfiguration(strictMode = true, littleEndian = true): Con
4956
{
5057
parsers: [
5158
new SlashDateFormatParser(littleEndian),
59+
new NLTimeUnitWithinFormatParser(),
5260
new NLMonthNameMiddleEndianParser(),
5361
new NLMonthNameParser(),
54-
new NLTimeExpressionParser(),
55-
new NLTimeUnitWithinFormatParser(),
56-
new NLSlashMonthFormatParser(),
5762
new NLWeekdayParser(),
5863
new NLCasualYearMonthDayParser(),
64+
new NLSlashMonthFormatParser(),
65+
new NLTimeExpressionParser(strictMode),
66+
new NLTimeUnitAgoFormatParser(strictMode),
67+
new NLTimeUnitLaterFormatParser(strictMode),
5968
],
6069
refiners: [new NLMergeDateTimeRefiner(), new NLMergeDateRangeRefiner()],
6170
},

‎src/locales/nl/parsers/NLRelativeDateFormatParser.ts

+70
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,70 @@
1+
import { TIME_UNIT_DICTIONARY } from "../constants";
2+
import { ParsingContext } from "../../../chrono";
3+
import { ParsingComponents } from "../../../results";
4+
import dayjs from "dayjs";
5+
import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
6+
import { matchAnyPattern } from "../../../utils/pattern";
7+
8+
const PATTERN = new RegExp(
9+
`(dit|deze|komende|volgend|volgende|afgelopen|vorige)\\s*(${matchAnyPattern(TIME_UNIT_DICTIONARY)})(?=\\s*)` +
10+
"(?=\\W|$)",
11+
"i"
12+
);
13+
14+
const MODIFIER_WORD_GROUP = 1;
15+
const RELATIVE_WORD_GROUP = 2;
16+
17+
export default class NLRelativeDateFormatParser extends AbstractParserWithWordBoundaryChecking {
18+
innerPattern(): RegExp {
19+
return PATTERN;
20+
}
21+
22+
innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
23+
const modifier = match[MODIFIER_WORD_GROUP].toLowerCase();
24+
const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();
25+
const timeunit = TIME_UNIT_DICTIONARY[unitWord];
26+
27+
if (modifier == "volgend" || modifier == "volgende" || modifier == "komende") {
28+
const timeUnits = {};
29+
timeUnits[timeunit] = 1;
30+
return ParsingComponents.createRelativeFromRefDate(context.refDate, timeUnits);
31+
}
32+
33+
if (modifier == "afgelopen" || modifier == "vorige") {
34+
const timeUnits = {};
35+
timeUnits[timeunit] = -1;
36+
return ParsingComponents.createRelativeFromRefDate(context.refDate, timeUnits);
37+
}
38+
39+
const components = context.createParsingComponents();
40+
let date = dayjs(context.refDate);
41+
42+
// This week
43+
if (unitWord.match(/week/i)) {
44+
date = date.add(-date.get("d"), "d");
45+
components.imply("day", date.date());
46+
components.imply("month", date.month() + 1);
47+
components.imply("year", date.year());
48+
}
49+
50+
// This month
51+
else if (unitWord.match(/maand/i)) {
52+
date = date.add(-date.date() + 1, "d");
53+
components.imply("day", date.date());
54+
components.assign("year", date.year());
55+
components.assign("month", date.month() + 1);
56+
}
57+
58+
// This year
59+
else if (unitWord.match(/jaar/i)) {
60+
date = date.add(-date.date() + 1, "d");
61+
date = date.add(-date.month(), "month");
62+
63+
components.imply("day", date.date());
64+
components.imply("month", date.month() + 1);
65+
components.assign("year", date.year());
66+
}
67+
68+
return components;
69+
}
70+
}

‎src/locales/nl/parsers/NLTimeExpressionParser.ts

+4
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,10 @@ export default class NLTimeExpressionParser extends AbstractTimeExpressionParser
1111
return "\\s*(?:\\-|\\–|\\~|\\〜|om|\\?)\\s*";
1212
}
1313

14+
primarySuffix(): string {
15+
return "(?:\\s*(?:uur))?(?!/)(?=\\W|$)";
16+
}
17+
1418
extractPrimaryTimeComponents(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | null {
1519
// This looks more like a year e.g. 2020
1620
if (match[0].match(/^\s*\d{4}\s*$/)) {

‎src/locales/nl/parsers/NLTimeUnitAgoFormatParser.ts

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
import { ParsingContext } from "../../../chrono";
2+
import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
3+
import { ParsingComponents } from "../../../results";
4+
import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
5+
import { reverseTimeUnits } from "../../../utils/timeunits";
6+
7+
const PATTERN = new RegExp("" + "(" + TIME_UNITS_PATTERN + ")" + "(?:geleden|voor|eerder)(?=(?:\\W|$))", "i");
8+
9+
const STRICT_PATTERN = new RegExp("" + "(" + TIME_UNITS_PATTERN + ")" + "geleden(?=(?:\\W|$))", "i");
10+
11+
export default class NLTimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
12+
constructor(private strictMode: boolean) {
13+
super();
14+
}
15+
16+
innerPattern(): RegExp {
17+
return this.strictMode ? STRICT_PATTERN : PATTERN;
18+
}
19+
20+
innerExtract(context: ParsingContext, match: RegExpMatchArray) {
21+
const timeUnits = parseTimeUnits(match[1]);
22+
const outputTimeUnits = reverseTimeUnits(timeUnits);
23+
24+
return ParsingComponents.createRelativeFromRefDate(context.refDate, outputTimeUnits);
25+
}
26+
}

‎src/locales/nl/parsers/NLTimeUnitCasualRelativeFormatParser.ts

+27
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
import { TIME_UNITS_PATTERN, parseTimeUnits } from "../constants";
2+
import { ParsingContext } from "../../../chrono";
3+
import { ParsingComponents } from "../../../results";
4+
import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
5+
import { reverseTimeUnits } from "../../../utils/timeunits";
6+
7+
const PATTERN = new RegExp(`(deze|vorige|afgelopen|komende|over|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
8+
9+
export default class NLTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
10+
innerPattern(): RegExp {
11+
return PATTERN;
12+
}
13+
14+
innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
15+
const prefix = match[1].toLowerCase();
16+
let timeUnits = parseTimeUnits(match[2]);
17+
switch (prefix) {
18+
case "vorige":
19+
case "afgelopen":
20+
case "-":
21+
timeUnits = reverseTimeUnits(timeUnits);
22+
break;
23+
}
24+
25+
return ParsingComponents.createRelativeFromRefDate(context.refDate, timeUnits);
26+
}
27+
}

‎src/locales/nl/parsers/NLTimeUnitLaterFormatParser.ts

+27
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
import { ParsingContext } from "../../../chrono";
2+
import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
3+
import { ParsingComponents } from "../../../results";
4+
import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
5+
6+
const PATTERN = new RegExp(
7+
"" + "(" + TIME_UNITS_PATTERN + ")" + "(later|na|vanaf nu|voortaan|vooruit|uit)" + "(?=(?:\\W|$))",
8+
"i"
9+
);
10+
11+
const STRICT_PATTERN = new RegExp("" + "(" + TIME_UNITS_PATTERN + ")" + "(later|vanaf nu)" + "(?=(?:\\W|$))", "i");
12+
const GROUP_NUM_TIMEUNITS = 1;
13+
14+
export default class NLTimeUnitLaterFormatParser extends AbstractParserWithWordBoundaryChecking {
15+
constructor(private strictMode: boolean) {
16+
super();
17+
}
18+
19+
innerPattern(): RegExp {
20+
return this.strictMode ? STRICT_PATTERN : PATTERN;
21+
}
22+
23+
innerExtract(context: ParsingContext, match: RegExpMatchArray) {
24+
const fragments = parseTimeUnits(match[GROUP_NUM_TIMEUNITS]);
25+
return ParsingComponents.createRelativeFromRefDate(context.refDate, fragments);
26+
}
27+
}

‎test/nl/nl_relative.test.ts

+212
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,212 @@
1+
import * as chrono from "../../src";
2+
import { testSingleCase } from "../test_util";
3+
import { ParsingResult } from "../../src/results";
4+
5+
test("Test - 'This' expressions", () => {
6+
// this week
7+
testSingleCase(chrono.nl, "deze week", new Date(2017, 11 - 1, 19, 12), (result, text) => {
8+
expect(result.text).toBe(text);
9+
expect(result.start.get("year")).toBe(2017);
10+
expect(result.start.get("month")).toBe(11);
11+
expect(result.start.get("day")).toBe(19);
12+
expect(result.start.get("hour")).toBe(12);
13+
});
14+
15+
// this month
16+
testSingleCase(chrono.nl, "deze maand", new Date(2017, 11 - 1, 19, 12), (result, text) => {
17+
expect(result.text).toBe(text);
18+
expect(result.start.get("year")).toBe(2017);
19+
expect(result.start.get("month")).toBe(11);
20+
expect(result.start.get("day")).toBe(1);
21+
expect(result.start.get("hour")).toBe(12);
22+
});
23+
24+
// this year
25+
testSingleCase(chrono.nl, "dit jaar", new Date(2017, 11 - 1, 19, 12), (result, text) => {
26+
expect(result.text).toBe(text);
27+
expect(result.start.get("year")).toBe(2017);
28+
expect(result.start.get("month")).toBe(1);
29+
expect(result.start.get("day")).toBe(1);
30+
expect(result.start.get("hour")).toBe(12);
31+
});
32+
});
33+
34+
test("Test - Past relative expressions", () => {
35+
// last week
36+
testSingleCase(chrono.nl, "afgelopen week", new Date(2016, 10 - 1, 1, 12), (result, text) => {
37+
expect(result.text).toBe(text);
38+
expect(result.start.get("year")).toBe(2016);
39+
expect(result.start.get("month")).toBe(9);
40+
expect(result.start.get("day")).toBe(24);
41+
expect(result.start.get("hour")).toBe(12);
42+
});
43+
44+
// last month
45+
testSingleCase(chrono.nl, "afgelopen maand", new Date(2016, 10 - 1, 1, 12), (result, text) => {
46+
expect(result.text).toBe(text);
47+
expect(result.start.get("year")).toBe(2016);
48+
expect(result.start.get("month")).toBe(9);
49+
expect(result.start.get("day")).toBe(1);
50+
expect(result.start.get("hour")).toBe(12);
51+
});
52+
53+
// last day
54+
testSingleCase(chrono.nl, "afgelopen dag", new Date(2016, 10 - 1, 1, 12), (result, text) => {
55+
expect(result.text).toBe(text);
56+
expect(result.start.get("year")).toBe(2016);
57+
expect(result.start.get("month")).toBe(9);
58+
expect(result.start.get("day")).toBe(30);
59+
expect(result.start.get("hour")).toBe(12);
60+
});
61+
62+
// past week
63+
testSingleCase(chrono.nl, "vorige week", new Date(2016, 10 - 1, 1, 12), (result, text) => {
64+
expect(result.text).toBe(text);
65+
expect(result.start.get("year")).toBe(2016);
66+
expect(result.start.get("month")).toBe(9);
67+
expect(result.start.get("day")).toBe(24);
68+
expect(result.start.get("hour")).toBe(12);
69+
});
70+
});
71+
72+
test("Test - Future relative expressions", () => {
73+
// next hour
74+
testSingleCase(chrono.nl, "komende uur", new Date(2016, 10 - 1, 1, 12), (result, text) => {
75+
expect(result.text).toBe(text);
76+
expect(result.start.get("year")).toBe(2016);
77+
expect(result.start.get("month")).toBe(10);
78+
expect(result.start.get("day")).toBe(1);
79+
expect(result.start.get("hour")).toBe(13);
80+
});
81+
82+
// next week
83+
testSingleCase(chrono.nl, "volgende week", new Date(2016, 10 - 1, 1, 12), (result, text) => {
84+
expect(result.text).toBe(text);
85+
expect(result.start.get("year")).toBe(2016);
86+
expect(result.start.get("month")).toBe(10);
87+
expect(result.start.get("day")).toBe(8);
88+
expect(result.start.get("hour")).toBe(12);
89+
});
90+
91+
// next day
92+
testSingleCase(chrono.nl, "volgende dag", new Date(2016, 10 - 1, 1, 12), (result, text) => {
93+
expect(result.text).toBe(text);
94+
expect(result.start.get("year")).toBe(2016);
95+
expect(result.start.get("month")).toBe(10);
96+
expect(result.start.get("day")).toBe(2);
97+
expect(result.start.get("hour")).toBe(12);
98+
});
99+
100+
// next month
101+
testSingleCase(chrono.nl, "volgende maand", new Date(2016, 10 - 1, 1, 12), (result, text) => {
102+
expect(result.text).toBe(text);
103+
expect(result.start.get("year")).toBe(2016);
104+
expect(result.start.get("month")).toBe(11);
105+
expect(result.start.get("day")).toBe(1);
106+
expect(result.start.get("hour")).toBe(12);
107+
108+
expect(result.start.isCertain("year")).toBe(true);
109+
expect(result.start.isCertain("month")).toBe(true);
110+
expect(result.start.isCertain("day")).toBe(false);
111+
expect(result.start.isCertain("hour")).toBe(false);
112+
});
113+
114+
// next year
115+
testSingleCase(chrono.nl, "volgend jaar", new Date(2020, 11 - 1, 22, 12, 11, 32, 6), (result, text) => {
116+
expect(result.text).toBe(text);
117+
expect(result.start.get("year")).toBe(2021);
118+
expect(result.start.get("month")).toBe(11);
119+
expect(result.start.get("day")).toBe(22);
120+
expect(result.start.get("hour")).toBe(12);
121+
expect(result.start.get("minute")).toBe(11);
122+
expect(result.start.get("second")).toBe(32);
123+
expect(result.start.get("millisecond")).toBe(6);
124+
125+
expect(result.start.isCertain("year")).toBe(true);
126+
expect(result.start.isCertain("month")).toBe(false);
127+
expect(result.start.isCertain("day")).toBe(false);
128+
expect(result.start.isCertain("hour")).toBe(false);
129+
expect(result.start.isCertain("minute")).toBe(false);
130+
expect(result.start.isCertain("second")).toBe(false);
131+
expect(result.start.isCertain("millisecond")).toBe(false);
132+
expect(result.start.isCertain("timezoneOffset")).toBe(false);
133+
});
134+
});
135+
136+
test("Test - Relative date components' certainty", () => {
137+
const refDate = new Date(2016, 10 - 1, 7, 12);
138+
139+
// next hour
140+
testSingleCase(chrono.nl, "komende uur", refDate, (result, text) => {
141+
expect(result.text).toBe(text);
142+
expect(result.start.get("year")).toBe(2016);
143+
expect(result.start.get("month")).toBe(10);
144+
expect(result.start.get("day")).toBe(7);
145+
expect(result.start.get("hour")).toBe(13);
146+
expect(result.start.get("timezoneOffset")).toBe(refDate.getTimezoneOffset() * -1);
147+
148+
expect(result.start.isCertain("year")).toBe(true);
149+
expect(result.start.isCertain("month")).toBe(true);
150+
expect(result.start.isCertain("day")).toBe(true);
151+
expect(result.start.isCertain("hour")).toBe(true);
152+
expect(result.start.isCertain("timezoneOffset")).toBe(true);
153+
});
154+
155+
// next month
156+
testSingleCase(chrono.nl, "volgende maand", refDate, (result, text) => {
157+
const expectedDate = new Date(2016, 11, 7, 12);
158+
159+
expect(result.text).toBe(text);
160+
expect(result.start.get("year")).toBe(2016);
161+
expect(result.start.get("month")).toBe(11);
162+
expect(result.start.get("day")).toBe(7);
163+
expect(result.start.get("hour")).toBe(12);
164+
expect(result.start.get("timezoneOffset")).toBe(-expectedDate.getTimezoneOffset());
165+
166+
expect(result.start.isCertain("year")).toBe(true);
167+
expect(result.start.isCertain("month")).toBe(true);
168+
expect(result.start.isCertain("day")).toBe(false);
169+
expect(result.start.isCertain("hour")).toBe(false);
170+
expect(result.start.isCertain("timezoneOffset")).toBe(false);
171+
});
172+
});
173+
174+
test("Test - Relative date components' certainty and imply timezone", () => {
175+
const refDate = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
176+
177+
{
178+
// now
179+
const text = "nu";
180+
const result = chrono.nl.parse(text, refDate)[0] as ParsingResult;
181+
182+
expect(result.text).toBe(text);
183+
result.start.imply("timezoneOffset", 60);
184+
185+
expect(result).toBeDate(new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)"));
186+
expect(result).toBeDate(new Date("Sun Nov 29 2020 5:24:13 GMT+0100"));
187+
}
188+
189+
{
190+
// tomorrow at 5pm
191+
const text = "morgen om 17 uur";
192+
const result = chrono.nl.parse(text, refDate)[0] as ParsingResult;
193+
194+
expect(result.text).toBe(text);
195+
result.start.imply("timezoneOffset", 60);
196+
197+
expect(result).toBeDate(new Date("Sun Dec 1 2020 1:00:00 GMT+0900 (Japan Standard Time)"));
198+
expect(result).toBeDate(new Date("Sun Nov 30 2020 17:00:00 GMT+0100"));
199+
}
200+
201+
{
202+
// in 10 minutes
203+
const text = "binnen 10 minuten";
204+
const result = chrono.nl.parse(text, refDate)[0] as ParsingResult;
205+
206+
expect(result.text).toBe(text);
207+
result.start.imply("timezoneOffset", 60);
208+
209+
expect(result).toBeDate(new Date("Sun Nov 29 2020 13:34:13 GMT+0900 (Japan Standard Time)"));
210+
expect(result).toBeDate(new Date("Sun Nov 29 2020 5:34:13 GMT+0100"));
211+
}
212+
});

‎test/nl/nl_time_units_ago.test.ts

+243
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,243 @@
1+
import * as chrono from "../../src/";
2+
import { testSingleCase, testUnexpectedResult } from "../test_util";
3+
4+
test("Test - Single Expression", function () {
5+
// 5 days ago, we did something
6+
testSingleCase(chrono.nl, "5 dagen geleden, hebben we wat gedaan", new Date(2012, 7, 10), (result) => {
7+
expect(result.start).not.toBeNull();
8+
expect(result.start.get("year")).toBe(2012);
9+
expect(result.start.get("month")).toBe(8);
10+
expect(result.start.get("day")).toBe(5);
11+
12+
expect(result.index).toBe(0);
13+
expect(result.text).toBe("5 dagen geleden");
14+
15+
expect(result.start).toBeDate(new Date(2012, 8 - 1, 5));
16+
});
17+
18+
// 10 days ago, we did something
19+
testSingleCase(chrono.nl, "10 dagen geleden, hebben we wat gedaan", new Date(2012, 7, 10), (result) => {
20+
expect(result.start).not.toBeNull();
21+
expect(result.start.get("year")).toBe(2012);
22+
expect(result.start.get("month")).toBe(7);
23+
expect(result.start.get("day")).toBe(31);
24+
25+
expect(result.index).toBe(0);
26+
expect(result.text).toBe("10 dagen geleden");
27+
28+
expect(result.start).toBeDate(new Date(2012, 7 - 1, 31));
29+
});
30+
31+
// 15 minute ago
32+
testSingleCase(chrono.nl, "15 minuten geleden", new Date(2012, 7, 10, 12, 14), (result) => {
33+
expect(result.index).toBe(0);
34+
expect(result.text).toBe("15 minuten geleden");
35+
expect(result.start.get("hour")).toBe(11);
36+
expect(result.start.get("minute")).toBe(59);
37+
38+
expect(result.start).toBeDate(new Date(2012, 7, 10, 11, 59));
39+
});
40+
41+
// 15 minute earlier
42+
testSingleCase(chrono.nl, "15 minuten eerder", new Date(2012, 7, 10, 12, 14), (result) => {
43+
expect(result.index).toBe(0);
44+
expect(result.text).toBe("15 minuten eerder");
45+
expect(result.start.get("hour")).toBe(11);
46+
expect(result.start.get("minute")).toBe(59);
47+
48+
expect(result.start).toBeDate(new Date(2012, 7, 10, 11, 59));
49+
});
50+
51+
// 15 minute before
52+
testSingleCase(chrono.nl, "15 minuten voor", new Date(2012, 7, 10, 12, 14), (result) => {
53+
expect(result.index).toBe(0);
54+
expect(result.text).toBe("15 minuten voor");
55+
expect(result.start.get("hour")).toBe(11);
56+
expect(result.start.get("minute")).toBe(59);
57+
58+
expect(result.start).toBeDate(new Date(2012, 7, 10, 11, 59));
59+
});
60+
61+
// 12 hours ago
62+
testSingleCase(chrono.nl, " 12 uur geleden", new Date(2012, 7, 10, 12, 14), (result) => {
63+
expect(result.index).toBe(3);
64+
expect(result.text).toBe("12 uur geleden");
65+
expect(result.start.get("hour")).toBe(0);
66+
expect(result.start.get("minute")).toBe(14);
67+
68+
expect(result.start).toBeDate(new Date(2012, 7, 10, 0, 14));
69+
});
70+
71+
// 1h ago
72+
testSingleCase(chrono.nl, "1u geleden", new Date(2012, 7, 10, 12, 14), (result) => {
73+
expect(result.index).toBe(0);
74+
expect(result.text).toBe("1u geleden");
75+
expect(result.start.get("hour")).toBe(11);
76+
expect(result.start.get("minute")).toBe(14);
77+
});
78+
79+
// half an hour ago
80+
testSingleCase(chrono.nl, " half uur geleden", new Date(2012, 7, 10, 12, 14), (result) => {
81+
expect(result.index).toBe(3);
82+
expect(result.text).toBe("half uur geleden");
83+
expect(result.start.get("hour")).toBe(11);
84+
expect(result.start.get("minute")).toBe(44);
85+
86+
expect(result.start).toBeDate(new Date(2012, 7, 10, 11, 44));
87+
});
88+
89+
// 12 hours ago I did something
90+
testSingleCase(chrono.nl, "12 uur geleden deed ik iets", new Date(2012, 7, 10, 12, 14), (result) => {
91+
expect(result.index).toBe(0);
92+
expect(result.text).toBe("12 uur geleden");
93+
expect(result.start.get("hour")).toBe(0);
94+
expect(result.start.get("minute")).toBe(14);
95+
96+
expect(result.start).toBeDate(new Date(2012, 7, 10, 0, 14));
97+
});
98+
99+
// 12 seconds ago I did something
100+
testSingleCase(chrono.nl, "12 seconden geleden deed ik iets", new Date(2012, 7, 10, 12, 14), (result) => {
101+
expect(result.index).toBe(0);
102+
expect(result.text).toBe("12 seconden geleden");
103+
expect(result.start.get("hour")).toBe(12);
104+
expect(result.start.get("minute")).toBe(13);
105+
expect(result.start.get("second")).toBe(48);
106+
107+
expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 13, 48));
108+
});
109+
110+
// three seconds ago I did something
111+
testSingleCase(chrono.nl, "drie seconden geleden deed ik iets", new Date(2012, 7, 10, 12, 14), (result) => {
112+
expect(result.index).toBe(0);
113+
expect(result.text).toBe("drie seconden geleden");
114+
expect(result.start.get("hour")).toBe(12);
115+
expect(result.start.get("minute")).toBe(13);
116+
expect(result.start.get("second")).toBe(57);
117+
118+
expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 13, 57));
119+
});
120+
121+
// 5 Days ago, we did something
122+
testSingleCase(chrono.nl, "5 dagen geleden, hebben we iets gedaan", new Date(2012, 7, 10), (result) => {
123+
expect(result.start).not.toBeNull();
124+
expect(result.start.get("year")).toBe(2012);
125+
expect(result.start.get("month")).toBe(8);
126+
expect(result.start.get("day")).toBe(5);
127+
128+
expect(result.index).toBe(0);
129+
expect(result.text).toBe("5 dagen geleden");
130+
131+
expect(result.start).toBeDate(new Date(2012, 8 - 1, 5));
132+
});
133+
134+
// A days ago, we did something
135+
testSingleCase(chrono.nl, "Een dag geleden, hebben we wat gedaan", new Date(2012, 7, 10), (result) => {
136+
expect(result.start).not.toBeNull();
137+
expect(result.start.get("year")).toBe(2012);
138+
expect(result.start.get("month")).toBe(8);
139+
expect(result.start.get("day")).toBe(9);
140+
141+
expect(result.index).toBe(0);
142+
expect(result.text).toBe("Een dag geleden");
143+
144+
expect(result.start).toBeDate(new Date(2012, 8 - 1, 9));
145+
});
146+
147+
// a min before
148+
testSingleCase(chrono.nl, "een minuut geleden", new Date(2012, 7, 10, 12, 14), (result) => {
149+
expect(result.index).toBe(0);
150+
expect(result.text).toBe("een minuut geleden");
151+
expect(result.start.get("hour")).toBe(12);
152+
expect(result.start.get("minute")).toBe(13);
153+
154+
expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 13));
155+
});
156+
});
157+
158+
test("Test - Single Expression (Casual)", function () {
159+
// 5 months ago, we did something
160+
testSingleCase(chrono.nl, "5 maanden geleden, hebben we iets gedaan", new Date(2012, 8 - 1, 10), (result) => {
161+
expect(result.start).not.toBeNull();
162+
expect(result.start.get("year")).toBe(2012);
163+
expect(result.start.get("month")).toBe(3);
164+
expect(result.start.get("day")).toBe(10);
165+
166+
expect(result.index).toBe(0);
167+
expect(result.text).toBe("5 maanden geleden");
168+
169+
expect(result.start).toBeDate(new Date(2012, 3 - 1, 10));
170+
});
171+
172+
// 5 years ago, we did something
173+
testSingleCase(chrono.nl, "5 jaar geleden, hebben we iets gedaan", new Date(2012, 8 - 1, 10), (result) => {
174+
expect(result.start).not.toBeNull();
175+
expect(result.start.get("year")).toBe(2007);
176+
expect(result.start.get("month")).toBe(8);
177+
expect(result.start.get("day")).toBe(10);
178+
179+
expect(result.index).toBe(0);
180+
expect(result.text).toBe("5 jaar geleden");
181+
182+
expect(result.start).toBeDate(new Date(2007, 8 - 1, 10));
183+
});
184+
185+
// a week ago, we did something
186+
testSingleCase(chrono.nl, "een week geleden, hebben we iets gedaan", new Date(2012, 8 - 1, 3), (result) => {
187+
expect(result.start).not.toBeNull();
188+
expect(result.start.get("year")).toBe(2012);
189+
expect(result.start.get("month")).toBe(7);
190+
expect(result.start.get("day")).toBe(27);
191+
192+
expect(result.index).toBe(0);
193+
expect(result.text).toBe("een week geleden");
194+
195+
expect(result.start).toBeDate(new Date(2012, 7 - 1, 27));
196+
});
197+
198+
// a couple of days ago, we did something
199+
testSingleCase(chrono.nl, "paar dagen geleden, hebben we iets gedaan", new Date(2012, 8 - 1, 2), (result) => {
200+
expect(result.start).not.toBeNull();
201+
expect(result.start.get("year")).toBe(2012);
202+
expect(result.start.get("month")).toBe(7);
203+
expect(result.start.get("day")).toBe(31);
204+
205+
expect(result.index).toBe(0);
206+
expect(result.text).toBe("paar dagen geleden");
207+
208+
expect(result.start).toBeDate(new Date(2012, 7 - 1, 31));
209+
});
210+
});
211+
212+
test("Test - Nested time ago", function () {
213+
// 15 hours 29 min ago
214+
testSingleCase(chrono.nl, "15 uur 29 minuten geleden", new Date(2012, 7, 10, 22, 30), (result) => {
215+
expect(result.text).toBe("15 uur 29 minuten geleden");
216+
expect(result.start.get("day")).toBe(10);
217+
expect(result.start.get("hour")).toBe(7);
218+
expect(result.start.get("minute")).toBe(1);
219+
});
220+
221+
// 1 day 21 hours ago
222+
testSingleCase(chrono.nl, "1 dag 21 uur geleden ", new Date(2012, 7, 10, 22, 30), (result) => {
223+
expect(result.text).toBe("1 dag 21 uur geleden");
224+
expect(result.start.get("day")).toBe(9);
225+
expect(result.start.get("hour")).toBe(1);
226+
expect(result.start.get("minute")).toBe(30);
227+
});
228+
229+
// 3 min 49 sec ago
230+
testSingleCase(chrono.nl, "3 min 49 sec geleden ", new Date(2012, 7, 10, 22, 30), (result) => {
231+
expect(result.text).toBe("3 min 49 sec geleden");
232+
expect(result.start.get("day")).toBe(10);
233+
expect(result.start.get("hour")).toBe(22);
234+
expect(result.start.get("minute")).toBe(26);
235+
expect(result.start.get("second")).toBe(11);
236+
});
237+
});
238+
239+
test("Test - Negative cases", function () {
240+
testUnexpectedResult(chrono, "15 uur 29 min");
241+
testUnexpectedResult(chrono, "een paar uur");
242+
testUnexpectedResult(chrono, "5 dagen");
243+
});

‎test/nl/nl_time_units_casual_relative.test.ts

+130
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,130 @@
1+
import * as chrono from "../../src";
2+
import { testSingleCase } from "../test_util";
3+
4+
test("Test - Positive time units", () => {
5+
// next 2 weeks
6+
testSingleCase(chrono.nl, "komende 2 weken", new Date(2016, 10 - 1, 1, 12), (result, text) => {
7+
expect(result.text).toBe(text);
8+
expect(result.start.get("year")).toBe(2016);
9+
expect(result.start.get("month")).toBe(10);
10+
expect(result.start.get("day")).toBe(15);
11+
});
12+
13+
// next 2 days
14+
testSingleCase(chrono.nl, "komende 2 dagen", new Date(2016, 10 - 1, 1, 12), (result, text) => {
15+
expect(result.text).toBe(text);
16+
expect(result.start.get("year")).toBe(2016);
17+
expect(result.start.get("month")).toBe(10);
18+
expect(result.start.get("day")).toBe(3);
19+
expect(result.start.get("hour")).toBe(12);
20+
});
21+
22+
// next two years
23+
testSingleCase(chrono.nl, "komende 2 jaar", new Date(2016, 10 - 1, 1, 12), (result, text) => {
24+
expect(result.text).toBe(text);
25+
expect(result.start.get("year")).toBe(2018);
26+
expect(result.start.get("month")).toBe(10);
27+
expect(result.start.get("day")).toBe(1);
28+
expect(result.start.get("hour")).toBe(12);
29+
});
30+
31+
// next 2 weeks 3 days
32+
testSingleCase(chrono.nl, "komende 2 weken 3 dagen", new Date(2016, 10 - 1, 1, 12), (result, text) => {
33+
expect(result.text).toBe(text);
34+
expect(result.start.get("year")).toBe(2016);
35+
expect(result.start.get("month")).toBe(10);
36+
expect(result.start.get("day")).toBe(18);
37+
expect(result.start.get("hour")).toBe(12);
38+
});
39+
});
40+
41+
test("Test - Negative time units", () => {
42+
// last 2 weeks
43+
testSingleCase(chrono.nl, "afgelopen 2 weken", new Date(2016, 10 - 1, 1, 12), (result, text) => {
44+
expect(result.text).toBe(text);
45+
expect(result.start.get("year")).toBe(2016);
46+
expect(result.start.get("month")).toBe(9);
47+
expect(result.start.get("day")).toBe(17);
48+
expect(result.start.get("hour")).toBe(12);
49+
});
50+
51+
// last two weeks
52+
testSingleCase(chrono.nl, "afgelopen twee weken", new Date(2016, 10 - 1, 1, 12), (result, text) => {
53+
expect(result.text).toBe(text);
54+
expect(result.start.get("year")).toBe(2016);
55+
expect(result.start.get("month")).toBe(9);
56+
expect(result.start.get("day")).toBe(17);
57+
expect(result.start.get("hour")).toBe(12);
58+
});
59+
60+
// past 2 days
61+
testSingleCase(chrono.nl, "afgelopen 2 dagen", new Date(2016, 10 - 1, 1, 12), (result, text) => {
62+
expect(result.text).toBe(text);
63+
expect(result.start.get("year")).toBe(2016);
64+
expect(result.start.get("month")).toBe(9);
65+
expect(result.start.get("day")).toBe(29);
66+
expect(result.start.get("hour")).toBe(12);
67+
});
68+
69+
// +2 months, 5 days
70+
testSingleCase(chrono.nl, "+2 maanden 5 dagen", new Date(2016, 10 - 1, 1, 12), (result, text) => {
71+
expect(result.text).toBe(text);
72+
expect(result.start.get("year")).toBe(2016);
73+
expect(result.start.get("month")).toBe(12);
74+
expect(result.start.get("day")).toBe(6);
75+
expect(result.start.get("hour")).toBe(12);
76+
});
77+
});
78+
79+
test("Test - Plus '+' sign", () => {
80+
//+15 minutes
81+
testSingleCase(chrono.nl.casual, "+15 minuten", new Date(2012, 7 - 1, 10, 12, 14), (result, text) => {
82+
expect(result.text).toBe(text);
83+
expect(result.start.get("hour")).toBe(12);
84+
expect(result.start.get("minute")).toBe(29);
85+
86+
expect(result.start).toBeDate(new Date(2012, 7 - 1, 10, 12, 29));
87+
});
88+
89+
testSingleCase(chrono.nl.casual, "+15min", new Date(2012, 7 - 1, 10, 12, 14), (result, text) => {
90+
expect(result.text).toBe(text);
91+
expect(result.start.get("hour")).toBe(12);
92+
expect(result.start.get("minute")).toBe(29);
93+
94+
expect(result.start).toBeDate(new Date(2012, 7 - 1, 10, 12, 29));
95+
});
96+
97+
// +1 day 2 hour
98+
testSingleCase(chrono.nl.casual, "+1 dag 2 uur", new Date(2012, 7 - 1, 10, 12, 14), (result, text) => {
99+
expect(result.text).toBe(text);
100+
expect(result.start.get("day")).toBe(11);
101+
expect(result.start.get("hour")).toBe(14);
102+
expect(result.start.get("minute")).toBe(14);
103+
104+
expect(result.start).toBeDate(new Date(2012, 7 - 1, 11, 14, 14));
105+
});
106+
});
107+
108+
test("Test - Minus '-' sign", () => {
109+
// -3y
110+
testSingleCase(chrono.nl.casual, "-3jr", new Date(2015, 7 - 1, 10, 12, 14), (result, text) => {
111+
expect(result.text).toBe(text);
112+
expect(result.start.get("year")).toBe(2012);
113+
expect(result.start.get("month")).toBe(7);
114+
expect(result.start.get("day")).toBe(10);
115+
expect(result.start.get("hour")).toBe(12);
116+
expect(result.start.get("minute")).toBe(14);
117+
118+
expect(result.start).toBeDate(new Date(2012, 7 - 1, 10, 12, 14));
119+
});
120+
121+
// -2hr5min
122+
testSingleCase(chrono.nl, "-2u5min", new Date(2016, 10 - 1, 1, 12), (result, text) => {
123+
expect(result.text).toBe(text);
124+
expect(result.start.get("year")).toBe(2016);
125+
expect(result.start.get("month")).toBe(10);
126+
expect(result.start.get("day")).toBe(1);
127+
expect(result.start.get("hour")).toBe(9);
128+
expect(result.start.get("minute")).toBe(55);
129+
});
130+
});

‎test/nl/nl_time_units_later.test.ts

+250
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,250 @@
1+
import * as chrono from "../../src/";
2+
import { testSingleCase } from "../test_util";
3+
4+
test("Test - Later Expression", function () {
5+
// 2 days later
6+
testSingleCase(chrono.nl, "2 dagen later", new Date(2012, 7, 10, 12), (result) => {
7+
expect(result.start).not.toBeNull();
8+
expect(result.start.get("year")).toBe(2012);
9+
expect(result.start.get("month")).toBe(8);
10+
expect(result.start.get("day")).toBe(12);
11+
12+
expect(result.index).toBe(0);
13+
expect(result.text).toBe("2 dagen later");
14+
15+
expect(result.start.isCertain("day")).toBe(true);
16+
expect(result.start.isCertain("month")).toBe(true);
17+
18+
expect(result.start).toBeDate(new Date(2012, 8 - 1, 12, 12));
19+
});
20+
21+
// 5 minutes later
22+
testSingleCase(chrono.nl, "5 minuten later", new Date(2012, 7, 10, 10, 0), (result) => {
23+
expect(result.start).not.toBeNull();
24+
expect(result.start.get("year")).toBe(2012);
25+
expect(result.start.get("month")).toBe(8);
26+
expect(result.start.get("day")).toBe(10);
27+
expect(result.start.get("hour")).toBe(10);
28+
expect(result.start.get("minute")).toBe(5);
29+
30+
expect(result.index).toBe(0);
31+
expect(result.text).toBe("5 minuten later");
32+
33+
expect(result.start.isCertain("hour")).toBe(true);
34+
expect(result.start.isCertain("minute")).toBe(true);
35+
36+
expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 10, 5));
37+
});
38+
39+
// 3 week later
40+
testSingleCase(chrono.nl, "3 weken later", new Date(2012, 7 - 1, 10, 10, 0), (result) => {
41+
expect(result.start).not.toBeNull();
42+
expect(result.start.get("year")).toBe(2012);
43+
expect(result.start.get("month")).toBe(7);
44+
expect(result.start.get("day")).toBe(31);
45+
46+
expect(result.index).toBe(0);
47+
expect(result.text).toBe("3 weken later");
48+
49+
expect(result.start).toBeDate(new Date(2012, 7 - 1, 31, 10, 0));
50+
});
51+
});
52+
53+
test("Test - From now Expression", () => {
54+
// 5 days from now, we did something
55+
testSingleCase(chrono.nl, "5 dagen vanaf nu we hebben iets gedaan", new Date(2012, 7, 10), (result) => {
56+
expect(result.start).not.toBeNull();
57+
expect(result.start.get("year")).toBe(2012);
58+
expect(result.start.get("month")).toBe(8);
59+
expect(result.start.get("day")).toBe(15);
60+
61+
expect(result.index).toBe(0);
62+
expect(result.text).toBe("5 dagen vanaf nu");
63+
64+
expect(result.start).toBeDate(new Date(2012, 8 - 1, 15));
65+
});
66+
67+
// 10 days from now, we did something
68+
testSingleCase(chrono.nl, "10 dagen vanaf nu we hebben iets gedaan", new Date(2012, 7, 10), (result) => {
69+
expect(result.start).not.toBeNull();
70+
expect(result.start.get("year")).toBe(2012);
71+
expect(result.start.get("month")).toBe(8);
72+
expect(result.start.get("day")).toBe(20);
73+
74+
expect(result.index).toBe(0);
75+
expect(result.text).toBe("10 dagen vanaf nu");
76+
77+
expect(result.start).toBeDate(new Date(2012, 8 - 1, 20));
78+
});
79+
80+
// 15 minute from now
81+
testSingleCase(chrono.nl, "15 minuten vanaf nu", new Date(2012, 7, 10, 12, 14), (result) => {
82+
expect(result.index).toBe(0);
83+
expect(result.text).toBe("15 minuten vanaf nu");
84+
expect(result.start.get("hour")).toBe(12);
85+
expect(result.start.get("minute")).toBe(29);
86+
87+
expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 29));
88+
});
89+
90+
// 15 minutes earlier
91+
testSingleCase(chrono.nl, "15 minuten eerder", new Date(2012, 7, 10, 12, 14), (result) => {
92+
expect(result.index).toBe(0);
93+
expect(result.text).toBe("15 minuten eerder");
94+
expect(result.start.get("hour")).toBe(11);
95+
expect(result.start.get("minute")).toBe(59);
96+
97+
expect(result.start).toBeDate(new Date(2012, 7, 10, 11, 59));
98+
});
99+
100+
// 15 minute out
101+
testSingleCase(chrono.nl, "15 minuten uit", new Date(2012, 7, 10, 12, 14), (result) => {
102+
expect(result.index).toBe(0);
103+
expect(result.text).toBe("15 minuten uit");
104+
expect(result.start.get("hour")).toBe(12);
105+
expect(result.start.get("minute")).toBe(29);
106+
107+
expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 29));
108+
});
109+
110+
// 12 hours from now
111+
testSingleCase(chrono.nl, " 12 uur vanaf nu", new Date(2012, 7, 10, 12, 14), (result) => {
112+
expect(result.index).toBe(3);
113+
expect(result.text).toBe("12 uur vanaf nu");
114+
expect(result.start.get("day")).toBe(11);
115+
expect(result.start.get("hour")).toBe(0);
116+
expect(result.start.get("minute")).toBe(14);
117+
118+
expect(result.start).toBeDate(new Date(2012, 7, 11, 0, 14));
119+
});
120+
121+
// half an hour from now
122+
testSingleCase(chrono.nl, " half uur vanaf nu", new Date(2012, 7, 10, 12, 14), (result) => {
123+
expect(result.text).toBe("half uur vanaf nu");
124+
expect(result.index).toBe(3);
125+
expect(result.start.get("hour")).toBe(12);
126+
expect(result.start.get("minute")).toBe(44);
127+
128+
expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 44));
129+
});
130+
131+
// 12 hours from now I did something
132+
testSingleCase(chrono.nl, "Over 12 uur heb ik iets gedaan", new Date(2012, 7, 10, 12, 14), (result) => {
133+
expect(result.index).toBe(0);
134+
expect(result.text).toBe("Over 12 uur");
135+
expect(result.start.get("day")).toBe(11);
136+
expect(result.start.get("hour")).toBe(0);
137+
expect(result.start.get("minute")).toBe(14);
138+
139+
expect(result.start).toBeDate(new Date(2012, 7, 11, 0, 14));
140+
});
141+
142+
// 12 seconds from now I did something
143+
testSingleCase(chrono.nl, "Over 12 seconden heb ik iets gedaan", new Date(2012, 7, 10, 12, 14), (result) => {
144+
expect(result.index).toBe(0);
145+
expect(result.text).toBe("Over 12 seconden");
146+
expect(result.start.get("hour")).toBe(12);
147+
expect(result.start.get("minute")).toBe(14);
148+
expect(result.start.get("second")).toBe(12);
149+
150+
expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 14, 12));
151+
});
152+
153+
// three seconds from now I did something
154+
testSingleCase(chrono.nl, "over drie seconden heb ik iets gedaan", new Date(2012, 7, 10, 12, 14), (result) => {
155+
expect(result.index).toBe(0);
156+
expect(result.text).toBe("over drie seconden");
157+
expect(result.start.get("hour")).toBe(12);
158+
expect(result.start.get("minute")).toBe(14);
159+
expect(result.start.get("second")).toBe(3);
160+
161+
expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 14, 3));
162+
});
163+
164+
// 5 Days from now, we did something
165+
testSingleCase(chrono.nl, "Over 5 dagen hebben we iets gedaan", new Date(2012, 7, 10), (result) => {
166+
expect(result.start).not.toBeNull();
167+
expect(result.start.get("year")).toBe(2012);
168+
expect(result.start.get("month")).toBe(8);
169+
expect(result.start.get("day")).toBe(15);
170+
171+
expect(result.index).toBe(0);
172+
expect(result.text).toBe("Over 5 dagen");
173+
174+
expect(result.start).toBeDate(new Date(2012, 8 - 1, 15));
175+
});
176+
177+
// half An hour from now
178+
testSingleCase(chrono.nl, " half uur vanaf nu", new Date(2012, 7, 10, 12, 14), (result) => {
179+
expect(result.index).toBe(3);
180+
expect(result.text).toBe("half uur vanaf nu");
181+
expect(result.start.get("hour")).toBe(12);
182+
expect(result.start.get("minute")).toBe(44);
183+
184+
expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 44));
185+
});
186+
187+
// A days from now, we did something
188+
testSingleCase(chrono.nl, "Over een dag hebben we iets gedaan", new Date(2012, 7, 10), (result) => {
189+
expect(result.start).not.toBeNull();
190+
expect(result.start.get("year")).toBe(2012);
191+
expect(result.start.get("month")).toBe(8);
192+
expect(result.start.get("day")).toBe(11);
193+
194+
expect(result.index).toBe(0);
195+
expect(result.text).toBe("Over een dag");
196+
197+
expect(result.start).toBeDate(new Date(2012, 8 - 1, 11));
198+
});
199+
200+
// a min out
201+
testSingleCase(chrono.nl, "een minuutje uit", new Date(2012, 7, 10, 12, 14), (result) => {
202+
expect(result.index).toBe(0);
203+
expect(result.text).toBe("een minuutje uit");
204+
expect(result.start.get("hour")).toBe(12);
205+
expect(result.start.get("minute")).toBe(15);
206+
207+
expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 15));
208+
});
209+
210+
// in 1 hour
211+
testSingleCase(chrono.nl, "in 1 uur", new Date(2012, 7, 10, 12, 14), (result) => {
212+
expect(result.index).toBe(0);
213+
expect(result.text).toBe("in 1 uur");
214+
expect(result.start.get("hour")).toBe(13);
215+
expect(result.start.get("minute")).toBe(14);
216+
217+
expect(result.start).toBeDate(new Date(2012, 7, 10, 13, 14));
218+
});
219+
220+
// in 1.5 hours
221+
testSingleCase(chrono.nl, "over 1,5 uur", new Date(2012, 7, 10, 12, 40), (result) => {
222+
expect(result.index).toBe(0);
223+
expect(result.text).toBe("over 1,5 uur");
224+
expect(result.start.get("hour")).toBe(14);
225+
expect(result.start.get("minute")).toBe(10);
226+
227+
expect(result.start).toBeDate(new Date(2012, 7, 10, 14, 10));
228+
});
229+
});
230+
231+
test("Test - Strict mode", function () {
232+
// 15 minutes from now
233+
testSingleCase(chrono.nl.strict, "15 minuten vanaf nu", new Date(2012, 7, 10, 12, 14), (result, text) => {
234+
expect(result.text).toBe(text);
235+
expect(result.start.get("hour")).toBe(12);
236+
expect(result.start.get("minute")).toBe(29);
237+
238+
expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 29));
239+
});
240+
241+
// 25 minutes later
242+
testSingleCase(chrono.nl.strict, "25 minuten later", new Date(2012, 7, 10, 12, 40), (result) => {
243+
expect(result.index).toBe(0);
244+
expect(result.text).toBe("25 minuten later");
245+
expect(result.start.get("hour")).toBe(13);
246+
expect(result.start.get("minute")).toBe(5);
247+
248+
expect(result.start).toBeDate(new Date(2012, 7, 10, 13, 5));
249+
});
250+
});

0 commit comments

Comments
 (0)
Please sign in to comment.