@koobiq/components 20.4.1 → 21.0.0

package/schematics/migrations/dropdown-demote-overlay/index.js

@@ -0,0 +1,288 @@
+'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_dropdownDemoteOverlay_data = require('./data.js');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+
+const TS_EXT = '.ts';
+const HTML_EXT = '.html';
+const SCSS_EXT = '.scss';
+const CSS_EXT = '.css';
+const LABEL = '[dropdown-demote-overlay]';
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** `demoteOverlay`, `[demoteOverlay]` and `bind-demoteOverlay` all name the same input. */
+function attributeName(name) {
+    return utils_ast.getSimpleAttributeName(name).replace(/^bind-/, '');
+}
+/** Collects the source span of every `demoteOverlay` attribute in a parsed template. */
+class RemovedAttributeCollector {
+    constructor() {
+        this.spans = [];
+    }
+    visitElement(element) {
+        for (const attr of element.attrs ?? []) {
+            if (typeof attr.name !== 'string' || attributeName(attr.name) !== migrations_dropdownDemoteOverlay_data.REMOVED_ATTRIBUTE)
+                continue;
+            this.spans.push({ start: attr.sourceSpan.start.offset, end: attr.sourceSpan.end.offset });
+        }
+        this.visitChildren(element);
+    }
+    visitBlock(block) {
+        this.visitChildren(block);
+    }
+    visitChildren(node) {
+        for (const child of node.children ?? []) {
+            child.visit(this);
+        }
+    }
+    visitAttribute() { }
+    visitText() { }
+    visitComment() { }
+    visitExpansion() { }
+    visitExpansionCase() { }
+    visitBlockParameter() { }
+    visitLetDeclaration() { }
+}
+/**
+ * Deletes the given spans, each together with the whitespace that separated it
+ * from the previous attribute: an inline attribute takes its leading spaces, one
+ * written on its own line takes the line break and the indent as well, so the tag
+ * is not left with a blank line.
+ */
+function removeSpans(content, spans) {
+    let result = content;
+    // Right-to-left, so earlier offsets stay valid.
+    for (const { start, end } of [...spans].sort((a, b) => b.start - a.start)) {
+        let from = start;
+        while (from > 0 && (result[from - 1] === ' ' || result[from - 1] === '\t'))
+            from--;
+        if (result[from - 1] === '\n') {
+            from--;
+            if (result[from - 1] === '\r')
+                from--;
+        }
+        result = result.slice(0, from) + result.slice(end);
+    }
+    return result;
+}
+/**
+ * Removes every `demoteOverlay` attribute from a template. Returns `null` when
+ * the template could not be parsed — editing it blind is how a regex-based
+ * migration corrupts binding expressions, so the caller warns instead.
+ */
+async function migrateTemplate(template) {
+    if (!template.includes(migrations_dropdownDemoteOverlay_data.REMOVED_ATTRIBUTE))
+        return template;
+    const parsed = await utils_typescript.parseTemplate(template);
+    if (!parsed.tree)
+        return null;
+    const collector = new RemovedAttributeCollector();
+    utils_ast.visitAll(collector, parsed.tree.rootNodes);
+    return removeSpans(template, collector.spans);
+}
+/**
+ * Applies the template migration to every inline `@Component({ template })` literal
+ * of a `.ts` source.
+ *
+ * Scoping matters: a wrapper component may legitimately declare its own
+ * `demoteOverlay` member (e.g. `@Input() demoteOverlay = false;`) that forwards
+ * to the trigger. Only the binding in its template is removed; the now-dead
+ * member is left for the compiler to flag.
+ */
+async function migrateInlineTemplates(content, sourceFile, onParseError) {
+    let result = content;
+    // 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));
+        if (migrated === null) {
+            onParseError();
+            continue;
+        }
+        result = result.slice(0, start) + migrated + result.slice(end);
+    }
+    return result;
+}
+const createSourceFile = (fileName, content) => ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+/** A `{ provide: KBQ_DROPDOWN_HOST, … }` object literal used as an element of a provider array. */
+function isProviderEntry(node) {
+    return (ts.isObjectLiteralExpression(node) &&
+        ts.isArrayLiteralExpression(node.parent) &&
+        node.properties.some((prop) => ts.isPropertyAssignment(prop) &&
+            (ts.isIdentifier(prop.name) || ts.isStringLiteralLike(prop.name)) &&
+            prop.name.text === 'provide' &&
+            ts.isIdentifier(prop.initializer) &&
+            prop.initializer.text === migrations_dropdownDemoteOverlay_data.PROVIDER_TOKEN));
+}
+/**
+ * Spans of every `KBQ_DROPDOWN_HOST` provider entry.
+ *
+ * Being an array element is what makes the entry safe to delete: a provider
+ * object bound to a name (`export const HOST_PROVIDER = { provide: KBQ_DROPDOWN_HOST, … };`)
+ * or returned from a function is not an element of anything, and cutting it out
+ * would leave `= ;` behind. Those are reported by the leftover-token warning instead.
+ */
+function collectProviderEntrySpans(sourceFile) {
+    const spans = [];
+    const visit = (node) => {
+        if (isProviderEntry(node)) {
+            spans.push({ start: node.getStart(sourceFile), end: node.getEnd() });
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return spans;
+}
+/** A comma and the whitespace — at most one line break — that separates two array elements. */
+const SEPARATOR_BEFORE = /,[ \t]*\r?\n?[ \t]*$/;
+const SEPARATOR_AFTER = /^,[ \t]*\r?\n?[ \t]*/;
+/**
+ * Deletes the given provider entries, each together with exactly one adjacent
+ * separator — the preceding one when the entry has one — so the array keeps its
+ * shape and nothing outside the entry is reformatted.
+ */
+function removeProviderEntries(content, spans) {
+    let result = content;
+    // Right-to-left, so earlier offsets stay valid.
+    for (const { start, end } of [...spans].sort((a, b) => b.start - a.start)) {
+        const before = SEPARATOR_BEFORE.exec(result.slice(0, start));
+        const after = before ? null : SEPARATOR_AFTER.exec(result.slice(end));
+        result = result.slice(0, before ? before.index : start) + result.slice(end + (after ? after[0].length : 0));
+    }
+    return result;
+}
+/**
+ * Idempotently strips `symbol` from any `import { … } from 'from'` clause.
+ * - Multi-symbol clause: drop just that symbol, keep the others.
+ * - Single-symbol clause: drop the whole import line.
+ */
+function removeImport(content, symbol, from) {
+    // The trailing part deliberately stops after a single newline (`[ \t]*\r?\n?`
+    // rather than `\s*\n?`): dropping the whole import line must not also swallow
+    // the blank line that separates the import block from the code below it.
+    const moduleRe = new RegExp(`(import\\s*(?:type\\s*)?\\{)([^}]*)(\\}\\s*from\\s*['"]${escapeRegExp(from)}['"];?[ \\t]*\\r?\\n?)`, 'g');
+    return content.replace(moduleRe, (full, open, body, close) => {
+        const items = body
+            .split(',')
+            .map((item) => item.trim())
+            .filter(Boolean);
+        // An already-empty clause is somebody else's import — leave it alone.
+        if (items.length === 0)
+            return full;
+        // Handle `<name> as <alias>` — match on the source name, not the alias.
+        const kept = items.filter((spec) => spec.split(/\s+as\s+/)[0].trim() !== symbol);
+        if (kept.length === items.length)
+            return full;
+        if (kept.length === 0)
+            return '';
+        return `${open} ${kept.join(', ')} ${close}`;
+    });
+}
+/**
+ * Drops a `providers` property the removal left empty. Angular treats
+ * `providers: []` as a no-op, so this is purely cosmetic — but leaving it
+ * behind in a decorator whose only provider was `KBQ_DROPDOWN_HOST` looks like
+ * an unfinished migration.
+ */
+function dropEmptyProvidersProperty(content) {
+    return content.replace(/[ \t]*providers:\s*\[\s*\],?[ \t]*\r?\n/g, '').replace(/,?[ \t]*providers:\s*\[\s*\]/g, '');
+}
+function logWarnings(context, filePath, content, patterns) {
+    for (const { pattern, message } of patterns) {
+        if (new RegExp(pattern).test(content)) {
+            utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${message}`]);
+        }
+    }
+}
+function pickWarnPatterns(filePath) {
+    if (filePath.endsWith(TS_EXT))
+        return [...migrations_dropdownDemoteOverlay_data.tsWarnPatterns, ...migrations_dropdownDemoteOverlay_data.templateWarnPatterns];
+    if (filePath.endsWith(HTML_EXT))
+        return migrations_dropdownDemoteOverlay_data.templateWarnPatterns;
+    return migrations_dropdownDemoteOverlay_data.styleWarnPatterns;
+}
+function isMigratableFile(filePath) {
+    return (filePath.endsWith(TS_EXT) ||
+        filePath.endsWith(HTML_EXT) ||
+        filePath.endsWith(SCSS_EXT) ||
+        filePath.endsWith(CSS_EXT));
+}
+function dropdownDemoteOverlay(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 filePaths = [];
+        utils_packageConfig.visitProjectFiles(rootDir, (filePath) => {
+            if (!isMigratableFile(filePath))
+                return;
+            filePaths.push(filePath);
+        });
+        let touched = 0;
+        for (const filePath of filePaths) {
+            const originalContent = tree.read(filePath)?.toString();
+            if (!originalContent)
+                continue;
+            let content = originalContent;
+            let unparseable = false;
+            const reportParseError = () => (unparseable = true);
+            // Parsing every `.ts` of the project is not free, and nothing can change in
+            // a file that mentions neither the token nor the input.
+            const mentionsRemovedApi = content.includes(migrations_dropdownDemoteOverlay_data.PROVIDER_TOKEN) || content.includes(migrations_dropdownDemoteOverlay_data.REMOVED_ATTRIBUTE);
+            if (filePath.endsWith(TS_EXT) && mentionsRemovedApi) {
+                let sourceFile = createSourceFile(filePath, content);
+                const withoutProvider = removeProviderEntries(content, collectProviderEntrySpans(sourceFile));
+                if (withoutProvider !== content) {
+                    content = dropEmptyProvidersProperty(removeImport(withoutProvider, migrations_dropdownDemoteOverlay_data.PROVIDER_IMPORT.symbol, migrations_dropdownDemoteOverlay_data.PROVIDER_IMPORT.from));
+                    // Those edits moved every offset that followed them.
+                    sourceFile = createSourceFile(filePath, content);
+                }
+                content = await migrateInlineTemplates(content, sourceFile, reportParseError);
+            }
+            else if (filePath.endsWith(HTML_EXT)) {
+                const migrated = await migrateTemplate(content);
+                if (migrated === null)
+                    reportParseError();
+                else
+                    content = migrated;
+            }
+            // Warn on what is left over, so an auto-fixed usage does not also
+            // produce a "manual migration required" note. In dry-run mode the
+            // fix is not written, so report against the original content.
+            logWarnings(context, filePath, fix ? content : originalContent, pickWarnPatterns(filePath));
+            if (unparseable) {
+                utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${migrations_dropdownDemoteOverlay_data.UNPARSEABLE_TEMPLATE_MESSAGE}`]);
+            }
+            if (content === originalContent)
+                continue;
+            touched++;
+            if (fix) {
+                tree.overwrite(filePath, content);
+            }
+            else {
+                utils_messages.logMessage(context.logger, [`${LABEL} would update ${filePath} (run with --fix to apply)`]);
+            }
+        }
+        utils_messages.logMessage(context.logger, [
+            `${LABEL} processed tree under "${root || '<workspace root>'}", ` +
+                `${fix ? 'updated' : 'would update'} ${touched} file(s).`,
+            '',
+            ...migrations_dropdownDemoteOverlay_data.BEHAVIOUR_NOTE
+        ]);
+    };
+}
+
+exports.default = dropdownDemoteOverlay;

