Refactor typescript interfaces and publishing files

.gitignore

@@ -1,4 +1,5 @@
 # Node Modules
+dist/
 node_modules/*
 package-lock.json
 

README.md

@@ -172,7 +172,7 @@ Chrono’s extraction pipeline configuration consists of `parsers: Parser[]` and
 interface Parser {
     pattern: (context: ParsingContext) => RegExp,
     extract: (context: ParsingContext, match: RegExpMatchArray) =>
-        (ParsingComponents | ParsingResult | {[c: Component]: string|number} | null)
+        (ParsingComponents | ParsingResult | {[c in Component]?: number} | null)
 }
 ```
 

package.json

@@ -8,69 +8,28 @@
   },
   "jest": {
     "verbose": true,
-    "testURL": "http://localhost/"
+    "testURL": "http://localhost/",
+    "preset": "ts-jest"
   },
   "license": "MIT",
   "version": "2.0.3",
   "directories": {
     "source": "./src",
     "test": "./test"
   },
-  "main": "./dist/chrono.js",
-  "babel": {
-    "presets": [
-      "@babel/preset-env",
-      "@babel/preset-typescript"
-    ],
-    "plugins": [
-      "@babel/plugin-proposal-export-namespace-from"
-    ]
-  },
-  "eslintConfig": {
-    "ignorePatterns": [
-      "webpack.config.js",
-      "dist/*.js"
-    ],
-    "parser": "@typescript-eslint/parser",
-    "plugins": [
-      "@typescript-eslint",
-      "jest"
-    ],
-    "extends": [
-      "eslint:recommended",
-      "plugin:@typescript-eslint/recommended",
-      "plugin:jest/recommended"
-    ],
-    "rules": {
-      "@typescript-eslint/explicit-module-boundary-types": "off",
-      "jest/expect-expect": "off"
-    }
-  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "devDependencies": {
-    "@babel/core": "^7.10.4",
-    "@babel/plugin-proposal-export-namespace-from": "^7.10.4",
-    "@babel/preset-env": "^7.10.4",
-    "@babel/preset-typescript": "^7.10.4",
-    "@typescript-eslint/eslint-plugin": "^3.5.0",
-    "@typescript-eslint/parser": "^3.5.0",
-    "babel-jest": "^25.5.1",
-    "babel-loader": "^8.0.6",
-    "coveralls": "^3.1.0",
-    "eslint": "^7.4.0",
-    "eslint-plugin-jest": "^23.18.0",
-    "jest": "^25.5.4",
-    "terser-webpack-plugin": "^2.3.7",
-    "typescript": "^3.9.6",
-    "webpack": "^4.43.0",
-    "webpack-cli": "^3.3.12"
+    "@types/jest": "^26.0.4",
+    "jest": "^26.1.0",
+    "ts-jest": "^26.1.1",
+    "typescript": "^3.9.6"
   },
   "scripts": {
-    "build": "webpack",
+    "build": "tsc -p tsconfig.build.json",
     "watch": "jest --watch",
-    "pretest": "eslint .",
     "test": "jest --coverage",
-    "coveralls": "npm run test && cat coverage/lcov.info | coveralls",
-    "version": "npm run build && git add -A dist"
+    "coveralls": "npm run test && cat coverage/lcov.info | coveralls"
   },
   "dependencies": {
     "dayjs": "^1.8.29"

src/chrono.ts

@@ -9,9 +9,9 @@ export interface Configuration {
 }
 
 export interface Parser {
-    pattern: (context: ParsingContext) => RegExp,
-    extract: (context: ParsingContext, match: RegExpMatchArray) =>
-        (ParsingComponents | ParsingResult | {[c: Component]: string|number} | null)
+    pattern(context: ParsingContext): RegExp,
+    extract(context: ParsingContext, match: RegExpMatchArray):
+        (ParsingComponents | ParsingResult | {[c in Component]?: number} | null)
 }
 
 export interface Refiner {
@@ -28,7 +28,7 @@ export class Chrono {
         this.refiners = [...configuration.refiners];
     }
 
-    parseDate(text, refDate, opt): Date {
+    parseDate(text, refDate?, opt?): Date {
         const results = this.parse(text, refDate, opt);
         return (results.length > 0) ? results[0].start.date() : null;
     }
@@ -113,14 +113,14 @@ export class ParsingContext implements DebugHandler {
         readonly option: ParsingOption
     ) {}
 
-    createParsingComponents(components?: {[c: Component]: string|number}) : ParsingComponents {
+    createParsingComponents(components?: {[c in Component]?: number}) : ParsingComponents {
         return new ParsingComponents(this.refDate, components)
     }
 
     createParsingResult(
         index: number, textOrEndIndex: number | string,
-        startComponents?: {[c: Component]: string|number},
-        endComponents?: {[c: Component]: string|number}
+        startComponents?: {[c in Component]?: number},
+        endComponents?: {[c in Component]?: number}
     ) : ParsingResult {
 
         const text = (typeof textOrEndIndex === 'string') ? textOrEndIndex :

src/common/parsers/AbstractParserWithWordBoundary.ts

@@ -0,0 +1,27 @@
+import {Parser, ParsingContext} from "../../chrono";
+import {ParsingComponents, ParsingResult} from "../../results";
+import {Component} from "../../index";
+
+export abstract class AbstractParserWithWordBoundaryChecking implements Parser {
+
+    abstract innerPattern(context: ParsingContext): RegExp;
+    abstract innerExtract(context: ParsingContext, match: RegExpMatchArray):
+        (ParsingComponents | ParsingResult | {[c in Component]?: number} | null)
+
+    pattern(context: ParsingContext): RegExp {
+        const innerPattern = this.innerPattern(context);
+        return new RegExp(`(\\W|^)${innerPattern.source}`, innerPattern.flags);
+    }
+
+    extract(context: ParsingContext, match: RegExpMatchArray) {
+        const header = match[1]
+        match.index = match.index + header.length
+        match[0] = match[0].substring(header.length)
+        for (let i=2; i<match.length; i++) {
+            match[i-1] = match[i]
+        }
+
+        return this.innerExtract(context, match)
+    }
+}
+

src/common/parsers/ISOFormatParser.ts

@@ -1,5 +1,6 @@
 import {Parser, ParsingContext} from "../../chrono";
 import {Component} from "../../index";
+import {AbstractParserWithWordBoundaryChecking} from "./AbstractParserWithWordBoundary";
 
 // ISO 8601
 // http://www.w3.org/TR/NOTE-datetime
@@ -27,14 +28,14 @@ const MILLISECOND_NUMBER_GROUP = 7;
 const TZD_HOUR_OFFSET_GROUP = 8;
 const TZD_MINUTE_OFFSET_GROUP = 9;
 
-export default class ISOFormatParser implements Parser {
+export default class ISOFormatParser extends AbstractParserWithWordBoundaryChecking {
 
-    pattern(): RegExp {
+    innerPattern(): RegExp {
         return PATTERN;
     }
 
-    extract(context: ParsingContext, match: RegExpMatchArray) : {[component: Component]: string | number}{
-        const components: {[component: Component]: string | number} = {}
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const components: {[component in Component]?: number} = {}
         components['year'] = parseInt(match[YEAR_NUMBER_GROUP])
         components['month'] = parseInt(match[MONTH_NUMBER_GROUP])
         components['day'] = parseInt(match[DATE_NUMBER_GROUP])

src/configurations.ts

@@ -6,11 +6,10 @@ import OverlapRemovalRefiner from "./common/refiners/OverlapRemovalRefiner";
 import ForwardDateRefiner from "./common/refiners/ForwardDateRefiner";
 import UnlikelyFormatFilter from "./common/refiners/UnlikelyFormatFilter";
 import ISOFormatParser from "./common/parsers/ISOFormatParser";
-import {createParserWithWordBoundaryDetection} from "./utils/ParserWithWordEndingDetection";
 
 export function includeCommonConfiguration(configuration: Configuration): Configuration {
 
-    configuration.parsers.unshift(createParserWithWordBoundaryDetection(new ISOFormatParser()))
+    configuration.parsers.unshift(new ISOFormatParser())
 
     configuration.refiners.unshift(new ExtractTimezoneAbbrRefiner())
     configuration.refiners.unshift(new ExtractTimezoneOffsetRefiner())

src/index.ts

@@ -31,7 +31,8 @@ export interface ParsedResult {
 }
 
 export interface ParsedComponents {
-    readonly get: (c: Component) => number
+    readonly isCertain: (c: Component) => boolean
+    readonly get: (c: Component) => number | undefined
     readonly date: () => Date
 }
 

src/locales/en/constants.ts

@@ -226,7 +226,7 @@ const SINGLE_TIME_UNIT_PATTERN_NO_CAPTURE = SINGLE_TIME_UNIT_PATTERN.replace(/\(
 
 export const TIME_UNITS_PATTERN = `(?:${SINGLE_TIME_UNIT_PATTERN_NO_CAPTURE})+`;
 
-export function parseTimeUnits(timeunitText) : {[c: OpUnitType]: number} {
+export function parseTimeUnits(timeunitText) : {[c in OpUnitType]?: number} {
     const fragments = {};
     let remainingText = timeunitText;
     let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);

src/locales/en/index.ts

@@ -21,7 +21,6 @@ import ENRelativeDateFormatParser from "./parsers/ENRelativeDateFormatParser";
 
 import {ParsedResult, ParsingOption} from "../../index";
 import {Chrono, Configuration} from "../../chrono";
-import {createParserWithWordBoundaryDetection as withWordBoundary} from "../../utils/ParserWithWordEndingDetection";
 
 // Shortcuts
 export const casual = new Chrono(createCasualConfiguration(false))
@@ -39,26 +38,26 @@ export function parseDate(text: string, ref?: Date, option?: ParsingOption) : Da
 
 export function createCasualConfiguration(littleEndian = false) : Configuration {
     const option = createConfiguration(false, littleEndian);
-    option.parsers.unshift(withWordBoundary(new ENCasualDateParser()));
-    option.parsers.unshift(withWordBoundary(new ENCasualTimeParser()));
-    option.parsers.unshift(withWordBoundary(new ENWeekdayParser()));
-    option.parsers.unshift(withWordBoundary(new ENRelativeDateFormatParser()));
+    option.parsers.unshift(new ENCasualDateParser());
+    option.parsers.unshift(new ENCasualTimeParser());
+    option.parsers.unshift(new ENWeekdayParser());
+    option.parsers.unshift(new ENRelativeDateFormatParser());
     return option;
 }
 
 export function createConfiguration(strictMode= true, littleEndian = false) : Configuration {
     return includeCommonConfiguration({
         parsers: [
-            withWordBoundary(new ENTimeUnitDeadlineFormatParser(strictMode)),
-            withWordBoundary(new ENMonthNameLittleEndianParser()),
-            withWordBoundary(new ENMonthNameMiddleEndianParser()),
-            withWordBoundary(new ENMonthNameParser()),
+            new ENTimeUnitDeadlineFormatParser(strictMode),
+            new ENMonthNameLittleEndianParser(),
+            new ENMonthNameMiddleEndianParser(),
+            new ENMonthNameParser(),
             new ENSlashDateFormatParser(littleEndian),
-            withWordBoundary(new ENSlashDateFormatStartWithYearParser()),
-            withWordBoundary(new ENSlashMonthFormatParser()),
+            new ENSlashDateFormatStartWithYearParser(),
+            new ENSlashMonthFormatParser(),
             new ENTimeExpressionParser(),
-            withWordBoundary(new ENTimeUnitAgoFormatParser(strictMode)),
-            withWordBoundary(new ENTimeUnitLaterFormatParser(strictMode)),
+            new ENTimeUnitAgoFormatParser(strictMode),
+            new ENTimeUnitLaterFormatParser(strictMode),
         ],
         refiners: [
             new ENMergeDateTimeRefiner(),

src/locales/en/parsers/ENCasualDateParser.ts

@@ -2,14 +2,15 @@ import {Parser, ParsingContext} from "../../../chrono";
 import {ParsingComponents, ParsingResult} from "../../../results";
 import dayjs from "dayjs";
 import {Meridiem} from "../../../index";
+import {AbstractParserWithWordBoundaryChecking} from "../../../common/parsers/AbstractParserWithWordBoundary";
 
-export default class ENCasualDateParser implements Parser {
+export default class ENCasualDateParser extends AbstractParserWithWordBoundaryChecking {
 
-    pattern(): RegExp {
+    innerPattern(context: ParsingContext): RegExp {
         return /(now|today|tonight|last\s*night|tomorrow|tmr|yesterday)(?=\W|$)/i;
     }
 
-    extract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
 
         let targetDate = dayjs(context.refDate);
         const lowerText = match[0].toLowerCase();

src/locales/en/parsers/ENCasualTimeParser.ts

@@ -1,11 +1,12 @@
 import {Parser, ParsingContext} from "../../../chrono";
 import {Meridiem} from "../../../index";
+import {AbstractParserWithWordBoundaryChecking} from "../../../common/parsers/AbstractParserWithWordBoundary";
 
-export default class ENCasualTimeParser implements Parser {
+export default class ENCasualTimeParser extends AbstractParserWithWordBoundaryChecking {
 
-    pattern() { return /(?:this)?\s*(morning|afternoon|evening|night|noon)(?=\W|$)/i; }
+    innerPattern() { return /(?:this)?\s*(morning|afternoon|evening|night|noon)(?=\W|$)/i; }
 
-    extract(context: ParsingContext, match: RegExpMatchArray) {
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
         const component = context.createParsingComponents()
         switch (match[1].toLowerCase()) {
 

src/locales/en/parsers/ENMonthNameLittleEndianParser.ts

@@ -5,6 +5,7 @@ import {MONTH_DICTIONARY, WEEKDAY_DICTIONARY,} from "../constants";
 import {YEAR_PATTERN, parseYear} from "../constants";
 import {ORDINAL_NUMBER_PATTERN, parseOrdinalNumberPattern} from "../constants";
 import {matchAnyPattern} from "../../../utils/pattern";
+import {AbstractParserWithWordBoundaryChecking} from "../../../common/parsers/AbstractParserWithWordBoundary";
 
 
 const PATTERN = new RegExp(
@@ -30,13 +31,13 @@ const DATE_TO_GROUP = 3;
 const MONTH_NAME_GROUP = 4;
 const YEAR_GROUP = 5;
 
-export default class ENMonthNameLittleEndianParser implements Parser {
+export default class ENMonthNameLittleEndianParser extends AbstractParserWithWordBoundaryChecking {
 
-    pattern(): RegExp {
+    innerPattern(): RegExp {
         return PATTERN;
     }
 
-    extract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {
         //console.log(match)
 
         const result = context.createParsingResult(match.index, match[0]);

src/locales/en/parsers/ENMonthNameMiddleEndianParser.ts

@@ -4,6 +4,7 @@ import {MONTH_DICTIONARY, WEEKDAY_DICTIONARY} from "../constants";
 import {ORDINAL_NUMBER_PATTERN, parseOrdinalNumberPattern} from "../constants";
 import {YEAR_PATTERN, parseYear} from "../constants";
 import {matchAnyPattern} from "../../../utils/pattern";
+import {AbstractParserWithWordBoundaryChecking} from "../../../common/parsers/AbstractParserWithWordBoundary";
 
 const PATTERN = new RegExp(
     '(?:' +
@@ -40,13 +41,13 @@ const YEAR_GROUP = 5;
  *  - January 12.44
  *  - January 1222344
  */
