@pisell/date-picker 1.0.0

package/es/Shortcuts/index.less

@@ -0,0 +1,18 @@
+.date-picker-shortcuts {
+  width: 192px;
+  padding: 12px 16px;
+  border-right: 1px solid rgba(0, 0, 0, 0.12);
+  .date-picker-shortcuts-item {
+    cursor: pointer;
+    padding: 10px 16px;
+    align-items: center;
+    color: var(--gray-700, #344054);
+    font-size: 14px;
+    font-style: normal;
+    font-weight: 500;
+    line-height: 20px; /* 142.857% */
+    &:hover {
+      background-color: rgb(249, 250, 251);
+    }
+  }
+}

package/es/SingleInputDateRangeField/SingleInputDateRangeField.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { SingleInputDateRangeFieldProps } from './SingleInputDateRangeField.types';
+declare type DateRangeFieldComponent = (<TDate>(props: SingleInputDateRangeFieldProps<TDate> & React.RefAttributes<HTMLInputElement>) => JSX.Element) & {
+    propTypes?: any;
+    fieldType?: string;
+};
+declare const SingleInputDateRangeField: DateRangeFieldComponent;
+export { SingleInputDateRangeField };
+//# sourceMappingURL=SingleInputDateRangeField.d.ts.map

package/es/SingleInputDateRangeField/SingleInputDateRangeField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SingleInputDateRangeField.d.ts","sourceRoot":"","sources":["SingleInputDateRangeField.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAK/B,OAAO,EAAE,8BAA8B,EAAE,MAAM,mCAAmC,CAAC;AAGnF,aAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,EACpC,KAAK,EAAE,8BAA8B,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,aAAa,CAAC,gBAAgB,CAAC,KACjF,GAAG,CAAC,OAAO,CAAC,GAAG;IAAE,SAAS,CAAC,EAAE,GAAG,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5D,QAAA,MAAM,yBAAyB,yBA+CF,CAAC;AAuR9B,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/es/SingleInputDateRangeField/SingleInputDateRangeField.js

@@ -0,0 +1,324 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["slots", "slotProps", "components", "componentsProps", "InputProps", "inputProps"],
+  _excluded2 = ["inputRef"],
+  _excluded3 = ["ref", "onPaste", "onKeyDown", "inputMode", "readOnly"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import MuiTextField from '@mui/material/TextField';
+import { useThemeProps } from '@mui/material/styles';
+import { useSlotProps } from '@mui/base/utils';
+import { useSingleInputDateRangeField } from "./useSingleInputDateRangeField";
+var SingleInputDateRangeField = /*#__PURE__*/React.forwardRef(function SingleInputDateRangeField(inProps, ref) {
+  var _ref, _slots$textField, _slotProps$textField;
+  var themeProps = useThemeProps({
+    props: inProps,
+    name: 'MuiSingleInputDateRangeField'
+  });
+  var slots = themeProps.slots,
+    slotProps = themeProps.slotProps,
+    components = themeProps.components,
+    componentsProps = themeProps.componentsProps,
+    InputProps = themeProps.InputProps,
+    inputProps = themeProps.inputProps,
+    other = _objectWithoutProperties(themeProps, _excluded);
+  var ownerState = themeProps;
+  var TextField = (_ref = (_slots$textField = slots === null || slots === void 0 ? void 0 : slots.textField) !== null && _slots$textField !== void 0 ? _slots$textField : components === null || components === void 0 ? void 0 : components.TextField) !== null && _ref !== void 0 ? _ref : MuiTextField;
+  var _useSlotProps = useSlotProps({
+      elementType: TextField,
+      externalSlotProps: (_slotProps$textField = slotProps === null || slotProps === void 0 ? void 0 : slotProps.textField) !== null && _slotProps$textField !== void 0 ? _slotProps$textField : componentsProps === null || componentsProps === void 0 ? void 0 : componentsProps.textField,
+      externalForwardedProps: other,
+      ownerState: ownerState
+    }),
+    externalInputRef = _useSlotProps.inputRef,
+    textFieldProps = _objectWithoutProperties(_useSlotProps, _excluded2);
+
+  // TODO: Remove when mui/material-ui#35088 will be merged
+  textFieldProps.inputProps = _objectSpread(_objectSpread({}, textFieldProps.inputProps), inputProps);
+  textFieldProps.InputProps = _objectSpread(_objectSpread({}, textFieldProps.InputProps), InputProps);
+  var _useSingleInputDateRa = useSingleInputDateRangeField({
+      props: textFieldProps,
+      inputRef: externalInputRef
+    }),
+    inputRef = _useSingleInputDateRa.ref,
+    onPaste = _useSingleInputDateRa.onPaste,
+    onKeyDown = _useSingleInputDateRa.onKeyDown,
+    inputMode = _useSingleInputDateRa.inputMode,
+    readOnly = _useSingleInputDateRa.readOnly,
+    fieldProps = _objectWithoutProperties(_useSingleInputDateRa, _excluded3);
+  return /*#__PURE__*/React.createElement(TextField, _extends({
+    ref: ref
+  }, fieldProps, {
+    InputProps: _objectSpread(_objectSpread({}, fieldProps.InputProps), {}, {
+      readOnly: readOnly
+    }),
+    inputProps: _objectSpread(_objectSpread({}, fieldProps.inputProps), {}, {
+      inputMode: inputMode,
+      onPaste: onPaste,
+      onKeyDown: onKeyDown,
+      ref: inputRef
+    })
+  }));
+});
+SingleInputDateRangeField.fieldType = 'single-input';
+SingleInputDateRangeField.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * If `true`, the `input` element is focused during the first mount.
+   * @default false
+   */
+  autoFocus: PropTypes.bool,
+  className: PropTypes.string,
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#adding-new-colors).
+   * @default 'primary'
+   */
+  color: PropTypes.oneOf(['error', 'info', 'primary', 'secondary', 'success', 'warning']),
+  /**
+   * Overridable components.
+   * @default {}
+   * @deprecated Please use `slots`.
+   */
+  components: PropTypes.object,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   * @deprecated Please use `slotProps`.
+   */
+  componentsProps: PropTypes.object,
+  /**
+   * The default value. Use when the component is not controlled.
+   */
+  defaultValue: PropTypes.arrayOf(PropTypes.any),
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: PropTypes.bool,
+  /**
+   * If `true`, disable values after the current date for date components, time for time components and both for date time components.
+   * @default false
+   */
+  disableFuture: PropTypes.bool,
+  /**
+   * If `true`, disable values before the current date for date components, time for time components and both for date time components.
+   * @default false
+   */
+  disablePast: PropTypes.bool,
+  /**
+   * If `true`, the component is displayed in focused state.
+   */
+  focused: PropTypes.bool,
+  /**
+   * Format of the date when rendered in the input(s).
+   */
+  format: PropTypes.string,
+  /**
+   * Density of the format when rendered in the input.
+   * Setting `formatDensity` to `"spacious"` will add a space before and after each `/`, `-` and `.` character.
+   * @default "dense"
+   */
+  formatDensity: PropTypes.oneOf(['dense', 'spacious']),
+  /**
+   * Props applied to the [`FormHelperText`](/material-ui/api/form-helper-text/) element.
+   */
+  FormHelperTextProps: PropTypes.object,
+  /**
+   * If `true`, the input will take up the full width of its container.
+   * @default false
+   */
+  fullWidth: PropTypes.bool,
+  /**
+   * The helper text content.
+   */
+  helperText: PropTypes.node,
+  /**
+   * If `true`, the label is hidden.
+   * This is used to increase density for a `FilledInput`.
+   * Be sure to add `aria-label` to the `input` element.
+   * @default false
+   */
+  hiddenLabel: PropTypes.bool,
+  /**
+   * The id of the `input` element.
+   * Use this prop to make `label` and `helperText` accessible for screen readers.
+   */
+  id: PropTypes.string,
+  /**
+   * Props applied to the [`InputLabel`](/material-ui/api/input-label/) element.
+   * Pointer events like `onClick` are enabled if and only if `shrink` is `true`.
+   */
+  InputLabelProps: PropTypes.object,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
+   */
+  inputProps: PropTypes.object,
+  /**
+   * Props applied to the Input element.
+   * It will be a [`FilledInput`](/material-ui/api/filled-input/),
+   * [`OutlinedInput`](/material-ui/api/outlined-input/) or [`Input`](/material-ui/api/input/)
+   * component depending on the `variant` prop value.
+   */
+  InputProps: PropTypes.object,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: PropTypes.oneOfType([PropTypes.func, PropTypes.shape({
+    current: PropTypes.any.isRequired
+  })]),
+  /**
+   * The label content.
+   */
+  label: PropTypes.node,
+  /**
+   * If `dense` or `normal`, will adjust vertical spacing of this and contained components.
+   * @default 'none'
+   */
+  margin: PropTypes.oneOf(['dense', 'none', 'normal']),
+  /**
+   * Maximal selectable date.
+   */
+  maxDate: PropTypes.any,
+  /**
+   * Minimal selectable date.
+   */
+  minDate: PropTypes.any,
+  /**
+   * Name attribute of the `input` element.
+   */
+  name: PropTypes.string,
+  onBlur: PropTypes.func,
+  /**
+   * Callback fired when the value changes.
+   * @template TValue The value type. Will be either the same type as `value` or `null`. Can be in `[start, end]` format in case of range value.
+   * @template TError The validation error type. Will be either `string` or a `null`. Can be in `[start, end]` format in case of range value.
+   * @param {TValue} value The new value.
+   * @param {FieldChangeHandlerContext<TError>} context The context containing the validation result of the current value.
+   */
+  onChange: PropTypes.func,
+  /**
+   * @ignore
+   */
+  onClick: PropTypes.func,
+  /**
+   * Callback fired when the error associated to the current value changes.
+   * @template TValue The value type. Will be either the same type as `value` or `null`. Can be in `[start, end]` format in case of range value.
+   * @template TError The validation error type. Will be either `string` or a `null`. Can be in `[start, end]` format in case of range value.
+   * @param {TError} error The new error.
+   * @param {TValue} value The value associated to the error.
+   */
+  onError: PropTypes.func,
+  onFocus: PropTypes.func,
+  /**
+   * Callback fired when the selected sections change.
+   * @param {FieldSelectedSections} newValue The new selected sections.
+   */
+  onSelectedSectionsChange: PropTypes.func,
+  /**
+   * It prevents the user from changing the value of the field
+   * (not from interacting with the field).
+   * @default false
+   */
+  readOnly: PropTypes.bool,
+  /**
+   * The date used to generate a part of the new value that is not present in the format when both `value` and `defaultValue` are empty.
+   * For example, on time fields it will be used to determine the date to set.
+   * @default The closest valid date using the validation props, except callbacks such as `shouldDisableDate`. Value is rounded to the most granular section used.
+   */
+  referenceDate: PropTypes.any,
+  /**
+   * If `true`, the label is displayed as required and the `input` element is required.
+   * @default false
+   */
+  required: PropTypes.bool,
+  /**
+   * The currently selected sections.
+   * This prop accept four formats:
+   * 1. If a number is provided, the section at this index will be selected.
+   * 2. If an object with a `startIndex` and `endIndex` properties are provided, the sections between those two indexes will be selected.
+   * 3. If a string of type `FieldSectionType` is provided, the first section with that name will be selected.
+   * 4. If `null` is provided, no section will be selected
+   * If not provided, the selected sections will be handled internally.
+   */
+  selectedSections: PropTypes.oneOfType([PropTypes.oneOf(['all', 'day', 'hours', 'meridiem', 'minutes', 'month', 'seconds', 'weekDay', 'year']), PropTypes.number, PropTypes.shape({
+    endIndex: PropTypes.number.isRequired,
+    startIndex: PropTypes.number.isRequired
+  })]),
+  /**
+   * Disable specific date.
+   * @template TDate
+   * @param {TDate} day The date to test.
+   * @param {string} position The date to test, 'start' or 'end'.
+   * @returns {boolean} Returns `true` if the date should be disabled.
+   */
+  shouldDisableDate: PropTypes.func,
+  /**
+   * If `true`, the format will respect the leading zeroes (e.g: on dayjs, the format `M/D/YYYY` will render `8/16/2018`)
+   * If `false`, the format will always add leading zeroes (e.g: on dayjs, the format `M/D/YYYY` will render `08/16/2018`)
+   *
+   * Warning n°1: Luxon is not able to respect the leading zeroes when using macro tokens (e.g: "DD"), so `shouldRespectLeadingZeros={true}` might lead to inconsistencies when using `AdapterLuxon`.
+   *
+   * Warning n°2: When `shouldRespectLeadingZeros={true}`, the field will add an invisible character on the sections containing a single digit to make sure `onChange` is fired.
+   * If you need to get the clean value from the input, you can remove this character using `input.value.replace(/\u200e/g, '')`.
+   *
+   * Warning n°3: When used in strict mode, dayjs and moment require to respect the leading zeros.
+   * This mean that when using `shouldRespectLeadingZeros={false}`, if you retrieve the value directly from the input (not listening to `onChange`) and your format contains tokens without leading zeros, the value will not be parsed by your library.
+   *
+   * @default `false`
+   */
+  shouldRespectLeadingZeros: PropTypes.bool,
+  /**
+   * The size of the component.
+   */
+  size: PropTypes.oneOf(['medium', 'small']),
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: PropTypes.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: PropTypes.object,
+  style: PropTypes.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
+  /**
+   * Choose which timezone to use for the value.
+   * Example: "default", "system", "UTC", "America/New_York".
+   * If you pass values from other timezones to some props, they will be converted to this timezone before being used.
+   * @see See the {@link https://mui.com/x/react-date-pickers/timezone/ timezones documention} for more details.
+   * @default The timezone of the `value` or `defaultValue` prop is defined, 'default' otherwise.
+   */
+  timezone: PropTypes.string,
+  /**
+   * The ref object used to imperatively interact with the field.
+   */
+  unstableFieldRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
+  /**
+   * The selected value.
+   * Used when the component is controlled.
+   */
+  value: PropTypes.arrayOf(PropTypes.any),
+  /**
+   * The variant to use.
+   * @default 'outlined'
+   */
+  variant: PropTypes.oneOf(['filled', 'outlined', 'standard'])
+};
+export { SingleInputDateRangeField };

package/es/SingleInputDateRangeField/SingleInputDateRangeField.types.d.ts

@@ -0,0 +1,50 @@
+import * as React from 'react';
+import { SlotComponentProps } from '@mui/base/utils';
+import TextField from '@mui/material/TextField';
+import { FieldsTextFieldProps, UncapitalizeObjectKeys } from '@mui/x-date-pickers/internals';
+import { UseDateRangeFieldDefaultizedProps, UseDateRangeFieldProps } from '../internals/models';
+export interface UseSingleInputDateRangeFieldParams<TDate, TChildProps extends {}> {
+    props: UseSingleInputDateRangeFieldComponentProps<TDate, TChildProps>;
+    inputRef?: React.Ref<HTMLInputElement>;
+}
+export interface UseSingleInputDateRangeFieldProps<TDate> extends UseDateRangeFieldProps<TDate> {
+}
+export declare type UseSingleInputDateRangeFieldDefaultizedProps<TDate, AdditionalProps extends {}> = UseDateRangeFieldDefaultizedProps<TDate> & Omit<AdditionalProps, 'value' | 'defaultValue' | 'onChange'>;
+export declare type UseSingleInputDateRangeFieldComponentProps<TDate, TChildProps extends {}> = Omit<TChildProps, keyof UseSingleInputDateRangeFieldProps<TDate>> & UseSingleInputDateRangeFieldProps<TDate>;
+export declare type SingleInputDateRangeFieldProps<TDate, TChildProps extends {} = FieldsTextFieldProps> = UseSingleInputDateRangeFieldComponentProps<TDate, TChildProps> & {
+    /**
+     * Overridable components.
+     * @default {}
+     * @deprecated Please use `slots`.
+     */
+    components?: SingleInputDateRangeFieldSlotsComponent;
+    /**
+     * The props used for each component slot.
+     * @default {}
+     * @deprecated Please use `slotProps`.
+     */
+    componentsProps?: SingleInputDateRangeFieldSlotsComponentsProps<TDate>;
+    /**
+     * Overridable component slots.
+     * @default {}
+     */
+    slots?: UncapitalizeObjectKeys<SingleInputDateRangeFieldSlotsComponent>;
+    /**
+     * The props used for each component slot.
+     * @default {}
+     */
+    slotProps?: SingleInputDateRangeFieldSlotsComponentsProps<TDate>;
+};
+export declare type SingleInputDateRangeFieldOwnerState<TDate> = SingleInputDateRangeFieldProps<TDate>;
+export interface SingleInputDateRangeFieldSlotsComponent {
+    /**
+     * Form control with an input to render the value.
+     * Receives the same props as `@mui/material/TextField`.
+     * @default TextField from '@mui/material'
+     */
+    TextField?: React.ElementType;
+}
+export interface SingleInputDateRangeFieldSlotsComponentsProps<TDate> {
+    textField?: SlotComponentProps<typeof TextField, {}, SingleInputDateRangeFieldOwnerState<TDate>>;
+}
+//# sourceMappingURL=SingleInputDateRangeField.types.d.ts.map

package/es/SingleInputDateRangeField/SingleInputDateRangeField.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SingleInputDateRangeField.types.d.ts","sourceRoot":"","sources":["SingleInputDateRangeField.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,SAAS,MAAM,yBAAyB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAC7F,OAAO,EAAE,iCAAiC,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAEhG,MAAM,WAAW,kCAAkC,CAAC,KAAK,EAAE,WAAW,SAAS,EAAE;IAC/E,KAAK,EAAE,0CAA0C,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IACtE,QAAQ,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;CACxC;AAED,MAAM,WAAW,iCAAiC,CAAC,KAAK,CAAE,SAAQ,sBAAsB,CAAC,KAAK,CAAC;CAAG;AAElG,oBAAY,4CAA4C,CACtD,KAAK,EACL,eAAe,SAAS,EAAE,IACxB,iCAAiC,CAAC,KAAK,CAAC,GAC1C,IAAI,CAAC,eAAe,EAAE,OAAO,GAAG,cAAc,GAAG,UAAU,CAAC,CAAC;AAE/D,oBAAY,0CAA0C,CAAC,KAAK,EAAE,WAAW,SAAS,EAAE,IAAI,IAAI,CAC1F,WAAW,EACX,MAAM,iCAAiC,CAAC,KAAK,CAAC,CAC/C,GACC,iCAAiC,CAAC,KAAK,CAAC,CAAC;AAE3C,oBAAY,8BAA8B,CACxC,KAAK,EACL,WAAW,SAAS,EAAE,GAAG,oBAAoB,IAC3C,0CAA0C,CAAC,KAAK,EAAE,WAAW,CAAC,GAAG;IACnE;;;;OAIG;IACH,UAAU,CAAC,EAAE,uCAAuC,CAAC;IACrD;;;;OAIG;IACH,eAAe,CAAC,EAAE,6CAA6C,CAAC,KAAK,CAAC,CAAC;IACvE;;;OAGG;IACH,KAAK,CAAC,EAAE,sBAAsB,CAAC,uCAAuC,CAAC,CAAC;IACxE;;;OAGG;IACH,SAAS,CAAC,EAAE,6CAA6C,CAAC,KAAK,CAAC,CAAC;CAClE,CAAC;AAEF,oBAAY,mCAAmC,CAAC,KAAK,IAAI,8BAA8B,CAAC,KAAK,CAAC,CAAC;AAE/F,MAAM,WAAW,uCAAuC;IACtD;;;;OAIG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,WAAW,CAAC;CAC/B;AAED,MAAM,WAAW,6CAA6C,CAAC,KAAK;IAClE,SAAS,CAAC,EAAE,kBAAkB,CAAC,OAAO,SAAS,EAAE,EAAE,EAAE,mCAAmC,CAAC,KAAK,CAAC,CAAC,CAAC;CAClG"}

package/es/SingleInputDateRangeField/SingleInputDateRangeField.types.js

@@ -0,0 +1 @@
+export {};

package/es/SingleInputDateRangeField/index.d.ts

@@ -0,0 +1,4 @@
+export { SingleInputDateRangeField } from './SingleInputDateRangeField';
+export { useSingleInputDateRangeField as unstable_useSingleInputDateRangeField } from './useSingleInputDateRangeField';
+export type { UseSingleInputDateRangeFieldProps, UseSingleInputDateRangeFieldComponentProps, SingleInputDateRangeFieldProps, } from './SingleInputDateRangeField.types';
+//# sourceMappingURL=index.d.ts.map

package/es/SingleInputDateRangeField/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,EAAE,4BAA4B,IAAI,qCAAqC,EAAE,MAAM,gCAAgC,CAAC;AACvH,YAAY,EACV,iCAAiC,EACjC,0CAA0C,EAC1C,8BAA8B,GAC/B,MAAM,mCAAmC,CAAC"}

package/es/SingleInputDateRangeField/index.js

@@ -0,0 +1,2 @@
+export { SingleInputDateRangeField } from "./SingleInputDateRangeField";
+export { useSingleInputDateRangeField as unstable_useSingleInputDateRangeField } from "./useSingleInputDateRangeField";

package/es/SingleInputDateRangeField/useSingleInputDateRangeField.d.ts

@@ -0,0 +1,4 @@
+import { UseSingleInputDateRangeFieldDefaultizedProps, UseSingleInputDateRangeFieldParams, UseSingleInputDateRangeFieldProps } from './SingleInputDateRangeField.types';
+export declare const useDefaultizedDateRangeFieldProps: <TDate, AdditionalProps extends {}>(props: UseSingleInputDateRangeFieldProps<TDate>) => UseSingleInputDateRangeFieldDefaultizedProps<TDate, AdditionalProps>;
+export declare const useSingleInputDateRangeField: <TDate, TChildProps extends {}>({ props: inProps, inputRef, }: UseSingleInputDateRangeFieldParams<TDate, TChildProps>) => import("@mui/x-date-pickers/internals").UseFieldResponse<Omit<UseSingleInputDateRangeFieldDefaultizedProps<TDate, TChildProps>, keyof UseSingleInputDateRangeFieldProps<any>>>;
+//# sourceMappingURL=useSingleInputDateRangeField.d.ts.map

package/es/SingleInputDateRangeField/useSingleInputDateRangeField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSingleInputDateRangeField.d.ts","sourceRoot":"","sources":["useSingleInputDateRangeField.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,4CAA4C,EAC5C,kCAAkC,EAClC,iCAAiC,EAClC,MAAM,mCAAmC,CAAC;AAI3C,eAAO,MAAM,iCAAiC,8JAc7C,CAAC;AAEF,eAAO,MAAM,4BAA4B,0SAoBxC,CAAC"}

package/es/SingleInputDateRangeField/useSingleInputDateRangeField.js

@@ -0,0 +1,38 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { useUtils, useDefaultDates, applyDefaultDate, useField, splitFieldInternalAndForwardedProps } from '@mui/x-date-pickers/internals';
+import { rangeValueManager, rangeFieldValueManager } from "../internals/utils/valueManagers";
+import { validateDateRange } from "../internals/utils/validation/validateDateRange";
+export var useDefaultizedDateRangeFieldProps = function useDefaultizedDateRangeFieldProps(props) {
+  var _props$disablePast, _props$disableFuture, _props$format;
+  var utils = useUtils();
+  var defaultDates = useDefaultDates();
+  return _objectSpread(_objectSpread({}, props), {}, {
+    disablePast: (_props$disablePast = props.disablePast) !== null && _props$disablePast !== void 0 ? _props$disablePast : false,
+    disableFuture: (_props$disableFuture = props.disableFuture) !== null && _props$disableFuture !== void 0 ? _props$disableFuture : false,
+    format: (_props$format = props.format) !== null && _props$format !== void 0 ? _props$format : utils.formats.keyboardDate,
+    minDate: applyDefaultDate(utils, props.minDate, defaultDates.minDate),
+    maxDate: applyDefaultDate(utils, props.maxDate, defaultDates.maxDate)
+  });
+};
+export var useSingleInputDateRangeField = function useSingleInputDateRangeField(_ref) {
+  var inProps = _ref.props,
+    inputRef = _ref.inputRef;
+  var props = useDefaultizedDateRangeFieldProps(inProps);
+  var _splitFieldInternalAn = splitFieldInternalAndForwardedProps(props, 'date'),
+    forwardedProps = _splitFieldInternalAn.forwardedProps,
+    internalProps = _splitFieldInternalAn.internalProps;
+  return useField({
+    inputRef: inputRef,
+    forwardedProps: forwardedProps,
+    internalProps: internalProps,
+    valueManager: rangeValueManager,
+    fieldValueManager: rangeFieldValueManager,
+    validator: validateDateRange,
+    valueType: 'date'
+  });
+};

package/es/SingleInputDateTimeRangeField/SingleInputDateTimeRangeField.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { SingleInputDateTimeRangeFieldProps } from './SingleInputDateTimeRangeField.types';
+declare type DateRangeFieldComponent = (<TDate>(props: SingleInputDateTimeRangeFieldProps<TDate> & React.RefAttributes<HTMLInputElement>) => JSX.Element) & {
+    propTypes?: any;
+    fieldType?: string;
+};
+declare const SingleInputDateTimeRangeField: DateRangeFieldComponent;
+export { SingleInputDateTimeRangeField };
+//# sourceMappingURL=SingleInputDateTimeRangeField.d.ts.map

package/es/SingleInputDateTimeRangeField/SingleInputDateTimeRangeField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SingleInputDateTimeRangeField.d.ts","sourceRoot":"","sources":["SingleInputDateTimeRangeField.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAK/B,OAAO,EAAE,kCAAkC,EAAE,MAAM,uCAAuC,CAAC;AAG3F,aAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,EACpC,KAAK,EAAE,kCAAkC,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,aAAa,CAAC,gBAAgB,CAAC,KACrF,GAAG,CAAC,OAAO,CAAC,GAAG;IAAE,SAAS,CAAC,EAAE,GAAG,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5D,QAAA,MAAM,6BAA6B,yBAgDN,CAAC;AAwU9B,OAAO,EAAE,6BAA6B,EAAE,CAAC"}