@redis-ui/components 49.1.0 → 50.0.0

package/dist/node_modules/rsuite/esm/DateInput/DateInput.js

@@ -0,0 +1,195 @@
+"use client";
+import { _extends } from "../../../@babel/runtime/helpers/esm/extends.js";
+import { forwardRef as forwardRef$1 } from "../internals/utils/react/forwardRef.js";
+import isValid from "../../../date-fns/isValid.js";
+import useCustom from "../internals/hooks/useCustom.js";
+import mergeRefs from "../internals/utils/react/mergeRefs.js";
+import useControlled from "../internals/hooks/useControlled.js";
+import useEventCallback from "../internals/hooks/useEventCallback.js";
+import Input_default from "../Input/index.js";
+import { getInputSelectedState, useInputSelection, validateDateTime } from "./utils.js";
+import useDateInputState from "./hooks/useDateInputState.js";
+import useKeyboardInputEvent from "./hooks/useKeyboardInputEvent.js";
+import useIsFocused from "./hooks/useIsFocused.js";
+import useFieldCursor from "./hooks/useFieldCursor.js";
+import useSelectedState from "./hooks/useSelectedState.js";
+import React, { useMemo, useRef } from "react";
+//#region ../../node_modules/rsuite/esm/DateInput/DateInput.js
+/**
+* The DateInput component lets users select a date with the keyboard.
+* @version 5.58.0
+* @see https://rsuitejs.com/components/date-input/
+*/
+var DateInput = forwardRef$1((props, ref) => {
+	const { propsWithDefaults, parseDate, getLocale } = useCustom("DateInput", props);
+	const { dateLocale, shortDateFormat } = getLocale("DateTimeFormats");
+	const { format: formatStr = shortDateFormat, value: valueProp, defaultValue, placeholder, onChange, onKeyDown, onBlur, onFocus, onPaste, ...rest } = propsWithDefaults;
+	const inputRef = useRef(null);
+	const { selectedState, setSelectedState } = useSelectedState();
+	const [value, setValue, isControlled] = useControlled(valueProp, defaultValue);
+	const { dateField, setDateOffset, setDateField, setNewDate, getDateField, toDateString, isEmptyValue } = useDateInputState({
+		formatStr,
+		locale: dateLocale,
+		date: value,
+		isControlledDate: isControlled
+	});
+	const { isMoveCursor, isResetValue, increment, reset } = useFieldCursor(formatStr, valueProp);
+	const dateString = toDateString();
+	const keyPressOptions = useMemo(() => ({
+		formatStr,
+		localize: dateLocale.localize,
+		selectedMonth: dateField.month,
+		dateString
+	}), [
+		dateField,
+		dateString,
+		formatStr,
+		dateLocale
+	]);
+	const setSelectionRange = useInputSelection(inputRef);
+	const handleChange = useEventCallback((value, event) => {
+		onChange?.(value, event);
+		setValue(value);
+	});
+	const handleClear = useEventCallback((event) => {
+		handleChange(null, event);
+		setNewDate(null);
+		setSelectionRange(0, 0);
+		reset();
+	});
+	const onSegmentChange = useEventCallback((event, nextDirection) => {
+		const input = event.target;
+		const key = event.key;
+		const direction = nextDirection || (key === "ArrowRight" ? "right" : "left");
+		const state = getInputSelectedState({
+			...keyPressOptions,
+			input,
+			direction
+		});
+		setSelectedState(state);
+		setSelectionRange(state.selectionStart, state.selectionEnd);
+		if (selectedState.selectedPattern !== state.selectedPattern) reset();
+	});
+	const onSegmentValueChange = useEventCallback((event) => {
+		const input = event.target;
+		const offset = event.key === "ArrowUp" ? 1 : -1;
+		const state = getInputSelectedState({
+			...keyPressOptions,
+			input,
+			valueOffset: offset
+		});
+		setSelectedState(state);
+		setDateOffset(state.selectedPattern, offset, (date) => handleChange(date, event));
+		setSelectionRange(state.selectionStart, state.selectionEnd);
+	});
+	const onSegmentValueChangeWithNumericKeys = useEventCallback((event) => {
+		const input = event.target;
+		const key = event.key;
+		if (key.startsWith("F") && !isNaN(Number(key.slice(1)))) return;
+		const pattern = selectedState.selectedPattern;
+		if (!pattern) return;
+		const field = getDateField(pattern);
+		const value = parseInt(key, 10);
+		const padValue = parseInt(`${field.value || ""}${key}`, 10);
+		let newValue = value;
+		if (validateDateTime(field.name, padValue) && !isResetValue()) newValue = padValue;
+		setDateField(pattern, newValue, (date) => handleChange(date, event));
+		const selectedMonth = pattern === "M" ? newValue : dateField.month;
+		const nextState = getInputSelectedState({
+			...keyPressOptions,
+			input,
+			selectedMonth
+		});
+		setSelectedState(nextState);
+		setSelectionRange(nextState.selectionStart, nextState.selectionEnd);
+		increment();
+		if (isMoveCursor(newValue, pattern) && input.selectionEnd !== input.value.length) onSegmentChange(event, "right");
+	});
+	const onSegmentValueRemove = useEventCallback((event) => {
+		const input = event.target;
+		const value = input.value;
+		if (input.selectionStart === 0 && value && input.selectionEnd === value.length) handleClear(event);
+		else if (selectedState.selectedPattern) {
+			const nextState = getInputSelectedState({
+				...keyPressOptions,
+				input,
+				valueOffset: null
+			});
+			setSelectedState(nextState);
+			setSelectionRange(nextState.selectionStart, nextState.selectionEnd);
+			setDateField(selectedState.selectedPattern, null, (date) => handleChange(date, event));
+			reset();
+		}
+	});
+	const onAmPmToggle = useEventCallback((event) => {
+		const input = event.target;
+		const key = event.key.toLowerCase();
+		if (selectedState.selectedPattern === "a" && (key === "a" || key === "p")) {
+			const currentHour = dateField.hour || 0;
+			if (key === "a" && currentHour >= 12 || key === "p" && currentHour < 12) {
+				const state = getInputSelectedState({
+					...keyPressOptions,
+					input
+				});
+				setSelectedState(state);
+				setDateOffset("a", 1, (date) => handleChange(date, event));
+				setSelectionRange(state.selectionStart, state.selectionEnd);
+			}
+		}
+	});
+	const handleClick = useEventCallback((event) => {
+		const input = event.target;
+		const state = getInputSelectedState({
+			...keyPressOptions,
+			input
+		});
+		setSelectedState(state);
+		setSelectionRange(state.selectionStart, state.selectionEnd);
+		if (selectedState.selectedPattern !== state.selectedPattern) reset();
+	});
+	const handlePaste = useEventCallback((event) => {
+		event.preventDefault();
+		const pasteText = event.clipboardData?.getData("text");
+		const nextDate = parseDate(pasteText, formatStr);
+		if (isValid(nextDate)) {
+			handleChange(nextDate, event);
+			setNewDate(nextDate);
+		}
+		onPaste?.(event);
+	});
+	const onKeyboardInput = useKeyboardInputEvent({
+		onSegmentChange,
+		onSegmentValueChange,
+		onSegmentValueChangeWithNumericKeys,
+		onSegmentValueRemove,
+		onAmPmToggle,
+		onKeyDown
+	});
+	const [focused, focusEventProps] = useIsFocused({
+		onBlur,
+		onFocus
+	});
+	const renderedValue = useMemo(() => {
+		if (!isEmptyValue()) return dateString;
+		return !focused ? "" : dateString;
+	}, [
+		dateString,
+		focused,
+		isEmptyValue
+	]);
+	return /*#__PURE__*/ React.createElement(Input_default, _extends({
+		inputMode: focused ? "numeric" : "text",
+		autoComplete: "off",
+		autoCorrect: "off",
+		spellCheck: false,
+		ref: mergeRefs(inputRef, ref),
+		onKeyDown: onKeyboardInput,
+		onClick: handleClick,
+		onPaste: handlePaste,
+		value: renderedValue,
+		placeholder: placeholder || formatStr
+	}, focusEventProps, rest));
+});
+DateInput.displayName = "DateInput";
+//#endregion
+export { DateInput as default };

