@monimesl/dot-renderer-react 0.1.0-alpha.8 → 0.1.0-alpha.9

package/dist/vendor/@base-ui/react/internals/serializeValue.js

@@ -0,0 +1,12 @@
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/internals/serializeValue.mjs
+function serializeValue(value) {
+	if (value == null) return "";
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+//#endregion
+export { serializeValue };

package/dist/vendor/@base-ui/react/internals/stateAttributesMapping.js

@@ -0,0 +1,11 @@
+import { endingStyle, startingStyle } from "./TransitionStatusDataAttributes.js";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/internals/stateAttributesMapping.mjs
+const STARTING_HOOK = { [startingStyle]: "" };
+const ENDING_HOOK = { [endingStyle]: "" };
+const transitionStatusMapping = { transitionStatus(value) {
+	if (value === "starting") return STARTING_HOOK;
+	if (value === "ending") return ENDING_HOOK;
+	return null;
+} };
+//#endregion
+export { transitionStatusMapping };

package/dist/vendor/@base-ui/react/internals/use-button/useButton.js

@@ -0,0 +1,137 @@
+"use client";
+import { makeEventPreventable, mergeProps } from "../../merge-props/mergeProps.js";
+import { isHTMLElement } from "../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { SafeReact } from "../../../utils/safeReact.js";
+import { useStableCallback } from "../../../utils/useStableCallback.js";
+import { error } from "../../../utils/error.js";
+import { useIsoLayoutEffect } from "../../../utils/useIsoLayoutEffect.js";
+import { useCompositeRootContext } from "../composite/root/CompositeRootContext.js";
+import { useFocusableWhenDisabled } from "../../utils/useFocusableWhenDisabled.js";
+import { dispatchClickWithModifiers } from "../../utils/dispatchClickWithModifiers.js";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/internals/use-button/useButton.mjs
+function useButton(parameters = {}) {
+	const { disabled = false, focusableWhenDisabled, tabIndex = 0, native: isNativeButton = true, composite: compositeProp } = parameters;
+	const elementRef = React.useRef(null);
+	const compositeRootContext = useCompositeRootContext(true);
+	const isCompositeItem = compositeProp ?? compositeRootContext !== void 0;
+	const { props: focusableWhenDisabledProps } = useFocusableWhenDisabled({
+		focusableWhenDisabled,
+		disabled,
+		composite: isCompositeItem,
+		tabIndex,
+		isNativeButton
+	});
+	if (process.env.NODE_ENV !== "production") React.useEffect(() => {
+		if (!elementRef.current) return;
+		const isButtonTag = isButtonElement(elementRef.current);
+		if (isNativeButton) {
+			if (!isButtonTag) {
+				const ownerStackMessage = SafeReact.captureOwnerStack?.() || "";
+				error(`A component that acts as a button expected a native <button> because the \`nativeButton\` prop is true. Rendering a non-<button> removes native button semantics, which can impact forms and accessibility. Use a real <button> in the \`render\` prop, or set \`nativeButton\` to \`false\`.${ownerStackMessage}`);
+			}
+		} else if (isButtonTag) {
+			const ownerStackMessage = SafeReact.captureOwnerStack?.() || "";
+			error(`A component that acts as a button expected a non-<button> because the \`nativeButton\` prop is false. Rendering a <button> keeps native behavior while Base UI applies non-native attributes and handlers, which can add unintended extra attributes (such as \`role\` or \`aria-disabled\`). Use a non-<button> in the \`render\` prop, or set \`nativeButton\` to \`true\`.${ownerStackMessage}`);
+		}
+	}, [isNativeButton]);
+	const updateDisabled = React.useCallback(() => {
+		const element = elementRef.current;
+		if (!isButtonElement(element)) return;
+		if (isCompositeItem && disabled && focusableWhenDisabledProps.disabled === void 0 && element.disabled) element.disabled = false;
+	}, [
+		disabled,
+		focusableWhenDisabledProps.disabled,
+		isCompositeItem
+	]);
+	useIsoLayoutEffect(updateDisabled, [updateDisabled]);
+	return {
+		getButtonProps: React.useCallback((externalProps = {}) => {
+			const { onClick: externalOnClick, onMouseDown: externalOnMouseDown, onKeyUp: externalOnKeyUp, onKeyDown: externalOnKeyDown, onPointerDown: externalOnPointerDown, ...otherExternalProps } = externalProps;
+			return mergeProps({
+				onClick(event) {
+					if (disabled) {
+						event.preventDefault();
+						return;
+					}
+					externalOnClick?.(event);
+				},
+				onMouseDown(event) {
+					if (!disabled) externalOnMouseDown?.(event);
+				},
+				onKeyDown(event) {
+					if (disabled) return;
+					makeEventPreventable(event);
+					externalOnKeyDown?.(event);
+					if (event.baseUIHandlerPrevented) return;
+					const isCurrentTarget = event.target === event.currentTarget;
+					const currentTarget = event.currentTarget;
+					const isButton = isButtonElement(currentTarget);
+					const isLink = !isNativeButton && isValidLinkElement(currentTarget);
+					const shouldClick = isCurrentTarget && (isNativeButton ? isButton : !isLink);
+					const isEnterKey = event.key === "Enter";
+					const isSpaceKey = event.key === " ";
+					const role = currentTarget.getAttribute("role");
+					const isTextNavigationRole = role?.startsWith("menuitem") || role === "option" || role === "gridcell";
+					if (isCurrentTarget && isCompositeItem && isSpaceKey) {
+						if (event.defaultPrevented && isTextNavigationRole) return;
+						event.preventDefault();
+						if (!isNativeButton || isButton) {
+							event.preventBaseUIHandler();
+							dispatchClickWithModifiers(currentTarget, event);
+						}
+						return;
+					}
+					if (!shouldClick || isNativeButton || !isSpaceKey && !isEnterKey) {
+						if (isCurrentTarget && isLink && isSpaceKey) event.preventDefault();
+						return;
+					}
+					if (event.defaultPrevented) return;
+					event.preventDefault();
+					if (isEnterKey) {
+						event.preventBaseUIHandler();
+						dispatchClickWithModifiers(currentTarget, event);
+					}
+				},
+				onKeyUp(event) {
+					if (disabled) return;
+					makeEventPreventable(event);
+					externalOnKeyUp?.(event);
+					if (event.target === event.currentTarget && isNativeButton && isCompositeItem && isButtonElement(event.currentTarget) && event.key === " ") {
+						event.preventDefault();
+						return;
+					}
+					if (event.baseUIHandlerPrevented) return;
+					if (event.target === event.currentTarget && !isNativeButton && !isCompositeItem && !event.defaultPrevented && event.key === " ") {
+						event.preventBaseUIHandler();
+						dispatchClickWithModifiers(event.currentTarget, event);
+					}
+				},
+				onPointerDown(event) {
+					if (disabled) {
+						event.preventDefault();
+						return;
+					}
+					externalOnPointerDown?.(event);
+				}
+			}, isNativeButton ? { type: "button" } : { role: "button" }, focusableWhenDisabledProps, otherExternalProps);
+		}, [
+			disabled,
+			focusableWhenDisabledProps,
+			isCompositeItem,
+			isNativeButton
+		]),
+		buttonRef: useStableCallback((element) => {
+			elementRef.current = element;
+			updateDisabled();
+		})
+	};
+}
+function isButtonElement(elem) {
+	return isHTMLElement(elem) && elem.tagName === "BUTTON";
+}
+function isValidLinkElement(elem) {
+	return isHTMLElement(elem) && elem.tagName === "A" && Boolean(elem.href);
+}
+//#endregion
+export { useButton };

package/dist/vendor/@base-ui/react/internals/useAnimationsFinished.js

@@ -0,0 +1,94 @@
+"use client";
+import { startingStyle } from "./TransitionStatusDataAttributes.js";
+import { useStableCallback } from "../../utils/useStableCallback.js";
+import { useAnimationFrame } from "../../utils/useAnimationFrame.js";
+import { resolveRef } from "../utils/resolveRef.js";
+import * as ReactDOM from "react-dom";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/internals/useAnimationsFinished.mjs
+let pendingCallbacks = null;
+/**
+* Runs the callback in a synchronous flush before the browser paints, so that the
+* browser doesn't paint an intermediate frame: https://github.com/mui/base-ui/issues/979
+* Callbacks that become ready within the same microtask checkpoint (e.g. multiple elements
+* whose animations finish together) are batched into a single commit:
+* https://github.com/mui/base-ui/issues/5481
+*/
+function flushBeforePaint(fn) {
+	if (!pendingCallbacks) {
+		const callbacks = [];
+		pendingCallbacks = callbacks;
+		queueMicrotask(() => {
+			pendingCallbacks = null;
+			ReactDOM.flushSync(() => {
+				for (const callback of callbacks) callback();
+			});
+		});
+	}
+	pendingCallbacks.push(fn);
+}
+/**
+* Executes a function once all animations have finished on the provided element.
+* If an animation is canceled, waits for any replacement animations before executing.
+* @param elementOrRef - The element to watch for animations.
+* @param waitForStartingStyleRemoved - Whether to wait for [data-starting-style] to be removed before checking for animations.
+* @param batch - Whether completions ready in the same microtask may be coalesced into a single
+* commit. A batched callback runs before earlier callbacks' React updates have committed, so only
+* opt in when the callback doesn't read state that another completion can change.
+* @returns A function that takes a callback to execute once all animations have finished, and an optional AbortSignal to abort the callback
+*/
+function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = false, batch = false) {
+	const frame = useAnimationFrame();
+	return useStableCallback((fnToExecute, signal = null) => {
+		frame.cancel();
+		const element = resolveRef(elementOrRef);
+		if (element == null) return;
+		const resolvedElement = element;
+		const done = () => {
+			if (!batch) {
+				ReactDOM.flushSync(fnToExecute);
+				return;
+			}
+			flushBeforePaint(() => {
+				if (!signal?.aborted) fnToExecute();
+			});
+		};
+		if (typeof resolvedElement.getAnimations !== "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED) {
+			fnToExecute();
+			return;
+		}
+		function exec() {
+			Promise.all(resolvedElement.getAnimations().map((animation) => animation.finished)).then(() => {
+				if (!signal?.aborted) done();
+			}, () => {
+				if (signal?.aborted) return;
+				if (resolvedElement.getAnimations().some((animation) => animation.pending || animation.playState !== "finished")) {
+					exec();
+					return;
+				}
+				done();
+			});
+		}
+		if (waitForStartingStyleRemoved) {
+			const startingStyleAttribute = startingStyle;
+			if (!resolvedElement.hasAttribute(startingStyleAttribute)) {
+				frame.request(exec);
+				return;
+			}
+			const attributeObserver = new MutationObserver(() => {
+				if (!resolvedElement.hasAttribute(startingStyleAttribute)) {
+					attributeObserver.disconnect();
+					exec();
+				}
+			});
+			attributeObserver.observe(resolvedElement, {
+				attributes: true,
+				attributeFilter: [startingStyleAttribute]
+			});
+			signal?.addEventListener("abort", () => attributeObserver.disconnect(), { once: true });
+			return;
+		}
+		frame.request(exec);
+	});
+}
+//#endregion
+export { useAnimationsFinished };

