@koobiq/components 20.4.2 → 21.0.0

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

@@ -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;

package/schematics/migrations/form-field-signals/index.js

@@ -0,0 +1,382 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ts = require('typescript');
+var utils_messages = require('../../utils/messages.js');
+var utils_packageConfig = require('../../package-config-BhU2TfC8.js');
+var signalMembersMigration = require('../../signal-members-migration-BoAJKutT.js');
+var templateRefAccess = require('../../template-ref-access-DLNoxmmG.js');
+var utils_typescript = require('../../utils/typescript.js');
+var migrations_formFieldSignals_data = require('./data.js');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+require('../../utils/ast.js');
+
+const MIGRATION = 'form-field-signals';
+const TS_EXT = '.ts';
+const HTML_EXT = '.html';
+const STYLE_EXTS = ['.scss', '.css'];
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Applies text-span edits to `content`, right-to-left, so earlier edits don't shift later offsets. */
+function applyEdits(content, edits) {
+    const sorted = [...edits].sort((a, b) => b.start - a.start || b.end - a.end);
+    let result = content;
+    for (const { start, end, text } of sorted) {
+        result = result.slice(0, start) + text + result.slice(end);
+    }
+    return result;
+}
+/**
+ * Whether a property access reads from a receiver of the target. The shared engine resolves the receiver at
+ * this exact position, so a nested declaration that shadows its name or a `function` that rebinds `this` is
+ * not followed. A signal query (`viewChild(KbqSelect)`) holds the instance behind a call of its own, which
+ * this pass does not reach.
+ */
+function onReceiver(node, sourceFile, scope) {
+    const receiver = signalMembersMigration.resolveReceiver(node.expression, node, sourceFile, scope.receivers, scope.bindings);
+    return !!receiver && !receiver.signalQuery;
+}
+/** Collects edits for every read/write of a migrated member on a known receiver of `target`. */
+function collectAccessEdits(sourceFile, target, scope) {
+    const edits = [];
+    const visit = (node) => {
+        if (ts.isPropertyAccessExpression(node) &&
+            ts.isIdentifier(node.name) &&
+            target.signalMembers.includes(node.name.text) &&
+            onReceiver(node, sourceFile, scope)) {
+            signalMembersMigration.classifyAccess(node, sourceFile, target.writableMembers, edits);
+        }
+        node.forEachChild(visit);
+    };
+    visit(sourceFile);
+    return edits;
+}
+const emptyWarnings = () => ({
+    queryListApi: new Set(),
+    nullability: new Set(),
+    readOnlyInputWrites: new Set(),
+    readOnlyQueryWrites: new Set(),
+    readOnlyStateWrites: new Set(),
+    writableWrites: new Set(),
+    removed: new Set()
+});
+/** Collects the members that the auto-fix can't fully migrate for one target. */
+function collectReceiverWarnings(sourceFile, target, scope) {
+    const warnings = emptyWarnings();
+    const visit = (node) => {
+        if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name)) {
+            const name = node.name.text;
+            const reachesReceiver = onReceiver(node, sourceFile, scope);
+            if (reachesReceiver && migrations_formFieldSignals_data.NULLABILITY_CHANGED_MEMBERS.includes(name)) {
+                warnings.nullability.add(name);
+            }
+            if (reachesReceiver && target.removedMembers?.includes(name)) {
+                warnings.removed.add(name);
+            }
+            // `target.signalMembers` scopes the flat name lists to the members this receiver actually owns.
+            if (reachesReceiver && target.signalMembers.includes(name) && signalMembersMigration.isWriteTarget(node)) {
+                if (target.writableMembers.has(name)) {
+                    if (!signalMembersMigration.isPlainAssignment(node))
+                        warnings.writableWrites.add(name);
+                }
+                else if (migrations_formFieldSignals_data.READ_ONLY_INPUT_MEMBERS.includes(name)) {
+                    warnings.readOnlyInputWrites.add(name);
+                }
+                else if (migrations_formFieldSignals_data.READ_ONLY_QUERY_MEMBERS.includes(name)) {
+                    warnings.readOnlyQueryWrites.add(name);
+                }
+                else if (migrations_formFieldSignals_data.READ_ONLY_STATE_MEMBERS.includes(name)) {
+                    warnings.readOnlyStateWrites.add(name);
+                }
+            }
+            // `formField.hint.changes` — the query member is migrated, the QueryList API below it is not.
+            if (migrations_formFieldSignals_data.QUERY_LIST_ONLY_API.includes(name) &&
+                ts.isPropertyAccessExpression(node.expression) &&
+                ts.isIdentifier(node.expression.name) &&
+                migrations_formFieldSignals_data.QUERY_LIST_MEMBERS.includes(node.expression.name.text) &&
+                onReceiver(node.expression, sourceFile, scope)) {
+                warnings.queryListApi.add(`${node.expression.name.text}.${name}`);
+            }
+        }
+        node.forEachChild(visit);
+    };
+    visit(sourceFile);
+    return warnings;
+}
+/** The members of a file's receivers that can't be auto-fixed, across every target. */
+function collectFileWarnings(filePath, content) {
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const bindings = signalMembersMigration.collectBindings(sourceFile);
+    const merged = emptyWarnings();
+    for (const target of migrations_formFieldSignals_data.TARGETS) {
+        const receivers = signalMembersMigration.collectAllReceivers(sourceFile, target.types);
+        if (receivers.length === 0)
+            continue;
+        const warnings = collectReceiverWarnings(sourceFile, target, { receivers, bindings });
+        warnings.queryListApi.forEach((value) => merged.queryListApi.add(value));
+        warnings.nullability.forEach((value) => merged.nullability.add(value));
+        warnings.readOnlyInputWrites.forEach((value) => merged.readOnlyInputWrites.add(value));
+        warnings.readOnlyQueryWrites.forEach((value) => merged.readOnlyQueryWrites.add(value));
+        warnings.readOnlyStateWrites.forEach((value) => merged.readOnlyStateWrites.add(value));
+        warnings.writableWrites.forEach((value) => merged.writableWrites.add(value));
+        warnings.removed.forEach((value) => merged.removed.add(value));
+    }
+    return merged;
+}
+const emptyTemplateFindings = () => ({
+    readOnlyWrites: new Set(),
+    compoundWrites: new Set(),
+    removed: new Set()
+});
+/** Merges the findings of one template into `into`. */
+function mergeTemplateFindings(into, from) {
+    from.readOnlyWrites.forEach((member) => into.readOnlyWrites.add(member));
+    from.compoundWrites.forEach((member) => into.compoundWrites.add(member));
+    from.removed.forEach((member) => into.removed.add(member));
+}
+/** Adds the members a template reaches through a reference variable to the warnings. */
+function addTemplateFindings(warnings, findings) {
+    for (const name of findings.readOnlyWrites) {
+        if (migrations_formFieldSignals_data.READ_ONLY_INPUT_MEMBERS.includes(name))
+            warnings.readOnlyInputWrites.add(name);
+        else if (migrations_formFieldSignals_data.READ_ONLY_QUERY_MEMBERS.includes(name))
+            warnings.readOnlyQueryWrites.add(name);
+        else if (migrations_formFieldSignals_data.READ_ONLY_STATE_MEMBERS.includes(name))
+            warnings.readOnlyStateWrites.add(name);
+    }
+    findings.compoundWrites.forEach((member) => warnings.writableWrites.add(member));
+    findings.removed.forEach((member) => warnings.removed.add(member));
+    return warnings;
+}
+/** Emits precise, receiver-scoped warnings for the members that can't be auto-fixed. */
+function logReceiverWarnings(context, filePath, merged) {
+    if (merged.queryListApi.size > 0) {
+        utils_messages.logMessage(context.logger, [
+            `[${MIGRATION}] ${filePath}`,
+            `  These KbqFormField members are now a readonly array instead of a QueryList, so the QueryList API is`,
+            `  gone: ${[...merged.queryListApi].join(', ')}. The queries are signals — react to them with`,
+            `  \`computed()\`/\`effect()\` instead of \`.changes\`, and use \`[0]\`/\`.at(-1)\`/the array itself instead`,
+            `  of \`.first\`/\`.last\`/\`.toArray()\`.`
+        ]);
+    }
+    if (merged.nullability.size > 0) {
+        utils_messages.logMessage(context.logger, [
+            `[${MIGRATION}] ${filePath}`,
+            `  \`${[...merged.nullability].join('`, `')}\` now returns \`undefined\` instead of \`null\` when absent.`,
+            `  Strict comparisons against \`null\` no longer match — use a truthiness check or \`== null\`.`
+        ]);
+    }
+    if (merged.readOnlyInputWrites.size > 0) {
+        utils_messages.logMessage(context.logger, [
+            `[${MIGRATION}] ${filePath}`,
+            `  \`${[...merged.readOnlyInputWrites].join('`, `')}\` can no longer be assigned: they are read-only`,
+            `  signal inputs now. Drive them with a template binding (e.g. \`[fillTextOff]="…"\`) instead of an`,
+            `  assignment.`
+        ]);
+    }
+    if (merged.readOnlyQueryWrites.size > 0) {
+        utils_messages.logMessage(context.logger, [
+            `[${MIGRATION}] ${filePath}`,
+            `  \`${[...merged.readOnlyQueryWrites].join('`, `')}\` can no longer be assigned: they are read-only`,
+            `  signal content queries now. Project the content into the form field instead — code that assigned a`,
+            `  query result (usually a test faking the projected content) has to render the real component.`
+        ]);
+    }
+    if (merged.readOnlyStateWrites.size > 0) {
+        utils_messages.logMessage(context.logger, [`[${MIGRATION}] ${filePath}`, `  ${migrations_formFieldSignals_data.READ_ONLY_STATE_MESSAGE}`]);
+    }
+    if (merged.removed.size > 0) {
+        utils_messages.logMessage(context.logger, [`[${MIGRATION}] ${filePath}`, `  ${migrations_formFieldSignals_data.REMOVED_MEMBERS_MESSAGE}`]);
+    }
+    if (merged.writableWrites.size > 0) {
+        utils_messages.logMessage(context.logger, [
+            `[${MIGRATION}] ${filePath}`,
+            `  \`${[...merged.writableWrites].join('`, `')}\` are writable signals now, but only a plain \`=\` is`,
+            `  rewritten to \`.set()\`: a compound assignment, an increment, \`delete\` or a destructuring target`,
+            `  was left as it is. Write it with \`.set()\` or \`.update()\`.`
+        ]);
+    }
+}
+/** Pass A — rewrite value-safe programmatic reads of migrated members in TypeScript code. */
+function migrateTsExpressions(content, fileName) {
+    let result = content;
+    // One target at a time, re-parsing in between, so the edit offsets of each pass stay valid.
+    for (const target of migrations_formFieldSignals_data.TARGETS) {
+        const sourceFile = ts.createSourceFile(fileName, result, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+        const receivers = signalMembersMigration.collectAllReceivers(sourceFile, target.types);
+        if (receivers.length === 0)
+            continue;
+        const edits = collectAccessEdits(sourceFile, target, { receivers, bindings: signalMembersMigration.collectBindings(sourceFile) });
+        if (edits.length > 0)
+            result = applyEdits(result, edits);
+    }
+    return result;
+}
+/** Rewrites renamed attributes inside the opening tag of the elements that own them. */
+function rewriteAttributes(template) {
+    let content = template;
+    for (const { element, from, to } of migrations_formFieldSignals_data.attributeRewrites) {
+        const tagPattern = new RegExp(`<${escapeRegExp(element)}\\b[^>]*>`, 'g');
+        content = content.replace(tagPattern, (tag) => {
+            const attrPattern = new RegExp(`(\\s)${escapeRegExp(from)}(\\s*=)`, 'g');
+            return tag.replace(attrPattern, `$1${to}$2`);
+        });
+    }
+    return content;
+}
+/**
+ * Whether a `#ref` with `value` on an `element` names `target`: bare or naming the `exportAs` on one of its elements,
+ * or naming one of its directive `exportAs` names on any element.
+ */
+function refersTo({ elements, exportAs = [] }, element, value) {
+    if (Object.hasOwn(elements, element) && (!value || value === elements[element]))
+        return true;
+    return !!value && exportAs.includes(value);
+}
+/**
+ * Pass B (core) — parse a template, discover target refs, rewrite their reads, writes and renamed attributes, and
+ * find the removed members they reach.
+ */
+async function migrateTemplate(template) {
+    let content = rewriteAttributes(template);
+    const findings = emptyTemplateFindings();
+    const relevant = migrations_formFieldSignals_data.TARGETS.filter((target) => Object.keys(target.elements).some((element) => template.includes(element)) ||
+        target.exportAs?.some((exportAs) => template.includes(exportAs)));
+    if (relevant.length > 0) {
+        const parsed = await utils_typescript.parseTemplate(content);
+        if (parsed.tree) {
+            const { rootNodes } = parsed.tree;
+            const policies = new Map(relevant.map((target) => [
+                target,
+                {
+                    members: target.signalMembers,
+                    writable: target.writableMembers,
+                    reported: target.removedMembers
+                }
+            ]));
+            const result = templateRefAccess.rewriteRefAccesses(content, rootNodes, (element, value) => {
+                const target = relevant.find((candidate) => refersTo(candidate, element.name, value));
+                return target && policies.get(target);
+            });
+            content = result.content;
+            result.readOnlyWrites.forEach((member) => findings.readOnlyWrites.add(member));
+            result.compoundWrites.forEach((member) => findings.compoundWrites.add(member));
+            result.reported.forEach((member) => findings.removed.add(member));
+        }
+    }
+    return { content, changed: content !== template, ...findings };
+}
+/** Pass B (inline) — rewrite target ref reads and writes inside inline component templates. */
+async function migrateInlineTemplates(content, fileName) {
+    const sourceFile = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const ranges = utils_typescript.collectInlineTemplateRanges(sourceFile).sort((a, b) => b.start - a.start);
+    const findings = emptyTemplateFindings();
+    let result = content;
+    for (const { start, end } of ranges) {
+        const outcome = await migrateTemplate(result.slice(start, end));
+        mergeTemplateFindings(findings, outcome);
+        if (outcome.changed) {
+            result = result.slice(0, start) + outcome.content + result.slice(end);
+        }
+    }
+    return { content: result, ...findings };
+}
+/** Pass C — the misspelled `_fiedset-theme.scss` was renamed. */
+function migrateStyles(content) {
+    let result = content;
+    for (const { from, to } of migrations_formFieldSignals_data.styleRewrites) {
+        result = result.split(from).join(to);
+    }
+    return result;
+}
+function logWarnings(context, filePath, content) {
+    for (const { pattern, message } of migrations_formFieldSignals_data.warnPatterns) {
+        if (new RegExp(pattern).test(content)) {
+            utils_messages.logMessage(context.logger, [`[${MIGRATION}] ${filePath}`, `  ${message}`]);
+        }
+    }
+}
+/**
+ * A file is a form-field consumer if it names one of the migrated symbols, imports the package, renders a
+ * control or names the `exportAs` of a directive one: a component that imports only `KbqInputModule` names no type.
+ */
+function referencesFormField(content) {
+    return (migrations_formFieldSignals_data.TARGETS.some((target) => target.exportAs?.some((name) => content.includes(name))) ||
+        /\bKbq(FormField|Hint|Error|ReactivePasswordHint|Cleaner|PasswordToggle|Stepper|Trim|A11yLocaleConfiguration)\b/.test(content) ||
+        /\b(mixinColor|CanColorCtor|KBQ_FORM_FIELD_REF|kbqA11yLocaleConfigurationProvider)\b/.test(content) ||
+        /\bKbq(Select|TreeSelect|TimezoneSelect|TagList|TagInput|Input|InputPassword|Textarea|Timepicker|DatepickerInput|FormFieldControl|ErrorStateTracker|IconErrorStateContext)\b/.test(content) ||
+        /\b(mixinErrorState|CanUpdateErrorState|CanUpdateErrorStateCtor|kbqIconErrorStateContextFactoryProvider)\b/.test(content) ||
+        content.includes('@koobiq/components/form-field') ||
+        content.includes('kbq-form-field') ||
+        content.includes('kbq-cleaner') ||
+        /<kbq-(select|tree-select|timezone-select|tag-list)\b/.test(content));
+}
+function formFieldSignals(options) {
+    return async (tree, context) => {
+        const { project } = options;
+        // `ng update` invokes migrations with no options at all, and migrations.json declares no schema, so the
+        // schema default never reaches us — applying the fix is the intended behaviour there.
+        const fix = options.fix ?? true;
+        const projectDefinition = await utils_packageConfig.setupOptions(project, tree);
+        const root = projectDefinition?.root ?? '';
+        const rootDir = root ? tree.getDir(root) : tree.root;
+        const tsPaths = [];
+        const htmlPaths = [];
+        const stylePaths = [];
+        utils_packageConfig.visitProjectFiles(rootDir, (filePath) => {
+            if (filePath.endsWith(TS_EXT))
+                tsPaths.push(filePath);
+            else if (filePath.endsWith(HTML_EXT))
+                htmlPaths.push(filePath);
+            else if (STYLE_EXTS.some((ext) => filePath.endsWith(ext)))
+                stylePaths.push(filePath);
+        });
+        let touched = 0;
+        const commit = (filePath, original, updated) => {
+            if (updated === original)
+                return;
+            touched++;
+            if (fix) {
+                tree.overwrite(filePath, updated);
+            }
+            else {
+                utils_messages.logMessage(context.logger, [`[${MIGRATION}] would update ${filePath} (run with --fix to apply)`]);
+            }
+        };
+        for (const filePath of tsPaths) {
+            const original = tree.read(filePath)?.toString();
+            if (!original || !referencesFormField(original))
+                continue;
+            logWarnings(context, filePath, original);
+            const warnings = collectFileWarnings(filePath, original);
+            const inline = await migrateInlineTemplates(migrateTsExpressions(original, filePath), filePath);
+            logReceiverWarnings(context, filePath, addTemplateFindings(warnings, inline));
+            commit(filePath, original, inline.content);
+        }
+        for (const filePath of htmlPaths) {
+            const original = tree.read(filePath)?.toString();
+            if (!original)
+                continue;
+            logWarnings(context, filePath, original);
+            const outcome = await migrateTemplate(original);
+            logReceiverWarnings(context, filePath, addTemplateFindings(emptyWarnings(), outcome));
+            if (outcome.changed)
+                commit(filePath, original, outcome.content);
+        }
+        for (const filePath of stylePaths) {
+            const original = tree.read(filePath)?.toString();
+            if (!original)
+                continue;
+            commit(filePath, original, migrateStyles(original));
+        }
+        utils_messages.logMessage(context.logger, [
+            `[${MIGRATION}] processed tree under "${root || '<workspace root>'}", ` +
+                `${fix ? 'updated' : 'would update'} ${touched} file(s).`
+        ]);
+    };
+}
+
+exports.default = formFieldSignals;