@koobiq/components 20.4.1 → 21.0.0

package/schematics/migrations/input-number-surface/README.md

@@ -0,0 +1,140 @@
+# input-number-surface
+
+Migration schematic invoked automatically by `ng update @koobiq/components@20`
+(registered for `21.0.0-0`). Rewrites reads of the four `KbqNumberInput` members that became signals,
+and reports everything else: the members that disappeared with the `KbqFormFieldControl` surface the
+directive declared and never populated, the validator directives that gained a `Kbq` prefix, and the
+behaviors that changed without a call site to point at.
+
+## `min`, `max`, `step` and `bigStep` are `input()` signals
+
+A read becomes a call. The value is unchanged, so this part is auto-fixed:
+
+```ts
+// before
+const span = numberInput.max - numberInput.min;
+// after
+const span = numberInput.max() - numberInput.min();
+```
+
+The rewrite is scoped, not textual. `min`, `max` and `step` are among the most common property names
+there are, so a bare `\.min\b` match would rewrite a plain object literal's bounds. Only two receivers
+qualify:
+
+- an identifier this file **annotates** as `KbqNumberInput` — a parameter, a field, a local, or a
+  `viewChild(KbqNumberInput)` initializer. There is no cross-package type resolution, so a receiver
+  whose type is only inferred is left alone.
+- a template reference bound through the directive's `exportAs`: `#ref="kbqNumberInput"` or the
+  `kbqNumericalInput` alias. Both external and inline templates.
+
+Template **bindings** are otherwise untouched — `[min]="lower"` and `min="3"` still work.
+
+The one exception is `bigStep`, which had a second spelling: the legacy `big-step` attribute, read once
+at construction and deaf to every later change. Keeping both would mean maintaining the same input
+twice, so the kebab-case one is dropped and renamed here, scoped to the `<input>` tag that carries the
+directive.
+
+A programmatic **write** (`numberInput.min = 0`) is reported, not rewritten: an `input()` is read-only
+and has no `.set()`, so the binding has to take over. The rewrite is idempotent — an already-migrated
+`min()` is left alone, so running it twice is safe.
+
+## `KbqInputPassword` mints its ids in its own namespace
+
+It shared the `kbq-input-` counter with `KbqInput`, so any page holding both controls emitted two
+elements with the same id, and the form field's `<label for>` resolved to whichever came first. A
+password field now renders `id="kbq-input-password-7"` where it used to render `id="kbq-input-7"`.
+
+Reported, not rewritten: a hand-written reference to a generated id is a symptom, and the fix is
+usually to stop depending on the generated value rather than to renumber it.
+
+## The unprefixed validator exports are gone
+
+`MinValidator`, `MaxValidator`, `MIN_VALIDATOR` and `MAX_VALIDATOR` were deprecated aliases of the
+`Kbq`-prefixed names. They are removed, and rewritten here — a pure rename has one mechanical
+translation.
+
+The rewrite is scoped to the names a file imports from `@koobiq/components/input`, because
+`@angular/forms` exports `MinValidator` and `MaxValidator` under exactly those spellings — which is
+why the koobiq ones were renamed in the first place. A file importing the framework's is left alone.
+
+## `valueChange` and `disabledChange` are Subjects
+
+Both were `EventEmitter`. Subscribing is unchanged; a call to `.emit()` becomes `.next()`. Reported
+rather than rewritten: those two names are far too common to match blind.
+
+## Background
+
+`KbqNumberInput` declared `implements KbqFormFieldControl<any>` and then assigned none of it. The
+private `control` field behind `ngControl` had no writer anywhere in the file, so `ngControl` was
+permanently `undefined`, and `id`, `placeholder`, `empty`, `required` and `errorState` were declared
+only to satisfy the interface. Nothing broke, because the `KbqFormFieldControl` provider lives on the
+sibling `KbqInput` — which matches the same host and supplies the real implementation — but the
+members were public, so a consumer reading `numberInputRef.errorState` got `undefined` with no type
+error.
+
+| Member                                                              | Before                     | After              |
+| ------------------------------------------------------------------- | -------------------------- | ------------------ |
+| `ngControl`, `id`, `placeholder`, `empty`, `required`, `errorState` | public, always `undefined` | removed            |
+| `MinValidator`, `MaxValidator`                                      | deprecated aliases         | removed, rewritten |
+| `MIN_VALIDATOR`, `MAX_VALIDATOR`                                    | deprecated aliases         | removed, rewritten |
+
+The unprefixed validator names are the exact names `@angular/forms` exports, so importing both in one
+file shadowed the framework's.
+
+## Two behaviors that changed with no call site
+
+`type="number"` on a `kbqNumberInput` is now reset to `type="text"` with a console warning. A native
+number field runs the value sanitization algorithm on assignment and rejects everything the directive
+renders once a group separator or a comma fraction separator is in it, so the field went blank while
+the model still held the value; it also reports `selectionStart` as `null`, which disabled caret
+preservation entirely.
+
+`HTMLInputElement.prototype.valueAsNumber` is no longer redefined. The constructor used to call
+`Object.defineProperty(Object.getPrototypeOf(this.nativeElement), 'valueAsNumber', …)` — that is the
+prototype, not the element, so constructing one koobiq number input replaced the platform accessor for
+every `<input>` in the application, permanently and with no teardown. A locale-aware numeric read is
+now a member of the directive: `numberInput.valueAsNumber`.
+
+## What it does _not_ rewrite
+
+A member that was always `undefined` has no replacement expression, and the validator rename is safe to
+leave in place until the deprecated aliases are dropped.
+
+| Pattern                                                          | Manual migration                                                   |
+| ---------------------------------------------------------------- | ------------------------------------------------------------------ |
+| `numberInput.errorState` / `.ngControl` / `.empty` / `.required` | Read them off the sibling `KbqInput` or off the `<kbq-form-field>` |
+| `numberInput.min = 0`                                            | Bind `[min]="0"` — an `input()` has no `.set()`                    |
+| `numberInput.valueChange.emit(v)`                                | `numberInput.valueChange.next(v)`                                  |
+| `<input kbqNumberInput type="number">`                           | Drop the attribute                                                 |
+| `inputElement.valueAsNumber`                                     | `numberInput.valueAsNumber`, or read the form control              |
+| `#kbq-input-7` on a password field                               | Stop keying on a generated id, or use `kbq-input-password-7`       |
+
+A receiver whose `KbqNumberInput` type is inferred rather than written down is also out of reach, as
+are the forms no structural match can see — an index read (`refs['input'].min`) and destructuring
+(`const { min } = numberInput`). Nothing about those is reported, so check them by hand.
+
+## Also in the release, with nothing to migrate
+
+- The numeric inputs coerce their value, so a static attribute (`min="3"`) holds the number `3` rather
+  than the string `"3"`. The `ngAcceptInputType_*` declarations that used to carry that are gone: a
+  signal input types what it accepts through its transform's parameter.
+- The validators no longer `parseInt` their bound value, so `[min]="0.5"` validates against `0.5`
+  instead of `0`, and a bound `[min]="0"` reaches the DOM instead of being dropped by a falsy check.
+- Stepping runs in integer space against a decimal scale, so one arrow press on `1.005` with
+  `step="0.001"` renders `1,006` rather than `1,0059999999999998`.
+- `KbqNumberInput` carries spinbutton semantics: `role`, `aria-valuenow`, `aria-valuetext`,
+  `aria-valuemin`, `aria-valuemax` and `inputmode`.
+- `startFormattingFrom` is read from the input as well as from the locale, instead of being declared
+  and ignored.
+
+## Usage
+
+```bash
+ng update @koobiq/components
+```
+
+Or standalone:
+
+```bash
+ng generate @koobiq/components:input-number-surface --project=my-app
+```

