svelte-date-utils 0.0.0-stage → 0.2.0

package/dist/createDateUtils.js

@@ -0,0 +1,132 @@
+const padStart = (value, length = 2) => String(value).padStart(length, '0');
+const isDateString = (value) => typeof value === 'string';
+/** Piece `index` (0 hours, 1 minutes, 2 seconds) of a time string that has at least `hh:mm`. */
+const timePiece = (value, index) => {
+    const pieces = value.split(':');
+    return pieces.length >= 2 ? pieces[index] || (index === 0 ? undefined : '0') : undefined;
+};
+const parseTimePiece = (piece, name, value) => {
+    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(adapter) {
+    const ops = adapter;
+    const yearOf = (value) => {
+        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) => typeof value === 'number' || isDateString(value)
+        ? ops.setYear(ops.date(), yearOf(value))
+        : value;
+    // ---- getters
+    const getYear = yearOf;
+    const getMonth = (date) => ops.getMonth(date);
+    const getMonthHuman = (date) => ops.getMonth(date) + 1;
+    const getDate = (date) => ops.getDate(date);
+    const getHours = (date) => isDateString(date) ? parseTimePiece(timePiece(date, 0), 'hours', date) : ops.getHours(date);
+    const getMinutes = (date) => isDateString(date) ? parseTimePiece(timePiece(date, 1), 'minutes', date) : ops.getMinutes(date);
+    const getSeconds = (date) => isDateString(date) ? parseTimePiece(timePiece(date, 2), 'seconds', date) : ops.getSeconds(date);
+    const getMilliseconds = (date) => isDateString(date)
+        ? parseTimePiece(timePiece(date, 2) === undefined ? undefined : timePiece(date, 2).split('.')[1] || '0', 'milliseconds', date)
+        : ops.getMilliseconds(date);
+    const range = (start, end) => (date) => [start(date), end(date)];
+    /** Builds start, end, previous, next and range helpers of a period measured in `unit`s. */
+    const period = (unit, startOf, endOf, shift, alignStart = startOf) => {
+        const start = (date) => alignStart(dateOf(date));
+        const end = (date) => endOf(alignStart(dateOf(date)));
+        const previous = (edge, offset) => {
+            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, size) => year + ((-year + 1) % size);
+    const alignedStart = (size) => (date) => ops.startOfYear(ops.setYear(date, alignedYear(ops.getYear(date), size)));
+    const alignedEnd = (size) => (date) => 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) => ops.getDaysInMonth(date);
+    // ---- ISO-like local formatting
+    const getHoursMinutes = (date) => `${padStart(getHours(date))}:${padStart(getMinutes(date))}`;
+    const getHoursMinutesSeconds = (date) => `${getHoursMinutes(date)}:${padStart(getSeconds(date))}`;
+    const getISOLocalMonth = (date) => `${padStart(ops.getYear(date), 4)}-${padStart(getMonthHuman(date))}`;
+    const getISOLocalDate = (date) => `${getISOLocalMonth(date)}-${padStart(ops.getDate(date))}`;
+    const getISOLocalDateTime = (date) => `${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,
+    };
+}

package/dist/date-fns.d.ts

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

package/dist/date-fns.js

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

package/dist/index.d.ts

@@ -0,0 +1,63 @@
+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 declare const dateUtils: {
+    adapter: import("./types.js").DateAdapter<Date>;
+    getYear: (value: import("./createDateUtils.js").YearLike<Date>) => number;
+    getMonth: (date: Date) => number;
+    getMonthHuman: (date: Date) => number;
+    getDate: (date: Date) => number;
+    getHours: (date: import("./createDateUtils.js").TimeLike<Date>) => number;
+    getMinutes: (date: import("./createDateUtils.js").TimeLike<Date>) => number;
+    getSeconds: (date: import("./createDateUtils.js").TimeLike<Date>) => number;
+    getMilliseconds: (date: import("./createDateUtils.js").TimeLike<Date>) => number;
+    getCenturyStart: (date: import("./createDateUtils.js").YearLike<Date>) => Date;
+    getPreviousCenturyStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getNextCenturyStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getCenturyEnd: (date: import("./createDateUtils.js").YearLike<Date>) => Date;
+    getPreviousCenturyEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getNextCenturyEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getCenturyRange: (date: import("./createDateUtils.js").YearLike<Date>) => [Date, Date];
+    getDecadeStart: (date: import("./createDateUtils.js").YearLike<Date>) => Date;
+    getPreviousDecadeStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getNextDecadeStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getDecadeEnd: (date: import("./createDateUtils.js").YearLike<Date>) => Date;
+    getPreviousDecadeEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getNextDecadeEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getDecadeRange: (date: import("./createDateUtils.js").YearLike<Date>) => [Date, Date];
+    getYearStart: (date: import("./createDateUtils.js").YearLike<Date>) => Date;
+    getPreviousYearStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getNextYearStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getYearEnd: (date: import("./createDateUtils.js").YearLike<Date>) => Date;
+    getPreviousYearEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getNextYearEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getYearRange: (date: import("./createDateUtils.js").YearLike<Date>) => [Date, Date];
+    getMonthStart: (date: import("./createDateUtils.js").YearLike<Date>) => Date;
+    getPreviousMonthStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getNextMonthStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getMonthEnd: (date: import("./createDateUtils.js").YearLike<Date>) => Date;
+    getPreviousMonthEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getNextMonthEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getMonthRange: (date: import("./createDateUtils.js").YearLike<Date>) => [Date, Date];
+    getDayStart: (date: import("./createDateUtils.js").YearLike<Date>) => Date;
+    getPreviousDayStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getNextDayStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getDayEnd: (date: import("./createDateUtils.js").YearLike<Date>) => Date;
+    getPreviousDayEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getNextDayEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date;
+    getDayRange: (date: import("./createDateUtils.js").YearLike<Date>) => [Date, Date];
+    getDaysInMonth: (date: Date) => number;
+    getHoursMinutes: (date: import("./createDateUtils.js").TimeLike<Date>) => string;
+    getHoursMinutesSeconds: (date: import("./createDateUtils.js").TimeLike<Date>) => string;
+    getISOLocalMonth: (date: Date) => string;
+    getISOLocalDate: (date: Date) => string;
+    getISOLocalDateTime: (date: Date) => string;
+};
+export declare const getYear: (value: import("./createDateUtils.js").YearLike<Date>) => number, getMonth: (date: Date) => number, getMonthHuman: (date: Date) => number, getDate: (date: Date) => number, getHours: (date: import("./createDateUtils.js").TimeLike<Date>) => number, getMinutes: (date: import("./createDateUtils.js").TimeLike<Date>) => number, getSeconds: (date: import("./createDateUtils.js").TimeLike<Date>) => number, getMilliseconds: (date: import("./createDateUtils.js").TimeLike<Date>) => number, getCenturyStart: (date: import("./createDateUtils.js").YearLike<Date>) => Date, getPreviousCenturyStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getNextCenturyStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getCenturyEnd: (date: import("./createDateUtils.js").YearLike<Date>) => Date, getPreviousCenturyEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getNextCenturyEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getCenturyRange: (date: import("./createDateUtils.js").YearLike<Date>) => [Date, Date], getDecadeStart: (date: import("./createDateUtils.js").YearLike<Date>) => Date, getPreviousDecadeStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getNextDecadeStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getDecadeEnd: (date: import("./createDateUtils.js").YearLike<Date>) => Date, getPreviousDecadeEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getNextDecadeEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getDecadeRange: (date: import("./createDateUtils.js").YearLike<Date>) => [Date, Date], getYearStart: (date: import("./createDateUtils.js").YearLike<Date>) => Date, getPreviousYearStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getNextYearStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getYearEnd: (date: import("./createDateUtils.js").YearLike<Date>) => Date, getPreviousYearEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getNextYearEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getYearRange: (date: import("./createDateUtils.js").YearLike<Date>) => [Date, Date], getMonthStart: (date: import("./createDateUtils.js").YearLike<Date>) => Date, getPreviousMonthStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getNextMonthStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getMonthEnd: (date: import("./createDateUtils.js").YearLike<Date>) => Date, getPreviousMonthEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getNextMonthEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getMonthRange: (date: import("./createDateUtils.js").YearLike<Date>) => [Date, Date], getDayStart: (date: import("./createDateUtils.js").YearLike<Date>) => Date, getPreviousDayStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getNextDayStart: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getDayEnd: (date: import("./createDateUtils.js").YearLike<Date>) => Date, getPreviousDayEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getNextDayEnd: (date: import("./createDateUtils.js").YearLike<Date>, offset?: number) => Date, getDayRange: (date: import("./createDateUtils.js").YearLike<Date>) => [Date, Date], getDaysInMonth: (date: Date) => number, getHoursMinutes: (date: import("./createDateUtils.js").TimeLike<Date>) => string, getHoursMinutesSeconds: (date: import("./createDateUtils.js").TimeLike<Date>) => string, getISOLocalMonth: (date: Date) => string, getISOLocalDate: (date: Date) => string, getISOLocalDateTime: (date: Date) => string;

package/dist/index.js

@@ -0,0 +1,11 @@
+import { AdapterDate } from './AdapterDate.js';
+import { createDateUtils } from './createDateUtils.js';
+export { AdapterDate } from './AdapterDate.js';
+export { createDateUtils } from './createDateUtils.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/dist/luxon.d.ts

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

package/dist/luxon.js

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

package/dist/types.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 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/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,77 @@
 {
   "name": "svelte-date-utils",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Date helpers for calendars and date inputs (start, end, previous, next and range of a century, decade, year, month and day) that work on native Date, date-fns or Luxon through adapters.",
+  "keywords": [
+    "date",
+    "date-fns",
+    "luxon",
+    "svelte",
+    "utils"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Adhi Ravishankar",
+    "email": "adhiravishankar@gmail.com"
+  },
+  "files": [
+    "dist/**/*",
+    "src/**/*",
+    "!**/*.spec.*"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./date-fns": {
+      "types": "./dist/date-fns.d.ts",
+      "default": "./dist/date-fns.js"
+    },
+    "./luxon": {
+      "types": "./dist/luxon.d.ts",
+      "default": "./dist/luxon.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "node -e \"fs.rmSync('./dist', { recursive: true, force: true })\"",
+    "format": "vp fmt --check",
+    "lint": "vp lint",
+    "prepack": "npm run clean && npm run build",
+    "test": "npm run tsc && npm run format && npm run unit",
+    "tsc": "tsc",
+    "unit": "vp test",
+    "watch": "tsc -p tsconfig.build.json --watch"
+  },
+  "devDependencies": {
+    "@types/luxon": "^3.7.1",
+    "@vitest/browser-playwright": "5.0.5",
+    "date-fns": "^4.1.0",
+    "luxon": "^3.7.2",
+    "playwright": "^1.64.1",
+    "typescript": "^6.0.3",
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.4.0",
+    "vite-plus": "1.4.0",
+    "vitest": "5.0.5"
+  },
+  "peerDependencies": {
+    "date-fns": "^3.2.0 || ^4.0.0",
+    "luxon": "^3.0.2"
+  },
+  "peerDependenciesMeta": {
+    "date-fns": {
+      "optional": true
+    },
+    "luxon": {
+      "optional": true
+    }
+  }
+}

package/src/AdapterDate.ts

@@ -0,0 +1,209 @@
+import type { DateAdapter } from './types.js';
+
+export interface AdapterDateOptions {
+  /** First day of the week, 0 (Sunday) to 6 (Saturday). Defaults to 0. */
+  weekStartsOn?: number;
+}
+
+const copy = (value: Date) => new Date(value.getTime());
+
+/** Adapter for the native `Date`, with no dependency. The default adapter of the package. */
+export class AdapterDate implements DateAdapter<Date> {
+  public readonly lib = 'native';
+
+  private readonly weekStartsOn: number;
+
+  constructor({ weekStartsOn = 0 }: AdapterDateOptions = {}) {
+    this.weekStartsOn = weekStartsOn;
+  }
+
+  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 instanceof Date && !Number.isNaN(value.getTime());
+  public toJsDate = (value: Date) => value;
+
+  public formatByString = (value: Date, format: string): string => {
+    const pad = (n: number, length = 2) => String(n).padStart(length, '0');
+    const tokens: Record<string, string> = {
+      yyyy: pad(value.getFullYear(), 4),
+      MM: pad(value.getMonth() + 1),
+      dd: pad(value.getDate()),
+      HH: pad(value.getHours()),
+      mm: pad(value.getMinutes()),
+      ss: pad(value.getSeconds()),
+      SSS: pad(value.getMilliseconds(), 3),
+    };
+    return format.replace(/yyyy|MM|dd|HH|mm|ss|SSS/g, (token) => tokens[token] ?? token);
+  };
+
+  /** Parses the numeric tokens `yyyy MM dd HH mm ss`. Use another adapter for locale formats. */
+  public parse = (value: string, format: string): Date | null => {
+    if (value === '') return null;
+    const order: string[] = [];
+    const source = format
+      .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+      .replace(/yyyy|MM|dd|HH|mm|ss/g, (token) => {
+        order.push(token);
+        return `(\\d{${token.length}})`;
+      });
+    const match = new RegExp(`^${source}$`).exec(value);
+    if (!match) return this.getInvalidDate();
+    const part = (token: string, fallback: number) => {
+      const index = order.indexOf(token);
+      return index === -1 ? fallback : Number(match[index + 1]);
+    };
+    const result = new Date(
+      part('yyyy', 1970),
+      part('MM', 1) - 1,
+      part('dd', 1),
+      part('HH', 0),
+      part('mm', 0),
+      part('ss', 0),
+    );
+    // new Date(99, ...) means 1999: keep the year as written
+    result.setFullYear(part('yyyy', 1970));
+    return result;
+  };
+
+  public isEqual = (value: Date | null, comparing: Date | null) =>
+    value === null || comparing === null ? value === comparing : +value === +comparing;
+  public isSameYear = (value: Date, comparing: Date) =>
+    value.getFullYear() === comparing.getFullYear();
+  public isSameMonth = (value: Date, comparing: Date) =>
+    this.isSameYear(value, comparing) && value.getMonth() === comparing.getMonth();
+  public isSameDay = (value: Date, comparing: Date) =>
+    this.isSameMonth(value, comparing) && value.getDate() === comparing.getDate();
+  public isAfter = (value: Date, comparing: Date) => value > comparing;
+  public isBefore = (value: Date, comparing: Date) => value < comparing;
+  public isWithinRange = (value: Date, [start, end]: [Date, Date]) =>
+    value >= start && value <= end;
+
+  public startOfYear = (value: Date) => {
+    const result = new Date(0);
+    result.setFullYear(value.getFullYear(), 0, 1);
+    result.setHours(0, 0, 0, 0);
+    return result;
+  };
+  public startOfMonth = (value: Date) => this.startOfDay(this.setDate(value, 1));
+  public startOfWeek = (value: Date) => {
+    const diff = (value.getDay() - this.weekStartsOn + 7) % 7;
+    return this.startOfDay(this.addDays(value, -diff));
+  };
+  public startOfDay = (value: Date) => {
+    const result = copy(value);
+    result.setHours(0, 0, 0, 0);
+    return result;
+  };
+  public endOfYear = (value: Date) => {
+    const result = copy(value);
+    result.setMonth(11, 31);
+    result.setHours(23, 59, 59, 999);
+    return result;
+  };
+  public endOfMonth = (value: Date) => {
+    const result = this.setDate(value, this.getDaysInMonth(value));
+    result.setHours(23, 59, 59, 999);
+    return result;
+  };
+  public endOfWeek = (value: Date) => this.endOfDay(this.addDays(this.startOfWeek(value), 6));
+  public endOfDay = (value: Date) => {
+    const result = copy(value);
+    result.setHours(23, 59, 59, 999);
+    return result;
+  };
+
+  public addYears = (value: Date, amount: number) => this.addMonths(value, amount * 12);
+  /** Clamps to the last day of the target month, like date-fns and Luxon: Jan 31 + 1 month is Feb 28. */
+  public addMonths = (value: Date, amount: number) => {
+    const result = copy(value);
+    result.setDate(1);
+    result.setMonth(result.getMonth() + amount);
+    result.setDate(Math.min(value.getDate(), this.getDaysInMonth(result)));
+    return result;
+  };
+  public addWeeks = (value: Date, amount: number) => this.addDays(value, amount * 7);
+  public addDays = (value: Date, amount: number) => {
+    const result = copy(value);
+    result.setDate(result.getDate() + amount);
+    return result;
+  };
+  public addHours = (value: Date, amount: number) => new Date(value.getTime() + amount * 3_600_000);
+  public addMinutes = (value: Date, amount: number) => new Date(value.getTime() + amount * 60_000);
+  public addSeconds = (value: Date, amount: number) => new Date(value.getTime() + amount * 1000);
+
+  public getYear = (value: Date) => value.getFullYear();
+  public getMonth = (value: Date) => value.getMonth();
+  public getDate = (value: Date) => value.getDate();
+  public getHours = (value: Date) => value.getHours();
+  public getMinutes = (value: Date) => value.getMinutes();
+  public getSeconds = (value: Date) => value.getSeconds();
+  public getMilliseconds = (value: Date) => value.getMilliseconds();
+
+  /** Clamps the day when the target month is shorter (Feb 29 to a common year is Feb 28). */
+  public setYear = (value: Date, year: number) => {
+    const result = copy(value);
+    result.setFullYear(year, value.getMonth(), 1);
+    result.setDate(Math.min(value.getDate(), this.getDaysInMonth(result)));
+    return result;
+  };
+  public setMonth = (value: Date, month: number) => {
+    const result = copy(value);
+    result.setMonth(month, 1);
+    result.setDate(Math.min(value.getDate(), this.getDaysInMonth(result)));
+    return result;
+  };
+  public setDate = (value: Date, date: number) => {
+    const result = copy(value);
+    result.setDate(date);
+    return result;
+  };
+  public setHours = (value: Date, hours: number) => {
+    const result = copy(value);
+    result.setHours(hours);
+    return result;
+  };
+  public setMinutes = (value: Date, minutes: number) => {
+    const result = copy(value);
+    result.setMinutes(minutes);
+    return result;
+  };
+  public setSeconds = (value: Date, seconds: number) => {
+    const result = copy(value);
+    result.setSeconds(seconds);
+    return result;
+  };
+  public setMilliseconds = (value: Date, milliseconds: number) => {
+    const result = copy(value);
+    result.setMilliseconds(milliseconds);
+    return result;
+  };
+
+  public getDaysInMonth = (value: Date) =>
+    new Date(value.getFullYear(), value.getMonth() + 1, 0).getDate();
+
+  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; current < end; count += 1) {
+      const week = (weeks[Math.floor(count / 7)] ??= []);
+      week.push(current);
+      current = this.addDays(current, 1);
+    }
+    return weeks;
+  };
+
+  /** Week of the year, where week 1 holds January 1 (the date-fns default for `getWeek`). */
+  public getWeekNumber = (value: Date) => {
+    const yearStart = this.startOfWeek(this.startOfYear(value));
+    const weekStart = this.startOfWeek(value);
+    const nextYearStart = this.startOfWeek(this.startOfYear(this.addYears(value, 1)));
+    // the last days of December can belong to week 1 of the next year
+    if (weekStart >= nextYearStart) return 1;
+    return Math.round((weekStart.getTime() - yearStart.getTime()) / (7 * 86_400_000)) + 1;
+  };
+
+  public getDayOfWeek = (value: Date) => ((value.getDay() - this.weekStartsOn + 7) % 7) + 1;
+}