@spartan-ng/brain 0.0.1-alpha.608 → 0.0.1-alpha.609

package/autocomplete/index.d.ts

@@ -1,7 +1,9 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, Type, ExistingProvider } from '@angular/core';
+import { InputSignal, ModelSignal, Signal, InjectionToken, Type, ExistingProvider, ValueProvider } from '@angular/core';
 import { Highlightable, ActiveDescendantKeyManager } from '@angular/cdk/a11y';
 import { BooleanInput } from '@angular/cdk/coercion';
+import { ControlValueAccessor } from '@angular/forms';
+import { ChangeFn, TouchFn } from '@spartan-ng/brain/forms';
 
 declare class BrnAutocompleteItem<T> implements Highlightable {
     private static _id;
@@ -13,101 +15,261 @@ declare class BrnAutocompleteItem<T> implements Highlightable {
     readonly id: _angular_core.InputSignal<string>;
     /** The value this item represents. */
     readonly value: _angular_core.InputSignal<T>;
-    /** Whether the item is disabled. */
     readonly _disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /** Expose disabled as a value - used by the Highlightable interface */
     get disabled(): boolean;
     /** Whether the item is selected. */
-    protected readonly _active: _angular_core.WritableSignal<boolean>;
-    /** Emits when the item is selected. */
-    readonly selected: _angular_core.OutputEmitterRef<void>;
-    /** @internal Get the display value */
-    getLabel(): string;
-    /** @internal */
+    readonly active: _angular_core.Signal<boolean>;
+    protected readonly _highlighted: _angular_core.WritableSignal<boolean>;
     setActiveStyles(): void;
-    /** @internal */
     setInactiveStyles(): void;
-    protected onClick(): void;
+    getLabel(): string;
+    protected select(): void;
     protected activate(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnAutocompleteItem<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocompleteItem<any>, "button[brnAutocompleteItem]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "_disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocompleteItem<any>, "[brnAutocompleteItem]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "_disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class BrnAutocomplete<T> {
-    private static _id;
+interface BrnAutocompleteBase<T> {
+    itemToString: InputSignal<AutocompleteItemToString<T> | undefined>;
+    search: ModelSignal<string>;
+    disabled: Signal<boolean>;
+    disabledState: Signal<boolean>;
+    keyManager: ActiveDescendantKeyManager<BrnAutocompleteItem<T>>;
+    value: ModelSignal<T | null> | ModelSignal<string | null>;
+    visibleItems: Signal<boolean>;
+    isExpanded: Signal<boolean>;
+    searchInputWrapperWidth: Signal<number | null>;
+    updateSearch: (value: string) => void;
+    isSelected: (itemValue: T) => boolean;
+    select: (itemValue: T) => void;
+    open: () => void;
+    resetValue: () => void;
+    /** Select the active item with Enter key. */
+    selectActiveItem: () => void;
+}
+declare const BrnAutocompleteBaseToken: InjectionToken<BrnAutocompleteBase<unknown>>;
+declare function provideBrnAutocompleteBase<T>(autocomplete: Type<BrnAutocompleteBase<T>>): ExistingProvider;
+declare function injectBrnAutocompleteBase<T>(): BrnAutocompleteBase<T>;
+type AutocompleteItemEqualToValue<T> = (itemValue: T, selectedValue: T | null) => boolean;
+type AutocompleteItemToString<T> = (itemValue: T) => string;
+interface BrnAutocompleteConfig<T> {
+    isItemEqualToValue: AutocompleteItemEqualToValue<T>;
+    itemToString?: AutocompleteItemToString<T>;
+}
+declare function provideBrnAutocompleteConfig<T>(config: Partial<BrnAutocompleteConfig<T>>): ValueProvider;
+declare function injectBrnAutocompleteConfig<T>(): BrnAutocompleteConfig<T>;
+
+declare const BRN_AUTOCOMPLETE_VALUE_ACCESSOR: {
+    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: _angular_core.Type<any>;
+    multi: boolean;
+};
+declare class BrnAutocomplete<T> implements BrnAutocompleteBase<T>, ControlValueAccessor {
     private readonly _injector;
-    /** The id of the autocomplete */
-    readonly id: _angular_core.InputSignal<string>;
-    /** when the selection has changed */
-    readonly valueChange: _angular_core.OutputEmitterRef<T>;
-    /** when the selection has been cleared */
-    readonly selectionCleared: _angular_core.OutputEmitterRef<void>;
+    private readonly _config;
     /** Access the popover if present */
     private readonly _brnPopover;
-    /** @internal The focus strategy when opening */
-    private readonly _focus;
+    /** Whether the autocomplete is disabled */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _disabled: _angular_core.WritableSignal<boolean>;
+    /** @internal The disabled state as a readonly signal */
+    readonly disabledState: _angular_core.Signal<boolean>;
+    /** A function to compare an item with the selected value. */
+    readonly isItemEqualToValue: _angular_core.InputSignal<AutocompleteItemEqualToValue<T>>;
+    /** A function to convert an item to a string for display. */
+    readonly itemToString: _angular_core.InputSignal<AutocompleteItemToString<T> | undefined>;
+    /** The selected value of the autocomplete. */
+    readonly value: _angular_core.ModelSignal<T | null>;
+    /** The current search query. */
+    readonly search: _angular_core.ModelSignal<string>;
+    private readonly _searchInputWrapper;
+    /** @internal The width of the search input wrapper */
+    readonly searchInputWrapperWidth: _angular_core.Signal<number | null>;
     /** @internal Access all the items within the autocomplete */
     readonly items: _angular_core.Signal<readonly BrnAutocompleteItem<T>[]>;
+    /** Determine if the autocomplete has any visible items */
+    readonly visibleItems: _angular_core.Signal<boolean>;
     /** @internal The key manager for managing active descendant */
     readonly keyManager: ActiveDescendantKeyManager<BrnAutocompleteItem<T>>;
     /** @internal Whether the autocomplete is expanded */
     readonly isExpanded: _angular_core.Signal<boolean>;
+    protected _onChange?: ChangeFn<T | null>;
+    protected _onTouched?: TouchFn;
     constructor();
-    protected selectActiveItem(): void;
-    open(focus?: 'first' | 'last'): void;
+    updateSearch(value: string): void;
+    isSelected(itemValue: T): boolean;
+    select(itemValue: T): void;
+    /** Select the active item with Enter key. */
+    selectActiveItem(): void;
+    resetValue(): void;
+    open(): void;
     close(): void;
     toggle(): void;
+    /** CONTROL VALUE ACCESSOR */
+    writeValue(value: T | null): void;
+    registerOnChange(fn: ChangeFn<T | null>): void;
+    registerOnTouched(fn: TouchFn): void;
+    setDisabledState(isDisabled: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnAutocomplete<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocomplete<any>, "[brnAutocomplete]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "selectionCleared": "selectionCleared"; }, ["items"], never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocomplete<any>, "[brnAutocomplete]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "isItemEqualToValue": { "alias": "isItemEqualToValue"; "required": false; "isSignal": true; }; "itemToString": { "alias": "itemToString"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "search": "searchChange"; }, ["_searchInputWrapper", "items"], never, true, never>;
 }
 
-declare class BrnAutocompleteEmpty {
+declare class BrnAutocompleteAnchor {
+    private readonly _host;
+    private readonly _brnDialog;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnAutocompleteAnchor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocompleteAnchor, "[brnAutocompleteAnchor]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BrnAutocompleteClear {
+    private readonly _autocomplete;
+    private readonly _renderer;
     private readonly _templateRef;
     private readonly _viewContainerRef;
-    private readonly _autocomplete;
-    /** Determine if the autocomplete has any items */
-    private readonly _visible;
+    /** Determine if the combobox has a value */
+    private readonly _hasValue;
     constructor();
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnAutocompleteClear, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocompleteClear, "[brnAutocompleteClear]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BrnAutocompleteContent {
+    private readonly _autocomplete;
+    /** Determine if the autocomplete has any visible items */
+    protected readonly _visibleItems: _angular_core.Signal<boolean>;
+    protected readonly _autocompleteWidth: _angular_core.Signal<number | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnAutocompleteContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocompleteContent, "[brnAutocompleteContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BrnAutocompleteEmpty {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnAutocompleteEmpty, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocompleteEmpty, "[brnAutocompleteEmpty]", never, {}, {}, never, never, true, never>;
 }
 
 declare class BrnAutocompleteGroup {
+    /** Get the items in the group */
+    private readonly _items;
+    /** Determine if there are any visible items in the group */
+    protected readonly _visible: _angular_core.Signal<boolean>;
+    /** Get the label associated with the group */
+    private readonly _label;
+    protected readonly _labelledBy: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnAutocompleteGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocompleteGroup, "[brnAutocompleteGroup]", never, {}, {}, ["_items", "_label"], never, true, never>;
+}
+
+declare class BrnAutocompleteInput<T> {
     private static _id;
-    /** The id of the autocomplete list */
+    private readonly _el;
+    private readonly _autocomplete;
+    /** The id of the autocomplete input */
     readonly id: _angular_core.InputSignal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnAutocompleteGroup, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocompleteGroup, "[brnAutocompleteGroup]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    /** Whether the autocomplete panel is expanded */
+    protected readonly _isExpanded: _angular_core.Signal<boolean>;
+    constructor();
+    protected onInput(event: Event): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnAutocompleteInput<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocompleteInput<any>, "input[brnAutocompleteInput]", ["brnAutocompleteInput"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class BrnAutocompleteInputWrapper {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnAutocompleteInputWrapper, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocompleteInputWrapper, "[brnAutocompleteInputWrapper]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BrnAutocompleteLabel {
+    private static _id;
+    /** The id of the autocomplete label */
+    readonly id: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnAutocompleteLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocompleteLabel, "[brnAutocompleteLabel]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class BrnAutocompleteList {
     private static _id;
-    /** The id of the command list */
+    private readonly _autocomplete;
+    /** Determine if the autocomplete has any visible items */
+    protected readonly _visibleItems: _angular_core.Signal<boolean>;
+    /** The id of the autocomplete list */
     readonly id: _angular_core.InputSignal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnAutocompleteList, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocompleteList, "[brnAutocompleteList]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class BrnAutocompleteSearchInput {
-    private readonly _autocomplete;
-    /** Whether the autocomplete panel is expanded */
-    protected readonly _isExpanded: _angular_core.Signal<boolean>;
-    /** The id of the active option */
-    protected readonly _activeDescendant: _angular_core.WritableSignal<string | undefined>;
+declare const BRN_AUTOCOMPLETE_SEARCH_VALUE_ACCESSOR: {
+    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: _angular_core.Type<any>;
+    multi: boolean;
+};
+declare class BrnAutocompleteSearch<T> implements BrnAutocompleteBase<T>, ControlValueAccessor {
+    private readonly _injector;
+    private readonly _config;
+    /** Access the popover if present */
+    private readonly _brnPopover;
+    /** Whether the autocomplete is disabled */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _disabled: _angular_core.WritableSignal<boolean>;
+    /** @internal The disabled state as a readonly signal */
+    readonly disabledState: _angular_core.Signal<boolean>;
+    /** A function to convert an item to a string for display. */
+    readonly itemToString: _angular_core.InputSignal<AutocompleteItemToString<T> | undefined>;
+    /** The selected value of the autocomplete. */
+    readonly value: _angular_core.ModelSignal<string | null>;
+    /** The current search query. */
+    readonly search: _angular_core.ModelSignal<string>;
+    private readonly _searchInputWrapper;
+    /** @internal The width of the search input wrapper */
+    readonly searchInputWrapperWidth: _angular_core.Signal<number | null>;
+    /** @internal Access all the items within the autocomplete */
+    readonly items: _angular_core.Signal<readonly BrnAutocompleteItem<T>[]>;
+    /** Determine if the autocomplete has any visible items */
+    readonly visibleItems: _angular_core.Signal<boolean>;
+    /** @internal The key manager for managing active descendant */
+    readonly keyManager: ActiveDescendantKeyManager<BrnAutocompleteItem<T>>;
+    /** @internal Whether the autocomplete is expanded */
+    readonly isExpanded: _angular_core.Signal<boolean>;
+    protected _onChange?: ChangeFn<string | null>;
+    protected _onTouched?: TouchFn;
     constructor();
-    /** Listen for keydown events */
-    protected onKeyDown(event: KeyboardEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnAutocompleteSearchInput, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocompleteSearchInput, "input[brnAutocompleteSearchInput]", never, {}, {}, never, never, true, never>;
+    updateSearch(value: string): void;
+    isSelected(itemValue: T): boolean;
+    select(itemValue: T): void;
+    /** Select the active item with Enter key. */
+    selectActiveItem(): void;
+    resetValue(): void;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    /** CONTROL VALUE ACCESSOR */
+    writeValue(value: string | null): void;
+    registerOnChange(fn: ChangeFn<string | null>): void;
+    registerOnTouched(fn: TouchFn): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnAutocompleteSearch<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocompleteSearch<any>, "[brnAutocomplete]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "itemToString": { "alias": "itemToString"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "search": "searchChange"; }, ["_searchInputWrapper", "items"], never, true, never>;
+}
+
+declare class BrnAutocompleteSeparator {
+    readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnAutocompleteSeparator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocompleteSeparator, "[brnAutocompleteSeparator]", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class BrnAutocompleteStatus {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnAutocompleteStatus, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnAutocompleteStatus, "[brnAutocompleteStatus]", never, {}, {}, never, never, true, never>;
 }
 
 declare const BrnAutocompleteItemToken: InjectionToken<BrnAutocompleteItem<unknown>>;
 declare function provideBrnAutocompleteItem<T>(autocomplete: Type<BrnAutocompleteItem<T>>): ExistingProvider;
 
-declare const BrnAutocompleteToken: InjectionToken<BrnAutocomplete<unknown>>;
-declare function provideBrnAutocomplete<T>(autocomplete: Type<BrnAutocomplete<T>>): ExistingProvider;
-declare function injectBrnAutocomplete<T>(): BrnAutocomplete<T>;
-
-declare const BrnAutocompleteImports: readonly [typeof BrnAutocomplete, typeof BrnAutocompleteEmpty, typeof BrnAutocompleteGroup, typeof BrnAutocompleteItem, typeof BrnAutocompleteList, typeof BrnAutocompleteSearchInput];
+declare const BrnAutocompleteImports: readonly [typeof BrnAutocomplete, typeof BrnAutocompleteAnchor, typeof BrnAutocompleteClear, typeof BrnAutocompleteContent, typeof BrnAutocompleteEmpty, typeof BrnAutocompleteGroup, typeof BrnAutocompleteInput, typeof BrnAutocompleteInputWrapper, typeof BrnAutocompleteItem, typeof BrnAutocompleteLabel, typeof BrnAutocompleteList, typeof BrnAutocompleteSearch, typeof BrnAutocompleteSeparator, typeof BrnAutocompleteStatus];
 
-export { BrnAutocomplete, BrnAutocompleteEmpty, BrnAutocompleteGroup, BrnAutocompleteImports, BrnAutocompleteItem, BrnAutocompleteItemToken, BrnAutocompleteList, BrnAutocompleteSearchInput, BrnAutocompleteToken, injectBrnAutocomplete, provideBrnAutocomplete, provideBrnAutocompleteItem };
+export { BRN_AUTOCOMPLETE_SEARCH_VALUE_ACCESSOR, BRN_AUTOCOMPLETE_VALUE_ACCESSOR, BrnAutocomplete, BrnAutocompleteAnchor, BrnAutocompleteBaseToken, BrnAutocompleteClear, BrnAutocompleteContent, BrnAutocompleteEmpty, BrnAutocompleteGroup, BrnAutocompleteImports, BrnAutocompleteInput, BrnAutocompleteInputWrapper, BrnAutocompleteItem, BrnAutocompleteItemToken, BrnAutocompleteLabel, BrnAutocompleteList, BrnAutocompleteSearch, BrnAutocompleteSeparator, BrnAutocompleteStatus, injectBrnAutocompleteBase, injectBrnAutocompleteConfig, provideBrnAutocompleteBase, provideBrnAutocompleteConfig, provideBrnAutocompleteItem };
+export type { AutocompleteItemEqualToValue, AutocompleteItemToString, BrnAutocompleteBase, BrnAutocompleteConfig };