package/dist/vendor/@base-ui/react/internals/useBaseUiId.js

@@ -0,0 +1,13 @@
+"use client";
+import { useId } from "../../utils/useId.js";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/internals/useBaseUiId.mjs
+/**
+* Wraps `useId` and prefixes generated `id`s with `base-ui-`
+* @param {string | undefined} idOverride overrides the generated id when provided
+* @returns {string | undefined}
+*/
+function useBaseUiId(idOverride) {
+	return useId(idOverride, "base-ui");
+}
+//#endregion
+export { useBaseUiId };

package/dist/vendor/@base-ui/react/internals/useOpenChangeComplete.js

@@ -0,0 +1,28 @@
+"use client";
+import { useStableCallback } from "../../utils/useStableCallback.js";
+import { useAnimationsFinished } from "./useAnimationsFinished.js";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/internals/useOpenChangeComplete.mjs
+/**
+* Calls the provided function when the CSS open/close animation or transition completes.
+*/
+function useOpenChangeComplete(parameters) {
+	const { enabled = true, open, ref, batch = false, onComplete: onCompleteParam } = parameters;
+	const onComplete = useStableCallback(onCompleteParam);
+	const runOnceAnimationsFinish = useAnimationsFinished(ref, open, batch);
+	React.useEffect(() => {
+		if (!enabled) return;
+		const abortController = new AbortController();
+		runOnceAnimationsFinish(onComplete, abortController.signal);
+		return () => {
+			abortController.abort();
+		};
+	}, [
+		enabled,
+		open,
+		onComplete,
+		runOnceAnimationsFinish
+	]);
+}
+//#endregion
+export { useOpenChangeComplete };

