@mui/lab 5.0.0-alpha.75 → 5.0.0-alpha.76

package/internal/pickers/hooks/useMaskedInput.js

@@ -1,93 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { useRifm } from 'rifm';
-import { useUtils } from './useUtils';
-import { createDelegatedEventHandler } from '../utils';
-import { maskedDateFormatter, getDisplayDate, checkMaskIsValidForCurrentFormat } from '../text-field-helper';
-export function useMaskedInput({
-  acceptRegex = /[\d]/gi,
-  disabled,
-  disableMaskedInput,
-  ignoreInvalidInputs,
-  inputFormat,
-  inputProps,
-  label,
-  mask,
-  onChange,
-  rawValue,
-  readOnly,
-  rifmFormatter,
-  TextFieldProps,
-  validationError
-}) {
-  const utils = useUtils();
-  const [isFocused, setIsFocused] = React.useState(false);
-  const formatHelperText = utils.getFormatHelperText(inputFormat);
-  const shouldUseMaskedInput = React.useMemo(() => {
-    // formatting of dates is a quite slow thing, so do not make useless .format calls
-    if (!mask || disableMaskedInput) {
-      return false;
-    }
-
-    return checkMaskIsValidForCurrentFormat(mask, inputFormat, acceptRegex, utils);
-  }, [acceptRegex, disableMaskedInput, inputFormat, mask, utils]);
-  const formatter = React.useMemo(() => shouldUseMaskedInput && mask ? maskedDateFormatter(mask, acceptRegex) : st => st, [acceptRegex, mask, shouldUseMaskedInput]); // TODO: Implement with controlled vs unctrolled `rawValue`
-
-  const currentInputValue = getDisplayDate(utils, rawValue, inputFormat);
-  const [innerInputValue, setInnerInputValue] = React.useState(currentInputValue);
-  const previousInputValueRef = React.useRef(currentInputValue);
-  React.useEffect(() => {
-    previousInputValueRef.current = currentInputValue;
-  }, [currentInputValue]);
-  const notTyping = !isFocused;
-  const valueChanged = previousInputValueRef.current !== currentInputValue; // Update the input value only if the value changed outside of typing
-
-  if (notTyping && valueChanged && (rawValue === null || utils.isValid(rawValue))) {
-    if (currentInputValue !== innerInputValue) {
-      setInnerInputValue(currentInputValue);
-    }
-  }
-
-  const handleChange = text => {
-    const finalString = text === '' || text === mask ? '' : text;
-    setInnerInputValue(finalString);
-    const date = finalString === null ? null : utils.parse(finalString, inputFormat);
-
-    if (ignoreInvalidInputs && !utils.isValid(date)) {
-      return;
-    }
-
-    onChange(date, finalString || undefined);
-  };
-
-  const rifmProps = useRifm({
-    value: innerInputValue,
-    onChange: handleChange,
-    format: rifmFormatter || formatter
-  });
-  const inputStateArgs = shouldUseMaskedInput ? rifmProps : {
-    value: innerInputValue,
-    onChange: event => {
-      handleChange(event.currentTarget.value);
-    }
-  };
-  return _extends({
-    label,
-    disabled,
-    error: validationError,
-    inputProps: _extends({}, inputStateArgs, {
-      disabled,
-      placeholder: formatHelperText,
-      readOnly,
-      type: shouldUseMaskedInput ? 'tel' : 'text'
-    }, inputProps, {
-      onFocus: createDelegatedEventHandler(() => {
-        setIsFocused(true);
-      }, inputProps == null ? void 0 : inputProps.onFocus),
-      onBlur: createDelegatedEventHandler(() => {
-        setIsFocused(false);
-      }, inputProps == null ? void 0 : inputProps.onBlur)
-    })
-  }, TextFieldProps);
-}
-export default useMaskedInput;

package/internal/pickers/hooks/useOpenState.d.ts

@@ -1,10 +0,0 @@
-export interface OpenStateProps {
-    open?: boolean;
-    onOpen?: () => void;
-    onClose?: () => void;
-}
-export declare function useOpenState({ open, onOpen, onClose }: OpenStateProps): {
-    isOpen: boolean;
-    setIsOpen: (newIsOpen: boolean) => void;
-};
-export default useOpenState;

