@koobiq/components 19.8.3 → 20.1.0

package/progress-spinner/index.d.ts

@@ -1 +1,37 @@
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { KbqColorDirective } from '@koobiq/components/core';
+import * as i1 from '@angular/cdk/platform';
+
+type ProgressSpinnerMode = 'determinate' | 'indeterminate';
+type ProgressSpinnerSize = 'compact' | 'big';
+declare class KbqProgressSpinnerText {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqProgressSpinnerText, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqProgressSpinnerText, "[kbq-progress-spinner-text]", never, {}, {}, never, never, true, never>;
+}
+declare class KbqProgressSpinnerCaption {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqProgressSpinnerCaption, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqProgressSpinnerCaption, "[kbq-progress-spinner-caption]", never, {}, {}, never, never, true, never>;
+}
+declare class KbqProgressSpinner extends KbqColorDirective {
+    readonly id: i0.InputSignal<string>;
+    readonly value: i0.InputSignal<number>;
+    readonly mode: i0.InputSignal<ProgressSpinnerMode>;
+    get size(): ProgressSpinnerSize | string;
+    set size(value: ProgressSpinnerSize | string);
+    private _size;
+    svgCircleRadius: string;
+    get percentage(): number;
+    get dashOffsetPercent(): string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqProgressSpinner, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqProgressSpinner, "kbq-progress-spinner", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; }; }, {}, never, ["[kbq-progress-spinner-text]", "[kbq-progress-spinner-caption]"], true, never>;
+}
+
+declare class KbqProgressSpinnerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqProgressSpinnerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqProgressSpinnerModule, never, [typeof i1.PlatformModule, typeof KbqProgressSpinner, typeof KbqProgressSpinnerText, typeof KbqProgressSpinnerCaption], [typeof KbqProgressSpinner, typeof KbqProgressSpinnerText, typeof KbqProgressSpinnerCaption]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqProgressSpinnerModule>;
+}
+
+export { KbqProgressSpinner, KbqProgressSpinnerCaption, KbqProgressSpinnerModule, KbqProgressSpinnerText };
+export type { ProgressSpinnerMode, ProgressSpinnerSize };

package/progress-spinner/progress-spinner.scss