package/dist/vendor/@base-ui/react/internals/useRenderElement.js

@@ -0,0 +1,109 @@
+import formatErrorMessage from "../../utils/formatErrorMessage.js";
+import { useMergedRefs, useMergedRefsN } from "../../utils/useMergedRefs.js";
+import { getReactElementRef } from "../../utils/getReactElementRef.js";
+import { mergeObjects } from "../../utils/mergeObjects.js";
+import { warn } from "../../utils/warn.js";
+import { EMPTY_OBJECT } from "../../utils/empty.js";
+import { getStateAttributesProps } from "./getStateAttributesProps.js";
+import { resolveClassName } from "../utils/resolveClassName.js";
+import { resolveStyle } from "../utils/resolveStyle.js";
+import { mergeClassNames, mergeProps, mergePropsN } from "../merge-props/mergeProps.js";
+import * as React from "react";
+import { createElement } from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/internals/useRenderElement.mjs
+/**
+* Renders a Base UI element.
+*
+* @param element The default HTML element to render. Can be overridden by the `render` prop.
+* @param componentProps An object containing the `render` and `className` props to be used for element customization. Other props are ignored.
+* @param params Additional parameters for rendering the element.
+*/
+function useRenderElement(element, componentProps, params = {}) {
+	let renderProp = componentProps.render;
+	if (params.enabled !== false) renderProp = unwrapLazyRenderProp(renderProp);
+	const outProps = useRenderElementProps(componentProps, params, renderProp);
+	if (params.enabled === false) return null;
+	const state = params.state ?? EMPTY_OBJECT;
+	return evaluateRenderProp(element, renderProp, outProps, state);
+}
+/**
+* Computes render element final props.
+*/
+function useRenderElementProps(componentProps, params, renderProp) {
+	const { className: classNameProp, style: styleProp } = componentProps;
+	const { state = EMPTY_OBJECT, ref, props, stateAttributesMapping, enabled = true } = params;
+	const className = enabled ? resolveClassName(classNameProp, state) : void 0;
+	const style = enabled ? resolveStyle(styleProp, state) : void 0;
+	const stateProps = enabled ? getStateAttributesProps(state, stateAttributesMapping) : EMPTY_OBJECT;
+	const resolvedProps = enabled && props ? resolveRenderFunctionProps(props) : void 0;
+	const outProps = enabled ? mergeObjects(stateProps, resolvedProps) ?? {} : EMPTY_OBJECT;
+	if (typeof document !== "undefined") {
+		if (!enabled) useMergedRefs(null, null);
+		else if (Array.isArray(ref)) outProps.ref = useMergedRefsN([
+			outProps.ref,
+			getReactElementRef(renderProp),
+			...ref
+		]);
+		else outProps.ref = useMergedRefs(outProps.ref, getReactElementRef(renderProp), ref);
+	}
+	if (!enabled) return EMPTY_OBJECT;
+	if (className !== void 0) outProps.className = mergeClassNames(outProps.className, className);
+	if (style !== void 0) outProps.style = mergeObjects(outProps.style, style);
+	return outProps;
+}
+function resolveRenderFunctionProps(props) {
+	if (Array.isArray(props)) return mergePropsN(props);
+	return mergeProps(void 0, props);
+}
+const REACT_LAZY_TYPE = Symbol.for("react.lazy");
+const COMPONENT_IDENTIFIER_PATTERN = /^[A-Z][A-Za-z0-9$]*$/;
+const LOWERCASE_CHARACTER_PATTERN = /[a-z]/;
+function unwrapLazyRenderProp(render) {
+	if (render?.$$typeof !== REACT_LAZY_TYPE) return render;
+	const unwrapped = React.Children.toArray(render)[0];
+	return /*#__PURE__*/ React.isValidElement(unwrapped) ? unwrapped : render;
+}
+function evaluateRenderProp(element, render, props, state) {
+	if (render) {
+		if (typeof render === "function") {
+			if (process.env.NODE_ENV !== "production") warnIfRenderPropLooksLikeComponent(render);
+			return render(props, state);
+		}
+		const mergedProps = mergeProps(props, render.props);
+		mergedProps.ref = props.ref;
+		if (process.env.NODE_ENV !== "production") {
+			if (!/*#__PURE__*/ React.isValidElement(render)) throw new Error([
+				"Base UI: The `render` prop was provided an invalid React element as `React.isValidElement(render)` is `false`.",
+				"A valid React element must be provided to the `render` prop because it is cloned with props to replace the default element.",
+				"https://base-ui.com/r/invalid-render-prop"
+			].join("\n"));
+		}
+		return /*#__PURE__*/ React.cloneElement(render, mergedProps);
+	}
+	if (element) {
+		if (typeof element === "string") return renderTag(element, props);
+	}
+	throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: Render element or function are not defined." : formatErrorMessage(8));
+}
+function warnIfRenderPropLooksLikeComponent(renderFn) {
+	const functionName = renderFn.name;
+	if (functionName.length === 0) return;
+	if (!COMPONENT_IDENTIFIER_PATTERN.test(functionName)) return;
+	if (!LOWERCASE_CHARACTER_PATTERN.test(functionName)) return;
+	warn(`The \`render\` prop received a function named \`${functionName}\` that starts with an uppercase letter.`, "This usually means a React component was passed directly as `render={Component}`.", "Base UI calls `render` as a plain function, which can break the Rules of Hooks during reconciliation.", "If this is an intentional render callback, rename it to start with a lowercase letter.", "Use `render={<Component />}` or `render={(props) => <Component {...props} />}` instead.", "https://base-ui.com/r/invalid-render-prop");
+}
+function renderTag(Tag, props) {
+	if (Tag === "button") return /*#__PURE__*/ createElement("button", {
+		type: "button",
+		...props,
+		key: props.key
+	});
+	if (Tag === "img") return /*#__PURE__*/ createElement("img", {
+		alt: "",
+		...props,
+		key: props.key
+	});
+	return /*#__PURE__*/ React.createElement(Tag, props);
+}
+//#endregion
+export { useRenderElement };

