@lattice-ui/combobox 0.3.0

package/out/Combobox/ComboboxRoot.luau

@@ -0,0 +1,256 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _core = TS.import(script, TS.getModule(script, "@lattice-ui", "core").out)
+local React = _core.React
+local useControllableState = _core.useControllableState
+local ComboboxContextProvider = TS.import(script, script.Parent, "context").ComboboxContextProvider
+local _logic = TS.import(script, script.Parent, "logic")
+local defaultComboboxFilter = _logic.defaultComboboxFilter
+local resolveComboboxInputValue = _logic.resolveComboboxInputValue
+local resolveForcedComboboxValue = _logic.resolveForcedComboboxValue
+local function getOrderedItems(items)
+	local _array = {}
+	local _length = #_array
+	table.move(items, 1, #items, _length + 1, _array)
+	local ordered = _array
+	table.sort(ordered, function(left, right)
+		return left.order < right.order
+	end)
+	return ordered
+end
+local function toOptions(items)
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue = table.create(#items)
+	local _callback = function(item)
+		return {
+			value = item.value,
+			disabled = item.getDisabled(),
+			textValue = item.getTextValue(),
+		}
+	end
+	for _k, _v in items do
+		_newValue[_k] = _callback(_v, _k - 1, items)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	return _newValue
+end
+local function ComboboxRoot(props)
+	local _object = {
+		value = props.open,
+	}
+	local _left = "defaultValue"
+	local _condition = props.defaultOpen
+	if _condition == nil then
+		_condition = false
+	end
+	_object[_left] = _condition
+	_object.onChange = props.onOpenChange
+	local _binding = useControllableState(_object)
+	local open = _binding[1]
+	local setOpenState = _binding[2]
+	local _binding_1 = useControllableState({
+		value = props.value,
+		defaultValue = props.defaultValue,
+		onChange = function(nextValue)
+			if nextValue ~= nil then
+				local _result = props.onValueChange
+				if _result ~= nil then
+					_result(nextValue)
+				end
+			end
+		end,
+	})
+	local value = _binding_1[1]
+	local setValueState = _binding_1[2]
+	local _object_1 = {
+		value = props.inputValue,
+	}
+	local _left_1 = "defaultValue"
+	local _condition_1 = props.defaultInputValue
+	if _condition_1 == nil then
+		_condition_1 = ""
+	end
+	_object_1[_left_1] = _condition_1
+	_object_1.onChange = props.onInputValueChange
+	local _binding_2 = useControllableState(_object_1)
+	local inputValue = _binding_2[1]
+	local setInputValueState = _binding_2[2]
+	local disabled = props.disabled == true
+	local readOnly = props.readOnly == true
+	local required = props.required == true
+	local _condition_2 = props.loop
+	if _condition_2 == nil then
+		_condition_2 = true
+	end
+	local loop = _condition_2
+	local filterFn = props.filterFn or defaultComboboxFilter
+	local triggerRef = React.useRef()
+	local inputRef = React.useRef()
+	local contentRef = React.useRef()
+	local itemEntriesRef = React.useRef({})
+	local registryRevision, setRegistryRevision = React.useState(0)
+	local registerItem = React.useCallback(function(item)
+		local _current = itemEntriesRef.current
+		local _item = item
+		table.insert(_current, _item)
+		setRegistryRevision(function(revision)
+			return revision + 1
+		end)
+		return function()
+			local _exp = itemEntriesRef.current
+			-- ▼ ReadonlyArray.findIndex ▼
+			local _callback = function(entry)
+				return entry.id == item.id
+			end
+			local _result = -1
+			for _i, _v in _exp do
+				if _callback(_v, _i - 1, _exp) == true then
+					_result = _i - 1
+					break
+				end
+			end
+			-- ▲ ReadonlyArray.findIndex ▲
+			local index = _result
+			if index >= 0 then
+				table.remove(itemEntriesRef.current, index + 1)
+				setRegistryRevision(function(revision)
+					return revision + 1
+				end)
+			end
+		end
+	end, {})
+	local resolveOrderedItems = React.useCallback(function()
+		return getOrderedItems(itemEntriesRef.current)
+	end, { registryRevision })
+	local getItemText = React.useCallback(function(candidateValue)
+		local _exp = resolveOrderedItems()
+		-- ▼ ReadonlyArray.find ▼
+		local _callback = function(item)
+			return item.value == candidateValue
+		end
+		local _result
+		for _i, _v in _exp do
+			if _callback(_v, _i - 1, _exp) == true then
+				_result = _v
+				break
+			end
+		end
+		-- ▲ ReadonlyArray.find ▲
+		local selected = _result
+		local _result_1 = selected
+		if _result_1 ~= nil then
+			_result_1 = _result_1.getTextValue()
+		end
+		return _result_1
+	end, { resolveOrderedItems })
+	local syncInputFromValue = React.useCallback(function()
+		local nextInputValue = resolveComboboxInputValue(value, toOptions(resolveOrderedItems()), "")
+		setInputValueState(nextInputValue)
+	end, { resolveOrderedItems, setInputValueState, value })
+	local setOpen = React.useCallback(function(nextOpen)
+		if disabled and nextOpen then
+			return nil
+		end
+		setOpenState(nextOpen)
+		if not nextOpen then
+			syncInputFromValue()
+		end
+	end, { disabled, setOpenState, syncInputFromValue })
+	local setValue = React.useCallback(function(nextValue)
+		if disabled then
+			return nil
+		end
+		local _exp = resolveOrderedItems()
+		-- ▼ ReadonlyArray.find ▼
+		local _callback = function(item)
+			return item.value == nextValue
+		end
+		local _result
+		for _i, _v in _exp do
+			if _callback(_v, _i - 1, _exp) == true then
+				_result = _v
+				break
+			end
+		end
+		-- ▲ ReadonlyArray.find ▲
+		local selected = _result
+		if selected and selected.getDisabled() then
+			return nil
+		end
+		setValueState(nextValue)
+		local _condition_3 = getItemText(nextValue)
+		if _condition_3 == nil then
+			_condition_3 = nextValue
+		end
+		local nextInputValue = _condition_3
+		setInputValueState(nextInputValue)
+	end, { disabled, getItemText, resolveOrderedItems, setInputValueState, setValueState })
+	local setInputValue = React.useCallback(function(nextInputValue)
+		if disabled or readOnly then
+			return nil
+		end
+		setInputValueState(nextInputValue)
+		setOpenState(true)
+	end, { disabled, readOnly, setInputValueState, setOpenState })
+	local getFilteredItems = React.useCallback(function()
+		local query = inputValue
+		local _exp = resolveOrderedItems()
+		-- ▼ ReadonlyArray.filter ▼
+		local _newValue = {}
+		local _callback = function(item)
+			return filterFn(item.getTextValue(), query)
+		end
+		local _length = 0
+		for _k, _v in _exp do
+			if _callback(_v, _k - 1, _exp) == true then
+				_length += 1
+				_newValue[_length] = _v
+			end
+		end
+		-- ▲ ReadonlyArray.filter ▲
+		return _newValue
+	end, { filterFn, inputValue, resolveOrderedItems })
+	React.useEffect(function()
+		local orderedItems = resolveOrderedItems()
+		local nextValue = resolveForcedComboboxValue(value, toOptions(orderedItems))
+		if nextValue ~= value then
+			setValueState(nextValue)
+		end
+	end, { registryRevision, resolveOrderedItems, setValueState, value })
+	React.useEffect(function()
+		if open then
+			return nil
+		end
+		syncInputFromValue()
+	end, { open, syncInputFromValue, value })
+	local contextValue = React.useMemo(function()
+		return {
+			open = open,
+			setOpen = setOpen,
+			value = value,
+			setValue = setValue,
+			inputValue = inputValue,
+			setInputValue = setInputValue,
+			syncInputFromValue = syncInputFromValue,
+			disabled = disabled,
+			readOnly = readOnly,
+			required = required,
+			loop = loop,
+			filterFn = filterFn,
+			triggerRef = triggerRef,
+			inputRef = inputRef,
+			contentRef = contentRef,
+			registerItem = registerItem,
+			getOrderedItems = resolveOrderedItems,
+			getFilteredItems = getFilteredItems,
+			getItemText = getItemText,
+		}
+	end, { disabled, filterFn, getFilteredItems, getItemText, inputValue, loop, open, readOnly, registerItem, required, resolveOrderedItems, setInputValue, setOpen, setValue, syncInputFromValue, value })
+	return React.createElement(ComboboxContextProvider, {
+		value = contextValue,
+	}, props.children)
+end
+return {
+	ComboboxRoot = ComboboxRoot,
+	Combobox = ComboboxRoot,
+}

package/out/Combobox/ComboboxSeparator.d.ts

@@ -0,0 +1,3 @@
+import { React } from "@lattice-ui/core";
+import type { ComboboxSeparatorProps } from "./types";
+export declare function ComboboxSeparator(props: ComboboxSeparatorProps): React.JSX.Element;

package/out/Combobox/ComboboxSeparator.luau

@@ -0,0 +1,22 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _core = TS.import(script, TS.getModule(script, "@lattice-ui", "core").out)
+local React = _core.React
+local Slot = _core.Slot
+local function ComboboxSeparator(props)
+	if props.asChild then
+		local child = props.children
+		if not child then
+			error("[ComboboxSeparator] `asChild` requires a child element.")
+		end
+		return React.createElement(Slot, nil, child)
+	end
+	return React.createElement("frame", {
+		BackgroundColor3 = Color3.fromRGB(78, 86, 104),
+		BorderSizePixel = 0,
+		Size = UDim2.fromOffset(220, 1),
+	}, props.children)
+end
+return {
+	ComboboxSeparator = ComboboxSeparator,
+}

package/out/Combobox/ComboboxTrigger.d.ts

@@ -0,0 +1,3 @@
+import { React } from "@lattice-ui/core";
+import type { ComboboxTriggerProps } from "./types";
+export declare function ComboboxTrigger(props: ComboboxTriggerProps): React.JSX.Element;

package/out/Combobox/ComboboxTrigger.luau

@@ -0,0 +1,72 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _core = TS.import(script, TS.getModule(script, "@lattice-ui", "core").out)
+local React = _core.React
+local Slot = _core.Slot
+local useComboboxContext = TS.import(script, script.Parent, "context").useComboboxContext
+local function toGuiObject(instance)
+	if not instance or not instance:IsA("GuiObject") then
+		return nil
+	end
+	return instance
+end
+local function ComboboxTrigger(props)
+	local comboboxContext = useComboboxContext()
+	local disabled = comboboxContext.disabled or props.disabled == true
+	local setTriggerRef = React.useCallback(function(instance)
+		comboboxContext.triggerRef.current = toGuiObject(instance)
+	end, { comboboxContext.triggerRef })
+	local handleActivated = React.useCallback(function()
+		if disabled then
+			return nil
+		end
+		comboboxContext.setOpen(not comboboxContext.open)
+	end, { comboboxContext, disabled })
+	local handleInputBegan = React.useCallback(function(_rbx, inputObject)
+		if disabled then
+			return nil
+		end
+		local keyCode = inputObject.KeyCode
+		if keyCode == Enum.KeyCode.Return or keyCode == Enum.KeyCode.Space then
+			comboboxContext.setOpen(not comboboxContext.open)
+			return nil
+		end
+		if keyCode == Enum.KeyCode.Down or keyCode == Enum.KeyCode.Up then
+			comboboxContext.setOpen(true)
+		end
+	end, { comboboxContext, disabled })
+	local eventHandlers = React.useMemo(function()
+		return {
+			Activated = handleActivated,
+			InputBegan = handleInputBegan,
+		}
+	end, { handleActivated, handleInputBegan })
+	if props.asChild then
+		local child = props.children
+		if not child then
+			error("[ComboboxTrigger] `asChild` requires a child element.")
+		end
+		return React.createElement(Slot, {
+			Active = not disabled,
+			Event = eventHandlers,
+			Selectable = not disabled,
+			ref = setTriggerRef,
+		}, child)
+	end
+	return React.createElement("textbutton", {
+		Active = not disabled,
+		AutoButtonColor = false,
+		BackgroundColor3 = Color3.fromRGB(41, 48, 63),
+		BorderSizePixel = 0,
+		Event = eventHandlers,
+		Selectable = not disabled,
+		Size = UDim2.fromOffset(220, 36),
+		Text = "Combobox",
+		TextColor3 = if disabled then Color3.fromRGB(140, 148, 164) else Color3.fromRGB(235, 241, 248),
+		TextSize = 15,
+		ref = setTriggerRef,
+	}, props.children)
+end
+return {
+	ComboboxTrigger = ComboboxTrigger,
+}

package/out/Combobox/ComboboxValue.d.ts

@@ -0,0 +1,3 @@
+import { React } from "@lattice-ui/core";
+import type { ComboboxValueProps } from "./types";
+export declare function ComboboxValue(props: ComboboxValueProps): React.JSX.Element;

package/out/Combobox/ComboboxValue.luau

@@ -0,0 +1,47 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _core = TS.import(script, TS.getModule(script, "@lattice-ui", "core").out)
+local React = _core.React
+local Slot = _core.Slot
+local useComboboxContext = TS.import(script, script.Parent, "context").useComboboxContext
+local function ComboboxValue(props)
+	local comboboxContext = useComboboxContext()
+	local selectedValue = comboboxContext.value
+	local hasValue = selectedValue ~= nil
+	local resolvedText = React.useMemo(function()
+		if not hasValue or selectedValue == nil then
+			local _condition = props.placeholder
+			if _condition == nil then
+				_condition = ""
+			end
+			return _condition
+		end
+		local _condition = comboboxContext.getItemText(selectedValue)
+		if _condition == nil then
+			_condition = selectedValue
+		end
+		return _condition
+	end, { comboboxContext, hasValue, props.placeholder, selectedValue })
+	if props.asChild then
+		local child = props.children
+		if not child then
+			error("[ComboboxValue] `asChild` requires a child element.")
+		end
+		return React.createElement(Slot, {
+			Name = "ComboboxValue",
+			Text = resolvedText,
+		}, child)
+	end
+	return React.createElement("textlabel", {
+		BackgroundTransparency = 1,
+		BorderSizePixel = 0,
+		Size = UDim2.fromOffset(200, 20),
+		Text = resolvedText,
+		TextColor3 = if hasValue then Color3.fromRGB(235, 240, 248) else Color3.fromRGB(153, 161, 177),
+		TextSize = 14,
+		TextXAlignment = Enum.TextXAlignment.Left,
+	})
+end
+return {
+	ComboboxValue = ComboboxValue,
+}

package/out/Combobox/context.d.ts

@@ -0,0 +1,3 @@
+import type { ComboboxContextValue } from "./types";
+declare const ComboboxContextProvider: import("@rbxts/react").Provider<ComboboxContextValue | undefined>, useComboboxContext: () => ComboboxContextValue;
+export { ComboboxContextProvider, useComboboxContext };

package/out/Combobox/context.luau

@@ -0,0 +1,10 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local createStrictContext = TS.import(script, TS.getModule(script, "@lattice-ui", "core").out).createStrictContext
+local _binding = createStrictContext("Combobox")
+local ComboboxContextProvider = _binding[1]
+local useComboboxContext = _binding[2]
+return {
+	ComboboxContextProvider = ComboboxContextProvider,
+	useComboboxContext = useComboboxContext,
+}

package/out/Combobox/logic.d.ts

@@ -0,0 +1,10 @@
+export type ComboboxOption = {
+    value: string;
+    disabled: boolean;
+    textValue: string;
+};
+export type ComboboxFilterFn = (itemText: string, query: string) => boolean;
+export declare function defaultComboboxFilter(itemText: string, query: string): boolean;
+export declare function resolveForcedComboboxValue(currentValue: string | undefined, options: Array<ComboboxOption>): string | undefined;
+export declare function resolveComboboxInputValue(selectedValue: string | undefined, options: Array<ComboboxOption>, placeholder?: string): string;
+export declare function filterComboboxOptions(options: Array<ComboboxOption>, query: string, filterFn?: ComboboxFilterFn): ComboboxOption[];

package/out/Combobox/logic.luau

@@ -0,0 +1,103 @@
+-- Compiled with roblox-ts v3.0.0
+local function defaultComboboxFilter(itemText, query)
+	local normalizedItemText = string.lower(itemText)
+	local normalizedQuery = string.lower(query)
+	return { string.find(normalizedItemText, normalizedQuery, 1, true) } ~= nil
+end
+local function resolveForcedComboboxValue(currentValue, options)
+	-- ▼ ReadonlyArray.filter ▼
+	local _newValue = {}
+	local _callback = function(option)
+		return not option.disabled
+	end
+	local _length = 0
+	for _k, _v in options do
+		if _callback(_v, _k - 1, options) == true then
+			_length += 1
+			_newValue[_length] = _v
+		end
+	end
+	-- ▲ ReadonlyArray.filter ▲
+	local enabled = _newValue
+	if #enabled == 0 then
+		return nil
+	end
+	if currentValue == nil then
+		local _result = enabled[1]
+		if _result ~= nil then
+			_result = _result.value
+		end
+		return _result
+	end
+	-- ▼ ReadonlyArray.find ▼
+	local _callback_1 = function(option)
+		return option.value == currentValue
+	end
+	local _result
+	for _i, _v in enabled do
+		if _callback_1(_v, _i - 1, enabled) == true then
+			_result = _v
+			break
+		end
+	end
+	-- ▲ ReadonlyArray.find ▲
+	local selected = _result
+	if selected then
+		return selected.value
+	end
+	local _result_1 = enabled[1]
+	if _result_1 ~= nil then
+		_result_1 = _result_1.value
+	end
+	return _result_1
+end
+local function resolveComboboxInputValue(selectedValue, options, placeholder)
+	if placeholder == nil then
+		placeholder = ""
+	end
+	if selectedValue == nil then
+		return placeholder
+	end
+	-- ▼ ReadonlyArray.find ▼
+	local _callback = function(option)
+		return option.value == selectedValue and not option.disabled
+	end
+	local _result
+	for _i, _v in options do
+		if _callback(_v, _i - 1, options) == true then
+			_result = _v
+			break
+		end
+	end
+	-- ▲ ReadonlyArray.find ▲
+	local selected = _result
+	if not selected then
+		return placeholder
+	end
+	return selected.textValue
+end
+local function filterComboboxOptions(options, query, filterFn)
+	if filterFn == nil then
+		filterFn = defaultComboboxFilter
+	end
+	-- ▼ ReadonlyArray.filter ▼
+	local _newValue = {}
+	local _callback = function(option)
+		return filterFn(option.textValue, query)
+	end
+	local _length = 0
+	for _k, _v in options do
+		if _callback(_v, _k - 1, options) == true then
+			_length += 1
+			_newValue[_length] = _v
+		end
+	end
+	-- ▲ ReadonlyArray.filter ▲
+	return _newValue
+end
+return {
+	defaultComboboxFilter = defaultComboboxFilter,
+	resolveForcedComboboxValue = resolveForcedComboboxValue,
+	resolveComboboxInputValue = resolveComboboxInputValue,
+	filterComboboxOptions = filterComboboxOptions,
+}

package/out/Combobox/types.d.ts

@@ -0,0 +1,105 @@
+import type { LayerInteractEvent } from "@lattice-ui/layer";
+import type { PopperPlacement } from "@lattice-ui/popper";
+import type React from "@rbxts/react";
+export type ComboboxFilterFn = (itemText: string, query: string) => boolean;
+export type ComboboxSetOpen = (open: boolean) => void;
+export type ComboboxSetValue = (value: string) => void;
+export type ComboboxSetInputValue = (inputValue: string) => void;
+export type ComboboxItemRegistration = {
+    id: number;
+    value: string;
+    order: number;
+    getNode: () => GuiObject | undefined;
+    getDisabled: () => boolean;
+    getTextValue: () => string;
+};
+export type ComboboxContextValue = {
+    open: boolean;
+    setOpen: ComboboxSetOpen;
+    value?: string;
+    setValue: ComboboxSetValue;
+    inputValue: string;
+    setInputValue: ComboboxSetInputValue;
+    syncInputFromValue: () => void;
+    disabled: boolean;
+    readOnly: boolean;
+    required: boolean;
+    loop: boolean;
+    filterFn: ComboboxFilterFn;
+    triggerRef: React.MutableRefObject<GuiObject | undefined>;
+    inputRef: React.MutableRefObject<TextBox | undefined>;
+    contentRef: React.MutableRefObject<GuiObject | undefined>;
+    registerItem: (item: ComboboxItemRegistration) => () => void;
+    getOrderedItems: () => Array<ComboboxItemRegistration>;
+    getFilteredItems: () => Array<ComboboxItemRegistration>;
+    getItemText: (value: string) => string | undefined;
+};
+export type ComboboxProps = {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    inputValue?: string;
+    defaultInputValue?: string;
+    onInputValueChange?: (inputValue: string) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    loop?: boolean;
+    filterFn?: ComboboxFilterFn;
+    children?: React.ReactNode;
+};
+export type ComboboxTriggerProps = {
+    asChild?: boolean;
+    disabled?: boolean;
+    children?: React.ReactElement;
+};
+export type ComboboxInputProps = {
+    asChild?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    placeholder?: string;
+    children?: React.ReactElement;
+};
+export type ComboboxValueProps = {
+    asChild?: boolean;
+    placeholder?: string;
+    children?: React.ReactElement;
+};
+export type ComboboxPortalProps = {
+    container?: BasePlayerGui;
+    displayOrderBase?: number;
+    children?: React.ReactNode;
+};
+export type ComboboxContentProps = {
+    asChild?: boolean;
+    forceMount?: boolean;
+    placement?: PopperPlacement;
+    offset?: Vector2;
+    padding?: number;
+    onEscapeKeyDown?: (event: LayerInteractEvent) => void;
+    onPointerDownOutside?: (event: LayerInteractEvent) => void;
+    onInteractOutside?: (event: LayerInteractEvent) => void;
+    children?: React.ReactNode;
+};
+export type ComboboxItemProps = {
+    value: string;
+    textValue?: string;
+    disabled?: boolean;
+    asChild?: boolean;
+    children?: React.ReactElement;
+};
+export type ComboboxSeparatorProps = {
+    asChild?: boolean;
+    children?: React.ReactElement;
+};
+export type ComboboxGroupProps = {
+    asChild?: boolean;
+    children?: React.ReactElement;
+};
+export type ComboboxLabelProps = {
+    asChild?: boolean;
+    children?: React.ReactElement;
+};

package/out/Combobox/types.luau

@@ -0,0 +1,2 @@
+-- Compiled with roblox-ts v3.0.0
+return nil

package/out/index.d.ts

@@ -0,0 +1,24 @@
+import { ComboboxContent } from "./Combobox/ComboboxContent";
+import { ComboboxGroup } from "./Combobox/ComboboxGroup";
+import { ComboboxInput } from "./Combobox/ComboboxInput";
+import { ComboboxItem } from "./Combobox/ComboboxItem";
+import { ComboboxLabel } from "./Combobox/ComboboxLabel";
+import { ComboboxPortal } from "./Combobox/ComboboxPortal";
+import { ComboboxRoot } from "./Combobox/ComboboxRoot";
+import { ComboboxSeparator } from "./Combobox/ComboboxSeparator";
+import { ComboboxTrigger } from "./Combobox/ComboboxTrigger";
+import { ComboboxValue } from "./Combobox/ComboboxValue";
+export declare const Combobox: {
+    readonly Root: typeof ComboboxRoot;
+    readonly Trigger: typeof ComboboxTrigger;
+    readonly Input: typeof ComboboxInput;
+    readonly Value: typeof ComboboxValue;
+    readonly Portal: typeof ComboboxPortal;
+    readonly Content: typeof ComboboxContent;
+    readonly Item: typeof ComboboxItem;
+    readonly Group: typeof ComboboxGroup;
+    readonly Label: typeof ComboboxLabel;
+    readonly Separator: typeof ComboboxSeparator;
+};
+export { defaultComboboxFilter, filterComboboxOptions, resolveComboboxInputValue, resolveForcedComboboxValue, } from "./Combobox/logic";
+export type { ComboboxContentProps, ComboboxContextValue, ComboboxFilterFn, ComboboxGroupProps, ComboboxInputProps, ComboboxItemProps, ComboboxItemRegistration, ComboboxLabelProps, ComboboxPortalProps, ComboboxProps, ComboboxSeparatorProps, ComboboxSetInputValue, ComboboxSetOpen, ComboboxSetValue, ComboboxTriggerProps, ComboboxValueProps, } from "./Combobox/types";