@wirekyt/react 0.0.1 → 0.0.3

package/dist/core-CEYOEcVI.js

@@ -0,0 +1,357 @@
+import { callAll, compact, ensure, identity, isFunction, isString, toArray, warn } from "@wirekyt/dom/utils";
+import * as React$1 from "react";
+import { useEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore as useSyncExternalStore$1 } from "react";
+import { INIT_STATE, MachineStatus, createScope, findTransition, getExitEnterStates, hasTag, matchesState, mergeProps as mergeProps$1, resolveStateValue } from "@wirekyt/dom";
+import { createPortal, flushSync } from "react-dom";
+import { createNormalizer } from "@wirekyt/dom/types";
+import { jsx } from "react/jsx-runtime";
+//#region src/core/use-layout-effect.ts
+const useSafeLayoutEffect = typeof globalThis.document !== "undefined" ? useLayoutEffect : useEffect;
+//#endregion
+//#region src/core/bindable.ts
+function useBindable(props) {
+	const initial = props().value ?? props().defaultValue;
+	const eq = props().isEqual ?? Object.is;
+	const [initialValue] = useState(initial);
+	const [value, setValue] = useState(initialValue);
+	const controlled = props().value !== void 0;
+	const valueRef = useRef(value);
+	valueRef.current = controlled ? props().value : value;
+	const prevValue = useRef(valueRef.current);
+	useSafeLayoutEffect(() => {
+		prevValue.current = valueRef.current;
+	}, [value, props().value]);
+	const setFn = (value) => {
+		const prev = prevValue.current;
+		const next = isFunction(value) ? value(prev) : value;
+		if (props().debug) console.log(`[bindable > ${props().debug}] setValue`, {
+			next,
+			prev
+		});
+		if (!controlled) setValue(next);
+		if (!eq(next, prev)) props().onChange?.(next, prev);
+	};
+	function get() {
+		return controlled ? props().value : value;
+	}
+	return {
+		initial: initialValue,
+		ref: valueRef,
+		get,
+		set(value) {
+			(props().sync ? flushSync : identity)(() => setFn(value));
+		},
+		invoke(nextValue, prevValue) {
+			props().onChange?.(nextValue, prevValue);
+		},
+		hash(value) {
+			return props().hash?.(value) ?? String(value);
+		}
+	};
+}
+useBindable.cleanup = (fn) => {
+	useEffect(() => fn, []);
+};
+useBindable.ref = (defaultValue) => {
+	const value = useRef(defaultValue);
+	return {
+		get: () => value.current,
+		set: (next) => {
+			value.current = next;
+		}
+	};
+};
+//#endregion
+//#region src/core/refs.ts
+function useRefs(refs) {
+	const ref = useRef(refs);
+	return {
+		get(key) {
+			return ref.current[key];
+		},
+		set(key, value) {
+			ref.current[key] = value;
+		}
+	};
+}
+//#endregion
+//#region src/core/track.ts
+const useTrack = (deps, effect) => {
+	const render = useRef(false);
+	const called = useRef(false);
+	useEffect(() => {
+		if (render.current && called.current) return effect();
+		called.current = true;
+	}, (deps ?? []).map((d) => typeof d === "function" ? d() : d));
+	useEffect(() => {
+		render.current = true;
+		return () => {
+			render.current = false;
+		};
+	}, []);
+};
+//#endregion
+//#region src/core/machine.ts
+function useMachine(machine, userProps = {}) {
+	const scope = useMemo(() => {
+		const { id, ids, getRootNode } = userProps;
+		return createScope({
+			id,
+			ids,
+			getRootNode
+		});
+	}, [userProps]);
+	const debug = (...args) => {
+		if (machine.debug) console.log(...args);
+	};
+	const prop = useProp(machine.props?.({
+		props: compact(userProps),
+		scope
+	}) ?? userProps);
+	const context = machine.context?.({
+		prop,
+		bindable: useBindable,
+		scope,
+		flush,
+		getContext() {
+			return ctx;
+		},
+		getComputed() {
+			return computed;
+		},
+		getRefs() {
+			return refs;
+		},
+		getEvent() {
+			return getEvent();
+		}
+	});
+	const contextRef = useLiveRef(context);
+	const ctx = {
+		get(key) {
+			return contextRef.current?.[key].ref.current;
+		},
+		set(key, value) {
+			contextRef.current?.[key].set(value);
+		},
+		initial(key) {
+			return contextRef.current?.[key].initial;
+		},
+		hash(key) {
+			const current = contextRef.current?.[key].get();
+			return contextRef.current?.[key].hash(current);
+		}
+	};
+	const effects = useRef(/* @__PURE__ */ new Map());
+	const transitionRef = useRef(null);
+	const previousEventRef = useRef(null);
+	const eventRef = useRef({ type: "" });
+	const getEvent = () => ({
+		...eventRef.current,
+		current() {
+			return eventRef.current;
+		},
+		previous() {
+			return previousEventRef.current;
+		}
+	});
+	const getState = () => ({
+		...state,
+		matches(...values) {
+			return values.some((value) => matchesState(state.ref.current, value));
+		},
+		hasTag(tag) {
+			return hasTag(machine, state.ref.current, tag);
+		}
+	});
+	const refs = useRefs(machine.refs?.({
+		prop,
+		context: ctx
+	}) ?? {});
+	const getParams = () => ({
+		state: getState(),
+		context: ctx,
+		event: getEvent(),
+		prop,
+		send,
+		action,
+		guard,
+		track: useTrack,
+		refs,
+		computed,
+		flush,
+		scope,
+		choose
+	});
+	const action = (keys) => {
+		const strs = isFunction(keys) ? keys(getParams()) : keys;
+		if (!strs) return;
+		const fns = strs.map((s) => {
+			const fn = machine.implementations?.actions?.[s];
+			if (!fn) warn(`[wirekyt] No implementation found for action "${JSON.stringify(s)}"`);
+			return fn;
+		});
+		for (const fn of fns) fn?.(getParams());
+	};
+	const guard = (str) => {
+		if (isFunction(str)) return str(getParams());
+		const fn = machine.implementations?.guards?.[str];
+		if (!fn) warn(`[wirekyt] No implementation found for guard "${JSON.stringify(str)}"`);
+		return fn?.(getParams());
+	};
+	const effect = (keys) => {
+		const strs = isFunction(keys) ? keys(getParams()) : keys;
+		if (!strs) return;
+		const fns = strs.map((s) => {
+			const fn = machine.implementations?.effects?.[s];
+			if (!fn) warn(`[wirekyt] No implementation found for effect "${JSON.stringify(s)}"`);
+			return fn;
+		});
+		const cleanups = [];
+		for (const fn of fns) {
+			const cleanup = fn?.(getParams());
+			if (cleanup) cleanups.push(cleanup);
+		}
+		return () => cleanups.forEach((fn) => fn?.());
+	};
+	const choose = (transitions) => {
+		return toArray(transitions).find((t) => {
+			let result = !t.guard;
+			if (isString(t.guard)) result = !!guard(t.guard);
+			else if (isFunction(t.guard)) result = t.guard(getParams());
+			return result;
+		});
+	};
+	const computed = (key) => {
+		ensure(machine.computed, () => `[wirekyt] No computed object found on machine`);
+		const fn = machine.computed[key];
+		return fn({
+			context: ctx,
+			event: getEvent(),
+			prop,
+			refs,
+			scope,
+			computed
+		});
+	};
+	const state = useBindable(() => ({
+		defaultValue: resolveStateValue(machine, machine.initialState({ prop })),
+		onChange(nextState, prevState) {
+			const { exiting, entering } = getExitEnterStates(machine, prevState, nextState, transitionRef.current?.reenter);
+			exiting.forEach((item) => {
+				effects.current.get(item.path)?.();
+				effects.current.delete(item.path);
+			});
+			exiting.forEach((item) => {
+				action(item.state?.exit);
+			});
+			action(transitionRef.current?.actions);
+			entering.forEach((item) => {
+				const cleanup = effect(item.state?.effects);
+				if (cleanup) {
+					const existing = effects.current.get(item.path);
+					effects.current.set(item.path, existing ? callAll(existing, cleanup) : cleanup);
+				}
+			});
+			if (prevState === INIT_STATE) {
+				action(machine.entry);
+				const cleanup = effect(machine.effects);
+				if (cleanup) {
+					const existing = effects.current.get(INIT_STATE);
+					effects.current.set(INIT_STATE, existing ? callAll(existing, cleanup) : cleanup);
+				}
+			}
+			entering.forEach((item) => {
+				action(item.state?.entry);
+			});
+		}
+	}));
+	const hydratedStateRef = useRef(void 0);
+	const statusRef = useRef(MachineStatus.NotStarted);
+	useSafeLayoutEffect(() => {
+		queueMicrotask(() => {
+			const started = statusRef.current === MachineStatus.Started;
+			statusRef.current = MachineStatus.Started;
+			debug(started ? "rehydrating..." : "initializing...");
+			const initialState = hydratedStateRef.current ?? state.initial;
+			state.invoke(initialState, started ? state.get() : INIT_STATE);
+		});
+		const fns = effects.current;
+		return () => {
+			const currentState = getCurrentState();
+			debug("unmounting...");
+			hydratedStateRef.current = currentState;
+			statusRef.current = MachineStatus.Stopped;
+			fns.forEach((fn) => fn?.());
+			effects.current = /* @__PURE__ */ new Map();
+			transitionRef.current = null;
+			queueMicrotask(() => {
+				action(machine.exit);
+				statusRef.current = MachineStatus.Stopped;
+			});
+		};
+	}, []);
+	const getCurrentState = () => {
+		if ("ref" in state) return state.ref.current;
+		return state.get();
+	};
+	const send = (event) => {
+		queueMicrotask(() => {
+			if (statusRef.current !== MachineStatus.Started) return;
+			previousEventRef.current = eventRef.current;
+			eventRef.current = event;
+			let currentState = getCurrentState();
+			const { transitions, source } = findTransition(machine, currentState, event.type);
+			const transition = choose(transitions);
+			if (!transition) return;
+			transitionRef.current = transition;
+			const target = resolveStateValue(machine, transition.target ?? currentState, source);
+			debug("transition", event.type, transition.target || currentState, `(${transition.actions})`);
+			if (target !== currentState) flushSync(() => state.set(target));
+			else if (transition.reenter) state.invoke(currentState, currentState);
+			else action(transition.actions ?? []);
+		});
+	};
+	machine.watch?.(getParams());
+	return {
+		state: getState(),
+		send,
+		context: ctx,
+		prop,
+		scope,
+		refs,
+		computed,
+		event: getEvent(),
+		getStatus: () => statusRef.current
+	};
+}
+function useLiveRef(value) {
+	const ref = useRef(value);
+	ref.current = value;
+	return ref;
+}
+function useProp(value) {
+	const ref = useLiveRef(value);
+	return function get(key) {
+		return ref.current[key];
+	};
+}
+function flush(fn) {
+	queueMicrotask(() => {
+		flushSync(() => fn());
+	});
+}
+//#endregion
+//#region src/core/normalize-props.ts
+const normalizeProps = createNormalizer((v) => v);
+//#endregion
+//#region src/core/portal.tsx
+const Portal = (props) => {
+	const { children, container, disabled, getRootNode } = props;
+	if (typeof window === "undefined" || disabled) return /* @__PURE__ */ jsx(React$1.Fragment, { children });
+	const doc = getRootNode?.().ownerDocument ?? document;
+	const mountNode = container?.current ?? doc.body;
+	return /* @__PURE__ */ jsx(React$1.Fragment, { children: React$1.Children.map(children, (child) => createPortal(child, mountNode)) });
+};
+//#endregion
+export { useMachine as a, normalizeProps as i, useSyncExternalStore$1 as n, Portal as r, mergeProps$1 as t };

