@krelborn/stylesui 0.8.1 → 0.9.0

package/dist/components/Combobox/autocompleteKeys.js

@@ -0,0 +1,25 @@
+import { hasModifier as e } from "../../menus/hasModifier.js";
+import { isAltArrow as t } from "./isAltArrow.js";
+// src/components/Combobox/autocompleteKeys.ts
+function n(n, i, a) {
+	if (n.nativeEvent.isComposing || n.keyCode === 229) return !1;
+	if (t(n, "ArrowDown")) return i.open || i.openList("none", "keyboard"), !0;
+	if (t(n, "ArrowUp")) {
+		let e = i.open;
+		return i.commitActive(), e;
+	}
+	return !e(n) && r(n.key, i, a);
+}
+function r(e, t, n) {
+	return e === "ArrowDown" || e === "ArrowUp" ? i(e, t) : e === "Enter" ? a(t, n) : e === "Escape" ? o(t, n) : (e === "Tab" && t.close(), !1);
+}
+function i(e, t) {
+	return t.open ? t.moveByKey(e) : (t.openList(e === "ArrowDown" ? "first" : "last", "keyboard"), !0);
+}
+function a(e, t) {
+	return e.activeDescendant === void 0 ? t.editing && t.shown !== "" : (e.commitActive(), !0);
+}
+function o(e, t) {
+	return e.open ? (e.close(), !0) : t.shown === "" && e.selectedValue === null ? !1 : (e.select(null), t.commit(""), !0);
+}
+export { n as handleAutocompleteKey };

package/dist/components/Combobox/comboboxKeys.d.ts

@@ -0,0 +1,10 @@
+import type { KeyboardEvent } from "react";
+import type { ComboboxList } from "./useComboboxList";
+/**
+ * Acts on a key pressed on a `Combobox`'s field
+ *
+ * @param event the key event
+ * @param list the combobox's list
+ * @returns whether the key was handled, so its default should be prevented
+ */
+export declare function handleComboboxKey(event: KeyboardEvent<HTMLElement>, list: ComboboxList): boolean;

package/dist/components/Combobox/comboboxKeys.js

@@ -0,0 +1,22 @@
+import { hasModifier as e } from "../../menus/hasModifier.js";
+import { isAltArrow as t } from "./isAltArrow.js";
+// src/components/Combobox/comboboxKeys.ts
+var n = {
+	" ": "selected",
+	ArrowDown: "selected",
+	ArrowUp: "selected",
+	End: "last",
+	Enter: "selected",
+	Home: "first"
+};
+function r(e, t) {
+	return t.open ? a(e, t) : i(e, t);
+}
+function i(r, i) {
+	let a = n[r.key];
+	return t(r, "ArrowDown") ? (i.openList("none", "keyboard"), !0) : e(r) ? !1 : a === void 0 ? Array.from(r.key).length === 1 && (i.openList("selected", "keyboard"), i.typeAhead(r.key), !0) : (i.openList(a, "keyboard"), !0);
+}
+function a(n, r) {
+	return n.key === "Tab" || n.key === "Escape" ? (r.close(), n.key === "Escape") : t(n, "ArrowUp") ? (r.commitActive(), !0) : e(n) ? !1 : n.key === "Enter" || n.key === " " && !r.isTypingAhead() ? (r.commitActive(), !0) : r.moveByKey(n.key) || r.typeAhead(n.key);
+}
+export { r as handleComboboxKey };

package/dist/components/Combobox/containsText.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Tests whether an option's text contains the typed text, ignoring case, accents and the typed text's surrounding
+ * spaces: an `Autocomplete`'s default filter
+ *
+ * @param textValue the option's text
+ * @param inputValue the typed text
+ * @returns true when the option shows
+ */
+export declare function containsText(textValue: string, inputValue: string): boolean;

package/dist/components/Combobox/containsText.js

@@ -0,0 +1,8 @@
+// src/components/Combobox/containsText.ts
+function e(e, n) {
+	return t(e).includes(t(n.trim()));
+}
+function t(e) {
+	return e.normalize("NFD").replace(/\p{Diacritic}/gu, "").toLocaleLowerCase();
+}
+export { e as containsText };

package/dist/components/Combobox/index.d.ts

@@ -0,0 +1,6 @@
+export { Autocomplete } from "./Autocomplete";
+export type { AutocompleteProps } from "./Autocomplete";
+export { Combobox } from "./Combobox";
+export type { ComboboxProps } from "./Combobox";
+export { ComboboxOption } from "./ComboboxOption";
+export type { ComboboxOptionProps } from "./ComboboxOption";

