@pisell/date-picker 1.0.0

package/lib/SingleInputDateTimeRangeField/index.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/SingleInputDateTimeRangeField/index.ts
+var SingleInputDateTimeRangeField_exports = {};
+__export(SingleInputDateTimeRangeField_exports, {
+  SingleInputDateTimeRangeField: () => import_SingleInputDateTimeRangeField.SingleInputDateTimeRangeField,
+  unstable_useSingleInputDateTimeRangeField: () => import_useSingleInputDateTimeRangeField.useSingleInputDateTimeRangeField
+});
+module.exports = __toCommonJS(SingleInputDateTimeRangeField_exports);
+var import_SingleInputDateTimeRangeField = require("./SingleInputDateTimeRangeField");
+var import_useSingleInputDateTimeRangeField = require("./useSingleInputDateTimeRangeField");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SingleInputDateTimeRangeField,
+  unstable_useSingleInputDateTimeRangeField
+});

package/lib/SingleInputDateTimeRangeField/useSingleInputDateTimeRangeField.d.ts

@@ -0,0 +1,4 @@
+import { UseSingleInputDateTimeRangeFieldDefaultizedProps, UseSingleInputDateTimeRangeFieldParams, UseSingleInputDateTimeRangeFieldProps } from './SingleInputDateTimeRangeField.types';
+export declare const useDefaultizedTimeRangeFieldProps: <TDate, AdditionalProps extends {}>(props: UseSingleInputDateTimeRangeFieldProps<TDate>) => UseSingleInputDateTimeRangeFieldDefaultizedProps<TDate, AdditionalProps>;
+export declare const useSingleInputDateTimeRangeField: <TDate, TChildProps extends {}>({ props: inProps, inputRef, }: UseSingleInputDateTimeRangeFieldParams<TDate, TChildProps>) => import("@mui/x-date-pickers/internals").UseFieldResponse<Omit<UseSingleInputDateTimeRangeFieldDefaultizedProps<TDate, TChildProps>, keyof UseSingleInputDateTimeRangeFieldProps<any>>>;
+//# sourceMappingURL=useSingleInputDateTimeRangeField.d.ts.map

package/lib/SingleInputDateTimeRangeField/useSingleInputDateTimeRangeField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSingleInputDateTimeRangeField.d.ts","sourceRoot":"","sources":["useSingleInputDateTimeRangeField.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,gDAAgD,EAChD,sCAAsC,EACtC,qCAAqC,EACtC,MAAM,uCAAuC,CAAC;AAI/C,eAAO,MAAM,iCAAiC,sKAsB7C,CAAC;AAEF,eAAO,MAAM,gCAAgC,sTAoB5C,CAAC"}

package/lib/SingleInputDateTimeRangeField/useSingleInputDateTimeRangeField.js