package/schematics/migrations/dropdown-demote-overlay/schema.json

@@ -0,0 +1,20 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "koobiq-components-dropdown-demote-overlay",
+    "title": "Koobiq components overlay demotion removal",
+    "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/dropdown-signals/README.md

@@ -0,0 +1,83 @@
+# dropdown-signals
+
+Migration schematic invoked automatically by `ng update @koobiq/components@21` (registered for
+`21.0.0-0`). Migrates `KbqDropdown`, `KbqDropdownTrigger` and `KbqDropdownItem` consumers to the
+signal-based API the component review landed.
+
+## Background
+
+The dropdown was the only component in the v21 review campaign whose decorators were left in place —
+its siblings (`badge`, `autocomplete`, `markdown`, `progress-spinner`) each shipped a `*-signals`
+migration, and the dropdown shipped none. Two notes in the source deferred the work explicitly:
+
+```ts
+// The inputs below stay decorators on purpose: in-repo consumers assign to them imperatively […]
+// Migrating them is a breaking change owned by the next major.
+```
+
+v21 is that next major. Twenty of the twenty-one members are signals now; the one that stayed is at the
+bottom of this page.
+
+## What it rewrites
+
+A read becomes a call, scoped to the type that declares the member:
+
+| Type                 | Members                                                                                                                               |
+| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
+| `KbqDropdown`        | `xPosition`, `yPosition`, `overlapTriggerX`, `overlapTriggerY`, `hasBackdrop`, `backdropClass`, `templateRef`, `items`, `lazyContent` |
+| `KbqDropdownTrigger` | `offsetX`, `offsetY`, `data`, `openByArrowDown`, `restoreFocus`, `dropdown`                                                           |
+| `KbqDropdownItem`    | `disabled`, `icon`                                                                                                                    |
+
+Seven of them are `model()`s, so a write has a mechanical translation:
+
+| Before                            | After                                |
+| --------------------------------- | ------------------------------------ |
+| `panel.xPosition = 'before'`      | `panel.xPosition.set('before')`      |
+| `panel.overlapTriggerX = false`   | `panel.overlapTriggerX.set(false)`   |
+| `trigger.offsetX = -8`            | `trigger.offsetX.set(-8)`            |
+| `trigger.openByArrowDown = false` | `trigger.openByArrowDown.set(false)` |
+
+They are `model()`s rather than `input()`s because in-repo hosts position the panel they were handed:
+`kbq-split-button` writes `xPosition`, and `kbq-navbar-item` writes both overlap flags, `offsetX` and
+`openByArrowDown`. A write to a read-only input (`hasBackdrop`, `restoreFocus`, `data`, …) is left
+untouched and becomes a compile error the consumer fixes by hand.
+
+Receivers are found by explicit type annotation and by the `inject()` / `viewChild()` /
+`contentChild()` initializer forms, and through template reference variables — a bare `#ref` on
+`<kbq-dropdown>` or `<kbq-dropdown-item>`, and `#ref="kbqDropdownTrigger"` on a trigger host. Reads
+already migrated are left alone, so the schematic is idempotent.
+
+**Input aliases did not change.** `[xPosition]`, `[panelWidth]`, `class`, `[kbqDropdownTriggerFor]`
+and the rest bind exactly as before; only programmatic access moved.
+
+## What it reports rather than fixes
+
+- **`items` is a `Signal<readonly KbqDropdownItem[]>`, not a `QueryList`.** `items().length` and the
+  array methods on `items()` work; `changes`, `first`, `last` and `toArray()` do not. Use
+  `toObservable(panel.items)` for the stream, and the new `adoptItems()` in place of `items.reset(…)`.
+- **`closed` is an `output()`.** It has `emit()` and `subscribe(fn)`, but no `pipe()`,
+  `asObservable()` or `complete()`. Wrap it in `outputToObservable(panel.closed)`.
+- **`classList` is `protected`.** It is one `computed` over the position classes, the safe-area class
+  and the `class` input. Set `class` on `<kbq-dropdown>` to add your own.
+- **`KbqDropdownPanel` changed shape throughout.** A custom panel has to be updated by hand.
+- **Signal queries hold the instance behind a call of their own**, so a read through
+  `viewChild(KbqDropdown)` is `this.panel().items()`. Those are resolved where the query is assigned
+  to a field; other shapes are reported.
+
+## Changes with no call site to match on
+
+- `model()` takes no `transform`, so the seven writable members no longer coerce a string attribute:
+  use `[overlapTriggerX]="true"`, not `overlapTriggerX="true"`.
+- `KbqDropdownItem.disabled` is a signal, and `ListKeyManagerOption.disabled` accepts one. A custom
+  option that reads `item.disabled` as a plain property is broken by this — a signal is a function,
+  so every item reads as disabled, and both the arrow skip and the typeahead match silently stop
+  working. Check `typeof item.disabled === 'function'` before reading it.
+- `KbqDropdownItem.textElement` is still read as a property: a getter typed `ElementRef`. It implements `KbqTitleTextRef`, which `KbqTitle` and
+  five other components read as a plain property.
+
+## Options
+
+| Option    | Default | Description                                                          |
+| --------- | ------- | -------------------------------------------------------------------- |
+| `project` | —       | Project to migrate. Omitted, the migration runs over the whole tree. |
+| `fix`     | `true`  | When false, prints what would change without writing.                |

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

