@sprawlify/primitives 0.0.1

package/dist/machines/listbox/index.cjs

@@ -0,0 +1,794 @@
+const require_create_anatomy = require('../../create-anatomy-CDsIFUXg.cjs');
+const require_dom_query = require('../../dom-query-CWZdWUGp.cjs');
+const require_utils = require('../../utils-_6frwjgJ.cjs');
+const require_collection = require('../../collection-DIoIDISa.cjs');
+const require_core = require('../../core-CQFbMdTl.cjs');
+const require_focus_visible = require('../../focus-visible-DYTWdWpa.cjs');
+const require_create_props = require('../../create-props-YKy7JIKj.cjs');
+
+//#region src/machines/listbox/listbox.anatomy.ts
+const anatomy = require_create_anatomy.createAnatomy("listbox").parts("label", "input", "item", "itemText", "itemIndicator", "itemGroup", "itemGroupLabel", "content", "root", "valueText");
+const parts = anatomy.build();
+
+//#endregion
+//#region src/machines/listbox/listbox.collection.ts
+const collection = (options) => {
+	return new require_collection.ListCollection(options);
+};
+collection.empty = () => {
+	return new require_collection.ListCollection({ items: [] });
+};
+const gridCollection = (options) => {
+	return new require_collection.GridCollection(options);
+};
+gridCollection.empty = () => {
+	return new require_collection.GridCollection({
+		items: [],
+		columnCount: 0
+	});
+};
+
+//#endregion
+//#region src/machines/listbox/listbox.dom.ts
+const getRootId = (ctx) => ctx.ids?.root ?? `listbox:${ctx.id}`;
+const getContentId = (ctx) => ctx.ids?.content ?? `listbox:${ctx.id}:content`;
+const getLabelId = (ctx) => ctx.ids?.label ?? `listbox:${ctx.id}:label`;
+const getItemId = (ctx, id) => ctx.ids?.item?.(id) ?? `listbox:${ctx.id}:item:${id}`;
+const getItemGroupId = (ctx, id) => ctx.ids?.itemGroup?.(id) ?? `listbox:${ctx.id}:item-group:${id}`;
+const getItemGroupLabelId = (ctx, id) => ctx.ids?.itemGroupLabel?.(id) ?? `listbox:${ctx.id}:item-group-label:${id}`;
+const getContentEl = (ctx) => ctx.getById(getContentId(ctx));
+const getItemEl = (ctx, id) => ctx.getById(getItemId(ctx, id));
+
+//#endregion
+//#region src/machines/listbox/listbox.connect.ts
+function connect(service, normalize) {
+	const { context, prop, scope, computed, send, refs } = service;
+	const disabled = prop("disabled");
+	const collection$1 = prop("collection");
+	const layout = require_collection.isGridCollection(collection$1) ? "grid" : "list";
+	const focused = context.get("focused");
+	const focusVisible = refs.get("focusVisible") && focused;
+	const inputState = refs.get("inputState");
+	const value = context.get("value");
+	const selectedItems = context.get("selectedItems");
+	const highlightedValue = context.get("highlightedValue");
+	const highlightedItem = context.get("highlightedItem");
+	const isTypingAhead = computed("isTypingAhead");
+	const interactive = computed("isInteractive");
+	const ariaActiveDescendant = highlightedValue ? getItemId(scope, highlightedValue) : void 0;
+	function getItemState(props$1) {
+		const itemDisabled = collection$1.getItemDisabled(props$1.item);
+		const value$1 = collection$1.getItemValue(props$1.item);
+		require_utils.ensure(value$1, () => `[sprawlify-js] No value found for item ${JSON.stringify(props$1.item)}`);
+		const highlighted = highlightedValue === value$1;
+		return {
+			value: value$1,
+			disabled: Boolean(disabled || itemDisabled),
+			focused: highlighted && focused,
+			focusVisible: highlighted && focusVisible,
+			highlighted: highlighted && (inputState.focused ? focused : focusVisible),
+			selected: context.get("value").includes(value$1)
+		};
+	}
+	return {
+		empty: value.length === 0,
+		highlightedItem,
+		highlightedValue,
+		clearHighlightedValue() {
+			send({
+				type: "HIGHLIGHTED_VALUE.SET",
+				value: null
+			});
+		},
+		selectedItems,
+		hasSelectedItems: computed("hasSelectedItems"),
+		value,
+		valueAsString: computed("valueAsString"),
+		collection: collection$1,
+		disabled: !!disabled,
+		selectValue(value$1) {
+			send({
+				type: "ITEM.SELECT",
+				value: value$1
+			});
+		},
+		setValue(value$1) {
+			send({
+				type: "VALUE.SET",
+				value: value$1
+			});
+		},
+		selectAll() {
+			if (!computed("multiple")) throw new Error("[sprawlify-js] Cannot select all items in a single-select listbox");
+			send({
+				type: "VALUE.SET",
+				value: collection$1.getValues()
+			});
+		},
+		highlightValue(value$1) {
+			send({
+				type: "HIGHLIGHTED_VALUE.SET",
+				value: value$1
+			});
+		},
+		clearValue(value$1) {
+			if (value$1) send({
+				type: "ITEM.CLEAR",
+				value: value$1
+			});
+			else send({ type: "VALUE.CLEAR" });
+		},
+		getItemState,
+		getRootProps() {
+			return normalize.element({
+				...parts.root.attrs,
+				dir: prop("dir"),
+				id: getRootId(scope),
+				"data-orientation": prop("orientation"),
+				"data-disabled": require_dom_query.dataAttr(disabled)
+			});
+		},
+		getInputProps(props$1 = {}) {
+			return normalize.input({
+				...parts.input.attrs,
+				dir: prop("dir"),
+				disabled,
+				"data-disabled": require_dom_query.dataAttr(disabled),
+				autoComplete: "off",
+				autoCorrect: "off",
+				"aria-haspopup": "listbox",
+				"aria-controls": getContentId(scope),
+				"aria-autocomplete": "list",
+				"aria-activedescendant": ariaActiveDescendant,
+				spellCheck: false,
+				enterKeyHint: "go",
+				onFocus() {
+					queueMicrotask(() => {
+						send({
+							type: "INPUT.FOCUS",
+							autoHighlight: !!props$1?.autoHighlight
+						});
+					});
+				},
+				onBlur() {
+					send({
+						type: "CONTENT.BLUR",
+						src: "input"
+					});
+				},
+				onInput(event) {
+					if (!props$1?.autoHighlight) return;
+					if (event.currentTarget.value.trim()) return;
+					queueMicrotask(() => {
+						send({
+							type: "HIGHLIGHTED_VALUE.SET",
+							value: null
+						});
+					});
+				},
+				onKeyDown(event) {
+					if (event.defaultPrevented) return;
+					if (require_dom_query.isComposingEvent(event)) return;
+					const nativeEvent = require_dom_query.getNativeEvent(event);
+					const forwardEvent = () => {
+						event.preventDefault();
+						const keyboardEvent = new (scope.getWin()).KeyboardEvent(nativeEvent.type, nativeEvent);
+						getContentEl(scope)?.dispatchEvent(keyboardEvent);
+					};
+					switch (nativeEvent.key) {
+						case "ArrowLeft":
+						case "ArrowRight":
+							if (!require_collection.isGridCollection(collection$1)) return;
+							if (event.ctrlKey) return;
+							forwardEvent();
+						case "Home":
+						case "End":
+							if (highlightedValue == null && event.shiftKey) return;
+							forwardEvent();
+						case "ArrowDown":
+						case "ArrowUp":
+							forwardEvent();
+							break;
+						case "Enter":
+							if (highlightedValue != null) {
+								event.preventDefault();
+								send({
+									type: "ITEM.CLICK",
+									value: highlightedValue
+								});
+							}
+							break;
+						default: break;
+					}
+				}
+			});
+		},
+		getLabelProps() {
+			return normalize.element({
+				dir: prop("dir"),
+				id: getLabelId(scope),
+				...parts.label.attrs,
+				"data-disabled": require_dom_query.dataAttr(disabled)
+			});
+		},
+		getValueTextProps() {
+			return normalize.element({
+				...parts.valueText.attrs,
+				dir: prop("dir"),
+				"data-disabled": require_dom_query.dataAttr(disabled)
+			});
+		},
+		getItemProps(props$1) {
+			const itemState = getItemState(props$1);
+			return normalize.element({
+				id: getItemId(scope, itemState.value),
+				role: "option",
+				...parts.item.attrs,
+				dir: prop("dir"),
+				"data-value": itemState.value,
+				"aria-selected": itemState.selected,
+				"data-selected": require_dom_query.dataAttr(itemState.selected),
+				"data-layout": layout,
+				"data-state": itemState.selected ? "checked" : "unchecked",
+				"data-orientation": prop("orientation"),
+				"data-highlighted": require_dom_query.dataAttr(itemState.highlighted),
+				"data-disabled": require_dom_query.dataAttr(itemState.disabled),
+				"aria-disabled": require_dom_query.ariaAttr(itemState.disabled),
+				onPointerMove(event) {
+					if (!props$1.highlightOnHover) return;
+					if (itemState.disabled || event.pointerType !== "mouse") return;
+					if (itemState.highlighted) return;
+					send({
+						type: "ITEM.POINTER_MOVE",
+						value: itemState.value
+					});
+				},
+				onMouseDown(event) {
+					event.preventDefault();
+					getContentEl(scope)?.focus();
+				},
+				onClick(event) {
+					if (event.defaultPrevented) return;
+					if (itemState.disabled) return;
+					send({
+						type: "ITEM.CLICK",
+						value: itemState.value,
+						shiftKey: event.shiftKey,
+						anchorValue: highlightedValue,
+						metaKey: require_dom_query.isCtrlOrMetaKey(event)
+					});
+				}
+			});
+		},
+		getItemTextProps(props$1) {
+			const itemState = getItemState(props$1);
+			return normalize.element({
+				...parts.itemText.attrs,
+				"data-state": itemState.selected ? "checked" : "unchecked",
+				"data-disabled": require_dom_query.dataAttr(itemState.disabled),
+				"data-highlighted": require_dom_query.dataAttr(itemState.highlighted)
+			});
+		},
+		getItemIndicatorProps(props$1) {
+			const itemState = getItemState(props$1);
+			return normalize.element({
+				...parts.itemIndicator.attrs,
+				"aria-hidden": true,
+				"data-state": itemState.selected ? "checked" : "unchecked",
+				hidden: !itemState.selected
+			});
+		},
+		getItemGroupLabelProps(props$1) {
+			const { htmlFor } = props$1;
+			return normalize.element({
+				...parts.itemGroupLabel.attrs,
+				id: getItemGroupLabelId(scope, htmlFor),
+				dir: prop("dir"),
+				role: "presentation"
+			});
+		},
+		getItemGroupProps(props$1) {
+			const { id } = props$1;
+			return normalize.element({
+				...parts.itemGroup.attrs,
+				"data-disabled": require_dom_query.dataAttr(disabled),
+				"data-orientation": prop("orientation"),
+				"data-empty": require_dom_query.dataAttr(collection$1.size === 0),
+				id: getItemGroupId(scope, id),
+				"aria-labelledby": getItemGroupLabelId(scope, id),
+				role: "group",
+				dir: prop("dir")
+			});
+		},
+		getContentProps() {
+			return normalize.element({
+				dir: prop("dir"),
+				id: getContentId(scope),
+				role: "listbox",
+				...parts.content.attrs,
+				"data-activedescendant": ariaActiveDescendant,
+				"aria-activedescendant": ariaActiveDescendant,
+				"data-orientation": prop("orientation"),
+				"aria-multiselectable": computed("multiple") ? true : void 0,
+				"aria-labelledby": getLabelId(scope),
+				tabIndex: 0,
+				"data-layout": layout,
+				"data-empty": require_dom_query.dataAttr(collection$1.size === 0),
+				style: { "--column-count": require_collection.isGridCollection(collection$1) ? collection$1.columnCount : 1 },
+				onFocus() {
+					send({ type: "CONTENT.FOCUS" });
+				},
+				onBlur() {
+					send({ type: "CONTENT.BLUR" });
+				},
+				onKeyDown(event) {
+					if (!interactive) return;
+					if (!require_dom_query.contains(event.currentTarget, require_dom_query.getEventTarget(event))) return;
+					const shiftKey = event.shiftKey;
+					const keyMap = {
+						ArrowUp(event$1) {
+							let nextValue = null;
+							if (require_collection.isGridCollection(collection$1) && highlightedValue) nextValue = collection$1.getPreviousRowValue(highlightedValue);
+							else if (highlightedValue) nextValue = collection$1.getPreviousValue(highlightedValue);
+							if (!nextValue && (prop("loopFocus") || !highlightedValue)) nextValue = collection$1.lastValue;
+							if (!nextValue) return;
+							event$1.preventDefault();
+							send({
+								type: "NAVIGATE",
+								value: nextValue,
+								shiftKey,
+								anchorValue: highlightedValue
+							});
+						},
+						ArrowDown(event$1) {
+							let nextValue = null;
+							if (require_collection.isGridCollection(collection$1) && highlightedValue) nextValue = collection$1.getNextRowValue(highlightedValue);
+							else if (highlightedValue) nextValue = collection$1.getNextValue(highlightedValue);
+							if (!nextValue && (prop("loopFocus") || !highlightedValue)) nextValue = collection$1.firstValue;
+							if (!nextValue) return;
+							event$1.preventDefault();
+							send({
+								type: "NAVIGATE",
+								value: nextValue,
+								shiftKey,
+								anchorValue: highlightedValue
+							});
+						},
+						ArrowLeft() {
+							if (!require_collection.isGridCollection(collection$1) && prop("orientation") === "vertical") return;
+							let nextValue = highlightedValue ? collection$1.getPreviousValue(highlightedValue) : null;
+							if (!nextValue && prop("loopFocus")) nextValue = collection$1.lastValue;
+							if (!nextValue) return;
+							event.preventDefault();
+							send({
+								type: "NAVIGATE",
+								value: nextValue,
+								shiftKey,
+								anchorValue: highlightedValue
+							});
+						},
+						ArrowRight() {
+							if (!require_collection.isGridCollection(collection$1) && prop("orientation") === "vertical") return;
+							let nextValue = highlightedValue ? collection$1.getNextValue(highlightedValue) : null;
+							if (!nextValue && prop("loopFocus")) nextValue = collection$1.firstValue;
+							if (!nextValue) return;
+							event.preventDefault();
+							send({
+								type: "NAVIGATE",
+								value: nextValue,
+								shiftKey,
+								anchorValue: highlightedValue
+							});
+						},
+						Home(event$1) {
+							event$1.preventDefault();
+							let nextValue = collection$1.firstValue;
+							send({
+								type: "NAVIGATE",
+								value: nextValue,
+								shiftKey,
+								anchorValue: highlightedValue
+							});
+						},
+						End(event$1) {
+							event$1.preventDefault();
+							let nextValue = collection$1.lastValue;
+							send({
+								type: "NAVIGATE",
+								value: nextValue,
+								shiftKey,
+								anchorValue: highlightedValue
+							});
+						},
+						Enter() {
+							send({
+								type: "ITEM.CLICK",
+								value: highlightedValue
+							});
+						},
+						a(event$1) {
+							if (require_dom_query.isCtrlOrMetaKey(event$1) && computed("multiple") && !prop("disallowSelectAll")) {
+								event$1.preventDefault();
+								send({
+									type: "VALUE.SET",
+									value: collection$1.getValues()
+								});
+							}
+						},
+						Space(event$1) {
+							if (isTypingAhead && prop("typeahead")) send({
+								type: "CONTENT.TYPEAHEAD",
+								key: event$1.key
+							});
+							else keyMap.Enter?.(event$1);
+						},
+						Escape(event$1) {
+							if (prop("deselectable") && value.length > 0) {
+								event$1.preventDefault();
+								event$1.stopPropagation();
+								send({ type: "VALUE.CLEAR" });
+							}
+						}
+					};
+					const exec = keyMap[require_dom_query.getEventKey(event)];
+					if (exec) {
+						exec(event);
+						return;
+					}
+					if (require_dom_query.isEditableElement(require_dom_query.getEventTarget(event))) return;
+					if (require_dom_query.getByTypeahead.isValidEvent(event) && prop("typeahead")) {
+						send({
+							type: "CONTENT.TYPEAHEAD",
+							key: event.key
+						});
+						event.preventDefault();
+					}
+				}
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/machines/listbox/listbox.machine.ts
+const { guards, createMachine } = require_core.setup();
+const { or } = guards;
+const machine = createMachine({
+	props({ props: props$1 }) {
+		return {
+			loopFocus: false,
+			composite: true,
+			defaultValue: [],
+			multiple: false,
+			typeahead: true,
+			collection: collection.empty(),
+			orientation: "vertical",
+			selectionMode: "single",
+			...props$1
+		};
+	},
+	context({ prop, bindable }) {
+		return {
+			value: bindable(() => ({
+				defaultValue: prop("defaultValue"),
+				value: prop("value"),
+				isEqual: require_utils.isEqual,
+				onChange(value) {
+					const items = prop("collection").findMany(value);
+					return prop("onValueChange")?.({
+						value,
+						items
+					});
+				}
+			})),
+			highlightedValue: bindable(() => ({
+				defaultValue: prop("defaultHighlightedValue") || null,
+				value: prop("highlightedValue"),
+				sync: true,
+				onChange(value) {
+					prop("onHighlightChange")?.({
+						highlightedValue: value,
+						highlightedItem: prop("collection").find(value),
+						highlightedIndex: prop("collection").indexOf(value)
+					});
+				}
+			})),
+			highlightedItem: bindable(() => ({ defaultValue: null })),
+			selectedItems: bindable(() => {
+				const value = prop("value") ?? prop("defaultValue") ?? [];
+				return { defaultValue: prop("collection").findMany(value) };
+			}),
+			focused: bindable(() => ({
+				sync: true,
+				defaultValue: false
+			}))
+		};
+	},
+	refs() {
+		return {
+			typeahead: { ...require_dom_query.getByTypeahead.defaultOptions },
+			focusVisible: false,
+			inputState: {
+				autoHighlight: false,
+				focused: false
+			}
+		};
+	},
+	computed: {
+		hasSelectedItems: ({ context }) => context.get("value").length > 0,
+		isTypingAhead: ({ refs }) => refs.get("typeahead").keysSoFar !== "",
+		isInteractive: ({ prop }) => !prop("disabled"),
+		selection: ({ context, prop }) => {
+			const selection = new require_collection.Selection(context.get("value"));
+			selection.selectionMode = prop("selectionMode");
+			selection.deselectable = !!prop("deselectable");
+			return selection;
+		},
+		multiple: ({ prop }) => prop("selectionMode") === "multiple" || prop("selectionMode") === "extended",
+		valueAsString: ({ context, prop }) => prop("collection").stringifyItems(context.get("selectedItems"))
+	},
+	initialState() {
+		return "idle";
+	},
+	watch({ context, prop, track, action }) {
+		track([() => context.get("value").toString()], () => {
+			action(["syncSelectedItems"]);
+		});
+		track([() => context.get("highlightedValue")], () => {
+			action(["syncHighlightedItem"]);
+		});
+		track([() => prop("collection").toString()], () => {
+			action(["syncHighlightedValue"]);
+		});
+	},
+	effects: ["trackFocusVisible"],
+	on: {
+		"HIGHLIGHTED_VALUE.SET": { actions: ["setHighlightedItem"] },
+		"ITEM.SELECT": { actions: ["selectItem"] },
+		"ITEM.CLEAR": { actions: ["clearItem"] },
+		"VALUE.SET": { actions: ["setSelectedItems"] },
+		"VALUE.CLEAR": { actions: ["clearSelectedItems"] }
+	},
+	states: { idle: {
+		effects: ["scrollToHighlightedItem"],
+		on: {
+			"INPUT.FOCUS": { actions: ["setFocused", "setInputState"] },
+			"CONTENT.FOCUS": [{
+				guard: or("hasSelectedValue", "hasHighlightedValue"),
+				actions: ["setFocused"]
+			}, { actions: ["setFocused", "setDefaultHighlightedValue"] }],
+			"CONTENT.BLUR": { actions: ["clearFocused", "clearInputState"] },
+			"ITEM.CLICK": { actions: ["setHighlightedItem", "selectHighlightedItem"] },
+			"CONTENT.TYPEAHEAD": { actions: ["setFocused", "highlightMatchingItem"] },
+			"ITEM.POINTER_MOVE": { actions: ["highlightItem"] },
+			"ITEM.POINTER_LEAVE": { actions: ["clearHighlightedItem"] },
+			NAVIGATE: { actions: [
+				"setFocused",
+				"setHighlightedItem",
+				"selectWithKeyboard"
+			] }
+		}
+	} },
+	implementations: {
+		guards: {
+			hasSelectedValue: ({ context }) => context.get("value").length > 0,
+			hasHighlightedValue: ({ context }) => context.get("highlightedValue") != null
+		},
+		effects: {
+			trackFocusVisible: ({ scope, refs }) => {
+				return require_focus_visible.trackFocusVisible({
+					root: scope.getRootNode?.(),
+					onChange(details) {
+						refs.set("focusVisible", details.isFocusVisible);
+					}
+				});
+			},
+			scrollToHighlightedItem({ context, prop, scope }) {
+				const exec = (immediate) => {
+					const highlightedValue = context.get("highlightedValue");
+					if (highlightedValue == null) return;
+					if (require_focus_visible.getInteractionModality() !== "keyboard") return;
+					const contentEl$1 = getContentEl(scope);
+					const scrollToIndexFn = prop("scrollToIndexFn");
+					if (scrollToIndexFn) {
+						const highlightedIndex = prop("collection").indexOf(highlightedValue);
+						scrollToIndexFn?.({
+							index: highlightedIndex,
+							immediate,
+							getElement() {
+								return getItemEl(scope, highlightedValue);
+							}
+						});
+						return;
+					}
+					require_dom_query.scrollIntoView(getItemEl(scope, highlightedValue), {
+						rootEl: contentEl$1,
+						block: "nearest"
+					});
+				};
+				require_dom_query.raf(() => exec(true));
+				const contentEl = () => getContentEl(scope);
+				return require_dom_query.observeAttributes(contentEl, {
+					defer: true,
+					attributes: ["data-activedescendant"],
+					callback() {
+						exec(false);
+					}
+				});
+			}
+		},
+		actions: {
+			selectHighlightedItem({ context, prop, event, computed }) {
+				const value = event.value ?? context.get("highlightedValue");
+				const collection$1 = prop("collection");
+				if (value == null || !collection$1.has(value)) return;
+				const selection = computed("selection");
+				if (event.shiftKey && computed("multiple") && event.anchorValue) {
+					const next = selection.extendSelection(collection$1, event.anchorValue, value);
+					invokeOnSelect(selection, next, prop("onSelect"));
+					context.set("value", Array.from(next));
+				} else {
+					const next = selection.select(collection$1, value, event.metaKey);
+					invokeOnSelect(selection, next, prop("onSelect"));
+					context.set("value", Array.from(next));
+				}
+			},
+			selectWithKeyboard({ context, prop, event, computed }) {
+				const selection = computed("selection");
+				const collection$1 = prop("collection");
+				if (event.shiftKey && computed("multiple") && event.anchorValue) {
+					const next = selection.extendSelection(collection$1, event.anchorValue, event.value);
+					invokeOnSelect(selection, next, prop("onSelect"));
+					context.set("value", Array.from(next));
+					return;
+				}
+				if (prop("selectOnHighlight")) {
+					const next = selection.replaceSelection(collection$1, event.value);
+					invokeOnSelect(selection, next, prop("onSelect"));
+					context.set("value", Array.from(next));
+				}
+			},
+			highlightItem({ context, event }) {
+				context.set("highlightedValue", event.value);
+			},
+			highlightMatchingItem({ context, prop, event, refs }) {
+				const value = prop("collection").search(event.key, {
+					state: refs.get("typeahead"),
+					currentValue: context.get("highlightedValue")
+				});
+				if (value == null) return;
+				context.set("highlightedValue", value);
+			},
+			setHighlightedItem({ context, event }) {
+				context.set("highlightedValue", event.value);
+			},
+			clearHighlightedItem({ context }) {
+				context.set("highlightedValue", null);
+			},
+			selectItem({ context, prop, event, computed }) {
+				const collection$1 = prop("collection");
+				const selection = computed("selection");
+				const next = selection.select(collection$1, event.value);
+				invokeOnSelect(selection, next, prop("onSelect"));
+				context.set("value", Array.from(next));
+			},
+			clearItem({ context, event, computed }) {
+				const value = computed("selection").deselect(event.value);
+				context.set("value", Array.from(value));
+			},
+			setSelectedItems({ context, event }) {
+				context.set("value", event.value);
+			},
+			clearSelectedItems({ context }) {
+				context.set("value", []);
+			},
+			syncSelectedItems({ context, prop }) {
+				const collection$1 = prop("collection");
+				const prevSelectedItems = context.get("selectedItems");
+				const selectedItems = context.get("value").map((value) => {
+					return prevSelectedItems.find((item) => collection$1.getItemValue(item) === value) || collection$1.find(value);
+				});
+				context.set("selectedItems", selectedItems);
+			},
+			syncHighlightedItem({ context, prop }) {
+				const collection$1 = prop("collection");
+				const highlightedValue = context.get("highlightedValue");
+				const highlightedItem = highlightedValue ? collection$1.find(highlightedValue) : null;
+				context.set("highlightedItem", highlightedItem);
+			},
+			syncHighlightedValue({ context, prop, refs }) {
+				const collection$1 = prop("collection");
+				const highlightedValue = context.get("highlightedValue");
+				const { autoHighlight } = refs.get("inputState");
+				if (autoHighlight) {
+					queueMicrotask(() => {
+						context.set("highlightedValue", prop("collection").firstValue ?? null);
+					});
+					return;
+				}
+				if (highlightedValue != null && !collection$1.has(highlightedValue)) queueMicrotask(() => {
+					context.set("highlightedValue", null);
+				});
+			},
+			setFocused({ context }) {
+				context.set("focused", true);
+			},
+			setDefaultHighlightedValue({ context, prop }) {
+				const firstValue = prop("collection").firstValue;
+				if (firstValue != null) context.set("highlightedValue", firstValue);
+			},
+			clearFocused({ context }) {
+				context.set("focused", false);
+			},
+			setInputState({ refs, event }) {
+				refs.set("inputState", {
+					autoHighlight: !!event.autoHighlight,
+					focused: true
+				});
+			},
+			clearInputState({ refs }) {
+				refs.set("inputState", {
+					autoHighlight: false,
+					focused: false
+				});
+			}
+		}
+	}
+});
+const diff = (a, b) => {
+	const result = new Set(a);
+	for (const item of b) result.delete(item);
+	return result;
+};
+function invokeOnSelect(current, next, onSelect) {
+	const added = diff(next, current);
+	for (const item of added) onSelect?.({ value: item });
+}
+
+//#endregion
+//#region src/machines/listbox/listbox.props.ts
+const props = require_create_props.createProps()([
+	"collection",
+	"defaultHighlightedValue",
+	"defaultValue",
+	"dir",
+	"disabled",
+	"deselectable",
+	"disallowSelectAll",
+	"getRootNode",
+	"highlightedValue",
+	"id",
+	"ids",
+	"loopFocus",
+	"onHighlightChange",
+	"onSelect",
+	"onValueChange",
+	"orientation",
+	"scrollToIndexFn",
+	"selectionMode",
+	"selectOnHighlight",
+	"typeahead",
+	"value"
+]);
+const splitProps = require_utils.createSplitProps(props);
+const itemProps = require_create_props.createProps()(["item", "highlightOnHover"]);
+const splitItemProps = require_utils.createSplitProps(itemProps);
+const itemGroupProps = require_create_props.createProps()(["id"]);
+const splitItemGroupProps = require_utils.createSplitProps(itemGroupProps);
+const itemGroupLabelProps = require_create_props.createProps()(["htmlFor"]);
+const splitItemGroupLabelProps = require_utils.createSplitProps(itemGroupLabelProps);
+
+//#endregion
+exports.anatomy = anatomy;
+exports.collection = collection;
+exports.connect = connect;
+exports.gridCollection = gridCollection;
+exports.itemGroupLabelProps = itemGroupLabelProps;
+exports.itemGroupProps = itemGroupProps;
+exports.itemProps = itemProps;
+exports.machine = machine;
+exports.props = props;
+exports.splitItemGroupLabelProps = splitItemGroupLabelProps;
+exports.splitItemGroupProps = splitItemGroupProps;
+exports.splitItemProps = splitItemProps;
+exports.splitProps = splitProps;