@koobiq/components 20.1.0 → 20.3.0

package/filter-bar/index.d.ts

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { AfterViewInit, ChangeDetectorRef, DestroyRef, ElementRef, TemplateRef, InjectionToken, ModelSignal, Signal, OutputEmitterRef, Type, Provider, OnInit, AfterContentInit } from '@angular/core';
 import * as _koobiq_components_core from '@koobiq/components/core';
-import { PopUpPlacements, KbqComponentColors, PopUpSizes, KbqOption, DateAdapter, DateFormatter, KbqPseudoCheckboxState } from '@koobiq/components/core';
+import { KbqPanelMaxHeight, PopUpPlacements, KbqComponentColors, PopUpSizes, KbqOption, DateAdapter, DateFormatter, KbqPseudoCheckboxState } from '@koobiq/components/core';
 import { Subject, BehaviorSubject, Observable } from 'rxjs';
 import { FocusMonitor, FocusOrigin } from '@angular/cdk/a11y';
 import { FormControl, FormGroup } from '@angular/forms';
@@ -10,6 +10,7 @@ import { KbqDropdownTrigger } from '@koobiq/components/dropdown';
 import { KbqPopoverTrigger } from '@koobiq/components/popover';
 import { KbqSelect } from '@koobiq/components/select';
 import { KbqListSelection } from '@koobiq/components/list';
+import { KbqInput } from '@koobiq/components/input';
 import { FlatTreeControl, KbqTreeFlattener, KbqTreeFlatDataSource, KbqTreeSelection, KbqTreeOption } from '@koobiq/components/tree';
 import { KbqTreeSelect } from '@koobiq/components/tree-select';
 
@@ -35,8 +36,6 @@ declare abstract class KbqBasePipe<V> implements AfterViewInit {
     protected readonly elementRef: ElementRef<HTMLElement>;
     private readonly inputModalityDetector;
     private readonly document;
-    /** Last known focus origin within the pipe. Used to preserve the keyboard focus ring on restore. */
-    private focusOrigin;
     /**
      * Whether this pipe has been destroyed. Guards deferred (`setTimeout`) work that could otherwise
      * read view queries or mutate `data` after the pipe was removed or the filter switched.
@@ -47,6 +46,23 @@ declare abstract class KbqBasePipe<V> implements AfterViewInit {
     protected values: any;
     /** TemplateRef for selecting an option */
     protected valueTemplate?: TemplateRef<any> | string;
+    /**
+     * Optional equality comparator forwarded from the pipe template to the underlying `kbq-select`.
+     * Only consumed by the select / multi-select pipe components; when unset they fall back to their
+     * own id-based `compareByValue`.
+     */
+    protected optionCompareWith?: (o1: KbqSelectValue | null | undefined, o2: KbqSelectValue | null | undefined) => boolean;
+    /**
+     * Values forwarded from the pipe template whose selection the user cannot remove. Only consumed by
+     * the multi-select pipe components; other pipe types ignore it.
+     */
+    protected lockedValues?: unknown[];
+    /**
+     * Maximum height of the dropdown panel's scrollable list, forwarded from the pipe template to the
+     * underlying `kbq-select` / `kbq-tree-select`. Only consumed by the select-family pipe components;
+     * `undefined` leaves the list at the select-family default of 256px.
+     */
+    protected panelMaxHeight?: KbqPanelMaxHeight;
     /**
      * Whether the current platform is a Mac.
      *
@@ -73,10 +89,33 @@ declare abstract class KbqBasePipe<V> implements AfterViewInit {
     onRemove(): void;
     /** clears the pipe and triggers changes */
     onClear(): void;
+    /**
+     * Value a cleared pipe is left with. Overridden by pipes that keep part of their value across a clear
+     * — the multi-select pipes hold on to their locked options.
+     *
+     * @docs-private
+     */
+    protected clearedValue(): V | null;
+    /**
+     * Focus origin to hand to {@link FocusMonitor} whenever this pipe moves focus programmatically, so the
+     * `.cdk-keyboard-focused` ring is painted for keyboard navigation only and never for a mouse-driven one.
+     *
+     * `InputModalityDetector.mostRecentModality` reflects what the user is doing *right now*, and is the
+     * only source that stays correct while a panel is open: panel content lives in the CDK overlay
+     * container, which is not a DOM descendant of the pipe host, so a focus origin captured on the host
+     * itself would freeze at "how the trigger was focused" and couldn't tell a click inside the panel apart
+     * from the keypress that opened it. The detector reacts only to `keydown`/`mousedown`/`touchstart`
+     * (never to hover or scroll), so merely moving the mouse cannot strip a keyboard user's ring, and it
+     * maps a screen reader's synthetic mousedown to `keyboard`. It falls back to `'program'` only before any
+     * such interaction has ever occurred on the page — at which point no ring should be shown anyway.
+     *
+     * @docs-private
+     */
+    protected get currentFocusOrigin(): NonNullable<FocusOrigin>;
     /**
      * Restores focus to the pipe's trigger button after a value is chosen or the panel closes.
-     * Focuses via {@link FocusMonitor} with the captured origin so a keyboard-driven interaction
-     * keeps its focus ring, while a mouse-driven one does not.
+     * Focuses via {@link FocusMonitor} with `currentFocusOrigin` so a keyboard-driven interaction keeps
+     * its focus ring, while a mouse-driven one does not.
      *
      * @docs-private
      */
@@ -159,6 +198,8 @@ declare const KBQ_FILTER_BAR_DEFAULT_CONFIGURATION: {
         customPeriodFrom: string;
         customPeriodTo: string;
         customPeriodErrorHint: string;
+        customPeriodMinIntervalErrorHint: string;
+        customPeriodMaxIntervalErrorHint: string;
         backToPeriodSelection: string;
     };
 };
