@koobiq/components 20.0.0 → 20.2.0

package/schematics/migrations/autocomplete-panel-width-auto/index.js

@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var node_path = require('node:path');
+var process = require('node:process');
+var ts = require('typescript');
+var utils_angularParsing = require('../../utils/angular-parsing.js');
+var utils_packageConfig = require('../../utils/package-config.js');
+var utils_typescript = require('../../utils/typescript.js');
+require('path');
+require('../../utils/ast.js');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+require('../../utils/messages.js');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var process__namespace = /*#__PURE__*/_interopNamespaceDefault(process);
+
+const migrationData = {
+    elementName: 'kbq-autocomplete',
+    attrs: {
+        key: {
+            from: 'panelWidth',
+            to: 'panelWidth'
+        },
+        value: {
+            replacements: [{ from: 'auto', to: 'fit-content' }]
+        }
+    }
+};
+function migrate(options) {
+    return async (tree, context) => {
+        const { project } = options;
+        const { tsPaths, templatePaths, projectDefinition } = await utils_packageConfig.getParsingInfo(project, tree);
+        const program = ts.createProgram(Array.from(tsPaths, (item) => node_path.resolve(projectDefinition.root, `.${item}`)), {
+            baseUrl: projectDefinition.root,
+            rootDir: projectDefinition.root,
+            _enableTemplateTypeChecker: true, // Required for the template type checker to work.
+            compileNonExportedClasses: true, // We want to migrate non-exported classes too.
+            // Avoid checking libraries to speed up the migration.
+            skipLibCheck: true,
+            skipDefaultLibCheck: true
+        });
+        // Update external html
+        await utils_angularParsing.migrateTemplate(tree, Array.from(templatePaths), context, migrationData);
+        // Update inline html
+        await utils_angularParsing.migrateTs(tree, program.getSourceFiles().filter((sourceFile) => utils_typescript.canMigrateFile(sourceFile, program)), process__namespace.cwd(), context, migrationData);
+        context.logger.warn('Warning! Run linter in updated files since line breaks or indents may be broken.');
+    };
+}
+
+exports.default = migrate;
+exports.migrationData = migrationData;

package/schematics/migrations/autocomplete-panel-width-auto/schema.json

@@ -0,0 +1,15 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "koobiq-components-autocomplete-panel-width-auto",
+    "title": "koobiq-components autocomplete-panel-width-auto schematic",
+    "type": "object",
+    "properties": {
+        "project": {
+            "type": "string",
+            "description": "Name of the project",
+            "$default": {
+                "$source": "projectName"
+            }
+        }
+    }
+}

package/schematics/migrations/filter-bar-signals/README.md