package/dist/components/Combobox/isAltArrow.d.ts

@@ -0,0 +1,9 @@
+import type { KeyboardEvent } from "react";
+/**
+ * Whether a key is an arrow pressed with Alt alone, which opens or commits a combobox's list
+ *
+ * @param event the key event
+ * @param key the arrow
+ * @returns true for that arrow with Alt and neither Ctrl nor Meta
+ */
+export declare function isAltArrow(event: KeyboardEvent<HTMLElement>, key: "ArrowDown" | "ArrowUp"): boolean;

package/dist/components/Combobox/isAltArrow.js

@@ -0,0 +1,5 @@
+// src/components/Combobox/isAltArrow.ts
+function e(e, t) {
+	return e.key === t && e.altKey && !e.ctrlKey && !e.metaKey;
+}
+export { e as isAltArrow };

package/dist/components/Combobox/isOptionShown.d.ts

@@ -0,0 +1,10 @@
+import type { ComboboxFilter } from "./ComboboxContext";
+/**
+ * Whether an option shows for the typed text
+ *
+ * @param filter the combobox's filter, or null to show every option
+ * @param query the typed text
+ * @param text the option's text
+ * @returns true when there is no filter or no text, or the filter accepts the option
+ */
+export declare function isOptionShown(filter: ComboboxFilter | null, query: string, text: string): boolean;

package/dist/components/Combobox/isOptionShown.js

@@ -0,0 +1,5 @@
+// src/components/Combobox/isOptionShown.ts
+function e(e, t, n) {
+	return e === null || t === "" || e(n, t);
+}
+export { e as isOptionShown };

package/dist/components/Combobox/useAutocompleteText.d.ts

@@ -0,0 +1,56 @@
+interface UseAutocompleteTextOptions {
+    /**
+     * The text the input starts with when uncontrolled
+     */
+    defaultInputValue: string | undefined;
+    /**
+     * The input's text when controlled
+     */
+    inputValue: string | undefined;
+    /**
+     * Called with each new text
+     */
+    onInputValueChange: ((inputValue: string) => void) | undefined;
+    /**
+     * The selected option's text, or undefined for none or one that has not rendered
+     */
+    selectedText: string | undefined;
+}
+/**
+ * An `Autocomplete`'s text and the ways it changes
+ */
+interface AutocompleteText {
+    /**
+     * Puts an option's text in the input as the user commits it
+     */
+    commit: (text: string) => void;
+    /**
+     * Takes the text the user typed
+     */
+    edit: (text: string) => void;
+    /**
+     * Whether the input holds text other than the selection's: typed since the last choice, or, when controlled, any
+     * text the parent gives that is not the selected option's
+     */
+    editing: boolean;
+    /**
+     * The text the options are filtered by: the input's while editing, or empty while it shows the selection
+     */
+    query: string;
+    /**
+     * Shows the selection's text again, after editing that chose nothing
+     */
+    restore: () => void;
+    /**
+     * The text the input shows
+     */
+    shown: string;
+}
+/**
+ * Holds what the user is typing in an `Autocomplete`, apart from the selection's text, which the input shows otherwise
+ *
+ * @param options the controlled or starting text, the change callback and the selection's text
+ * @returns the text and the ways it changes
+ */
+export declare function useAutocompleteText({ defaultInputValue, inputValue, onInputValueChange, selectedText, }: UseAutocompleteTextOptions): AutocompleteText;
+export {};

package/dist/components/Combobox/useAutocompleteText.js

@@ -0,0 +1,27 @@
+import { useState as e } from "react";
+import { c as t } from "react/compiler-runtime";
+// src/components/Combobox/useAutocompleteText.ts
+function n(n) {
+	let r = t(15), { defaultInputValue: i, inputValue: a, onInputValueChange: o, selectedText: s } = n, [c, l] = e(i ?? null), u = a ?? c ?? s ?? "", d = a === void 0 ? c !== null : a !== (s ?? ""), f;
+	r[0] === o ? f = r[1] : (f = function(e) {
+		l(e), o?.(e);
+	}, r[0] = o, r[1] = f);
+	let p = f, m;
+	r[2] === o ? m = r[3] : (m = function(e) {
+		l(null), o?.(e);
+	}, r[2] = o, r[3] = m);
+	let h = m, g;
+	r[4] !== h || r[5] !== d || r[6] !== s ? (g = function() {
+		d && h(s ?? "");
+	}, r[4] = h, r[5] = d, r[6] = s, r[7] = g) : g = r[7];
+	let _ = g, v = d ? u : "", y;
+	return r[8] !== h || r[9] !== p || r[10] !== d || r[11] !== _ || r[12] !== u || r[13] !== v ? (y = {
+		commit: h,
+		edit: p,
+		editing: d,
+		query: v,
+		restore: _,
+		shown: u
+	}, r[8] = h, r[9] = p, r[10] = d, r[11] = _, r[12] = u, r[13] = v, r[14] = y) : y = r[14], y;
+}
+export { n as useAutocompleteText };