package/internal/pickers/hooks/useOpenState.js

@@ -1,38 +0,0 @@
-import * as React from 'react';
-export function useOpenState({
-  open,
-  onOpen,
-  onClose
-}) {
-  const isControllingOpenProp = React.useRef(typeof open === 'boolean').current;
-  const [openState, setIsOpenState] = React.useState(false); // It is required to update inner state in useEffect in order to avoid situation when
-  // Our component is not mounted yet, but `open` state is set to `true` (e.g. initially opened)
-
-  React.useEffect(() => {
-    if (isControllingOpenProp) {
-      if (typeof open !== 'boolean') {
-        throw new Error('You must not mix controlling and uncontrolled mode for `open` prop');
-      }
-
-      setIsOpenState(open);
-    }
-  }, [isControllingOpenProp, open]);
-  const setIsOpen = React.useCallback(newIsOpen => {
-    if (!isControllingOpenProp) {
-      setIsOpenState(newIsOpen);
-    }
-
-    if (newIsOpen && onOpen) {
-      onOpen();
-    }
-
-    if (!newIsOpen && onClose) {
-      onClose();
-    }
-  }, [isControllingOpenProp, onOpen, onClose]);
-  return {
-    isOpen: openState,
-    setIsOpen
-  };
-}
-export default useOpenState;

package/internal/pickers/hooks/usePickerState.d.ts

@@ -1,38 +0,0 @@
-import { WrapperVariant } from '../wrappers/WrapperVariantContext';
-import { MuiPickersAdapter } from './useUtils';
-export interface PickerStateValueManager<TInputValue, TDateValue> {
-    areValuesEqual: (utils: MuiPickersAdapter, valueLeft: TDateValue, valueRight: TDateValue) => boolean;
-    emptyValue: TDateValue;
-    parseInput: (utils: MuiPickersAdapter, value: TInputValue) => TDateValue;
-}
-export declare type PickerSelectionState = 'partial' | 'shallow' | 'finish';
-export interface PickerStateProps<TInput, TDateValue> {
-    disableCloseOnSelect?: boolean;
-    open?: boolean;
-    onAccept?: (date: TDateValue) => void;
-    onChange: (date: TDateValue, keyboardInputValue?: string) => void;
-    onClose?: () => void;
-    onOpen?: () => void;
-    value: TInput;
-}
-export declare function usePickerState<TInput, TDateValue>(props: PickerStateProps<TInput, TDateValue>, valueManager: PickerStateValueManager<TInput, TDateValue>): {
-    pickerProps: {
-        date: TDateValue;
-        isMobileKeyboardViewOpen: boolean;
-        toggleMobileKeyboardView: () => void;
-        onDateChange: (newDate: TDateValue, wrapperVariant: WrapperVariant, selectionState?: PickerSelectionState) => void;
-    };
-    inputProps: {
-        onChange: (date: TDateValue, keyboardInputValue?: string | undefined) => void;
-        open: boolean;
-        rawValue: TInput;
-        openPicker: () => void;
-    };
-    wrapperProps: {
-        open: boolean;
-        onClear: () => void;
-        onAccept: () => void;
-        onDismiss: () => void;
-        onSetToday: () => void;
-    };
-};

package/internal/pickers/hooks/usePickerState.js

