@koobiq/components 20.4.1 → 21.0.0

package/schematics/migrations/tags-signals/schema.json

@@ -0,0 +1,20 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "koobiq-components-tags-signals",
+    "title": "Koobiq components tags signals migration",
+    "type": "object",
+    "properties": {
+        "project": {
+            "type": "string",
+            "description": "Name of the project to migrate. If omitted, the migration runs over the whole tree.",
+            "$default": {
+                "$source": "projectName"
+            }
+        },
+        "fix": {
+            "type": "boolean",
+            "default": true,
+            "description": "When true, applies all auto-fix replacements. When false, prints what would change without writing."
+        }
+    }
+}

package/schematics/migrations/textarea-signals/README.md

@@ -0,0 +1,72 @@
+# textarea-signals
+
+Migration schematic invoked automatically by `ng update @koobiq/components@21` (registered for
+`21.0.0-0`). Migrates `KbqTextarea` consumers to its signal-based inputs.
+
+## Background
+
+The `KbqFormFieldControl` members of `KbqTextarea` — `value`, `id`, `placeholder`, `required`,
+`disabled`, `focused`, `empty` and `errorState` — are signals, migrated by `form-field-signals`: reads
+become calls, a write to `value` becomes `.set()`, a write to the rest is reported. This schematic
+covers the four inputs the textarea owns.
+
+`canGrow` was the odd one:
+
+```ts
+get canGrow(): boolean {
+    return !this.maxRowLimitReached && this._canGrow;
+}
+```
+
+It reported `false` once the textarea hit `maxRows`, even though the consumer had asked for growth.
+The folded value is an internal `growing` computed now, and `canGrow()` reports what was bound. At the
+row limit the element keeps its own scrollbar rather than gaining a native resize handle:
+`kbq-textarea_max-row-limit-reached` sets `resize: unset`, which follows `kbq-textarea-resizable` in
+the stylesheet and wins on source order.
+
+## What it rewrites
+
+| Before                        | After                           |
+| ----------------------------- | ------------------------------- |
+| `textarea.maxRows`            | `textarea.maxRows()`            |
+| `textarea.maxRowLimitReached` | `textarea.maxRowLimitReached()` |
+
+On receivers explicitly typed `KbqTextarea`. Already-migrated reads are left alone, so the schematic
+is idempotent. There is no template pass: `kbqTextarea` is an attribute on a native `<textarea>`, so
+a reference variable is not tied to an element name the schematic can match.
+
+## What it does _not_ do
+
+| Pattern                                                 | Manual migration                                                                           |
+| ------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
+| `.canGrow`                                              | `canGrow()`, and expect what was bound — not `false` at the row limit                      |
+| `.freeRowsHeight`                                       | `freeRowsHeight()`, and expect `undefined` when unbound                                    |
+| `.canGrow = …` / `.maxRows = …` / `.freeRowsHeight = …` | Bind them; the inputs are read-only                                                        |
+| `.grow()` / a detached `.grow`                          | Protected now; a layout change it cannot see is measured at the next value or input change |
+| `viewChild(KbqTextarea)`                                | The query returns the instance, so a read is a double call                                 |
+
+## Notes with no call site to point at
+
+- **`maxRows` and `freeRowsHeight` report `number | undefined`.** Both were declared non-nullable
+  while an unbound `maxRows` held `undefined`, and `maxRowLimitReached` compared against it —
+  `rowsCount > undefined` is false, which is why unlimited growth worked at all. `freeRowsHeight`
+  differs: `ngOnInit` used to assign the measured line height into the input, so an unbound read came
+  back with a number. It stays `undefined` now, which is why the migration reports those reads rather
+  than rewriting them.
+- **`freeRowsHeight` no longer writes itself.** It defaulted to the measured line height by assigning
+  its own input in `ngOnInit`; the fallback is a computed now, so binding it later actually takes
+  effect instead of being overwritten on the next init.
+- **The `kbq-textarea_max-row-limit-reached` class follows the row count directly.** It is derived
+  from a signal written inside `runOutsideAngular`, so the class used to wait for an unrelated change
+  detection pass to appear.
+- **Generated ids come from the CDK `_IdGenerator`** instead of a module-level counter. The shape is
+  unchanged for a default `APP_ID` - the CDK omits the app id when it is `ng` - and the per-prefix
+  counter still starts at 0, so a real app keeps getting `kbq-textarea-0`.
+
+## Running it manually
+
+```
+ng generate @koobiq/components:textarea-signals --project my-app
+```
+
+Pass `--fix=false` to see what it would change without writing.

