@nizivo/react 0.0.0-stage → 0.2.0

package/dist/_engines/react-aria/popup.client.js

@@ -0,0 +1,153 @@
+"use client";
+import { use, useEffect, useLayoutEffect, useRef, useState } from "react";
+import { OverlayTriggerStateContext, PopoverContext } from "react-aria-components";
+//#region src/_engines/react-aria/popup.client.tsx
+const TABBABLE = "a[href], area[href], button, input, select, textarea, iframe, summary, [tabindex], [contenteditable]:not([contenteditable=\"false\"])";
+/**
+* The tabbable element after (or before) `from` in its dialog, else in the document, skipping `skip`
+* (the popup itself). `inert` is not checked: the engine marks the page inert while the popup is
+* open, and lifts it as the popup closes.
+*/
+function adjacentTabbable(from, backwards, skip) {
+	const root = from.closest("[role=\"dialog\"], [role=\"alertdialog\"], dialog") ?? from.ownerDocument;
+	const order = backwards ? Node.DOCUMENT_POSITION_PRECEDING : Node.DOCUMENT_POSITION_FOLLOWING;
+	const candidates = [...root.querySelectorAll(TABBABLE)].filter((element) => element.tabIndex >= 0 && !element.matches(":disabled") && (skip === null || !skip.contains(element)) && !from.contains(element) && (from.compareDocumentPosition(element) & order) !== 0 && element.getClientRects().length > 0);
+	return backwards ? candidates.at(-1) : candidates[0];
+}
+/**
+* Tab and Shift+Tab out of a menu or listbox popup (§12.2 Dismiss stack; APG menu button): the popup
+* closes and focus moves to the element after (or before) its trigger. React Aria 1.22.1 keeps Tab
+* inside its modal popovers, so the adapter handles the key on the popup's list element.
+*/
+function useTabOut(popup) {
+	const state = use(OverlayTriggerStateContext);
+	const context = use(PopoverContext);
+	const trigger = typeof context === "object" && context !== null && "triggerRef" in context ? context.triggerRef : void 0;
+	return (event) => {
+		if (event.key !== "Tab" || event.altKey || event.ctrlKey || event.metaKey) return;
+		const from = typeof trigger === "object" && trigger !== null && "current" in trigger ? trigger.current : void 0;
+		if (state === null || !(from instanceof HTMLElement)) return;
+		event.preventDefault();
+		event.stopPropagation();
+		const target = adjacentTabbable(from, event.shiftKey, popup.current) ?? from;
+		state.close();
+		requestAnimationFrame(() => target.focus());
+	};
+}
+function isElementRef(value) {
+	return typeof value === "object" && value !== null && "current" in value && (value.current === null || value.current instanceof HTMLElement);
+}
+/** The enclosing MenuTrigger's, Select's or DialogTrigger's trigger, from the engine's PopoverContext. */
+function useTriggerRef() {
+	const context = use(PopoverContext);
+	const ref = typeof context === "object" && context !== null && "triggerRef" in context ? context.triggerRef : void 0;
+	return isElementRef(ref) ? ref : void 0;
+}
+/**
+* Popups the family closed itself on an outside press (outside-press.client.tsx). The press lands on
+* the popup's underlay, so no control took focus, but a modal parent's FocusScope moves focus to its
+* first control as the popup's content leaves (React Aria's containment fallback), before any
+* restore: the chain runs for these even though focus is no longer on <body> (O-12).
+*/
+const CLOSED_OUTSIDE = /* @__PURE__ */ new WeakSet();
+/** Marks `popup` as closed by the family's outside press, for ReturnFocus. */
+function returnAfterClose(popup) {
+	CLOSED_OUTSIDE.add(popup);
+}
+/** The family's open popups and their triggers: the parent-overlay step below. */
+const OPEN = /* @__PURE__ */ new Map();
+/**
+* React Aria's FocusScope dispatches this cancelable event on the element it is about to focus when a
+* scope unmounts with focus lost to <body> (react-aria 3.53.1, FocusScope `restoreFocusToElement`); a
+* prevented event leaves focus alone. It is how `returnFocus` overrides the engine's choice.
+*/
+const ENGINE_RESTORE = "react-aria-focus-scope-restore";
+/** A focus target: on the page, and not <body> (where focus is when nothing has it). */
+const usable = (element) => element instanceof HTMLElement && element.isConnected && element !== element.ownerDocument.body;
+/** Whether the popup is still in the DOM: Strict Mode's mount-time replay of the effect. */
+const mounted = (popup) => popup.current?.isConnected === true;
+/** The element a `returnFocus` ref or function names, if any. */
+const named = (target) => typeof target === "function" ? target() : typeof target === "object" ? target.current : null;
+/**
+* Focus return (§12.2): `returnFocus` (`true`, an element ref, a function returning one, or `false`)
+* → the original trigger if still connected → the element that had focus as the popup opened → the
+* parent overlay's trigger (a Dialog opened from a Menu item returns to the Menu button) → <body>,
+* with a development warning. Rendered inside every modal popup of the family (Dialog, Menu,
+* Select).
+*
+* React Aria returns focus to the element that had it when the popup opened, which covers the
+* common case; this completes the chain where it has nowhere to go: a popup open on the server
+* (`defaultOpen`) or opened from code with nothing focused, and a Dialog opened from an item of a
+* Menu that had no focus origin of its own loses its opener with the Menu. Each popup registers
+* itself while open, so one opened from inside another records that one's trigger as its parent
+* step. It never moves focus that went somewhere (an outside click on a control, Tab out of a
+* menu).
+*/
+function ReturnFocus({ trigger, popup, target = true }) {
+	const [origin] = useState(() => {
+		const opener = globalThis.document?.activeElement;
+		let parent;
+		for (const [open, openTrigger] of OPEN) if (opener != null && open.current?.contains(opener)) parent = openTrigger?.current;
+		return [opener, parent];
+	});
+	const latest = useRef(target);
+	useLayoutEffect(() => {
+		latest.current = target;
+	});
+	const shown = useRef(false);
+	useEffect(() => {
+		if (mounted(popup)) shown.current = true;
+	});
+	useLayoutEffect(() => {
+		const element = trigger?.current;
+		OPEN.set(popup, trigger);
+		return () => {
+			OPEN.delete(popup);
+			const doc = document;
+			let handled = false;
+			const onRestore = (event) => {
+				const own = latest.current;
+				const to = own === false ? void 0 : [named(own), element].find(usable);
+				if (event.defaultPrevented || mounted(popup) || own !== false && to === void 0) return;
+				event.preventDefault();
+				handled = true;
+				to?.focus();
+			};
+			doc.addEventListener(ENGINE_RESTORE, onRestore, true);
+			requestAnimationFrame(() => {
+				doc.removeEventListener(ENGINE_RESTORE, onRestore, true);
+				const own = latest.current;
+				const outside = CLOSED_OUTSIDE.delete(popup);
+				if (handled || !shown.current || own === false || mounted(popup) || (doc.activeElement ?? doc.body) !== doc.body && !outside) return;
+				const next = [
+					named(own),
+					element,
+					...origin
+				].find(usable);
+				if (next) next.focus();
+				else if (process.env.NODE_ENV !== "production") console.warn("Nizivo: an overlay closed and focus had nowhere to return (its trigger, the element that opened it and its parent overlay are gone), so it is on <body>. Pass `returnFocus` an element that stays on the page.");
+			});
+		};
+	}, [
+		trigger,
+		popup,
+		origin
+	]);
+	return null;
+}
+/**
+* Moves focus to the leaf's initial-focus element (§12.2 Focus on open; Dialog, Drawer, Popover). A
+* child of the content element, so its effect runs before React Aria's own focus-the-dialog effect (a
+* parent's), which then sees focus inside and leaves it; and after FocusScope recorded the trigger to
+* return focus to.
+*/
+function InitialFocus({ content, resolve }) {
+	useEffect(() => {
+		const element = content.current;
+		if (element === null || element.contains(element.ownerDocument.activeElement)) return;
+		resolve(element)?.focus();
+	}, [content, resolve]);
+	return null;
+}
+//#endregion
+export { InitialFocus, ReturnFocus, returnAfterClose, useTabOut, useTriggerRef };