@@ -0,0 +1,66 @@
+# filter-bar-signals
+
+Migration schematic invoked automatically by `ng update @koobiq/components@20`.
+Migrates consumers of `KbqFilterBar` to its signal-based public API.
+
+## Why
+
+`KbqFilterBar` moved several members from accessors/getters to signals. Reading
+them programmatically now requires a call, and assigning `filter` now goes
+through `.set(...)`. Template _bindings_ (`[filter]`, `[(filter)]`,
+`[pipeTemplates]`) keep working — only reads break.
+
+| Member                                                                      | Before   | After             |
+| --------------------------------------------------------------------------- | -------- | ----------------- |
+| `filter`                                                                    | accessor | `ModelSignal`     |
+| `pipeTemplates`                                                             | accessor | `InputSignal`     |
+| `isChanged` / `isDisabled` / `isReadOnly` / `isSaved` / `isSavedAndChanged` | getter   | `Signal<boolean>` |
+
+## What it does
+
+The schematic walks every `.ts` and `.html` file in the project (skipping
+`node_modules` and `dist`) and, for files that reference the filter bar:
+
+- **TypeScript reads/writes.** For a receiver whose static type is annotated
+  `KbqFilterBar` / `KbqFilterBarHost` (method/function params, class fields —
+  including `@ViewChild(KbqFilterBar) x: KbqFilterBar` and constructor
+  parameter-properties — and typed locals), a read of a signal member becomes a
+  call and a `filter` write becomes `.set(...)`:
+    - `filterBar.filter` → `filterBar.filter()` (incl. optional chain `filterBar.filter?.name` → `filterBar.filter()?.name`)
+    - `filterBar.filter = next` → `filterBar.filter.set(next)`
+    - `this.filterBar.isChanged` → `this.filterBar.isChanged()`
+- **Template reference reads.** For a `#ref` bound to `<kbq-filter-bar>`, reads
+  of signal members through that ref are rewritten in the same template
+  (external `.html` and inline `template:` strings): `ref.isChanged` →
+  `ref.isChanged()`.
+- **Rename.** `KbqFilterBarRefresher` → `KbqFilterRefresher` (the old name is
+  still re-exported as an alias, so this is optional cleanup).
+
+All rewrites are idempotent — running twice does not double the call.
+
+## What it does _not_ do (warn-only)
+
+Some changes require code restructuring and are surfaced as warnings without
+auto-fixing:
+
+| Pattern                          | Manual migration                                                                                   |
+| -------------------------------- | -------------------------------------------------------------------------------------------------- |
+| `.changes` (KbqFilterBar)        | Deprecated no-op; read `filterBar.filter()` inside an `effect(...)`, or listen to `(filterChange)` |
+| `.preparePopover()` (KbqFilters) | Removed; use `openSaveAsNewFilterPopover()` / `openChangeFilterNamePopover()`                      |
+| `viewChild(KbqFilterBar)` query  | Returns the instance, so reads are a double call: `this.filterBar().filter()` — verify manually    |
+| `KBQ_FILTER_BAR_PIPES`           | Now typed `Map<KbqPipeType, Type<KbqBasePipe>>`; wrap direct providers in `new Map([...])`         |
+
+## Running it manually
+
+```
+ng generate @koobiq/components:filter-bar-signals --project my-app
+```
+
+Pass `--fix=false` to see what would change without writing files.
+
+## Limitations
+
+Receivers are matched by explicit `KbqFilterBar` type annotation only (no
+cross-package type inference), so aliased/inferred receivers
+(`const fb = this.filterBar; fb.filter`) are left untouched and covered by the
+warnings above. After running, **always inspect the diff** before committing.

package/schematics/migrations/filter-bar-signals/data.js