package/schematics/migrations/input-number-surface/data.js

@@ -0,0 +1,135 @@
+'use strict';
+
+/**
+ * Data for the `input-number-surface` migration.
+ *
+ * The input review stripped the `KbqFormFieldControl` surface `KbqNumberInput` declared and never
+ * populated, and prefixed the two validator directives whose unprefixed names shadow the identically
+ * named exports of `@angular/forms`:
+ *
+ * - `KbqNumberInput` no longer `implements KbqFormFieldControl`. `ngControl`, `errorState`, `id`,
+ *   `placeholder`, `empty` and `required` are gone; every one of them was `undefined` for the whole
+ *   lifetime of the directive, because the backing `control` field was never assigned. The real
+ *   implementation always lived on the sibling `KbqInput`, which is what the form field resolves.
+ * - `MinValidator` / `MaxValidator` / `MIN_VALIDATOR` / `MAX_VALIDATOR` → `KbqMinValidator` /
+ *   `KbqMaxValidator` / `KBQ_MIN_VALIDATOR` / `KBQ_MAX_VALIDATOR`. The old names stay as deprecated
+ *   aliases for one minor, so nothing breaks today.
+ *
+ * It then finished the signal migration: `min`, `max`, `step` and `bigStep` became `input()`, so a read
+ * has to become a call. That part *is* rewritten — scoped to a receiver whose type is provably
+ * `KbqNumberInput`, because `min`/`max`/`step` are far too common to match on the member name alone.
+ *
+ * The rest is warn-only. A removed member that was always `undefined` has no replacement expression,
+ * and the validator rename is safe to leave until the aliases are dropped.
+ */
+/** Import specifier that marks a file as an input consumer. */
+const INPUT_PACKAGE = '@koobiq/components/input';
+/** Identifier and attribute shapes that mark a consumer without an import. */
+const INPUT_TYPE = '\\bKbqNumberInput\\b|\\bkbqNumberInput\\b';
+/** The password directive, which owns the id-namespace change. Anchors its own warning. */
+const PASSWORD_TYPE = '\\bKbqInputPassword\\b|\\bkbqInputPassword\\b';
+/** TypeScript type annotation that marks a receiver as a number input. */
+const NUMBER_INPUT_TYPE = 'KbqNumberInput';
+/** `exportAs` names a template reference variable can bind the directive under. */
+const NUMBER_INPUT_EXPORT_AS = ['kbqNumberInput', 'kbqNumericalInput'];
+/**
+ * `KbqNumberInput` members that became `input()` signals. The value is unchanged — only the call
+ * syntax — so a read is rewritten to a call. Every one of these is read-only: a programmatic write
+ * has no `.set()` and is warned about instead.
+ */
+const SIGNAL_MEMBERS = ['min', 'max', 'step', 'bigStep'];
+/**
+ * The `KbqFormFieldControl` member-access pattern, handled separately from {@link warnPatterns}: `KbqInput`
+ * — the sibling directive that also matches `input[kbqNumberInput]` — still exposes every one of these
+ * members, so a bare text match would also flag a file that correctly reads them off a `KbqInput`-typed
+ * reference. `index.ts` resolves the receiver of each match against the file's AST before reporting it.
+ */
+const FORM_FIELD_CONTROL_MEMBER_PATTERN = {
+    anchor: INPUT_TYPE,
+    pattern: '\\b([A-Za-z_$][\\w$]*)\\s*\\.\\s*(?:ngControl|errorState|placeholder|empty|required)\\b',
+    message: 'KbqNumberInput no longer implements KbqFormFieldControl: ngControl, errorState, id, placeholder, ' +
+        'empty and required were removed. None of them was ever assigned — the private `control` field ' +
+        'behind ngControl had no writer — so every read returned undefined. Read them off the sibling ' +
+        'KbqInput, which owns the KbqFormFieldControl provider on the same element, or off the form ' +
+        'field itself.'
+};
+/**
+ * Removed exports and the prefixed names that replace them. A pure rename with one mechanical
+ * translation each, so these are rewritten rather than reported.
+ *
+ * The unprefixed names were the exact names `@angular/forms` exports, so importing both in one file
+ * shadowed the framework validator. They were deprecated aliases; this release drops them.
+ *
+ * Only rewritten in a file that imports `@koobiq/components/input` — without that anchor, a project
+ * importing `MinValidator` from `@angular/forms` would be rewritten to a koobiq name it never imported.
+ */
+const RENAMED_EXPORTS = [
+    ['MinValidator', 'KbqMinValidator'],
+    ['MaxValidator', 'KbqMaxValidator'],
+    ['MIN_VALIDATOR', 'KBQ_MIN_VALIDATOR'],
+    ['MAX_VALIDATOR', 'KBQ_MAX_VALIDATOR']
+];
+const warnPatterns = [
+    {
+        anchor: INPUT_TYPE,
+        // Both attribute orders, and only within the same `<input>` tag as `kbqNumberInput` — a bare
+        // `type\s*=\s*"number"` anywhere in the file also matches an unrelated native input.
+        pattern: '<input\\b[^>]*\\bkbqNumberInput\\b[^>]*\\btype\\s*=\\s*[\'"]number[\'"]|' +
+            '<input\\b[^>]*\\btype\\s*=\\s*[\'"]number[\'"][^>]*\\bkbqNumberInput\\b',
+        message: 'type="number" on a kbqNumberInput is reset to type="text" with a console warning. A native ' +
+            'number field runs the value sanitization algorithm on assignment and drops every value the ' +
+            'directive formats — anything with a fraction, and anything over 999 while withThousandSeparator ' +
+            'is on — so the field went blank while the model still held the value. Drop the attribute.'
+    },
+    {
+        anchor: INPUT_TYPE,
+        pattern: '\\b(?:valueChange|disabledChange)\\s*\\.\\s*emit\\b',
+        message: 'KbqNumberInput.valueChange and .disabledChange are RxJS Subjects rather than EventEmitters. ' +
+            'Subscribing is unchanged; a call to .emit() becomes .next(). These names are too common to ' +
+            'rewrite blind — check whether the receiver is the number input before renaming.'
+    },
+    {
+        // Anchored on the password directive, not on INPUT_TYPE: the ids belong to KbqInputPassword.
+        anchor: PASSWORD_TYPE,
+        // A hand-written reference to a generated id, in a selector, a test id or an aria-* attribute.
+        pattern: '[\'"#\\[]\\s*kbq-input-\\d|kbq-input-\\d+["\'\\]]|\\bkbq-input-\\d',
+        message: 'KbqInputPassword mints its ids in its own kbq-input-password- namespace now, so a password ' +
+            'field that used to render id="kbq-input-7" renders id="kbq-input-password-7". It shared the ' +
+            'kbq-input- counter with KbqInput before, which produced two elements with the same id on any ' +
+            "page holding both controls, and the form field's <label for> then resolved to the wrong one. " +
+            'Anything keyed on the generated id — a CSS selector, a test locator, a hand-written ' +
+            'aria-labelledby — has to be updated, or better, stop depending on a generated value.'
+    },
+    {
+        anchor: INPUT_TYPE,
+        pattern: '\\bvalueAsNumber\\b',
+        message: 'KbqNumberInput no longer redefines HTMLInputElement.prototype.valueAsNumber. The patch replaced ' +
+            'the platform accessor for every <input> in the application, returned null where the DOM ' +
+            'specification requires NaN, and read a date field as parseFloat of its date string. A ' +
+            'locale-aware numeric read is now a member of the directive: numberInput.valueAsNumber.'
+    }
+];
+/** Printed once per project, after the per-file reports. */
+const SUMMARY = [
+    '  min, max, step and bigStep are input() signals that coerce their value, so a static attribute ' +
+        '(min="3") holds the number 3 rather than the string "3". Reads on a KbqNumberInput-typed ' +
+        'receiver were rewritten to calls; template bindings ([min], big-step="2") are unchanged.',
+    '  MinValidator/MaxValidator no longer parseInt their bound value, so a fractional [min]="0.5" ' +
+        'validates against 0.5 instead of 0, and a bound [min]="0" reaches the DOM instead of being ' +
+        'dropped by a falsy check.',
+    '  Stepping is done in integer space against a decimal scale, so one arrow press on 1.005 with ' +
+        'step="0.001" renders 1,006 rather than 1,0059999999999998.',
+    '  KbqNumberInput carries spinbutton semantics — role, aria-valuenow, aria-valuetext, aria-valuemin, ' +
+        'aria-valuemax and inputmode.'
+];
+
+exports.FORM_FIELD_CONTROL_MEMBER_PATTERN = FORM_FIELD_CONTROL_MEMBER_PATTERN;
+exports.INPUT_PACKAGE = INPUT_PACKAGE;
+exports.INPUT_TYPE = INPUT_TYPE;
+exports.NUMBER_INPUT_EXPORT_AS = NUMBER_INPUT_EXPORT_AS;
+exports.NUMBER_INPUT_TYPE = NUMBER_INPUT_TYPE;
+exports.PASSWORD_TYPE = PASSWORD_TYPE;
+exports.RENAMED_EXPORTS = RENAMED_EXPORTS;
+exports.SIGNAL_MEMBERS = SIGNAL_MEMBERS;
+exports.SUMMARY = SUMMARY;
+exports.warnPatterns = warnPatterns;