@@ -211,6 +252,8 @@ declare const KBQ_FILTER_BAR_CONFIGURATION: InjectionToken<{
         customPeriodFrom: string;
         customPeriodTo: string;
         customPeriodErrorHint: string;
+        customPeriodMinIntervalErrorHint: string;
+        customPeriodMaxIntervalErrorHint: string;
         backToPeriodSelection: string;
     };
 }>;
@@ -272,6 +315,8 @@ declare const kbqFilterBarPipesProvider: () => Provider;
 declare enum KbqPipeTypes {
     ReadOnly = "readonly",
     Text = "text",
+    /** Renders a bare input: no popover, never opens. Commits while typing (debounced), on Enter and on blur. */
+    Input = "input",
     Select = "select",
     TreeSelect = "tree-select",
     MultiSelect = "multiselect",
@@ -327,6 +372,65 @@ interface KbqPipeData<V> extends KbqPipe {
 interface KbqPipeTemplate extends Omit<KbqPipe, 'value'> {
     values?: unknown[];
     valueTemplate?: TemplateRef<any> | string;
+    /**
+     * Custom equality comparator forwarded to the underlying `kbq-select` of the `select` /
+     * `multiselect` pipes. When omitted, the pipe's default id-based comparator (`compareByValue`)
+     * is used. Ignored by other pipe types.
+     */
+    compareWith?: (o1: KbqSelectValue | null | undefined, o2: KbqSelectValue | null | undefined) => boolean;
+    /**
+     * Options whose selection cannot be removed by the user: they are always selected, render as
+     * `disabled` with a checked checkbox, and survive both "select all" toggling and clearing the pipe.
+     *
+     * Entries have the same shape as the entries of the owning pipe's `value`: `KbqSelectValue` objects
+     * for the `multiselect` pipe (matched with `compareWith`, falling back to the pipe's id-based
+     * comparator), and raw node values for the `multi-tree-select` pipe. Locking a tree branch locks its
+     * whole subtree. Ignored by other pipe types.
+     */
+    lockedValues?: unknown[];
+    /**
+     * Maximum height of the dropdown panel's scrollable list, in pixels, forwarded to the underlying
+     * `kbq-select` / `kbq-tree-select` of the `select`, `multiselect`, `tree-select` and `multi-tree-select`
+     * pipes. Omitting it — or passing `null` — keeps the select-family default of 256px, i.e. exactly eight
+     * 32px options.
+     *
+     * The cap covers the scrollable list only, and the list's own padding is added on top of it, so a
+     * multiple of the option height fits without a scrollbar. The pipe's search field is rendered above the
+     * list and adds to the panel's total height, while the "select all" row scrolls with the options and is
+     * counted by the cap. A value taller than the room left in the viewport is clipped by the overlay rather
+     * than scrolled. Ignored by other pipe types.
+     */
+    panelMaxHeight?: KbqPanelMaxHeight;
+    /**
+     * Earliest selectable instant for the `date` / `datetime` pipe custom period. Accepts any value the
+     * configured `DateAdapter` can deserialize (with the default Luxon adapter: an ISO-8601 string, a
+     * `Date`, or a `DateTime`). The `date` pipe uses only its day (pinned to the start of day). Ignored by
+     * other pipe types.
+     */
+    minDateTime?: unknown;
+    /**
+     * Latest selectable instant for the `date` / `datetime` pipe custom period. See
+     * {@link KbqPipeTemplate.minDateTime}. The `date` pipe uses only its day (pinned to the end of day).
+     * Ignored by other pipe types.
+     */
+    maxDateTime?: unknown;
+    /**
+     * Minimum length of the `date` / `datetime` pipe custom period (`end − start`), as a Luxon
+     * duration-like object, e.g. `{ days: 1 }` or `{ hours: 2 }`. When the selected period is shorter, the
+     * editor shows an error and disables Apply. Ignored by other pipe types.
+     *
+     * Unlike {@link KbqPipeTemplate.minDateTime}, this value is NOT deserialized through the configured
+     * `DateAdapter` — it is applied directly via the date value's own `.plus()`, so this option currently
+     * assumes the default Luxon adapter and is not portable to other `DateAdapter` implementations (e.g.
+     * the Moment adapter).
+     */
+    minInterval?: unknown;
+    /**
+     * Maximum length of the `date` / `datetime` pipe custom period (`end − start`). See
+     * {@link KbqPipeTemplate.minInterval}. When the selected period is longer, the editor shows an error and
+     * disables Apply. Ignored by other pipe types.
+     */
+    maxInterval?: unknown;
 }
 interface KbqSaveFilterError {
     text?: string;
@@ -388,6 +492,8 @@ declare class KbqFilterReset {
  */
 declare class KbqFilterSavePopover implements AfterViewInit {
     private readonly changeDetectorRef;
+    private readonly focusMonitor;
+    private readonly inputModalityDetector;
     /** Popover trigger owned by the parent (`KbqFilters` main button). */
     readonly popoverTrigger: _angular_core.InputSignal<KbqPopoverTrigger>;
     /** Filter bar, used for the save payload, the current filter and localized strings. */
@@ -409,7 +515,8 @@ declare class KbqFilterSavePopover implements AfterViewInit {
     /** true if saving a new filter, false if saving changes in filter */
     saveNewFilter: boolean;
     showFilterSavingError: boolean;
-    filterSavingErrorText: string;
+    /** Custom error text passed to `showError()`; `null` when the locale-derived default should be used. */
+    private customErrorText;
     isSaving: boolean;
     /** localized data
      * @docs-private */
@@ -431,6 +538,9 @@ declare class KbqFilterSavePopover implements AfterViewInit {
         cancelButton: string;
         actionsTooltip: string;
     };
+    /** Filter saving error text (custom or locale-derived).
+     * @docs-private */
+    get filterSavingErrorText(): string;
     /** header of popover. Depends on the mode */
     get popoverHeader(): string;
     ngAfterViewInit(): void;
@@ -647,11 +757,15 @@ declare class KbqFilterBar implements KbqFilterBarHost {
             customPeriodFrom: string;
             customPeriodTo: string;
             customPeriodErrorHint: string;
+            customPeriodMinIntervalErrorHint: string;
+            customPeriodMaxIntervalErrorHint: string;
             backToPeriodSelection: string;
         };
     } | null;
     /** Localized strings and configuration for the filter-bar and its pipes. */
-    configuration: KbqFilterBarConfiguration;
+    get configuration(): KbqFilterBarConfiguration;
+    set configuration(value: KbqFilterBarConfiguration);
+    private readonly _configuration;
     /** @docs-private */
     readonly filters: _angular_core.Signal<KbqFilters | undefined>;
     /** @docs-private */
@@ -792,6 +906,8 @@ declare class KbqFilterRefresher {
             customPeriodFrom: string;
             customPeriodTo: string;
             customPeriodErrorHint: string;
+            customPeriodMinIntervalErrorHint: string;
+            customPeriodMaxIntervalErrorHint: string;
             backToPeriodSelection: string;
         };
     };
@@ -908,12 +1024,53 @@ declare abstract class KbqPipeDateBaseComponent<D> extends KbqBasePipe<KbqDateTi
     protected showStartCalendar: boolean;
     /** @docs-private */
     protected showEndCalendar: boolean;
+    /**
+     * Lower bound instant applied to the calendars, date inputs and (datetime) timepickers.
+     * @docs-private
+     */
+    protected min: any;
+    /**
+     * Upper bound instant applied to the calendars, date inputs and (datetime) timepickers.
+     * @docs-private
+     */
+    protected max: any;
+    /** Minimum length of the custom period (`end − start`), resolved from the template as a duration-like object. */
+    private minInterval?;
+    /** Maximum length of the custom period (`end − start`), resolved from the template as a duration-like object. */
+    private maxInterval?;
+    /** Canonical duration units (largest-first) used to render an interval limit faithfully to its config. */
+    private static readonly INTERVAL_UNITS;
     /** @docs-private */
     readonly popover: _angular_core.Signal<KbqPopoverTrigger>;
     /** @docs-private */
-    readonly listSelection: _angular_core.Signal<KbqListSelection | undefined>;
+    readonly listSelection: _angular_core.Signal<KbqListSelection<any> | undefined>;
     /** @docs-private */
     readonly returnButton: _angular_core.Signal<KbqButton>;
+    /** Resolves the `minDateTime` / `maxDateTime` bounds from the pipe template matching this pipe. */
+    private updateDateBounds;
+    /**
+     * Deserializes a `minDateTime` / `maxDateTime` template value, treating an unset (`null`/`undefined`)
+     * value and an unparseable one alike as "no bound", so call sites need no own null-check.
+     */
+    private toValidDate;
+    /**
+     * Validates a `minInterval` / `maxInterval` template value, treating anything that isn't a genuine
+     * duration-like object — or that resolves to an invalid or sub-second span — as "no constraint"
+     * instead of letting it crash `validateInterval`/`formatInterval` downstream (both call `.plus()` on
+     * it directly). A bare number is rejected too: Luxon would silently read it as milliseconds, which
+     * would otherwise disable the constraint without any error (e.g. a `{ days: 5 }` typo'd as `5`).
+     */
+    private toValidInterval;
+    /** Clamps `value` into the configured `[min, max]` bounds using full-instant comparison. */
+    private clampToBounds;
+    /**
+     * Cross-field validator flagging the custom period when its length (`end − start`) is outside the
+     * configured `[minInterval, maxInterval]`. Intervals are applied via `DateTime.plus`, so calendar units
+     * (months/years) are respected; unset intervals impose no constraint.
+     */
+    private validateInterval;
+    /** Formats a duration-like interval as a locale-aware human string via the formatter, e.g. "7 дней". */
+    private formatInterval;
     /** formatted value for period */
     get formattedValue(): string;
     /** Whether the current pipe is disabled. */
@@ -926,6 +1083,42 @@ declare abstract class KbqPipeDateBaseComponent<D> extends KbqBasePipe<KbqDateTi
     get end(): D;
     /** default object for end */
     get defaultEnd(): D;
+    /**
+     * Computes the default `start`/`end` pair used when the pipe has no stored value, clamped into
+     * `[min, max]` and, unlike a plain clamp, also reconciled against `[minInterval, maxInterval]`: `end`
+     * is extended or shrunk to fit, falling back to pulling `start` back when `[min, max]` doesn't leave
+     * enough room past `start` to satisfy `minInterval`. If `[min, max]` is itself narrower than
+     * `minInterval`, the result may still violate it — that's a contradictory host configuration (the
+     * same class of issue as `min` configured later than `max`), not something to further engineer around.
+     */
+    private computeDefaultRange;
+    /**
+     * Upper bound for the START date input: the earlier of the END value and the configured `max`.
+     * @docs-private
+     */
+    get startMax(): any;
+    /**
+     * Whether the period is invalid specifically because it runs backwards (`start` later than `end`) —
+     * the one case `customPeriodErrorHint` actually describes. Deliberately compares the values rather
+     * than keying off the START control's `kbqDatepickerMax` error: `startMax` is `min(max, end)`, so that
+     * error fires both for a backwards period AND for a start beyond the configured `max`, and cannot
+     * tell them apart. Everything else that can invalidate a control here — a value outside
+     * `[min, max]` (`kbqDatepickerMin`/`kbqDatepickerMax`, `kbqTimepickerLowerThenMin`/
+     * `kbqTimepickerHigherThenMax`) or unparseable typed text (`kbqDatepickerParse`/`kbqTimepickerParse`)
+     * — is left to the field's own error styling instead of being mislabelled as an ordering problem.
+     * @docs-private
+     */
+    protected get isPeriodInverted(): boolean;
+    /**
+     * Localized "period too short" hint with the `minInterval` limit interpolated and locale-formatted.
+     * @docs-private
+     */
+    get minIntervalErrorHint(): string;
+    /**
+     * Localized "period too long" hint with the `maxInterval` limit interpolated and locale-formatted.
+     * @docs-private
+     */
+    get maxIntervalErrorHint(): string;
     /** Whether the current pipe is empty. */
     get isEmpty(): boolean;
     ngAfterViewInit(): void;
@@ -943,6 +1136,11 @@ declare abstract class KbqPipeDateBaseComponent<D> extends KbqBasePipe<KbqDateTi
     onFocusStartInput(): void;
     onFocusEndInput(): void;
     hideCalendars(): void;
+    /**
+     * Whether this pipe edits the time part (`datetime`) or only the date (`date`). Gates whether the
+     * `minDateTime` / `maxDateTime` bounds keep their time or are pinned to day edges.
+     */
+    protected abstract usesTime(): boolean;
     /** Formats the selected range for display. */
     protected abstract formatRange(start: D, end: D): string;
     /** Default start value used when the pipe has no stored `start`. */
@@ -955,6 +1153,7 @@ declare abstract class KbqPipeDateBaseComponent<D> extends KbqBasePipe<KbqDateTi
 }
 
 declare class KbqPipeDateComponent<D> extends KbqPipeDateBaseComponent<D> {
+    protected usesTime(): boolean;
     protected formatRange(start: D, end: D): string;
     protected getDefaultStart(): D;
     protected getDefaultEnd(): D;
@@ -963,6 +1162,7 @@ declare class KbqPipeDateComponent<D> extends KbqPipeDateBaseComponent<D> {
 }
 
 declare class KbqPipeDatetimeComponent<D> extends KbqPipeDateBaseComponent<D> {
+    protected usesTime(): boolean;
     protected formatRange(start: D, end: D): string;
     protected getDefaultStart(): D;
     protected getDefaultEnd(): D;
@@ -970,6 +1170,44 @@ declare class KbqPipeDatetimeComponent<D> extends KbqPipeDateBaseComponent<D> {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPipeDatetimeComponent<any>, "kbq-pipe-datetime", never, {}, {}, never, never, true, never>;
 }
 
+declare class KbqPipeInputComponent extends KbqBasePipe<string | null> implements OnInit {
+    /** @docs-private */
+    protected readonly input: _angular_core.Signal<KbqInput>;
+    /**
+     * Input control.
+     *
+     * Must stay nullable: `KbqCleaner` resets the control, and `reset()` resolves to `defaultValue`, which is
+     * `null` only while `nonNullable` is unset. `{ nonNullable: true }` would make `reset()` yield `''` and silently
+     * break the cleaner bridge below.
+     */
+    readonly control: FormControl<string | null>;
+    /**
+     * Debounce in milliseconds between the last keystroke and the typed value being applied to the filter.
+     * Matches `defaultEmitValueTimeout` of `kbq-search-expandable`, so both search fields of a bar feel the
+     * same. `Enter` and blur apply immediately and cancel a pending apply.
+     */
+    debounceTime: number;
+    /**
+     * Minimum number of characters before typing applies the value to the filter. Anything shorter —
+     * including an emptied field — is applied as `null`, so the filter never keeps text the user has
+     * already erased. `Enter` and blur ignore the threshold. Set to `0` to apply every keystroke.
+     */
+    minLength: number;
+    /** Cancels a pending debounced apply once the value has been applied (or cleared) through another path. */
+    private readonly cancelPendingApply;
+    /** Whether the current pipe is empty. Used for apply style modifier */
+    get isEmpty(): boolean;
+    ngOnInit(): void;
+    /** clears the pipe and triggers changes */
+    onClear(): void;
+    /** focuses the input */
+    open(): void;
+    /** Commits a value to `data` and notifies the filter-bar. */
+    private commit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPipeInputComponent, "kbq-pipe-input", never, {}, {}, never, never, true, never>;
+}
+
 declare class KbqPipeMultiSelectComponent extends KbqBasePipe<KbqSelectValue[]> implements AfterViewInit, OnInit {
     /** control for search options */
     readonly searchControl: FormControl<string | null>;
@@ -989,15 +1227,24 @@ declare class KbqPipeMultiSelectComponent extends KbqBasePipe<KbqSelectValue[]>
     get allVisibleOptionsSelected(): boolean;
     /** true if all options selected */
     get allOptionsSelected(): boolean;
+    /**
+     * Selection tally restricted to the options the user can actually toggle — the one place the
+     * "ignore the locked options" rule of "select all" is expressed. `null` while there is nothing to
+     * tally: no options came from the pipe template yet, or the view is not up.
+     */
+    private get unlockedTally();
     get selectedAllEqualsSelectedNothing(): boolean;
     private get visibleOptions();
     private selectionAllInProgress;
     private readonly multiSelect;
+    constructor();
     /** @docs-private */
     ngOnInit(): void;
     ngAfterViewInit(): void;
     /** @docs-private */
     onSelect(item: KbqSelectValue[]): void;
+    /** Whether the option cannot be deselected by the user. Template-only. */
+    protected isLocked(item: KbqSelectValue): boolean;
     /** @docs-private */
     onClear(): void;
     /** @docs-private */
@@ -1065,12 +1312,27 @@ declare class KbqPipeMultiTreeSelectComponent extends KbqTreeSelectPipeBase<KbqS
     get numberOfSelectedLeaves(): number;
     /** true if all options selected */
     get allOptionsSelected(): boolean;
+    /**
+     * Selection tally restricted to the nodes the user can actually toggle — the one place the "ignore the
+     * locked nodes" rule of "select all" is expressed. `null` until the tree data has been built.
+     *
+     * `triggerValues` is derived from the very same selection model as `selected`, so either would do.
+     */
+    private get unlockedTally();
     get selectedAllEqualsSelectedNothing(): boolean;
     /** true if all visible options selected */
     get allVisibleOptionsSelected(): boolean;
+    /** Flat nodes whose selection the user cannot remove, the subtree of a locked branch included. */
+    private get lockedDataNodes();
+    /**
+     * Values of every locked node, the subtree of a locked branch included. Resolved once per template
+     * change rather than on demand — `isEmpty` reads it on every change-detection pass.
+     */
+    private lockedNodeValues;
     private readonly multiSelect;
     constructor();
     ngOnInit(): void;
+    ngAfterViewInit(): void;
     isNodeSelectAll(_: number, nodeData: KbqTreeSelectFlatNode): boolean;
     onSelect({ value: option }: {
         value: any;
@@ -1084,10 +1346,20 @@ declare class KbqPipeMultiTreeSelectComponent extends KbqTreeSelectPipeBase<KbqS
      */
     updateTemplates: (templates: KbqPipeTemplate[] | null) => void;
     onClear(): void;
+    /** Clearing keeps the locked values; with none configured the pipe resets to `null` as before. */
+    protected clearedValue(): KbqSelectValue[] | null;
     /** @docs-private */
     onClose(): void;
     /** handler for select all options in select */
     selectAllHandler: (event: KeyboardEvent) => void;
+    /**
+     * Whether the node cannot be deselected: either its own value is locked, or it descends from a locked
+     * branch. Locking a branch has to lock its subtree — deselecting a child would otherwise switch the
+     * locked parent's own checkbox off.
+     */
+    private isLockedNode;
+    /** Puts back every locked node the tree's own cascades may have deselected. */
+    private enforceLockedNodes;
     private toggleParents;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeMultiTreeSelectComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPipeMultiTreeSelectComponent, "kbq-pipe-multi-tree-select", never, {}, {}, never, never, true, never>;
@@ -1161,5 +1433,5 @@ declare class KbqPipeTreeSelectComponent extends KbqTreeSelectPipeBase<KbqSelect
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPipeTreeSelectComponent, "kbq-pipe-tree-select", never, {}, {}, never, never, true, never>;
 }
 
-export { KBQ_FILTER_BAR_CONFIGURATION, KBQ_FILTER_BAR_DEFAULT_CONFIGURATION, KBQ_FILTER_BAR_HOST, KBQ_FILTER_BAR_PIPES, KBQ_PIPE_DATA, KbqBasePipe, KbqFilterBar, KbqFilterBarButton, KbqFilterBarModule, KbqFilterRefresher as KbqFilterBarRefresher, KbqFilterRefresher, KbqFilterReset, KbqFilterSavePopover, KbqFilters, KbqPipeAdd, KbqPipeButton, KbqPipeDateBaseComponent, KbqPipeDateComponent, KbqPipeDatetimeComponent, KbqPipeDirective, KbqPipeMinWidth, KbqPipeMultiSelectComponent, KbqPipeMultiTreeSelectComponent, KbqPipeReadonlyComponent, KbqPipeSelectComponent, KbqPipeState, KbqPipeTextComponent, KbqPipeTreeSelectComponent, KbqPipeTypes, KbqSaveFilterStatuses, KbqTreeSelectFlatNode, KbqTreeSelectPipeBase, defaultFilterBarPipes, getId, kbqBuildTree, kbqFilterBarPipesProvider };
+export { KBQ_FILTER_BAR_CONFIGURATION, KBQ_FILTER_BAR_DEFAULT_CONFIGURATION, KBQ_FILTER_BAR_HOST, KBQ_FILTER_BAR_PIPES, KBQ_PIPE_DATA, KbqBasePipe, KbqFilterBar, KbqFilterBarButton, KbqFilterBarModule, KbqFilterRefresher as KbqFilterBarRefresher, KbqFilterRefresher, KbqFilterReset, KbqFilterSavePopover, KbqFilters, KbqPipeAdd, KbqPipeButton, KbqPipeDateBaseComponent, KbqPipeDateComponent, KbqPipeDatetimeComponent, KbqPipeDirective, KbqPipeInputComponent, KbqPipeMinWidth, KbqPipeMultiSelectComponent, KbqPipeMultiTreeSelectComponent, KbqPipeReadonlyComponent, KbqPipeSelectComponent, KbqPipeState, KbqPipeTextComponent, KbqPipeTreeSelectComponent, KbqPipeTypes, KbqSaveFilterStatuses, KbqTreeSelectFlatNode, KbqTreeSelectPipeBase, defaultFilterBarPipes, getId, kbqBuildTree, kbqFilterBarPipesProvider };
 export type { KbqDateTimeValue, KbqFilter, KbqFilterBarConfiguration, KbqFilterBarHost, KbqPipe, KbqPipeData, KbqPipeTemplate, KbqPipeType, KbqSaveFilterError, KbqSaveFilterEvent, KbqSelectValue, KbqTreeSelectNode };

package/filter-bar/pipes/base-pipe.scss

@@ -31,17 +31,6 @@
         }
     }
 
-    .kbq-pipe__separator {
-        z-index: 1;
-
-        margin-inline-start: -1px;
-        margin-inline-end: 0;
-
-        height: var(--kbq-size-l);
-
-        align-self: center;
-    }
-
     .kbq-select:not(:hover, .kbq-active),
     .kbq-tree-select:not(:hover, .kbq-active),
     .kbq-button:not(:hover, .kbq-active, [disabled]) {

package/filter-bar/pipes/pipe-input.scss

@@ -0,0 +1,10 @@
+.kbq-pipe.kbq-pipe__input {
+    // Fall back like base-pipe.scss does for --kbq-filter-bar-pipe-max-width: the token is declared on
+    // .kbq-filter-bar, which a pipe rendered outside a bar never sees.
+    width: var(--kbq-filter-bar-pipe-input-width, 240px);
+    flex: none;
+
+    .kbq-form-field {
+        width: 100%;
+    }
+}

package/filter-bar/pipes/pipe-multi-tree-select.scss

@@ -1,5 +1,3 @@
-@use '../filter-bar-theme' as *;
-
 .kbq-pipe__multi-tree-select {
     .kbq-pipe__value {
         margin-inline-start: var(--kbq-size-xxs);
@@ -15,7 +13,3 @@
         height: unset;
     }
 }
-
-.kbq-pipe-multi-tree-select__panel .kbq-select__content {
-    @include kbq-filter-bar-panel-content-max-height();
-}

package/filter-bar/pipes/pipe-multiselect.scss

@@ -1,5 +1,3 @@
-@use '../filter-bar-theme' as *;
-
 .kbq-pipe__multiselect {
     .kbq-pipe__value {
         margin-inline-start: var(--kbq-size-xxs);
@@ -11,7 +9,3 @@
         margin-inline-start: var(--kbq-size-xs);
     }
 }
-
-.kbq-pipe-multiselect__panel .kbq-select__content {
-    @include kbq-filter-bar-panel-content-max-height();
-}

package/filter-bar/pipes/pipe-tree-select.scss

@@ -1,9 +1,3 @@
-@use '../filter-bar-theme' as *;
-
-.kbq-pipe-tree-select__panel .kbq-tree-select__content {
-    @include kbq-filter-bar-panel-content-max-height();
-}
-
 .kbq-pipe__tree-select {
     .kbq-select__trigger {
         height: unset;