@@ -0,0 +1,152 @@
+'use strict';
+
+/**
+ * Data for the `dropdown-signals` migration.
+ *
+ * The dropdown was the only component in the v21 review campaign whose decorators were left in place.
+ * Twenty of its twenty-one `@Input`/`@Output`/query members moved to the signal API. Seventeen of those
+ * are read through — the members listed below — so every programmatic read of one is a call.
+ *
+ * Seven are `model()`s rather than `input()`s, because another component writes them on the instance it
+ * was handed: `kbq-split-button` writes `xPosition`, `kbq-navbar-item` writes both overlap flags, `offsetX`
+ * and `openByArrowDown`, and `KbqOptionActionComponent` writes `restoreFocus`. A write to one of those has a mechanical translation to `.set(...)`; a write to a
+ * read-only input does not, and is left to become a compile error.
+ *
+ * `KbqDropdownItem.textElement` is deliberately absent: it implements `KbqTitleTextRef`, a contract five
+ * other components implement as a plain property, so it is a getter typed `ElementRef`.
+ *
+ * `KbqDropdownTrigger.dropdownClosed` is an `output()` now. Its reads are not rewritten — it is an event,
+ * not a value — but an operator chain over it is reported, the same as over the panel's `closed`.
+ */
+const DROPDOWN_ANCHOR = '\\bKbqDropdown\\w*\\b';
+/** Which members each type owns. A receiver resolves to one type, so the rewrite is scoped by it. */
+const MEMBERS_BY_TYPE = {
+    KbqDropdown: [
+        'xPosition',
+        'yPosition',
+        'overlapTriggerX',
+        'overlapTriggerY',
+        'hasBackdrop',
+        'backdropClass',
+        'templateRef',
+        'items',
+        'lazyContent'
+    ],
+    KbqDropdownTrigger: ['offsetX', 'offsetY', 'data', 'openByArrowDown', 'restoreFocus', 'dropdown'],
+    KbqDropdownItem: ['disabled', 'icon']
+};
+/**
+ * `exportAs` names a template reference can be bound to. The trigger is a directive on an arbitrary
+ * element, so `#t="kbqDropdownTrigger"` is the only way a template names it.
+ */
+const EXPORT_AS_TO_TYPE = {
+    kbqDropdown: 'KbqDropdown',
+    kbqDropdownTrigger: 'KbqDropdownTrigger',
+    kbqDropdownItem: 'KbqDropdownItem'
+};
+/** Element selectors whose bare `#ref` points at one of the migrated types. */
+const ELEMENT_TO_TYPE = {
+    'kbq-dropdown': 'KbqDropdown',
+    'kbq-dropdown-item': 'KbqDropdownItem'
+};
+/** The `model()` members, whose `x = v` becomes `x.set(v)`. */
+const WRITABLE_MEMBERS = new Set([
+    'xPosition',
+    'yPosition',
+    'overlapTriggerX',
+    'overlapTriggerY',
+    'offsetX',
+    'openByArrowDown',
+    'restoreFocus'
+]);
+/** Members that moved from `public` to `protected` and can no longer be read from outside. */
+const PROTECTED_MEMBERS = ['classList'];
+const PROTECTED_HINT = 'It is derived state now — the position classes, the safe-area class and the `class` input are ' +
+    'folded into one `computed`. Set `class` on `<kbq-dropdown>` to add your own.';
+const warnPatterns = [
+    {
+        anchor: DROPDOWN_ANCHOR,
+        pattern: '\\bitems\\s*\\.\\s*(?:reset|notifyOnChanges|toArray|forEach|filter|map|find|some)\\s*\\(|\\bitems\\s*\\.\\s*(?:changes|first|last)\\b',
+        message: '`KbqDropdown.items` is a `Signal<readonly KbqDropdownItem[]>` now, not a `QueryList`. ' +
+            '`items().length` and the array methods on `items()` still work; `changes`, `first`, `last` and ' +
+            '`toArray()` do not. Use `toObservable(panel.items)` for the stream, and `adoptItems()` instead ' +
+            'of `items.reset(...)`.'
+    },
+    {
+        anchor: DROPDOWN_ANCHOR,
+        pattern: '\\b(?:closed|dropdownClosed)\\s*\\.\\s*(?:pipe|asObservable|complete|subscribe\\s*\\([^)]*,)',
+        message: '`KbqDropdown.closed` and `KbqDropdownTrigger.dropdownClosed` are `output()`s now. Each has ' +
+            '`emit()` and `subscribe(fn)`, but no ' +
+            '`pipe()`, `asObservable()` or `complete()`, and `subscribe` takes a single callback. Wrap it ' +
+            'in `outputToObservable(panel.closed)` from `@angular/core/rxjs-interop` to keep an operator chain.'
+    },
+    {
+        anchor: DROPDOWN_ANCHOR,
+        pattern: 'implements\\s+[^{]*\\bKbqDropdownPanel\\b',
+        message: 'Every member of `KbqDropdownPanel` changed shape: `xPosition`, `yPosition` and both overlap ' +
+            'flags are `WritableSignal`s, `templateRef`, `hasBackdrop`, `backdropClass` and `lazyContent` are ' +
+            '`Signal`s, `items` is a `Signal<readonly KbqDropdownItem[]>`, and `closed` is an ' +
+            '`OutputEmitterRef`. A custom panel has to be updated by hand; the optional `adoptItems` replaces ' +
+            'the `items.reset(...)` the trigger used to perform on it.'
+    },
+    {
+        anchor: DROPDOWN_ANCHOR,
+        pattern: '\\b(?:viewChild|contentChild)(?:\\s*\\.\\s*required)?\\s*(?:<[^<>()]*>)?\\s*\\(\\s*KbqDropdown(?:Trigger|Item)?\\b',
+        message: 'A `viewChild(KbqDropdown)` / `contentChild(KbqDropdownItem)` query is itself a signal, so ' +
+            'reading a member through it is a double call: `this.panel().items()`. Those reads are resolved ' +
+            'and rewritten where the query is assigned to a field; check any other shape by hand.'
+    },
+    {
+        anchor: DROPDOWN_ANCHOR,
+        pattern: '\\bpanelClass\\s*=[^=]',
+        message: "`KbqDropdown.panelClass` was a write-only `@Input('class')` and is a read-only `input()` " +
+            'aliased to `class` now. Set it in the template — `<kbq-dropdown class="...">` or ' +
+            '`[class]="..."` — rather than assigning to the property.'
+    }
+];
+const UNPARSEABLE_TEMPLATE_MESSAGE = 'This template renders a dropdown but could not be parsed, so it was left untouched. Migrate reads ' +
+    'through its template reference variables by hand.';
+const UNRESOLVED_RECEIVER_MESSAGE = 'A dropdown type is used here in a way this migration cannot resolve to a single receiver, so any ' +
+    'signal read through it was left untouched. Check these lines by hand:';
+const SUMMARY = [
+    '  Seventeen members across `KbqDropdown`, `KbqDropdownTrigger` and `KbqDropdownItem` are signals now, so ' +
+        'a read is a call. A read left un-called is silent in a template: `{{ panel.xPosition }}` prints the ' +
+        'function source, and `@if (item.disabled)` is always true.',
+    '  `xPosition`, `yPosition`, `overlapTriggerX`, `overlapTriggerY`, `offsetX`, `openByArrowDown` and ' +
+        '`restoreFocus` are ' +
+        '`model()`s, so a write becomes `.set(...)`. `model()` takes no `transform`, so they no longer coerce ' +
+        'a string attribute: use `[overlapTriggerX]="true"`, not `overlapTriggerX="true"`.',
+    '  `KbqDropdownItem.disabled` is a signal, and `ListKeyManagerOption.disabled` accepts one. A custom ' +
+        'option that passes a signal to a key manager works; one that reads `item.disabled` as a plain ' +
+        'property does not — a signal is a function, so every item reads as disabled.',
+    '  `KbqDropdownItem.textElement` is unchanged. It implements `KbqTitleTextRef`, which `KbqTitle` and five ' +
+        'other components read as a plain property.'
+];
+const config = {
+    label: '[dropdown-signals]',
+    package: '@koobiq/components/dropdown',
+    membersByType: MEMBERS_BY_TYPE,
+    exportAsToType: EXPORT_AS_TO_TYPE,
+    elementToType: ELEMENT_TO_TYPE,
+    writableMembers: WRITABLE_MEMBERS,
+    protectedMembers: PROTECTED_MEMBERS,
+    warnPatterns,
+    messages: {
+        unparseableTemplate: UNPARSEABLE_TEMPLATE_MESSAGE,
+        unresolvedReceiver: UNRESOLVED_RECEIVER_MESSAGE,
+        protectedHint: PROTECTED_HINT,
+        summary: SUMMARY
+    }
+};
+
+exports.ELEMENT_TO_TYPE = ELEMENT_TO_TYPE;
+exports.EXPORT_AS_TO_TYPE = EXPORT_AS_TO_TYPE;
+exports.MEMBERS_BY_TYPE = MEMBERS_BY_TYPE;
+exports.PROTECTED_HINT = PROTECTED_HINT;
+exports.PROTECTED_MEMBERS = PROTECTED_MEMBERS;
+exports.SUMMARY = SUMMARY;
+exports.UNPARSEABLE_TEMPLATE_MESSAGE = UNPARSEABLE_TEMPLATE_MESSAGE;
+exports.UNRESOLVED_RECEIVER_MESSAGE = UNRESOLVED_RECEIVER_MESSAGE;
+exports.WRITABLE_MEMBERS = WRITABLE_MEMBERS;
+exports.config = config;
+exports.warnPatterns = warnPatterns;

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

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var signalMembersMigration = require('../../signal-members-migration-BoAJKutT.js');
+var migrations_dropdownSignals_data = require('./data.js');
+require('typescript');
+require('../../utils/ast.js');
+require('../../utils/messages.js');
+require('../../package-config-BhU2TfC8.js');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+require('../../utils/typescript.js');
+
+function dropdownSignals(options) {
+    return signalMembersMigration.signalMembersRule(migrations_dropdownSignals_data.config, options);
+}
+
+exports.default = dropdownSignals;

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

@@ -0,0 +1,20 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "koobiq-components-dropdown-signals",
+    "title": "Koobiq components dropdown 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."
+        }
+    }
+}