package/dist/node_modules/rsuite/esm/DateInput/hooks/useDateInputState.cjs

@@ -0,0 +1,122 @@
+"use client";
+const require_runtime = require("../../../../../_virtual/_rolldown/runtime.cjs");
+const require_addDays = require("../../../../date-fns/addDays.cjs");
+const require_addMonths = require("../../../../date-fns/addMonths.cjs");
+const require_addYears = require("../../../../date-fns/addYears.cjs");
+const require_addSeconds = require("../../../../date-fns/addSeconds.cjs");
+const require_addMinutes = require("../../../../date-fns/addMinutes.cjs");
+const require_addHours = require("../../../../date-fns/addHours.cjs");
+const require_isValid = require("../../../../date-fns/isValid.cjs");
+const require_isLastDayOfMonth = require("../../../../date-fns/isLastDayOfMonth.cjs");
+const require_lastDayOfMonth = require("../../../../date-fns/lastDayOfMonth.cjs");
+const require_useCustom = require("../../internals/hooks/useCustom.cjs");
+const require_startCase$1 = require("../../../../lodash/startCase.cjs");
+const require_DateField = require("../DateField.cjs");
+let react = require("react");
+//#region ../../node_modules/rsuite/esm/DateInput/hooks/useDateInputState.js
+var import_startCase = /* @__PURE__ */ require_runtime.__toESM(require_startCase$1.default);
+function useDateInputState({ formatStr, locale, date, isControlledDate }) {
+	const { formatDate } = require_useCustom.default();
+	const { dateField, dispatch, toDateString, toDate, isEmptyValue } = require_DateField.useDateField(formatStr, locale.localize, date);
+	const setDateOffset = (pattern, offset, callback) => {
+		const currentDate = /* @__PURE__ */ new Date();
+		const year = dateField.year || currentDate.getFullYear();
+		const month = dateField.month ? dateField.month - 1 : currentDate.getMonth();
+		const day = dateField.day || 0;
+		const hour = dateField.hour || 0;
+		const minute = dateField.minute || 0;
+		const second = dateField.second || 0;
+		let actionName;
+		let value;
+		switch (pattern) {
+			case "y":
+				actionName = "setYear";
+				value = require_addYears.default(new Date(year, 0), offset).getFullYear();
+				break;
+			case "M":
+				actionName = "setMonth";
+				value = require_addMonths.default(new Date(year, month), offset).getMonth() + 1;
+				break;
+			case "d": {
+				actionName = "setDay";
+				const prevDate = new Date(year, month, day);
+				value = require_addDays.default(prevDate, offset).getDate();
+				if (offset > 0) value = require_isLastDayOfMonth.default(prevDate) ? 1 : value;
+				else value = prevDate.getDate() === 1 ? require_lastDayOfMonth.default(prevDate).getDate() : value;
+				break;
+			}
+			case "H":
+			case "h":
+				actionName = "setHour";
+				value = require_addHours.default(new Date(year, month, day, hour), offset).getHours();
+				break;
+			case "m":
+				actionName = "setMinute";
+				value = require_addMinutes.default(new Date(year, month, day, hour, minute), offset).getMinutes();
+				break;
+			case "s":
+				actionName = "setSecond";
+				value = require_addSeconds.default(new Date(year, month, day, hour, minute, second), offset).getSeconds();
+				break;
+			case "a":
+				actionName = "setHour";
+				value = hour >= 12 ? hour - 12 : hour + 12;
+				break;
+		}
+		if (actionName && typeof value === "number") {
+			dispatch({
+				type: actionName,
+				value
+			});
+			const field = require_DateField.patternMap[pattern];
+			callback?.(toDate(field, value));
+		}
+	};
+	const setDateField = (pattern, value, callback) => {
+		const field = require_DateField.patternMap[pattern];
+		dispatch({
+			type: `set${(0, import_startCase.default)(field)}`,
+			value
+		});
+		callback?.(toDate(field, value));
+	};
+	const getDateField = (pattern) => {
+		const fieldName = require_DateField.patternMap[pattern];
+		return {
+			name: fieldName,
+			value: dateField[fieldName]
+		};
+	};
+	const toControlledDateString = () => {
+		if (date && require_isValid.default(date)) return formatDate(date, formatStr, { locale });
+		return toDateString();
+	};
+	const setNewDate = (0, react.useCallback)((value) => {
+		dispatch({
+			type: "setNewDate",
+			value
+		});
+	}, [dispatch]);
+	(0, react.useEffect)(() => {
+		if (isControlledDate) {
+			if (date && require_isValid.default(date)) setNewDate(date);
+			else if (date === null) setNewDate(null);
+		}
+	}, [
+		date,
+		dispatch,
+		isControlledDate,
+		setNewDate
+	]);
+	return {
+		dateField,
+		setDateOffset,
+		setDateField,
+		setNewDate,
+		getDateField,
+		toDateString: isControlledDate ? toControlledDateString : toDateString,
+		isEmptyValue
+	};
+}
+//#endregion
+exports.default = useDateInputState;