@@ -1,117 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { useOpenState } from './useOpenState';
-import { useUtils } from './useUtils';
-export function usePickerState(props, valueManager) {
-  const {
-    disableCloseOnSelect,
-    onAccept,
-    onChange,
-    value
-  } = props;
-  const utils = useUtils();
-  const {
-    isOpen,
-    setIsOpen
-  } = useOpenState(props);
-
-  function initDraftableDate(date) {
-    return {
-      committed: date,
-      draft: date
-    };
-  }
-
-  const parsedDateValue = valueManager.parseInput(utils, value);
-  const [draftState, dispatch] = React.useReducer((state, action) => {
-    switch (action.type) {
-      case 'reset':
-        return initDraftableDate(action.payload);
-
-      case 'update':
-        return _extends({}, state, {
-          draft: action.payload
-        });
-
-      default:
-        return state;
-    }
-  }, parsedDateValue, initDraftableDate);
-
-  if (!valueManager.areValuesEqual(utils, draftState.committed, parsedDateValue)) {
-    dispatch({
-      type: 'reset',
-      payload: parsedDateValue
-    });
-  }
-
-  const [initialDate, setInitialDate] = React.useState(draftState.committed); // Mobile keyboard view is a special case.
-  // When it's open picker should work like closed, cause we are just showing text field
-
-  const [isMobileKeyboardViewOpen, setMobileKeyboardViewOpen] = React.useState(false);
-  const acceptDate = React.useCallback((acceptedDate, needClosePicker) => {
-    onChange(acceptedDate);
-
-    if (needClosePicker) {
-      setIsOpen(false);
-      setInitialDate(acceptedDate);
-
-      if (onAccept) {
-        onAccept(acceptedDate);
-      }
-    }
-  }, [onAccept, onChange, setIsOpen]);
-  const wrapperProps = React.useMemo(() => ({
-    open: isOpen,
-    onClear: () => acceptDate(valueManager.emptyValue, true),
-    onAccept: () => acceptDate(draftState.draft, true),
-    onDismiss: () => acceptDate(initialDate, true),
-    onSetToday: () => {
-      const now = utils.date();
-      dispatch({
-        type: 'update',
-        payload: now
-      });
-      acceptDate(now, !disableCloseOnSelect);
-    }
-  }), [acceptDate, disableCloseOnSelect, isOpen, utils, draftState.draft, valueManager.emptyValue, initialDate]);
-  const pickerProps = React.useMemo(() => ({
-    date: draftState.draft,
-    isMobileKeyboardViewOpen,
-    toggleMobileKeyboardView: () => setMobileKeyboardViewOpen(!isMobileKeyboardViewOpen),
-    onDateChange: (newDate, wrapperVariant, selectionState = 'partial') => {
-      dispatch({
-        type: 'update',
-        payload: newDate
-      });
-
-      if (selectionState === 'partial') {
-        acceptDate(newDate, false);
-      }
-
-      if (selectionState === 'finish') {
-        const shouldCloseOnSelect = !(disableCloseOnSelect != null ? disableCloseOnSelect : wrapperVariant === 'mobile');
-        acceptDate(newDate, shouldCloseOnSelect);
-      } // if selectionState === "shallow" do nothing (we already update the draft state)
-
-    }
-  }), [acceptDate, disableCloseOnSelect, isMobileKeyboardViewOpen, draftState.draft]);
-  const inputProps = React.useMemo(() => ({
-    onChange,
-    open: isOpen,
-    rawValue: value,
-    openPicker: () => setIsOpen(true)
-  }), [onChange, isOpen, value, setIsOpen]);
-  const pickerState = {
-    pickerProps,
-    inputProps,
-    wrapperProps
-  };
-  React.useDebugValue(pickerState, () => ({
-    MuiPickerState: {
-      pickerDraft: draftState,
-      other: pickerState
-    }
-  }));
-  return pickerState;
-}

package/internal/pickers/hooks/useUtils.d.ts

@@ -1,7 +0,0 @@
-export declare type MuiPickersAdapter<TDate = unknown> = import('../../../LocalizationProvider').MuiPickersAdapter<TDate>;
-export declare function useUtils<T = unknown>(): import("../../../LocalizationProvider").MuiPickersAdapter<T>;
-export declare function useDefaultDates<T>(): {
-    minDate: T;
-    maxDate: T;
-};
-export declare function useNow<TDate = unknown>(): TDate;

package/internal/pickers/hooks/useUtils.js

