.editorconfig

@@ -1,226 +0,0 @@
-# Remove the line below if you want to inherit .editorconfig settings from higher directories
-root = true
-
-# C# files
-[*.cs]
-
-#### Core EditorConfig Options ####
-
-# Indentation and spacing
-indent_size = 3
-indent_style = tab
-tab_width = 3
-
-# New line preferences
-end_of_line = crlf
-insert_final_newline = false
-
-#### .NET Coding Conventions ####
-
-# Organize usings
-dotnet_separate_import_directive_groups = false
-dotnet_sort_system_directives_first = false
-file_header_template = unset
-
-# this. and Me. preferences
-dotnet_style_qualification_for_event = false:suggestion
-dotnet_style_qualification_for_field = false:suggestion
-dotnet_style_qualification_for_method = false:suggestion
-dotnet_style_qualification_for_property = false:suggestion
-
-# Language keywords vs BCL types preferences
-dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
-dotnet_style_predefined_type_for_member_access = true:suggestion
-
-# Parentheses preferences
-dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:suggestion
-dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:suggestion
-dotnet_style_parentheses_in_other_operators = never_if_unnecessary:suggestion
-dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:suggestion
-
-# Modifier preferences
-dotnet_style_require_accessibility_modifiers = for_non_interface_members
-
-# Expression-level preferences
-dotnet_style_coalesce_expression = true
-dotnet_style_collection_initializer = true
-dotnet_style_explicit_tuple_names = true
-dotnet_style_namespace_match_folder = true
-dotnet_style_null_propagation = true
-dotnet_style_object_initializer = true
-dotnet_style_operator_placement_when_wrapping = beginning_of_line
-dotnet_style_prefer_auto_properties = true:suggestion
-dotnet_style_prefer_compound_assignment = true
-dotnet_style_prefer_conditional_expression_over_assignment = true:suggestion
-dotnet_style_prefer_conditional_expression_over_return = true:suggestion
-dotnet_style_prefer_foreach_explicit_cast_in_source = when_strongly_typed
-dotnet_style_prefer_inferred_anonymous_type_member_names = true
-dotnet_style_prefer_inferred_tuple_names = false
-dotnet_style_prefer_is_null_check_over_reference_equality_method = true
-dotnet_style_prefer_simplified_boolean_expressions = true
-dotnet_style_prefer_simplified_interpolation = true
-
-# Field preferences
-dotnet_style_readonly_field = true
-
-# Parameter preferences
-dotnet_code_quality_unused_parameters = all
-
-# Suppression preferences
-dotnet_remove_unnecessary_suppression_exclusions = 0
-
-# New line preferences
-dotnet_style_allow_multiple_blank_lines_experimental = false:suggestion
-dotnet_style_allow_statement_immediately_after_block_experimental = false:suggestion
-
-#### C# Coding Conventions ####
-
-# var preferences
-csharp_style_var_elsewhere = true:warning
-csharp_style_var_for_built_in_types = true:warning
-csharp_style_var_when_type_is_apparent = true:warning
-
-# Expression-bodied members
-csharp_style_expression_bodied_accessors = when_on_single_line:suggestion
-csharp_style_expression_bodied_constructors = when_on_single_line:suggestion
-csharp_style_expression_bodied_indexers = when_on_single_line:suggestion
-csharp_style_expression_bodied_lambdas = when_on_single_line:suggestion
-csharp_style_expression_bodied_local_functions = when_on_single_line:suggestion
-csharp_style_expression_bodied_methods = when_on_single_line:suggestion
-csharp_style_expression_bodied_operators = when_on_single_line:suggestion
-csharp_style_expression_bodied_properties = when_on_single_line:suggestion
-
-# Pattern matching preferences
-csharp_style_pattern_matching_over_as_with_null_check = true
-csharp_style_pattern_matching_over_is_with_cast_check = true
-csharp_style_prefer_extended_property_pattern = true
-csharp_style_prefer_not_pattern = true
-csharp_style_prefer_pattern_matching = true:suggestion
-csharp_style_prefer_switch_expression = true
-
-# Null-checking preferences
-csharp_style_conditional_delegate_call = true
-
-# Modifier preferences
-csharp_prefer_static_local_function = true
-csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async
-csharp_style_prefer_readonly_struct = true
-
-# Code-block preferences
-csharp_prefer_braces = when_multiline:suggestion
-csharp_prefer_simple_using_statement = true
-csharp_style_namespace_declarations = file_scoped:warning
-csharp_style_prefer_method_group_conversion = true:suggestion
-csharp_style_prefer_top_level_statements = false:suggestion
-
-# Expression-level preferences
-csharp_prefer_simple_default_expression = true
-csharp_style_deconstructed_variable_declaration = true
-csharp_style_implicit_object_creation_when_type_is_apparent = true
-csharp_style_inlined_variable_declaration = true
-csharp_style_prefer_index_operator = true
-csharp_style_prefer_local_over_anonymous_function = true
-csharp_style_prefer_null_check_over_type_check = true
-csharp_style_prefer_range_operator = true
-csharp_style_prefer_tuple_swap = true
-csharp_style_prefer_utf8_string_literals = true
-csharp_style_throw_expression = true
-csharp_style_unused_value_assignment_preference = discard_variable
-csharp_style_unused_value_expression_statement_preference = discard_variable:suggestion
-
-# 'using' directive preferences
-csharp_using_directive_placement = outside_namespace:suggestion
-
-# New line preferences
-csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental = true:suggestion
-csharp_style_allow_blank_lines_between_consecutive_braces_experimental = false:suggestion
-csharp_style_allow_embedded_statements_on_same_line_experimental = false:suggestion
-
-#### C# Formatting Rules ####
-
-# New line preferences
-csharp_new_line_before_catch = true
-csharp_new_line_before_else = true
-csharp_new_line_before_finally = true
-csharp_new_line_before_members_in_anonymous_types = true
-csharp_new_line_before_members_in_object_initializers = true
-csharp_new_line_before_open_brace = all
-csharp_new_line_between_query_expression_clauses = true
-
-# Indentation preferences
-csharp_indent_block_contents = true
-csharp_indent_braces = false
-csharp_indent_case_contents = true
-csharp_indent_case_contents_when_block = true
-csharp_indent_labels = no_change
-csharp_indent_switch_labels = true
-
-# Space preferences
-csharp_space_after_cast = false
-csharp_space_after_colon_in_inheritance_clause = true
-csharp_space_after_comma = true
-csharp_space_after_dot = false
-csharp_space_after_keywords_in_control_flow_statements = true
-csharp_space_after_semicolon_in_for_statement = true
-csharp_space_around_binary_operators = before_and_after
-csharp_space_around_declaration_statements = false
-csharp_space_before_colon_in_inheritance_clause = true
-csharp_space_before_comma = false
-csharp_space_before_dot = false
-csharp_space_before_open_square_brackets = false
-csharp_space_before_semicolon_in_for_statement = false
-csharp_space_between_empty_square_brackets = false
-csharp_space_between_method_call_empty_parameter_list_parentheses = false
-csharp_space_between_method_call_name_and_opening_parenthesis = false
-csharp_space_between_method_call_parameter_list_parentheses = false
-csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
-csharp_space_between_method_declaration_name_and_open_parenthesis = false
-csharp_space_between_method_declaration_parameter_list_parentheses = false
-csharp_space_between_parentheses = false
-csharp_space_between_square_brackets = false
-
-# Wrapping preferences
-csharp_preserve_single_line_blocks = true
-csharp_preserve_single_line_statements = true
-
-#### Naming styles ####
-
-# Naming rules
-
-dotnet_naming_rule.interface_should_be_begins_with_i.severity = suggestion
-dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface
-dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i
-
-dotnet_naming_rule.types_should_be_pascal_case.severity = suggestion
-dotnet_naming_rule.types_should_be_pascal_case.symbols = types
-dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case
-
-dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = suggestion
-dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members
-dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case
-
-# Symbol specifications
-
-dotnet_naming_symbols.interface.applicable_kinds = interface
-dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
-dotnet_naming_symbols.interface.required_modifiers = 
-
-dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum
-dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
-dotnet_naming_symbols.types.required_modifiers = 
-
-dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
-dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
-dotnet_naming_symbols.non_field_members.required_modifiers = 
-
-# Naming styles
-
-dotnet_naming_style.pascal_case.required_prefix = 
-dotnet_naming_style.pascal_case.required_suffix = 
-dotnet_naming_style.pascal_case.word_separator = 
-dotnet_naming_style.pascal_case.capitalization = pascal_case
-
-dotnet_naming_style.begins_with_i.required_prefix = I
-dotnet_naming_style.begins_with_i.required_suffix = 
-dotnet_naming_style.begins_with_i.word_separator = 
-dotnet_naming_style.begins_with_i.capitalization = pascal_case

