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

package/legacy/internal/pickers/date-utils.js

@@ -1,143 +0,0 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-export var findClosestEnabledDate = function findClosestEnabledDate(_ref) {
-  var date = _ref.date,
-      disableFuture = _ref.disableFuture,
-      disablePast = _ref.disablePast,
-      maxDate = _ref.maxDate,
-      minDate = _ref.minDate,
-      shouldDisableDate = _ref.shouldDisableDate,
-      utils = _ref.utils;
-  var today = utils.startOfDay(utils.date());
-
-  if (disablePast && utils.isBefore(minDate, today)) {
-    minDate = today;
-  }
-
-  if (disableFuture && utils.isAfter(maxDate, today)) {
-    maxDate = today;
-  }
-
-  var forward = date;
-  var backward = date;
-
-  if (utils.isBefore(date, minDate)) {
-    forward = utils.date(minDate);
-    backward = null;
-  }
-
-  if (utils.isAfter(date, maxDate)) {
-    if (backward) {
-      backward = utils.date(maxDate);
-    }
-
-    forward = null;
-  }
-
-  while (forward || backward) {
-    if (forward && utils.isAfter(forward, maxDate)) {
-      forward = null;
-    }
-
-    if (backward && utils.isBefore(backward, minDate)) {
-      backward = null;
-    }
-
-    if (forward) {
-      if (!shouldDisableDate(forward)) {
-        return forward;
-      }
-
-      forward = utils.addDays(forward, 1);
-    }
-
-    if (backward) {
-      if (!shouldDisableDate(backward)) {
-        return backward;
-      }
-
-      backward = utils.addDays(backward, -1);
-    }
-  }
-
-  return today;
-};
-export function parsePickerInputValue(utils, value) {
-  var parsedValue = utils.date(value);
-  return utils.isValid(parsedValue) ? parsedValue : null;
-}
-export function parseRangeInputValue(utils) {
-  var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [null, null];
-  return value.map(function (date) {
-    return !utils.isValid(date) || date === null ? null : utils.startOfDay(utils.date(date));
-  });
-}
-export var isRangeValid = function isRangeValid(utils, range) {
-  return Boolean(range && range[0] && range[1] && !utils.isBefore(range[1], range[0]));
-};
-export var isWithinRange = function isWithinRange(utils, day, range) {
-  return isRangeValid(utils, range) && utils.isWithinRange(day, range);
-};
-export var isStartOfRange = function isStartOfRange(utils, day, range) {
-  return isRangeValid(utils, range) && utils.isSameDay(day, range[0]);
-};
-export var isEndOfRange = function isEndOfRange(utils, day, range) {
-  return isRangeValid(utils, range) && utils.isSameDay(day, range[1]);
-};
-export var validateDate = function validateDate(utils, value, _ref2) {
-  var disablePast = _ref2.disablePast,
-      disableFuture = _ref2.disableFuture,
-      minDate = _ref2.minDate,
-      maxDate = _ref2.maxDate,
-      shouldDisableDate = _ref2.shouldDisableDate;
-  var now = utils.date();
-  var date = utils.date(value);
-
-  if (date === null) {
-    return null;
-  }
-
-  switch (true) {
-    case !utils.isValid(value):
-      return 'invalidDate';
-
-    case Boolean(shouldDisableDate && shouldDisableDate(date)):
-      return 'shouldDisableDate';
-
-    case Boolean(disableFuture && utils.isAfterDay(date, now)):
-      return 'disableFuture';
-
-    case Boolean(disablePast && utils.isBeforeDay(date, now)):
-      return 'disablePast';
-
-    case Boolean(minDate && utils.isBeforeDay(date, minDate)):
-      return 'minDate';
-
-    case Boolean(maxDate && utils.isAfterDay(date, maxDate)):
-      return 'maxDate';
-
-    default:
-      return null;
-  }
-};
-export var validateDateRange = function validateDateRange(utils, value, dateValidationProps) {
-  var _value = _slicedToArray(value, 2),
-      start = _value[0],
-      end = _value[1]; // for partial input
-
-
-  if (start === null || end === null) {
-    return [null, null];
-  }
-
-  var dateValidations = [validateDate(utils, start, dateValidationProps), validateDate(utils, end, dateValidationProps)];
-
-  if (dateValidations[0] || dateValidations[1]) {
-    return dateValidations;
-  }
-
-  if (!isRangeValid(utils, [utils.date(start), utils.date(end)])) {
-    return ['invalidRange', 'invalidRange'];
-  }
-
-  return [null, null];
-};