package/dist/node_modules/rsuite/esm/DateInput/hooks/useDateInputState.js

@@ -0,0 +1,122 @@
+"use client";
+import { __toESM } from "../../../../../_virtual/_rolldown/runtime.js";
+import addDays from "../../../../date-fns/addDays.js";
+import addMonths from "../../../../date-fns/addMonths.js";
+import addYears from "../../../../date-fns/addYears.js";
+import addSeconds from "../../../../date-fns/addSeconds.js";
+import addMinutes from "../../../../date-fns/addMinutes.js";
+import addHours from "../../../../date-fns/addHours.js";
+import isValid from "../../../../date-fns/isValid.js";
+import isLastDayOfMonth from "../../../../date-fns/isLastDayOfMonth.js";
+import lastDayOfMonth from "../../../../date-fns/lastDayOfMonth.js";
+import useCustom from "../../internals/hooks/useCustom.js";
+import { require_startCase } from "../../../../lodash/startCase.js";
+import { patternMap, useDateField } from "../DateField.js";
+import { useCallback, useEffect } from "react";
+//#region ../../node_modules/rsuite/esm/DateInput/hooks/useDateInputState.js
+var import_startCase = /* @__PURE__ */ __toESM(require_startCase());
+function useDateInputState({ formatStr, locale, date, isControlledDate }) {
+	const { formatDate } = useCustom();
+	const { dateField, dispatch, toDateString, toDate, isEmptyValue } = useDateField(formatStr, locale.localize, date);
+	const setDateOffset = (pattern, offset, callback) => {
+		const currentDate = /* @__PURE__ */ new Date();
+		const year = dateField.year || currentDate.getFullYear();
+		const month = dateField.month ? dateField.month - 1 : currentDate.getMonth();
+		const day = dateField.day || 0;
+		const hour = dateField.hour || 0;
+		const minute = dateField.minute || 0;
+		const second = dateField.second || 0;
+		let actionName;
+		let value;
+		switch (pattern) {
+			case "y":
+				actionName = "setYear";
+				value = addYears(new Date(year, 0), offset).getFullYear();
+				break;
+			case "M":
+				actionName = "setMonth";
+				value = addMonths(new Date(year, month), offset).getMonth() + 1;
+				break;
+			case "d": {
+				actionName = "setDay";
+				const prevDate = new Date(year, month, day);
+				value = addDays(prevDate, offset).getDate();
+				if (offset > 0) value = isLastDayOfMonth(prevDate) ? 1 : value;
+				else value = prevDate.getDate() === 1 ? lastDayOfMonth(prevDate).getDate() : value;
+				break;
+			}
+			case "H":
+			case "h":
+				actionName = "setHour";
+				value = addHours(new Date(year, month, day, hour), offset).getHours();
+				break;
+			case "m":
+				actionName = "setMinute";
+				value = addMinutes(new Date(year, month, day, hour, minute), offset).getMinutes();
+				break;
+			case "s":
+				actionName = "setSecond";
+				value = addSeconds(new Date(year, month, day, hour, minute, second), offset).getSeconds();
+				break;
+			case "a":
+				actionName = "setHour";
+				value = hour >= 12 ? hour - 12 : hour + 12;
+				break;
+		}
+		if (actionName && typeof value === "number") {
+			dispatch({
+				type: actionName,
+				value
+			});
+			const field = patternMap[pattern];
+			callback?.(toDate(field, value));
+		}
+	};
+	const setDateField = (pattern, value, callback) => {
+		const field = patternMap[pattern];
+		dispatch({
+			type: `set${(0, import_startCase.default)(field)}`,
+			value
+		});
+		callback?.(toDate(field, value));
+	};
+	const getDateField = (pattern) => {
+		const fieldName = patternMap[pattern];
+		return {
+			name: fieldName,
+			value: dateField[fieldName]
+		};
+	};
+	const toControlledDateString = () => {
+		if (date && isValid(date)) return formatDate(date, formatStr, { locale });
+		return toDateString();
+	};
+	const setNewDate = useCallback((value) => {
+		dispatch({
+			type: "setNewDate",
+			value
+		});
+	}, [dispatch]);
+	useEffect(() => {
+		if (isControlledDate) {
+			if (date && isValid(date)) setNewDate(date);
+			else if (date === null) setNewDate(null);
+		}
+	}, [
+		date,
+		dispatch,
+		isControlledDate,
+		setNewDate
+	]);
+	return {
+		dateField,
+		setDateOffset,
+		setDateField,
+		setNewDate,
+		getDateField,
+		toDateString: isControlledDate ? toControlledDateString : toDateString,
+		isEmptyValue
+	};
+}
+//#endregion
+export { useDateInputState as default };

