@koobiq/components 20.4.2 → 21.0.1

package/schematics/migrations/flag-inner-html/index.cjs

@@ -0,0 +1,62 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils_messages = require('../../utils/messages.cjs');
+var utils_packageConfig = require('../../utils/package-config.cjs');
+var utils_projectFiles = require('../../utils/project-files.cjs');
+var migrations_flagInnerHtml_data = require('./data.cjs');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+
+const LABEL = '[flag-inner-html]';
+const EXTENSIONS = ['.ts', '.html'];
+/** A file is a flag consumer if it imports the package, names the component, or renders one. */
+function referencesFlag(content) {
+    return content.includes(migrations_flagInnerHtml_data.FLAG_PACKAGE) || new RegExp(migrations_flagInnerHtml_data.FLAG_TYPE).test(content);
+}
+/** Renames `[innerHTML]` to `[svg]` inside every `<kbq-flag …>` opening tag, and leaves the rest alone. */
+function rewriteInnerHtmlBindings(content) {
+    return content.replace(migrations_flagInnerHtml_data.FLAG_OPEN_TAG, (tag) => tag.replace(migrations_flagInnerHtml_data.INNER_HTML_BINDING, '[svg]='));
+}
+/**
+ * Moves `[innerHTML]` bindings off the `<kbq-flag>` host element onto the `svg` input the flag review
+ * added, and reports the behavior changes that have no call site to point at.
+ *
+ * `.html` is visited as well as `.ts`, because the binding lives in a template either way.
+ */
+function flagInnerHtml(options) {
+    return async (tree, context) => {
+        const { project } = options;
+        const projectDefinition = await utils_packageConfig.setupOptions(project, tree);
+        const root = projectDefinition?.root ?? '';
+        const rootDir = root ? tree.getDir(root) : tree.root;
+        let consumers = 0;
+        let rewritten = 0;
+        utils_projectFiles.visitProjectFiles(rootDir, (filePath, entry) => {
+            if (!EXTENSIONS.some((extension) => filePath.endsWith(extension)))
+                return;
+            const content = entry?.content.toString();
+            if (!content || !referencesFlag(content))
+                return;
+            consumers++;
+            const migrated = rewriteInnerHtmlBindings(content);
+            if (migrated === content)
+                return;
+            rewritten++;
+            tree.overwrite(filePath, migrated);
+            utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${migrations_flagInnerHtml_data.REWRITE_MESSAGE}`]);
+        });
+        // Nothing here renders a flag, so the summary would only be noise.
+        if (consumers === 0)
+            return;
+        utils_messages.logMessage(context.logger, [
+            `${LABEL} processed kbq-flag under "${root || '<workspace root>'}", ` +
+                `${consumers} file(s) reference the component, ${rewritten} file(s) rewritten.`,
+            ...migrations_flagInnerHtml_data.SUMMARY
+        ]);
+    };
+}
+
+exports.default = flagInnerHtml;
+exports.rewriteInnerHtmlBindings = rewriteInnerHtmlBindings;

package/schematics/migrations/flag-inner-html/schema.json

@@ -0,0 +1,15 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "koobiq-components-flag-inner-html",
+    "title": "Koobiq components flag review migration",
+    "type": "object",
+    "properties": {
+        "project": {
+            "type": "string",
+            "description": "Name of the project to inspect. If omitted, the migration runs over the whole tree.",
+            "$default": {
+                "$source": "projectName"
+            }
+        }
+    }
+}

package/schematics/migrations/form-field-signals/README.md

@@ -0,0 +1,125 @@
+# form-field-signals
+
+Migration schematic invoked automatically by `ng update @koobiq/components`.
+Migrates consumers of the full `@koobiq/components/form-field` review: the signal-based `KbqFormField` /
+`KbqHint` API, the new accessibility semantics of the cleaner and the password toggle, and the removal of the
+deprecated `mixinColor`.
+
+## Why
+
+`KbqFormField` finished its migration to signal queries and `KbqHint` to signal inputs, so every programmatic
+read of those members needs a call. The icon-only cleaner and password toggle became real buttons with a
+localized accessible name, which means the component now owns the `aria-label` a consumer used to set by hand.
+`KbqFormFieldControl` followed: the state of every control is a signal, and `stateChanges` is gone.
+Template _bindings_ (`[fillTextOff]`, `[compact]`, …) keep working — only programmatic reads/writes
+and template-reference reads break.
+
+| Member                                                                                                        | Before                  | After                                    | Auto-fix                         |
+| ------------------------------------------------------------------------------------------------------------- | ----------------------- | ---------------------------------------- | -------------------------------- |
+| `KbqFormField.cleaner` / `passwordToggle`                                                                     | `T \| null`             | `Signal<T \| undefined>`                 | ✅ read → call                   |
+| `KbqFormField.hint` / `prefix` / `suffix`                                                                     | `QueryList<T>`          | `Signal<readonly T[]>`                   | ✅ read → call                   |
+| `KbqFormField.hasCleaner` / `hasHint` / `hasPasswordToggle` / `hasPrefix` / `hasStepper` / `hasSuffix`        | getter                  | `Signal<boolean>`                        | ✅ read → call                   |
+| `KbqHint.fillTextOff` / `compact` (also on `KbqError`, `KbqReactivePasswordHint`)                             | `boolean` input         | `InputSignalWithTransform`               | ✅ read → call                   |
+| `<kbq-cleaner [attr.aria-label]>`                                                                             | plain attribute binding | `[aria-label]` input                     | ✅ rewritten                     |
+| `fiedset-theme` stylesheet                                                                                    | misspelled filename     | `fieldset-theme`                         | ✅ renamed                       |
+| `mixinColor` / `CanColorCtor`                                                                                 | exported from `core`    | removed                                  | ⚠️ warn                          |
+| `KbqA11yLocaleConfiguration`                                                                                  | 8 keys                  | +`clear`, `showPassword`, `hidePassword` | ⚠️ warn                          |
+| `KbqFormFieldRef.control`                                                                                     | `any`                   | `Signal<KbqFormFieldControlRef>`         | ⚠️ warn                          |
+| `value` / `id` / `placeholder` / `focused` / `empty` / `required` / `disabled` / `errorState` of the controls | property or getter      | `Signal`                                 | ✅ read → call, write → `.set()` |
+| `KbqTagInput.id` / `placeholder` / `focused` / `empty`                                                        | input, field or getter  | read-only `Signal`                       | ✅ read → call                   |
+| `KbqInputPassword.elementType`                                                                                | writable `string`       | read-only `Signal<'text' \| 'password'>` | ✅ read → call, ⚠️ write warned  |
+| `KbqFormFieldControl.stateChanges`                                                                            | `Observable<void>`      | removed                                  | ⚠️ warn                          |
+| `KbqFormField.hovered` / `onHoverChanged()`                                                                   | `boolean` / method      | removed                                  | ⚠️ warn                          |
+
+`control`, `stepper` and `connectionContainerRef` were already signals before this release and are deliberately
+left alone — appending `()` to them would be a double call.
+
+## What it does (auto-fix)
+
+The schematic walks every `.ts`, `.html`, `.scss` and `.css` file in the project (skipping `node_modules` and
+`dist`) and, for files that reference the form field:
+
+- **TypeScript reads.** For a receiver whose static type is annotated `KbqFormField`, `KbqHint`, `KbqError` or
+  `KbqReactivePasswordHint` (method/function params, class fields — including
+  `@ContentChild(KbqFormField) x: KbqFormField`, constructor parameter-properties and `inject(KbqFormField)` — and
+  typed locals), a read of a migrated member becomes a call: `formField.hasHint` → `formField.hasHint()` (incl.
+  optional chain `formField?.hint` → `formField?.hint()`). A nested declaration that reuses the receiver's name,
+  and `this.<field>` inside a `function` that rebinds `this`, are left alone.
+- **Control state.** On a receiver typed `KbqSelect`, `KbqTreeSelect`, `KbqTimezoneSelect`, `KbqTagList`,
+  `KbqTimepicker`, `KbqDatepickerInput`, `KbqInput`, `KbqInputPassword`, `KbqTextarea` or `KbqFormFieldControl`,
+  a read of `value`, `id`, `placeholder`, `focused`, `empty`, `required`, `disabled` or `errorState` becomes a
+  call. A plain `=` write becomes `.set()` where the member stays writable — `disabled` on the selects, the tag
+  list, the timepicker and the datepicker input, `value` on the select, the timezone select, the tag list and the
+  native-element controls, `placeholder` on the native-element controls. The tree select, the timepicker and the
+  datepicker input own their `value`, so a write to it is reported. The same reads of `id`, `placeholder`,
+  `focused` and `empty` on a receiver typed `KbqTagInput` become calls too, and so do reads of `elementType` on
+  a receiver typed `KbqInputPassword`, whose writes are reported.
+- **Template references.** For a `#ref` bound to `<kbq-form-field>`, `<kbq-hint>`, `<kbq-error>`,
+  `<kbq-reactive-password-hint>`, `<kbq-select>`, `<kbq-tree-select>`, `<kbq-timezone-select>` or
+  `<kbq-tag-list>`, reads through that ref are rewritten in the same template (external `.html` and inline
+  `template:` strings). The ref has to be bare or name the component's own `exportAs` (`#s="kbqSelect"`): one
+  that names another directive (`#s="ngModel"`) is left alone. The input, the password input, the textarea, the
+  timepicker, the datepicker input and the tag input are directives on a native element, where a bare ref is the
+  element, so only a ref naming their `exportAs` is followed: `#i="kbqInput"`, `kbqInputPassword`,
+  `kbqTextarea`, `kbqTimepicker`, `kbqDatepickerInput`, `kbqTagInput` or `kbqTagInputFor`.
+  Only the ref itself is matched — `form.controls.country.value` stays as it is. Only the expressions of the view
+  that declares the ref are looked at — prose, comments and plain attributes are not — and a ref whose name a
+  `@for`, `let-`, `*ngFor` or `@let` variable or another `#ref` shares is left alone. In an event binding, a
+  write
+  to a writable member becomes `.set()`: `(click)="s.disabled = true"` → `(click)="s.disabled.set(true)"`;
+  `[(ngModel)]="tags.value"` keeps working on the signal unchanged.
+- **Cleaner accessible name.** `<kbq-cleaner [attr.aria-label]="…">` → `<kbq-cleaner [aria-label]="…">`. The
+  component now writes `aria-label` from a host binding, so an `attr.` binding is silently overwritten by the
+  localized default.
+- **Stylesheet import.** `fiedset-theme` → `fieldset-theme`.
+
+All rewrites are idempotent — running twice does not double the call.
+
+## What it does _not_ do (warn-only)
+
+These changes can't be rewritten safely and are surfaced as warnings (in both `fix` and dry-run mode):
+
+| Change                                                                    | Manual migration                                                                                                                                                                                   |
+| ------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `formField.hint.changes` / `.first` / `.last` / `.toArray()` / `.get(i)`  | The content queries are signals over a readonly array. React with `computed()` / `effect()` instead of `.changes`, and index the array instead of the `QueryList` helpers.                         |
+| `formField.cleaner === null`                                              | `cleaner` / `passwordToggle` now return `undefined` when absent. Use a truthiness check or `== null`.                                                                                              |
+| `hint.fillTextOff = …` / `hint.compact = …`                               | Read-only signal inputs now. Drive them with a template binding (`[fillTextOff]="…"`), not an assignment.                                                                                          |
+| `formField.cleaner = …` / `hint` / `prefix` / `suffix` / `passwordToggle` | Read-only signal content queries now. Project the content instead — code that assigned a query result (usually a test faking it) has to render the real component.                                 |
+| `mixinColor(...)` / `CanColorCtor`                                        | Removed, and `CanColor` with them. Extend `KbqColorDirective`, which exposes the same `color` input and `colorClassName` getter, or type a member `Signal<KbqComponentColors \| string>`.          |
+| A custom `KbqA11yLocaleConfiguration`                                     | Add the three new keys — `clear`, `showPassword`, `hidePassword` — used for the accessible names of the cleaner and the password toggle.                                                           |
+| `inject(KBQ_FORM_FIELD_REF)` + `formField.control.<member>`               | `control` is typed now. The read was silently `undefined` and has to become `formField.control().<member>`.                                                                                        |
+| `KbqTrim.trim(...)`                                                       | Typed `(value: unknown) => unknown`. Narrow or cast the result.                                                                                                                                    |
+| `<kbq-error role="…">` / `<kbq-cleaner role="button">`                    | `kbq-error` renders `role="alert"` + `aria-atomic` and `kbq-cleaner` renders `role="button"` themselves. Drop the hand-rolled attributes.                                                          |
+| `implements KbqFormFieldControl`                                          | Expose the state as signals and drop `stateChanges`: the form field derives its state from the signals.                                                                                            |
+| `formField.control().stateChanges`                                        | Removed. Read the state signals in `computed()` / `effect()`, or turn one into a stream with `toObservable()`.                                                                                     |
+| `formField.hovered` / `.onHoverChanged(…)`, also through a `#ref`         | Removed: nothing read them; their pointer listeners ran change detection on every hover. Bind `(mouseenter)` / `(mouseleave)` on `<kbq-form-field>` yourself, or style with `:hover`.              |
+| A write to a read-only control member (`select.placeholder = …`)          | Bind it in the template, or set the value through a form control. Also reported for `+=`, `++`, `delete` and a destructuring target, and through a template ref, in an event or a two-way binding. |
+| `input.value += …` / `++` / `delete` / destructuring on a writable member | Only a plain `=` becomes `.set()`. Write the rest with `.set()` / `.update()`. Also reported for `+=`, `??=`, `++` and the rest through a template ref in an event binding.                        |
+| `password.elementType = …`, also through a `#ref`                         | `KbqInputPassword.elementType` is a read-only signal now. Call `toggleType()` to show or hide the password.                                                                                        |
+| `KbqErrorStateTracker` / `CanUpdateErrorState`                            | The tracker takes no `stateChanges` subject; `errorState` is a `Signal<boolean>`; the interface no longer declares `errorStateMatcher`.                                                            |
+| `mixinErrorState(...)` / `CanUpdateErrorStateCtor`                        | Removed. Track the error state with `KbqErrorStateTracker`.                                                                                                                                        |
+| `KbqIconErrorStateContext`                                                | Its `errorState` is a `Signal<boolean>`, and `stateChanges` was removed.                                                                                                                           |
+
+## Behaviour changes without a code fix
+
+- The form field now writes `aria-describedby` on the control, referencing every rendered hint and — while the
+  control is invalid — the error. Tests that assert on the control's attributes will see the new value.
+- `KbqInput`, `KbqInputPassword` and `KbqSelect` render `aria-invalid`; `KbqSelect` also renders `aria-required`.
+- `.kbq-form-field_no-borders` and `.kbq-form-field_in-overlay` no longer use `!important`: they override the
+  `--kbq-form-field-*` tokens instead. A stylesheet that fought the old `!important` can be simplified.
+- `KbqDatepicker` is no longer provided as a `KbqFormFieldControl`; the form field always finds the
+  `kbqDatepicker` input, which now renders its `id` for the label.
+
+## Running it manually
+
+```
+ng generate @koobiq/components:form-field-signals --project my-app
+```
+
+Pass `--fix=false` to see what would change without writing files.
+
+## Limitations
+
+Receivers are matched by explicit type annotation or an `inject()` initializer (no type inference), so inferred
+receivers (`const f = this.formField; f.hasHint`) and signal queries (`viewChild(KbqSelect)`) are left untouched. After running, **always inspect the diff**
+and act on the warnings before committing.

package/schematics/migrations/form-field-signals/data.cjs

@@ -0,0 +1,288 @@
+'use strict';
+
+/**
+ * Data for the `form-field-signals` migration.
+ *
+ * The full review of `@koobiq/components/form-field` finished the migration of `KbqFormField` and `KbqHint`
+ * to a signal-based public API, removed the deprecated `mixinColor` from `core`, and gave the icon-only
+ * cleaner and password toggle real button semantics. `KbqFormFieldControl` followed: the state of every control
+ * is a signal, and `stateChanges` is gone.
+ *
+ * Value-preserving property → signal reads are auto-fixed; everything whose value or type semantics changed
+ * is surfaced as a warning.
+ */
+/**
+ * `KbqFormField` content queries and their derived `has*` getters became signals.
+ *
+ * `control`, `stepper` and `connectionContainerRef` were already signals before this release and are
+ * deliberately absent — appending `()` to them would produce a double call.
+ */
+const FORM_FIELD_TARGET = {
+    id: 'KbqFormField',
+    types: ['KbqFormField'],
+    elements: { 'kbq-form-field': 'kbqFormField' },
+    signalMembers: [
+        'cleaner',
+        'passwordToggle',
+        'hint',
+        'prefix',
+        'suffix',
+        'hasCleaner',
+        'hasHint',
+        'hasPasswordToggle',
+        'hasPrefix',
+        'hasStepper',
+        'hasSuffix'
+    ],
+    writableMembers: new Set(),
+    removedMembers: ['hovered', 'onHoverChanged']
+};
+/** Reported where a `KbqFormField` receiver or a reference variable reaches one of its `removedMembers`. */
+const REMOVED_MEMBERS_MESSAGE = '`KbqFormField.hovered` and `onHoverChanged()` were removed — nothing read them, and their pointer listeners ' +
+    'ran change detection on every hover. Bind `(mouseenter)` / `(mouseleave)` on `<kbq-form-field>` yourself, ' +
+    'or style with `:hover`.';
+/** `fillTextOff` and `compact` became signal inputs on the whole hint family. */
+const HINT_TARGET = {
+    id: 'KbqHint',
+    types: ['KbqHint', 'KbqError', 'KbqReactivePasswordHint'],
+    elements: {
+        'kbq-hint': 'kbqHint',
+        'kbq-error': 'kbqError',
+        'kbq-reactive-password-hint': 'kbqReactivePasswordHint'
+    },
+    signalMembers: ['fillTextOff', 'compact'],
+    writableMembers: new Set()
+};
+/** The `KbqFormFieldControl` state: a signal on every control, read-only unless a target says otherwise. */
+const CONTROL_MEMBERS = [
+    'value',
+    'id',
+    'placeholder',
+    'focused',
+    'empty',
+    'required',
+    'disabled',
+    'errorState'
+];
+/** Controls whose `disabled` and `value` both stay writable through `.set()`: the selects and the tag list. */
+const WRITABLE_VALUE_CONTROL_TARGET = {
+    id: 'KbqSelect',
+    types: ['KbqSelect', 'KbqTimezoneSelect', 'KbqTagList'],
+    elements: {
+        'kbq-select': 'kbqSelect',
+        'kbq-timezone-select': 'kbqTimezoneSelect',
+        'kbq-tag-list': 'kbqTagList'
+    },
+    signalMembers: CONTROL_MEMBERS,
+    writableMembers: new Set(['disabled', 'value'])
+};
+/** Controls that own their `value`: only `disabled`, which the form control also sets, stays writable. */
+const READ_ONLY_VALUE_CONTROL_TARGET = {
+    id: 'KbqTreeSelect',
+    types: ['KbqTreeSelect', 'KbqTimepicker', 'KbqDatepickerInput'],
+    elements: { 'kbq-tree-select': 'kbqTreeSelect' },
+    exportAs: ['kbqTimepicker', 'kbqDatepickerInput'],
+    signalMembers: CONTROL_MEMBERS,
+    writableMembers: new Set(['disabled'])
+};
+/** Native-element controls: `value` and `placeholder` stay writable, `disabled` follows the input and the form control. */
+const INPUT_CONTROL_TARGET = {
+    id: 'KbqInput',
+    types: ['KbqInput', 'KbqTextarea'],
+    elements: {},
+    exportAs: ['kbqInput', 'kbqTextarea'],
+    signalMembers: CONTROL_MEMBERS,
+    writableMembers: new Set(['value', 'placeholder'])
+};
+/** The password input: a native-element control whose `elementType` became a read-only signal too. */
+const INPUT_PASSWORD_TARGET = {
+    id: 'KbqInputPassword',
+    types: ['KbqInputPassword'],
+    elements: {},
+    exportAs: ['kbqInputPassword'],
+    signalMembers: [...CONTROL_MEMBERS, 'elementType'],
+    writableMembers: INPUT_CONTROL_TARGET.writableMembers
+};
+/** A receiver typed with the contract itself, which declares every member a read-only signal. */
+const FORM_FIELD_CONTROL_TARGET = {
+    id: 'KbqFormFieldControl',
+    types: ['KbqFormFieldControl'],
+    elements: {},
+    signalMembers: CONTROL_MEMBERS,
+    writableMembers: new Set()
+};
+/** `KbqTagInput`, the text control of a tag list: its state is a read-only signal, as the tag list reads it. */
+const TAG_INPUT_TARGET = {
+    id: 'KbqTagInput',
+    types: ['KbqTagInput'],
+    elements: {},
+    exportAs: ['kbqTagInput', 'kbqTagInputFor'],
+    signalMembers: ['id', 'placeholder', 'focused', 'empty'],
+    writableMembers: new Set()
+};
+const TARGETS = [
+    FORM_FIELD_TARGET,
+    HINT_TARGET,
+    WRITABLE_VALUE_CONTROL_TARGET,
+    READ_ONLY_VALUE_CONTROL_TARGET,
+    INPUT_CONTROL_TARGET,
+    INPUT_PASSWORD_TARGET,
+    FORM_FIELD_CONTROL_TARGET,
+    TAG_INPUT_TARGET
+];
+/**
+ * `KbqFormField` members that were a `QueryList` and are now a `readonly` array. The call syntax is
+ * auto-fixed, but the `QueryList` API is gone.
+ */
+const QUERY_LIST_MEMBERS = ['hint', 'prefix', 'suffix'];
+/** `QueryList` members that a plain array does not have. Detected right after a migrated query member. */
+const QUERY_LIST_ONLY_API = [
+    'changes',
+    'first',
+    'last',
+    'dirty',
+    'toArray',
+    'get',
+    'reset',
+    'notifyOnChanges',
+    'destroy'
+];
+/** `KbqFormField` members whose empty value changed from `null` to `undefined`. */
+const NULLABILITY_CHANGED_MEMBERS = ['cleaner', 'passwordToggle'];
+/**
+ * Members that were writable properties and are now read-only signals: inputs, or state the control derives.
+ * Scoped by each target's `writableMembers`, so a member writable on one control is not reported on it.
+ */
+const READ_ONLY_INPUT_MEMBERS = ['fillTextOff', 'compact', ...CONTROL_MEMBERS];
+/**
+ * `KbqFormField` content queries that were writable properties and are now read-only signals. `cleaner` was
+ * writable only because of an internal workaround; the rest were a `QueryList`, which consumers reassigned to
+ * fake the projected content in tests.
+ */
+const READ_ONLY_QUERY_MEMBERS = [
+    'cleaner',
+    'passwordToggle',
+    'hint',
+    'prefix',
+    'suffix'
+];
+/** Members that were writable fields and are now read-only signals only the control itself changes. */
+const READ_ONLY_STATE_MEMBERS = ['elementType'];
+/** Reported where a write reaches one of `READ_ONLY_STATE_MEMBERS`. */
+const READ_ONLY_STATE_MESSAGE = "`KbqInputPassword.elementType` can no longer be assigned: it is a read-only `Signal<'text' | 'password'>` " +
+    'now. Call `toggleType()` to show or hide the password instead.';
+/**
+ * File-scoped patterns that can't be auto-fixed reliably — surfaced with file locations (in both `fix` and
+ * dry-run mode).
+ */
+const warnPatterns = [
+    {
+        pattern: '\\bmixinColor\\s*\\(',
+        message: '`mixinColor` was removed. Extend `KbqColorDirective` from @koobiq/components/core instead — it ' +
+            'exposes the same `color` input and `colorClassName` getter.'
+    },
+    {
+        pattern: '\\bCanColorCtor\\b',
+        message: '`CanColorCtor` was removed together with `mixinColor`, and so was the `CanColor` interface: type the ' +
+            'member `Signal<KbqComponentColors | string>`, or use `KbqColorDirective`.'
+    },
+    {
+        pattern: 'implements[^{]*\\bKbqFormFieldControl\\b',
+        message: '`KbqFormFieldControl` is signal-based: `value`, `id`, `placeholder`, `focused`, `empty`, `required`, ' +
+            '`disabled` and `errorState` are `Signal`s, and `stateChanges` was removed. A custom control exposes ' +
+            'its state as signals and drops `stateChanges`: the form field derives its own state from them.'
+    },
+    {
+        pattern: 'control\\(\\)\\??\\.stateChanges\\b',
+        message: 'The form field control no longer has `stateChanges`. Read its state signals in a `computed()` or an ' +
+            '`effect()` instead, or turn one into a stream with `toObservable()`.'
+    },
+    {
+        pattern: '\\bKbqErrorStateTracker\\b',
+        message: '`KbqErrorStateTracker` no longer takes a `stateChanges` subject, and its `errorState` is a ' +
+            '`Signal<boolean>`: call `updateErrorState()` from `ngDoCheck` and read `errorState()`.'
+    },
+    {
+        pattern: '\\bmixinErrorState\\s*\\(|\\bCanUpdateErrorStateCtor\\b',
+        message: 'The deprecated `mixinErrorState` and `CanUpdateErrorStateCtor` were removed. Track the error state ' +
+            'with `KbqErrorStateTracker` from @koobiq/components/core instead.'
+    },
+    {
+        pattern: '\\bCanUpdateErrorState\\b',
+        message: '`CanUpdateErrorState.errorState` is a `Signal<boolean>`, and the interface no longer declares ' +
+            '`errorStateMatcher`.'
+    },
+    {
+        pattern: '\\bKbqIconErrorStateContext\\b|\\bkbqIconErrorStateContextFactoryProvider\\b',
+        message: '`KbqIconErrorStateContext.errorState` is a `Signal<boolean>` and `stateChanges` was removed: ' +
+            '`KbqIcon` follows the signal.'
+    },
+    {
+        pattern: '\\bKBQ_FORM_FIELD_REF\\b',
+        message: '`KbqFormFieldRef.control` is no longer `any`: it is `Signal<KbqFormFieldControlRef>`. Reads written ' +
+            'as `formField.control.<member>` were silently `undefined` and now fail to compile — call the signal ' +
+            'first: `formField.control().<member>`.'
+    },
+    {
+        pattern: '\\bKbqA11yLocaleConfiguration\\b|\\bkbqA11yLocaleConfigurationProvider\\s*\\(',
+        message: '`KbqA11yLocaleConfiguration` gained three required keys — `clear`, `showPassword` and ' +
+            '`hidePassword` — for the accessible names of the form-field cleaner and password toggle. A custom ' +
+            'locale object literal has to provide them.'
+    },
+    {
+        pattern: '\\bKbqTrim\\b',
+        message: '`KbqTrim.trim` is now typed `(value: unknown) => unknown` instead of `any`. Assigning its result to ' +
+            'a typed variable needs a narrowing check or a cast.'
+    },
+    {
+        pattern: '<kbq-error[^>]*\\b(?:role|aria-live|aria-atomic)=',
+        message: '`kbq-error` now renders `role="alert"` and `aria-atomic="true"` itself, so the form field announces ' +
+            'validation errors. Drop the hand-rolled live-region attributes.'
+    },
+    {
+        pattern: '<kbq-cleaner[^>]*\\brole=',
+        message: '`kbq-cleaner` now renders `role="button"` and a localized `aria-label` itself. The explicit `role` ' +
+            'attribute is redundant.'
+    }
+];
+/**
+ * `KbqCleaner` exposes `aria-label` as a real input backed by a host binding, so an `[attr.aria-label]`
+ * written by the consumer is now overwritten by the component's localized default.
+ */
+const attributeRewrites = [
+    {
+        element: 'kbq-cleaner',
+        from: '[attr.aria-label]',
+        to: '[aria-label]',
+        reason: 'kbq-cleaner now owns the aria-label host binding'
+    },
+    {
+        element: 'kbq-cleaner',
+        from: 'attr.aria-label',
+        to: 'aria-label',
+        reason: 'kbq-cleaner now owns the aria-label host binding'
+    }
+];
+/** The misspelled `_fiedset-theme.scss` was renamed to `_fieldset-theme.scss`. */
+const styleRewrites = [{ from: 'fiedset-theme', to: 'fieldset-theme' }];
+
+exports.FORM_FIELD_CONTROL_TARGET = FORM_FIELD_CONTROL_TARGET;
+exports.FORM_FIELD_TARGET = FORM_FIELD_TARGET;
+exports.HINT_TARGET = HINT_TARGET;
+exports.INPUT_CONTROL_TARGET = INPUT_CONTROL_TARGET;
+exports.INPUT_PASSWORD_TARGET = INPUT_PASSWORD_TARGET;
+exports.NULLABILITY_CHANGED_MEMBERS = NULLABILITY_CHANGED_MEMBERS;
+exports.QUERY_LIST_MEMBERS = QUERY_LIST_MEMBERS;
+exports.QUERY_LIST_ONLY_API = QUERY_LIST_ONLY_API;
+exports.READ_ONLY_INPUT_MEMBERS = READ_ONLY_INPUT_MEMBERS;
+exports.READ_ONLY_QUERY_MEMBERS = READ_ONLY_QUERY_MEMBERS;
+exports.READ_ONLY_STATE_MEMBERS = READ_ONLY_STATE_MEMBERS;
+exports.READ_ONLY_STATE_MESSAGE = READ_ONLY_STATE_MESSAGE;
+exports.READ_ONLY_VALUE_CONTROL_TARGET = READ_ONLY_VALUE_CONTROL_TARGET;
+exports.REMOVED_MEMBERS_MESSAGE = REMOVED_MEMBERS_MESSAGE;
+exports.TAG_INPUT_TARGET = TAG_INPUT_TARGET;
+exports.TARGETS = TARGETS;
+exports.WRITABLE_VALUE_CONTROL_TARGET = WRITABLE_VALUE_CONTROL_TARGET;
+exports.attributeRewrites = attributeRewrites;
+exports.styleRewrites = styleRewrites;
+exports.warnPatterns = warnPatterns;