package/legacy/internal/pickers/hooks/date-helpers-hooks.js

@@ -1,35 +0,0 @@
-import * as React from 'react';
-import { useUtils } from './useUtils';
-import { getMeridiem, convertToMeridiem } from '../time-utils';
-export function useNextMonthDisabled(month, _ref) {
-  var disableFuture = _ref.disableFuture,
-      maxDate = _ref.maxDate;
-  var utils = useUtils();
-  return React.useMemo(function () {
-    var now = utils.date();
-    var lastEnabledMonth = utils.startOfMonth(disableFuture && utils.isBefore(now, maxDate) ? now : maxDate);
-    return !utils.isAfter(lastEnabledMonth, month);
-  }, [disableFuture, maxDate, month, utils]);
-}
-export function usePreviousMonthDisabled(month, _ref2) {
-  var disablePast = _ref2.disablePast,
-      minDate = _ref2.minDate;
-  var utils = useUtils();
-  return React.useMemo(function () {
-    var now = utils.date();
-    var firstEnabledMonth = utils.startOfMonth(disablePast && utils.isAfter(now, minDate) ? now : minDate);
-    return !utils.isBefore(firstEnabledMonth, month);
-  }, [disablePast, minDate, month, utils]);
-}
-export function useMeridiemMode(date, ampm, onChange) {
-  var utils = useUtils();
-  var meridiemMode = getMeridiem(date, utils);
-  var handleMeridiemChange = React.useCallback(function (mode) {
-    var timeWithMeridiem = convertToMeridiem(date, mode, Boolean(ampm), utils);
-    onChange(timeWithMeridiem, 'partial');
-  }, [ampm, date, onChange, utils]);
-  return {
-    meridiemMode: meridiemMode,
-    handleMeridiemChange: handleMeridiemChange
-  };
-}

package/legacy/internal/pickers/hooks/useIsLandscape.js

@@ -1,46 +0,0 @@
-import * as React from 'react';
-import { unstable_useEnhancedEffect as useEnhancedEffect } from '@mui/utils';
-import { arrayIncludes } from '../utils';
-
-function getOrientation() {
-  if (typeof window === 'undefined') {
-    return 'portrait';
-  }
-
-  if (window.screen && window.screen.orientation && window.screen.orientation.angle) {
-    return Math.abs(window.screen.orientation.angle) === 90 ? 'landscape' : 'portrait';
-  } // Support IOS safari
-
-
-  if (window.orientation) {
-    return Math.abs(Number(window.orientation)) === 90 ? 'landscape' : 'portrait';
-  }
-
-  return 'portrait';
-}
-
-export function useIsLandscape(views, customOrientation) {
-  var _React$useState = React.useState(getOrientation),
-      orientation = _React$useState[0],
-      setOrientation = _React$useState[1];
-
-  useEnhancedEffect(function () {
-    var eventHandler = function eventHandler() {
-      setOrientation(getOrientation());
-    };
-
-    window.addEventListener('orientationchange', eventHandler);
-    return function () {
-      window.removeEventListener('orientationchange', eventHandler);
-    };
-  }, []);
-
-  if (arrayIncludes(views, ['hours', 'minutes', 'seconds'])) {
-    // could not display 13:34:44 in landscape mode
-    return false;
-  }
-
-  var orientationToUse = customOrientation || orientation;
-  return orientationToUse === 'landscape';
-}
-export default useIsLandscape;

package/legacy/internal/pickers/hooks/useMaskedInput.js