package/schematics/migrations/textarea-signals/data.js

@@ -0,0 +1,121 @@
+'use strict';
+
+/**
+ * Data for the `textarea-signals` migration.
+ *
+ * The `KbqFormFieldControl` members of `KbqTextarea` (`value`, `id`, `placeholder`, `required`, `disabled`,
+ * `focused`, `empty`, `errorState`) are signals too, but `form-field-signals` migrates them. This migration
+ * covers the inputs that belong to the textarea itself.
+ *
+ * - `textarea.canGrow` → a signal whose value changed: the getter folded in the row limit (warn)
+ * - `textarea.freeRowsHeight` → a signal whose value changed: the textarea used to write the measured
+ *   line height into it on init, so an unbound read came back with a number (warn)
+ * - `textarea.maxRows` / `maxRowLimitReached` → calls (value unchanged — auto-fixed)
+ * - `textarea.grow` → protected, so a call or a detached reference no longer compiles (warn)
+ */
+/** Members whose value is unchanged; a read must become a call. Auto-fixed. */
+const SIGNAL_MEMBERS = ['maxRows', 'maxRowLimitReached'];
+/** TypeScript type annotation that marks a receiver as a textarea. */
+const TEXTAREA_TYPE = 'KbqTextarea';
+/** `exportAs` a template reference variable has to carry to point at the textarea. */
+const TEXTAREA_EXPORT_AS = 'kbqTextarea';
+/** Signal-API methods reachable on a signal; a read followed by one is already migrated. */
+const SIGNAL_API_METHODS = new Set(['set', 'update', 'asReadonly', 'subscribe']);
+/** Reported for a value-changed member read through a template reference, which is not auto-fixed. */
+const templateManualMessage = (members) => `Read through a template reference variable and left untouched, because the value changed as well ` +
+    `as the shape: ${[...members].join(', ')}. Migrate those bindings by hand.`;
+/** Reported when a template names the textarea but cannot be parsed, so nothing in it was inspected. */
+const UNPARSEABLE_TEMPLATE_MESSAGE = 'This template names `kbqTextarea` but could not be parsed, so it was left untouched. Migrate reads ' +
+    'through its template reference variables by hand.';
+/** Import specifier that marks a file as a textarea consumer. */
+const TEXTAREA_PACKAGE = '@koobiq/components/textarea';
+/**
+ * Read-only `InputSignal`s whose value also changed, so a mechanical `()` append would compile and hand
+ * back something else.
+ *
+ * `canGrow`: the getter used to return `!maxRowLimitReached && bound`, so it reported `false` once the
+ * textarea hit `maxRows` even though the consumer had asked for growth. It reports what was bound now.
+ *
+ * `freeRowsHeight`: `ngOnInit` used to assign the measured line height into the input, so an unbound
+ * textarea read back a number once the first microtask had run. The fallback is a private computed now
+ * and the input stays `undefined`, which turns `gap + 'px'` at a call site into `"undefined" + "px"` with no
+ * diagnostic.
+ */
+const VALUE_CHANGED_MEMBERS = ['canGrow', 'freeRowsHeight'];
+/**
+ * Reported for a read of a member that still compiles after a mechanical `()` append but hands back a
+ * different value than it did before.
+ */
+const valueChangedMessage = (members) => {
+    const names = [...members];
+    const lines = [
+        `${names.join(' and ')} ${names.length > 1 ? 'are' : 'is a'} read-only InputSignal` +
+            `${names.length > 1 ? 's' : ''} whose value also changed, so appending \`()\` compiles and ` +
+            'hands back something else. Migrate by hand.'
+    ];
+    if (names.includes('canGrow')) {
+        lines.push('`canGrow` used to return `!maxRowLimitReached && bound`, so it reported false once the ' +
+            'textarea hit `maxRows` even though the consumer had asked for growth; it reports what ' +
+            'was bound now.');
+    }
+    if (names.includes('freeRowsHeight')) {
+        lines.push('`freeRowsHeight` used to be assigned the measured line height in `ngOnInit`, so an unbound ' +
+            'textarea read back a number; the fallback is internal now and the input stays ' +
+            '`undefined`, which turns `gap + "px"` into `"undefined" + "px"` with no diagnostic.');
+    }
+    return lines.join(' ');
+};
+const TEXTAREA_ANCHOR = '\\bKbqTextarea\\b';
+const warnPatterns = [
+    {
+        anchor: TEXTAREA_ANCHOR,
+        pattern: '\\.\\s*(?:freeRowsHeight|maxRows|canGrow)\\s*=[^=]',
+        message: 'KbqTextarea.canGrow, maxRows and freeRowsHeight are read-only signal inputs now, so a ' +
+            'programmatic write no longer compiles. Bind them in the template instead. `freeRowsHeight` in ' +
+            'particular used to be written by the textarea itself on init, which is why the automated ' +
+            'migration skipped it.'
+    },
+    {
+        anchor: TEXTAREA_ANCHOR,
+        pattern: '\\.\\s*grow\\b',
+        message: 'KbqTextarea.grow is protected now, so a call - `textarea.grow()` - and a detached reference - ' +
+            '`setTimeout(textarea.grow, 0)` - no longer compile. The textarea already re-measures on every ' +
+            'value change and whenever one of its inputs changes; a layout change it cannot see, such as a width ' +
+            'change, is measured at the next one.'
+    },
+    {
+        anchor: TEXTAREA_ANCHOR,
+        pattern: '(?:viewChild|ViewChild|contentChild|ContentChild)[^\\n;]*\\bKbqTextarea\\b',
+        message: 'A KbqTextarea view/content query returns the directive instance, whose `maxRows` and ' +
+            '`maxRowLimitReached` are now signals — reading one is a double call, e.g. ' +
+            '`this.textarea().maxRows()`. Verify query reads manually.'
+    }
+];
+/** Printed once per project, after the per-file reports. */
+const SUMMARY = [
+    '  `maxRows` and `freeRowsHeight` report `number | undefined` instead of `number`. Both were declared ' +
+        'non-nullable while an unbound textarea held `undefined`, and `maxRowLimitReached` compared against ' +
+        'it — `rowsCount > undefined` is false, which is why unlimited growth worked at all.',
+    '  `freeRowsHeight` no longer writes itself. It defaulted to the measured line height by assigning its ' +
+        'own input in `ngOnInit`; the fallback is a computed now, so binding it later actually takes effect ' +
+        'instead of being overwritten on the next init.',
+    '  The `kbq-textarea_max-row-limit-reached` class follows the row count directly. It is derived from a ' +
+        'signal written inside `runOutsideAngular`, so the class used to wait for an unrelated change ' +
+        'detection pass to appear.',
+    '  Generated ids come from the CDK `_IdGenerator` instead of a module-level counter. The shape is ' +
+        'unchanged for a default `APP_ID`: the CDK omits the app id when it is `ng`, and the per-prefix ' +
+        'counter still starts at 0, so a real app keeps getting `kbq-textarea-0`. Only an app that sets ' +
+        '`APP_ID` explicitly sees it in the id, and the counter is shared per prefix rather than per module.'
+];
+
+exports.SIGNAL_API_METHODS = SIGNAL_API_METHODS;
+exports.SIGNAL_MEMBERS = SIGNAL_MEMBERS;
+exports.SUMMARY = SUMMARY;
+exports.TEXTAREA_EXPORT_AS = TEXTAREA_EXPORT_AS;
+exports.TEXTAREA_PACKAGE = TEXTAREA_PACKAGE;
+exports.TEXTAREA_TYPE = TEXTAREA_TYPE;
+exports.UNPARSEABLE_TEMPLATE_MESSAGE = UNPARSEABLE_TEMPLATE_MESSAGE;
+exports.VALUE_CHANGED_MEMBERS = VALUE_CHANGED_MEMBERS;
+exports.templateManualMessage = templateManualMessage;
+exports.valueChangedMessage = valueChangedMessage;
+exports.warnPatterns = warnPatterns;