package/dist/components/Combobox/useComboboxContext.d.ts

@@ -0,0 +1,9 @@
+import type { ComboboxContextValue } from "./ComboboxContext";
+/**
+ * Reads the state of the surrounding `Combobox` or `Autocomplete`
+ *
+ * @param part the name of the part reading it, for the error message
+ * @returns the surrounding combobox's state
+ * @throws MissingContextError when the part is not inside a `Combobox` or `Autocomplete`
+ */
+export declare function useComboboxContext(part: string): ComboboxContextValue;

package/dist/components/Combobox/useComboboxContext.js

@@ -0,0 +1,10 @@
+import { MissingContextError as e } from "../../errors/MissingContextError.js";
+import { ComboboxContext as t } from "./ComboboxContext.js";
+import { useContext as n } from "react";
+// src/components/Combobox/useComboboxContext.ts
+function r(r) {
+	let i = n(t);
+	if (i === null) throw new e(r, "Combobox or Autocomplete");
+	return i;
+}
+export { r as useComboboxContext };

package/dist/components/Combobox/useComboboxList.d.ts

@@ -0,0 +1,129 @@
+import type { ActiveSource, ComboboxContextValue, ComboboxFilter, SelectedContent } from "./ComboboxContext";
+import type { ComboboxSelection } from "./useComboboxSelection";
+/**
+ * Which option is active as the list opens: the selected one (else the first), the first, the last, or none
+ */
+export type OpeningActive = "first" | "last" | "none" | "selected";
+interface UseComboboxListOptions {
+    /**
+     * The control's own id, or a surrounding field's; without one, the list generates it
+     */
+    controlId: string | undefined;
+    /**
+     * Whether an option shows for the typed text, or null to show every option
+     */
+    filter: ComboboxFilter | null;
+    /**
+     * Called with an option's text when the user commits it
+     */
+    onCommit?: (text: string) => void;
+    /**
+     * The text the options are filtered by; empty shows every option
+     */
+    query: string;
+    /**
+     * The combobox's selection, from `useComboboxSelection`
+     */
+    selection: ComboboxSelection;
+}
+/**
+ * A combobox's list: its open state, active option and selection, and the actions its control's keys and pointer take
+ */
+export interface ComboboxList {
+    /**
+     * The id of the active option while the list is open, for the control's `aria-activedescendant`
+     */
+    activeDescendant: string | undefined;
+    /**
+     * The generated id the list's ids start with
+     */
+    baseId: string;
+    /**
+     * Closes the list without committing
+     */
+    close: () => void;
+    /**
+     * Commits the active option and closes the list, unless the option is disabled; with no active option, closes it
+     */
+    commitActive: () => void;
+    /**
+     * The state the list's options read
+     */
+    context: ComboboxContextValue;
+    /**
+     * The control's id
+     */
+    controlId: string;
+    /**
+     * Counts the options the filter shows
+     */
+    countShown: () => number;
+    /**
+     * Whether Space would join a type-ahead query now rather than act
+     */
+    isTypingAhead: () => boolean;
+    /**
+     * The list's id, for the control's `aria-controls`
+     */
+    listId: string;
+    /**
+     * Takes the `listbox` element, as its `ref`
+     */
+    attachList: (listbox: HTMLDivElement | null) => void;
+    /**
+     * Makes the first option the filter shows, and that is not disabled, active once the next render has filtered the
+     * options by the query it brings, which a parent controlling the text may have changed; with no filter or no query,
+     * makes none active
+     */
+    matchFirst: () => void;
+    /**
+     * Moves the active option for an arrow key, Home or End, without wrapping
+     *
+     * @returns whether the key was one of those
+     */
+    moveByKey: (key: string) => boolean;
+    /**
+     * Whether the list is open
+     */
+    open: boolean;
+    /**
+     * Opens the list
+     *
+     * @param opening which option becomes active
+     * @param source what opened it, which decides whether the active option shows the focus ring
+     */
+    openList: (opening: OpeningActive, source: ActiveSource) => void;
+    /**
+     * Selects a value, or none, reporting it unless it is already selected
+     */
+    select: (value: string | null) => void;
+    /**
+     * What the selected option shows in the field, or null when it is not rendered
+     */
+    selectedContent: SelectedContent | null;
+    /**
+     * The selected value, or null for none
+     */
+    selectedValue: string | null;
+    /**
+     * Closes the list if it was open, or opens it on the selected option
+     *
+     * @param wasOpen whether the list was open when the user asked to toggle it
+     * @param source what toggled it, which decides whether the active option shows the focus ring
+     */
+    toggleList: (wasOpen: boolean, source: ActiveSource) => void;
+    /**
+     * Moves the active option by type-ahead for a printable character, from the active option or else the selected one
+     *
+     * @returns whether the key was a character type-ahead took
+     */
+    typeAhead: (key: string) => boolean;
+}
+/**
+ * Holds the state of a combobox's list, which `Combobox` and `Autocomplete` share
+ *
+ * @param options the control's id, the selection, the filter and its query, and the commit callback
+ * @returns the list's state and actions
+ */
+export declare function useComboboxList({ controlId, filter, onCommit, query, selection, }: UseComboboxListOptions): ComboboxList;
+export {};