package/dist/node_modules/rsuite/esm/DateInput/hooks/useFieldCursor.cjs

@@ -0,0 +1,43 @@
+"use client";
+const require_useUpdateEffect = require("../../internals/hooks/useUpdateEffect.cjs");
+const require_utils = require("../utils.cjs");
+let react = require("react");
+//#region ../../node_modules/rsuite/esm/DateInput/hooks/useFieldCursor.js
+function useFieldCursor(format, value) {
+	const typeCount = (0, react.useRef)(0);
+	const increment = (0, react.useCallback)(() => {
+		typeCount.current += 1;
+	}, []);
+	const reset = (0, react.useCallback)(() => {
+		typeCount.current = 0;
+	}, []);
+	const isResetValue = (0, react.useCallback)(() => {
+		return typeCount.current === 0;
+	}, []);
+	const isMoveCursor = (0, react.useCallback)((value, pattern) => {
+		const patternGroup = require_utils.getPatternGroups(format, pattern);
+		if (value.toString().length === patternGroup.length) return true;
+		else if (pattern === "y" && typeCount.current === 4) return true;
+		else if (pattern !== "y" && typeCount.current === 2) return true;
+		switch (pattern) {
+			case "M": return parseInt(`${value}0`) > 12;
+			case "d": return parseInt(`${value}0`) > 31;
+			case "H": return parseInt(`${value}0`) > 23;
+			case "h": return parseInt(`${value}0`) > 12;
+			case "m":
+			case "s": return parseInt(`${value}0`) > 59;
+			default: return false;
+		}
+	}, [format]);
+	require_useUpdateEffect.default(() => {
+		if (!value) reset();
+	}, [value]);
+	return {
+		increment,
+		reset,
+		isMoveCursor,
+		isResetValue
+	};
+}
+//#endregion
+exports.default = useFieldCursor;