package/dist/vendor/@base-ui/react/internals/useTransitionStatus.js

@@ -0,0 +1,70 @@
+"use client";
+import { useIsoLayoutEffect } from "../../utils/useIsoLayoutEffect.js";
+import { AnimationFrame } from "../../utils/useAnimationFrame.js";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/internals/useTransitionStatus.mjs
+/**
+* Provides a status string for CSS animations.
+* @param open - a boolean that determines if the element is open.
+* @param enableIdleState - a boolean that enables the `'idle'` state between `'starting'` and `'ending'`
+* @param deferEndingState - a boolean that delays the `'ending'` state by a frame
+* @param animateInitialOpen - a boolean that makes an element which mounts already open still go
+*   through `'starting'`. Off by default so content that was open on the first render (a
+*   `defaultOpen` popup on page load, SSR'd markup) doesn't animate in.
+*/
+function useTransitionStatus(open, enableIdleState = false, deferEndingState = false, animateInitialOpen = false) {
+	const [transitionStatus, setTransitionStatus] = React.useState(open && enableIdleState ? "idle" : void 0);
+	const [mounted, setMounted] = React.useState(open && !animateInitialOpen);
+	if (open && !mounted) {
+		setMounted(true);
+		setTransitionStatus("starting");
+	}
+	if (!open && mounted && transitionStatus !== "ending" && !deferEndingState) setTransitionStatus("ending");
+	if (!open && !mounted && transitionStatus === "ending") setTransitionStatus(void 0);
+	useIsoLayoutEffect(() => {
+		if (!open && mounted && transitionStatus !== "ending" && deferEndingState) {
+			const frame = AnimationFrame.request(() => {
+				setTransitionStatus("ending");
+			});
+			return () => {
+				AnimationFrame.cancel(frame);
+			};
+		}
+	}, [
+		open,
+		mounted,
+		transitionStatus,
+		deferEndingState
+	]);
+	useIsoLayoutEffect(() => {
+		if (!open || enableIdleState) return;
+		const frame = AnimationFrame.request(() => {
+			setTransitionStatus(void 0);
+		});
+		return () => {
+			AnimationFrame.cancel(frame);
+		};
+	}, [enableIdleState, open]);
+	useIsoLayoutEffect(() => {
+		if (!open || !enableIdleState) return;
+		if (open && mounted && transitionStatus !== "idle") setTransitionStatus("starting");
+		const frame = AnimationFrame.request(() => {
+			setTransitionStatus("idle");
+		});
+		return () => {
+			AnimationFrame.cancel(frame);
+		};
+	}, [
+		enableIdleState,
+		open,
+		mounted,
+		transitionStatus
+	]);
+	return {
+		mounted,
+		setMounted,
+		transitionStatus
+	};
+}
+//#endregion
+export { useTransitionStatus };