package/dist/components/Combobox/useComboboxList.js

@@ -0,0 +1,138 @@
+import { extendTypeAheadQuery as e, isTypeAheadQueryLive as t, typeAheadTarget as n } from "../../collections/typeAhead.js";
+import { optionId as r } from "../../collections/optionId.js";
+import { renderedOptions as i } from "../../collections/renderedOptions.js";
+import { targetIndexForKey as a } from "../../collections/targetIndexForKey.js";
+import { useEffect as o, useEffectEvent as s, useId as c, useLayoutEffect as l, useRef as u, useState as d } from "react";
+// src/components/Combobox/useComboboxList.ts
+var f = {
+	block: "nearest",
+	container: "nearest"
+};
+function p({ controlId: p, filter: m, onCommit: h, query: g, selection: _ }) {
+	let v = c(), y = `${v}-list`, b = u(null), x = u(null), S = u(!1), C = u(!1), [w, T] = d(!1), [E, D] = d(null), { select: O, selectedContent: k, selectedValue: A, setSelectedContent: j } = _, M = s((e) => {
+		let t = m === null || g === "" ? void 0 : e.find((e) => !e.disabled);
+		D(t === void 0 ? null : {
+			source: "keyboard",
+			value: t.value
+		});
+	}), N = s((e) => {
+		E !== null && !e.some((e) => e.value === E.value) && D(null);
+	});
+	l(() => {
+		let e = P();
+		b.current?.toggleAttribute("data-empty", e.length === 0), C.current ? (C.current = !1, M(e)) : N(e);
+	}), o(() => {
+		if (!w) return;
+		let e = E !== null && (E.source === "keyboard" || S.current);
+		S.current = !1, e && P().find((e) => e.value === E.value)?.element.scrollIntoView(f);
+	}, [E, w]);
+	function P() {
+		return b.current === null ? [] : i(b.current);
+	}
+	function F(e, t, n) {
+		let r = e.at(t);
+		D(r === void 0 || t < 0 ? null : {
+			source: n,
+			value: r.value
+		});
+	}
+	function I(e) {
+		let t = e.findIndex((e) => e.value === E?.value);
+		return t === -1 ? e.findIndex((e) => e.value === A) : t;
+	}
+	function L(e, t) {
+		let n = P(), r = Math.max(n.findIndex((e) => e.value === A), 0), i = {
+			first: 0,
+			last: n.length - 1,
+			none: -1,
+			selected: r
+		};
+		S.current = !0, T(!0), F(n, i[e], t);
+	}
+	function R(e, t) {
+		e ? z() : L("selected", t);
+	}
+	function z() {
+		T(!1), D(null);
+	}
+	function B(e) {
+		let t = P().find((t) => t.value === e);
+		O(e), h?.(t?.textValue ?? ""), z();
+	}
+	function V() {
+		let e = P().find((e) => e.value === E?.value);
+		e === void 0 ? z() : e.disabled || B(e.value);
+	}
+	function H(e) {
+		let t = P(), n = t.findIndex((e) => e.value === E?.value), r = n === -1 && e === "ArrowUp" ? t.length - 1 : a({
+			count: t.length,
+			currentIndex: n,
+			key: e,
+			orientation: "vertical",
+			wraps: !1
+		});
+		return r === null || r === -1 ? [
+			"ArrowDown",
+			"ArrowUp",
+			"End",
+			"Home"
+		].includes(e) : (F(t, r, "keyboard"), !0);
+	}
+	function U() {
+		return t(x.current, Date.now());
+	}
+	function W(r) {
+		let i = Date.now();
+		if (Array.from(r).length !== 1 || r === " " && !t(x.current, i)) return !1;
+		x.current = e(x.current, r, i);
+		let a = P(), o = a.map((e) => e.textValue), s = n(o, I(a), x.current.text);
+		return s !== null && F(a, s, "keyboard"), !0;
+	}
+	function G() {
+		return P().length;
+	}
+	function K() {
+		C.current = !0;
+	}
+	function q(e) {
+		b.current = e;
+	}
+	function J(e) {
+		D({
+			source: "pointer",
+			value: e
+		});
+	}
+	return {
+		activeDescendant: w && E !== null ? r(v, E.value) : void 0,
+		attachList: q,
+		baseId: v,
+		close: z,
+		commitActive: V,
+		context: {
+			activateFromPointer: J,
+			active: E,
+			baseId: v,
+			commit: B,
+			filter: m,
+			query: g,
+			selectedValue: A,
+			setActive: D,
+			setSelectedContent: j
+		},
+		controlId: p ?? `${v}-control`,
+		countShown: G,
+		isTypingAhead: U,
+		listId: y,
+		matchFirst: K,
+		moveByKey: H,
+		open: w,
+		openList: L,
+		select: O,
+		selectedContent: k,
+		selectedValue: A,
+		toggleList: R,
+		typeAhead: W
+	};
+}
+export { p as useComboboxList };

