svelte-date-utils 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,28 @@
+MIT License
+
+Copyright (c) 2018–2026 Wojciech Maj
+Copyright (c) 2026 Adhi Ravishankar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+The adapters in src/AdapterDateFns.ts and src/AdapterLuxon.ts are adapted from the
+adapters in @mui/x-date-pickers (MIT, Copyright (c) 2020 MUI Team), which are based on
+@date-io (MIT, Copyright (c) 2017 Dmitriy Kovalenko). The function names and behavior in
+src/createDateUtils.ts follow @wojtekmaj/date-utils (MIT, Copyright (c) Wojciech Maj).

package/dist/AdapterDate.d.ts

@@ -0,0 +1,61 @@
+import type { DateAdapter } from './types.js';
+export interface AdapterDateOptions {
+    /** First day of the week, 0 (Sunday) to 6 (Saturday). Defaults to 0. */
+    weekStartsOn?: number;
+}
+/** Adapter for the native `Date`, with no dependency. The default adapter of the package. */
+export declare class AdapterDate implements DateAdapter<Date> {
+    readonly lib = "native";
+    private readonly weekStartsOn;
+    constructor({ weekStartsOn }?: AdapterDateOptions);
+    date: (value?: string) => Date;
+    getInvalidDate: () => Date;
+    isValid: (value: Date | null | undefined) => value is Date;
+    toJsDate: (value: Date) => Date;
+    formatByString: (value: Date, format: string) => string;
+    /** Parses the numeric tokens `yyyy MM dd HH mm ss`. Use another adapter for locale formats. */
+    parse: (value: string, format: string) => Date | null;
+    isEqual: (value: Date | null, comparing: Date | null) => boolean;
+    isSameYear: (value: Date, comparing: Date) => boolean;
+    isSameMonth: (value: Date, comparing: Date) => boolean;
+    isSameDay: (value: Date, comparing: Date) => boolean;
+    isAfter: (value: Date, comparing: Date) => boolean;
+    isBefore: (value: Date, comparing: Date) => boolean;
+    isWithinRange: (value: Date, [start, end]: [Date, Date]) => boolean;
+    startOfYear: (value: Date) => Date;
+    startOfMonth: (value: Date) => Date;
+    startOfWeek: (value: Date) => Date;
+    startOfDay: (value: Date) => Date;
+    endOfYear: (value: Date) => Date;
+    endOfMonth: (value: Date) => Date;
+    endOfWeek: (value: Date) => Date;
+    endOfDay: (value: Date) => Date;
+    addYears: (value: Date, amount: number) => Date;
+    /** Clamps to the last day of the target month, like date-fns and Luxon: Jan 31 + 1 month is Feb 28. */
+    addMonths: (value: Date, amount: number) => Date;
+    addWeeks: (value: Date, amount: number) => Date;
+    addDays: (value: Date, amount: number) => Date;
+    addHours: (value: Date, amount: number) => Date;
+    addMinutes: (value: Date, amount: number) => Date;
+    addSeconds: (value: Date, amount: number) => Date;
+    getYear: (value: Date) => number;
+    getMonth: (value: Date) => number;
+    getDate: (value: Date) => number;
+    getHours: (value: Date) => number;
+    getMinutes: (value: Date) => number;
+    getSeconds: (value: Date) => number;
+    getMilliseconds: (value: Date) => number;
+    /** Clamps the day when the target month is shorter (Feb 29 to a common year is Feb 28). */
+    setYear: (value: Date, year: number) => Date;
+    setMonth: (value: Date, month: number) => Date;
+    setDate: (value: Date, date: number) => Date;
+    setHours: (value: Date, hours: number) => Date;
+    setMinutes: (value: Date, minutes: number) => Date;
+    setSeconds: (value: Date, seconds: number) => Date;
+    setMilliseconds: (value: Date, milliseconds: number) => Date;
+    getDaysInMonth: (value: Date) => number;
+    getWeekArray: (value: Date) => Date[][];
+    /** Week of the year, where week 1 holds January 1 (the date-fns default for `getWeek`). */
+    getWeekNumber: (value: Date) => number;
+    getDayOfWeek: (value: Date) => number;
+}