package/dist/_engines/react-aria/select.client.js

@@ -0,0 +1,180 @@
+"use client";
+import { mergeProps } from "../../contracts/merge-props.js";
+import { details } from "../../contracts/details.js";
+import { stateAttrs } from "../../contracts/state.js";
+import { defined, engineDom } from "./dom.js";
+import { EngineLocale } from "./locale.client.js";
+import { popupStyle, resolveSide, toPlacement } from "./overlay.client.js";
+import { PopupKey, useOpenState } from "./open-state.client.js";
+import { ReturnFocus, useTabOut, useTriggerRef } from "./popup.client.js";
+import { OutsidePress } from "./outside-press.client.js";
+import { createElement, use, useEffect, useLayoutEffect, useRef } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Button, Header, ListBox, ListBoxItem, ListBoxSection, Popover, Select, SelectStateContext, SelectValue, Separator, useLocale } from "react-aria-components";
+//#region src/_engines/react-aria/select.client.tsx
+/**
+* React Aria 1.22.1 resets the state on the form's `reset`, then the browser resets the hidden native
+* <select> to its empty first option, and React never writes the value back (its prop did not
+* change after the reset): the trigger showed the default while FormData had ''. After the browser's
+* reset, the hidden <select> takes the state's value again.
+*/
+function FormReset({ root }) {
+	const value = use(SelectStateContext)?.value;
+	const latest = useRef(value);
+	useLayoutEffect(() => {
+		latest.current = value;
+	});
+	useEffect(() => {
+		const select = root.current?.querySelector("select");
+		const form = select?.form;
+		const onReset = () => {
+			setTimeout(() => {
+				if (select) select.value = String(latest.current ?? "");
+			});
+		};
+		form?.addEventListener("reset", onReset);
+		return () => form?.removeEventListener("reset", onReset);
+	}, [root]);
+	return null;
+}
+const Root = ({ value, defaultValue, onValueChange, open, defaultOpen, onOpenChange, name, required, disabled, invalid, placeholder, "aria-label": label, "aria-labelledby": labelledBy, render, children, ...dom }) => {
+	const root = useRef(null);
+	const [isOpen, setOpen, popupKey] = useOpenState(open, defaultOpen, onOpenChange);
+	return /* @__PURE__ */ jsx(EngineLocale, { children: /* @__PURE__ */ jsxs(Select, {
+		...defined({
+			value,
+			defaultValue,
+			name,
+			isRequired: required,
+			isDisabled: disabled,
+			isInvalid: invalid,
+			placeholder,
+			"aria-label": label,
+			"aria-labelledby": labelledBy
+		}),
+		isOpen,
+		onOpenChange: setOpen,
+		onChange: (key) => onValueChange?.(key == null ? null : String(key), details("unknown")),
+		validationBehavior: "native",
+		render: (p, rp) => {
+			const s = {
+				open: rp.isOpen,
+				disabled: rp.isDisabled
+			};
+			const attrs = stateAttrs({
+				...s,
+				required: rp.isRequired,
+				invalid
+			});
+			return render(mergeProps(engineDom(p), dom, attrs, { ref: root }), s);
+		},
+		children: [/* @__PURE__ */ jsx(PopupKey, {
+			value: popupKey,
+			children
+		}), /* @__PURE__ */ jsx(FormReset, { root })]
+	}) });
+};
+const Trigger = ({ id, "aria-label": label, "aria-describedby": describedBy, render, children, ...dom }) => {
+	const open = use(SelectStateContext)?.isOpen ?? false;
+	return /* @__PURE__ */ jsx(Button, {
+		...defined({
+			id,
+			"aria-label": label,
+			"aria-describedby": describedBy
+		}),
+		render: (p, rp) => {
+			const s = {
+				open,
+				pressed: rp.isPressed && !open,
+				focusVisible: rp.isFocusVisible,
+				disabled: rp.isDisabled
+			};
+			return render(mergeProps(engineDom(p), dom, stateAttrs(s)), s);
+		},
+		children
+	});
+};
+const Value = ({ render, children, ...dom }) => /* @__PURE__ */ jsx(SelectValue, {
+	render: (p, rp) => {
+		const s = { placeholder: rp.isPlaceholder };
+		return render(mergeProps(engineDom(p), dom, stateAttrs(s)), s);
+	},
+	children
+});
+const Popup = ({ side, align, sideOffset, container, list, render, children, ...dom }) => {
+	const { direction } = useLocale();
+	const popup = useRef(null);
+	const tabOut = useTabOut(popup);
+	const trigger = useTriggerRef();
+	const key = use(PopupKey);
+	return /* @__PURE__ */ jsxs(Popover, {
+		placement: toPlacement(side, align),
+		offset: sideOffset,
+		...defined({ UNSTABLE_portalContainer: container ?? void 0 }),
+		render: (p, rp) => {
+			const s = {
+				entering: rp.isEntering,
+				exiting: rp.isExiting,
+				side: resolveSide(rp.placement, side, direction)
+			};
+			const engine = {
+				...engineDom(p),
+				style: popupStyle(p.style)
+			};
+			const attrs = stateAttrs({
+				open: !rp.isExiting,
+				...s,
+				align
+			});
+			return render(mergeProps(engine, dom, attrs, { ref: popup }), s);
+		},
+		children: [
+			/* @__PURE__ */ jsx(ReturnFocus, {
+				trigger,
+				popup
+			}),
+			/* @__PURE__ */ jsx(OutsidePress, { popup }),
+			/* @__PURE__ */ jsx(ListBox, {
+				render: (p) => createElement("div", mergeProps(engineDom(p), list, { onKeyDown: tabOut })),
+				children
+			})
+		]
+	}, key);
+};
+const Item = ({ value, textValue, disabled, render, children, ...dom }) => /* @__PURE__ */ jsx(ListBoxItem, {
+	id: value,
+	...defined({
+		textValue,
+		isDisabled: disabled
+	}),
+	render: (p, rp) => {
+		const s = {
+			highlighted: rp.isFocused,
+			selected: rp.isSelected,
+			disabled: rp.isDisabled,
+			focusVisible: rp.isFocusVisible
+		};
+		return render(mergeProps(engineDom(p), dom, stateAttrs(s)), s);
+	},
+	children
+});
+const Group = ({ render, children, ...dom }) => /* @__PURE__ */ jsx(ListBoxSection, {
+	render: (p) => render(mergeProps(engineDom(p), dom), {}),
+	children
+});
+const GroupLabel = ({ render, children, ...dom }) => /* @__PURE__ */ jsx(Header, {
+	render: (p) => render(mergeProps(engineDom(p), dom), {}),
+	children
+});
+/** ARIA allows only option and group inside a listbox (axe aria-required-children), so the rule is
+* presentational: React Aria's role="separator" and its orientation are dropped. */
+function presentational(props) {
+	const { role: _role, "aria-orientation": _orientation, ...rest } = engineDom(props);
+	return {
+		...rest,
+		role: "presentation"
+	};
+}
+const Separator$1 = ({ render, ...dom }) => /* @__PURE__ */ jsx(Separator, { render: (p) => render(mergeProps(presentational(p), dom), {}) });
+//#endregion
+export { Group, GroupLabel, Item, Popup, Root, Separator$1 as Separator, Trigger, Value };

