svelte-date-utils 0.0.0-stage → 0.2.0

package/src/AdapterDateFns.ts

@@ -0,0 +1,141 @@
+// Adapted from AdapterDateFns in @mui/x-date-pickers, which is based on @date-io/date-fns.
+// MIT License, Copyright (c) 2017 Dmitriy Kovalenko. See LICENSE.
+import { addDays } from 'date-fns/addDays';
+import { addHours } from 'date-fns/addHours';
+import { addMinutes } from 'date-fns/addMinutes';
+import { addMonths } from 'date-fns/addMonths';
+import { addSeconds } from 'date-fns/addSeconds';
+import { addWeeks } from 'date-fns/addWeeks';
+import { addYears } from 'date-fns/addYears';
+import { endOfDay } from 'date-fns/endOfDay';
+import { endOfMonth } from 'date-fns/endOfMonth';
+import { endOfWeek } from 'date-fns/endOfWeek';
+import { endOfYear } from 'date-fns/endOfYear';
+import { format } from 'date-fns/format';
+import { getDate } from 'date-fns/getDate';
+import { getDay } from 'date-fns/getDay';
+import { getDaysInMonth } from 'date-fns/getDaysInMonth';
+import { getHours } from 'date-fns/getHours';
+import { getMilliseconds } from 'date-fns/getMilliseconds';
+import { getMinutes } from 'date-fns/getMinutes';
+import { getMonth } from 'date-fns/getMonth';
+import { getSeconds } from 'date-fns/getSeconds';
+import { getWeek } from 'date-fns/getWeek';
+import { getYear } from 'date-fns/getYear';
+import { isAfter } from 'date-fns/isAfter';
+import { isBefore } from 'date-fns/isBefore';
+import { isEqual } from 'date-fns/isEqual';
+import { isSameDay } from 'date-fns/isSameDay';
+import { isSameMonth } from 'date-fns/isSameMonth';
+import { isSameYear } from 'date-fns/isSameYear';
+import { isValid } from 'date-fns/isValid';
+import { isWithinInterval } from 'date-fns/isWithinInterval';
+import { enUS } from 'date-fns/locale/en-US';
+import { parse } from 'date-fns/parse';
+import { setDate } from 'date-fns/setDate';
+import { setHours } from 'date-fns/setHours';
+import { setMilliseconds } from 'date-fns/setMilliseconds';
+import { setMinutes } from 'date-fns/setMinutes';
+import { setMonth } from 'date-fns/setMonth';
+import { setSeconds } from 'date-fns/setSeconds';
+import { setYear } from 'date-fns/setYear';
+import { startOfDay } from 'date-fns/startOfDay';
+import { startOfMonth } from 'date-fns/startOfMonth';
+import { startOfWeek } from 'date-fns/startOfWeek';
+import { startOfYear } from 'date-fns/startOfYear';
+
+import type { Locale } from 'date-fns/locale';
+
+import type { DateAdapter } from './types.js';
+
+export interface AdapterDateFnsOptions {
+  /** A date-fns locale, for example `import { de } from 'date-fns/locale/de'`. Defaults to en-US. */
+  locale?: Locale;
+}
+
+/** Adapter for date-fns v3 and v4. Values are native `Date` objects. */
+export class AdapterDateFns implements DateAdapter<Date> {
+  public readonly lib = 'date-fns';
+
+  public readonly locale: Locale;
+
+  constructor({ locale }: AdapterDateFnsOptions = {}) {
+    this.locale = locale ?? enUS;
+  }
+
+  public date = (value?: string) => (value === undefined ? new Date() : new Date(value));
+  public getInvalidDate = () => new Date('Invalid Date');
+  public isValid = (value: Date | null | undefined): value is Date =>
+    value != null && isValid(value);
+  public toJsDate = (value: Date) => value;
+
+  public formatByString = (value: Date, formatString: string) =>
+    format(value, formatString, { locale: this.locale });
+  public parse = (value: string, formatString: string) =>
+    value === '' ? null : parse(value, formatString, new Date(), { locale: this.locale });
+
+  public isEqual = (value: Date | null, comparing: Date | null) =>
+    value === null || comparing === null ? value === comparing : isEqual(value, comparing);
+  public isSameYear = (value: Date, comparing: Date) => isSameYear(value, comparing);
+  public isSameMonth = (value: Date, comparing: Date) => isSameMonth(value, comparing);
+  public isSameDay = (value: Date, comparing: Date) => isSameDay(value, comparing);
+  public isAfter = (value: Date, comparing: Date) => isAfter(value, comparing);
+  public isBefore = (value: Date, comparing: Date) => isBefore(value, comparing);
+  public isWithinRange = (value: Date, [start, end]: [Date, Date]) =>
+    isWithinInterval(value, { start, end });
+
+  public startOfYear = (value: Date) => startOfYear(value);
+  public startOfMonth = (value: Date) => startOfMonth(value);
+  public startOfWeek = (value: Date) => startOfWeek(value, { locale: this.locale });
+  public startOfDay = (value: Date) => startOfDay(value);
+  public endOfYear = (value: Date) => endOfYear(value);
+  public endOfMonth = (value: Date) => endOfMonth(value);
+  public endOfWeek = (value: Date) => endOfWeek(value, { locale: this.locale });
+  public endOfDay = (value: Date) => endOfDay(value);
+
+  public addYears = (value: Date, amount: number) => addYears(value, amount);
+  public addMonths = (value: Date, amount: number) => addMonths(value, amount);
+  public addWeeks = (value: Date, amount: number) => addWeeks(value, amount);
+  public addDays = (value: Date, amount: number) => addDays(value, amount);
+  public addHours = (value: Date, amount: number) => addHours(value, amount);
+  public addMinutes = (value: Date, amount: number) => addMinutes(value, amount);
+  public addSeconds = (value: Date, amount: number) => addSeconds(value, amount);
+
+  public getYear = (value: Date) => getYear(value);
+  public getMonth = (value: Date) => getMonth(value);
+  public getDate = (value: Date) => getDate(value);
+  public getHours = (value: Date) => getHours(value);
+  public getMinutes = (value: Date) => getMinutes(value);
+  public getSeconds = (value: Date) => getSeconds(value);
+  public getMilliseconds = (value: Date) => getMilliseconds(value);
+
+  public setYear = (value: Date, year: number) => setYear(value, year);
+  public setMonth = (value: Date, month: number) => setMonth(value, month);
+  public setDate = (value: Date, date: number) => setDate(value, date);
+  public setHours = (value: Date, hours: number) => setHours(value, hours);
+  public setMinutes = (value: Date, minutes: number) => setMinutes(value, minutes);
+  public setSeconds = (value: Date, seconds: number) => setSeconds(value, seconds);
+  public setMilliseconds = (value: Date, milliseconds: number) =>
+    setMilliseconds(value, milliseconds);
+
+  public getDaysInMonth = (value: Date) => getDaysInMonth(value);
+
+  public getWeekArray = (value: Date) => {
+    const start = this.startOfWeek(this.startOfMonth(value));
+    const end = this.endOfWeek(this.endOfMonth(value));
+
+    const weeks: Date[][] = [];
+    let current = start;
+    for (let count = 0; this.isBefore(current, end); count += 1) {
+      const week = (weeks[Math.floor(count / 7)] ??= []);
+      week.push(current);
+      current = this.addDays(current, 1);
+    }
+    return weeks;
+  };
+
+  public getWeekNumber = (value: Date) => getWeek(value, { locale: this.locale });
+
+  public getDayOfWeek = (value: Date) =>
+    ((getDay(value) - (this.locale.options?.weekStartsOn ?? 0) + 7) % 7) + 1;
+}

