chrono-node 2.2.7 → 2.3.3

package/dist/results.d.ts

@@ -1,9 +1,15 @@
-import { Component, ParsedComponents, ParsedResult } from "./index";
+import { Component, ParsedComponents, ParsedResult, ParsingReference } from "./index";
 import dayjs, { OpUnitType, QUnitType } from "dayjs";
+export declare class ReferenceWithTimezone {
+    readonly instant: Date;
+    readonly timezoneOffset?: number;
+    constructor(input?: ParsingReference | Date);
+}
 export declare class ParsingComponents implements ParsedComponents {
     private knownValues;
     private impliedValues;
-    constructor(refDate: Date, knownComponents?: {
+    private reference;
+    constructor(reference: ReferenceWithTimezone, knownComponents?: {
         [c in Component]?: number;
     });
     get(component: Component): number | null;
@@ -22,8 +28,8 @@ export declare class ParsingComponents implements ParsedComponents {
     dayjs(): dayjs.Dayjs;
     date(): Date;
     private dateWithoutTimezoneAdjustment;
-    private getTimezoneAdjustmentMinute;
-    static createRelativeFromRefDate(refDate: Date, fragments: {
+    private getSystemTimezoneAdjustmentMinute;
+    static createRelativeFromReference(reference: ReferenceWithTimezone, fragments: {
         [c in OpUnitType | QUnitType]?: number;
     }): ParsingComponents;
 }
@@ -31,9 +37,10 @@ export declare class ParsingResult implements ParsedResult {
     refDate: Date;
     index: number;
     text: string;
+    reference: ReferenceWithTimezone;
     start: ParsingComponents;
     end?: ParsingComponents;
-    constructor(refDate: Date, index: number, text: string, start?: ParsingComponents, end?: ParsingComponents);
+    constructor(reference: ReferenceWithTimezone, index: number, text: string, start?: ParsingComponents, end?: ParsingComponents);
     clone(): ParsingResult;
     date(): Date;
     toString(): string;

package/dist/results.js

@@ -3,13 +3,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParsingResult = exports.ParsingComponents = void 0;
+exports.ParsingResult = exports.ParsingComponents = exports.ReferenceWithTimezone = void 0;
 const quarterOfYear_1 = __importDefault(require("dayjs/plugin/quarterOfYear"));
 const dayjs_1 = __importDefault(require("dayjs"));
 const dayjs_2 = require("./utils/dayjs");
+const timezone_1 = require("./timezone");
 dayjs_1.default.extend(quarterOfYear_1.default);
+class ReferenceWithTimezone {
+    constructor(input) {
+        var _a;
+        input = input !== null && input !== void 0 ? input : new Date();
+        if (input instanceof Date) {
+            this.instant = input;
+            this.timezoneOffset = -input.getTimezoneOffset();
+        }
+        else {
+            this.instant = (_a = input.instant) !== null && _a !== void 0 ? _a : new Date();
+            this.timezoneOffset = timezone_1.toTimezoneOffset(input.timezone);
+        }
+    }
+}
+exports.ReferenceWithTimezone = ReferenceWithTimezone;
 class ParsingComponents {
-    constructor(refDate, knownComponents) {
+    constructor(reference, knownComponents) {
+        this.reference = reference;
         this.knownValues = {};
         this.impliedValues = {};
         if (knownComponents) {
@@ -17,7 +34,7 @@ class ParsingComponents {
                 this.knownValues[key] = knownComponents[key];
             }
         }
-        const refDayJs = dayjs_1.default(refDate);
+        const refDayJs = dayjs_1.default(reference.instant);
         this.imply("day", refDayJs.date());
         this.imply("month", refDayJs.month() + 1);
         this.imply("year", refDayJs.year());
@@ -58,7 +75,7 @@ class ParsingComponents {
         delete this.impliedValues[component];
     }
     clone() {
-        const component = new ParsingComponents(new Date());
+        const component = new ParsingComponents(this.reference);
         component.knownValues = {};
         component.impliedValues = {};
         for (const key in this.knownValues) {
@@ -82,7 +99,7 @@ class ParsingComponents {
         return this.isCertain("day") && this.isCertain("month") && !this.isCertain("year");
     }
     isValidDate() {
-        const date = this.isCertain("timezoneOffset") ? this.dateWithoutTimezoneAdjustment() : this.date();
+        const date = this.dateWithoutTimezoneAdjustment();
         if (date.getFullYear() !== this.get("year"))
             return false;
         if (date.getMonth() !== this.get("month") - 1)
@@ -103,32 +120,37 @@ class ParsingComponents {
     }
     date() {
         const date = this.dateWithoutTimezoneAdjustment();
-        return new Date(date.getTime() + this.getTimezoneAdjustmentMinute(date) * 60000);
+        return new Date(date.getTime() + this.getSystemTimezoneAdjustmentMinute() * 60000);
     }
     dateWithoutTimezoneAdjustment() {
         const date = new Date(this.get("year"), this.get("month") - 1, this.get("day"), this.get("hour"), this.get("minute"), this.get("second"), this.get("millisecond"));
         date.setFullYear(this.get("year"));
         return date;
     }
-    getTimezoneAdjustmentMinute(date) {
+    getSystemTimezoneAdjustmentMinute() {
         var _a;
-        date = date !== null && date !== void 0 ? date : new Date();
-        const currentTimezoneOffset = -date.getTimezoneOffset();
-        const targetTimezoneOffset = (_a = this.get("timezoneOffset")) !== null && _a !== void 0 ? _a : currentTimezoneOffset;
+        const currentTimezoneOffset = -new Date().getTimezoneOffset();
+        const targetTimezoneOffset = (_a = this.get("timezoneOffset")) !== null && _a !== void 0 ? _a : this.reference.timezoneOffset;
         return currentTimezoneOffset - targetTimezoneOffset;
     }
-    static createRelativeFromRefDate(refDate, fragments) {
-        let date = dayjs_1.default(refDate);
+    static createRelativeFromReference(reference, fragments) {
+        let date = dayjs_1.default(reference.instant);
         for (const key in fragments) {
             date = date.add(fragments[key], key);
         }
-        const components = new ParsingComponents(refDate);
+        const components = new ParsingComponents(reference);
         if (fragments["hour"] || fragments["minute"] || fragments["second"]) {
             dayjs_2.assignSimilarTime(components, date);
             dayjs_2.assignSimilarDate(components, date);
+            if (reference.timezoneOffset !== null) {
+                components.assign("timezoneOffset", -reference.instant.getTimezoneOffset());
+            }
         }
         else {
             dayjs_2.implySimilarTime(components, date);
+            if (reference.timezoneOffset !== null) {
+                components.imply("timezoneOffset", -reference.instant.getTimezoneOffset());
+            }
             if (fragments["d"]) {
                 components.assign("day", date.date());
                 components.assign("month", date.month() + 1);
@@ -159,15 +181,16 @@ class ParsingComponents {
 }
 exports.ParsingComponents = ParsingComponents;
 class ParsingResult {
-    constructor(refDate, index, text, start, end) {
-        this.refDate = refDate;
+    constructor(reference, index, text, start, end) {
+        this.reference = reference;
+        this.refDate = reference.instant;
         this.index = index;
         this.text = text;
-        this.start = start || new ParsingComponents(this.refDate);
+        this.start = start || new ParsingComponents(reference);
         this.end = end;
     }
     clone() {
-        const result = new ParsingResult(this.refDate, this.index, this.text);
+        const result = new ParsingResult(this.reference, this.index, this.text);
         result.start = this.start ? this.start.clone() : null;
         result.end = this.end ? this.end.clone() : null;
         return result;

package/dist/timezone.d.ts

@@ -0,0 +1,194 @@
+export declare const TIMEZONE_ABBR_MAP: {
+    ACDT: number;
+    ACST: number;
+    ADT: number;
+    AEDT: number;
+    AEST: number;
+    AFT: number;
+    AKDT: number;
+    AKST: number;
+    ALMT: number;
+    AMST: number;
+    AMT: number;
+    ANAST: number;
+    ANAT: number;
+    AQTT: number;
+    ART: number;
+    AST: number;
+    AWDT: number;
+    AWST: number;
+    AZOST: number;
+    AZOT: number;
+    AZST: number;
+    AZT: number;
+    BNT: number;
+    BOT: number;
+    BRST: number;
+    BRT: number;
+    BST: number;
+    BTT: number;
+    CAST: number;
+    CAT: number;
+    CCT: number;
+    CDT: number;
+    CEST: number;
+    CET: number;
+    CHADT: number;
+    CHAST: number;
+    CKT: number;
+    CLST: number;
+    CLT: number;
+    COT: number;
+    CST: number;
+    CVT: number;
+    CXT: number;
+    ChST: number;
+    DAVT: number;
+    EASST: number;
+    EAST: number;
+    EAT: number;
+    ECT: number;
+    EDT: number;
+    EEST: number;
+    EET: number;
+    EGST: number;
+    EGT: number;
+    EST: number;
+    ET: number;
+    FJST: number;
+    FJT: number;
+    FKST: number;
+    FKT: number;
+    FNT: number;
+    GALT: number;
+    GAMT: number;
+    GET: number;
+    GFT: number;
+    GILT: number;
+    GMT: number;
+    GST: number;
+    GYT: number;
+    HAA: number;
+    HAC: number;
+    HADT: number;
+    HAE: number;
+    HAP: number;
+    HAR: number;
+    HAST: number;
+    HAT: number;
+    HAY: number;
+    HKT: number;
+    HLV: number;
+    HNA: number;
+    HNC: number;
+    HNE: number;
+    HNP: number;
+    HNR: number;
+    HNT: number;
+    HNY: number;
+    HOVT: number;
+    ICT: number;
+    IDT: number;
+    IOT: number;
+    IRDT: number;
+    IRKST: number;
+    IRKT: number;
+    IRST: number;
+    IST: number;
+    JST: number;
+    KGT: number;
+    KRAST: number;
+    KRAT: number;
+    KST: number;
+    KUYT: number;
+    LHDT: number;
+    LHST: number;
+    LINT: number;
+    MAGST: number;
+    MAGT: number;
+    MART: number;
+    MAWT: number;
+    MDT: number;
+    MESZ: number;
+    MEZ: number;
+    MHT: number;
+    MMT: number;
+    MSD: number;
+    MSK: number;
+    MST: number;
+    MUT: number;
+    MVT: number;
+    MYT: number;
+    NCT: number;
+    NDT: number;
+    NFT: number;
+    NOVST: number;
+    NOVT: number;
+    NPT: number;
+    NST: number;
+    NUT: number;
+    NZDT: number;
+    NZST: number;
+    OMSST: number;
+    OMST: number;
+    PDT: number;
+    PET: number;
+    PETST: number;
+    PETT: number;
+    PGT: number;
+    PHOT: number;
+    PHT: number;
+    PKT: number;
+    PMDT: number;
+    PMST: number;
+    PONT: number;
+    PST: number;
+    PT: number;
+    PWT: number;
+    PYST: number;
+    PYT: number;
+    RET: number;
+    SAMT: number;
+    SAST: number;
+    SBT: number;
+    SCT: number;
+    SGT: number;
+    SRT: number;
+    SST: number;
+    TAHT: number;
+    TFT: number;
+    TJT: number;
+    TKT: number;
+    TLT: number;
+    TMT: number;
+    TVT: number;
+    ULAT: number;
+    UTC: number;
+    UYST: number;
+    UYT: number;
+    UZT: number;
+    VET: number;
+    VLAST: number;
+    VLAT: number;
+    VUT: number;
+    WAST: number;
+    WAT: number;
+    WEST: number;
+    WESZ: number;
+    WET: number;
+    WEZ: number;
+    WFT: number;
+    WGST: number;
+    WGT: number;
+    WIB: number;
+    WIT: number;
+    WITA: number;
+    WST: number;
+    WT: number;
+    YAKST: number;
+    YAKT: number;
+    YAPT: number;
+    YEKST: number;
+    YEKT: number;
+};
+export declare function toTimezoneOffset(timezoneInput: string | number): number | null;

package/dist/timezone.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTimezoneOffset = exports.TIMEZONE_ABBR_MAP = void 0;
+exports.TIMEZONE_ABBR_MAP = {
+    ACDT: 630,
+    ACST: 570,
+    ADT: -180,
+    AEDT: 660,
+    AEST: 600,
+    AFT: 270,
+    AKDT: -480,
+    AKST: -540,
+    ALMT: 360,
+    AMST: -180,
+    AMT: -240,
+    ANAST: 720,
+    ANAT: 720,
+    AQTT: 300,
+    ART: -180,
+    AST: -240,
+    AWDT: 540,
+    AWST: 480,
+    AZOST: 0,
+    AZOT: -60,
+    AZST: 300,
+    AZT: 240,
+    BNT: 480,
+    BOT: -240,
+    BRST: -120,
+    BRT: -180,
+    BST: 60,
+    BTT: 360,
+    CAST: 480,
+    CAT: 120,
+    CCT: 390,
+    CDT: -300,
+    CEST: 120,
+    CET: 60,
+    CHADT: 825,
+    CHAST: 765,
+    CKT: -600,
+    CLST: -180,
+    CLT: -240,
+    COT: -300,
+    CST: -360,
+    CVT: -60,
+    CXT: 420,
+    ChST: 600,
+    DAVT: 420,
+    EASST: -300,
+    EAST: -360,
+    EAT: 180,
+    ECT: -300,
+    EDT: -240,
+    EEST: 180,
+    EET: 120,
+    EGST: 0,
+    EGT: -60,
+    EST: -300,
+    ET: -300,
+    FJST: 780,
+    FJT: 720,
+    FKST: -180,
+    FKT: -240,
+    FNT: -120,
+    GALT: -360,
+    GAMT: -540,
+    GET: 240,
+    GFT: -180,
+    GILT: 720,
+    GMT: 0,
+    GST: 240,
+    GYT: -240,
+    HAA: -180,
+    HAC: -300,
+    HADT: -540,
+    HAE: -240,
+    HAP: -420,
+    HAR: -360,
+    HAST: -600,
+    HAT: -90,
+    HAY: -480,
+    HKT: 480,
+    HLV: -210,
+    HNA: -240,
+    HNC: -360,
+    HNE: -300,
+    HNP: -480,
+    HNR: -420,
+    HNT: -150,
+    HNY: -540,
+    HOVT: 420,
+    ICT: 420,
+    IDT: 180,
+    IOT: 360,
+    IRDT: 270,
+    IRKST: 540,
+    IRKT: 540,
+    IRST: 210,
+    IST: 330,
+    JST: 540,
+    KGT: 360,
+    KRAST: 480,
+    KRAT: 480,
+    KST: 540,
+    KUYT: 240,
+    LHDT: 660,
+    LHST: 630,
+    LINT: 840,
+    MAGST: 720,
+    MAGT: 720,
+    MART: -510,
+    MAWT: 300,
+    MDT: -360,
+    MESZ: 120,
+    MEZ: 60,
+    MHT: 720,
+    MMT: 390,
+    MSD: 240,
+    MSK: 240,
+    MST: -420,
+    MUT: 240,
+    MVT: 300,
+    MYT: 480,
+    NCT: 660,
+    NDT: -90,
+    NFT: 690,
+    NOVST: 420,
+    NOVT: 360,
+    NPT: 345,
+    NST: -150,
+    NUT: -660,
+    NZDT: 780,
+    NZST: 720,
+    OMSST: 420,
+    OMST: 420,
+    PDT: -420,
+    PET: -300,
+    PETST: 720,
+    PETT: 720,
+    PGT: 600,
+    PHOT: 780,
+    PHT: 480,
+    PKT: 300,
+    PMDT: -120,
+    PMST: -180,
+    PONT: 660,
+    PST: -480,
+    PT: -480,
+    PWT: 540,
+    PYST: -180,
+    PYT: -240,
+    RET: 240,
+    SAMT: 240,
+    SAST: 120,
+    SBT: 660,
+    SCT: 240,
+    SGT: 480,
+    SRT: -180,
+    SST: -660,
+    TAHT: -600,
+    TFT: 300,
+    TJT: 300,
+    TKT: 780,
+    TLT: 540,
+    TMT: 300,
+    TVT: 720,
+    ULAT: 480,
+    UTC: 0,
+    UYST: -120,
+    UYT: -180,
+    UZT: 300,
+    VET: -210,
+    VLAST: 660,
+    VLAT: 660,
+    VUT: 660,
+    WAST: 120,
+    WAT: 60,
+    WEST: 60,
+    WESZ: 60,
+    WET: 0,
+    WEZ: 0,
+    WFT: 720,
+    WGST: -120,
+    WGT: -180,
+    WIB: 420,
+    WIT: 540,
+    WITA: 480,
+    WST: 780,
+    WT: 0,
+    YAKST: 600,
+    YAKT: 600,
+    YAPT: 600,
+    YEKST: 360,
+    YEKT: 360,
+};
+function toTimezoneOffset(timezoneInput) {
+    var _a;
+    if (timezoneInput === null) {
+        return null;
+    }
+    if (typeof timezoneInput === "number") {
+        return timezoneInput;
+    }
+    return (_a = exports.TIMEZONE_ABBR_MAP[timezoneInput]) !== null && _a !== void 0 ? _a : 0;
+}
+exports.toTimezoneOffset = toTimezoneOffset;

package/dist/utils/dayjs.js

@@ -18,7 +18,6 @@ function assignSimilarTime(component, targetDayJs) {
     component.assign("minute", targetDayJs.minute());
     component.assign("second", targetDayJs.second());
     component.assign("millisecond", targetDayJs.millisecond());
-    component.assign("timezoneOffset", targetDayJs.utcOffset());
 }
 exports.assignSimilarTime = assignSimilarTime;
 function implySimilarTime(component, targetDayJs) {
@@ -26,6 +25,5 @@ function implySimilarTime(component, targetDayJs) {
     component.imply("minute", targetDayJs.minute());
     component.imply("second", targetDayJs.second());
     component.imply("millisecond", targetDayJs.millisecond());
-    component.imply("timezoneOffset", targetDayJs.utcOffset());
 }
 exports.implySimilarTime = implySimilarTime;

package/dist/utils/pattern.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.matchAnyPattern = exports.extractTerms = exports.repeatedTimeunitPattern = void 0;
 function repeatedTimeunitPattern(prefix, singleTimeunitPattern) {
     const singleTimeunitPatternNoCapture = singleTimeunitPattern.replace(/\((?!\?)/g, "(?:");
-    return `${prefix}${singleTimeunitPatternNoCapture}\\s*(?:,?\\s{0,5}${singleTimeunitPatternNoCapture}){0,10}`;
+    return `${prefix}${singleTimeunitPatternNoCapture}\\s{0,5}(?:,?\\s{0,5}${singleTimeunitPatternNoCapture}){0,10}`;
 }
 exports.repeatedTimeunitPattern = repeatedTimeunitPattern;
 function extractTerms(dictionary) {

package/package.json

@@ -15,7 +15,7 @@
     "preset": "ts-jest"
   },
   "license": "MIT",
-  "version": "2.2.7",
+  "version": "2.3.3",
   "directories": {
     "source": "./src",
     "test": "./test"
@@ -33,8 +33,8 @@
     "jest": "^26.1.0",
     "prettier": "^2.0.5",
     "ts-jest": "^26.1.1",
-    "typedoc": "^0.20.25",
-    "typescript": "^4.1.3"
+    "typedoc": "^0.20.36",
+    "typescript": "~4.2.4"
   },
   "husky": {
     "hooks": {

package/src/chrono.ts

@@ -1,5 +1,5 @@
-import { ParsingComponents, ParsingResult } from "./results";
-import { Component, ParsedResult, ParsingOption } from "./index";
+import { ReferenceWithTimezone, ParsingComponents, ParsingResult } from "./results";
+import { Component, ParsedResult, ParsingOption, ParsingReference } from "./index";
 import { AsyncDebugBlock, DebugHandler } from "./debugging";
 import { createCasualConfiguration } from "./locales/en";
 
@@ -68,13 +68,13 @@ export class Chrono {
      * A shortcut for calling {@Link parse | parse() } then transform the result into Javascript's Date object
      * @return Date object created from the first parse result
      */
-    parseDate(text: string, referenceDate?: Date, option?: ParsingOption): Date | null {
+    parseDate(text: string, referenceDate?: ParsingReference | Date, option?: ParsingOption): Date | null {
         const results = this.parse(text, referenceDate, option);
         return results.length > 0 ? results[0].start.date() : null;
     }
 
-    parse(text: string, referenceDate?: Date, option?: ParsingOption): ParsedResult[] {
-        const context = new ParsingContext(text, referenceDate || new Date(), option || {});
+    parse(text: string, referenceDate?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
+        const context = new ParsingContext(text, referenceDate, option);
 
         let results = [];
         this.parsers.forEach((parser) => {
@@ -136,14 +136,27 @@ export class Chrono {
 }
 
 export class ParsingContext implements DebugHandler {
-    constructor(readonly text: string, readonly refDate: Date, readonly option: ParsingOption) {}
+    readonly text: string;
+    readonly option: ParsingOption;
+    readonly reference: ReferenceWithTimezone;
+
+    // Deprecated. Use reference.instant instead.
+    readonly refDate: Date;
+
+    constructor(text: string, refDate?: ParsingReference | Date, option?: ParsingOption) {
+        this.text = text;
+        this.reference = new ReferenceWithTimezone(refDate);
+        this.option = option ?? {};
+
+        this.refDate = this.reference.instant;
+    }
 
     createParsingComponents(components?: { [c in Component]?: number } | ParsingComponents): ParsingComponents {
         if (components instanceof ParsingComponents) {
             return components;
         }
 
-        return new ParsingComponents(this.refDate, components);
+        return new ParsingComponents(this.reference, components);
     }
 
     createParsingResult(
@@ -157,7 +170,7 @@ export class ParsingContext implements DebugHandler {
         const start = startComponents ? this.createParsingComponents(startComponents) : null;
         const end = endComponents ? this.createParsingComponents(endComponents) : null;
 
-        return new ParsingResult(this.refDate, index, text, start, end);
+        return new ParsingResult(this.reference, index, text, start, end);
     }
 
     debug(block: AsyncDebugBlock): void {