best way to do isAfter with variable precision?

[srevenant]

I want to be able to do isAfter() but like moment's isSameOrAfter with variable precision, so I can have it only care about year, month, day, etc. From what I glean via the docs date-fns isAfter is likely precise down to the millisecond.

I realize I can use startOfDay/Month/etc on each... I'm just curious if there was a way to have this happen automatically. I may just be missing it in the docs, and it's already possible...

any suggestions for something better?

[fturmel]

The isAfter and isBefore functions in their current form are somewhat useless since you can use the greater than/smaller than operators with Date instances directly in JavaScript. It could be worth revisiting that API.

For your use case, have you tried the differenceIn* functions?

import { differenceInMonths } from "date-fns";

const earlier = new Date(2020, 0, 1);
const later = new Date(2021, 4, 3);

console.log(differenceInMonths(earlier, later)); // -16
console.log(differenceInMonths(later, earlier)); // 16

console.log(differenceInMonths(later, earlier) > 0); // true

[srevenant]

Alas, I tried it... it won't work because it's relative to each other, not relative to the month. So:

differenceInMonths(
new Date("Wed Feb 02 2022 14:02:00 GMT-0700"),
new Date("Sun Jan 02 2022 14:02:00 GMT-0700"))

=> 1
differenceInMonths(
new Date("Wed Feb 02 2022 14:02:00 GMT-0700"),
new Date("Wed Jan 12 2022 08:46:02 GMT-0700"))
=> 0

Where what I need is both results to be the same -- any day in the month so even jan30 vs feb1 should be 1 month difference.

I think I'll have to combine truncating both of them still.

[fturmel]

Oh I see, I misunderstood the problem. Apologies.

[leshakoss]

Try differenceInCalendarMonths with the same snippet, I believe it is what you're looking for

[srevenant]

I'm playing with this right now and it seems to be doing the job. I'm doing more testing...

export function isSameOrAfter(target, type, origin = new Date()) {
  switch (type) {
    case 'year':
      return startOfYear(target) >= startOfYear(origin)
    case 'month':
      return startOfMonth(target) >= startOfMonth(origin)
    case 'day':
      return startOfDay(target) >= startOfDay(origin)
    case 'hour':
      return startOfHour(target) >= startOfHour(origin)
    case 'minute':
      return startOfMinute(target) >= startOfMinute(origin)
    default:
      throw new Error(`isSameOrAfter - unrecognized precision type: ${type}!`)
  }
}

[fturmel]

@srevenant It's a slow day, so here's an alternate approach for you with benchmarks. It seems to perform better for most paths and equal at worst.

import {
  isSameDay,
  isSameHour,
  isSameMinute,
  isSameMonth,
  isSameYear,
} from 'date-fns'

export function isSameOrAfter(target, type, origin = new Date()) {
  if (target.getTime() >= origin.getTime()) return true

  switch (type) {
    case 'year':
      return isSameYear(origin, target)
    case 'month':
      return isSameMonth(origin, target)
    case 'day':
      return isSameDay(origin, target)
    case 'hour':
      return isSameHour(origin, target)
    case 'minute':
      return isSameMinute(origin, target)
    default:
      throw new Error(`isSameOrAfter - unrecognized precision type: ${type}!`)
  }
}

All later dates bench at 100+ MM ops/sec with the early exit code. (interesting note, target >= origin benched slower at 12 MM ops/sec).

For earlier dates:

	startOf* (any date)	isSame* (earlier date)
year	0.8 MM	2.8 MM
month	1 MM	2.7 MM
day	1.7 MM	1.7 MM
hour	1.7 MM	1.7 MM
minute	1.7 MM	1.7 MM