-export default class ENMonthNameMiddleEndianParser implements Parser {
+export default class ENMonthNameMiddleEndianParser extends AbstractParserWithWordBoundaryChecking {
 
-    pattern(): RegExp {
+    innerPattern(): RegExp {
         return PATTERN;
     }
 
-    extract(context: ParsingContext, match: RegExpMatchArray) {
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
 
         const month = MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];
         const day = parseOrdinalNumberPattern(match[DATE_GROUP]);

src/locales/en/parsers/ENMonthNameParser.ts

@@ -3,6 +3,7 @@ import {Parser, ParsingContext} from "../../../chrono";
 import {findYearClosestToRef} from "../../../calculation/yearCalculation";
 import {matchAnyPattern} from "../../../utils/pattern";
 import {YEAR_PATTERN, parseYear} from "../constants";
+import {AbstractParserWithWordBoundaryChecking} from "../../../common/parsers/AbstractParserWithWordBoundary";
 
 const PATTERN = new RegExp(
     `(${matchAnyPattern(MONTH_DICTIONARY)})` +
@@ -21,11 +22,11 @@ const YEAR_GROUP = 2;
  * - January 2012
  * - January
  */
-export default class ENMonthNameParser implements Parser {
+export default class ENMonthNameParser extends AbstractParserWithWordBoundaryChecking {
 
-    pattern(): RegExp {return PATTERN; }
+    innerPattern(): RegExp {return PATTERN; }
 
-    extract(context: ParsingContext, match: RegExpMatchArray) {
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
 
         if (match[0].length <= 3) {
             return null;