@@ -1,25 +0,0 @@
-import { formatMuiErrorMessage as _formatMuiErrorMessage } from "@mui/utils";
-import * as React from 'react';
-import { MuiPickersAdapterContext } from '../../../LocalizationProvider'; // Required for babel https://github.com/vercel/next.js/issues/7882. Replace with `export type` in future
-
-function useLocalizationContext() {
-  const localization = React.useContext(MuiPickersAdapterContext);
-
-  if (localization === null) {
-    throw new Error(process.env.NODE_ENV !== "production" ? `Can not find utils in context. It looks like you forgot to wrap your component in LocalizationProvider, or pass dateAdapter prop directly.` : _formatMuiErrorMessage(13));
-  }
-
-  return localization;
-}
-
-export function useUtils() {
-  return useLocalizationContext().utils;
-}
-export function useDefaultDates() {
-  return useLocalizationContext().defaultDates;
-}
-export function useNow() {
-  const utils = useUtils();
-  const now = React.useRef(utils.date());
-  return now.current;
-}

package/internal/pickers/hooks/useValidation.d.ts

@@ -1,23 +0,0 @@
-import { DateValidationProps, RangeInput } from '../date-utils';
-import { DateTimeValidationProps } from '../date-time-utils';
-import { TimeValidationProps } from '../time-utils';
-export interface ValidationProps<TError, TDateValue> {
-    /**
-     * Callback that fired when input value or new `value` prop validation returns **new** validation error (or value is valid after error).
-     * In case of validation error detected `reason` prop return non-null value and `TextField` must be displayed in `error` state.
-     * This can be used to render appropriate form error.
-     *
-     * [Read the guide](https://next.material-ui-pickers.dev/guides/forms) about form integration and error displaying.
-     * @DateIOType
-     */
-    onError?: (reason: TError, value: TDateValue) => void;
-    value: TDateValue;
-}
-export declare type TimeValidationError = import('../time-utils').TimeValidationError;
-export declare function useTimeValidation<TDate>(props: TimeValidationProps<TDate> & ValidationProps<TimeValidationError, TDate>): TimeValidationError;
-export declare type DateValidationError = import('../date-utils').DateValidationError;
-export declare function useDateValidation<TDate>(props: DateValidationProps<TDate> & ValidationProps<DateValidationError, TDate>): DateValidationError;
-export declare type DateTimeValidationError = import('../date-time-utils').DateTimeValidationError;
-export declare function useDateTimeValidation<TDate>(props: DateTimeValidationProps<TDate> & ValidationProps<DateTimeValidationError, TDate>): DateTimeValidationError;
-export declare type DateRangeValidationError = import('../date-utils').DateRangeValidationError;
-export declare function useDateRangeValidation<TDate>(props: DateValidationProps<TDate> & ValidationProps<DateRangeValidationError, RangeInput<TDate>>): DateRangeValidationError;

package/internal/pickers/hooks/useValidation.js

@@ -1,44 +0,0 @@
-import * as React from 'react';
-import { useUtils } from './useUtils';
-import { validateDate, validateDateRange } from '../date-utils';
-import { validateDateTime } from '../date-time-utils';
-import { validateTime } from '../time-utils';
-
-function isSameDateOrTimeError(a, b) {
-  return a === b;
-}
-
-function isSameDateRangeError(a, b) {
-  return b !== null && a[1] === b[1] && a[0] === b[0];
-}
-
-function useValidation(props, validate, isSameError = isSameDateOrTimeError) {
-  const {
-    value,
-    onError
-  } = props;
-  const utils = useUtils();
-  const previousValidationErrorRef = React.useRef(null);
-  const validationError = validate(utils, value, props);
-  React.useEffect(() => {
-    if (onError && !isSameError(validationError, previousValidationErrorRef.current)) {
-      onError(validationError, value);
-    }
-
-    previousValidationErrorRef.current = validationError;
-  }, [isSameError, onError, previousValidationErrorRef, validationError, value]);
-  return validationError;
-}
-
-export function useTimeValidation(props) {
-  return useValidation(props, validateTime, isSameDateOrTimeError);
-}
-export function useDateValidation(props) {
-  return useValidation(props, validateDate, isSameDateOrTimeError);
-}
-export function useDateTimeValidation(props) {
-  return useValidation(props, validateDateTime, isSameDateOrTimeError);
-}
-export function useDateRangeValidation(props) {
-  return useValidation(props, validateDateRange, isSameDateRangeError);
-}

package/internal/pickers/hooks/useViews.d.ts