@@ -1,105 +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(_ref) {
-  var _ref$acceptRegex = _ref.acceptRegex,
-      acceptRegex = _ref$acceptRegex === void 0 ? /[\d]/gi : _ref$acceptRegex,
-      disabled = _ref.disabled,
-      disableMaskedInput = _ref.disableMaskedInput,
-      ignoreInvalidInputs = _ref.ignoreInvalidInputs,
-      inputFormat = _ref.inputFormat,
-      inputProps = _ref.inputProps,
-      label = _ref.label,
-      mask = _ref.mask,
-      onChange = _ref.onChange,
-      rawValue = _ref.rawValue,
-      readOnly = _ref.readOnly,
-      rifmFormatter = _ref.rifmFormatter,
-      TextFieldProps = _ref.TextFieldProps,
-      validationError = _ref.validationError;
-  var utils = useUtils();
-
-  var _React$useState = React.useState(false),
-      isFocused = _React$useState[0],
-      setIsFocused = _React$useState[1];
-
-  var formatHelperText = utils.getFormatHelperText(inputFormat);
-  var shouldUseMaskedInput = React.useMemo(function () {
-    // 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]);
-  var formatter = React.useMemo(function () {
-    return shouldUseMaskedInput && mask ? maskedDateFormatter(mask, acceptRegex) : function (st) {
-      return st;
-    };
-  }, [acceptRegex, mask, shouldUseMaskedInput]); // TODO: Implement with controlled vs unctrolled `rawValue`
-
-  var currentInputValue = getDisplayDate(utils, rawValue, inputFormat);
-
-  var _React$useState2 = React.useState(currentInputValue),
-      innerInputValue = _React$useState2[0],
-      setInnerInputValue = _React$useState2[1];
-
-  var previousInputValueRef = React.useRef(currentInputValue);
-  React.useEffect(function () {
-    previousInputValueRef.current = currentInputValue;
-  }, [currentInputValue]);
-  var notTyping = !isFocused;
-  var 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);
-    }
-  }
-
-  var handleChange = function handleChange(text) {
-    var finalString = text === '' || text === mask ? '' : text;
-    setInnerInputValue(finalString);
-    var date = finalString === null ? null : utils.parse(finalString, inputFormat);
-
-    if (ignoreInvalidInputs && !utils.isValid(date)) {
-      return;
-    }
-
-    onChange(date, finalString || undefined);
-  };
-
-  var rifmProps = useRifm({
-    value: innerInputValue,
-    onChange: handleChange,
-    format: rifmFormatter || formatter
-  });
-  var inputStateArgs = shouldUseMaskedInput ? rifmProps : {
-    value: innerInputValue,
-    onChange: function onChange(event) {
-      handleChange(event.currentTarget.value);
-    }
-  };
-  return _extends({
-    label: label,
-    disabled: disabled,
-    error: validationError,
-    inputProps: _extends({}, inputStateArgs, {
-      disabled: disabled,
-      placeholder: formatHelperText,
-      readOnly: readOnly,
-      type: shouldUseMaskedInput ? 'tel' : 'text'
-    }, inputProps, {
-      onFocus: createDelegatedEventHandler(function () {
-        setIsFocused(true);
-      }, inputProps == null ? void 0 : inputProps.onFocus),
-      onBlur: createDelegatedEventHandler(function () {
-        setIsFocused(false);
-      }, inputProps == null ? void 0 : inputProps.onBlur)
-    })
-  }, TextFieldProps);
-}
-export default useMaskedInput;

package/legacy/internal/pickers/hooks/useOpenState.js

@@ -1,41 +0,0 @@
-import * as React from 'react';
-export function useOpenState(_ref) {
-  var open = _ref.open,
-      onOpen = _ref.onOpen,
-      onClose = _ref.onClose;
-  var isControllingOpenProp = React.useRef(typeof open === 'boolean').current;
-
-  var _React$useState = React.useState(false),
-      openState = _React$useState[0],
-      setIsOpenState = _React$useState[1]; // 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(function () {
-    if (isControllingOpenProp) {
-      if (typeof open !== 'boolean') {
-        throw new Error('You must not mix controlling and uncontrolled mode for `open` prop');
-      }
-
-      setIsOpenState(open);
-    }
-  }, [isControllingOpenProp, open]);
-  var setIsOpen = React.useCallback(function (newIsOpen) {
-    if (!isControllingOpenProp) {
-      setIsOpenState(newIsOpen);
-    }
-
-    if (newIsOpen && onOpen) {
-      onOpen();
-    }
-
-    if (!newIsOpen && onClose) {
-      onClose();
-    }
-  }, [isControllingOpenProp, onOpen, onClose]);
-  return {
-    isOpen: openState,
-    setIsOpen: setIsOpen
-  };
-}
-export default useOpenState;

package/legacy/internal/pickers/hooks/usePickerState.js