package/src/AdapterLuxon.ts

@@ -0,0 +1,108 @@
+// Adapted from AdapterLuxon in @mui/x-date-pickers, which is based on @date-io/luxon.
+// MIT License, Copyright (c) 2017 Dmitriy Kovalenko. See LICENSE.
+import { DateTime } from 'luxon';
+
+import type { DateAdapter } from './types.js';
+
+export interface AdapterLuxonOptions {
+  /** A locale such as `de` or `en-GB`. Defaults to `en-US`. */
+  locale?: string;
+}
+
+/** Adapter for Luxon v3. Values are `DateTime` objects, in the zone they were created in. */
+export class AdapterLuxon implements DateAdapter<DateTime> {
+  public readonly lib = 'luxon';
+
+  public readonly locale: string;
+
+  constructor({ locale }: AdapterLuxonOptions = {}) {
+    this.locale = locale || 'en-US';
+  }
+
+  private withLocale = (value: DateTime) =>
+    value.locale === this.locale ? value : value.setLocale(this.locale);
+
+  public date = (value?: string) =>
+    value === undefined
+      ? DateTime.now().setLocale(this.locale)
+      : DateTime.fromISO(value, { locale: this.locale });
+  public getInvalidDate = () => DateTime.fromJSDate(new Date('Invalid Date'));
+  public isValid = (value: DateTime | null | undefined): value is DateTime =>
+    value != null && value.isValid;
+  public toJsDate = (value: DateTime) => value.toJSDate();
+
+  public formatByString = (value: DateTime, format: string) =>
+    value.setLocale(this.locale).toFormat(format);
+  public parse = (value: string, format: string) =>
+    value === '' ? null : DateTime.fromFormat(value, format, { locale: this.locale });
+
+  public isEqual = (value: DateTime | null, comparing: DateTime | null) =>
+    value === null || comparing === null ? value === comparing : +value === +comparing;
+  // the comparison happens in the zone of `value`
+  public isSameYear = (value: DateTime, comparing: DateTime) =>
+    value.hasSame(comparing.setZone(value.zone), 'year');
+  public isSameMonth = (value: DateTime, comparing: DateTime) =>
+    value.hasSame(comparing.setZone(value.zone), 'month');
+  public isSameDay = (value: DateTime, comparing: DateTime) =>
+    value.hasSame(comparing.setZone(value.zone), 'day');
+  public isAfter = (value: DateTime, comparing: DateTime) => value > comparing;
+  public isBefore = (value: DateTime, comparing: DateTime) => value < comparing;
+  public isWithinRange = (value: DateTime, [start, end]: [DateTime, DateTime]) =>
+    value >= start && value <= end;
+
+  public startOfYear = (value: DateTime) => value.startOf('year');
+  public startOfMonth = (value: DateTime) => value.startOf('month');
+  public startOfWeek = (value: DateTime) =>
+    this.withLocale(value).startOf('week', { useLocaleWeeks: true });
+  public startOfDay = (value: DateTime) => value.startOf('day');
+  public endOfYear = (value: DateTime) => value.endOf('year');
+  public endOfMonth = (value: DateTime) => value.endOf('month');
+  public endOfWeek = (value: DateTime) =>
+    this.withLocale(value).endOf('week', { useLocaleWeeks: true });
+  public endOfDay = (value: DateTime) => value.endOf('day');
+
+  public addYears = (value: DateTime, amount: number) => value.plus({ years: amount });
+  public addMonths = (value: DateTime, amount: number) => value.plus({ months: amount });
+  public addWeeks = (value: DateTime, amount: number) => value.plus({ weeks: amount });
+  public addDays = (value: DateTime, amount: number) => value.plus({ days: amount });
+  public addHours = (value: DateTime, amount: number) => value.plus({ hours: amount });
+  public addMinutes = (value: DateTime, amount: number) => value.plus({ minutes: amount });
+  public addSeconds = (value: DateTime, amount: number) => value.plus({ seconds: amount });
+
+  public getYear = (value: DateTime) => value.year;
+  // Luxon months are 1-based
+  public getMonth = (value: DateTime) => value.month - 1;
+  public getDate = (value: DateTime) => value.day;
+  public getHours = (value: DateTime) => value.hour;
+  public getMinutes = (value: DateTime) => value.minute;
+  public getSeconds = (value: DateTime) => value.second;
+  public getMilliseconds = (value: DateTime) => value.millisecond;
+
+  public setYear = (value: DateTime, year: number) => value.set({ year });
+  public setMonth = (value: DateTime, month: number) => value.set({ month: month + 1 });
+  public setDate = (value: DateTime, date: number) => value.set({ day: date });
+  public setHours = (value: DateTime, hour: number) => value.set({ hour });
+  public setMinutes = (value: DateTime, minute: number) => value.set({ minute });
+  public setSeconds = (value: DateTime, second: number) => value.set({ second });
+  public setMilliseconds = (value: DateTime, millisecond: number) => value.set({ millisecond });
+
+  public getDaysInMonth = (value: DateTime) => value.daysInMonth!;
+
+  public getWeekArray = (value: DateTime) => {
+    const first = this.startOfWeek(this.startOfMonth(value));
+    const last = this.endOfWeek(this.endOfMonth(value));
+    const days = Math.round(last.diff(first, 'days').days);
+
+    const weeks: DateTime[][] = [];
+    for (let day = 0; day < days; day += 1) {
+      const week = (weeks[Math.floor(day / 7)] ??= []);
+      week.push(first.plus({ days: day }));
+    }
+    return weeks;
+  };
+
+  public getWeekNumber = (value: DateTime) =>
+    this.withLocale(value).localWeekNumber ?? value.weekNumber;
+
+  public getDayOfWeek = (value: DateTime) => this.withLocale(value).localWeekday ?? value.weekday;
+}