package/dist/vendor/@base-ui/react/internals/useValueChanged.js

@@ -0,0 +1,15 @@
+"use client";
+import { useStableCallback } from "../../utils/useStableCallback.js";
+import { useIsoLayoutEffect } from "../../utils/useIsoLayoutEffect.js";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/internals/useValueChanged.mjs
+function useValueChanged(value, onChange) {
+	const valueRef = React.useRef(value);
+	const onChangeCallback = useStableCallback(onChange);
+	useIsoLayoutEffect(() => {
+		if (valueRef.current !== value) onChangeCallback(valueRef.current);
+		valueRef.current = value;
+	}, [value, onChangeCallback]);
+}
+//#endregion
+export { useValueChanged };

package/dist/vendor/@base-ui/react/merge-props/mergeProps.js

@@ -0,0 +1,153 @@
+import { mergeObjects } from "../../utils/mergeObjects.js";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/merge-props/mergeProps.mjs
+const EMPTY_PROPS = {};
+/**
+* Merges multiple sets of React props. It follows the Object.assign pattern where the rightmost object's fields overwrite
+* the conflicting ones from others. This doesn't apply to event handlers, `className` and `style` props.
+*
+* Event handlers are merged and called in right-to-left order (rightmost handler executes first, leftmost last).
+* For React synthetic events, the rightmost handler can prevent prior (left-positioned) handlers from executing
+* by calling `event.preventBaseUIHandler()`. For non-synthetic events (custom events with primitive/object values),
+* all handlers always execute without prevention capability.
+*
+* The `className` prop is merged by concatenating classes in right-to-left order (rightmost class appears first in the string).
+* The `style` prop is merged with rightmost styles overwriting the prior ones.
+*
+* Props can either be provided as objects or as functions that take the previous props as an argument.
+* The function will receive the merged props up to that point (going from left to right):
+* so in the case of `(obj1, obj2, fn, obj3)`, `fn` will receive the merged props of `obj1` and `obj2`.
+* The function is responsible for chaining event handlers if needed (that is, we don't run the merge logic).
+*
+* Event handlers returned by the functions are not automatically prevented when `preventBaseUIHandler` is called.
+* They must check `event.baseUIHandlerPrevented` themselves and bail out if it's true.
+*
+* @important **`ref` is not merged.**
+* @param a Props object to merge.
+* @param b Props object to merge. The function will overwrite conflicting props from `a`.
+* @param c Props object to merge. The function will overwrite conflicting props from previous parameters.
+* @param d Props object to merge. The function will overwrite conflicting props from previous parameters.
+* @param e Props object to merge. The function will overwrite conflicting props from previous parameters.
+* @returns The merged props.
+* @public
+*/
+function mergeProps(a, b, c, d, e) {
+	if (!c && !d && !e && !a) return createInitialMergedProps(b);
+	let merged = createInitialMergedProps(a);
+	if (b) merged = mergeInto(merged, b);
+	if (c) merged = mergeInto(merged, c);
+	if (d) merged = mergeInto(merged, d);
+	if (e) merged = mergeInto(merged, e);
+	return merged;
+}
+/**
+* Merges an arbitrary number of React props using the same logic as {@link mergeProps}.
+* This function accepts an array of props instead of individual arguments.
+*
+* This has slightly lower performance than {@link mergeProps} due to accepting an array
+* instead of a fixed number of arguments. Prefer {@link mergeProps} when merging 5 or
+* fewer prop sets for better performance.
+*
+* @param props Array of props to merge.
+* @returns The merged props.
+* @see mergeProps
+* @public
+*/
+function mergePropsN(props) {
+	if (props.length === 0) return EMPTY_PROPS;
+	if (props.length === 1) return createInitialMergedProps(props[0]);
+	let merged = createInitialMergedProps(props[0]);
+	for (let i = 1; i < props.length; i += 1) merged = mergeInto(merged, props[i]);
+	return merged;
+}
+function createInitialMergedProps(inputProps) {
+	if (isPropsGetter(inputProps)) return { ...resolvePropsGetter(inputProps, EMPTY_PROPS) };
+	return copyInitialProps(inputProps);
+}
+function mergeInto(merged, inputProps) {
+	if (isPropsGetter(inputProps)) return resolvePropsGetter(inputProps, merged);
+	return mutablyMergeInto(merged, inputProps);
+}
+function copyInitialProps(inputProps) {
+	const copiedProps = { ...inputProps };
+	for (const propName in copiedProps) {
+		const propValue = copiedProps[propName];
+		if (isEventHandler(propName, propValue)) copiedProps[propName] = wrapEventHandler(propValue);
+	}
+	return copiedProps;
+}
+/**
+* Merges two sets of props. In case of conflicts, the external props take precedence.
+*/
+function mutablyMergeInto(mergedProps, externalProps) {
+	if (!externalProps) return mergedProps;
+	for (const propName in externalProps) {
+		const externalPropValue = externalProps[propName];
+		switch (propName) {
+			case "style":
+				mergedProps[propName] = mergeObjects(mergedProps.style, externalPropValue);
+				break;
+			case "className":
+				mergedProps[propName] = mergeClassNames(mergedProps.className, externalPropValue);
+				break;
+			default: if (isEventHandler(propName, externalPropValue)) mergedProps[propName] = mergeEventHandlers(mergedProps[propName], externalPropValue);
+			else mergedProps[propName] = externalPropValue;
+		}
+	}
+	return mergedProps;
+}
+function isEventHandler(key, value) {
+	const code0 = key.charCodeAt(0);
+	const code1 = key.charCodeAt(1);
+	const code2 = key.charCodeAt(2);
+	return code0 === 111 && code1 === 110 && code2 >= 65 && code2 <= 90 && (typeof value === "function" || typeof value === "undefined");
+}
+function isPropsGetter(inputProps) {
+	return typeof inputProps === "function";
+}
+function resolvePropsGetter(inputProps, previousProps) {
+	if (isPropsGetter(inputProps)) return inputProps(previousProps);
+	return inputProps ?? EMPTY_PROPS;
+}
+function mergeEventHandlers(ourHandler, theirHandler) {
+	if (!theirHandler) return ourHandler;
+	if (!ourHandler) return wrapEventHandler(theirHandler);
+	return (...args) => {
+		const event = args[0];
+		if (isSyntheticEvent(event)) {
+			const baseUIEvent = event;
+			makeEventPreventable(baseUIEvent);
+			const result = theirHandler(...args);
+			if (!baseUIEvent.baseUIHandlerPrevented) ourHandler?.(...args);
+			return result;
+		}
+		const result = theirHandler(...args);
+		ourHandler?.(...args);
+		return result;
+	};
+}
+function wrapEventHandler(handler) {
+	if (!handler) return handler;
+	return (...args) => {
+		const event = args[0];
+		if (isSyntheticEvent(event)) makeEventPreventable(event);
+		return handler(...args);
+	};
+}
+function makeEventPreventable(event) {
+	event.preventBaseUIHandler = () => {
+		event.baseUIHandlerPrevented = true;
+	};
+	return event;
+}
+function mergeClassNames(ourClassName, theirClassName) {
+	if (theirClassName) {
+		if (ourClassName) return theirClassName + " " + ourClassName;
+		return theirClassName;
+	}
+	return ourClassName;
+}
+function isSyntheticEvent(event) {
+	return event != null && typeof event === "object" && "nativeEvent" in event;
+}
+//#endregion
+export { makeEventPreventable, mergeClassNames, mergeProps, mergePropsN };