package/dist/_engines/react-aria/tabs.client.js

@@ -0,0 +1,95 @@
+"use client";
+import { mergeProps } from "../../contracts/merge-props.js";
+import { details } from "../../contracts/details.js";
+import { stateAttrs } from "../../contracts/state.js";
+import { defined, engineDom } from "./dom.js";
+import { EngineLocale } from "./locale.client.js";
+import { createContext, use } from "react";
+import { jsx } from "react/jsx-runtime";
+import { I18nProvider, Tab, TabList, TabPanel, Tabs, useLocale } from "react-aria-components";
+//#region src/_engines/react-aria/tabs.client.tsx
+/**
+* The nearest Tabs root's `dir`, for its list. A root without `dir` inherits it, so a strip nested in
+* the panel of a `dir` root keys the way CSS lays it out (the attribute is inherited). Unset at every
+* level: the direction of the locale (EngineLocale).
+*/
+const Dir = createContext(void 0);
+/**
+* The arrows' direction (M26). React Aria has one direction input, the locale `I18nProvider` is
+* given, and only the tab list reads it (`useTabList` and `useSelectableCollection`, for the
+* arrows). So the list alone gets a locale whose direction is `dir`: the scope's locale when it
+* already has that direction (every render without `dir` is unchanged), else `ar` or `en`. Nothing
+* in the list formats, collates or speaks a string (the tabs delegate has no type-ahead), and each
+* tab's content gets the scope's locale back (`Tab`), so that locale only carries the direction to
+* the list's own hooks. A script subtag (`en-Arab-US`) would keep the language, but
+* WebKit 27.2 derives `Intl.Locale` text direction from the language only and reads it as `ltr`.
+* The provider is always rendered, so changing `dir` never remounts the list and drops focus.
+*/
+function Directed({ children }) {
+	const dir = use(Dir);
+	const { locale, direction } = useLocale();
+	return /* @__PURE__ */ jsx(I18nProvider, {
+		locale: dir === void 0 || dir === direction ? locale : dir === "rtl" ? "ar" : "en",
+		children
+	});
+}
+const Root = ({ value, defaultValue, onValueChange, activationMode, disabled, render, children, ...dom }) => {
+	const inherited = use(Dir);
+	return /* @__PURE__ */ jsx(EngineLocale, { children: /* @__PURE__ */ jsx(Dir, {
+		value: dom.dir ?? inherited,
+		children: /* @__PURE__ */ jsx(Tabs, {
+			...defined({
+				selectedKey: value,
+				defaultSelectedKey: defaultValue,
+				isDisabled: disabled
+			}),
+			keyboardActivation: activationMode,
+			onSelectionChange: (key) => onValueChange?.(String(key), details("unknown")),
+			render: (p) => {
+				const s = { disabled: disabled === true };
+				return render(mergeProps(engineDom(p), dom, stateAttrs(s)), s);
+			},
+			children
+		})
+	}) });
+};
+const List = ({ "aria-label": label, "aria-labelledby": labelledBy, "aria-describedby": describedBy, render, children, ...dom }) => /* @__PURE__ */ jsx(Directed, { children: /* @__PURE__ */ jsx(TabList, {
+	...defined({
+		"aria-label": label,
+		"aria-labelledby": labelledBy,
+		"aria-describedby": describedBy
+	}),
+	render: (p, rp) => {
+		const s = { disabled: rp.state.isDisabled };
+		return render(mergeProps(engineDom(p), dom, stateAttrs(s)), s);
+	},
+	children
+}) });
+const Tab$1 = ({ value, disabled, render, children, ...dom }) => /* @__PURE__ */ jsx(Tab, {
+	id: value,
+	...defined({ isDisabled: disabled }),
+	render: (p, rp) => {
+		const s = {
+			selected: rp.isSelected,
+			disabled: rp.isDisabled,
+			focusVisible: rp.isFocusVisible
+		};
+		return render(mergeProps(engineDom(p), dom, stateAttrs(s)), s);
+	},
+	children: /* @__PURE__ */ jsx(EngineLocale, { children })
+});
+const Panel = ({ value, keepMounted, render, children, ...dom }) => /* @__PURE__ */ jsx(TabPanel, {
+	id: value,
+	shouldForceMount: keepMounted,
+	render: (p, rp) => {
+		const s = {
+			selected: !rp.isInert,
+			focusVisible: rp.isFocusVisible
+		};
+		const hidden = rp.isInert ? { hidden: true } : void 0;
+		return render(mergeProps(engineDom(p), dom, hidden, stateAttrs({ focusVisible: s.focusVisible })), s);
+	},
+	children
+});
+//#endregion
+export { List, Panel, Root, Tab$1 as Tab };