package/dist/node_modules/rsuite/esm/DateInput/hooks/useFieldCursor.js

@@ -0,0 +1,43 @@
+"use client";
+import useUpdateEffect from "../../internals/hooks/useUpdateEffect.js";
+import { getPatternGroups } from "../utils.js";
+import { useCallback, useRef } from "react";
+//#region ../../node_modules/rsuite/esm/DateInput/hooks/useFieldCursor.js
+function useFieldCursor(format, value) {
+	const typeCount = useRef(0);
+	const increment = useCallback(() => {
+		typeCount.current += 1;
+	}, []);
+	const reset = useCallback(() => {
+		typeCount.current = 0;
+	}, []);
+	const isResetValue = useCallback(() => {
+		return typeCount.current === 0;
+	}, []);
+	const isMoveCursor = useCallback((value, pattern) => {
+		const patternGroup = getPatternGroups(format, pattern);
+		if (value.toString().length === patternGroup.length) return true;
+		else if (pattern === "y" && typeCount.current === 4) return true;
+		else if (pattern !== "y" && typeCount.current === 2) return true;
+		switch (pattern) {
+			case "M": return parseInt(`${value}0`) > 12;
+			case "d": return parseInt(`${value}0`) > 31;
+			case "H": return parseInt(`${value}0`) > 23;
+			case "h": return parseInt(`${value}0`) > 12;
+			case "m":
+			case "s": return parseInt(`${value}0`) > 59;
+			default: return false;
+		}
+	}, [format]);
+	useUpdateEffect(() => {
+		if (!value) reset();
+	}, [value]);
+	return {
+		increment,
+		reset,
+		isMoveCursor,
+		isResetValue
+	};
+}
+//#endregion
+export { useFieldCursor as default };