package/src/createDateUtils.ts

@@ -0,0 +1,188 @@
+import type { DateAdapter } from './types.js';
+
+/** A date, or a year given as a number or numeric string. */
+export type YearLike<T> = T | number | string;
+/** A date, or a time string such as `10:30`, `10:30:15` or `10:30:15.5`. */
+export type TimeLike<T> = T | string;
+
+const padStart = (value: number | string, length = 2) => String(value).padStart(length, '0');
+
+const isDateString = (value: unknown): value is string => typeof value === 'string';
+
+/** Piece `index` (0 hours, 1 minutes, 2 seconds) of a time string that has at least `hh:mm`. */
+const timePiece = (value: string, index: number) => {
+  const pieces = value.split(':');
+  return pieces.length >= 2 ? pieces[index] || (index === 0 ? undefined : '0') : undefined;
+};
+
+const parseTimePiece = (piece: string | undefined, name: string, value: string) => {
+  const parsed = Number.parseInt(piece ?? '', 10);
+  if (Number.isNaN(parsed)) throw new Error(`Failed to get ${name} from date: ${value}.`);
+  return parsed;
+};
+
+/**
+ * Builds the helpers of `@wojtekmaj/date-utils` (start, end, previous, next and range of a century,
+ * decade, year, month and day, plus ISO-like local formatting) on top of any `DateAdapter`.
+ */
+export function createDateUtils<T>(adapter: DateAdapter<T>) {
+  const ops = adapter;
+
+  const yearOf = (value: YearLike<T>): number => {
+    if (typeof value === 'number') return value;
+    if (isDateString(value)) {
+      const year = Number.parseInt(value, 10);
+      if (!Number.isNaN(year)) return year;
+      throw new Error(`Failed to get year from date: ${value}.`);
+    }
+    return ops.getYear(value);
+  };
+
+  /** A date to start from: the given one, or today moved to the given year. */
+  const dateOf = (value: YearLike<T>): T =>
+    typeof value === 'number' || isDateString(value)
+      ? ops.setYear(ops.date(), yearOf(value))
+      : value;
+
+  // ---- getters
+
+  const getYear = yearOf;
+  const getMonth = (date: T) => ops.getMonth(date);
+  const getMonthHuman = (date: T) => ops.getMonth(date) + 1;
+  const getDate = (date: T) => ops.getDate(date);
+  const getHours = (date: TimeLike<T>) =>
+    isDateString(date) ? parseTimePiece(timePiece(date, 0), 'hours', date) : ops.getHours(date);
+  const getMinutes = (date: TimeLike<T>) =>
+    isDateString(date) ? parseTimePiece(timePiece(date, 1), 'minutes', date) : ops.getMinutes(date);
+  const getSeconds = (date: TimeLike<T>) =>
+    isDateString(date) ? parseTimePiece(timePiece(date, 2), 'seconds', date) : ops.getSeconds(date);
+  const getMilliseconds = (date: TimeLike<T>) =>
+    isDateString(date)
+      ? parseTimePiece(
+          timePiece(date, 2) === undefined ? undefined : timePiece(date, 2)!.split('.')[1] || '0',
+          'milliseconds',
+          date,
+        )
+      : ops.getMilliseconds(date);
+
+  // ---- edges of a period
+
+  type Edge = (date: YearLike<T>) => T;
+  type Neighbor = (date: YearLike<T>, offset?: number) => T;
+
+  const range = (start: Edge, end: Edge) => (date: YearLike<T>) =>
+    [start(date), end(date)] as [T, T];
+
+  /** Builds start, end, previous, next and range helpers of a period measured in `unit`s. */
+  const period = (
+    unit: number,
+    startOf: (date: T) => T,
+    endOf: (date: T) => T,
+    shift: (date: T, amount: number) => T,
+    alignStart: (date: T) => T = startOf,
+  ) => {
+    const start: Edge = (date) => alignStart(dateOf(date));
+    const end: Edge = (date) => endOf(alignStart(dateOf(date)));
+    const previous = (edge: Edge, offset: number): Neighbor => {
+      return (date, amount = offset) => edge(shift(alignStart(dateOf(date)), amount));
+    };
+    return {
+      start,
+      end,
+      previousStart: previous(start, -unit),
+      nextStart: previous(start, unit),
+      previousEnd: previous(end, -unit),
+      nextEnd: previous(end, unit),
+      range: range(start, end),
+    };
+  };
+
+  // A century runs from year 1 to 100, 101 to 200, ...: 2001 to 2100 is the 21st. Same for decades.
+  const alignedYear = (year: number, size: number) => year + ((-year + 1) % size);
+  const alignedStart = (size: number) => (date: T) =>
+    ops.startOfYear(ops.setYear(date, alignedYear(ops.getYear(date), size)));
+  const alignedEnd = (size: number) => (date: T) =>
+    ops.endOfYear(ops.addYears(ops.setYear(date, alignedYear(ops.getYear(date), size)), size - 1));
+
+  const century = period(100, alignedStart(100), alignedEnd(100), ops.addYears, alignedStart(100));
+  const decade = period(10, alignedStart(10), alignedEnd(10), ops.addYears, alignedStart(10));
+  const year = period(1, ops.startOfYear, ops.endOfYear, ops.addYears);
+  const month = period(1, ops.startOfMonth, ops.endOfMonth, ops.addMonths);
+  const day = period(1, ops.startOfDay, ops.endOfDay, ops.addDays);
+
+  const getDaysInMonth = (date: T) => ops.getDaysInMonth(date);
+
+  // ---- ISO-like local formatting
+
+  const getHoursMinutes = (date: TimeLike<T>) =>
+    `${padStart(getHours(date))}:${padStart(getMinutes(date))}`;
+  const getHoursMinutesSeconds = (date: TimeLike<T>) =>
+    `${getHoursMinutes(date)}:${padStart(getSeconds(date))}`;
+  const getISOLocalMonth = (date: T) =>
+    `${padStart(ops.getYear(date), 4)}-${padStart(getMonthHuman(date))}`;
+  const getISOLocalDate = (date: T) => `${getISOLocalMonth(date)}-${padStart(ops.getDate(date))}`;
+  const getISOLocalDateTime = (date: T) =>
+    `${getISOLocalDate(date)}T${getHoursMinutesSeconds(date)}`;
+
+  return {
+    adapter,
+
+    getYear,
+    getMonth,
+    getMonthHuman,
+    getDate,
+    getHours,
+    getMinutes,
+    getSeconds,
+    getMilliseconds,
+
+    getCenturyStart: century.start,
+    getPreviousCenturyStart: century.previousStart,
+    getNextCenturyStart: century.nextStart,
+    getCenturyEnd: century.end,
+    getPreviousCenturyEnd: century.previousEnd,
+    getNextCenturyEnd: century.nextEnd,
+    getCenturyRange: century.range,
+
+    getDecadeStart: decade.start,
+    getPreviousDecadeStart: decade.previousStart,
+    getNextDecadeStart: decade.nextStart,
+    getDecadeEnd: decade.end,
+    getPreviousDecadeEnd: decade.previousEnd,
+    getNextDecadeEnd: decade.nextEnd,
+    getDecadeRange: decade.range,
+
+    getYearStart: year.start,
+    getPreviousYearStart: year.previousStart,
+    getNextYearStart: year.nextStart,
+    getYearEnd: year.end,
+    getPreviousYearEnd: year.previousEnd,
+    getNextYearEnd: year.nextEnd,
+    getYearRange: year.range,
+
+    getMonthStart: month.start,
+    getPreviousMonthStart: month.previousStart,
+    getNextMonthStart: month.nextStart,
+    getMonthEnd: month.end,
+    getPreviousMonthEnd: month.previousEnd,
+    getNextMonthEnd: month.nextEnd,
+    getMonthRange: month.range,
+
+    getDayStart: day.start,
+    getPreviousDayStart: day.previousStart,
+    getNextDayStart: day.nextStart,
+    getDayEnd: day.end,
+    getPreviousDayEnd: day.previousEnd,
+    getNextDayEnd: day.nextEnd,
+    getDayRange: day.range,
+
+    getDaysInMonth,
+    getHoursMinutes,
+    getHoursMinutesSeconds,
+    getISOLocalMonth,
+    getISOLocalDate,
+    getISOLocalDateTime,
+  };
+}
+
+export type DateUtils<T> = ReturnType<typeof createDateUtils<T>>;