package/dist/components/Combobox/useComboboxOption.d.ts

@@ -0,0 +1,35 @@
+import type { ReactNode, RefObject } from "react";
+interface UseComboboxOptionOptions {
+    /**
+     * The option's label
+     */
+    children: ReactNode;
+    /**
+     * The option's leading content
+     */
+    leading: ReactNode;
+    /**
+     * The option element
+     */
+    optionRef: RefObject<HTMLDivElement | null>;
+    /**
+     * Whether the option is selected
+     */
+    selected: boolean;
+    /**
+     * The text the consumer gave the option, if any
+     */
+    textValue: string | undefined;
+    /**
+     * The option's value
+     */
+    value: string;
+}
+/**
+ * Keeps an option in step with its combobox: shown or hidden for the filter, showing itself in the field while
+ * selected, and no longer active once it unmounts
+ *
+ * @param options the option's state, content and element
+ */
+export declare function useComboboxOption({ children, leading, optionRef, selected, textValue, value, }: UseComboboxOptionOptions): void;
+export {};

package/dist/components/Combobox/useComboboxOption.js

@@ -0,0 +1,46 @@
+import { optionTextValue as e } from "../../collections/renderedOptions.js";
+import { isOptionShown as t } from "./isOptionShown.js";
+import { useComboboxContext as n } from "./useComboboxContext.js";
+import { useLayoutEffect as r } from "react";
+import { c as i } from "react/compiler-runtime";
+// src/components/Combobox/useComboboxOption.ts
+function a(a) {
+	let o = i(29), { children: s, leading: c, optionRef: l, selected: u, textValue: d, value: f } = a, { filter: p, query: m, setActive: h, setSelectedContent: g } = n("ComboboxOption"), _;
+	o[0] !== p || o[1] !== l || o[2] !== m ? (_ = () => {
+		let n = l.current;
+		n !== null && (n.hidden = !t(p, m, e(n)));
+	}, o[0] = p, o[1] = l, o[2] = m, o[3] = _) : _ = o[3];
+	let v;
+	o[4] !== s || o[5] !== p || o[6] !== l || o[7] !== m || o[8] !== d ? (v = [
+		s,
+		p,
+		l,
+		m,
+		d
+	], o[4] = s, o[5] = p, o[6] = l, o[7] = m, o[8] = d, o[9] = v) : v = o[9], r(_, v);
+	let y;
+	o[10] !== s || o[11] !== c || o[12] !== l || o[13] !== u || o[14] !== g || o[15] !== f ? (y = () => {
+		let t = l.current;
+		u && t !== null && g({
+			label: s,
+			leading: c,
+			text: e(t),
+			value: f
+		});
+	}, o[10] = s, o[11] = c, o[12] = l, o[13] = u, o[14] = g, o[15] = f, o[16] = y) : y = o[16];
+	let b;
+	o[17] !== s || o[18] !== c || o[19] !== l || o[20] !== u || o[21] !== g || o[22] !== d || o[23] !== f ? (b = [
+		s,
+		c,
+		l,
+		u,
+		g,
+		d,
+		f
+	], o[17] = s, o[18] = c, o[19] = l, o[20] = u, o[21] = g, o[22] = d, o[23] = f, o[24] = b) : b = o[24], r(y, b);
+	let x, S;
+	o[25] !== h || o[26] !== f ? (x = () => () => {
+		h((e) => e?.value === f ? null : e);
+	}, S = [h, f], o[25] = h, o[26] = f, o[27] = x, o[28] = S) : (x = o[27], S = o[28]), r(x, S);
+}
+export { a as useComboboxOption };