Components/Autocomplete/Autocomplete.razor

@@ -5,14 +5,14 @@
 <CascadingValue Name="SubscribeToParentForm" Value="false" IsFixed="true">
     <div class="@AutocompleteClassList">
         <InputControl Label="@Label" Variant="@Variant" HelperText="@HelperText" HelperTextOnFocus="@HelperTextOnFocus" FullWidth="@FullWidth" Margin="@Margin" Class="@ClassList()" Style="@Style"
-                         Error="@HasError" ErrorText="@ErrorText" Disabled="@Disabled" @onclick="@ToggleMenu" Required="@Required" ForId="@FieldId">
+                         Error="@Error" ErrorText="@ErrorText" Disabled="@Disabled" @onclick="@ToggleMenu" Required="@Required" ForId="@FieldId">
             <InputContent>
                 <Input @ref="_elementReference" @key="_elementKey" InputType="InputType.Text"
                           Class="select-input" Margin="@Margin"
                           Variant="@Variant"
                           TextUpdateSuppression="@TextUpdateSuppression"
                           Value="@Text" DisableUnderLine="@DisableUnderLine"
-                          Disabled="@Disabled" ReadOnly="@ReadOnly" Error="@HasError"
+                          Disabled="@Disabled" ReadOnly="@ReadOnly" Error="@Error"
                           OnAdornmentClick="@OnAdornmentClick" AdornmentIcon="@CurrentIcon" Adornment="@Adornment" AdornmentColor="@AdornmentColor" IconSize="@IconSize" AdornmentText="@AdornmentText"
                           Clearable="@Clearable" OnClearButtonClick="@OnClearButtonClick"
                           @attributes="UserAttributes"