package/dist/AdapterDate.js

@@ -0,0 +1,176 @@
+const copy = (value) => new Date(value.getTime());
+/** Adapter for the native `Date`, with no dependency. The default adapter of the package. */
+export class AdapterDate {
+    lib = 'native';
+    weekStartsOn;
+    constructor({ weekStartsOn = 0 } = {}) {
+        this.weekStartsOn = weekStartsOn;
+    }
+    date = (value) => (value === undefined ? new Date() : new Date(value));
+    getInvalidDate = () => new Date('Invalid Date');
+    isValid = (value) => value instanceof Date && !Number.isNaN(value.getTime());
+    toJsDate = (value) => value;
+    formatByString = (value, format) => {
+        const pad = (n, length = 2) => String(n).padStart(length, '0');
+        const tokens = {
+            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. */
+    parse = (value, format) => {
+        if (value === '')
+            return null;
+        const order = [];
+        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, fallback) => {
+            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;
+    };
+    isEqual = (value, comparing) => value === null || comparing === null ? value === comparing : +value === +comparing;
+    isSameYear = (value, comparing) => value.getFullYear() === comparing.getFullYear();
+    isSameMonth = (value, comparing) => this.isSameYear(value, comparing) && value.getMonth() === comparing.getMonth();
+    isSameDay = (value, comparing) => this.isSameMonth(value, comparing) && value.getDate() === comparing.getDate();
+    isAfter = (value, comparing) => value > comparing;
+    isBefore = (value, comparing) => value < comparing;
+    isWithinRange = (value, [start, end]) => value >= start && value <= end;
+    startOfYear = (value) => {
+        const result = new Date(0);
+        result.setFullYear(value.getFullYear(), 0, 1);
+        result.setHours(0, 0, 0, 0);
+        return result;
+    };
+    startOfMonth = (value) => this.startOfDay(this.setDate(value, 1));
+    startOfWeek = (value) => {
+        const diff = (value.getDay() - this.weekStartsOn + 7) % 7;
+        return this.startOfDay(this.addDays(value, -diff));
+    };
+    startOfDay = (value) => {
+        const result = copy(value);
+        result.setHours(0, 0, 0, 0);
+        return result;
+    };
+    endOfYear = (value) => {
+        const result = copy(value);
+        result.setMonth(11, 31);
+        result.setHours(23, 59, 59, 999);
+        return result;
+    };
+    endOfMonth = (value) => {
+        const result = this.setDate(value, this.getDaysInMonth(value));
+        result.setHours(23, 59, 59, 999);
+        return result;
+    };
+    endOfWeek = (value) => this.endOfDay(this.addDays(this.startOfWeek(value), 6));
+    endOfDay = (value) => {
+        const result = copy(value);
+        result.setHours(23, 59, 59, 999);
+        return result;
+    };
+    addYears = (value, amount) => 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. */
+    addMonths = (value, amount) => {
+        const result = copy(value);
+        result.setDate(1);
+        result.setMonth(result.getMonth() + amount);
+        result.setDate(Math.min(value.getDate(), this.getDaysInMonth(result)));
+        return result;
+    };
+    addWeeks = (value, amount) => this.addDays(value, amount * 7);
+    addDays = (value, amount) => {
+        const result = copy(value);
+        result.setDate(result.getDate() + amount);
+        return result;
+    };
+    addHours = (value, amount) => new Date(value.getTime() + amount * 3_600_000);
+    addMinutes = (value, amount) => new Date(value.getTime() + amount * 60_000);
+    addSeconds = (value, amount) => new Date(value.getTime() + amount * 1000);
+    getYear = (value) => value.getFullYear();
+    getMonth = (value) => value.getMonth();
+    getDate = (value) => value.getDate();
+    getHours = (value) => value.getHours();
+    getMinutes = (value) => value.getMinutes();
+    getSeconds = (value) => value.getSeconds();
+    getMilliseconds = (value) => value.getMilliseconds();
+    /** Clamps the day when the target month is shorter (Feb 29 to a common year is Feb 28). */
+    setYear = (value, year) => {
+        const result = copy(value);
+        result.setFullYear(year, value.getMonth(), 1);
+        result.setDate(Math.min(value.getDate(), this.getDaysInMonth(result)));
+        return result;
+    };
+    setMonth = (value, month) => {
+        const result = copy(value);
+        result.setMonth(month, 1);
+        result.setDate(Math.min(value.getDate(), this.getDaysInMonth(result)));
+        return result;
+    };
+    setDate = (value, date) => {
+        const result = copy(value);
+        result.setDate(date);
+        return result;
+    };
+    setHours = (value, hours) => {
+        const result = copy(value);
+        result.setHours(hours);
+        return result;
+    };
+    setMinutes = (value, minutes) => {
+        const result = copy(value);
+        result.setMinutes(minutes);
+        return result;
+    };
+    setSeconds = (value, seconds) => {
+        const result = copy(value);
+        result.setSeconds(seconds);
+        return result;
+    };
+    setMilliseconds = (value, milliseconds) => {
+        const result = copy(value);
+        result.setMilliseconds(milliseconds);
+        return result;
+    };
+    getDaysInMonth = (value) => new Date(value.getFullYear(), value.getMonth() + 1, 0).getDate();
+    getWeekArray = (value) => {
+        const start = this.startOfWeek(this.startOfMonth(value));
+        const end = this.endOfWeek(this.endOfMonth(value));
+        const weeks = [];
+        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`). */
+    getWeekNumber = (value) => {
+        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;
+    };
+    getDayOfWeek = (value) => ((value.getDay() - this.weekStartsOn + 7) % 7) + 1;
+}

package/dist/AdapterDateFns.d.ts

@@ -0,0 +1,58 @@
+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 declare class AdapterDateFns implements DateAdapter<Date> {
+    readonly lib = "date-fns";
+    readonly locale: Locale;
+    constructor({ locale }?: AdapterDateFnsOptions);
+    date: (value?: string) => Date;
+    getInvalidDate: () => Date;
+    isValid: (value: Date | null | undefined) => value is Date;
+    toJsDate: (value: Date) => Date;
+    formatByString: (value: Date, formatString: string) => string;
+    parse: (value: string, formatString: string) => Date | null;
+    isEqual: (value: Date | null, comparing: Date | null) => boolean;
+    isSameYear: (value: Date, comparing: Date) => boolean;
+    isSameMonth: (value: Date, comparing: Date) => boolean;
+    isSameDay: (value: Date, comparing: Date) => boolean;
+    isAfter: (value: Date, comparing: Date) => boolean;
+    isBefore: (value: Date, comparing: Date) => boolean;
+    isWithinRange: (value: Date, [start, end]: [Date, Date]) => boolean;
+    startOfYear: (value: Date) => Date;
+    startOfMonth: (value: Date) => Date;
+    startOfWeek: (value: Date) => Date;
+    startOfDay: (value: Date) => Date;
+    endOfYear: (value: Date) => Date;
+    endOfMonth: (value: Date) => Date;
+    endOfWeek: (value: Date) => Date;
+    endOfDay: (value: Date) => Date;
+    addYears: (value: Date, amount: number) => Date;
+    addMonths: (value: Date, amount: number) => Date;
+    addWeeks: (value: Date, amount: number) => Date;
+    addDays: (value: Date, amount: number) => Date;
+    addHours: (value: Date, amount: number) => Date;
+    addMinutes: (value: Date, amount: number) => Date;
+    addSeconds: (value: Date, amount: number) => Date;
+    getYear: (value: Date) => number;
+    getMonth: (value: Date) => number;
+    getDate: (value: Date) => number;
+    getHours: (value: Date) => number;
+    getMinutes: (value: Date) => number;
+    getSeconds: (value: Date) => number;
+    getMilliseconds: (value: Date) => number;
+    setYear: (value: Date, year: number) => Date;
+    setMonth: (value: Date, month: number) => Date;
+    setDate: (value: Date, date: number) => Date;
+    setHours: (value: Date, hours: number) => Date;
+    setMinutes: (value: Date, minutes: number) => Date;
+    setSeconds: (value: Date, seconds: number) => Date;
+    setMilliseconds: (value: Date, milliseconds: number) => Date;
+    getDaysInMonth: (value: Date) => number;
+    getWeekArray: (value: Date) => Date[][];
+    getWeekNumber: (value: Date) => number;
+    getDayOfWeek: (value: Date) => number;
+}

package/dist/AdapterDateFns.js

@@ -0,0 +1,110 @@
+// 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';
+/** Adapter for date-fns v3 and v4. Values are native `Date` objects. */
+export class AdapterDateFns {
+    lib = 'date-fns';
+    locale;
+    constructor({ locale } = {}) {
+        this.locale = locale ?? enUS;
+    }
+    date = (value) => (value === undefined ? new Date() : new Date(value));
+    getInvalidDate = () => new Date('Invalid Date');
+    isValid = (value) => value != null && isValid(value);
+    toJsDate = (value) => value;
+    formatByString = (value, formatString) => format(value, formatString, { locale: this.locale });
+    parse = (value, formatString) => value === '' ? null : parse(value, formatString, new Date(), { locale: this.locale });
+    isEqual = (value, comparing) => value === null || comparing === null ? value === comparing : isEqual(value, comparing);
+    isSameYear = (value, comparing) => isSameYear(value, comparing);
+    isSameMonth = (value, comparing) => isSameMonth(value, comparing);
+    isSameDay = (value, comparing) => isSameDay(value, comparing);
+    isAfter = (value, comparing) => isAfter(value, comparing);
+    isBefore = (value, comparing) => isBefore(value, comparing);
+    isWithinRange = (value, [start, end]) => isWithinInterval(value, { start, end });
+    startOfYear = (value) => startOfYear(value);
+    startOfMonth = (value) => startOfMonth(value);
+    startOfWeek = (value) => startOfWeek(value, { locale: this.locale });
+    startOfDay = (value) => startOfDay(value);
+    endOfYear = (value) => endOfYear(value);
+    endOfMonth = (value) => endOfMonth(value);
+    endOfWeek = (value) => endOfWeek(value, { locale: this.locale });
+    endOfDay = (value) => endOfDay(value);
+    addYears = (value, amount) => addYears(value, amount);
+    addMonths = (value, amount) => addMonths(value, amount);
+    addWeeks = (value, amount) => addWeeks(value, amount);
+    addDays = (value, amount) => addDays(value, amount);
+    addHours = (value, amount) => addHours(value, amount);
+    addMinutes = (value, amount) => addMinutes(value, amount);
+    addSeconds = (value, amount) => addSeconds(value, amount);
+    getYear = (value) => getYear(value);
+    getMonth = (value) => getMonth(value);
+    getDate = (value) => getDate(value);
+    getHours = (value) => getHours(value);
+    getMinutes = (value) => getMinutes(value);
+    getSeconds = (value) => getSeconds(value);
+    getMilliseconds = (value) => getMilliseconds(value);
+    setYear = (value, year) => setYear(value, year);
+    setMonth = (value, month) => setMonth(value, month);
+    setDate = (value, date) => setDate(value, date);
+    setHours = (value, hours) => setHours(value, hours);
+    setMinutes = (value, minutes) => setMinutes(value, minutes);
+    setSeconds = (value, seconds) => setSeconds(value, seconds);
+    setMilliseconds = (value, milliseconds) => setMilliseconds(value, milliseconds);
+    getDaysInMonth = (value) => getDaysInMonth(value);
+    getWeekArray = (value) => {
+        const start = this.startOfWeek(this.startOfMonth(value));
+        const end = this.endOfWeek(this.endOfMonth(value));
+        const weeks = [];
+        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;
+    };
+    getWeekNumber = (value) => getWeek(value, { locale: this.locale });
+    getDayOfWeek = (value) => ((getDay(value) - (this.locale.options?.weekStartsOn ?? 0) + 7) % 7) + 1;
+}

package/dist/AdapterLuxon.d.ts

@@ -0,0 +1,59 @@
+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 declare class AdapterLuxon implements DateAdapter<DateTime> {
+    readonly lib = "luxon";
+    readonly locale: string;
+    constructor({ locale }?: AdapterLuxonOptions);
+    private withLocale;
+    date: (value?: string) => DateTime<true> | DateTime<false>;
+    getInvalidDate: () => DateTime<true> | DateTime<false>;
+    isValid: (value: DateTime | null | undefined) => value is DateTime;
+    toJsDate: (value: DateTime) => Date;
+    formatByString: (value: DateTime, format: string) => string;
+    parse: (value: string, format: string) => DateTime<true> | DateTime<false> | null;
+    isEqual: (value: DateTime | null, comparing: DateTime | null) => boolean;
+    isSameYear: (value: DateTime, comparing: DateTime) => boolean;
+    isSameMonth: (value: DateTime, comparing: DateTime) => boolean;
+    isSameDay: (value: DateTime, comparing: DateTime) => boolean;
+    isAfter: (value: DateTime, comparing: DateTime) => boolean;
+    isBefore: (value: DateTime, comparing: DateTime) => boolean;
+    isWithinRange: (value: DateTime, [start, end]: [DateTime, DateTime]) => boolean;
+    startOfYear: (value: DateTime) => DateTime<boolean>;
+    startOfMonth: (value: DateTime) => DateTime<boolean>;
+    startOfWeek: (value: DateTime) => DateTime<boolean>;
+    startOfDay: (value: DateTime) => DateTime<boolean>;
+    endOfYear: (value: DateTime) => DateTime<boolean>;
+    endOfMonth: (value: DateTime) => DateTime<boolean>;
+    endOfWeek: (value: DateTime) => DateTime<boolean>;
+    endOfDay: (value: DateTime) => DateTime<boolean>;
+    addYears: (value: DateTime, amount: number) => DateTime<boolean>;
+    addMonths: (value: DateTime, amount: number) => DateTime<boolean>;
+    addWeeks: (value: DateTime, amount: number) => DateTime<boolean>;
+    addDays: (value: DateTime, amount: number) => DateTime<boolean>;
+    addHours: (value: DateTime, amount: number) => DateTime<boolean>;
+    addMinutes: (value: DateTime, amount: number) => DateTime<boolean>;
+    addSeconds: (value: DateTime, amount: number) => DateTime<boolean>;
+    getYear: (value: DateTime) => number;
+    getMonth: (value: DateTime) => number;
+    getDate: (value: DateTime) => number;
+    getHours: (value: DateTime) => number;
+    getMinutes: (value: DateTime) => number;
+    getSeconds: (value: DateTime) => number;
+    getMilliseconds: (value: DateTime) => number;
+    setYear: (value: DateTime, year: number) => DateTime<boolean>;
+    setMonth: (value: DateTime, month: number) => DateTime<boolean>;
+    setDate: (value: DateTime, date: number) => DateTime<boolean>;
+    setHours: (value: DateTime, hour: number) => DateTime<boolean>;
+    setMinutes: (value: DateTime, minute: number) => DateTime<boolean>;
+    setSeconds: (value: DateTime, second: number) => DateTime<boolean>;
+    setMilliseconds: (value: DateTime, millisecond: number) => DateTime<boolean>;
+    getDaysInMonth: (value: DateTime) => import("luxon").PossibleDaysInMonth;
+    getWeekArray: (value: DateTime) => DateTime<boolean>[][];
+    getWeekNumber: (value: DateTime) => number;
+    getDayOfWeek: (value: DateTime) => number;
+}

package/dist/AdapterLuxon.js

@@ -0,0 +1,72 @@
+// 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';
+/** Adapter for Luxon v3. Values are `DateTime` objects, in the zone they were created in. */
+export class AdapterLuxon {
+    lib = 'luxon';
+    locale;
+    constructor({ locale } = {}) {
+        this.locale = locale || 'en-US';
+    }
+    withLocale = (value) => value.locale === this.locale ? value : value.setLocale(this.locale);
+    date = (value) => value === undefined
+        ? DateTime.now().setLocale(this.locale)
+        : DateTime.fromISO(value, { locale: this.locale });
+    getInvalidDate = () => DateTime.fromJSDate(new Date('Invalid Date'));
+    isValid = (value) => value != null && value.isValid;
+    toJsDate = (value) => value.toJSDate();
+    formatByString = (value, format) => value.setLocale(this.locale).toFormat(format);
+    parse = (value, format) => value === '' ? null : DateTime.fromFormat(value, format, { locale: this.locale });
+    isEqual = (value, comparing) => value === null || comparing === null ? value === comparing : +value === +comparing;
+    // the comparison happens in the zone of `value`
+    isSameYear = (value, comparing) => value.hasSame(comparing.setZone(value.zone), 'year');
+    isSameMonth = (value, comparing) => value.hasSame(comparing.setZone(value.zone), 'month');
+    isSameDay = (value, comparing) => value.hasSame(comparing.setZone(value.zone), 'day');
+    isAfter = (value, comparing) => value > comparing;
+    isBefore = (value, comparing) => value < comparing;
+    isWithinRange = (value, [start, end]) => value >= start && value <= end;
+    startOfYear = (value) => value.startOf('year');
+    startOfMonth = (value) => value.startOf('month');
+    startOfWeek = (value) => this.withLocale(value).startOf('week', { useLocaleWeeks: true });
+    startOfDay = (value) => value.startOf('day');
+    endOfYear = (value) => value.endOf('year');
+    endOfMonth = (value) => value.endOf('month');
+    endOfWeek = (value) => this.withLocale(value).endOf('week', { useLocaleWeeks: true });
+    endOfDay = (value) => value.endOf('day');
+    addYears = (value, amount) => value.plus({ years: amount });
+    addMonths = (value, amount) => value.plus({ months: amount });
+    addWeeks = (value, amount) => value.plus({ weeks: amount });
+    addDays = (value, amount) => value.plus({ days: amount });
+    addHours = (value, amount) => value.plus({ hours: amount });
+    addMinutes = (value, amount) => value.plus({ minutes: amount });
+    addSeconds = (value, amount) => value.plus({ seconds: amount });
+    getYear = (value) => value.year;
+    // Luxon months are 1-based
+    getMonth = (value) => value.month - 1;
+    getDate = (value) => value.day;
+    getHours = (value) => value.hour;
+    getMinutes = (value) => value.minute;
+    getSeconds = (value) => value.second;
+    getMilliseconds = (value) => value.millisecond;
+    setYear = (value, year) => value.set({ year });
+    setMonth = (value, month) => value.set({ month: month + 1 });
+    setDate = (value, date) => value.set({ day: date });
+    setHours = (value, hour) => value.set({ hour });
+    setMinutes = (value, minute) => value.set({ minute });
+    setSeconds = (value, second) => value.set({ second });
+    setMilliseconds = (value, millisecond) => value.set({ millisecond });
+    getDaysInMonth = (value) => value.daysInMonth;
+    getWeekArray = (value) => {
+        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 = [];
+        for (let day = 0; day < days; day += 1) {
+            const week = (weeks[Math.floor(day / 7)] ??= []);
+            week.push(first.plus({ days: day }));
+        }
+        return weeks;
+    };
+    getWeekNumber = (value) => this.withLocale(value).localWeekNumber ?? value.weekNumber;
+    getDayOfWeek = (value) => this.withLocale(value).localWeekday ?? value.weekday;
+}

package/dist/createDateUtils.d.ts

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