mui-temporal-pickers 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2025, Ben Scholzen 'DASPRiD'
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,130 @@
+# Temporal Pickers for MUI X
+
+[![Release](https://github.com/dasprid/mui-temporal-pickers/actions/workflows/release.yml/badge.svg)](https://github.com/dasprid/mui-temporal-pickers/actions/workflows/release.yml)
+
+A small utility library providing [Temporal](https://tc39.es/proposal-temporal/) support for
+[MUI X Date and Time Pickers](https://mui.com/x/react-date-pickers/).
+
+This package bridges the gap between MUI X and the TC39 Temporal API by introducing context-based providers that adapt
+pickers to work seamlessly with `Temporal.PlainDate`, `Temporal.PlainTime`, `Temporal.PlainDateTime`, and
+`Temporal.ZonedDateTime`.
+
+## Features
+
+- Plug-and-play support for Temporal types in MUI X pickers
+- Supports all major temporal types: `PlainDate`, `PlainTime`, `PlainDateTime`, `ZonedDateTime`
+- Global locale, format, and text customization via root provider
+- Fully tree-shakable and composable
+- Built-in localization fallback to `en-US`
+
+## Getting Started
+
+Install via your favorite package manager:
+
+```bash
+npm install mui-temporal-pickers
+# or
+pnpm add mui-temporal-pickers
+# or
+yarn add mui-temporal-pickers
+```
+
+### Try the demo
+
+This repository includes a working demo app. You can run it locally using:
+
+```bash
+pnpm demo
+```
+
+This will launch a Vite-powered playground with all picker types wired up.
+
+## Using the Temporal Polyfill
+
+If you want to use the [Temporal API](https://tc39.es/proposal-temporal/) in environments where it is not yet natively
+supported, you can include the [temporal-polyfill](https://www.npmjs.com/package/temporal-polyfill).
+
+Once you have it installed, you can enable it:
+
+```ts
+if (typeof Temporal === "undefined") {
+    await import("temporal-polyfill/global");
+}
+```
+
+This will globally patch the environment, adding the Temporal API on `globalThis.Temporal`.
+
+### TypeScript support for Temporal
+
+To get proper TypeScript typings for the polyfill (and the Temporal API in general), you need to install the
+[temporal-spec](https://www.npmjs.com/package/temporal-spec) types package.
+
+Then create a `temporal.d.ts` file in your project (e.g., in your `src` folder or your `types` folder) with the
+following content:
+
+```ts
+import "temporal-spec/global";
+```
+
+This will augment the TypeScript global scope with Temporal API types, so your editor and compiler understand `Temporal`
+properly.
+
+## Usage
+
+### 1. (Optional) Wrap your app with TemporalRootProvider
+
+This allows you to configure global `locale`, `dateFormats`, and `localeText`, similar to MUI's `LocalizationProvider`.
+You can omit this if you don't need customization.
+
+```tsx
+import { TemporalRootProvider } from 'mui-temporal-pickers';
+
+<TemporalRootProvider locale="de-DE">
+    <App />
+</TemporalRootProvider>
+```
+
+### 2. Wrap pickers with the appropriate Temporal provider
+
+You must wrap each picker (or group of same-kind pickers) in a provider that matches the Temporal type being used.
+
+```tsx
+import { TemporalPlainDateProvider } from 'mui-temporal-pickers';
+import { DatePicker, TimePicker, DateTimePicker } from '@mui/x-date-pickers';
+
+// Example: PlainDate
+<TemporalPlainDateProvider>
+    <DatePicker
+        label="PlainDate"
+        value={Temporal.PlainDate.from('2025-06-19')}
+        onChange={(val) => console.log(val?.toString())}
+    />
+</TemporalPlainDateProvider>
+```
+
+Pickers **must be wrapped** in the matching provider to work correctly. Mixed types or mismatched types will result in
+runtime errors.
+
+## Caveats
+
+### Limited formatting token support
+
+Due to how `Intl.DateTimeFormat` works, text field formatting only supports numeric tokens (like `yyyy`, `MM`, `dd`,
+`HH`, `mm`). Literal characters (like slashes or dashes) are fine.
+
+The only non-numeric token allowed is **AM/PM**, which is not currently localized and always displays as `"AM"` /
+`"PM"`.
+
+### No runtime validation of input types
+
+For performance reasons, this library **does not validate** that the value passed to a picker matches the expected
+Temporal type. Passing an incorrect type (e.g., `PlainDate` to a time picker) will lead to downstream errors from MUI
+or the Temporal API.
+
+Use with care and ensure values match the context's expectation.
+
+## Package Goals
+
+- Stay minimal: no runtime conversions or unnecessary wrappers
+- Keep compatibility with MUI X moving forward
+- Encourage adoption of Temporal without losing MUI's power

package/dist/adapters/adapter-formats.d.ts

@@ -0,0 +1,2 @@
+import type { AdapterFormats } from "@mui/x-date-pickers";
+export declare const defaultFormats: AdapterFormats;

package/dist/adapters/adapter-formats.js

@@ -0,0 +1,25 @@
+export const defaultFormats = {
+    year: "yyyy",
+    month: "MMMM",
+    monthShort: "MMM",
+    dayOfMonth: "d",
+    // Full day of the month format (i.e. 3rd) is not supported
+    // Falling back to regular format
+    dayOfMonthFull: "d",
+    weekday: "cccc",
+    weekdayShort: "ccc",
+    hours24h: "HH",
+    hours12h: "hh",
+    meridiem: "a",
+    minutes: "mm",
+    seconds: "ss",
+    fullDate: "lfd",
+    keyboardDate: "lkd",
+    shortDate: "lsd",
+    normalDate: "lnd",
+    normalDateWithWeekday: "lndw",
+    fullTime12h: "lfta",
+    fullTime24h: "lftd",
+    keyboardDateTime12h: "lkdta",
+    keyboardDateTime24h: "lkdtd",
+};

package/dist/adapters/base.d.ts

@@ -0,0 +1,97 @@
+import type { AdapterFormats, AdapterOptions, DateBuilderReturnType, FieldFormatTokenMap, MuiPickersAdapter, PickersTimezone } from "@mui/x-date-pickers";
+import { LocaleSpecs } from "../locale/specs.js";
+import { type AdapterComparisonOperations, type AdapterConversionOperations, type AdapterDateOperations, type AdapterTimeOperations, type AdapterTimezoneOperations } from "./operations.js";
+export type ValidTemporal = Temporal.PlainTime | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime;
+export type ValidTimeTemporal = Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime;
+export type ValidDateTemporal = Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime;
+declare module "@mui/x-date-pickers/models" {
+    interface PickerValidDateLookup {
+        temporal: ValidTemporal;
+    }
+}
+type AdapterTemporalOptions<T extends ValidTemporal> = {
+    conversionOperations: AdapterConversionOperations<T>;
+    comparisonOperations: AdapterComparisonOperations<T>;
+    dateOperations?: AdapterDateOperations<T>;
+    timeOperations?: AdapterTimeOperations<T>;
+    timezoneOperations?: AdapterTimezoneOperations<T>;
+};
+export declare abstract class AdapterTemporalBase<TTemporal extends ValidTemporal> implements MuiPickersAdapter<Intl.Locale> {
+    readonly isMUIAdapter = true;
+    readonly isTimezoneCompatible = true;
+    readonly lib = "temporal";
+    readonly locale: Intl.Locale;
+    readonly formats: AdapterFormats;
+    readonly escapedCharacters: {
+        start: string;
+        end: string;
+    };
+    abstract readonly formatTokenMap: FieldFormatTokenMap;
+    protected readonly localeSpecs: LocaleSpecs;
+    protected readonly conversionOperations: AdapterConversionOperations<TTemporal>;
+    protected readonly comparisonOperations: AdapterComparisonOperations<TTemporal>;
+    protected readonly dateOperations: AdapterDateOperations<TTemporal>;
+    protected readonly timeOperations: AdapterTimeOperations<TTemporal>;
+    protected readonly timezoneOperations: AdapterTimezoneOperations<TTemporal>;
+    protected constructor({ locale, formats, conversionOperations, comparisonOperations, dateOperations, timeOperations, timezoneOperations, }: AdapterOptions<Intl.Locale | string, never> & AdapterTemporalOptions<TTemporal>);
+    date<T extends string | null | undefined>(value?: T, timezone?: PickersTimezone): DateBuilderReturnType<T>;
+    toJsDate(value: TTemporal): Date;
+    parse(value: string, format: string): TTemporal | null;
+    isEqual(value: TTemporal | null, comparing: TTemporal | null): boolean;
+    isSameYear(value: TTemporal, comparing: TTemporal): boolean;
+    isSameMonth(value: TTemporal, comparing: TTemporal): boolean;
+    isSameDay(value: TTemporal, comparing: TTemporal): boolean;
+    isSameHour(value: TTemporal, comparing: TTemporal): boolean;
+    isAfter(value: TTemporal, comparing: TTemporal): boolean;
+    isAfterYear(value: TTemporal, comparing: TTemporal): boolean;
+    isAfterDay(value: TTemporal, comparing: TTemporal): boolean;
+    isBefore(value: TTemporal, comparing: TTemporal): boolean;
+    isBeforeYear(value: TTemporal, comparing: TTemporal): boolean;
+    isBeforeDay(value: TTemporal, comparing: TTemporal): boolean;
+    getInvalidDate(): TTemporal;
+    getTimezone(value: TTemporal | null): PickersTimezone;
+    setTimezone(value: TTemporal, timezone: PickersTimezone): TTemporal;
+    getCurrentLocaleCode(): string;
+    is12HourCycleInCurrentLocale(): boolean;
+    expandFormat(format: string): string;
+    isValid(value: TTemporal | null): value is TTemporal;
+    format(value: TTemporal, formatKey: keyof AdapterFormats): string;
+    formatByString(value: TTemporal, format: string): string;
+    formatNumber(numberToFormat: string): string;
+    isWithinRange(value: TTemporal, [start, end]: [TTemporal, TTemporal]): boolean;
+    startOfYear(value: TTemporal): TTemporal;
+    startOfMonth(value: TTemporal): TTemporal;
+    startOfWeek(value: TTemporal): TTemporal;
+    startOfDay(value: TTemporal): TTemporal;
+    endOfYear(value: TTemporal): TTemporal;
+    endOfMonth(value: TTemporal): TTemporal;
+    endOfWeek(value: TTemporal): TTemporal;
+    endOfDay(value: TTemporal): TTemporal;
+    addYears(value: TTemporal, amount: number): TTemporal;
+    addMonths(value: TTemporal, amount: number): TTemporal;
+    addWeeks(value: TTemporal, amount: number): TTemporal;
+    addDays(value: TTemporal, amount: number): TTemporal;
+    addHours(value: TTemporal, amount: number): TTemporal;
+    addMinutes(value: TTemporal, amount: number): TTemporal;
+    addSeconds(value: TTemporal, amount: number): TTemporal;
+    getYear(value: TTemporal): number;
+    getMonth(value: TTemporal): number;
+    getDate(value: TTemporal): number;
+    getHours(value: TTemporal): number;
+    getMinutes(value: TTemporal): number;
+    getSeconds(value: TTemporal): number;
+    getMilliseconds(value: TTemporal): number;
+    getDaysInMonth(value: TTemporal): number;
+    getWeekNumber(value: TTemporal): number;
+    getDayOfWeek(value: TTemporal): number;
+    setYear(value: TTemporal, year: number): TTemporal;
+    setMonth(value: TTemporal, month: number): TTemporal;
+    setDate(value: TTemporal, date: number): TTemporal;
+    setHours(value: TTemporal, hours: number): TTemporal;
+    setMinutes(value: TTemporal, minutes: number): TTemporal;
+    setSeconds(value: TTemporal, seconds: number): TTemporal;
+    setMilliseconds(value: TTemporal, milliseconds: number): TTemporal;
+    getWeekArray(value: TTemporal): TTemporal[][];
+    getYearRange(range: [TTemporal, TTemporal]): TTemporal[];
+}
+export {};

package/dist/adapters/base.js

@@ -0,0 +1,216 @@
+import { LocaleSpecs } from "../locale/specs.js";
+import { defaultFormats } from "./adapter-formats.js";
+import { noopAdapterDateOperations, noopAdapterTimeOperations, noopAdapterTimezoneOperations, } from "./operations.js";
+export class AdapterTemporalBase {
+    isMUIAdapter = true;
+    isTimezoneCompatible = true;
+    lib = "temporal";
+    locale;
+    formats;
+    escapedCharacters = { start: "'", end: "'" };
+    localeSpecs;
+    conversionOperations;
+    comparisonOperations;
+    dateOperations;
+    timeOperations;
+    timezoneOperations;
+    constructor({ locale = new Intl.Locale("en-US"), formats, conversionOperations, comparisonOperations, dateOperations = noopAdapterDateOperations, timeOperations = noopAdapterTimeOperations, timezoneOperations = noopAdapterTimezoneOperations, }) {
+        this.locale = typeof locale === "string" ? new Intl.Locale(locale) : locale;
+        this.localeSpecs = LocaleSpecs.get(this.locale);
+        this.formats = { ...defaultFormats, ...formats };
+        this.conversionOperations = conversionOperations;
+        this.comparisonOperations = comparisonOperations;
+        this.dateOperations = dateOperations;
+        this.timeOperations = timeOperations;
+        this.timezoneOperations = timezoneOperations;
+    }
+    date(value, timezone) {
+        return this.conversionOperations.date(value, timezone);
+    }
+    toJsDate(value) {
+        return this.conversionOperations.toJsDate(value);
+    }
+    parse(value, format) {
+        return this.conversionOperations.parse(value, format, this.localeSpecs);
+    }
+    isEqual(value, comparing) {
+        if (value === null && comparing === null) {
+            return true;
+        }
+        if (value === null || comparing === null) {
+            return false;
+        }
+        return this.comparisonOperations.isEqual(value, comparing);
+    }
+    isSameYear(value, comparing) {
+        return this.comparisonOperations.isSameYear(value, comparing);
+    }
+    isSameMonth(value, comparing) {
+        return this.comparisonOperations.isSameMonth(value, comparing);
+    }
+    isSameDay(value, comparing) {
+        return this.comparisonOperations.isSameDay(value, comparing);
+    }
+    isSameHour(value, comparing) {
+        return this.comparisonOperations.isSameHour(value, comparing);
+    }
+    isAfter(value, comparing) {
+        return this.comparisonOperations.isAfter(value, comparing);
+    }
+    isAfterYear(value, comparing) {
+        return this.comparisonOperations.isAfterYear(value, comparing);
+    }
+    isAfterDay(value, comparing) {
+        return this.comparisonOperations.isAfterDay(value, comparing);
+    }
+    isBefore(value, comparing) {
+        return this.comparisonOperations.isBefore(value, comparing);
+    }
+    isBeforeYear(value, comparing) {
+        return this.comparisonOperations.isBeforeYear(value, comparing);
+    }
+    isBeforeDay(value, comparing) {
+        return this.comparisonOperations.isBeforeDay(value, comparing);
+    }
+    getInvalidDate() {
+        return null;
+    }
+    getTimezone(value) {
+        return this.timezoneOperations.getTimezone(value);
+    }
+    setTimezone(value, timezone) {
+        return this.timezoneOperations.setTimezone(value, timezone);
+    }
+    getCurrentLocaleCode() {
+        return this.locale.toString();
+    }
+    is12HourCycleInCurrentLocale() {
+        return this.localeSpecs.hour12;
+    }
+    expandFormat(format) {
+        return this.localeSpecs.formatter.expandFormat(format);
+    }
+    isValid(value) {
+        return value !== null;
+    }
+    format(value, formatKey) {
+        return this.formatByString(value, this.formats[formatKey]);
+    }
+    formatByString(value, format) {
+        if (format === "s" && value instanceof Temporal.PlainDate) {
+            // This is MUI-X collecting localized digits. It allows us to return "0" here, which makes it fall back to
+            // non-localized digits!
+            return "0";
+        }
+        return this.localeSpecs.formatter.format(value, format);
+    }
+    formatNumber(numberToFormat) {
+        return numberToFormat;
+    }
+    isWithinRange(value, [start, end]) {
+        return !(this.comparisonOperations.isBefore(value, start) ||
+            this.comparisonOperations.isAfter(value, end));
+    }
+    startOfYear(value) {
+        return this.dateOperations.startOfYear(value);
+    }
+    startOfMonth(value) {
+        return this.dateOperations.startOfMonth(value);
+    }
+    startOfWeek(value) {
+        return this.dateOperations.startOfWeek(value, this.locale);
+    }
+    startOfDay(value) {
+        return this.timeOperations.startOfDay(value);
+    }
+    endOfYear(value) {
+        return this.dateOperations.endOfYear(value);
+    }
+    endOfMonth(value) {
+        return this.dateOperations.endOfMonth(value);
+    }
+    endOfWeek(value) {
+        return this.dateOperations.endOfWeek(value, this.locale);
+    }
+    endOfDay(value) {
+        return this.timeOperations.endOfDay(value);
+    }
+    addYears(value, amount) {
+        return this.dateOperations.addYears(value, amount);
+    }
+    addMonths(value, amount) {
+        return this.dateOperations.addMonths(value, amount);
+    }
+    addWeeks(value, amount) {
+        return this.dateOperations.addWeeks(value, amount);
+    }
+    addDays(value, amount) {
+        return this.dateOperations.addDays(value, amount);
+    }
+    addHours(value, amount) {
+        return this.timeOperations.addHours(value, amount);
+    }
+    addMinutes(value, amount) {
+        return this.timeOperations.addMinutes(value, amount);
+    }
+    addSeconds(value, amount) {
+        return this.timeOperations.addSeconds(value, amount);
+    }
+    getYear(value) {
+        return this.dateOperations.getYear(value);
+    }
+    getMonth(value) {
+        return this.dateOperations.getMonth(value);
+    }
+    getDate(value) {
+        return this.dateOperations.getDate(value);
+    }
+    getHours(value) {
+        return this.timeOperations.getHours(value);
+    }
+    getMinutes(value) {
+        return this.timeOperations.getMinutes(value);
+    }
+    getSeconds(value) {
+        return this.timeOperations.getSeconds(value);
+    }
+    getMilliseconds(value) {
+        return this.timeOperations.getMilliseconds(value);
+    }
+    getDaysInMonth(value) {
+        return this.dateOperations.getDaysInMonth(value);
+    }
+    getWeekNumber(value) {
+        return this.dateOperations.getWeekNumber(value, this.locale);
+    }
+    getDayOfWeek(value) {
+        return this.dateOperations.getDayOfWeek(value);
+    }
+    setYear(value, year) {
+        return this.dateOperations.setYear(value, year);
+    }
+    setMonth(value, month) {
+        return this.dateOperations.setMonth(value, month);
+    }
+    setDate(value, date) {
+        return this.dateOperations.setDate(value, date);
+    }
+    setHours(value, hours) {
+        return this.timeOperations.setHours(value, hours);
+    }
+    setMinutes(value, minutes) {
+        return this.timeOperations.setMinutes(value, minutes);
+    }
+    setSeconds(value, seconds) {
+        return this.timeOperations.setSeconds(value, seconds);
+    }
+    setMilliseconds(value, milliseconds) {
+        return this.timeOperations.setMilliseconds(value, milliseconds);
+    }
+    getWeekArray(value) {
+        return this.dateOperations.getWeekArray(value, this);
+    }
+    getYearRange(range) {
+        return this.dateOperations.getYearRange(range, this);
+    }
+}

package/dist/adapters/operations.d.ts

@@ -0,0 +1,70 @@
+import type { DateBuilderReturnType, PickersTimezone } from "@mui/x-date-pickers";
+import type { LocaleSpecs } from "../locale/specs.js";
+import type { AdapterTemporalBase, ValidDateTemporal, ValidTemporal, ValidTimeTemporal } from "./base.js";
+export type AdapterConversionOperations<T extends ValidTemporal> = {
+    date: <T extends string | null | undefined>(value?: T, timezone?: PickersTimezone) => DateBuilderReturnType<T>;
+    toJsDate: (value: T) => Date;
+    parse: (value: string, format: string, localeSpecs: LocaleSpecs) => T | null;
+};
+export type AdapterComparisonOperations<T extends ValidTemporal> = {
+    isEqual: (value: T, comparing: T) => boolean;
+    isSameYear: (value: T, comparing: T) => boolean;
+    isSameMonth: (value: T, comparing: T) => boolean;
+    isSameDay: (value: T, comparing: T) => boolean;
+    isSameHour: (value: T, comparing: T) => boolean;
+    isAfter: (value: T, comparing: T) => boolean;
+    isAfterYear: (value: T, comparing: T) => boolean;
+    isAfterDay: (value: T, comparing: T) => boolean;
+    isBefore: (value: T, comparing: T) => boolean;
+    isBeforeYear: (value: T, comparing: T) => boolean;
+    isBeforeDay: (value: T, comparing: T) => boolean;
+};
+export type AdapterDateOperations<T extends ValidTemporal> = {
+    startOfYear: (value: T) => T;
+    startOfMonth: (value: T) => T;
+    startOfWeek: (value: T, locale: Intl.Locale) => T;
+    endOfYear: (value: T) => T;
+    endOfMonth: (value: T) => T;
+    endOfWeek: (value: T, locale: Intl.Locale) => 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;
+    getYear: (value: T) => number;
+    getMonth: (value: T) => number;
+    getDate: (value: T) => number;
+    getDaysInMonth: (value: T) => number;
+    getWeekNumber: (value: T, locale: Intl.Locale) => number;
+    getDayOfWeek: (value: T) => number;
+    setYear: (value: T, year: number) => T;
+    setMonth: (value: T, month: number) => T;
+    setDate: (value: T, date: number) => T;
+    getWeekArray: (value: T, adapter: AdapterTemporalBase<T>) => T[][];
+    getYearRange: ([start, end]: [T, T], adapter: AdapterTemporalBase<T>) => T[];
+};
+export declare const noopAdapterDateOperations: AdapterDateOperations<ValidTemporal>;
+export declare const defaultAdapterDateOperations: AdapterDateOperations<ValidDateTemporal>;
+export type AdapterTimeOperations<T extends ValidTemporal> = {
+    startOfDay: (value: T) => T;
+    endOfDay: (value: T) => T;
+    addHours: (value: T, amount: number) => T;
+    addMinutes: (value: T, amount: number) => T;
+    addSeconds: (value: T, amount: 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;
+    getHours: (value: T) => number;
+    getMinutes: (value: T) => number;
+    getSeconds: (value: T) => number;
+    getMilliseconds: (value: T) => number;
+};
+export declare const noopAdapterTimeOperations: AdapterTimeOperations<ValidTemporal>;
+export declare const defaultAdapterTimeOperations: AdapterTimeOperations<ValidTimeTemporal>;
+export type AdapterTimezoneOperations<T extends ValidTemporal> = {
+    getTimezone: (value: T | null) => PickersTimezone;
+    setTimezone: (value: T, timezone: PickersTimezone) => T;
+};
+export declare const noopAdapterTimezoneOperations: AdapterTimezoneOperations<ValidTemporal>;
+export declare const resolveTimeZoneId: (timezone?: PickersTimezone) => string;
+export declare const defaultAdapterTimezoneOperations: AdapterTimezoneOperations<Temporal.ZonedDateTime>;

package/dist/adapters/operations.js

@@ -0,0 +1,120 @@
+import { firstDayOfMonth, firstDayOfWeek, firstDayOfYear, lastDayOfMonth, lastDayOfWeek, lastDayOfYear, localeAwareWeekNumber, } from "temporal-extra";
+export const noopAdapterDateOperations = {
+    startOfYear: (value) => value,
+    startOfMonth: (value) => value,
+    startOfWeek: (value) => value,
+    endOfYear: (value) => value,
+    endOfMonth: (value) => value,
+    endOfWeek: (value) => value,
+    addYears: (value) => value,
+    addMonths: (value) => value,
+    addWeeks: (value) => value,
+    addDays: (value) => value,
+    getYear: () => 2000,
+    getMonth: () => 1,
+    getDate: () => 1,
+    getDaysInMonth: () => 30,
+    getWeekNumber: () => 1,
+    getDayOfWeek: () => 1,
+    setYear: (value) => value,
+    setMonth: (value) => value,
+    setDate: (value) => value,
+    getWeekArray: () => [],
+    getYearRange: () => [],
+};
+export const defaultAdapterDateOperations = {
+    startOfYear: (value) => firstDayOfYear(value),
+    startOfMonth: (value) => firstDayOfMonth(value),
+    startOfWeek: (value, locale) => firstDayOfWeek(value, locale),
+    endOfYear: (value) => lastDayOfYear(value),
+    endOfMonth: (value) => lastDayOfMonth(value),
+    endOfWeek: (value, locale) => lastDayOfWeek(value, locale),
+    addYears: (value, amount) => value.add({ years: amount }),
+    addMonths: (value, amount) => value.add({ months: amount }),
+    addWeeks: (value, amount) => value.add({ weeks: amount }),
+    addDays: (value, amount) => value.add({ days: amount }),
+    getYear: (value) => value.year,
+    getMonth: (value) => value.month,
+    getDate: (value) => value.day,
+    getDaysInMonth: (value) => value.daysInMonth,
+    getWeekNumber: (value, locale) => localeAwareWeekNumber(value, locale),
+    getDayOfWeek: (value) => value.dayOfWeek,
+    setYear: (value, year) => value.with({ year }),
+    setMonth: (value, month) => value.with({ month }),
+    setDate: (value, date) => value.with({ day: date }),
+    getWeekArray: (value, adapter) => {
+        const start = adapter.startOfWeek(adapter.startOfMonth(value));
+        const end = adapter.endOfWeek(adapter.endOfMonth(value));
+        let count = 0;
+        let current = start;
+        const nestedWeeks = [];
+        while (!adapter.isAfter(current, end)) {
+            const weekNumber = Math.floor(count / 7);
+            nestedWeeks[weekNumber] = nestedWeeks[weekNumber] ?? [];
+            nestedWeeks[weekNumber].push(current);
+            current = adapter.addDays(current, 1);
+            count += 1;
+        }
+        return nestedWeeks;
+    },
+    getYearRange: ([start, end], adapter) => {
+        const startDate = adapter.startOfYear(start);
+        const endDate = adapter.endOfYear(end);
+        const years = [];
+        let current = startDate;
+        while (adapter.isBeforeYear(current, endDate)) {
+            years.push(current);
+            current = adapter.addYears(current, 1);
+        }
+        return years;
+    },
+};
+export const noopAdapterTimeOperations = {
+    startOfDay: (value) => value,
+    endOfDay: (value) => value,
+    addHours: (value) => value,
+    addMinutes: (value) => value,
+    addSeconds: (value) => value,
+    setHours: (value) => value,
+    setMinutes: (value) => value,
+    setSeconds: (value) => value,
+    setMilliseconds: (value) => value,
+    getHours: () => 0,
+    getMinutes: () => 0,
+    getSeconds: () => 0,
+    getMilliseconds: () => 0,
+};
+export const defaultAdapterTimeOperations = {
+    startOfDay: (value) => value.with({ hour: 0, minute: 0, second: 0, millisecond: 0 }),
+    endOfDay: (value) => value.with({
+        hour: 23,
+        minute: 59,
+        second: 59,
+        millisecond: 999,
+    }),
+    addHours: (value, amount) => value.add({ hours: amount }),
+    addMinutes: (value, amount) => value.add({ minutes: amount }),
+    addSeconds: (value, amount) => value.add({ seconds: amount }),
+    setHours: (value, hours) => value.with({ hour: hours }),
+    setMinutes: (value, minutes) => value.with({ minute: minutes }),
+    setSeconds: (value, seconds) => value.with({ second: seconds }),
+    setMilliseconds: (value, milliseconds) => value.with({ millisecond: milliseconds }),
+    getHours: (value) => value.hour,
+    getMinutes: (value) => value.minute,
+    getSeconds: (value) => value.second,
+    getMilliseconds: (value) => value.millisecond,
+};
+export const noopAdapterTimezoneOperations = {
+    getTimezone: () => "default",
+    setTimezone: (value) => value,
+};
+export const resolveTimeZoneId = (timezone) => {
+    if (!timezone || timezone === "default" || timezone === "system") {
+        return Temporal.Now.timeZoneId();
+    }
+    return timezone;
+};
+export const defaultAdapterTimezoneOperations = {
+    getTimezone: (value) => (value === null ? "default" : value.timeZoneId),
+    setTimezone: (value, timezone) => value.withTimeZone(resolveTimeZoneId(timezone)),
+};