Components/Autocomplete/Autocomplete.razor.cs

@@ -0,0 +1,696 @@
+using Connected.Utilities;
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Web;
+
+namespace Connected.Components;
+
+public partial class Autocomplete<T> : InputBase<T>, IDisposable
+{
+	private Func<T, string>? _toStringFunc;
+	private Task _currentSearchTask;
+	private CancellationTokenSource _cancellationTokenSrc;
+	private bool _isOpen;
+	private Timer _timer;
+	private T[] _items;
+	private int _selectedListItemIndex = 0;
+	private IList<int> _enabledItemIndices = new List<int>();
+	private int _itemsReturned; //the number of items returned by the search function
+	int _elementKey = 0;
+	/// <summary>
+	/// This boolean will keep track if the clear function is called too keep the set text function to be called.
+	/// </summary>
+	private bool _isCleared;
+	private Input<string> _elementReference;
+	/// <summary>
+	/// We need a random id for the year items in the year list so we can scroll to the item safely in every DatePicker.
+	/// </summary>
+	private readonly string _componentId = Guid.NewGuid().ToString();
+
+	public Autocomplete()
+	{
+		Adornment = Adornment.End;
+		IconSize = Size.Medium;
+	}
+
+	[Inject]
+	IScrollManager ScrollManager { get; set; }
+	/// <summary>
+	/// User class names for the popover, separated by space
+	/// </summary>
+	[Parameter]
+	public string PopoverClass { get; set; }
+	/// <summary>
+	/// Set the anchor origin point to determen where the popover will open from.
+	/// </summary>
+	[Parameter]
+	public Origin AnchorOrigin { get; set; } = Origin.BottomCenter;
+	/// <summary>
+	/// Sets the transform origin point for the popover.
+	/// </summary>
+	[Parameter]
+	public Origin TransformOrigin { get; set; } = Origin.TopCenter;
+	/// <summary>
+	/// If true, compact vertical padding will be applied to all Autocomplete items.
+	/// </summary>
+	[Parameter]
+	public bool Dense { get; set; }
+	/// <summary>
+	/// The Open Autocomplete Icon
+	/// </summary>
+	[Parameter]
+	public string OpenIcon { get; set; } = Icons.Material.Filled.ArrowDropDown;
+	/// <summary>
+	/// The Close Autocomplete Icon
+	/// </summary>
+	[Parameter]
+	public string CloseIcon { get; set; } = Icons.Material.Filled.ArrowDropUp;
+	/// <summary>
+	/// The maximum height of the Autocomplete when it is open.
+	/// </summary>
+	[Parameter]
+	public int MaxHeight { get; set; } = 300;
+	/// <summary>
+	/// Defines how values are displayed in the drop-down list
+	/// </summary>
+	[Parameter]
+	public Func<T, string>? ToStringFunc
+	{
+		get => _toStringFunc;
+		set
+		{
+			if (_toStringFunc == value)
+				return;
+
+			_toStringFunc = value;
+
+			Converter = new Converter<T>
+			{
+				SetFunc = _toStringFunc ?? (x => x?.ToString()),
+			};
+		}
+	}
+	/// <summary>
+	/// Whether to show the progress indicator. 
+	/// </summary>
+	[Parameter]
+	public bool ShowProgressIndicator { get; set; } = false;
+	/// <summary>
+	/// The color of the progress indicator. 
+	/// </summary>
+	[Parameter]
+	public ThemeColor ProgressIndicatorColor { get; set; } = ThemeColor.Default;
+	private bool IsLoading => _currentSearchTask is not null && !_currentSearchTask.IsCompleted;
+	/// <summary>
+	/// Func that returns a list of items matching the typed text. Provides a cancellation token that
+	/// is marked as cancelled when the user changes the search text or selects a value from the list. 
+	/// This can be used to cancel expensive asynchronous work occuring within the SearchFunc itself.
+	/// </summary>
+	[Parameter]
+	public Func<string, CancellationToken, Task<IEnumerable<T>>> SearchFuncWithCancel { get; set; }
+	/// <summary>
+	/// The SearchFunc returns a list of items matching the typed text
+	/// </summary>
+	[Parameter]
+	public Func<string, Task<IEnumerable<T>>> SearchFunc { get; set; }
+	/// <summary>
+	/// Maximum items to display, defaults to 10.
+	/// A null value will display all items.
+	/// </summary>
+	[Parameter]
+	public int? MaxItems { get; set; } = 10;
+	/// <summary>
+	/// Minimum characters to initiate a search
+	/// </summary>
+	[Parameter]
+	public int MinCharacters { get; set; } = 0;
+	/// <summary>
+	/// Reset value if user deletes the text
+	/// </summary>
+	[Parameter]
+	public bool ResetValueOnEmptyText { get; set; } = false;
+	/// <summary>
+	/// If true, clicking the text field will select (highlight) its contents.
+	/// </summary>
+	[Parameter]
+	public bool SelectOnClick { get; set; } = true;
+	/// <summary>
+	/// Debounce interval in milliseconds.
+	/// </summary>
+	[Parameter]
+	public int DebounceInterval { get; set; } = 100;
+	/// <summary>
+	/// Optional presentation template for unselected items
+	/// </summary>
+	[Parameter]
+	public RenderFragment<T> ItemTemplate { get; set; }
+	/// <summary>
+	/// Optional presentation template for the selected item
+	/// </summary>
+	[Parameter]
+	public RenderFragment<T> ItemSelectedTemplate { get; set; }
+	/// <summary>
+	/// Optional presentation template for disabled item
+	/// </summary>
+	[Parameter]
+	public RenderFragment<T> ItemDisabledTemplate { get; set; }
+	/// <summary>
+	/// Optional presentation template for when more items were returned from the Search function than the MaxItems limit
+	/// </summary>
+	[Parameter]
+	public RenderFragment MoreItemsTemplate { get; set; }
+	/// <summary>
+	/// Optional presentation template for when no items were returned from the Search function
+	/// </summary>
+	[Parameter]
+	public RenderFragment NoItemsTemplate { get; set; }
+	/// <summary>
+	/// Optional template for progress indicator
+	/// </summary>
+	[Parameter]
+	public RenderFragment ProgressIndicatorTemplate { get; set; }
+	/// <summary>
+	/// Optional template for showing progress indicator inside the popover
+	/// </summary>
+	[Parameter]
+	public RenderFragment ProgressIndicatorInPopoverTemplate { get; set; }
+	/// <summary>
+	/// On drop-down close override Text with selected Value. This makes it clear to the user
+	/// which list value is currently selected and disallows incomplete values in Text.
+	/// </summary>
+	[Parameter]
+	public bool CoerceText { get; set; } = true;
+	/// <summary>
+	/// If user input is not found by the search func and CoerceValue is set to true the user input
+	/// will be applied to the Value which allows to validate it and display an error message.
+	/// </summary>
+	[Parameter]
+	public bool CoerceValue { get; set; }
+	/// <summary>
+	/// Function to be invoked when checking whether an item should be disabled or not
+	/// </summary>
+	[Parameter]
+	public Func<T, bool> ItemDisabledFunc { get; set; }
+	/// <summary>
+	/// Returns the open state of the drop-down.
+	/// </summary>
+	public bool IsOpen
+	{
+		get => _isOpen;
+		// Note: the setter is protected because it was needed by a user who derived his own autocomplete from this class.
+		// Note: setting IsOpen will not open or close it. Use ToggleMenu() for that. 
+		protected set
+		{
+			if (value == _isOpen)
+				return;
+
+			_isOpen = value;
+
+			IsOpenChanged.InvokeAsync(_isOpen).AndForget();
+		}
+	}
+	/// <summary>
+	/// An event triggered when the state of IsOpen has changed
+	/// </summary>
+	[Parameter]
+	public EventCallback<bool> IsOpenChanged { get; set; }
+	/// <summary>
+	/// If true, the currently selected item from the drop-down (if it is open) is selected.
+	/// </summary>
+	[Parameter]
+	public bool SelectValueOnTab { get; set; } = false;
+	/// <summary>
+	/// Show clear button.
+	/// </summary>
+	[Parameter]
+	public bool Clearable { get; set; } = false;
+	/// <summary>
+	/// Button click event for clear button. Called after text and value has been cleared.
+	/// </summary>
+	[Parameter]
+	public EventCallback<MouseEventArgs> OnClearButtonClick { get; set; }
+
+	private string CurrentIcon => !string.IsNullOrWhiteSpace(AdornmentIcon) ? AdornmentIcon : _isOpen ? CloseIcon : OpenIcon;
+
+	protected string ClassList()
+	{
+		return new CssBuilder("select")
+		  .AddClass(Class)
+		  .Build();
+	}
+
+	protected string AutocompleteClassList()
+	{
+		return new CssBuilder("select")
+		  .AddClass("autocomplete")
+		  .AddClass("width-full", FullWidth)
+		  .AddClass("autocomplete--with-progress", ShowProgressIndicator && IsLoading)
+		  .Build();
+	}
+
+	protected string CircularProgressClassList()
+	{
+		return new CssBuilder("progress-indicator-circular")
+			.AddClass("progress-indicator-circular--with-adornment", Adornment == Adornment.End)
+			.Build();
+	}
+
+	public async Task SelectOption(T value)
+	{
+		await SetValueAsync(value);
+
+		if (_items is not null)
+			_selectedListItemIndex = Array.IndexOf(_items, value);
+
+		var optionText = GetItemString(value);
+
+		if (!_isCleared)
+			await SetTextAsync(optionText, false);
+
+		_timer?.Dispose();
+
+		IsOpen = false;
+
+		BeginValidate();
+
+		if (!_isCleared)
+			_elementReference?.SetText(optionText);
+
+		_elementReference?.FocusAsync().AndForget();
+
+		StateHasChanged();
+	}
+	/// <summary>
+	/// Toggle the menu (if not disabled or not readonly, and is opened).
+	/// </summary>
+	public async Task ToggleMenu()
+	{
+		if ((Disabled || ReadOnly) && !IsOpen)
+			return;
+
+		await ChangeMenu(!IsOpen);
+	}
+
+	private async Task ChangeMenu(bool open)
+	{
+		if (open)
+		{
+			if (SelectOnClick)
+				await _elementReference.SelectAsync();
+
+			await OnSearchAsync();
+		}
+		else
+		{
+			_timer?.Dispose();
+
+			RestoreScrollPosition();
+
+			await CoerceTextToValue();
+
+			IsOpen = false;
+
+			StateHasChanged();
+		}
+	}
+
+	protected override void OnInitialized()
+	{
+		var text = GetItemString(Value);
+
+		if (!string.IsNullOrWhiteSpace(text))
+			Text = text;
+	}
+
+	protected override void OnAfterRender(bool firstRender)
+	{
+		_isCleared = false;
+
+		base.OnAfterRender(firstRender);
+	}
+
+	protected override Task UpdateTextPropertyAsync(bool updateValue)
+	{
+		_timer?.Dispose();
+		// This keeps the text from being set when clear() was called
+		if (_isCleared)
+			return Task.CompletedTask;
+
+		return base.UpdateTextPropertyAsync(updateValue);
+	}
+
+	protected override async Task UpdateValuePropertyAsync(bool updateText)
+	{
+		_timer?.Dispose();
+
+		if (ResetValueOnEmptyText && string.IsNullOrWhiteSpace(Text))
+			await SetValueAsync(default, updateText);
+
+		if (DebounceInterval <= 0)
+			await OnSearchAsync();
+		else
+			_timer = new Timer(OnTimerComplete, null, DebounceInterval, Timeout.Infinite);
+	}
+
+	private void OnTimerComplete(object stateInfo)
+	{
+		InvokeAsync(OnSearchAsync);
+	}
+	private void CancelToken()
+	{
+		try
+		{
+			_cancellationTokenSrc?.Cancel();
+		}
+		catch
+		{
+		}
+
+		_cancellationTokenSrc = new CancellationTokenSource();
+	}
+	/// <remarks>
+	/// This async method needs to return a task and be awaited in order for
+	/// unit tests that trigger this method to work correctly.
+	/// </remarks>
+	private async Task OnSearchAsync()
+	{
+		if (MinCharacters > 0 && (string.IsNullOrWhiteSpace(Text) || Text.Length < MinCharacters))
+		{
+			IsOpen = false;
+			StateHasChanged();
+			return;
+		}
+
+		IEnumerable<T> searchedItems = Array.Empty<T>();
+		CancelToken();
+
+		try
+		{
+			if (ProgressIndicatorInPopoverTemplate is not null)
+				IsOpen = true;
+
+			var searchTask = SearchFuncWithCancel is not null ? SearchFuncWithCancel(Text, _cancellationTokenSrc.Token) : SearchFunc(Text);
+
+			_currentSearchTask = searchTask;
+
+			StateHasChanged();
+
+			searchedItems = await searchTask ?? Array.Empty<T>();
+		}
+		catch (TaskCanceledException)
+		{
+		}
+		catch (OperationCanceledException)
+		{
+		}
+		catch (Exception e)
+		{
+			Console.WriteLine($"The search function failed to return results: {e.Message}");
+		}
+
+		_itemsReturned = searchedItems.Count();
+
+		if (MaxItems.HasValue)
+			searchedItems = searchedItems.Take(MaxItems.Value);
+
+		_items = searchedItems.ToArray();
+		_enabledItemIndices = _items.Select((item, idx) => (item, idx)).Where(tuple => ItemDisabledFunc?.Invoke(tuple.item) != true).Select(tuple => tuple.idx).ToList();
+		_selectedListItemIndex = _enabledItemIndices.Any() ? _enabledItemIndices.First() : -1;
+
+		IsOpen = true;
+
+		if (_items?.Length == 0)
+		{
+			await CoerceValueToText();
+
+			StateHasChanged();
+
+			return;
+		}
+
+		StateHasChanged();
+	}
+
+	/// <summary>
+	/// Clears the autocomplete's text
+	/// </summary>
+	public async Task Clear()
+	{
+		_isCleared = true;
+		IsOpen = false;
+
+		await SetTextAsync(string.Empty, updateValue: false);
+		await CoerceValueToText();
+
+		if (_elementReference is not null)
+			await _elementReference.SetText(string.Empty);
+
+		_timer?.Dispose();
+
+		StateHasChanged();
+	}
+
+	protected override async void ResetValue()
+	{
+		await Clear();
+		base.ResetValue();
+	}
+
+	private string GetItemString(T item)
+	{
+		if (item is null)
+			return string.Empty;
+		try
+		{
+			return Converter.Set(item);
+		}
+		catch (NullReferenceException) { }
+
+		return "null";
+	}
+
+	internal virtual async Task OnInputKeyDown(KeyboardEventArgs args)
+	{
+		switch (args.Key)
+		{
+			case "Tab":
+				// NOTE: We need to catch Tab in Keydown because a tab will move focus to the next element and thus
+				// in OnInputKeyUp we'd never get the tab key
+				if (!IsOpen)
+					return;
+				if (SelectValueOnTab)
+					await OnEnterKey();
+				else
+					IsOpen = false;
+				break;
+		}
+	}
+
+	internal virtual async Task OnInputKeyUp(KeyboardEventArgs args)
+	{
+		switch (args.Key)
+		{
+			case "Enter":
+			case "NumpadEnter":
+				if (!IsOpen)
+					await ToggleMenu();
+				else
+					await OnEnterKey();
+
+				break;
+			case "ArrowDown":
+				if (!IsOpen)
+					await ToggleMenu();
+				else
+				{
+					var increment = _enabledItemIndices.ElementAtOrDefault(_enabledItemIndices.IndexOf(_selectedListItemIndex) + 1) - _selectedListItemIndex;
+
+					await SelectNextItem(increment < 0 ? 1 : increment);
+				}
+
+				break;
+			case "ArrowUp":
+				if (args.AltKey)
+					await ChangeMenu(false);
+				else if (!IsOpen)
+					await ToggleMenu();
+				else
+				{
+					var decrement = _selectedListItemIndex - _enabledItemIndices.ElementAtOrDefault(_enabledItemIndices.IndexOf(_selectedListItemIndex) - 1);
+					await SelectNextItem(-(decrement < 0 ? 1 : decrement));
+				}
+
+				break;
+			case "Escape":
+				await ChangeMenu(false);
+
+				break;
+			case "Tab":
+				await Task.Delay(1);
+
+				if (!IsOpen)
+					return;
+
+				if (SelectValueOnTab)
+					await OnEnterKey();
+				else
+					await ToggleMenu();
+
+				break;
+			case "Backspace":
+				if (args.CtrlKey && args.ShiftKey)
+					Reset();
+				break;
+		}
+
+		base.InvokeKeyUp(args);
+	}
+
+	private ValueTask SelectNextItem(int increment)
+	{
+		if (increment == 0 || _items is null || !_items.Any() || !_enabledItemIndices.Any())
+			return ValueTask.CompletedTask;
+		// if we are at the end, or the beginning we just do an rollover
+		_selectedListItemIndex = Math.Clamp(value: (10 * _items.Length + _selectedListItemIndex + increment) % _items.Length, min: 0, max: _items.Length - 1);
+
+		return ScrollToListItem(_selectedListItemIndex);
+	}
+	/// <summary>
+	/// Scroll to a specific item index in the Autocomplete list of items.
+	/// </summary>
+	/// <param name="index">the index to scroll to</param>
+	public ValueTask ScrollToListItem(int index)
+	{
+		var id = GetListItemId(index);
+		//id of the scrolled element
+		return ScrollManager.ScrollToListItemAsync(id);
+	}
+	/*
+	 * This restores the scroll position after closing the menu and element being 0
+	 */
+	private void RestoreScrollPosition()
+	{
+		if (_selectedListItemIndex != 0)
+			return;
+
+		ScrollManager.ScrollToListItemAsync(GetListItemId(0));
+	}
+
+	private string GetListItemId(in int index)
+	{
+		return $"{_componentId}_item{index}";
+	}
+
+	internal Task OnEnterKey()
+	{
+		if (!IsOpen)
+			return Task.CompletedTask;
+
+		if (_items is null || !_items.Any())
+			return Task.CompletedTask;
+
+		if (_selectedListItemIndex >= 0 && _selectedListItemIndex < _items.Length)
+			return SelectOption(_items[_selectedListItemIndex]);
+
+		return Task.CompletedTask;
+	}
+
+	private Task OnInputBlurred(FocusEventArgs args)
+	{
+		OnBlur.InvokeAsync(args);
+
+		return Task.CompletedTask;
+		// we should not validate on blur in autocomplete, because the user needs to click out of the input to select a value,
+		// resulting in a premature validation. thus, don't call base
+		//base.OnBlurred(args);
+	}
+
+	private Task CoerceTextToValue()
+	{
+		if (!CoerceText)
+			return Task.CompletedTask;
+
+		_timer?.Dispose();
+
+		var text = Value is null ? null : GetItemString(Value);
+		/*
+		 * Don't update the value to prevent the popover from opening again after coercion
+		 */
+		if (text != Text)
+			return SetTextAsync(text, updateValue: false);
+
+		return Task.CompletedTask;
+	}
+
+	private Task CoerceValueToText()
+	{
+		if (!CoerceValue)
+			return Task.CompletedTask;
+
+		_timer?.Dispose();
+
+		var value = Converter.Get(Text);
+
+		return SetValueAsync(value, updateText: false);
+	}
+
+	protected override void Dispose(bool disposing)
+	{
+		_timer?.Dispose();
+
+		if (_cancellationTokenSrc is not null)
+		{
+			try
+			{
+				_cancellationTokenSrc.Dispose();
+			}
+			catch { }
+		}
+
+		base.Dispose(disposing);
+	}
+	/// <summary>
+	/// Focus the input in the Autocomplete component.
+	/// </summary>
+	public override ValueTask FocusAsync()
+	{
+		return _elementReference.FocusAsync();
+	}
+	/// <summary>
+	/// Blur from the input in the Autocomplete component.
+	/// </summary>
+	public override ValueTask BlurAsync()
+	{
+		return _elementReference.BlurAsync();
+	}
+
+	/// <summary>
+	/// Select all text within the Autocomplete input.
+	/// </summary>
+	public override ValueTask SelectAsync()
+	{
+		return _elementReference.SelectAsync();
+	}
+
+	/// <summary>
+	/// Select all text within the Autocomplete input and aligns its start and end points to the text content of the current input.
+	/// </summary>
+	public override ValueTask SelectRangeAsync(int pos1, int pos2)
+	{
+		return _elementReference.SelectRangeAsync(pos1, pos2);
+	}
+
+	private async Task OnTextChanged(string text)
+	{
+		await TextChanged.InvokeAsync();
+
+		if (text is null)
+			return;
+
+		await SetTextAsync(text, true);
+	}
+
+	private async Task ListItemOnClick(T item)
+	{
+		await SelectOption(item);
+	}
+}