@@ -1,19 +0,0 @@
-import { PickerSelectionState } from './usePickerState';
-import { AllAvailableViews } from '../typings/Views';
-export declare type PickerOnChangeFn<TDate> = (date: TDate | null, selectionState?: PickerSelectionState) => void;
-interface UseViewsOptions<TDate, View extends AllAvailableViews> {
-    onChange: PickerOnChangeFn<TDate>;
-    onViewChange?: (newView: View) => void;
-    openTo?: View;
-    view: View | undefined;
-    views: readonly View[];
-}
-export declare function useViews<TDate, View extends AllAvailableViews>({ onChange, onViewChange, openTo, view, views, }: UseViewsOptions<TDate, View>): {
-    handleChangeAndOpenNext: (date: TDate, currentViewSelectionState?: PickerSelectionState | undefined) => void;
-    nextView: View;
-    previousView: View;
-    openNext: () => void;
-    openView: View;
-    setOpenView: (newView: View) => void;
-};
-export {};

package/internal/pickers/hooks/useViews.js

@@ -1,50 +0,0 @@
-import * as React from 'react';
-import { useControlled } from '@mui/material/utils';
-import { arrayIncludes } from '../utils';
-export function useViews({
-  onChange,
-  onViewChange,
-  openTo,
-  view,
-  views
-}) {
-  var _views, _views2;
-
-  const [openView, setOpenView] = useControlled({
-    name: 'Picker',
-    state: 'view',
-    controlled: view,
-    default: openTo && arrayIncludes(views, openTo) ? openTo : views[0]
-  });
-  const previousView = (_views = views[views.indexOf(openView) - 1]) != null ? _views : null;
-  const nextView = (_views2 = views[views.indexOf(openView) + 1]) != null ? _views2 : null;
-  const changeView = React.useCallback(newView => {
-    setOpenView(newView);
-
-    if (onViewChange) {
-      onViewChange(newView);
-    }
-  }, [setOpenView, onViewChange]);
-  const openNext = React.useCallback(() => {
-    if (nextView) {
-      changeView(nextView);
-    }
-  }, [nextView, changeView]);
-  const handleChangeAndOpenNext = React.useCallback((date, currentViewSelectionState) => {
-    const isSelectionFinishedOnCurrentView = currentViewSelectionState === 'finish';
-    const globalSelectionState = isSelectionFinishedOnCurrentView && Boolean(nextView) ? 'partial' : currentViewSelectionState;
-    onChange(date, globalSelectionState);
-
-    if (isSelectionFinishedOnCurrentView) {
-      openNext();
-    }
-  }, [nextView, onChange, openNext]);
-  return {
-    handleChangeAndOpenNext,
-    nextView,
-    previousView,
-    openNext,
-    openView,
-    setOpenView: changeView
-  };
-}

package/internal/pickers/test-utils.js