package/src/date-fns.ts

@@ -0,0 +1,2 @@
+export { AdapterDateFns } from './AdapterDateFns.js';
+export type { AdapterDateFnsOptions } from './AdapterDateFns.js';

package/src/index.ts

@@ -0,0 +1,67 @@
+import { AdapterDate } from './AdapterDate.js';
+import { createDateUtils } from './createDateUtils.js';
+
+export { AdapterDate } from './AdapterDate.js';
+export type { AdapterDateOptions } from './AdapterDate.js';
+export { createDateUtils } from './createDateUtils.js';
+export type { DateUtils, TimeLike, YearLike } from './createDateUtils.js';
+export type { DateAdapter } from './types.js';
+
+/**
+ * The helpers on the native `Date`, with the names and behavior of `@wojtekmaj/date-utils`.
+ * For date-fns or Luxon, call `createDateUtils` with `AdapterDateFns` or `AdapterLuxon`
+ * from `svelte-date-utils/date-fns` or `svelte-date-utils/luxon`.
+ */
+export const dateUtils = createDateUtils(new AdapterDate());
+
+export const {
+  getYear,
+  getMonth,
+  getMonthHuman,
+  getDate,
+  getHours,
+  getMinutes,
+  getSeconds,
+  getMilliseconds,
+  getCenturyStart,
+  getPreviousCenturyStart,
+  getNextCenturyStart,
+  getCenturyEnd,
+  getPreviousCenturyEnd,
+  getNextCenturyEnd,
+  getCenturyRange,
+  getDecadeStart,
+  getPreviousDecadeStart,
+  getNextDecadeStart,
+  getDecadeEnd,
+  getPreviousDecadeEnd,
+  getNextDecadeEnd,
+  getDecadeRange,
+  getYearStart,
+  getPreviousYearStart,
+  getNextYearStart,
+  getYearEnd,
+  getPreviousYearEnd,
+  getNextYearEnd,
+  getYearRange,
+  getMonthStart,
+  getPreviousMonthStart,
+  getNextMonthStart,
+  getMonthEnd,
+  getPreviousMonthEnd,
+  getNextMonthEnd,
+  getMonthRange,
+  getDayStart,
+  getPreviousDayStart,
+  getNextDayStart,
+  getDayEnd,
+  getPreviousDayEnd,
+  getNextDayEnd,
+  getDayRange,
+  getDaysInMonth,
+  getHoursMinutes,
+  getHoursMinutesSeconds,
+  getISOLocalMonth,
+  getISOLocalDate,
+  getISOLocalDateTime,
+} = dateUtils;