package/dist/date-input.cjs

@@ -0,0 +1,217 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("./rolldown-runtime-DakpK96I.cjs");
+const require_utils = require("./utils-Cfwm9WW1.cjs");
+const require_environment = require("./environment-B6IaCAuQ.cjs");
+const require_core = require("./core-CBFAnVIP.cjs");
+const require_factory = require("./factory-CFFufs5e.cjs");
+const require_providers = require("./providers-DrJEJcrE.cjs");
+let react = require("react");
+let react_jsx_runtime = require("react/jsx-runtime");
+let _wirekyt_dom_machines_date_input = require("@wirekyt/dom/machines/date-input");
+_wirekyt_dom_machines_date_input = require_rolldown_runtime.__toESM(_wirekyt_dom_machines_date_input, 1);
+let _wirekyt_dom = require("@wirekyt/dom");
+//#region src/components/date-input/use-date-input.ts
+const useDateInput = (props = {}) => {
+	const id = (0, react.useId)();
+	const { dir, locale } = require_providers.useLocaleContext();
+	const { getRootNode } = require_environment.useEnvironmentContext();
+	const context = {
+		id,
+		dir,
+		locale,
+		getRootNode,
+		...props
+	};
+	const service = require_core.useMachine(_wirekyt_dom_machines_date_input.machine, context);
+	return _wirekyt_dom_machines_date_input.connect(service, require_core.normalizeProps);
+};
+//#endregion
+//#region src/components/date-input/use-date-input-context.ts
+const [DateInputProvider, useDateInputContext] = require_utils.createContext({
+	name: "DateInputContext",
+	hookName: "useDateInputContext",
+	providerName: "<DateInput.Root />"
+});
+//#endregion
+//#region src/components/date-input/context.tsx
+const DateInputContext = (props) => props.children(useDateInputContext());
+//#endregion
+//#region src/components/date-input/label.tsx
+const DateInputLabel = (0, react.forwardRef)((props, ref) => {
+	const mergedProps = (0, _wirekyt_dom.mergeProps)(useDateInputContext().getLabelProps(), props);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_factory.wire.label, {
+		...mergedProps,
+		ref
+	});
+});
+DateInputLabel.displayName = "DateInputLabel";
+//#endregion
+//#region src/components/date-input/root.tsx
+const splitRootProps = require_utils.createSplitProps();
+const DateInputRoot = (0, react.forwardRef)((props, ref) => {
+	const [useDateInputProps, localProps] = splitRootProps(props, [
+		"dir",
+		"disabled",
+		"getRootNode",
+		"id",
+		"ids",
+		"invalid",
+		"locale",
+		"max",
+		"min",
+		"name",
+		"form",
+		"onFocusChange",
+		"onPlaceholderChange",
+		"onValueChange",
+		"readOnly",
+		"required",
+		"selectionMode",
+		"timeZone",
+		"hideTimeZone",
+		"translations",
+		"value",
+		"defaultValue",
+		"hourCycle",
+		"granularity",
+		"shouldForceLeadingZeros",
+		"allSegments",
+		"formatter",
+		"placeholderValue",
+		"defaultPlaceholderValue",
+		"format",
+		"createCalendar",
+		"isDateUnavailable"
+	]);
+	const dateInput = useDateInput(useDateInputProps);
+	const mergedProps = (0, _wirekyt_dom.mergeProps)(dateInput.getRootProps(), localProps);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(DateInputProvider, {
+		value: dateInput,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_factory.wire.div, {
+			...mergedProps,
+			ref
+		})
+	});
+});
+DateInputRoot.displayName = "DateInputRoot";
+//#endregion
+//#region src/components/date-input/root-provider.tsx
+const splitRootProviderProps = require_utils.createSplitProps();
+const DateInputRootProvider = (0, react.forwardRef)((props, ref) => {
+	const [{ value: dateInput }, localProps] = splitRootProviderProps(props, ["value"]);
+	const mergedProps = (0, _wirekyt_dom.mergeProps)(dateInput.getRootProps(), localProps);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(DateInputProvider, {
+		value: dateInput,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_factory.wire.div, {
+			...mergedProps,
+			ref
+		})
+	});
+});
+DateInputRootProvider.displayName = "DateInputRootProvider";
+//#endregion
+//#region src/components/date-input/use-date-input-segment-group-props-context.ts
+const [DateInputSegmentGroupPropsProvider, useDateInputSegmentGroupPropsContext] = require_utils.createContext({
+	name: "DateInputSegmentGroupPropsContext",
+	hookName: "useDateInputSegmentGroupPropsContext",
+	providerName: "<DateInput.SegmentGroup />",
+	strict: true
+});
+//#endregion
+//#region src/components/date-input/segment.tsx
+const splitSegmentProps = require_utils.createSplitProps();
+const DateInputSegment = (0, react.forwardRef)((props, ref) => {
+	const [segmentProps, localProps] = splitSegmentProps(props, ["segment"]);
+	const segmentGroupProps = useDateInputSegmentGroupPropsContext();
+	const mergedProps = (0, _wirekyt_dom.mergeProps)(useDateInputContext().getSegmentProps({
+		...segmentProps,
+		index: segmentGroupProps.index
+	}), localProps);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_factory.wire.span, {
+		...mergedProps,
+		ref,
+		children: segmentProps.segment.text
+	});
+});
+DateInputSegment.displayName = "DateInputSegment";
+//#endregion
+//#region src/components/date-input/segment-group.tsx
+const splitSegmentGroupProps = require_utils.createSplitProps();
+const DateInputSegmentGroup = (0, react.forwardRef)((props, ref) => {
+	const [segmentGroupProps, localProps] = splitSegmentGroupProps(props, ["index"]);
+	const mergedProps = (0, _wirekyt_dom.mergeProps)(useDateInputContext().getSegmentGroupProps(segmentGroupProps), localProps);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(DateInputSegmentGroupPropsProvider, {
+		value: segmentGroupProps,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_factory.wire.div, {
+			...mergedProps,
+			ref
+		})
+	});
+});
+DateInputSegmentGroup.displayName = "DateInputSegmentGroup";
+//#endregion
+//#region src/components/date-input/hidden-input.tsx
+const splitHiddenInputProps = require_utils.createSplitProps();
+const DateInputHiddenInput = (0, react.forwardRef)((props, ref) => {
+	const [hiddenInputProps, localProps] = splitHiddenInputProps(props, ["index", "name"]);
+	const mergedProps = (0, _wirekyt_dom.mergeProps)(useDateInputContext().getHiddenInputProps(hiddenInputProps), localProps);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_factory.wire.input, {
+		...mergedProps,
+		ref
+	});
+});
+DateInputHiddenInput.displayName = "DateInputHiddenInput";
+//#endregion
+//#region src/components/date-input/control.tsx
+const DateInputControl = (0, react.forwardRef)((props, ref) => {
+	const mergedProps = (0, _wirekyt_dom.mergeProps)(useDateInputContext().getControlProps(), props);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_factory.wire.div, {
+		...mergedProps,
+		ref
+	});
+});
+DateInputControl.displayName = "DateInputControl";
+//#endregion
+//#region src/components/date-input/segment-context.tsx
+const DateInputSegmentContext = (props) => {
+	const dateInput = useDateInputContext();
+	const segmentGroupProps = useDateInputSegmentGroupPropsContext();
+	return dateInput.getSegments(segmentGroupProps).map((segment, index) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react.Fragment, { children: props.children(segment) }, `${segment.type}-${index}`));
+};
+//#endregion
+//#region src/components/date-input/date-input.ts
+var date_input_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	Context: () => DateInputContext,
+	Control: () => DateInputControl,
+	HiddenInput: () => DateInputHiddenInput,
+	Label: () => DateInputLabel,
+	Root: () => DateInputRoot,
+	RootProvider: () => DateInputRootProvider,
+	Segment: () => DateInputSegment,
+	SegmentContext: () => DateInputSegmentContext,
+	SegmentGroup: () => DateInputSegmentGroup
+});
+//#endregion
+Object.defineProperty(exports, "DateInput", {
+	enumerable: true,
+	get: function() {
+		return date_input_exports;
+	}
+});
+exports.DateInputContext = DateInputContext;
+exports.DateInputControl = DateInputControl;
+exports.DateInputHiddenInput = DateInputHiddenInput;
+exports.DateInputLabel = DateInputLabel;
+exports.DateInputRoot = DateInputRoot;
+exports.DateInputRootProvider = DateInputRootProvider;
+exports.DateInputSegment = DateInputSegment;
+exports.DateInputSegmentContext = DateInputSegmentContext;
+exports.DateInputSegmentGroup = DateInputSegmentGroup;
+Object.defineProperty(exports, "dateInputAnatomy", {
+	enumerable: true,
+	get: function() {
+		return _wirekyt_dom_machines_date_input.anatomy;
+	}
+});
+exports.useDateInput = useDateInput;
+exports.useDateInputContext = useDateInputContext;

