Validators

Validation utilities from @edtf-ts/core for checking EDTF date properties.

TIP

These functions are part of the main @edtf-ts/core package.

Functions

isInRange()

Check if a date falls within a given range (with overlap detection).

function isInRange(
  date: EDTFDate | EDTFDateTime,
  start: EDTFDate | EDTFDateTime | Date,
  end: EDTFDate | EDTFDateTime | Date
): boolean

A date is "in range" if its possible values overlap with the given range.

import { parse, isEDTFDate } from '@edtf-ts/core';
import { isInRange } from '@edtf-ts/core';

const date = parse('2000-06');  // June 2000
const start = new Date('2000-01-01');
const end = new Date('2000-12-31');

if (date.success && isEDTFDate(date.value)) {
  isInRange(date.value, start, end);  // true
}

isCompletelyInRange()

Check if a date is completely contained within a range.

function isCompletelyInRange(
  date: EDTFDate | EDTFDateTime,
  start: EDTFDate | EDTFDateTime | Date,
  end: EDTFDate | EDTFDateTime | Date
): boolean

Unlike isInRange, this requires the entire date range to be within the bounds.

const month = parse('2000-06');
const year = parse('2000');

if (month.success && year.success &&
    isEDTFDate(month.value) && isEDTFDate(year.value)) {
  isCompletelyInRange(month.value, year.value.min, year.value.max);  // true
}

isLeapYear()

Check if a year is a leap year.

function isLeapYear(year: number): boolean

import { isLeapYear } from '@edtf-ts/core';

isLeapYear(2000);  // true (divisible by 400)
isLeapYear(2001);  // false
isLeapYear(2004);  // true (divisible by 4)
isLeapYear(1900);  // false (divisible by 100 but not 400)

getDaysInMonth()

Get the number of days in a given month.

function getDaysInMonth(year: number, month: number): number

import { getDaysInMonth } from '@edtf-ts/core';

getDaysInMonth(2000, 2);  // 29 (leap year)
getDaysInMonth(2001, 2);  // 28
getDaysInMonth(2000, 4);  // 30
getDaysInMonth(2000, 12); // 31

isValidDate()

Check if a date is valid (proper month and day values).

function isValidDate(year: number, month: number, day: number): boolean

import { isValidDate } from '@edtf-ts/core';

isValidDate(2000, 2, 29);  // true (leap year)
isValidDate(2001, 2, 29);  // false
isValidDate(2000, 13, 1);  // false (invalid month)
isValidDate(2000, 4, 31);  // false (April has 30 days)

isValidInterval()

Check if an interval is valid (start is before or equal to end).

function isValidInterval(interval: EDTFInterval): boolean

import { parse, isEDTFInterval } from '@edtf-ts/core';
import { isValidInterval } from '@edtf-ts/core';

const valid = parse('2000/2010');
const invalid = parse('2010/2000');

if (valid.success && isEDTFInterval(valid.value)) {
  isValidInterval(valid.value);  // true
}

isUncertain()

Check if a date has any uncertainty qualifications.

function isUncertain(date: EDTFDate): boolean

import { parse, isEDTFDate } from '@edtf-ts/core';
import { isUncertain } from '@edtf-ts/core';

const uncertain = parse('1984?');
const certain = parse('1984');

if (uncertain.success && isEDTFDate(uncertain.value)) {
  isUncertain(uncertain.value);  // true
}

if (certain.success && isEDTFDate(certain.value)) {
  isUncertain(certain.value);  // false
}

isApproximate()

Check if a date has any approximation qualifications.

function isApproximate(date: EDTFDate): boolean

const approximate = parse('1984~');
const exact = parse('1984');

if (approximate.success && isEDTFDate(approximate.value)) {
  isApproximate(approximate.value);  // true
}

hasUnspecified()

Check if a date has any unspecified digits.

function hasUnspecified(date: EDTFDate): boolean

const decade = parse('198X');
const year = parse('1984');

if (decade.success && isEDTFDate(decade.value)) {
  hasUnspecified(decade.value);  // true
}

if (year.success && isEDTFDate(year.value)) {
  hasUnspecified(year.value);  // false
}