package/schematics/migrations/textarea-signals/index.js

@@ -0,0 +1,379 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ts = require('typescript');
+var utils_ast = require('../../utils/ast.js');
+var utils_messages = require('../../utils/messages.js');
+var utils_packageConfig = require('../../package-config-BhU2TfC8.js');
+var utils_typescript = require('../../utils/typescript.js');
+var migrations_textareaSignals_data = require('./data.js');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+
+const LABEL = '[textarea-signals]';
+const TS_EXT = '.ts';
+const HTML_EXT = '.html';
+/** 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;
+}
+const isFunctionLike = (node) => ts.isFunctionDeclaration(node) ||
+    ts.isMethodDeclaration(node) ||
+    ts.isConstructorDeclaration(node) ||
+    ts.isArrowFunction(node) ||
+    ts.isFunctionExpression(node) ||
+    ts.isGetAccessorDeclaration(node) ||
+    ts.isSetAccessorDeclaration(node);
+/** Walks up from `node` to the nearest ancestor matching `predicate`. */
+function findAncestor(node, predicate) {
+    let current = node.parent;
+    while (current) {
+        if (predicate(current))
+            return current;
+        current = current.parent;
+    }
+    return undefined;
+}
+/** Whether a type annotation refers to `typeName`. */
+function isTypeReference(type, typeName) {
+    return !!type && ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName) && type.typeName.text === typeName;
+}
+const FIELD_MODIFIERS = new Set([
+    ts.SyntaxKind.PrivateKeyword,
+    ts.SyntaxKind.PublicKeyword,
+    ts.SyntaxKind.ProtectedKeyword,
+    ts.SyntaxKind.ReadonlyKeyword
+]);
+/**
+ * Collects the receivers annotated with `typeName`, by explicit annotation only (no cross-package type
+ * resolution): method/function params, class fields (incl. `@ViewChild(KbqTextarea) x: KbqTextarea` and constructor
+ * parameter-properties) and typed locals.
+ */
+function collectReceivers(sourceFile, typeName) {
+    const receivers = [];
+    const add = (text, scope) => receivers.push({ text, start: scope.getStart(sourceFile), end: scope.getEnd() });
+    const visit = (node) => {
+        if (ts.isParameter(node) && ts.isIdentifier(node.name) && isTypeReference(node.type, typeName)) {
+            add(node.name.text, findAncestor(node, isFunctionLike) ?? sourceFile);
+            // A constructor parameter-property is also a class field, reachable as `this.<name>`.
+            if (node.modifiers?.some((modifier) => FIELD_MODIFIERS.has(modifier.kind))) {
+                const owner = findAncestor(node, ts.isClassDeclaration);
+                if (owner)
+                    add(`this.${node.name.text}`, owner);
+            }
+        }
+        else if (ts.isPropertyDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            isTypeReference(node.type, typeName)) {
+            const owner = findAncestor(node, ts.isClassDeclaration);
+            if (owner)
+                add(`this.${node.name.text}`, owner);
+        }
+        else if (ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            isTypeReference(node.type, typeName)) {
+            add(node.name.text, findAncestor(node, isFunctionLike) ?? sourceFile);
+        }
+        node.forEachChild(visit);
+    };
+    visit(sourceFile);
+    return receivers;
+}
+/** Whether a property access on a receiver is within one of the receiver's scopes. */
+function inReceiverScope(node, sourceFile, receivers) {
+    const receiverText = node.expression.getText(sourceFile);
+    const start = node.getStart(sourceFile);
+    const end = node.getEnd();
+    return receivers.some((r) => r.text === receiverText && start >= r.start && end <= r.end);
+}
+/** Binary operators that make their left operand a write target rather than a read. */
+const ASSIGNMENT_OPERATORS = new Set([
+    ts.SyntaxKind.EqualsToken,
+    ts.SyntaxKind.PlusEqualsToken,
+    ts.SyntaxKind.MinusEqualsToken,
+    ts.SyntaxKind.AsteriskEqualsToken,
+    ts.SyntaxKind.AsteriskAsteriskEqualsToken,
+    ts.SyntaxKind.SlashEqualsToken,
+    ts.SyntaxKind.PercentEqualsToken,
+    ts.SyntaxKind.LessThanLessThanEqualsToken,
+    ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
+    ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
+    ts.SyntaxKind.AmpersandEqualsToken,
+    ts.SyntaxKind.BarEqualsToken,
+    ts.SyntaxKind.CaretEqualsToken,
+    ts.SyntaxKind.BarBarEqualsToken,
+    ts.SyntaxKind.AmpersandAmpersandEqualsToken,
+    ts.SyntaxKind.QuestionQuestionEqualsToken
+]);
+/** Unary operators that write their operand back. Every other prefix operator is a plain read. */
+const INCREMENT_OPERATORS = new Set([ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken]);
+/** Whether `node` sits on the left of a destructuring assignment, where it is written rather than read. */
+function isDestructuringTarget(node) {
+    let current = node;
+    while (ts.isPropertyAssignment(current.parent) ||
+        ts.isShorthandPropertyAssignment(current.parent) ||
+        ts.isSpreadAssignment(current.parent) ||
+        ts.isSpreadElement(current.parent) ||
+        ts.isObjectLiteralExpression(current.parent) ||
+        ts.isArrayLiteralExpression(current.parent)) {
+        current = current.parent;
+    }
+    return (ts.isBinaryExpression(current.parent) &&
+        current.parent.left === current &&
+        ASSIGNMENT_OPERATORS.has(current.parent.operatorToken.kind));
+}
+/** Classifies a matched property access and appends the resulting edit(s). */
+function classifyAccess(node, edits) {
+    const parent = node.parent;
+    // Already migrated: `x.maxRows()` — leave alone (idempotent).
+    if (ts.isCallExpression(parent) && parent.expression === node)
+        return;
+    // Write target, in every shape. Each migrated member is an `input()` or a read-only `computed`, so a
+    // write has no mechanical translation: it is left untouched and becomes the read-only error the
+    // consumer fixes by hand. Appending `()` to it would produce unparseable TypeScript instead.
+    if (ts.isBinaryExpression(parent) && parent.left === node && ASSIGNMENT_OPERATORS.has(parent.operatorToken.kind))
+        return;
+    // `x.maxRows++` / `--x.maxRows` and `delete x.maxRows` are writes too. Only the increment operators
+    // count: a `PrefixUnaryExpression` is also how `!x.maxRowLimitReached` is spelled, and that is a read.
+    if (ts.isPostfixUnaryExpression(parent) && parent.operand === node)
+        return;
+    if (ts.isPrefixUnaryExpression(parent) && parent.operand === node && INCREMENT_OPERATORS.has(parent.operator))
+        return;
+    if (ts.isDeleteExpression(parent))
+        return;
+    if (isDestructuringTarget(node))
+        return;
+    // Read (incl. optional chain `x?.maxRows`): append `()`.
+    edits.push({ start: node.getEnd(), end: node.getEnd(), text: '()' });
+}
+/** Collects edits for every read/write of a value-safe signal member on a known textarea receiver. */
+function collectAccessEdits(sourceFile, receivers) {
+    const edits = [];
+    const visit = (node) => {
+        if (ts.isPropertyAccessExpression(node) &&
+            ts.isIdentifier(node.name) &&
+            migrations_textareaSignals_data.SIGNAL_MEMBERS.includes(node.name.text) &&
+            inReceiverScope(node, sourceFile, receivers)) {
+            classifyAccess(node, edits);
+        }
+        node.forEachChild(visit);
+    };
+    visit(sourceFile);
+    return edits;
+}
+/** Collects the members read on a textarea receiver that need manual migration. */
+function collectValueChangedAccess(sourceFile, receivers) {
+    const valueChanged = new Set();
+    const visit = (node) => {
+        if (ts.isPropertyAccessExpression(node) &&
+            ts.isIdentifier(node.name) &&
+            migrations_textareaSignals_data.VALUE_CHANGED_MEMBERS.includes(node.name.text) &&
+            inReceiverScope(node, sourceFile, receivers)) {
+            valueChanged.add(node.name.text);
+        }
+        node.forEachChild(visit);
+    };
+    visit(sourceFile);
+    return valueChanged;
+}
+/** Pass A — rewrite value-safe programmatic reads of textarea signal members in TypeScript code. */
+function migrateTsExpressions(content, fileName) {
+    const sourceFile = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const receivers = collectReceivers(sourceFile, migrations_textareaSignals_data.TEXTAREA_TYPE);
+    if (receivers.length === 0)
+        return content;
+    const edits = collectAccessEdits(sourceFile, receivers);
+    return edits.length > 0 ? applyEdits(content, edits) : content;
+}
+/** Emits precise, receiver-scoped warnings for the members that can't be auto-fixed. */
+function warnReceiverMembers(context, filePath, content) {
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const receivers = collectReceivers(sourceFile, migrations_textareaSignals_data.TEXTAREA_TYPE);
+    if (receivers.length === 0)
+        return;
+    const valueChanged = collectValueChangedAccess(sourceFile, receivers);
+    if (valueChanged.size > 0) {
+        utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${migrations_textareaSignals_data.valueChangedMessage(valueChanged)}`]);
+    }
+}
+function logWarnings(context, filePath, content) {
+    for (const { anchor, pattern, message } of migrations_textareaSignals_data.warnPatterns) {
+        if (!new RegExp(anchor).test(content) || !new RegExp(pattern).test(content))
+            continue;
+        utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${message}`]);
+    }
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Matches `<ref>.<member>` where the access is neither already a call nor a signal-API call. A template can
+ * only read these, so an assignment never needs excluding. The dot is matched with the whitespace around it
+ * - Angular's expression grammar allows `t . maxRows` and a binding wrapped over two lines - and that
+ * whitespace is captured so the rewrite keeps the layout.
+ */
+function memberAccessPattern(ref, members) {
+    const methods = [...migrations_textareaSignals_data.SIGNAL_API_METHODS].join('|');
+    return new RegExp(`\\b(${escapeRegExp(ref)})(\\s*\\.\\s*)(${members.join('|')})\\b(?!\\s*\\()(?!\\s*\\.\\s*(?:${methods})\\b)`, 'g');
+}
+/** Reference variables bound to the textarea: `#t="kbqTextarea"` on any element. */
+class TemplateCollector {
+    constructor() {
+        this.refs = new Set();
+    }
+    visitElement(element) {
+        for (const attr of element.attrs ?? []) {
+            if (typeof attr.name !== 'string' || attr.value !== migrations_textareaSignals_data.TEXTAREA_EXPORT_AS)
+                continue;
+            if (attr.name.startsWith('#'))
+                this.refs.add(attr.name.slice(1));
+            else if (attr.name.startsWith('ref-'))
+                this.refs.add(attr.name.slice(4));
+        }
+        this.visitChildren(element);
+    }
+    visitBlock(block) {
+        this.visitChildren(block);
+    }
+    visitChildren(node) {
+        utils_ast.visitAll(this, node.children ?? []);
+    }
+    visitAttribute() { }
+    visitText() { }
+    visitComment() { }
+    visitExpansion() { }
+    visitExpansionCase() { }
+    visitBlockParameter() { }
+    visitLetDeclaration() { }
+}
+/** Pass B - rewrite reads through a textarea reference variable and report the ones that changed value. */
+async function migrateTemplate(template) {
+    const untouched = { content: template, changed: false, manual: new Set(), unparseable: false };
+    if (!template.includes(migrations_textareaSignals_data.TEXTAREA_EXPORT_AS))
+        return untouched;
+    const parsed = await utils_typescript.parseTemplate(template);
+    if (!parsed.tree)
+        return { ...untouched, unparseable: true };
+    const collector = new TemplateCollector();
+    utils_ast.visitAll(collector, parsed.tree.rootNodes);
+    const refs = [...collector.refs];
+    if (refs.length === 0)
+        return untouched;
+    const manual = new Set();
+    let content = template;
+    let changed = false;
+    for (const ref of refs) {
+        for (const match of template.matchAll(memberAccessPattern(ref, migrations_textareaSignals_data.VALUE_CHANGED_MEMBERS))) {
+            manual.add(match[3]);
+        }
+        const next = content.replace(memberAccessPattern(ref, migrations_textareaSignals_data.SIGNAL_MEMBERS), '$1$2$3()');
+        if (next !== content) {
+            content = next;
+            changed = true;
+        }
+    }
+    return { content, changed, manual, unparseable: false };
+}
+/** Pass B (inline) - the same, inside inline component templates. */
+async function migrateInlineTemplates(content, fileName) {
+    const sourceFile = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const manual = new Set();
+    let result = content;
+    let changed = false;
+    let unparseable = false;
+    // Splice right-to-left so earlier offsets stay valid.
+    for (const { start, end } of utils_typescript.collectInlineTemplateRanges(sourceFile).sort((a, b) => b.start - a.start)) {
+        const migrated = await migrateTemplate(result.slice(start, end));
+        migrated.manual.forEach((member) => manual.add(member));
+        unparseable ||= migrated.unparseable;
+        if (migrated.changed) {
+            result = result.slice(0, start) + migrated.content + result.slice(end);
+            changed = true;
+        }
+    }
+    return { content: result, changed, manual, unparseable };
+}
+/**
+ * A `.ts` file is a textarea consumer if it names any of the exported symbols or imports the package. There
+ * is no element to look for: `kbqTextarea` is an attribute on a native `<textarea>`.
+ */
+function referencesTextarea(content) {
+    return /\bKbqTextarea\w*\b/.test(content) || content.includes(migrations_textareaSignals_data.TEXTAREA_PACKAGE);
+}
+function textareaSignals(options) {
+    return async (tree, context) => {
+        const { project } = options;
+        // `ng update` runs a migration with no options at all, and `migrations.json` declares no schema, so
+        // the schema default never reaches the rule: without this the migration would only ever report.
+        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 = [];
+        utils_packageConfig.visitProjectFiles(rootDir, (filePath) => {
+            if (filePath.endsWith(TS_EXT))
+                tsPaths.push(filePath);
+            else if (filePath.endsWith(HTML_EXT))
+                htmlPaths.push(filePath);
+        });
+        let touched = 0;
+        let consumers = 0;
+        const commit = (filePath, original, updated) => {
+            if (updated === original)
+                return;
+            touched++;
+            if (fix) {
+                tree.overwrite(filePath, updated);
+            }
+            else {
+                utils_messages.logMessage(context.logger, [`${LABEL} would update ${filePath} (run with --fix to apply)`]);
+            }
+        };
+        const report = (filePath, message) => utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${message}`]);
+        for (const filePath of tsPaths) {
+            const original = tree.read(filePath)?.toString();
+            if (!original || !referencesTextarea(original))
+                continue;
+            consumers++;
+            logWarnings(context, filePath, original);
+            warnReceiverMembers(context, filePath, original);
+            const inline = await migrateInlineTemplates(migrateTsExpressions(original, filePath), filePath);
+            if (inline.manual.size > 0)
+                report(filePath, migrations_textareaSignals_data.templateManualMessage(inline.manual));
+            if (inline.unparseable)
+                report(filePath, migrations_textareaSignals_data.UNPARSEABLE_TEMPLATE_MESSAGE);
+            commit(filePath, original, inline.content);
+        }
+        for (const filePath of htmlPaths) {
+            const original = tree.read(filePath)?.toString();
+            if (!original)
+                continue;
+            const migrated = await migrateTemplate(original);
+            if (!migrated.changed && migrated.manual.size === 0 && !migrated.unparseable)
+                continue;
+            consumers++;
+            if (migrated.manual.size > 0)
+                report(filePath, migrations_textareaSignals_data.templateManualMessage(migrated.manual));
+            if (migrated.unparseable)
+                report(filePath, migrations_textareaSignals_data.UNPARSEABLE_TEMPLATE_MESSAGE);
+            commit(filePath, original, migrated.content);
+        }
+        // Nothing here uses the textarea, so the summary would only be noise.
+        if (consumers === 0)
+            return;
+        utils_messages.logMessage(context.logger, [
+            `${LABEL} processed tree under "${root || '<workspace root>'}", ` +
+                `${fix ? 'updated' : 'would update'} ${touched} file(s).`,
+            ...migrations_textareaSignals_data.SUMMARY
+        ]);
+    };
+}
+
+exports.default = textareaSignals;

package/schematics/migrations/textarea-signals/schema.json

@@ -0,0 +1,20 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "koobiq-components-textarea-signals",
+    "title": "Koobiq components textarea signals migration",
+    "type": "object",
+    "properties": {
+        "project": {
+            "type": "string",
+            "description": "Name of the project to migrate. If omitted, the migration runs over the whole tree.",
+            "$default": {
+                "$source": "projectName"
+            }
+        },
+        "fix": {
+            "type": "boolean",
+            "default": true,
+            "description": "When true, applies all auto-fix replacements. When false, prints what would change without writing."
+        }
+    }
+}