package/dist/date-input.d.cts

@@ -0,0 +1,69 @@
+import "./index-CQAbOgb7.cjs";
+import { r as Optional, t as Assign } from "./types-BQQfrr86.cjs";
+import { r as PolymorphicProps, t as HTMLProps } from "./factory--dkoVnFK.cjs";
+import { ReactNode } from "react";
+import * as dateInput from "@wirekyt/dom/machines/date-input";
+import { DateSegment, DateValue as DateInputDateValue, FocusChangeDetails as DateInputFocusChangeDetails, HiddenInputProps, SegmentGroupProps, SegmentProps, SelectionMode as DateInputSelectionMode, ValueChangeDetails as DateInputValueChangeDetails, anatomy as dateInputAnatomy } from "@wirekyt/dom/machines/date-input";
+//#region src/components/date-input/use-date-input.d.ts
+interface UseDateInputProps extends Optional<dateInput.Props, "id"> {}
+type UseDateInputReturn = ReturnType<typeof useDateInput>;
+declare const useDateInput: (props?: UseDateInputProps) => dateInput.Api;
+//#endregion
+//#region src/components/date-input/use-date-input-context.d.ts
+interface UseDateInputContext extends UseDateInputReturn {}
+declare const DateInputProvider: import("react").Provider<UseDateInputContext>, useDateInputContext: () => UseDateInputContext;
+//#endregion
+//#region src/components/date-input/context.d.ts
+interface DateInputContextProps {
+  children: (context: UseDateInputContext) => ReactNode;
+}
+declare const DateInputContext: (props: DateInputContextProps) => ReactNode;
+//#endregion
+//#region src/components/date-input/label.d.ts
+interface DateInputLabelBaseProps extends PolymorphicProps {}
+interface DateInputLabelProps extends HTMLProps<"label">, DateInputLabelBaseProps {}
+declare const DateInputLabel: import("react").ForwardRefExoticComponent<DateInputLabelProps & import("react").RefAttributes<HTMLLabelElement>>;
+//#endregion
+//#region src/components/date-input/root.d.ts
+interface DateInputRootBaseProps extends UseDateInputProps, PolymorphicProps {}
+interface DateInputRootProps extends Assign<HTMLProps<"div">, DateInputRootBaseProps> {}
+declare const DateInputRoot: import("react").ForwardRefExoticComponent<DateInputRootProps & import("react").RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/date-input/root-provider.d.ts
+interface RootProviderProps {
+  value: UseDateInputReturn;
+}
+interface DateInputRootProviderBaseProps extends RootProviderProps, PolymorphicProps {}
+interface DateInputRootProviderProps extends HTMLProps<"div">, DateInputRootProviderBaseProps {}
+declare const DateInputRootProvider: import("react").ForwardRefExoticComponent<DateInputRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/date-input/segment.d.ts
+interface DateInputSegmentBaseProps extends PolymorphicProps, Pick<SegmentProps, "segment"> {}
+interface DateInputSegmentProps extends HTMLProps<"span">, DateInputSegmentBaseProps {}
+declare const DateInputSegment: import("react").ForwardRefExoticComponent<DateInputSegmentProps & import("react").RefAttributes<HTMLSpanElement>>;
+//#endregion
+//#region src/components/date-input/segment-group.d.ts
+interface DateInputSegmentGroupBaseProps extends PolymorphicProps, SegmentGroupProps {}
+interface DateInputSegmentGroupProps extends HTMLProps<"div">, DateInputSegmentGroupBaseProps {}
+declare const DateInputSegmentGroup: import("react").ForwardRefExoticComponent<DateInputSegmentGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/date-input/hidden-input.d.ts
+interface DateInputHiddenInputBaseProps extends PolymorphicProps, HiddenInputProps {}
+interface DateInputHiddenInputProps extends HTMLProps<"input">, DateInputHiddenInputBaseProps {}
+declare const DateInputHiddenInput: import("react").ForwardRefExoticComponent<DateInputHiddenInputProps & import("react").RefAttributes<HTMLInputElement>>;
+//#endregion
+//#region src/components/date-input/control.d.ts
+interface DateInputControlBaseProps extends PolymorphicProps {}
+interface DateInputControlProps extends HTMLProps<"div">, DateInputControlBaseProps {}
+declare const DateInputControl: import("react").ForwardRefExoticComponent<DateInputControlProps & import("react").RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/date-input/segment-context.d.ts
+interface DateInputSegmentContextProps {
+  children: (segment: DateSegment) => ReactNode;
+}
+declare const DateInputSegmentContext: (props: DateInputSegmentContextProps) => import("react").JSX.Element[];
+declare namespace date_input_d_exports {
+  export { DateInputContext as Context, DateInputContextProps as ContextProps, DateInputControl as Control, DateInputControlBaseProps as ControlBaseProps, DateInputControlProps as ControlProps, DateInputHiddenInput as HiddenInput, DateInputHiddenInputBaseProps as HiddenInputBaseProps, DateInputHiddenInputProps as HiddenInputProps, DateInputLabel as Label, DateInputLabelBaseProps as LabelBaseProps, DateInputLabelProps as LabelProps, DateInputRoot as Root, DateInputRootBaseProps as RootBaseProps, DateInputRootProps as RootProps, DateInputRootProvider as RootProvider, DateInputRootProviderBaseProps as RootProviderBaseProps, DateInputRootProviderProps as RootProviderProps, DateInputSegment as Segment, DateInputSegmentBaseProps as SegmentBaseProps, DateInputSegmentContext as SegmentContext, DateInputSegmentContextProps as SegmentContextProps, DateInputSegmentGroup as SegmentGroup, DateInputSegmentGroupBaseProps as SegmentGroupBaseProps, DateInputSegmentGroupProps as SegmentGroupProps, DateInputSegmentProps as SegmentProps };
+}
+//#endregion
+export { date_input_d_exports as DateInput, DateInputContext, type DateInputContextProps, DateInputControl, type DateInputControlBaseProps, type DateInputControlProps, type DateInputDateValue, type DateInputFocusChangeDetails, DateInputHiddenInput, type DateInputHiddenInputBaseProps, type DateInputHiddenInputProps, DateInputLabel, type DateInputLabelBaseProps, type DateInputLabelProps, DateInputRoot, type DateInputRootBaseProps, type DateInputRootProps, DateInputRootProvider, type DateInputRootProviderBaseProps, type DateInputRootProviderProps, DateInputSegment, type DateInputSegmentBaseProps, DateInputSegmentContext, type DateInputSegmentContextProps, DateInputSegmentGroup, type DateInputSegmentGroupBaseProps, type DateInputSegmentGroupProps, type DateInputSegmentProps, type DateInputSelectionMode, type DateInputValueChangeDetails, type UseDateInputContext, type UseDateInputProps, type UseDateInputReturn, dateInputAnatomy, useDateInput, useDateInputContext };