package/dist/components/Combobox/useComboboxSelection.d.ts

@@ -0,0 +1,45 @@
+import type { Dispatch, SetStateAction } from "react";
+import type { SelectedContent } from "./ComboboxContext";
+interface UseComboboxSelectionOptions {
+    /**
+     * The value selected at first when uncontrolled
+     */
+    defaultValue: string | null;
+    /**
+     * Called with the new selection
+     */
+    onValueChange: ((value: string | null) => void) | undefined;
+    /**
+     * The selected value when controlled, or undefined when uncontrolled
+     */
+    value: string | null | undefined;
+}
+/**
+ * A combobox's selection and what its selected option shows
+ */
+export interface ComboboxSelection {
+    /**
+     * Selects a value, or none, reporting it unless it is already selected
+     */
+    select: (value: string | null) => void;
+    /**
+     * What the selected option shows in the field, or null when it has not rendered
+     */
+    selectedContent: SelectedContent | null;
+    /**
+     * The selected value, or null for none
+     */
+    selectedValue: string | null;
+    /**
+     * Sets what the selected option shows, which it hands over as it renders
+     */
+    setSelectedContent: Dispatch<SetStateAction<SelectedContent | null>>;
+}
+/**
+ * Holds a combobox's selection, controlled or uncontrolled, and what the selected option shows in the field
+ *
+ * @param options the selection props and the change callback
+ * @returns the selection and the ways it changes
+ */
+export declare function useComboboxSelection({ defaultValue, onValueChange, value, }: UseComboboxSelectionOptions): ComboboxSelection;
+export {};

package/dist/components/Combobox/useComboboxSelection.js

@@ -0,0 +1,17 @@
+import { useState as e } from "react";
+import { c as t } from "react/compiler-runtime";
+// src/components/Combobox/useComboboxSelection.ts
+function n(n) {
+	let r = t(8), { defaultValue: i, onValueChange: a, value: o } = n, [s, c] = e(i), [l, u] = e(null), d = o === void 0 ? s : o, f;
+	r[0] !== a || r[1] !== d || r[2] !== o ? (f = function(e) {
+		e !== d && (o === void 0 && c(e), a?.(e));
+	}, r[0] = a, r[1] = d, r[2] = o, r[3] = f) : f = r[3];
+	let p = f, m = l?.value === d ? l : null, h;
+	return r[4] !== p || r[5] !== d || r[6] !== m ? (h = {
+		select: p,
+		selectedContent: m,
+		selectedValue: d,
+		setSelectedContent: u
+	}, r[4] = p, r[5] = d, r[6] = m, r[7] = h) : h = r[7], h;
+}
+export { n as useComboboxSelection };

package/dist/components/Combobox/useResultsAnnouncement.d.ts

@@ -0,0 +1,23 @@
+/**
+ * What an `Autocomplete`'s live region says
+ */
+interface ResultsAnnouncement {
+    /**
+     * The live region's text
+     */
+    announcement: string;
+    /**
+     * Says how many options match once typing pauses while the list stays open, replacing any count still to come
+     */
+    announceCount: () => void;
+}
+/**
+ * Announces how many options match once typing pauses for the type-ahead window
+ *
+ * @param resultsLabel the words for a number of matches
+ * @param countShown counts the options the filter shows
+ * @param listOpen whether the list is open; a count still to come is dropped as it closes
+ * @returns the live region's text and a way to announce the count
+ */
+export declare function useResultsAnnouncement(resultsLabel: (count: number) => string, countShown: () => number, listOpen: boolean): ResultsAnnouncement;
+export {};