@@ -1,143 +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) {
-  var disableCloseOnSelect = props.disableCloseOnSelect,
-      onAccept = props.onAccept,
-      onChange = props.onChange,
-      value = props.value;
-  var utils = useUtils();
-
-  var _useOpenState = useOpenState(props),
-      isOpen = _useOpenState.isOpen,
-      setIsOpen = _useOpenState.setIsOpen;
-
-  function initDraftableDate(date) {
-    return {
-      committed: date,
-      draft: date
-    };
-  }
-
-  var parsedDateValue = valueManager.parseInput(utils, value);
-
-  var _React$useReducer = React.useReducer(function (state, action) {
-    switch (action.type) {
-      case 'reset':
-        return initDraftableDate(action.payload);
-
-      case 'update':
-        return _extends({}, state, {
-          draft: action.payload
-        });
-
-      default:
-        return state;
-    }
-  }, parsedDateValue, initDraftableDate),
-      draftState = _React$useReducer[0],
-      dispatch = _React$useReducer[1];
-
-  if (!valueManager.areValuesEqual(utils, draftState.committed, parsedDateValue)) {
-    dispatch({
-      type: 'reset',
-      payload: parsedDateValue
-    });
-  }
-
-  var _React$useState = React.useState(draftState.committed),
-      initialDate = _React$useState[0],
-      setInitialDate = _React$useState[1]; // Mobile keyboard view is a special case.
-  // When it's open picker should work like closed, cause we are just showing text field
-
-
-  var _React$useState2 = React.useState(false),
-      isMobileKeyboardViewOpen = _React$useState2[0],
-      setMobileKeyboardViewOpen = _React$useState2[1];
-
-  var acceptDate = React.useCallback(function (acceptedDate, needClosePicker) {
-    onChange(acceptedDate);
-
-    if (needClosePicker) {
-      setIsOpen(false);
-      setInitialDate(acceptedDate);
-
-      if (onAccept) {
-        onAccept(acceptedDate);
-      }
-    }
-  }, [onAccept, onChange, setIsOpen]);
-  var wrapperProps = React.useMemo(function () {
-    return {
-      open: isOpen,
-      onClear: function onClear() {
-        return acceptDate(valueManager.emptyValue, true);
-      },
-      onAccept: function onAccept() {
-        return acceptDate(draftState.draft, true);
-      },
-      onDismiss: function onDismiss() {
-        return acceptDate(initialDate, true);
-      },
-      onSetToday: function onSetToday() {
-        var now = utils.date();
-        dispatch({
-          type: 'update',
-          payload: now
-        });
-        acceptDate(now, !disableCloseOnSelect);
-      }
-    };
-  }, [acceptDate, disableCloseOnSelect, isOpen, utils, draftState.draft, valueManager.emptyValue, initialDate]);
-  var pickerProps = React.useMemo(function () {
-    return {
-      date: draftState.draft,
-      isMobileKeyboardViewOpen: isMobileKeyboardViewOpen,
-      toggleMobileKeyboardView: function toggleMobileKeyboardView() {
-        return setMobileKeyboardViewOpen(!isMobileKeyboardViewOpen);
-      },
-      onDateChange: function onDateChange(newDate, wrapperVariant) {
-        var selectionState = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'partial';
-        dispatch({
-          type: 'update',
-          payload: newDate
-        });
-
-        if (selectionState === 'partial') {
-          acceptDate(newDate, false);
-        }
-
-        if (selectionState === 'finish') {
-          var 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]);
-  var inputProps = React.useMemo(function () {
-    return {
-      onChange: onChange,
-      open: isOpen,
-      rawValue: value,
-      openPicker: function openPicker() {
-        return setIsOpen(true);
-      }
-    };
-  }, [onChange, isOpen, value, setIsOpen]);
-  var pickerState = {
-    pickerProps: pickerProps,
-    inputProps: inputProps,
-    wrapperProps: wrapperProps
-  };
-  React.useDebugValue(pickerState, function () {
-    return {
-      MuiPickerState: {
-        pickerDraft: draftState,
-        other: pickerState
-      }
-    };
-  });
-  return pickerState;
-}

package/legacy/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() {
-  var 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() {
-  var utils = useUtils();
-  var now = React.useRef(utils.date());
-  return now.current;
-}

package/legacy/internal/pickers/hooks/useValidation.js

@@ -1,43 +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) {
-  var isSameError = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : isSameDateOrTimeError;
-  var value = props.value,
-      onError = props.onError;
-  var utils = useUtils();
-  var previousValidationErrorRef = React.useRef(null);
-  var validationError = validate(utils, value, props);
-  React.useEffect(function () {
-    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/legacy/internal/pickers/hooks/useViews.js

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