Components/BooleanInput.cs

@@ -44,17 +44,17 @@ public class BooleanInput<T> : FormComponent<T, bool?>
 	/// </summary>
 	[Parameter] public EventCallback<T> CheckedChanged { get; set; }
 
-	protected bool? BoolValue => Converter.Convert(Checked);
+	protected bool? BoolValue => Converter.Set(Checked);
 
 	protected virtual Task OnChange(ChangeEventArgs args)
 	{
-		Modified = true;
+		Touched = true;
 		return SetBoolValueAsync((bool?)args.Value);
 	}
 
 	protected Task SetBoolValueAsync(bool? value)
 	{
-		return SetCheckedAsync(Converter.ConvertBack(value));
+		return SetCheckedAsync(Converter.Get(value));
 	}
 
 	protected async Task SetCheckedAsync(T value)
@@ -74,7 +74,7 @@ public class BooleanInput<T> : FormComponent<T, bool?>
 	{
 		var changed = base.SetConverter(value);
 		if (changed)
-			SetBoolValueAsync(Converter.Convert(Checked)).AndForget();
+			SetBoolValueAsync(Converter.Set(Checked)).AndForget();
 
 		return changed;
 	}

Components/CheckBox/CheckBox.razor.cs

@@ -139,7 +139,7 @@ public partial class CheckBox<T> : BooleanInput<T>
 
 	protected override Task OnChange(ChangeEventArgs args)
 	{
-		Modified = true;
+		Touched = true;
 
 		// Apply only when TriState parameter is set to true and T is bool?
 		if (TriState && typeof(T) == typeof(bool?))