package/schematics/migrations/input-number-surface/index.js

@@ -0,0 +1,292 @@
+'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 migrations_inputNumberSurface_data = require('./data.js');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+
+const LABEL = '[input-number-surface]';
+const EXTENSIONS = ['.ts', '.html'];
+const TS_EXT = '.ts';
+/** A file is an input consumer if it imports the package or names one of the directives. */
+function referencesInput(content) {
+    return (content.includes(migrations_inputNumberSurface_data.INPUT_PACKAGE) ||
+        new RegExp(migrations_inputNumberSurface_data.INPUT_TYPE).test(content) ||
+        new RegExp(migrations_inputNumberSurface_data.PASSWORD_TYPE).test(content));
+}
+const createSourceFile = (fileName, content) => ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+/**
+ * Identifiers in the file explicitly typed as `typeName` — through a type annotation, or a
+ * `viewChild(<typeName>)` / `viewChild.required(<typeName>)` initializer.
+ *
+ * Used for two opposite purposes. For `KbqInput` it suppresses a false positive: a member access on one
+ * of these can never be the `KbqFormFieldControl` surface this migration warns about, because `KbqInput`
+ * still owns it. For `KbqNumberInput` it is what scopes the signal-read rewrite, since `min`/`max`/`step`
+ * are far too common to match on the member name alone.
+ *
+ * Only this file's annotations are consulted — there is no cross-package type resolution — so a receiver
+ * whose type is inferred rather than written down is left alone.
+ */
+function collectTypedNames(sourceFile, typeName) {
+    const names = new Set();
+    const isKbqInputTypeNode = (node) => !!node && ts.isTypeReferenceNode(node) && node.typeName.getText(sourceFile) === typeName;
+    const referencesKbqInput = (call) => call.arguments.some((argument) => ts.isIdentifier(argument) && argument.text === typeName);
+    const visit = (node) => {
+        if ((ts.isPropertyDeclaration(node) || ts.isVariableDeclaration(node) || ts.isParameter(node)) &&
+            ts.isIdentifier(node.name) &&
+            isKbqInputTypeNode(node.type)) {
+            names.add(node.name.text);
+        }
+        if (ts.isCallExpression(node) &&
+            /^viewChild(\.required)?$/.test(node.expression.getText(sourceFile)) &&
+            referencesKbqInput(node)) {
+            const owner = node.parent;
+            if ((ts.isPropertyDeclaration(owner) || ts.isVariableDeclaration(owner)) && ts.isIdentifier(owner.name)) {
+                names.add(owner.name.text);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return names;
+}
+/** The receiver name (capture group 1) of every `FORM_FIELD_CONTROL_MEMBER_PATTERN` match in `content`. */
+function collectFormFieldControlReceivers(content) {
+    const regex = new RegExp(migrations_inputNumberSurface_data.FORM_FIELD_CONTROL_MEMBER_PATTERN.pattern, 'g');
+    const receivers = [];
+    let match;
+    while ((match = regex.exec(content))) {
+        receivers.push(match[1]);
+    }
+    return receivers;
+}
+/**
+ * Whether `content` reads a removed `KbqFormFieldControl` member off something other than a provably
+ * `KbqInput`-typed reference. `KbqInput` keeps every one of these members, so a match whose receiver
+ * resolves to a `KbqInput`-typed identifier is a false positive, not a call site the rename broke.
+ * `.html` templates fall back to the plain existence check: a template-reference receiver (`#ref="kbqInput"`)
+ * is not resolved here.
+ */
+function reportsFormFieldControlMember(filePath, content) {
+    const receivers = collectFormFieldControlReceivers(content);
+    if (receivers.length === 0)
+        return false;
+    if (!filePath.endsWith(TS_EXT))
+        return true;
+    const kbqInputTypedNames = collectTypedNames(createSourceFile(filePath, content), 'KbqInput');
+    return receivers.some((receiver) => !kbqInputTypedNames.has(receiver));
+}
+/** Applies text-span edits to `content`, right-to-left, so earlier edits don't shift later offsets. */
+function applyEdits(content, edits) {
+    return [...edits]
+        .sort((a, b) => b.start - a.start || b.end - a.end)
+        .reduce((result, { start, end, text }) => result.slice(0, start) + text + result.slice(end), content);
+}
+/**
+ * Trailing identifier of a receiver expression: `input` for `input`, `numberInput` for
+ * `this.numberInput`. Anything else (a call, an index read) has no stable name and is skipped.
+ */
+function receiverName(expression) {
+    if (ts.isIdentifier(expression))
+        return expression.text;
+    if (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.name))
+        return expression.name.text;
+    return null;
+}
+/**
+ * Rewrites `numberInput.min` to `numberInput.min()` on every receiver this file annotates as a
+ * `KbqNumberInput`. A write (`numberInput.min = 5`) is left alone and reported instead: the members are
+ * read-only `input()`s, so there is no `.set()` to rewrite to, and the binding is the replacement.
+ *
+ * Returns the rewritten content plus the distinct member names written to, for the caller to report.
+ */
+function migrateSignalReads(content, filePath) {
+    const written = new Set();
+    if (!migrations_inputNumberSurface_data.SIGNAL_MEMBERS.some((member) => content.includes(member)))
+        return { content, written };
+    const sourceFile = createSourceFile(filePath, content);
+    const receivers = collectTypedNames(sourceFile, migrations_inputNumberSurface_data.NUMBER_INPUT_TYPE);
+    if (receivers.size === 0)
+        return { content, written };
+    const edits = [];
+    const visit = (node) => {
+        if (ts.isPropertyAccessExpression(node) &&
+            ts.isIdentifier(node.name) &&
+            migrations_inputNumberSurface_data.SIGNAL_MEMBERS.includes(node.name.text)) {
+            const name = receiverName(node.expression);
+            if (name && receivers.has(name)) {
+                const parent = node.parent;
+                const isWrite = ts.isBinaryExpression(parent) &&
+                    parent.left === node &&
+                    parent.operatorToken.kind === ts.SyntaxKind.EqualsToken;
+                // Already a call — `min()` — so the rewrite stays idempotent across repeated runs.
+                const isCalled = ts.isCallExpression(parent) && parent.expression === node;
+                if (isWrite)
+                    written.add(node.name.text);
+                else if (!isCalled)
+                    edits.push({ start: node.getEnd(), end: node.getEnd(), text: '()' });
+            }
+        }
+        node.forEachChild(visit);
+    };
+    visit(sourceFile);
+    return { content: edits.length > 0 ? applyEdits(content, edits) : content, written };
+}
+/**
+ * Template reference variables bound to the number input by `exportAs` — `#ref="kbqNumberInput"` and the
+ * `kbqNumericalInput` alias. Matched textually: the templates this runs over are the consumer's, and a
+ * full template parse would still not tell us the directive's type.
+ */
+function collectTemplateRefs(template) {
+    const pattern = new RegExp(`#([A-Za-z_$][\\w$]*)\\s*=\\s*["'](?:${migrations_inputNumberSurface_data.NUMBER_INPUT_EXPORT_AS.join('|')})["']`, 'g');
+    return [...template.matchAll(pattern)].map((match) => match[1]);
+}
+/**
+ * Names this file imports from `@koobiq/components/input` that were renamed. A name can only be bound
+ * once per module, so a name imported from koobiq here cannot also be the `@angular/forms` export of the
+ * same spelling — which is what makes a whole-file rename of it safe.
+ */
+function collectRenamedImports(sourceFile) {
+    const imported = new Set();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) ||
+            !ts.isStringLiteralLike(statement.moduleSpecifier) ||
+            statement.moduleSpecifier.text !== migrations_inputNumberSurface_data.INPUT_PACKAGE) {
+            continue;
+        }
+        const bindings = statement.importClause?.namedBindings;
+        if (!bindings || !ts.isNamedImports(bindings))
+            continue;
+        for (const element of bindings.elements) {
+            // `import { MinValidator as Lower }` binds a different local name; the import itself is
+            // rewritten by the propertyName branch, and the alias keeps working untouched.
+            imported.add((element.propertyName ?? element.name).text);
+        }
+    }
+    return migrations_inputNumberSurface_data.RENAMED_EXPORTS.filter(([from]) => imported.has(from));
+}
+/** Rewrites the removed export names to their prefixed replacements, scoped to this file's imports. */
+function migrateRenamedExports(content, filePath) {
+    if (!migrations_inputNumberSurface_data.RENAMED_EXPORTS.some(([from]) => content.includes(from)))
+        return content;
+    const renames = collectRenamedImports(createSourceFile(filePath, content));
+    if (renames.length === 0)
+        return content;
+    // Longest first, so `MIN_VALIDATOR` is never matched as part of a longer identifier by a shorter
+    // pattern; `\b` on both ends keeps `KbqMinValidator` itself from matching `MinValidator`.
+    return [...renames]
+        .sort(([a], [b]) => b.length - a.length)
+        .reduce((result, [from, to]) => result.replace(new RegExp(`(?<![\\w$])${from}(?![\\w$])`, 'g'), to), content);
+}
+/**
+ * Renames the dropped kebab-case `big-step` to `bigStep`, within the same `<input>` tag as the
+ * directive so an unrelated element's attribute of that name is untouched. Both binding forms, and
+ * both attribute orders — the directive may sit before or after the attribute.
+ */
+function migrateBigStepAttribute(template) {
+    if (!template.includes('big-step'))
+        return template;
+    return template.replace(/<input\b[^>]*>/g, (tag) => /\bkbqNumberInput\b/.test(tag) ? tag.replace(/(\[?)big-step(\]?)\s*=/g, '$1bigStep$2=') : tag);
+}
+/** Rewrites `ref.min` to `ref.min()` for template refs bound to the number input, and renames `big-step`. */
+function migrateTemplate(template) {
+    let content = migrateBigStepAttribute(template);
+    const refs = collectTemplateRefs(content);
+    const members = migrations_inputNumberSurface_data.SIGNAL_MEMBERS.join('|');
+    for (const ref of refs) {
+        // `(?!\s*\()` skips anything already invoked, so a second run is a no-op.
+        content = content.replace(new RegExp(`\\b(${ref})\\.(${members})\\b(?!\\s*\\()`, 'g'), '$1.$2()');
+    }
+    return { content, changed: content !== template };
+}
+/**
+ * Rewrites reads of the `KbqNumberInput` members that became `input()` signals — `min`, `max`, `step`,
+ * `bigStep` — on a receiver this file annotates as a `KbqNumberInput`, and on a template reference bound
+ * through the directive's `exportAs`.
+ *
+ * Reports the rest: the members that disappeared with the unimplemented `KbqFormFieldControl` surface,
+ * the validator classes that gained a `Kbq` prefix, the `EventEmitter` → `Subject` change, and the two
+ * behaviors that changed without a call site to point at — the `type="number"` reset and the removed
+ * `valueAsNumber` prototype patch. A removed member that was always `undefined` has no replacement
+ * expression, so none of that half can be written.
+ *
+ * `.html` is visited as well as `.ts`, because `type="number"` is markup.
+ */
+function inputNumberSurface(options) {
+    return async (tree, context) => {
+        const { project } = options;
+        // `migrations.json` registers this without a schema, so the schema default never reaches us;
+        // applying the fix is the intended behavior of `ng update`.
+        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;
+        let consumers = 0;
+        let reported = 0;
+        let touched = 0;
+        const pending = [];
+        utils_packageConfig.visitProjectFiles(rootDir, (filePath, entry) => {
+            if (!EXTENSIONS.some((extension) => filePath.endsWith(extension)))
+                return;
+            const content = entry?.content.toString();
+            if (!content || !referencesInput(content))
+                return;
+            consumers++;
+            for (const { anchor, pattern, message } of migrations_inputNumberSurface_data.warnPatterns) {
+                if (!new RegExp(anchor).test(content) || !new RegExp(pattern).test(content))
+                    continue;
+                reported++;
+                utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${message}`]);
+            }
+            if (new RegExp(migrations_inputNumberSurface_data.FORM_FIELD_CONTROL_MEMBER_PATTERN.anchor).test(content) &&
+                reportsFormFieldControlMember(filePath, content)) {
+                reported++;
+                utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${migrations_inputNumberSurface_data.FORM_FIELD_CONTROL_MEMBER_PATTERN.message}`]);
+            }
+            const isTs = filePath.endsWith(TS_EXT);
+            // A `.ts` file carries both programmatic reads and any inline template; an `.html` file only
+            // the latter. Both passes run on a `.ts` file, so `#ref="kbqNumberInput"` in an inline
+            // template is reached too.
+            const { content: afterReads, written } = isTs
+                ? migrateSignalReads(content, filePath)
+                : { content, written: new Set() };
+            const afterRenames = isTs ? migrateRenamedExports(afterReads, filePath) : afterReads;
+            const { content: updated } = migrateTemplate(afterRenames);
+            if (written.size > 0) {
+                reported++;
+                utils_messages.logMessage(context.logger, [
+                    `${LABEL} ${filePath}`,
+                    `  ${[...written].join(', ')} on KbqNumberInput ${written.size === 1 ? 'is' : 'are'} a ` +
+                        'read-only input() and cannot be assigned. Bind the value in the template instead ' +
+                        '([min]="…"); a programmatic write has no .set() to migrate to.'
+                ]);
+            }
+            if (updated === content)
+                return;
+            touched++;
+            if (fix)
+                pending.push({ filePath, content: updated });
+            else
+                utils_messages.logMessage(context.logger, [`${LABEL} would update ${filePath} (run with --fix to apply)`]);
+        });
+        // Written after the walk: overwriting during `visit` re-enters the visitor on some Tree backends.
+        for (const { filePath, content } of pending) {
+            tree.overwrite(filePath, content);
+        }
+        // Nothing here uses the input, so the summary would only be noise.
+        if (consumers === 0)
+            return;
+        utils_messages.logMessage(context.logger, [
+            `${LABEL} processed kbqInput under "${root || '<workspace root>'}", ` +
+                `${consumers} file(s) reference the package, ${reported} call site(s) reported, ` +
+                `${fix ? 'updated' : 'would update'} ${touched} file(s).`,
+            ...migrations_inputNumberSurface_data.SUMMARY
+        ]);
+    };
+}
+
+exports.default = inputNumberSurface;