@@ -1,91 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["locale"];
-import * as React from 'react';
-import { parseISO } from 'date-fns';
-import { createRenderer, fireEvent, screen } from 'test/utils';
-import AdapterDateFns from '@mui/lab/AdapterDateFns';
-import LocalizationProvider from '@mui/lab/LocalizationProvider'; // TODO make possible to pass here any utils using cli
-
-/**
- * Wrapper around `@date-io/date-fns` that resolves https://github.com/dmtrKovalenko/date-io/issues/479.
- * We're not using `adapter.date` in the implementation which means the implementation is safe.
- * But we do use it in tests where usage of ISO dates without timezone is problematic
- */
-
-import { jsx as _jsx } from "react/jsx-runtime";
-export class AdapterClassToUse extends AdapterDateFns {
-  constructor(...args) {
-    super(...args);
-
-    this.date = value => {
-      if (typeof value === 'string') {
-        return parseISO(value);
-      }
-
-      if (typeof value === 'undefined') {
-        return new Date();
-      }
-
-      if (value === null) {
-        // @ts-expect-error AdapterDateFns#date says it returns NotNullable but that's not true
-        return null;
-      }
-
-      return new Date(value);
-    };
-  }
-
-}
-export const adapterToUse = new AdapterClassToUse();
-export const FakeTransitionComponent = /*#__PURE__*/React.forwardRef(function FakeTransitionComponent({
-  children
-}, ref) {
-  // set tabIndex in case it is used as a child of <TrapFocus />
-  return /*#__PURE__*/_jsx("div", {
-    ref: ref,
-    tabIndex: -1,
-    children: children
-  });
-});
-export function wrapPickerMount(mount) {
-  return node => mount( /*#__PURE__*/_jsx(LocalizationProvider, {
-    dateAdapter: AdapterClassToUse,
-    children: node
-  }));
-}
-export function createPickerRenderer(_ref = {}) {
-  let {
-    locale
-  } = _ref,
-      createRendererOptions = _objectWithoutPropertiesLoose(_ref, _excluded);
-
-  const {
-    clock,
-    render: clientRender
-  } = createRenderer(createRendererOptions);
-
-  function Wrapper({
-    children
-  }) {
-    return /*#__PURE__*/_jsx(LocalizationProvider, {
-      locale: locale,
-      dateAdapter: AdapterClassToUse,
-      children: children
-    });
-  }
-
-  return {
-    clock,
-
-    render(node, options) {
-      return clientRender(node, _extends({}, options, {
-        wrapper: Wrapper
-      }));
-    }
-
-  };
-}
-export function openMobilePicker() {
-  fireEvent.click(screen.getByRole('textbox'));
-}

package/internal/pickers/text-field-helper.d.ts

@@ -1,11 +0,0 @@
-import { ParseableDate } from './constants/prop-types';
-import { MuiPickersAdapter } from './hooks/useUtils';
-export declare function getTextFieldAriaText<TDate>(rawValue: ParseableDate<TDate>, utils: MuiPickersAdapter<TDate>): string;
-export declare const getDisplayDate: <TDate>(utils: MuiPickersAdapter<TDate>, value: ParseableDate<TDate>, inputFormat: string) => string;
-export declare function pick12hOr24hFormat(userFormat: string | undefined, ampm: boolean | undefined, formats: {
-    localized: string;
-    '12h': string;
-    '24h': string;
-}): string;
-export declare function checkMaskIsValidForCurrentFormat(mask: string, format: string, acceptRegex: RegExp, utils: MuiPickersAdapter): boolean;
-export declare const maskedDateFormatter: (mask: string, acceptRegexp: RegExp) => (value: string) => string;

package/internal/pickers/text-field-helper.js

