mui-temporal-pickers 1.0.0

package/dist/adapters/plain-date-time.d.ts

@@ -0,0 +1,12 @@
+import type { AdapterOptions } from "@mui/x-date-pickers";
+import { AdapterTemporalBase } from "./base.js";
+export declare class AdapterTemporalPlainDateTime extends AdapterTemporalBase<Temporal.PlainDateTime> {
+    readonly formatTokenMap: {
+        [x: string]: import("@mui/x-date-pickers").FieldSectionType | {
+            sectionType: import("@mui/x-date-pickers").FieldSectionType;
+            contentType: import("@mui/x-date-pickers").FieldSectionContentType;
+            maxLength?: number;
+        };
+    };
+    constructor({ locale, formats, }: AdapterOptions<Intl.Locale | string, never>);
+}

package/dist/adapters/plain-date-time.js

@@ -0,0 +1,46 @@
+import { dateFormatTokenMap, timeFormatTokenMap } from "../locale/format/tokens.js";
+import { AdapterTemporalBase } from "./base.js";
+import { defaultAdapterDateOperations, defaultAdapterTimeOperations, } from "./operations.js";
+const conversionOperations = {
+    date: (value) => {
+        if (value === null) {
+            return null;
+        }
+        if (!value) {
+            return Temporal.Now.plainDateTimeISO();
+        }
+        return Temporal.PlainDateTime.from(value);
+    },
+    toJsDate: (value) => {
+        return new Date(value.toZonedDateTime("UTC").epochMilliseconds);
+    },
+    parse: (value, format, localeSpecs) => {
+        return localeSpecs.formatter.parsePlainDateTime(value, format);
+    },
+};
+const comparisonOperations = {
+    isEqual: (value, comparing) => value.equals(comparing),
+    isSameYear: (value, comparing) => value.year === comparing.year,
+    isSameMonth: (value, comparing) => value.toPlainDate().toPlainYearMonth().equals(comparing.toPlainDate().toPlainYearMonth()),
+    isSameDay: (value, comparing) => value.equals(comparing),
+    isSameHour: (value, comparing) => value.toPlainDate().equals(comparing.toPlainDate()) && value.hour === comparing.hour,
+    isAfter: (value, comparing) => Temporal.PlainDate.compare(value, comparing) > 0,
+    isAfterYear: (value, comparing) => value.year > comparing.year,
+    isAfterDay: (value, comparing) => Temporal.PlainDate.compare(value, comparing) > 0,
+    isBefore: (value, comparing) => Temporal.PlainDate.compare(value, comparing) < 0,
+    isBeforeYear: (value, comparing) => value.year < comparing.year,
+    isBeforeDay: (value, comparing) => Temporal.PlainDate.compare(value, comparing) < 0,
+};
+export class AdapterTemporalPlainDateTime extends AdapterTemporalBase {
+    formatTokenMap = { ...timeFormatTokenMap, ...dateFormatTokenMap };
+    constructor({ locale = new Intl.Locale("en-US"), formats, }) {
+        super({
+            locale,
+            formats,
+            conversionOperations,
+            comparisonOperations,
+            dateOperations: defaultAdapterDateOperations,
+            timeOperations: defaultAdapterTimeOperations,
+        });
+    }
+}

package/dist/adapters/plain-date.d.ts

@@ -0,0 +1,6 @@
+import type { AdapterOptions } from "@mui/x-date-pickers";
+import { AdapterTemporalBase } from "./base.js";
+export declare class AdapterTemporalPlainDate extends AdapterTemporalBase<Temporal.PlainDate> {
+    readonly formatTokenMap: import("@mui/x-date-pickers").FieldFormatTokenMap;
+    constructor({ locale, formats, }: AdapterOptions<Intl.Locale | string, never>);
+}

package/dist/adapters/plain-date.js