package/schematics/migrations/input-number-surface/schema.json

@@ -0,0 +1,20 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "koobiq-components-input-number-surface",
+    "title": "Koobiq components input 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"
+            }
+        },
+        "fix": {
+            "type": "boolean",
+            "default": true,
+            "description": "When true, applies the signal-read replacements. When false, prints what would change without writing."
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+# input-signals
+
+Migration schematic invoked automatically by `ng update @koobiq/components@21` (registered for `21.0.0-0`).
+Reports programmatic writes to the signal inputs of `KbqNumberInput` and `KbqInput`. It never writes to the tree.
+
+## Background
+
+`KbqNumberInput.value`, `KbqNumberInput.disabled` and `KbqInput.type` are signal inputs read through a getter. A read
+is unchanged; a write no longer compiles.
+
+| Write                                               | Manual migration                                       |
+| --------------------------------------------------- | ------------------------------------------------------ |
+| `numberInput.value = …`, `numberInput.disabled = …` | Bind `[value]` / `[disabled]`, or use the form control |
+| `input.type = …`                                    | Bind `[type]`                                          |
+
+## Running it manually
+
+```bash
+ng g @koobiq/components:input-signals --project "<your project>"
+```

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

@@ -0,0 +1,30 @@
+'use strict';
+
+/**
+ * Data for the `input-signals` migration.
+ *
+ * `KbqNumberInput.value` / `.disabled` and `KbqInput.type` are signal inputs read through a getter now. Reads are
+ * unchanged; a programmatic write no longer compiles. Warn-only: the write belongs in a binding or a form control.
+ */
+const warnPatterns = [
+    {
+        anchor: '\\bKbqNumberInput\\b|\\bkbqNumberInput\\b',
+        pattern: '\\.\\s*(?:value|disabled)\\s*=[^=]',
+        message: 'KbqNumberInput.value and .disabled are signal inputs read through a getter now, so a programmatic ' +
+            'write no longer compiles. Bind [value] / [disabled], or write through the form control. This ' +
+            'pattern also matches a write to an unrelated object in the same file — check before changing it.'
+    },
+    {
+        anchor: '\\bKbqInput\\b',
+        pattern: '\\.\\s*type\\s*=[^=]',
+        message: 'KbqInput.type is a signal input read through a getter now, so a programmatic write no longer ' +
+            'compiles. Bind [type] instead. This pattern also matches a write to an unrelated object in the ' +
+            'same file — check before changing it.'
+    }
+];
+const SUMMARY = [
+    'KbqNumberInput.value / .disabled and KbqInput.type are read as before; only programmatic writes are gone.'
+];
+
+exports.SUMMARY = SUMMARY;
+exports.warnPatterns = warnPatterns;

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

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var warnOnlyMigration = require('../../warn-only-migration-BISJBODk.js');
+var migrations_inputSignals_data = require('./data.js');
+require('../../utils/messages.js');
+require('../../package-config-BhU2TfC8.js');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+
+/** Reports programmatic writes to the signal inputs of `KbqNumberInput` and `KbqInput`. Never writes. */
+function inputSignals(options) {
+    return warnOnlyMigration.warnOnlyRule({ label: '[input-signals]', warnPatterns: migrations_inputSignals_data.warnPatterns, summary: migrations_inputSignals_data.SUMMARY }, options);
+}
+
+exports.default = inputSignals;