@@ -18,7 +18,7 @@
 
 .kbq-progress-spinner__circle {
     fill: none;
-    stroke: black;
+    stroke: var(--stroke, var(--kbq-progress-spinner-circle-background));
     stroke-dasharray: 295%;
     stroke-width: 13%;
     transition: stroke-dashoffset 0.3s;
@@ -65,6 +65,10 @@
 .kbq-progress-spinner_indeterminate .kbq-progress-spinner__inner {
     animation: kbq-progress-spinner-indeterminate 1.5s timing.$ease-in-out-quad infinite;
 
+    @media (prefers-reduced-motion: reduce) {
+        animation: none;
+    }
+
     // TODO: rework this place
     .kbq-progress-spinner__circle {
         stroke-dashoffset: 80%;

package/radio/index.d.ts

@@ -1 +1,203 @@
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { OnInit, AfterViewInit, OnDestroy, ElementRef, AfterContentInit, QueryList } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { KbqColorDirective } from '@koobiq/components/core';
+import * as i1 from '@angular/cdk/a11y';
+
+/** Change event object emitted by KbqRadio. */
+declare class KbqRadioChange {
+    /** The KbqRadioButton that emits the change event. */
+    source: KbqRadioButton;
+    /** The value of the KbqRadioButton. */
+    value: any;
+    constructor(
+    /** The KbqRadioButton that emits the change event. */
+    source: KbqRadioButton, 
+    /** The value of the KbqRadioButton. */
+    value: any);
+}
+/**
+ * Provider Expression that allows kbq-radio-group to register as a ControlValueAccessor. This
+ * allows it to support [(ngModel)] and ngControl.
+ * @docs-private
+ */
+declare const KBQ_RADIO_GROUP_CONTROL_VALUE_ACCESSOR: any;
+declare class KbqRadioGroup implements AfterContentInit, ControlValueAccessor {
+    private readonly changeDetector;
+    readonly big: i0.InputSignal<boolean>;
+    /** Name of the radio button group. All radio buttons inside this group will use this name. */
+    get name(): string;
+    set name(value: string);
+    /** Whether the labels should appear after or before the radio-buttons. Defaults to 'after' */
+    get labelPosition(): 'before' | 'after';
+    set labelPosition(v: "before" | "after");
+    /** Value of the radio button. */
+    get value(): any;
+    set value(newValue: any);
+    /** Whether the radio button is selected. */
+    get selected(): KbqRadioButton | null;
+    set selected(selected: KbqRadioButton | null);
+    /** Whether the radio group is disabled */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    /** Whether the radio group is required */
+    get required(): boolean;
+    set required(value: boolean);
+    /** Whether the radio group is required. */
+    private _required;
+    /**
+     * Event emitted when the group value changes.
+     * Change events are only emitted when the value changes due to user interaction with
+     * a radio button (the same behavior as `<input type-"radio">`).
+     */
+    readonly change: i0.OutputEmitterRef<KbqRadioChange>;
+    /** Child radio buttons. */
+    radios: QueryList<KbqRadioButton>;
+    /**
+     * Selected value for group. Should equal the value of the selected radio button if there *is*
+     * a corresponding radio button with a matching value. If there is *not* such a corresponding
+     * radio button, this value persists to be applied in case a new radio button is added with a
+     * matching value.
+     */
+    private _value;
+    /** The HTML name attribute applied to radio buttons in this group. */
+    private _name;
+    /** The currently selected radio button. Should match value. */
+    private _selected;
+    /** Whether the `value` has been set to its initial value. */
+    private isInitialized;
+    /** Whether the labels should appear after or before the radio-buttons. Defaults to 'after' */
+    private _labelPosition;
+    /** The method to be called in order to update ngModel */
+    controlValueAccessorChangeFn: (value: any) => void;
+    /**
+     * onTouch function registered via registerOnTouch (ControlValueAccessor).
+     * @docs-private
+     */
+    onTouched: () => any;
+    checkSelectedRadioButton(): void;
+    /**
+     * Initialize properties once content children are available.
+     * This allows us to propagate relevant attributes to associated buttons.
+     */
+    ngAfterContentInit(): void;
+    /**
+     * Mark this group as being "touched" (for ngModel). Meant to be called by the contained
+     * radio buttons upon their blur.
+     */
+    touch(): void;
+    /** Dispatch change event with current selection and group value. */
+    emitChangeEvent(): void;
+    markRadiosForCheck(): void;
+    /**
+     * Sets the model value. Implemented as part of ControlValueAccessor.
+     */
+    writeValue(value: any): void;
+    /**
+     * Registers a callback to be triggered when the model value changes.
+     * Implemented as part of ControlValueAccessor.
+     * @param fn Callback to be registered.
+     */
+    registerOnChange(fn: (value: any) => void): void;
+    /**
+     * Registers a callback to be triggered when the control is touched.
+     * Implemented as part of ControlValueAccessor.
+     * @param fn Callback to be registered.
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Sets the disabled state of the control. Implemented as a part of ControlValueAccessor.
+     * @param isDisabled Whether the control should be disabled.
+     */
+    setDisabledState(isDisabled: boolean): void;
+    private updateRadioButtonNames;
+    /** Updates the `selected` radio button from the internal _value state. */
+    private updateSelectedRadioFromValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqRadioGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqRadioGroup, "kbq-radio-group", ["kbqRadioGroup"], { "big": { "alias": "big"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "value": { "alias": "value"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "change": "change"; }, ["radios"], never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+}
+declare class KbqRadioButton extends KbqColorDirective implements OnInit, AfterViewInit, OnDestroy {
+    private readonly changeDetector;
+    private focusMonitor;
+    private readonly radioDispatcher;
+    /** Whether this radio button is checked. */
+    get checked(): boolean;
+    set checked(value: boolean);
+    /** The value of this radio button. */
+    get value(): any;
+    set value(value: any);
+    /** Whether the radio button is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    get tabIndex(): number;
+    set tabIndex(value: number);
+    private _tabIndex;
+    /** Whether the radio button is required. */
+    get required(): boolean;
+    set required(value: boolean);
+    /** Whether this radio is required. */
+    private _required;
+    /** Whether the label should appear after or before the radio button. Defaults to 'after' */
+    get labelPosition(): 'before' | 'after';
+    /** @docs-private */
+    set labelPosition(value: "before" | "after");
+    /** Analog to HTML 'name' attribute used to group radios for unique selection. */
+    name: string;
+    /** The native `<input type=radio>` element */
+    readonly inputElement: i0.Signal<ElementRef<any>>;
+    /**
+     * Event emitted when the checked state of this radio button changes.
+     * Change events are only emitted when the value changes due to user interaction with
+     * the radio button (the same behavior as `<input type-"radio">`).
+     */
+    readonly change: i0.OutputEmitterRef<KbqRadioChange>;
+    /** The parent radio group. May or may not be present. */
+    radioGroup: KbqRadioGroup;
+    readonly isFocused: i0.InputSignal<boolean>;
+    /** The unique ID for the radio button. */
+    id: string;
+    /** ID of the native input element inside `<kbq-radio-button>` */
+    get inputId(): string;
+    private _labelPosition;
+    private readonly uniqueId;
+    /** Whether this radio is checked. */
+    private _checked;
+    /** Value assigned to this radio. */
+    private _value;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** Focuses the radio button. */
+    focus(): void;
+    /**
+     * Marks the radio button as needing checking for change detection.
+     * This method is exposed because the parent radio group will directly
+     * update bound properties of the radio button.
+     */
+    markForCheck(): void;
+    onInputClick(event: Event): void;
+    onInputChange(event: Event): void;
+    /** Unregister function for _radioDispatcher */
+    private readonly removeUniqueSelectionListener;
+    /** Dispatch change event with current value. */
+    private emitChangeEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqRadioButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqRadioButton, "kbq-radio-button", ["kbqRadioButton"], { "checked": { "alias": "checked"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "required": { "alias": "required"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "name": { "alias": "name"; "required": false; }; "isFocused": { "alias": "isFocused"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; }; }, { "change": "change"; }, never, ["*", "kbq-hint"], true, never>;
+    static ngAcceptInputType_checked: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_tabIndex: unknown;
+    static ngAcceptInputType_required: unknown;
+}
+
+declare class KbqRadioModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqRadioModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqRadioModule, never, [typeof i1.A11yModule, typeof KbqRadioGroup, typeof KbqRadioButton], [typeof KbqRadioGroup, typeof KbqRadioButton]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqRadioModule>;
+}
+
+export { KBQ_RADIO_GROUP_CONTROL_VALUE_ACCESSOR, KbqRadioButton, KbqRadioChange, KbqRadioGroup, KbqRadioModule };

package/radio/radio.scss

@@ -92,9 +92,18 @@
         margin-top: var(--kbq-radio-size-normal-vertical-content-padding);
     }
 
-    [dir='rtl'] & {
-        padding-right: var(--kbq-radio-size-normal-horizontal-content-padding);
+    &.kbq-radio-label-before {
         padding-left: 0;
+        padding-right: kbq-sum-series-css-variables(
+            [radio-size-normal-outer-size,
+            radio-size-normal-horizontal-content-padding,
+            calc(var(--kbq-radio-size-normal-outer-circle-border-width) * 2)]
+        );
+
+        .kbq-radio-button__outer-circle {
+            left: unset;
+            right: 0;
+        }
     }
 }
 
@@ -128,8 +137,13 @@
             margin-top: var(--kbq-radio-size-big-vertical-content-padding);
         }
 
-        [dir='rtl'] & {
-            padding-right: var(--kbq-radio-size-big-horizontal-content-padding);
+        &.kbq-radio-label-before {
+            padding-left: 0;
+            padding-right: kbq-sum-series-css-variables(
+                [radio-size-big-outer-size,
+                radio-size-big-horizontal-content-padding,
+                calc(var(--kbq-radio-size-big-outer-circle-border-width) * 2)]
+            );
         }
     }
 }

package/resizer/index.d.ts

@@ -1,2 +1,85 @@
-export * from './module';
-export * from './resizer';
+import * as i0 from '@angular/core';
+
+/**
+ * Directions for resizing.
+ *
+ * Horizontal direction (x):
+ * - Left: -1
+ * - None: 0
+ * - Right: 1
+ *
+ * Vertical direction (y):
+ * - Up: -1
+ * - None: 0
+ * - Down: 1
+ */
+type KbqResizerDirection = [x: -1 | 0 | 1, y: -1 | 0 | 1];
+/**
+ * Event emitted when the size of the resizable element changes.
+ */
+type KbqResizerSizeChangeEvent = {
+    width: number;
+    height: number;
+};
+/**
+ * Directive (container) sets whether the element is resizable.
+ *
+ * @example
+ *
+ * ```html
+ * <div kbqResizable>
+ *     <div [kbqResizer]="[-1, 0]"></div>
+ * </div>
+ * ```
+ */
+declare class KbqResizable {
+    /**
+     * @docs-private
+     */
+    readonly element: HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqResizable, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqResizable, "[kbqResizable]", ["kbqResizable"], {}, {}, never, never, true, never>;
+}
+/**
+ * Directive which defines element resizing direction.
+ */
+declare class KbqResizer {
+    private readonly element;
+    private readonly resizable;
+    private readonly zone;
+    private readonly document;
+    private readonly destroyRef;
+    private readonly renderer;
+    private x;
+    private y;
+    private width;
+    private height;
+    /**
+     * Direction of element resizing.
+     */
+    readonly direction: i0.InputSignal<KbqResizerDirection>;
+    /**
+     * Emits the new size of the element after resizing.
+     */
+    readonly sizeChange: i0.OutputEmitterRef<KbqResizerSizeChangeEvent>;
+    /**
+     * @docs-private
+     */
+    protected readonly cursor: i0.Signal<"default" | "ns-resize" | "ew-resize" | "nwse-resize" | "nesw-resize">;
+    constructor();
+    private handleElementPointerDown;
+    private handleDocumentPointerMove;
+    private handleDocumentPointerUp;
+    private updateSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqResizer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqResizer, "[kbqResizer]", ["kbqResizer"], { "direction": { "alias": "kbqResizer"; "required": true; "isSignal": true; }; }, { "sizeChange": "sizeChange"; }, never, never, true, never>;
+}
+
+declare class KbqResizerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqResizerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqResizerModule, never, [typeof KbqResizable, typeof KbqResizer], [typeof KbqResizable, typeof KbqResizer]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqResizerModule>;
+}
+
+export { KbqResizable, KbqResizer, KbqResizerModule };
+export type { KbqResizerDirection, KbqResizerSizeChangeEvent };

package/schematics/collection.json

@@ -36,6 +36,16 @@
             "description": "Updates names of icons in dedicated files",
             "factory": "./migrations/icons-replacement/index",
             "schema": "./migrations/icons-replacement/schema.json"
+        },
+        "v20-upgrade": {
+            "description": "Migrates deprecated API removed in @koobiq/components v20.0.0",
+            "factory": "./migrations/v20-upgrade/index",
+            "schema": "./migrations/v20-upgrade/schema.json"
+        },
+        "filter-bar-signals": {
+            "description": "Migrates KbqFilterBar consumers to the signal-based API (filter/pipeTemplates/isChanged/... reads become calls)",
+            "factory": "./migrations/filter-bar-signals/index",
+            "schema": "./migrations/filter-bar-signals/schema.json"
         }
     }
 }