package/dist/node_modules/rsuite/esm/DateInput/hooks/useIsFocused.cjs

@@ -0,0 +1,18 @@
+"use client";
+let react = require("react");
+//#region ../../node_modules/rsuite/esm/DateInput/hooks/useIsFocused.js
+function useIsFocused({ onFocus: onFocusProp, onBlur: onBlurProp }) {
+	const [isFocused, setIsFocused] = (0, react.useState)(false);
+	return [isFocused, {
+		onFocus: (0, react.useCallback)((event) => {
+			setIsFocused(true);
+			onFocusProp?.(event);
+		}, [onFocusProp]),
+		onBlur: (0, react.useCallback)((event) => {
+			setIsFocused(false);
+			onBlurProp?.(event);
+		}, [onBlurProp])
+	}];
+}
+//#endregion
+exports.default = useIsFocused;

package/dist/node_modules/rsuite/esm/DateInput/hooks/useIsFocused.js

@@ -0,0 +1,18 @@
+"use client";
+import { useCallback, useState } from "react";
+//#region ../../node_modules/rsuite/esm/DateInput/hooks/useIsFocused.js
+function useIsFocused({ onFocus: onFocusProp, onBlur: onBlurProp }) {
+	const [isFocused, setIsFocused] = useState(false);
+	return [isFocused, {
+		onFocus: useCallback((event) => {
+			setIsFocused(true);
+			onFocusProp?.(event);
+		}, [onFocusProp]),
+		onBlur: useCallback((event) => {
+			setIsFocused(false);
+			onBlurProp?.(event);
+		}, [onBlurProp])
+	}];
+}
+//#endregion
+export { useIsFocused as default };

package/dist/node_modules/rsuite/esm/DateInput/hooks/useKeyboardInputEvent.cjs