package/dist/_engines/react-aria/toast.client.js

@@ -0,0 +1,38 @@
+"use client";
+import { markTopLayer } from "./overlay.client.js";
+import { useToast, useToastRegion } from "react-aria/useToast";
+//#region src/_engines/react-aria/toast.client.tsx
+/** The ToastState the hooks read, over the store: React Aria never adds a toast here. */
+function state(options) {
+	return {
+		visibleToasts: options.toasts.map((toast) => ({
+			key: toast.id,
+			content: toast
+		})),
+		add: () => "",
+		close: options.close,
+		pauseAll: options.pause,
+		resumeAll: options.resume
+	};
+}
+function useRegion(options, ref) {
+	const { regionProps } = useToastRegion({ "aria-label": options.label }, state(options), ref);
+	return regionProps;
+}
+function useItem(toast, options, ref) {
+	const { toastProps, titleProps, descriptionProps } = useToast({ toast: {
+		key: toast.id,
+		content: toast
+	} }, state(options), ref);
+	const { "aria-describedby": describedBy, ...rest } = toastProps;
+	return {
+		toastProps: toast.description === void 0 ? rest : {
+			...rest,
+			"aria-describedby": describedBy
+		},
+		messageProps: titleProps,
+		descriptionProps
+	};
+}
+//#endregion
+export { markTopLayer, useItem, useRegion };