@@ -0,0 +1,46 @@
+import { dateFormatTokenMap } from "../locale/format/tokens.js";
+import { AdapterTemporalBase } from "./base.js";
+import { defaultAdapterDateOperations, } from "./operations.js";
+const conversionOperations = {
+    date: (value) => {
+        if (value === null) {
+            return null;
+        }
+        if (!value) {
+            return Temporal.Now.plainDateISO();
+        }
+        return Temporal.PlainDate.from(value);
+    },
+    toJsDate: (value) => {
+        return new Date(value.toPlainDateTime(Temporal.PlainTime.from({ hour: 0 })).toZonedDateTime("UTC")
+            .epochMilliseconds);
+    },
+    parse: (value, format, localeSpecs) => {
+        return localeSpecs.formatter.parsePlainDate(value, format);
+    },
+};
+const comparisonOperations = {
+    isEqual: (value, comparing) => value.equals(comparing),
+    isSameYear: (value, comparing) => value.year === comparing.year,
+    isSameMonth: (value, comparing) => value.toPlainYearMonth().equals(comparing.toPlainYearMonth()),
+    isSameDay: (value, comparing) => value.equals(comparing),
+    isSameHour: () => true,
+    isAfter: (value, comparing) => Temporal.PlainDate.compare(value, comparing) > 0,
+    isAfterYear: (value, comparing) => value.year > comparing.year,
+    isAfterDay: (value, comparing) => Temporal.PlainDate.compare(value, comparing) > 0,
+    isBefore: (value, comparing) => Temporal.PlainDate.compare(value, comparing) < 0,
+    isBeforeYear: (value, comparing) => value.year < comparing.year,
+    isBeforeDay: (value, comparing) => Temporal.PlainDate.compare(value, comparing) < 0,
+};
+export class AdapterTemporalPlainDate extends AdapterTemporalBase {
+    formatTokenMap = dateFormatTokenMap;
+    constructor({ locale = new Intl.Locale("en-US"), formats, }) {
+        super({
+            locale,
+            formats,
+            conversionOperations,
+            comparisonOperations,
+            dateOperations: defaultAdapterDateOperations,
+        });
+    }
+}

package/dist/adapters/plain-time.d.ts

@@ -0,0 +1,6 @@
+import type { AdapterOptions } from "@mui/x-date-pickers";
+import { AdapterTemporalBase } from "./base.js";
+export declare class AdapterTemporalPlainTime extends AdapterTemporalBase<Temporal.PlainTime> {
+    readonly formatTokenMap: import("@mui/x-date-pickers").FieldFormatTokenMap;
+    constructor({ locale, formats, }: AdapterOptions<Intl.Locale | string, never>);
+}

package/dist/adapters/plain-time.js

@@ -0,0 +1,46 @@
+import { timeFormatTokenMap } from "../locale/format/tokens.js";
+import { AdapterTemporalBase } from "./base.js";
+import { defaultAdapterTimeOperations, } from "./operations.js";
+const conversionOperations = {
+    date: (value) => {
+        if (value === null) {
+            return null;
+        }
+        if (!value) {
+            return Temporal.Now.plainTimeISO();
+        }
+        return Temporal.PlainTime.from(value);
+    },
+    toJsDate: (value) => {
+        return new Date(Temporal.PlainDate.from("2000-01-01").toPlainDateTime(value).toZonedDateTime("UTC")
+            .epochMilliseconds);
+    },
+    parse: (value, format, localeSpecs) => {
+        return localeSpecs.formatter.parsePlainTime(value, format);
+    },
+};
+const comparisonOperations = {
+    isEqual: (value, comparing) => value.equals(comparing),
+    isSameYear: () => true,
+    isSameMonth: () => true,
+    isSameDay: () => true,
+    isSameHour: (value, comparing) => value.hour === comparing.hour,
+    isAfter: (value, comparing) => Temporal.PlainTime.compare(value, comparing) > 0,
+    isAfterYear: () => false,
+    isAfterDay: () => false,
+    isBefore: (value, comparing) => Temporal.PlainTime.compare(value, comparing) < 0,
+    isBeforeYear: () => false,
+    isBeforeDay: () => false,
+};
+export class AdapterTemporalPlainTime extends AdapterTemporalBase {
+    formatTokenMap = timeFormatTokenMap;
+    constructor({ locale = new Intl.Locale("en-US"), formats, }) {
+        super({
+            locale,
+            formats,
+            conversionOperations,
+            comparisonOperations,
+            timeOperations: defaultAdapterTimeOperations,
+        });
+    }
+}