@@ -0,0 +1,72 @@
+'use strict';
+
+/**
+ * Data for the `filter-bar-signals` migration.
+ *
+ * `KbqFilterBar` moved several members from accessors/getters to signals. Reading them programmatically
+ * (in `.ts` code or via a template reference variable) now requires a call:
+ *
+ * - `filterBar.filter`            → `filterBar.filter()`            (write `= v` → `.set(v)`)
+ * - `filterBar.pipeTemplates`     → `filterBar.pipeTemplates()`
+ * - `filterBar.isChanged`         → `filterBar.isChanged()`        (also isDisabled/isReadOnly/isSaved/isSavedAndChanged)
+ *
+ * Template *bindings* (`[filter]`, `[(filter)]`, `[pipeTemplates]`) keep working — only reads break.
+ */
+/** Members of `KbqFilterBar` that became signals; a read of any of them must become a call. */
+const SIGNAL_MEMBERS = [
+    'filter',
+    'pipeTemplates',
+    'isChanged',
+    'isDisabled',
+    'isReadOnly',
+    'isSaved',
+    'isSavedAndChanged'
+];
+/** Signal members that are writable (`model()`); `x.filter = v` migrates to `x.filter.set(v)`. */
+const WRITABLE_MEMBERS = new Set(['filter']);
+/** TypeScript type annotations that mark a receiver as a filter bar. */
+const FILTER_BAR_TYPE = 'KbqFilterBar';
+const FILTER_BAR_HOST_TYPE = 'KbqFilterBarHost';
+/** Element selector whose template reference variables (`#ref`) point at a filter bar. */
+const FILTER_BAR_ELEMENT = 'kbq-filter-bar';
+/**
+ * Safe, idempotent identifier renames applied to `.ts` files. The `\b…\b` boundaries make each rule
+ * idempotent. `KbqFilterBarRefresher` is still re-exported as an alias of `KbqFilterRefresher`, so this
+ * is optional cleanup that can never break a consumer build.
+ */
+const tsRenameReplacements = [{ from: '\\bKbqFilterBarRefresher\\b', to: 'KbqFilterRefresher' }];
+/**
+ * Patterns that can't be auto-fixed reliably — surfaced with file locations (in both `fix` and dry-run
+ * mode). Only evaluated for files that reference the filter bar, so the broad `.changes` pattern stays scoped.
+ */
+const warnPatterns = [
+    {
+        pattern: '\\.changes\\b',
+        message: 'KbqFilterBar.changes is deprecated and no longer emits. Reactivity is driven by the `filter` ' +
+            'signal now — read it with `filterBar.filter()` inside an `effect(...)`, or listen to the ' +
+            '`(filterChange)` output. (Best-effort match — ignore if this `.changes` is unrelated.)'
+    },
+    {
+        pattern: '\\.preparePopover\\(',
+        message: 'KbqFilters.preparePopover() was removed. Use openSaveAsNewFilterPopover() / ' +
+            'openChangeFilterNamePopover() instead.'
+    },
+    {
+        pattern: '(?:viewChild|ViewChild)[^\\n;]*\\bKbqFilterBar\\b',
+        message: 'A KbqFilterBar view/signal query returns the component instance, whose filter is now a signal — ' +
+            'reading it is a double call, e.g. `this.filterBar().filter()`. Verify query reads manually.'
+    },
+    {
+        pattern: '\\bKBQ_FILTER_BAR_PIPES\\b',
+        message: 'KBQ_FILTER_BAR_PIPES is now typed as Map<KbqPipeType, Type<KbqBasePipe>> (was an array of tuples). ' +
+            'If you provide it directly, wrap the entries in `new Map([...])`.'
+    }
+];
+
+exports.FILTER_BAR_ELEMENT = FILTER_BAR_ELEMENT;
+exports.FILTER_BAR_HOST_TYPE = FILTER_BAR_HOST_TYPE;
+exports.FILTER_BAR_TYPE = FILTER_BAR_TYPE;
+exports.SIGNAL_MEMBERS = SIGNAL_MEMBERS;
+exports.WRITABLE_MEMBERS = WRITABLE_MEMBERS;
+exports.tsRenameReplacements = tsRenameReplacements;
+exports.warnPatterns = warnPatterns;

package/schematics/migrations/filter-bar-signals/index.js