@@ -0,0 +1,42 @@
+"use client";
+//#region ../../node_modules/rsuite/esm/DateInput/hooks/useKeyboardInputEvent.js
+function useKeyboardInputEvent({ onSegmentChange, onSegmentValueChange, onSegmentValueChangeWithNumericKeys, onSegmentValueRemove, onAmPmToggle, onKeyDown }) {
+	return (event) => {
+		const key = event.key;
+		switch (key) {
+			case "ArrowRight":
+			case "ArrowLeft":
+				onSegmentChange?.(event);
+				event.preventDefault();
+				break;
+			case "ArrowUp":
+			case "ArrowDown":
+				onSegmentValueChange?.(event);
+				event.preventDefault();
+				break;
+			case "Backspace":
+				onSegmentValueRemove?.(event);
+				event.preventDefault();
+				break;
+			case key.match(/\d/)?.input:
+				onSegmentValueChangeWithNumericKeys?.(event);
+				event.preventDefault();
+				break;
+			case "a":
+			case "p":
+			case "A":
+			case "P":
+				if (event.ctrlKey || event.metaKey) break;
+				onAmPmToggle?.(event);
+				event.preventDefault();
+				break;
+			case key.match(/[a-z]/)?.[0]:
+				if (event.ctrlKey || event.metaKey) break;
+				event.preventDefault();
+				break;
+		}
+		onKeyDown?.(event);
+	};
+}
+//#endregion
+exports.default = useKeyboardInputEvent;

package/dist/node_modules/rsuite/esm/DateInput/hooks/useKeyboardInputEvent.js

@@ -0,0 +1,42 @@
+"use client";
+//#region ../../node_modules/rsuite/esm/DateInput/hooks/useKeyboardInputEvent.js
+function useKeyboardInputEvent({ onSegmentChange, onSegmentValueChange, onSegmentValueChangeWithNumericKeys, onSegmentValueRemove, onAmPmToggle, onKeyDown }) {
+	return (event) => {
+		const key = event.key;
+		switch (key) {
+			case "ArrowRight":
+			case "ArrowLeft":
+				onSegmentChange?.(event);
+				event.preventDefault();
+				break;
+			case "ArrowUp":
+			case "ArrowDown":
+				onSegmentValueChange?.(event);
+				event.preventDefault();
+				break;
+			case "Backspace":
+				onSegmentValueRemove?.(event);
+				event.preventDefault();
+				break;
+			case key.match(/\d/)?.input:
+				onSegmentValueChangeWithNumericKeys?.(event);
+				event.preventDefault();
+				break;
+			case "a":
+			case "p":
+			case "A":
+			case "P":
+				if (event.ctrlKey || event.metaKey) break;
+				onAmPmToggle?.(event);
+				event.preventDefault();
+				break;
+			case key.match(/[a-z]/)?.[0]:
+				if (event.ctrlKey || event.metaKey) break;
+				event.preventDefault();
+				break;
+		}
+		onKeyDown?.(event);
+	};
+}
+//#endregion
+export { useKeyboardInputEvent as default };

package/dist/node_modules/rsuite/esm/DateInput/hooks/useSelectedState.cjs

@@ -0,0 +1,17 @@
+"use client";
+let react = require("react");
+//#region ../../node_modules/rsuite/esm/DateInput/hooks/useSelectedState.js
+var defaultSelectedState = {
+	selectedPattern: "y",
+	selectionStart: 0,
+	selectionEnd: 0
+};
+function useSelectedState() {
+	const [selectedState, setSelectedState] = (0, react.useState)(defaultSelectedState);
+	return {
+		selectedState,
+		setSelectedState
+	};
+}
+//#endregion
+exports.default = useSelectedState;

package/dist/node_modules/rsuite/esm/DateInput/hooks/useSelectedState.js

@@ -0,0 +1,17 @@
+"use client";
+import { useState } from "react";
+//#region ../../node_modules/rsuite/esm/DateInput/hooks/useSelectedState.js
+var defaultSelectedState = {
+	selectedPattern: "y",
+	selectionStart: 0,
+	selectionEnd: 0
+};
+function useSelectedState() {
+	const [selectedState, setSelectedState] = useState(defaultSelectedState);
+	return {
+		selectedState,
+		setSelectedState
+	};
+}
+//#endregion
+export { useSelectedState as default };