package/dist/_engines/react-aria/tooltip.client.js

@@ -0,0 +1,72 @@
+"use client";
+import { mergeProps } from "../../contracts/merge-props.js";
+import { stateAttrs } from "../../contracts/state.js";
+import { defined, engineDom } from "./dom.js";
+import { EngineLocale } from "./locale.client.js";
+import { popupStyle, resolveSide, toPlacement } from "./overlay.client.js";
+import { useOpenState } from "./open-state.client.js";
+import { use } from "react";
+import { jsx } from "react/jsx-runtime";
+import { Tooltip, TooltipTrigger, TooltipTriggerStateContext, useLocale } from "react-aria-components";
+import { useFocusable } from "react-aria/useFocusable";
+import { useObjectRef } from "react-aria/useObjectRef";
+//#region src/_engines/react-aria/tooltip.client.tsx
+const Root = ({ open, defaultOpen, onOpenChange, delay, disabled, children }) => {
+	const [isOpen, setOpen, key] = useOpenState(open, defaultOpen, onOpenChange);
+	return /* @__PURE__ */ jsx(EngineLocale, { children: /* @__PURE__ */ jsx(TooltipTrigger, {
+		delay,
+		isOpen,
+		onOpenChange: setOpen,
+		...defined({ isDisabled: disabled }),
+		children
+	}, key) });
+};
+/**
+* The trigger is the consumer's own element (often a server `<Button>`), so it takes the engine's
+* hover/focus props through `useFocusable` instead of a React Aria `Button`.
+*/
+const Trigger = ({ render, ...dom }) => {
+	const ref = useObjectRef();
+	const { focusableProps } = useFocusable({}, ref);
+	const s = { open: use(TooltipTriggerStateContext)?.isOpen ?? false };
+	return render(mergeProps(engineDom(focusableProps), { ref }, dom, stateAttrs(s)), s);
+};
+/**
+* React Aria 1.22.1 closes a tooltip "instantly" (no exit animation) when another one opens during
+* the warm-up period, as Tab moves across tooltip triggers. Its exit state is then left "exiting"
+* with no element to animate, so the next ordinary close of that tooltip (a press on its trigger,
+* after the keyboard, with no pointer move that would reopen it first) mounts an unpositioned popup
+* in `data-exiting` that never leaves. Keying the engine's Tooltip on that instant close remounts it
+* with a fresh exit state; it renders nothing in either state, so nothing visible remounts.
+*/
+function instantlyClosed(state) {
+	return state !== null && !state.isOpen && state.shouldSkipAnimation === true;
+}
+const Popup = ({ side, align, sideOffset, container, render, children, ...dom }) => {
+	const { direction } = useLocale();
+	return /* @__PURE__ */ jsx(Tooltip, {
+		placement: toPlacement(side, align),
+		offset: sideOffset,
+		...defined({ UNSTABLE_portalContainer: container ?? void 0 }),
+		render: (p, rp) => {
+			const s = {
+				entering: rp.isEntering,
+				exiting: rp.isExiting,
+				side: resolveSide(rp.placement, side, direction)
+			};
+			const engine = {
+				...engineDom(p),
+				style: popupStyle(p.style)
+			};
+			const attrs = stateAttrs({
+				open: rp.state.isOpen,
+				...s,
+				align
+			});
+			return render(mergeProps(engine, dom, attrs), s);
+		},
+		children
+	}, instantlyClosed(use(TooltipTriggerStateContext)) ? "instant" : "live");
+};
+//#endregion
+export { Popup, Root, Trigger };