package/schematics/migrations/css-selectors/index.js

@@ -36,7 +36,7 @@ function cssSelectors(options) {
             const projectDefinition = await utils_packageConfig.setupOptions(project, tree);
             targetDir = projectDefinition ? tree.getDir(projectDefinition.root) : tree;
         }
-        catch (e) {
+        catch {
             targetDir = tree;
         }
         const { logger } = context;

package/schematics/migrations/deprecated-icons/index.js

@@ -37,7 +37,7 @@ function deprecatedIcons(options) {
             const projectDefinition = await utils_packageConfig.setupOptions(project, tree);
             targetDir = projectDefinition ? tree.getDir(projectDefinition.root) : tree;
         }
-        catch (e) {
+        catch {
             targetDir = tree;
         }
         const { logger } = context;

package/schematics/migrations/filter-bar-signals/README.md

@@ -0,0 +1,66 @@
+# filter-bar-signals
+
+Migration schematic invoked automatically by `ng update @koobiq/components@21`.
+Migrates consumers of `KbqFilterBar` to its signal-based public API.
+
+## Why
+
+`KbqFilterBar` moved several members from accessors/getters to signals. Reading
+them programmatically now requires a call, and assigning `filter` now goes
+through `.set(...)`. Template _bindings_ (`[filter]`, `[(filter)]`,
+`[pipeTemplates]`) keep working — only reads break.
+
+| Member                                                                      | Before   | After             |
+| --------------------------------------------------------------------------- | -------- | ----------------- |
+| `filter`                                                                    | accessor | `ModelSignal`     |
+| `pipeTemplates`                                                             | accessor | `InputSignal`     |
+| `isChanged` / `isDisabled` / `isReadOnly` / `isSaved` / `isSavedAndChanged` | getter   | `Signal<boolean>` |
+
+## What it does
+
+The schematic walks every `.ts` and `.html` file in the project (skipping
+`node_modules` and `dist`) and, for files that reference the filter bar:
+
+- **TypeScript reads/writes.** For a receiver whose static type is annotated
+  `KbqFilterBar` / `KbqFilterBarHost` (method/function params, class fields —
+  including `@ViewChild(KbqFilterBar) x: KbqFilterBar` and constructor
+  parameter-properties — and typed locals), a read of a signal member becomes a
+  call and a `filter` write becomes `.set(...)`:
+    - `filterBar.filter` → `filterBar.filter()` (incl. optional chain `filterBar.filter?.name` → `filterBar.filter()?.name`)
+    - `filterBar.filter = next` → `filterBar.filter.set(next)`
+    - `this.filterBar.isChanged` → `this.filterBar.isChanged()`
+- **Template reference reads.** For a `#ref` bound to `<kbq-filter-bar>`, reads
+  of signal members through that ref are rewritten in the same template
+  (external `.html` and inline `template:` strings): `ref.isChanged` →
+  `ref.isChanged()`.
+- **Rename.** `KbqFilterBarRefresher` → `KbqFilterRefresher` (the old name is
+  still re-exported as an alias, so this is optional cleanup).
+
+All rewrites are idempotent — running twice does not double the call.
+
+## What it does _not_ do (warn-only)
+
+Some changes require code restructuring and are surfaced as warnings without
+auto-fixing:
+
+| Pattern                          | Manual migration                                                                                   |
+| -------------------------------- | -------------------------------------------------------------------------------------------------- |
+| `.changes` (KbqFilterBar)        | Deprecated no-op; read `filterBar.filter()` inside an `effect(...)`, or listen to `(filterChange)` |
+| `.preparePopover()` (KbqFilters) | Removed; use `openSaveAsNewFilterPopover()` / `openChangeFilterNamePopover()`                      |
+| `viewChild(KbqFilterBar)` query  | Returns the instance, so reads are a double call: `this.filterBar().filter()` — verify manually    |
+| `KBQ_FILTER_BAR_PIPES`           | Now typed `Map<KbqPipeType, Type<KbqBasePipe>>`; wrap direct providers in `new Map([...])`         |
+
+## Running it manually
+
+```
+ng generate @koobiq/components:filter-bar-signals --project my-app
+```
+
+Pass `--fix=false` to see what would change without writing files.
+
+## Limitations
+
+Receivers are matched by explicit `KbqFilterBar` type annotation only (no
+cross-package type inference), so aliased/inferred receivers
+(`const fb = this.filterBar; fb.filter`) are left untouched and covered by the
+warnings above. After running, **always inspect the diff** before committing.

package/schematics/migrations/filter-bar-signals/data.js

@@ -0,0 +1,72 @@
+'use strict';
+
+/**
+ * Data for the `filter-bar-signals` migration.
+ *
+ * `KbqFilterBar` moved several members from accessors/getters to signals. Reading them programmatically
+ * (in `.ts` code or via a template reference variable) now requires a call:
+ *
+ * - `filterBar.filter`            → `filterBar.filter()`            (write `= v` → `.set(v)`)
+ * - `filterBar.pipeTemplates`     → `filterBar.pipeTemplates()`
+ * - `filterBar.isChanged`         → `filterBar.isChanged()`        (also isDisabled/isReadOnly/isSaved/isSavedAndChanged)
+ *
+ * Template *bindings* (`[filter]`, `[(filter)]`, `[pipeTemplates]`) keep working — only reads break.
+ */
+/** Members of `KbqFilterBar` that became signals; a read of any of them must become a call. */
+const SIGNAL_MEMBERS = [
+    'filter',
+    'pipeTemplates',
+    'isChanged',
+    'isDisabled',
+    'isReadOnly',
+    'isSaved',
+    'isSavedAndChanged'
+];
+/** Signal members that are writable (`model()`); `x.filter = v` migrates to `x.filter.set(v)`. */
+const WRITABLE_MEMBERS = new Set(['filter']);
+/** TypeScript type annotations that mark a receiver as a filter bar. */
+const FILTER_BAR_TYPE = 'KbqFilterBar';
+const FILTER_BAR_HOST_TYPE = 'KbqFilterBarHost';
+/** Element selector whose template reference variables (`#ref`) point at a filter bar. */
+const FILTER_BAR_ELEMENT = 'kbq-filter-bar';
+/**
+ * Safe, idempotent identifier renames applied to `.ts` files. The `\b…\b` boundaries make each rule
+ * idempotent. `KbqFilterBarRefresher` is still re-exported as an alias of `KbqFilterRefresher`, so this
+ * is optional cleanup that can never break a consumer build.
+ */
+const tsRenameReplacements = [{ from: '\\bKbqFilterBarRefresher\\b', to: 'KbqFilterRefresher' }];
+/**
+ * Patterns that can't be auto-fixed reliably — surfaced with file locations (in both `fix` and dry-run
+ * mode). Only evaluated for files that reference the filter bar, so the broad `.changes` pattern stays scoped.
+ */
+const warnPatterns = [
+    {
+        pattern: '\\.changes\\b',
+        message: 'KbqFilterBar.changes is deprecated and no longer emits. Reactivity is driven by the `filter` ' +
+            'signal now — read it with `filterBar.filter()` inside an `effect(...)`, or listen to the ' +
+            '`(filterChange)` output. (Best-effort match — ignore if this `.changes` is unrelated.)'
+    },
+    {
+        pattern: '\\.preparePopover\\(',
+        message: 'KbqFilters.preparePopover() was removed. Use openSaveAsNewFilterPopover() / ' +
+            'openChangeFilterNamePopover() instead.'
+    },
+    {
+        pattern: '(?:viewChild|ViewChild)[^\\n;]*\\bKbqFilterBar\\b',
+        message: 'A KbqFilterBar view/signal query returns the component instance, whose filter is now a signal — ' +
+            'reading it is a double call, e.g. `this.filterBar().filter()`. Verify query reads manually.'
+    },
+    {
+        pattern: '\\bKBQ_FILTER_BAR_PIPES\\b',
+        message: 'KBQ_FILTER_BAR_PIPES is now typed as Map<KbqPipeType, Type<KbqBasePipe>> (was an array of tuples). ' +
+            'If you provide it directly, wrap the entries in `new Map([...])`.'
+    }
+];
+
+exports.FILTER_BAR_ELEMENT = FILTER_BAR_ELEMENT;
+exports.FILTER_BAR_HOST_TYPE = FILTER_BAR_HOST_TYPE;
+exports.FILTER_BAR_TYPE = FILTER_BAR_TYPE;
+exports.SIGNAL_MEMBERS = SIGNAL_MEMBERS;
+exports.WRITABLE_MEMBERS = WRITABLE_MEMBERS;
+exports.tsRenameReplacements = tsRenameReplacements;
+exports.warnPatterns = warnPatterns;