package/dist/adapters/zoned-date-time.d.ts

@@ -0,0 +1,12 @@
+import type { AdapterOptions } from "@mui/x-date-pickers";
+import { AdapterTemporalBase } from "./base.js";
+export declare class AdapterTemporalZonedDateTime extends AdapterTemporalBase<Temporal.ZonedDateTime> {
+    readonly formatTokenMap: {
+        [x: string]: import("@mui/x-date-pickers").FieldSectionType | {
+            sectionType: import("@mui/x-date-pickers").FieldSectionType;
+            contentType: import("@mui/x-date-pickers").FieldSectionContentType;
+            maxLength?: number;
+        };
+    };
+    constructor({ locale, formats, }: AdapterOptions<Intl.Locale | string, never>);
+}

package/dist/adapters/zoned-date-time.js

@@ -0,0 +1,55 @@
+import { dateFormatTokenMap, timeFormatTokenMap } from "../locale/format/tokens.js";
+import { AdapterTemporalBase } from "./base.js";
+import { defaultAdapterDateOperations, defaultAdapterTimeOperations, resolveTimeZoneId, } from "./operations.js";
+const conversionOperations = {
+    date: (value, timezone) => {
+        if (value === null) {
+            return null;
+        }
+        const plainDateTime = !value
+            ? Temporal.Now.plainDateTimeISO()
+            : Temporal.PlainDateTime.from(value);
+        return plainDateTime.toZonedDateTime(resolveTimeZoneId(timezone));
+    },
+    toJsDate: (value) => {
+        return new Date(value.epochMilliseconds);
+    },
+    parse: (value, format, localeSpecs) => {
+        return (localeSpecs.formatter
+            .parsePlainDateTime(value, format)
+            ?.toZonedDateTime(Temporal.Now.timeZoneId()) ?? null);
+    },
+};
+const comparisonOperations = {
+    isEqual: (value, comparing) => value.equals(comparing.withTimeZone(value)),
+    isSameYear: (value, comparing) => value.year === comparing.withTimeZone(value).year,
+    isSameMonth: (value, comparing) => value
+        .toPlainDate()
+        .toPlainYearMonth()
+        .equals(comparing.withTimeZone(value).toPlainDate().toPlainYearMonth()),
+    isSameDay: (value, comparing) => value.equals(comparing.withTimeZone(value)),
+    isSameHour: (value, comparing) => {
+        const comparingSameZone = comparing.withTimeZone(value);
+        return (value.toPlainDate().equals(comparingSameZone.toPlainDate()) &&
+            value.hour === comparingSameZone.hour);
+    },
+    isAfter: (value, comparing) => Temporal.PlainDate.compare(value, comparing.withTimeZone(value)) > 0,
+    isAfterYear: (value, comparing) => value.year > comparing.withTimeZone(value).year,
+    isAfterDay: (value, comparing) => Temporal.PlainDate.compare(value, comparing.withTimeZone(value)) > 0,
+    isBefore: (value, comparing) => Temporal.PlainDate.compare(value, comparing.withTimeZone(value)) < 0,
+    isBeforeYear: (value, comparing) => value.year < comparing.withTimeZone(value).year,
+    isBeforeDay: (value, comparing) => Temporal.PlainDate.compare(value, comparing.withTimeZone(value)) < 0,
+};
+export class AdapterTemporalZonedDateTime extends AdapterTemporalBase {
+    formatTokenMap = { ...timeFormatTokenMap, ...dateFormatTokenMap };
+    constructor({ locale = new Intl.Locale("en-US"), formats, }) {
+        super({
+            locale,
+            formats,
+            conversionOperations,
+            comparisonOperations,
+            dateOperations: defaultAdapterDateOperations,
+            timeOperations: defaultAdapterTimeOperations,
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./providers/index.js";

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./providers/index.js";

package/dist/locale/format/formatter.d.ts

@@ -0,0 +1,12 @@
+type FormattableValue = Temporal.PlainTime | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime;
+export declare class Formatter {
+    private locale;
+    private formats;
+    constructor(locale: Intl.Locale);
+    format(value: FormattableValue, format: string): string;
+    parsePlainTime(value: string, format: string): Temporal.PlainTime | null;
+    parsePlainDate(value: string, format: string): Temporal.PlainDate | null;
+    parsePlainDateTime(value: string, format: string): Temporal.PlainDateTime | null;
+    expandFormat(format: string): string;
+}
+export {};

package/dist/locale/format/formatter.js

@@ -0,0 +1,377 @@
+import { parseTokenString } from "./tokenizer.js";
+import { knownTokens, metaTokens } from "./tokens.js";
+const tokenFormatOptions = {
+    // Standard tokens
+    MMM: { month: "short" },
+    MMMM: { month: "long" },
+    ccc: { weekday: "short" },
+    cccc: { weekday: "long" },
+    ccccc: { weekday: "narrow" },
+    // Meta tokens
+    lfd: { day: "numeric", month: "short", year: "numeric" },
+    lkd: { year: "numeric", month: "2-digit", day: "2-digit" },
+    lsd: { day: "numeric", month: "short" },
+    lnd: { day: "numeric", month: "long" },
+    lndw: { weekday: "short", day: "numeric", month: "short" },
+    lfta: { hour: "2-digit", minute: "2-digit", hourCycle: "h11" },
+    lftd: { hour: "2-digit", minute: "2-digit", hourCycle: "h23" },
+    lkdta: {
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        hourCycle: "h12",
+    },
+    lkdtd: {
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        hourCycle: "h23",
+    },
+};
+const tokenToFieldMap = {
+    y: "year",
+    yy: "year",
+    M: "month",
+    MM: "month",
+    d: "day",
+    dd: "day",
+    H: "hour24",
+    HH: "hour24",
+    h: "hour12",
+    hh: "hour12",
+    m: "minute",
+    mm: "minute",
+    s: "second",
+    ss: "second",
+    a: "ampm",
+};
+const tokenRegexMap = {
+    yy: "\\d{1,4}",
+    yyyy: "\\d{2}",
+    M: "\\d{1,2}",
+    MM: "\\d{2}",
+    d: "\\d{1,2}",
+    dd: "\\d{2}",
+    H: "\\d{1,2}",
+    HH: "\\d{2}",
+    h: "\\d{1,2}",
+    hh: "\\d{2}",
+    m: "\\d{1,2}",
+    mm: "\\d{2}",
+    s: "\\d{1,2}",
+    ss: "\\d{2}",
+    a: "(AM|PM)",
+};
+export class Formatter {
+    locale;
+    formats;
+    constructor(locale) {
+        const dateTimeFormatter = new Intl.DateTimeFormat(locale);
+        if (dateTimeFormatter.resolvedOptions().numberingSystem !== "latn") {
+            throw new Error("Only latin numbering system is supported");
+        }
+        this.locale = locale;
+        this.formats = collectFormats(locale);
+    }
+    format(value, format) {
+        const formattable = value instanceof Temporal.ZonedDateTime ? value.toPlainDateTime() : value;
+        const tokens = parseTokenString(format);
+        let result = "";
+        for (const token of tokens) {
+            if (token.type === "literal") {
+                result += token.value;
+                continue;
+            }
+            const expandedToken = expandToken(token.value, value);
+            if (expandedToken) {
+                result += expandedToken;
+            }
+            else if (token.value in tokenFormatOptions) {
+                result += new Intl.DateTimeFormat(this.locale, tokenFormatOptions[token.value]).format(formattable);
+            }
+        }
+        return result;
+    }
+    parsePlainTime(value, format) {
+        const tokens = parseTokenString(format);
+        const components = parseInputFromFormat(value, tokens);
+        if (!components) {
+            return null;
+        }
+        return Temporal.PlainTime.from({
+            hour: to24Hours(components),
+            minute: components.minute,
+            second: components.second,
+        });
+    }
+    parsePlainDate(value, format) {
+        const tokens = parseTokenString(format);
+        const components = parseInputFromFormat(value, tokens);
+        if (!components) {
+            return null;
+        }
+        return Temporal.PlainDate.from({
+            year: components.year ?? 2000,
+            month: components.month ?? 1,
+            day: components.day ?? 1,
+        });
+    }
+    parsePlainDateTime(value, format) {
+        const tokens = parseTokenString(format);
+        const components = parseInputFromFormat(value, tokens);
+        if (!components) {
+            return null;
+        }
+        return Temporal.PlainDateTime.from({
+            year: components.year ?? 2000,
+            month: components.month ?? 1,
+            day: components.day ?? 1,
+            hour: to24Hours(components),
+            minute: components.minute,
+            second: components.second,
+        });
+    }
+    expandFormat(format) {
+        const tokens = parseTokenString(format);
+        let result = "";
+        for (const token of tokens) {
+            if (token.type === "literal") {
+                result += escapeLiteral(token.value);
+                continue;
+            }
+            switch (token.value) {
+                case "lkd":
+                    result += this.formats.keyboardDate;
+                    break;
+                case "lfta":
+                    result += this.formats.fullTime12h;
+                    break;
+                case "lftd":
+                    result += this.formats.fullTime24h;
+                    break;
+                case "lkdta":
+                    result += this.formats.keyboardDateTime12h;
+                    break;
+                case "lkdtd":
+                    result += this.formats.keyboardDateTime24h;
+                    break;
+                case "lfd":
+                case "lsd":
+                case "lnd":
+                case "lndw":
+                    throw new Error(`Format token '${token.value}' cannot be expanded`);
+                default:
+                    result += token.value;
+            }
+        }
+        return result;
+    }
+}
+const expandToken = (token, value) => {
+    if (value instanceof Temporal.PlainDate ||
+        value instanceof Temporal.PlainDateTime ||
+        value instanceof Temporal.ZonedDateTime) {
+        switch (token) {
+            case "yy":
+                return value.toString().slice(-2);
+            case "yyyy":
+                return value.year.toString();
+            case "M":
+                return value.month.toString();
+            case "MM":
+                return value.month.toString().padStart(2, "0");
+            case "d":
+                return value.day.toString();
+            case "dd":
+                return value.day.toString().padStart(2, "0");
+            case "MMM":
+            case "MMMM":
+            case "ccc":
+            case "cccc":
+            case "ccccc":
+                return null;
+        }
+    }
+    if (value instanceof Temporal.PlainTime ||
+        value instanceof Temporal.PlainDateTime ||
+        value instanceof Temporal.ZonedDateTime) {
+        switch (token) {
+            case "a":
+                return value.hour < 12 ? "AM" : "PM";
+            case "H":
+                return value.hour.toString();
+            case "HH":
+                return value.hour.toString().padStart(2, "0");
+            case "h":
+                return to12Hours(value.hour).toString();
+            case "hh":
+                return to12Hours(value.hour).toString().padStart(2, "0");
+            case "m":
+                return value.minute.toString();
+            case "mm":
+                return value.minute.toString().padStart(2, "0");
+            case "s":
+                return value.second.toString();
+            case "ss":
+                return value.second.toString().padStart(2, "0");
+        }
+    }
+    if (metaTokens.includes(token)) {
+        return null;
+    }
+    // MUI-X tries to format dates as times, even in the Date Picker; just ignore.
+    return "";
+};
+const to24Hours = (components) => {
+    if (components.hour24) {
+        return components.hour24;
+    }
+    if (!components.hour12) {
+        return undefined;
+    }
+    if (!components.ampm) {
+        throw new Error("Format is missing AM/PM");
+    }
+    if (components.ampm === "AM") {
+        return components.hour12 === 12 ? 0 : components.hour12;
+    }
+    return components.hour12 === 12 ? 12 : components.hour12 + 12;
+};
+const to12Hours = (hour24) => {
+    return hour24 % 12 === 0 ? 12 : hour24 % 12;
+};
+const buildRegexFromFormat = (tokens) => {
+    let pattern = "^";
+    const groupMap = [];
+    for (const token of tokens) {
+        if (token.type === "literal") {
+            pattern += token.value.replace(/[-[\]/{}()*+?.\\^$|]/g, "\\$&");
+        }
+        else {
+            if (!tokenRegexMap[token.value]) {
+                throw new Error(`Unsupported token: "${token.value}"`);
+            }
+            pattern += `(${tokenRegexMap[token.value]})`;
+            groupMap.push(token.value);
+        }
+    }
+    pattern += "$";
+    return {
+        regex: new RegExp(pattern),
+        groupMap,
+    };
+};
+const parseInputFromFormat = (input, format) => {
+    const { regex, groupMap } = buildRegexFromFormat(format);
+    const match = input.match(regex);
+    if (!match) {
+        return null;
+    }
+    const result = {};
+    groupMap.forEach((token, index) => {
+        const rawValue = match[index + 1];
+        const field = tokenToFieldMap[token];
+        if (field === "ampm") {
+            result.ampm = rawValue;
+        }
+        else {
+            result[field] = Number.parseInt(rawValue, 10);
+        }
+    });
+    return result;
+};
+const collectFormats = (locale) => ({
+    keyboardDate: collectFormat(locale, {
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    }),
+    fullTime12h: collectFormat(locale, {
+        hour: "2-digit",
+        minute: "2-digit",
+        hourCycle: "h11",
+    }),
+    fullTime24h: collectFormat(locale, {
+        hour: "2-digit",
+        minute: "2-digit",
+        hourCycle: "h23",
+    }),
+    keyboardDateTime12h: collectFormat(locale, {
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        hourCycle: "h12",
+    }),
+    keyboardDateTime24h: collectFormat(locale, {
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        hourCycle: "h23",
+    }),
+});
+const collectFormat = (locale, options) => {
+    const parts = new Intl.DateTimeFormat(locale, { ...options, timeZone: "utc" }).formatToParts(Temporal.PlainDateTime.from({
+        year: 2018,
+        month: 1,
+        day: 1,
+        hour: 1,
+        minute: 1,
+        second: 1,
+    }));
+    let tokens = "";
+    for (const part of parts) {
+        switch (part.type) {
+            case "day":
+                tokens += part.value.length === 1 ? "d" : "dd";
+                break;
+            case "dayPeriod":
+                tokens += "a";
+                break;
+            case "era":
+                throw new Error("timeZoneName is not supported");
+            case "hour":
+                tokens += determineHourToken(part.value, options.hourCycle);
+                break;
+            case "minute":
+                tokens += part.value.length === 1 ? "m" : "mm";
+                break;
+            case "month":
+                tokens += part.value.length === 1 ? "M" : "MM";
+                break;
+            case "second":
+                tokens += part.value.length === 1 ? "s" : "ss";
+                break;
+            case "timeZoneName":
+                throw new Error("timeZoneName is not supported");
+            case "weekday":
+                return "c";
+            case "year":
+                tokens += part.value.length === 2 ? "yy" : "yyyy";
+                break;
+            case "literal":
+                tokens += escapeLiteral(part.value);
+                break;
+        }
+    }
+    return tokens;
+};
+const determineHourToken = (value, hourCycle) => {
+    const baseToken = hourCycle?.[1] === "1" ? "h" : "H";
+    return value.length === 1 ? baseToken : baseToken.repeat(2);
+};
+const tokenPattern = new RegExp(knownTokens.sort((a, b) => b.length - a.length).join("|"), "g");
+const escapeLiteral = (literal) => {
+    const doubledQuotes = literal.replace(/'/g, "''");
+    if (!tokenPattern.test(doubledQuotes)) {
+        return doubledQuotes;
+    }
+    return `'${doubledQuotes}'`;
+};

package/dist/locale/format/tokenizer.d.ts

@@ -0,0 +1,9 @@
+import { type Token } from "./tokens.js";
+export type ParsedToken = {
+    type: "literal";
+    value: string;
+} | {
+    type: "token";
+    value: Token;
+};
+export declare const parseTokenString: (input: string) => ParsedToken[];