@@ -0,0 +1,316 @@
+'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('../../utils/package-config.js');
+var utils_typescript = require('../../utils/typescript.js');
+var migrations_filterBarSignals_data = require('./data.js');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+
+const TS_EXT = '.ts';
+const HTML_EXT = '.html';
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Applies text-span edits to `content`, right-to-left, so earlier edits don't shift later offsets. */
+function applyEdits(content, edits) {
+    const sorted = [...edits].sort((a, b) => b.start - a.start || b.end - a.end);
+    let result = content;
+    for (const { start, end, text } of sorted) {
+        result = result.slice(0, start) + text + result.slice(end);
+    }
+    return result;
+}
+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 the filter bar (`KbqFilterBar` / `KbqFilterBarHost`). */
+function isFilterBarType(type) {
+    return (!!type &&
+        ts.isTypeReferenceNode(type) &&
+        ts.isIdentifier(type.typeName) &&
+        (type.typeName.text === migrations_filterBarSignals_data.FILTER_BAR_TYPE || type.typeName.text === migrations_filterBarSignals_data.FILTER_BAR_HOST_TYPE));
+}
+const FIELD_MODIFIERS = new Set([
+    ts.SyntaxKind.PrivateKeyword,
+    ts.SyntaxKind.PublicKeyword,
+    ts.SyntaxKind.ProtectedKeyword,
+    ts.SyntaxKind.ReadonlyKeyword
+]);
+/**
+ * Collects the receivers whose static type is a filter bar, by explicit annotation only (no cross-package
+ * type resolution): method/function params, class fields (incl. `@ViewChild(KbqFilterBar) x: KbqFilterBar`
+ * and constructor parameter-properties) and typed locals.
+ */
+function collectReceivers(sourceFile) {
+    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) && isFilterBarType(node.type)) {
+            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) && isFilterBarType(node.type)) {
+            const owner = findAncestor(node, ts.isClassDeclaration);
+            if (owner)
+                add(`this.${node.name.text}`, owner);
+        }
+        else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && isFilterBarType(node.type)) {
+            add(node.name.text, findAncestor(node, isFunctionLike) ?? sourceFile);
+        }
+        node.forEachChild(visit);
+    };
+    visit(sourceFile);
+    return receivers;
+}
+/** Classifies a matched property access and appends the resulting edit(s). */
+function classifyAccess(node, sourceFile, edits) {
+    const parent = node.parent;
+    // Already migrated: `x.filter()` (call) or `x.filter.set(...)` — leave alone (idempotent).
+    if (ts.isCallExpression(parent) && parent.expression === node)
+        return;
+    if (ts.isPropertyAccessExpression(parent) && parent.expression === node && parent.name.text === 'set')
+        return;
+    // Write target: `x.filter = RHS` → `x.filter.set(RHS)` (writable members only).
+    if (ts.isBinaryExpression(parent) &&
+        parent.left === node &&
+        parent.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+        if (migrations_filterBarSignals_data.WRITABLE_MEMBERS.has(node.name.text)) {
+            const rhs = parent.right;
+            // Replace ` = ` with `.set(` and close after the right-hand side; keeping the RHS span intact
+            // lets any nested read edits inside it still apply.
+            edits.push({ start: node.getEnd(), end: rhs.getStart(sourceFile), text: '.set(' });
+            edits.push({ start: rhs.getEnd(), end: rhs.getEnd(), text: ')' });
+        }
+        return;
+    }
+    // Read (incl. optional chain `x?.filter`): append `()`.
+    edits.push({ start: node.getEnd(), end: node.getEnd(), text: '()' });
+}
+/** Collects edits for every read/write of a signal member on a known filter-bar receiver. */
+function collectAccessEdits(sourceFile, receivers) {
+    const edits = [];
+    const visit = (node) => {
+        if (ts.isPropertyAccessExpression(node) &&
+            ts.isIdentifier(node.name) &&
+            migrations_filterBarSignals_data.SIGNAL_MEMBERS.includes(node.name.text)) {
+            const receiverText = node.expression.getText(sourceFile);
+            const start = node.getStart(sourceFile);
+            const end = node.getEnd();
+            const inScope = receivers.some((r) => r.text === receiverText && start >= r.start && end <= r.end);
+            if (inScope)
+                classifyAccess(node, sourceFile, edits);
+        }
+        node.forEachChild(visit);
+    };
+    visit(sourceFile);
+    return edits;
+}
+/** Pass A — rewrite programmatic reads/writes of filter-bar 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);
+    if (receivers.length === 0)
+        return content;
+    const edits = collectAccessEdits(sourceFile, receivers);
+    return edits.length > 0 ? applyEdits(content, edits) : content;
+}
+/** Collects template reference variable names bound to a `<kbq-filter-bar>` element. */
+class FilterBarRefCollector {
+    constructor() {
+        this.refs = new Set();
+    }
+    visitElement(element) {
+        if (element.name === migrations_filterBarSignals_data.FILTER_BAR_ELEMENT) {
+            for (const attr of element.attrs ?? []) {
+                if (typeof attr.name !== 'string')
+                    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) {
+        for (const child of node.children ?? []) {
+            child.visit(this);
+        }
+    }
+    visitAttribute() { }
+    visitText() { }
+    visitComment() { }
+    visitExpansion() { }
+    visitExpansionCase() { }
+    visitBlockParameter() { }
+    visitLetDeclaration() { }
+}
+/** Rewrites `ref.member` reads to `ref.member()` for the given refs, scoped to those exact identifiers. */
+function rewriteRefReads(template, refs) {
+    const members = migrations_filterBarSignals_data.SIGNAL_MEMBERS.join('|');
+    let content = template;
+    let changed = false;
+    for (const ref of refs) {
+        // `\bref\.(member)\b(?!\s*\()` — skip anything already invoked, so the rewrite is idempotent.
+        const pattern = new RegExp(`\\b(${escapeRegExp(ref)})\\.(${members})\\b(?!\\s*\\()`, 'g');
+        const next = content.replace(pattern, '$1.$2()');
+        if (next !== content) {
+            content = next;
+            changed = true;
+        }
+    }
+    return { content, changed };
+}
+/** Pass B (core) — parse a template, discover filter-bar refs, rewrite their signal reads. */
+async function migrateTemplate(template) {
+    if (!template.includes(migrations_filterBarSignals_data.FILTER_BAR_ELEMENT))
+        return { content: template, changed: false };
+    const parsed = await utils_typescript.parseTemplate(template);
+    if (!parsed.tree)
+        return { content: template, changed: false };
+    const collector = new FilterBarRefCollector();
+    utils_ast.visitAll(collector, parsed.tree.rootNodes);
+    if (collector.refs.size === 0)
+        return { content: template, changed: false };
+    return rewriteRefReads(template, [...collector.refs]);
+}
+/** Interior `[start, end]` ranges of inline `@Component({ template: '…' })` string literals. */
+function collectInlineTemplateRanges(sourceFile) {
+    const ranges = [];
+    utils_typescript.forEachClass(sourceFile, (node) => {
+        const decorator = ts
+            .getDecorators(node)
+            ?.find((dec) => ts.isCallExpression(dec.expression) &&
+            ts.isIdentifier(dec.expression.expression) &&
+            dec.expression.expression.text === 'Component');
+        if (!decorator || !ts.isCallExpression(decorator.expression))
+            return;
+        const [arg] = decorator.expression.arguments;
+        if (!arg || !ts.isObjectLiteralExpression(arg))
+            return;
+        for (const prop of arg.properties) {
+            if (ts.isPropertyAssignment(prop) &&
+                (ts.isIdentifier(prop.name) || ts.isStringLiteralLike(prop.name)) &&
+                prop.name.text === 'template' &&
+                ts.isStringLiteralLike(prop.initializer) &&
+                prop.initializer.text) {
+                // +1 / -1 to exclude the opening/closing quote characters.
+                ranges.push({ start: prop.initializer.getStart(sourceFile) + 1, end: prop.initializer.getEnd() - 1 });
+            }
+        }
+    });
+    return ranges;
+}
+/** Pass B (inline) — rewrite filter-bar ref reads inside inline component templates. */
+async function migrateInlineTemplates(content, fileName) {
+    const sourceFile = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const ranges = collectInlineTemplateRanges(sourceFile).sort((a, b) => b.start - a.start);
+    let result = content;
+    for (const { start, end } of ranges) {
+        const { content: rewritten, changed } = await migrateTemplate(result.slice(start, end));
+        if (changed) {
+            result = result.slice(0, start) + rewritten + result.slice(end);
+        }
+    }
+    return result;
+}
+/** Pass C — safe identifier renames. */
+function applyRenames(content) {
+    let result = content;
+    for (const { from, to } of migrations_filterBarSignals_data.tsRenameReplacements) {
+        result = result.replace(new RegExp(from, 'g'), to);
+    }
+    return result;
+}
+function logWarnings(context, filePath, content) {
+    for (const { pattern, message } of migrations_filterBarSignals_data.warnPatterns) {
+        if (new RegExp(pattern).test(content)) {
+            utils_messages.logMessage(context.logger, [`[filter-bar-signals] ${filePath}`, `  ${message}`]);
+        }
+    }
+}
+/** A `.ts` file is a filter-bar consumer if it names the type or imports the package. */
+function referencesFilterBar(content) {
+    return /\bKbqFilterBar\b/.test(content) || content.includes('@koobiq/components/filter-bar');
+}
+function filterBarSignals(options) {
+    return async (tree, context) => {
+        const { project, fix } = options;
+        const projectDefinition = await utils_packageConfig.setupOptions(project, tree);
+        const root = projectDefinition?.root ?? '';
+        const rootDir = root ? tree.getDir(root) : tree.root;
+        const tsPaths = [];
+        const htmlPaths = [];
+        rootDir.visit((filePath) => {
+            if (filePath.includes('node_modules') || filePath.includes('/dist/'))
+                return;
+            if (filePath.endsWith(TS_EXT))
+                tsPaths.push(filePath);
+            else if (filePath.endsWith(HTML_EXT))
+                htmlPaths.push(filePath);
+        });
+        let touched = 0;
+        const commit = (filePath, original, updated) => {
+            if (updated === original)
+                return;
+            touched++;
+            if (fix) {
+                tree.overwrite(filePath, updated);
+            }
+            else {
+                utils_messages.logMessage(context.logger, [`[filter-bar-signals] would update ${filePath} (run with --fix to apply)`]);
+            }
+        };
+        for (const filePath of tsPaths) {
+            const original = tree.read(filePath)?.toString();
+            if (!original || !referencesFilterBar(original))
+                continue;
+            logWarnings(context, filePath, original);
+            let content = migrateTsExpressions(original, filePath);
+            content = await migrateInlineTemplates(content, filePath);
+            content = applyRenames(content);
+            commit(filePath, original, content);
+        }
+        for (const filePath of htmlPaths) {
+            const original = tree.read(filePath)?.toString();
+            if (!original)
+                continue;
+            const { content, changed } = await migrateTemplate(original);
+            if (changed)
+                commit(filePath, original, content);
+        }
+        utils_messages.logMessage(context.logger, [
+            `[filter-bar-signals] processed tree under "${root || '<workspace root>'}", ` +
+                `${fix ? 'updated' : 'would update'} ${touched} file(s).`
+        ]);
+    };
+}
+
+exports.default = filterBarSignals;

package/schematics/migrations/filter-bar-signals/schema.json

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

@@ -5,6 +5,21 @@
             "version": "20.0.0-0",
             "description": "Migrates code from deprecated APIs removed in @koobiq/components v20.0.0. Handles package moves (@koobiq/cdk/{a11y,keycodes,testing} → @koobiq/components/core, navbar-ic, risk-level, experimental form-field), TypeScript identifier renames, template selector renames (e.g. <kbq-filter-search> → <kbq-search-expandable>, <kbq-datepicker-toggle> → <kbq-datepicker-toggle-icon>), attribute renames (kbqFormFieldWithoutBorders → noBorders), tooltip modifier inputs, and emits warnings for structural changes that need manual migration (onSaveAsNew, file-upload customValidation/errors, app-switcher apps).",
             "factory": "./migrations/v20-upgrade/index"
+        },
+        "filter-bar-signals": {
+            "version": "20.2.0-0",
+            "description": "Migrates KbqFilterBar consumers to the signal-based API. Rewrites programmatic reads of the now-signal members (filter, pipeTemplates, isChanged, isDisabled, isReadOnly, isSaved, isSavedAndChanged) to calls and `filter = v` writes to `filter.set(v)` on receivers typed KbqFilterBar, including reads via template reference variables on <kbq-filter-bar>. Renames KbqFilterBarRefresher → KbqFilterRefresher and warns on changes/preparePopover/view-query cases that need manual migration.",
+            "factory": "./migrations/filter-bar-signals/index"
+        },
+        "alert-signals": {
+            "version": "20.2.0-0",
+            "description": "Migrates KbqAlert consumers to its finished signal-based API. Rewrites value-safe programmatic reads of the now-signal members (compact, alertStyle) to calls on receivers typed KbqAlert, including reads via template reference variables on <kbq-alert> (external and inline templates). Warns — without auto-fixing — on alertColor (now a read-only InputSignal whose getter returns the raw color instead of the `kbq-alert_<color>` class), the content-query members that became protected (icon/iconItem/button/title/control/closeButton/isColored), narrowed alertColor/alertStyle inputs, the compact booleanAttribute behavior change, descendants:false content projection, view/content queries returning the instance, and KbqAlertModule no longer re-exporting A11yModule/PlatformModule.",
+            "factory": "./migrations/alert-signals/index"
+        },
+        "autocomplete-panel-width-auto": {
+            "version": "20.2.0-0",
+            "description": "Replaces `panelWidth=\"auto\"` with `panelWidth=\"fit-content\"` on `<kbq-autocomplete>`. `auto` used to be passed to CSS verbatim, so the panel shrank to fit its content; it now means \"match the host width\", matching `kbq-select` and `kbq-tree-select`. The change is silent — `auto` still type-checks and still renders — so unmigrated templates only lay out differently.",
+            "factory": "./migrations/autocomplete-panel-width-auto/index"
         }
     }
 }