@@ -0,0 +1,66 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/SingleInputDateTimeRangeField/useSingleInputDateTimeRangeField.ts
+var useSingleInputDateTimeRangeField_exports = {};
+__export(useSingleInputDateTimeRangeField_exports, {
+  useDefaultizedTimeRangeFieldProps: () => useDefaultizedTimeRangeFieldProps,
+  useSingleInputDateTimeRangeField: () => useSingleInputDateTimeRangeField
+});
+module.exports = __toCommonJS(useSingleInputDateTimeRangeField_exports);
+var import_internals = require("@mui/x-date-pickers/internals");
+var import_valueManagers = require("../internals/utils/valueManagers");
+var import_validateDateTimeRange = require("../internals/utils/validation/validateDateTimeRange");
+var useDefaultizedTimeRangeFieldProps = (props) => {
+  const utils = (0, import_internals.useUtils)();
+  const defaultDates = (0, import_internals.useDefaultDates)();
+  const ampm = props.ampm ?? utils.is12HourCycleInCurrentLocale();
+  const defaultFormat = ampm ? utils.formats.keyboardDateTime12h : utils.formats.keyboardDateTime24h;
+  return {
+    ...props,
+    disablePast: props.disablePast ?? false,
+    disableFuture: props.disableFuture ?? false,
+    format: props.format ?? defaultFormat,
+    minDate: (0, import_internals.applyDefaultDate)(utils, props.minDateTime ?? props.minDate, defaultDates.minDate),
+    maxDate: (0, import_internals.applyDefaultDate)(utils, props.maxDateTime ?? props.maxDate, defaultDates.maxDate),
+    minTime: props.minDateTime ?? props.minTime,
+    maxTime: props.maxDateTime ?? props.maxTime,
+    disableIgnoringDatePartForTimeValidation: Boolean(props.minDateTime || props.maxDateTime)
+  };
+};
+var useSingleInputDateTimeRangeField = ({
+  props: inProps,
+  inputRef
+}) => {
+  const props = useDefaultizedTimeRangeFieldProps(inProps);
+  const { forwardedProps, internalProps } = (0, import_internals.splitFieldInternalAndForwardedProps)(props, "date-time");
+  return (0, import_internals.useField)({
+    inputRef,
+    forwardedProps,
+    internalProps,
+    valueManager: import_valueManagers.rangeValueManager,
+    fieldValueManager: import_valueManagers.rangeFieldValueManager,
+    validator: import_validateDateTimeRange.validateDateTimeRange,
+    valueType: "date-time"
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDefaultizedTimeRangeFieldProps,
+  useSingleInputDateTimeRangeField
+});

package/lib/SingleInputTimeRangeField/SingleInputTimeRangeField.d.ts

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

package/lib/SingleInputTimeRangeField/SingleInputTimeRangeField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SingleInputTimeRangeField.d.ts","sourceRoot":"","sources":["SingleInputTimeRangeField.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;AAgT9B,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/lib/SingleInputTimeRangeField/SingleInputTimeRangeField.js

@@ -0,0 +1,381 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/SingleInputTimeRangeField/SingleInputTimeRangeField.tsx
+var SingleInputTimeRangeField_exports = {};
+__export(SingleInputTimeRangeField_exports, {
+  SingleInputTimeRangeField: () => SingleInputTimeRangeField
+});
+module.exports = __toCommonJS(SingleInputTimeRangeField_exports);
+var React = __toESM(require("react"));
+var import_prop_types = __toESM(require("prop-types"));
+var import_TextField = __toESM(require("@mui/material/TextField"));
+var import_styles = require("@mui/material/styles");
+var import_utils = require("@mui/base/utils");
+var import_useSingleInputTimeRangeField = require("./useSingleInputTimeRangeField");
+var SingleInputTimeRangeField = React.forwardRef(function SingleInputTimeRangeField2(inProps, ref) {
+  const themeProps = (0, import_styles.useThemeProps)({
+    props: inProps,
+    name: "MuiSingleInputTimeRangeField"
+  });
+  const { slots, slotProps, components, componentsProps, InputProps, inputProps, ...other } = themeProps;
+  const ownerState = themeProps;
+  const TextField = (slots == null ? void 0 : slots.textField) ?? (components == null ? void 0 : components.TextField) ?? import_TextField.default;
+  const { inputRef: externalInputRef, ...textFieldProps } = (0, import_utils.useSlotProps)({
+    elementType: TextField,
+    externalSlotProps: (slotProps == null ? void 0 : slotProps.textField) ?? (componentsProps == null ? void 0 : componentsProps.textField),
+    externalForwardedProps: other,
+    ownerState
+  });
+  textFieldProps.inputProps = { ...textFieldProps.inputProps, ...inputProps };
+  textFieldProps.InputProps = { ...textFieldProps.InputProps, ...InputProps };
+  const {
+    ref: inputRef,
+    onPaste,
+    onKeyDown,
+    inputMode,
+    readOnly,
+    ...fieldProps
+  } = (0, import_useSingleInputTimeRangeField.useSingleInputTimeRangeField)({
+    props: textFieldProps,
+    inputRef: externalInputRef
+  });
+  return /* @__PURE__ */ React.createElement(
+    TextField,
+    {
+      ref,
+      ...fieldProps,
+      InputProps: { ...fieldProps.InputProps, readOnly },
+      inputProps: { ...fieldProps.inputProps, inputMode, onPaste, onKeyDown, ref: inputRef }
+    }
+  );
+});
+SingleInputTimeRangeField.fieldType = "single-input";
+SingleInputTimeRangeField.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * 12h/24h view for hour selection clock.
+   * @default `utils.is12HourCycleInCurrentLocale()`
+   */
+  ampm: import_prop_types.default.bool,
+  /**
+   * If `true`, the `input` element is focused during the first mount.
+   * @default false
+   */
+  autoFocus: import_prop_types.default.bool,
+  className: import_prop_types.default.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: import_prop_types.default.oneOf(["error", "info", "primary", "secondary", "success", "warning"]),
+  /**
+   * Overridable components.
+   * @default {}
+   * @deprecated Please use `slots`.
+   */
+  components: import_prop_types.default.object,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   * @deprecated Please use `slotProps`.
+   */
+  componentsProps: import_prop_types.default.object,
+  /**
+   * The default value. Use when the component is not controlled.
+   */
+  defaultValue: import_prop_types.default.arrayOf(import_prop_types.default.any),
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: import_prop_types.default.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: import_prop_types.default.bool,
+  /**
+   * Do not ignore date part when validating min/max time.
+   * @default false
+   */
+  disableIgnoringDatePartForTimeValidation: import_prop_types.default.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: import_prop_types.default.bool,
+  /**
+   * If `true`, the component is displayed in focused state.
+   */
+  focused: import_prop_types.default.bool,
+  /**
+   * Format of the date when rendered in the input(s).
+   */
+  format: import_prop_types.default.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: import_prop_types.default.oneOf(["dense", "spacious"]),
+  /**
+   * Props applied to the [`FormHelperText`](/material-ui/api/form-helper-text/) element.
+   */
+  FormHelperTextProps: import_prop_types.default.object,
+  /**
+   * If `true`, the input will take up the full width of its container.
+   * @default false
+   */
+  fullWidth: import_prop_types.default.bool,
+  /**
+   * The helper text content.
+   */
+  helperText: import_prop_types.default.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: import_prop_types.default.bool,
+  /**
+   * The id of the `input` element.
+   * Use this prop to make `label` and `helperText` accessible for screen readers.
+   */
+  id: import_prop_types.default.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: import_prop_types.default.object,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
+   */
+  inputProps: import_prop_types.default.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: import_prop_types.default.object,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: import_prop_types.default.oneOfType([
+    import_prop_types.default.func,
+    import_prop_types.default.shape({
+      current: import_prop_types.default.any.isRequired
+    })
+  ]),
+  /**
+   * The label content.
+   */
+  label: import_prop_types.default.node,
+  /**
+   * If `dense` or `normal`, will adjust vertical spacing of this and contained components.
+   * @default 'none'
+   */
+  margin: import_prop_types.default.oneOf(["dense", "none", "normal"]),
+  /**
+   * Maximal selectable time.
+   * The date part of the object will be ignored unless `props.disableIgnoringDatePartForTimeValidation === true`.
+   */
+  maxTime: import_prop_types.default.any,
+  /**
+   * Minimal selectable time.
+   * The date part of the object will be ignored unless `props.disableIgnoringDatePartForTimeValidation === true`.
+   */
+  minTime: import_prop_types.default.any,
+  /**
+   * Step over minutes.
+   * @default 1
+   */
+  minutesStep: import_prop_types.default.number,
+  /**
+   * Name attribute of the `input` element.
+   */
+  name: import_prop_types.default.string,
+  onBlur: import_prop_types.default.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: import_prop_types.default.func,
+  /**
+   * @ignore
+   */
+  onClick: import_prop_types.default.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: import_prop_types.default.func,
+  onFocus: import_prop_types.default.func,
+  /**
+   * Callback fired when the selected sections change.
+   * @param {FieldSelectedSections} newValue The new selected sections.
+   */
+  onSelectedSectionsChange: import_prop_types.default.func,
+  /**
+   * It prevents the user from changing the value of the field
+   * (not from interacting with the field).
+   * @default false
+   */
+  readOnly: import_prop_types.default.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: import_prop_types.default.any,
+  /**
+   * If `true`, the label is displayed as required and the `input` element is required.
+   * @default false
+   */
+  required: import_prop_types.default.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: import_prop_types.default.oneOfType([
+    import_prop_types.default.oneOf([
+      "all",
+      "day",
+      "hours",
+      "meridiem",
+      "minutes",
+      "month",
+      "seconds",
+      "weekDay",
+      "year"
+    ]),
+    import_prop_types.default.number,
+    import_prop_types.default.shape({
+      endIndex: import_prop_types.default.number.isRequired,
+      startIndex: import_prop_types.default.number.isRequired
+    })
+  ]),
+  /**
+   * Disable specific clock time.
+   * @param {number} clockValue The value to check.
+   * @param {TimeView} view The clock type of the timeValue.
+   * @returns {boolean} If `true` the time will be disabled.
+   * @deprecated Consider using `shouldDisableTime`.
+   */
+  shouldDisableClock: import_prop_types.default.func,
+  /**
+   * Disable specific time.
+   * @template TDate
+   * @param {TDate} value The value to check.
+   * @param {TimeView} view The clock type of the timeValue.
+   * @returns {boolean} If `true` the time will be disabled.
+   */
+  shouldDisableTime: import_prop_types.default.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: import_prop_types.default.bool,
+  /**
+   * The size of the component.
+   */
+  size: import_prop_types.default.oneOf(["medium", "small"]),
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: import_prop_types.default.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: import_prop_types.default.object,
+  style: import_prop_types.default.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: import_prop_types.default.oneOfType([
+    import_prop_types.default.arrayOf(import_prop_types.default.oneOfType([import_prop_types.default.func, import_prop_types.default.object, import_prop_types.default.bool])),
+    import_prop_types.default.func,
+    import_prop_types.default.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: import_prop_types.default.string,
+  /**
+   * The ref object used to imperatively interact with the field.
+   */
+  unstableFieldRef: import_prop_types.default.oneOfType([import_prop_types.default.func, import_prop_types.default.object]),
+  /**
+   * The selected value.
+   * Used when the component is controlled.
+   */
+  value: import_prop_types.default.arrayOf(import_prop_types.default.any),
+  /**
+   * The variant to use.
+   * @default 'outlined'
+   */
+  variant: import_prop_types.default.oneOf(["filled", "outlined", "standard"])
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SingleInputTimeRangeField
+});

package/lib/SingleInputTimeRangeField/SingleInputTimeRangeField.types.d.ts

@@ -0,0 +1,51 @@
+import * as React from 'react';
+import { SlotComponentProps } from '@mui/base/utils';
+import TextField from '@mui/material/TextField';
+import { FieldsTextFieldProps } from '@mui/x-date-pickers/internals/models/fields';
+import { UncapitalizeObjectKeys } from '@mui/x-date-pickers/internals';
+import { UseTimeRangeFieldDefaultizedProps, UseTimeRangeFieldProps } from '../internals/models';
+export interface UseSingleInputTimeRangeFieldParams<TDate, TChildProps extends {}> {
+    props: UseSingleInputTimeRangeFieldComponentProps<TDate, TChildProps>;
+    inputRef?: React.Ref<HTMLInputElement>;
+}
+export interface UseSingleInputTimeRangeFieldProps<TDate> extends UseTimeRangeFieldProps<TDate> {
+}
+export declare type UseSingleInputTimeRangeFieldDefaultizedProps<TDate, AdditionalProps extends {}> = UseTimeRangeFieldDefaultizedProps<TDate> & AdditionalProps;
+export declare type UseSingleInputTimeRangeFieldComponentProps<TDate, TChildProps extends {}> = Omit<TChildProps, keyof UseSingleInputTimeRangeFieldProps<TDate>> & UseSingleInputTimeRangeFieldProps<TDate>;
+export interface SingleInputTimeRangeFieldProps<TDate> extends UseSingleInputTimeRangeFieldComponentProps<TDate, FieldsTextFieldProps> {
+    /**
+     * Overridable components.
+     * @default {}
+     * @deprecated Please use `slots`.
+     */
+    components?: SingleInputTimeRangeFieldSlotsComponent;
+    /**
+     * The props used for each component slot.
+     * @default {}
+     * @deprecated Please use `slotProps`.
+     */
+    componentsProps?: SingleInputTimeRangeFieldSlotsComponentsProps<TDate>;
+    /**
+     * Overridable component slots.
+     * @default {}
+     */
+    slots?: UncapitalizeObjectKeys<SingleInputTimeRangeFieldSlotsComponent>;
+    /**
+     * The props used for each component slot.
+     * @default {}
+     */
+    slotProps?: SingleInputTimeRangeFieldSlotsComponentsProps<TDate>;
+}
+export declare type SingleInputTimeRangeFieldOwnerState<TDate> = SingleInputTimeRangeFieldProps<TDate>;
+export interface SingleInputTimeRangeFieldSlotsComponent {
+    /**
+     * 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 SingleInputTimeRangeFieldSlotsComponentsProps<TDate> {
+    textField?: SlotComponentProps<typeof TextField, {}, SingleInputTimeRangeFieldOwnerState<TDate>>;
+}
+//# sourceMappingURL=SingleInputTimeRangeField.types.d.ts.map

package/lib/SingleInputTimeRangeField/SingleInputTimeRangeField.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SingleInputTimeRangeField.types.d.ts","sourceRoot":"","sources":["SingleInputTimeRangeField.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,MAAM,6CAA6C,CAAC;AACnF,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,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,GAAG,eAAe,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,MAAM,WAAW,8BAA8B,CAAC,KAAK,CACnD,SAAQ,0CAA0C,CAAC,KAAK,EAAE,oBAAoB,CAAC;IAC/E;;;;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;AAED,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/lib/SingleInputTimeRangeField/SingleInputTimeRangeField.types.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/SingleInputTimeRangeField/SingleInputTimeRangeField.types.ts
+var SingleInputTimeRangeField_types_exports = {};
+module.exports = __toCommonJS(SingleInputTimeRangeField_types_exports);

package/lib/SingleInputTimeRangeField/index.d.ts

@@ -0,0 +1,4 @@
+export { SingleInputTimeRangeField } from './SingleInputTimeRangeField';
+export { useSingleInputTimeRangeField as unstable_useSingleInputTimeRangeField } from './useSingleInputTimeRangeField';
+export type { UseSingleInputTimeRangeFieldProps, UseSingleInputTimeRangeFieldComponentProps, SingleInputTimeRangeFieldProps, } from './SingleInputTimeRangeField.types';
+//# sourceMappingURL=index.d.ts.map

package/lib/SingleInputTimeRangeField/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/lib/SingleInputTimeRangeField/index.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/SingleInputTimeRangeField/index.ts
+var SingleInputTimeRangeField_exports = {};
+__export(SingleInputTimeRangeField_exports, {
+  SingleInputTimeRangeField: () => import_SingleInputTimeRangeField.SingleInputTimeRangeField,
+  unstable_useSingleInputTimeRangeField: () => import_useSingleInputTimeRangeField.useSingleInputTimeRangeField
+});
+module.exports = __toCommonJS(SingleInputTimeRangeField_exports);
+var import_SingleInputTimeRangeField = require("./SingleInputTimeRangeField");
+var import_useSingleInputTimeRangeField = require("./useSingleInputTimeRangeField");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SingleInputTimeRangeField,
+  unstable_useSingleInputTimeRangeField
+});

package/lib/SingleInputTimeRangeField/useSingleInputTimeRangeField.d.ts

@@ -0,0 +1,4 @@
+import { UseSingleInputTimeRangeFieldDefaultizedProps, UseSingleInputTimeRangeFieldParams, UseSingleInputTimeRangeFieldProps } from './SingleInputTimeRangeField.types';
+export declare const useDefaultizedTimeRangeFieldProps: <TDate, AdditionalProps extends {}>(props: UseSingleInputTimeRangeFieldProps<TDate>) => UseSingleInputTimeRangeFieldDefaultizedProps<TDate, AdditionalProps>;
+export declare const useSingleInputTimeRangeField: <TDate, TChildProps extends {}>({ props: inProps, inputRef, }: UseSingleInputTimeRangeFieldParams<TDate, TChildProps>) => import("@mui/x-date-pickers/internals").UseFieldResponse<Omit<UseSingleInputTimeRangeFieldDefaultizedProps<TDate, TChildProps>, keyof UseSingleInputTimeRangeFieldProps<any>>>;
+//# sourceMappingURL=useSingleInputTimeRangeField.d.ts.map

package/lib/SingleInputTimeRangeField/useSingleInputTimeRangeField.d.ts.map

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