package/src/luxon.ts

@@ -0,0 +1,2 @@
+export { AdapterLuxon } from './AdapterLuxon.js';
+export type { AdapterLuxonOptions } from './AdapterLuxon.js';

package/src/types.ts

@@ -0,0 +1,68 @@
+/**
+ * The date operations the utilities need, over any date type `T` (`Date`, a date-fns `Date`, a
+ * Luxon `DateTime`, ...). The shape follows `MuiPickersAdapter` from `@mui/x-date-pickers`, cut
+ * down to what a calendar and a date input use. Months are 0-based in every adapter.
+ */
+export interface DateAdapter<T> {
+  /** Name of the library behind the adapter. */
+  readonly lib: string;
+
+  /** The current time, or the date parsed from an ISO string. */
+  date(value?: string): T;
+  getInvalidDate(): T;
+  isValid(value: T | null | undefined): value is T;
+  toJsDate(value: T): Date;
+
+  formatByString(value: T, format: string): string;
+  parse(value: string, format: string): T | null;
+
+  isEqual(value: T | null, comparing: T | null): boolean;
+  isSameYear(value: T, comparing: T): boolean;
+  isSameMonth(value: T, comparing: T): boolean;
+  isSameDay(value: T, comparing: T): boolean;
+  isAfter(value: T, comparing: T): boolean;
+  isBefore(value: T, comparing: T): boolean;
+  isWithinRange(value: T, range: [T, T]): boolean;
+
+  startOfYear(value: T): T;
+  startOfMonth(value: T): T;
+  startOfWeek(value: T): T;
+  startOfDay(value: T): T;
+  endOfYear(value: T): T;
+  endOfMonth(value: T): T;
+  endOfWeek(value: T): T;
+  endOfDay(value: T): T;
+
+  addYears(value: T, amount: number): T;
+  addMonths(value: T, amount: number): T;
+  addWeeks(value: T, amount: number): T;
+  addDays(value: T, amount: number): T;
+  addHours(value: T, amount: number): T;
+  addMinutes(value: T, amount: number): T;
+  addSeconds(value: T, amount: number): T;
+
+  getYear(value: T): number;
+  /** 0-based month. */
+  getMonth(value: T): number;
+  getDate(value: T): number;
+  getHours(value: T): number;
+  getMinutes(value: T): number;
+  getSeconds(value: T): number;
+  getMilliseconds(value: T): number;
+
+  setYear(value: T, year: number): T;
+  /** 0-based month. */
+  setMonth(value: T, month: number): T;
+  setDate(value: T, date: number): T;
+  setHours(value: T, hours: number): T;
+  setMinutes(value: T, minutes: number): T;
+  setSeconds(value: T, seconds: number): T;
+  setMilliseconds(value: T, milliseconds: number): T;
+
+  getDaysInMonth(value: T): number;
+  /** Weeks of the month of `value`, padded with days of the neighboring months. */
+  getWeekArray(value: T): T[][];
+  getWeekNumber(value: T): number;
+  /** 1 to 7, from the first day of the week of the locale. */
+  getDayOfWeek(value: T): number;
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.