package/schematics/ng-add/index.js

@@ -27,7 +27,7 @@ function ngAdd(options) {
         }
         // Installing dependencies
         utils_packageConfig.addPackageToPackageJson(tree, '@angular/cdk', "^20.2.14");
-        utils_packageConfig.addPackageToPackageJson(tree, '@koobiq/angular-luxon-adapter', "^20.0.0");
+        utils_packageConfig.addPackageToPackageJson(tree, '@koobiq/angular-luxon-adapter', "^20.2.0");
         utils_packageConfig.addPackageToPackageJson(tree, '@koobiq/date-formatter', "^3.5.1");
         utils_packageConfig.addPackageToPackageJson(tree, '@koobiq/date-adapter', "^3.5.1");
         utils_packageConfig.addPackageToPackageJson(tree, '@koobiq/icons', "^11.7.1");

package/schematics/utils/angular-parsing.js

@@ -122,6 +122,7 @@ async function transformTemplateAttributes(template, fileName, migrationData) {
     if (parsed.tree !== undefined) {
         const visitor = new utils_typescript.ElementCollector(migrationData, fileName);
         utils_ast.visitAll(visitor, parsed.tree.rootNodes);
+        let didReplace = false;
         for (const el of visitor.elementsToMigrate) {
             const migrationAttr = el.attrs.find((attr) => utils_ast.getSimpleAttributeName(attr.name) === migrationData.attrs.key.from);
             let updatedAttrValue;
@@ -132,7 +133,14 @@ async function transformTemplateAttributes(template, fileName, migrationData) {
                     updatedAttrValue = replacement.to;
                 }
                 else {
-                    console.warn(`Element is using dynamic value. Check the code and change value on your own.${(fileName && ' File: ' + fileName) || ''}`);
+                    // A bound attribute (`[panelWidth]="..."`) whose value isn't a quoted string
+                    // literal is a genuine runtime expression and can't be resolved statically. A
+                    // plain attribute, or a bound attribute holding a quoted literal, has a known
+                    // value at migration time — it's just one the replacement table doesn't cover.
+                    const isDynamicExpression = migrationAttr.name.startsWith('[') && !/^\s*['"].*['"]\s*$/.test(migrationAttr.value);
+                    console.warn(isDynamicExpression
+                        ? `Element is using a dynamic value. Check the code and change value on your own.${(fileName && ' File: ' + fileName) || ''}`
+                        : `Element has value "${cleanAttrValue}" with no matching replacement. Check the code and change value on your own.${(fileName && ' File: ' + fileName) || ''}`);
                     continue;
                 }
                 updatedTemplate =
@@ -141,9 +149,10 @@ async function transformTemplateAttributes(template, fileName, migrationData) {
                         updatedTemplate.slice(migrationAttr.valueSpan.end.offset + 1 - offset, updatedTemplate.length);
                 offset += migrationAttr.name.length - migrationData.attrs.key.to.length;
                 offset += migrationAttr.value.length - updatedAttrValue.length;
+                didReplace = true;
             }
         }
-        return { fileContent: updatedTemplate, changed: visitor.elementsToMigrate.length > 0, errors: parsed.errors };
+        return { fileContent: updatedTemplate, changed: didReplace, errors: parsed.errors };
     }
     return { fileContent: updatedTemplate, changed: undefined, errors: parsed.errors };
 }

package/search-expandable/index.d.ts

@@ -35,6 +35,8 @@ declare class KbqSearchExpandable implements ControlValueAccessor, AfterViewInit
     /** Current value in input. */
     value: BehaviorSubject<string>;
     protected lastFocusOrigin: 'touch' | 'mouse' | 'keyboard' | 'program' | null;
+    /** Suppress the automatic input focus once — set when the component auto-opens from a model value. */
+    private suppressInputFocus;
     /** state of component. */
     isOpened: boolean;
     /** Emit event by enter or not. Default is false */
@@ -77,6 +79,7 @@ declare class KbqSearchExpandable implements ControlValueAccessor, AfterViewInit
     /** Implemented as part of ControlValueAccessor. */
     setDisabledState(isDisabled: boolean): void;
     toggle(): void;
+    private setOpened;
     private updateLocaleParams;
     private initDefaultParams;
     private emitValue;