package/dist/_internal/cx.js

@@ -0,0 +1,11 @@
+//#region src/_internal/cx.ts
+/** Joins class names, skipping empty values and repeated classes. Never exported from the package. */
+function cx(...parts) {
+	const classes = /* @__PURE__ */ new Set();
+	for (const part of parts) if (part) {
+		for (const name of part.split(/\s+/)) if (name !== "") classes.add(name);
+	}
+	return [...classes].join(" ");
+}
+//#endregion
+export { cx };

package/dist/_internal/data-status.d.ts

@@ -0,0 +1,3 @@
+//#region src/_internal/data-status.d.ts
+export type DataStatus = "ready" | "loading" | "empty" | "error";
+//#endregion

package/dist/_internal/data-status.js

@@ -0,0 +1,13 @@
+//#region src/_internal/data-status.ts
+/** The §16.5 attributes for a resolved status (ready with no value is 'empty' upstream). */
+function dataStatusAttrs(status, pending) {
+	return {
+		"data-loading": status === "loading" ? "" : void 0,
+		"data-empty": status === "empty" ? "" : void 0,
+		"data-error": status === "error" ? "" : void 0,
+		"data-pending": pending ? "" : void 0,
+		"aria-busy": status === "loading" || pending || void 0
+	};
+}
+//#endregion
+export { dataStatusAttrs };

package/dist/_internal/engine-part.d.ts

@@ -0,0 +1 @@
+import { ComponentPropsWithRef, JSX, ReactElement, ReactNode } from "react";

package/dist/_internal/field.js

@@ -0,0 +1,20 @@
+//#region src/_internal/field.ts
+/**
+* Whether a message node renders something. `null`, `undefined`, booleans and `''` render nothing,
+* so `error={failed && 'Enter a price'}` presents no error when `failed` is false.
+*/
+function presented(node) {
+	return node != null && typeof node !== "boolean" && node !== "";
+}
+/** Joins id references for `aria-describedby`, skipping empty ones; `undefined` when none remain. */
+function joinIds(...ids) {
+	const joined = ids.filter((id) => typeof id === "string" && id !== "").join(" ");
+	return joined === "" ? void 0 : joined;
+}
+/**
+* Marks a server-safe control (NativeSelect) that Field wires as plain props when it is placed
+* directly inside, as if it were a function child: zero JS, and the label still points at it.
+*/
+const FIELD_CONTROL = Symbol.for("nizivo.field-control");
+//#endregion
+export { FIELD_CONTROL, joinIds, presented };