Refactor: Remove dayjs from date/time calculation

Wanasit Tanakitrungruang · Wanasit Tanakitrungruang · commit e25fa10403dd · 2025-08-30T11:14:14.000+09:00
diff --git a/src/calculation/years.ts b/src/calculation/years.ts
@@ -1,4 +1,4 @@
-import dayjs from "dayjs";
+import { addDuration } from "./duration";
 
 /**
  * Find the most likely year, from a raw number. For example:
@@ -19,20 +19,15 @@ export function findMostLikelyADYear(yearNumber: number): number {
 }
 
 export function findYearClosestToRef(refDate: Date, day: number, month: number): number {
-    //Find the most appropriated year
-    const refMoment = dayjs(refDate);
-    let dateMoment = refMoment;
-    dateMoment = dateMoment.month(month - 1);
-    dateMoment = dateMoment.date(day);
-    dateMoment = dateMoment.year(refMoment.year());
-
-    const nextYear = dateMoment.add(1, "y");
-    const lastYear = dateMoment.add(-1, "y");
-    if (Math.abs(nextYear.diff(refMoment)) < Math.abs(dateMoment.diff(refMoment))) {
-        dateMoment = nextYear;
-    } else if (Math.abs(lastYear.diff(refMoment)) < Math.abs(dateMoment.diff(refMoment))) {
-        dateMoment = lastYear;
+    let date = new Date(refDate);
+    date.setMonth(month - 1);
+    date.setDate(day);
+    const nextYear = addDuration(date, { "year": 1 });
+    const lastYear = addDuration(date, { "year": -1 });
+    if (Math.abs(nextYear.getTime() - refDate.getTime()) < Math.abs(date.getTime() - refDate.getTime())) {
+        date = nextYear;
+    } else if (Math.abs(lastYear.getTime() - refDate.getTime()) < Math.abs(date.getTime() - refDate.getTime())) {
+        date = lastYear;
     }
-
-    return dateMoment.year();
+    return date.getFullYear();
 }
diff --git a/src/common/refiners/AbstractMergeDateRangeRefiner.ts b/src/common/refiners/AbstractMergeDateRangeRefiner.ts
@@ -4,6 +4,7 @@
 
 import { ParsingResult } from "../../results";
 import { MergingRefiner } from "../abstractRefiners";
+import { addDuration } from "../../calculation/duration";
 
 export default abstract class AbstractMergeDateRangeRefiner extends MergingRefiner {
     abstract patternBetween(): RegExp;
@@ -26,31 +27,30 @@ export default abstract class AbstractMergeDateRangeRefiner extends MergingRefin
                 }
             });
         }
+        if (fromResult.start.date() > toResult.start.date()) {
+            let fromDate = fromResult.start.date();
+            let toDate = toResult.start.date();
 
-        if (fromResult.start.date().getTime() > toResult.start.date().getTime()) {
-            let fromMoment = fromResult.start.dayjs();
-            let toMoment = toResult.start.dayjs();
-            if (toResult.start.isOnlyWeekdayComponent() && toMoment.add(7, "days").isAfter(fromMoment)) {
-                toMoment = toMoment.add(7, "days");
-                toResult.start.imply("day", toMoment.date());
-                toResult.start.imply("month", toMoment.month() + 1);
-                toResult.start.imply("year", toMoment.year());
-            } else if (fromResult.start.isOnlyWeekdayComponent() && fromMoment.add(-7, "days").isBefore(toMoment)) {
-                fromMoment = fromMoment.add(-7, "days");
-                fromResult.start.imply("day", fromMoment.date());
-                fromResult.start.imply("month", fromMoment.month() + 1);
-                fromResult.start.imply("year", fromMoment.year());
-            } else if (toResult.start.isDateWithUnknownYear() && toMoment.add(1, "years").isAfter(fromMoment)) {
-                toMoment = toMoment.add(1, "years");
-                toResult.start.imply("year", toMoment.year());
-            } else if (fromResult.start.isDateWithUnknownYear() && fromMoment.add(-1, "years").isBefore(toMoment)) {
-                fromMoment = fromMoment.add(-1, "years");
-                fromResult.start.imply("year", fromMoment.year());
+            if (toResult.start.isOnlyWeekdayComponent() && addDuration(toDate, { day: 7 }) > fromDate) {
+                toDate = addDuration(toDate, { day: 7 });
+                toResult.start.imply("day", toDate.getDate());
+                toResult.start.imply("month", toDate.getMonth() + 1);
+                toResult.start.imply("year", toDate.getFullYear());
+            } else if (fromResult.start.isOnlyWeekdayComponent() && addDuration(fromDate, { day: -7 }) < toDate) {
+                fromDate = addDuration(fromDate, { day: -7 });
+                fromResult.start.imply("day", fromDate.getDate());
+                fromResult.start.imply("month", fromDate.getMonth() + 1);
+                fromResult.start.imply("year", fromDate.getFullYear());
+            } else if (toResult.start.isDateWithUnknownYear() && addDuration(toDate, { year: 1 }) > fromDate) {
+                toDate = addDuration(toDate, { year: 1 });
+                toResult.start.imply("year", toDate.getFullYear());
+            } else if (fromResult.start.isDateWithUnknownYear() && addDuration(fromDate, { year: -1 }) < toDate) {
+                fromDate = addDuration(fromDate, { year: -1 });
+                fromResult.start.imply("year", fromDate.getFullYear());
             } else {
                 [toResult, fromResult] = [fromResult, toResult];
             }
         }
-
         const result = fromResult.clone();
         result.start = fromResult.start;
         result.end = toResult.start;
@@ -60,7 +60,6 @@ export default abstract class AbstractMergeDateRangeRefiner extends MergingRefin
         } else {
             result.text = toResult.text + textBetween + fromResult.text;
         }
-
         return result;
     }
 }
diff --git a/src/common/refiners/ForwardDateRefiner.ts b/src/common/refiners/ForwardDateRefiner.ts
@@ -6,8 +6,9 @@
 
 import { ParsingContext, Refiner } from "../../chrono";
 import { ParsingResult } from "../../results";
-import dayjs from "dayjs";
 import * as dates from "../../utils/dates";
+import { implySimilarDate } from "../../utils/dates";
+import { addDuration } from "../../calculation/duration";
 
 export default class ForwardDateRefiner implements Refiner {
     refine(context: ParsingContext, results: ParsingResult[]): ParsingResult[] {
@@ -16,7 +17,7 @@ export default class ForwardDateRefiner implements Refiner {
         }
 
         results.forEach((result) => {
-            let refMoment = dayjs(context.reference.getDateWithAdjustedTimezone());
+            let refDate = context.reference.getDateWithAdjustedTimezone();
 
             if (result.start.isOnlyTime() && context.reference.instant > result.start.date()) {
                 const refDate = context.reference.getDateWithAdjustedTimezone();
@@ -38,41 +39,35 @@ export default class ForwardDateRefiner implements Refiner {
                 }
             }
 
-            if (result.start.isOnlyWeekdayComponent() && refMoment.isAfter(result.start.dayjs())) {
-                if (refMoment.day() >= result.start.get("weekday")) {
-                    refMoment = refMoment.day(result.start.get("weekday") + 7);
-                } else {
-                    refMoment = refMoment.day(<number>result.start.get("weekday"));
+            if (result.start.isOnlyWeekdayComponent() && refDate > result.start.date()) {
+                let daysToAdd = result.start.get("weekday") - refDate.getDay();
+                if (daysToAdd <= 0) {
+                    daysToAdd += 7;
                 }
-
-                result.start.imply("day", refMoment.date());
-                result.start.imply("month", refMoment.month() + 1);
-                result.start.imply("year", refMoment.year());
+                refDate = addDuration(refDate, { day: daysToAdd });
+                implySimilarDate(result.start, refDate);
                 context.debug(() => {
                     console.log(`${this.constructor.name} adjusted ${result} weekday (${result.start})`);
                 });
 
                 if (result.end && result.end.isOnlyWeekdayComponent()) {
                     // Adjust date to the coming week
-                    if (refMoment.day() > result.end.get("weekday")) {
-                        refMoment = refMoment.day(result.end.get("weekday") + 7);
-                    } else {
-                        refMoment = refMoment.day(<number>result.end.get("weekday"));
+                    let daysToAdd = result.end.get("weekday") - refDate.getDay();
+                    if (daysToAdd <= 0) {
+                        daysToAdd += 7;
                     }
-
-                    result.end.imply("day", refMoment.date());
-                    result.end.imply("month", refMoment.month() + 1);
-                    result.end.imply("year", refMoment.year());
+                    refDate = addDuration(refDate, { day: daysToAdd });
+                    implySimilarDate(result.end, refDate);
                     context.debug(() => {
                         console.log(`${this.constructor.name} adjusted ${result} weekday (${result.end})`);
                     });
                 }
             }
 
             // In case where we know the month, but not which year (e.g. "in December", "25th December"),
-            // try move to another year
-            if (result.start.isDateWithUnknownYear() && refMoment.isAfter(result.start.dayjs())) {
-                for (let i = 0; i < 3 && refMoment.isAfter(result.start.dayjs()); i++) {
+            // try move to another year (up-to 3 times)
+            if (result.start.isDateWithUnknownYear() && refDate > result.start.date()) {
+                for (let i = 0; i < 3 && refDate > result.start.date(); i++) {
                     result.start.imply("year", result.start.get("year") + 1);
                     context.debug(() => {
                         console.log(`${this.constructor.name} adjusted ${result} year (${result.start})`);
diff --git a/src/locales/ja/parsers/JPStandardParser.ts b/src/locales/ja/parsers/JPStandardParser.ts
@@ -2,8 +2,6 @@ import { Parser, ParsingContext } from "../../../chrono";
 import { toHankaku } from "../constants";
 import { findYearClosestToRef } from "../../../calculation/years";
 
-import dayjs from "dayjs";
-
 const PATTERN =
     /(?:(?:([同今本])|((昭和|平成|令和)?([0-9０-９]{1,4}|元)))年\s*)?([0-9０-９]{1,2})月\s*([0-9０-９]{1,2})日/i;
 const SPECIAL_YEAR_GROUP = 1;
@@ -27,8 +25,7 @@ export default class JPStandardParser implements Parser {
         });
 
         if (match[SPECIAL_YEAR_GROUP] && match[SPECIAL_YEAR_GROUP].match("同|今|本")) {
-            const moment = dayjs(context.refDate);
-            components.assign("year", moment.year());
+            components.assign("year", context.reference.getDateWithAdjustedTimezone().getFullYear());
         }
 
         if (match[TYPICAL_YEAR_GROUP]) {
diff --git a/src/timezone.ts b/src/timezone.ts
@@ -1,4 +1,3 @@
-import dayjs from "dayjs";
 import { TimezoneAbbrMap, Weekday, Month } from "./types";
 
 export const TIMEZONE_ABBR_MAP: TimezoneAbbrMap = {
@@ -310,10 +309,7 @@ export function toTimezoneOffset(
     }
 
     // Return DST offset if the refDate is during daylight savings
-    if (
-        dayjs(date).isAfter(matchedTimezone.dstStart(date.getFullYear())) &&
-        !dayjs(date).isAfter(matchedTimezone.dstEnd(date.getFullYear()))
-    ) {
+    if (date > matchedTimezone.dstStart(date.getFullYear()) && !(date > matchedTimezone.dstEnd(date.getFullYear()))) {
         return matchedTimezone.timezoneOffsetDuringDst;
     }
 
diff --git a/src/utils/dayjs.ts b/src/utils/dayjs.ts

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,3 @@`
`1`		`-import dayjs from "dayjs";`
`2`	`1`	`import { TimezoneAbbrMap, Weekday, Month } from "./types";`
`3`	`2`
`4`	`3`	`export const TIMEZONE_ABBR_MAP: TimezoneAbbrMap = {`
`@@ -310,10 +309,7 @@ export function toTimezoneOffset(`
`310`	`309`	`}`
`311`	`310`
`312`	`311`	`// Return DST offset if the refDate is during daylight savings`
`313`		`- if (`
`314`		`- dayjs(date).isAfter(matchedTimezone.dstStart(date.getFullYear())) &&`
`315`		`- !dayjs(date).isAfter(matchedTimezone.dstEnd(date.getFullYear()))`
`316`		`- ) {`
	`312`	`+ if (date > matchedTimezone.dstStart(date.getFullYear()) && !(date > matchedTimezone.dstEnd(date.getFullYear()))) {`
`317`	`313`	`return matchedTimezone.timezoneOffsetDuringDst;`
`318`	`314`	`}`
`319`	`315`