@@ -1,66 +0,0 @@
-export function getTextFieldAriaText(rawValue, utils) {
-  // TODO: should `isValid` narrow `TDate | null` to `NonNullable<TDate>`?
-  // Either we allow `TDate | null` to be valid and guard against calling `formatByString` with `null`.
-  // Or we ensure `formatByString` is callable with `null`.
-  return rawValue && utils.isValid(utils.date(rawValue)) ? `Choose date, selected date is ${utils.format(utils.date(rawValue), 'fullDate')}` : 'Choose date';
-}
-export const getDisplayDate = (utils, value, inputFormat) => {
-  const date = utils.date(value);
-  const isEmpty = value === null;
-
-  if (isEmpty) {
-    return '';
-  }
-
-  return utils.isValid(date) ? utils.formatByString( // TODO: should `isValid` narrow `TDate | null` to `NonNullable<TDate>`?
-  // Either we allow `TDate | null` to be valid and guard against calling `formatByString` with `null`.
-  // Or we ensure `formatByString` is callable with `null`.
-  date, inputFormat) : '';
-};
-export function pick12hOr24hFormat(userFormat, ampm, formats) {
-  if (userFormat) {
-    return userFormat;
-  }
-
-  if (typeof ampm === 'undefined') {
-    return formats.localized;
-  }
-
-  return ampm ? formats['12h'] : formats['24h'];
-}
-const MASK_USER_INPUT_SYMBOL = '_';
-const staticDateWith2DigitTokens = '2019-11-21T22:30:00.000';
-const staticDateWith1DigitTokens = '2019-01-01T09:00:00.000';
-export function checkMaskIsValidForCurrentFormat(mask, format, acceptRegex, utils) {
-  const formattedDateWith1Digit = utils.formatByString(utils.date(staticDateWith1DigitTokens), format);
-  const inferredFormatPatternWith1Digits = formattedDateWith1Digit.replace(acceptRegex, MASK_USER_INPUT_SYMBOL);
-  const inferredFormatPatternWith2Digits = utils.formatByString(utils.date(staticDateWith2DigitTokens), format).replace(acceptRegex, '_');
-  const isMaskValid = inferredFormatPatternWith2Digits === mask && inferredFormatPatternWith1Digits === mask;
-
-  if (!isMaskValid && utils.lib !== 'luxon' && process.env.NODE_ENV !== 'production') {
-    console.warn(`The mask "${mask}" you passed is not valid for the format used ${format}. Falling down to uncontrolled not-masked input.`);
-  }
-
-  return isMaskValid;
-}
-export const maskedDateFormatter = (mask, acceptRegexp) => value => {
-  return value.split('').map((char, i) => {
-    acceptRegexp.lastIndex = 0;
-
-    if (i > mask.length - 1) {
-      return '';
-    }
-
-    const maskChar = mask[i];
-    const nextMaskChar = mask[i + 1];
-    const acceptedChar = acceptRegexp.test(char) ? char : '';
-    const formattedChar = maskChar === MASK_USER_INPUT_SYMBOL ? acceptedChar : maskChar + acceptedChar;
-
-    if (i === value.length - 1 && nextMaskChar && nextMaskChar !== MASK_USER_INPUT_SYMBOL) {
-      // when cursor at the end of mask part (e.g. month) prerender next symbol "21" -> "21/"
-      return formattedChar ? formattedChar + nextMaskChar : '';
-    }
-
-    return formattedChar;
-  }).join('');
-};

package/internal/pickers/time-utils.d.ts

@@ -1,33 +0,0 @@
-import { ParseableDate } from './constants/prop-types';
-import { MuiPickersAdapter } from './hooks/useUtils';
-declare type Meridiem = 'am' | 'pm' | null;
-export declare const getMeridiem: (date: unknown, utils: MuiPickersAdapter<unknown>) => Meridiem;
-export declare const convertValueToMeridiem: (value: number, meridiem: Meridiem, ampm: boolean) => number;
-export declare const convertToMeridiem: <TDate>(time: TDate, meridiem: 'am' | 'pm', ampm: boolean, utils: MuiPickersAdapter<TDate>) => TDate;
-export declare function getSecondsInDay(date: unknown, utils: MuiPickersAdapter): number;
-export declare const createIsAfterIgnoreDatePart: (disableIgnoringDatePartForTimeValidation: boolean, utils: MuiPickersAdapter<unknown>) => (dateLeft: unknown, dateRight: unknown) => boolean;
-export interface TimeValidationProps<TDate> {
-    /**
-     * Min time acceptable time.
-     * For input validation date part of passed object will be ignored if `disableIgnoringDatePartForTimeValidation` not specified.
-     */
-    minTime?: TDate;
-    /**
-     * Max time acceptable time.
-     * For input validation date part of passed object will be ignored if `disableIgnoringDatePartForTimeValidation` not specified.
-     */
-    maxTime?: TDate;
-    /**
-     * Dynamically check if time is disabled or not.
-     * If returns `false` appropriate time point will ot be acceptable.
-     */
-    shouldDisableTime?: (timeValue: number, clockType: 'hours' | 'minutes' | 'seconds') => boolean;
-    /**
-     * Do not ignore date part when validating min/max time.
-     * @default false
-     */
-    disableIgnoringDatePartForTimeValidation?: boolean;
-}
-export declare const validateTime: <TDate>(utils: MuiPickersAdapter<unknown>, value: ParseableDate<TDate>, { minTime, maxTime, shouldDisableTime, disableIgnoringDatePartForTimeValidation, }: TimeValidationProps<TDate>) => "invalidDate" | "minTime" | "maxTime" | "shouldDisableTime-hours" | "shouldDisableTime-minutes" | "shouldDisableTime-seconds" | null;
-export declare type TimeValidationError = ReturnType<typeof validateTime>;
-export {};