@koobiq/components 20.0.0 → 20.1.0

package/schematics/collection.json

@@ -41,6 +41,11 @@
             "description": "Migrates deprecated API removed in @koobiq/components v20.0.0",
             "factory": "./migrations/v20-upgrade/index",
             "schema": "./migrations/v20-upgrade/schema.json"
+        },
+        "filter-bar-signals": {
+            "description": "Migrates KbqFilterBar consumers to the signal-based API (filter/pipeTemplates/isChanged/... reads become calls)",
+            "factory": "./migrations/filter-bar-signals/index",
+            "schema": "./migrations/filter-bar-signals/schema.json"
         }
     }
 }

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

@@ -0,0 +1,66 @@
+# filter-bar-signals
+
+Migration schematic invoked automatically by `ng update @koobiq/components@21`.
+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,11 @@
             "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": "21.0.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"
         }
     }
 }

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.1.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/select/index.d.ts

@@ -9,7 +9,7 @@ import { ConnectedPosition, CdkConnectedOverlay, CdkOverlayOrigin } from '@angul
 import { CdkVirtualForOf, CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
 import { ControlValueAccessor, NgForm, FormGroupDirective, NgControl } from '@angular/forms';
 import * as i2 from '@koobiq/components/core';
-import { KbqAbstractSelect, CanUpdateErrorState, ErrorStateMatcher, KbqLocaleService, KbqOptionBase, ActiveDescendantKeyManager, KbqOption, KbqSelectTrigger, KbqSelectMatcher, KbqOptgroup, KbqSelectSearch, KbqSelectSearchEmptyResult, KbqOptionSelectionChange, KbqVirtualOption, KbqComponentColors } from '@koobiq/components/core';
+import { KbqAbstractSelect, CanUpdateErrorState, ErrorStateMatcher, KbqLocaleService, KbqOptionBase, ActiveDescendantKeyManager, KbqOption, KbqSelectTrigger, KbqSelectMatcher, KbqOptgroup, KbqSelectSearch, KbqSelectSearchEmptyResult, KbqOptionSelectionChange, KbqSelectAllEvent, KbqVirtualOption, KbqComponentColors } from '@koobiq/components/core';
 import * as i11 from '@koobiq/components/form-field';
 import { KbqFormFieldControl, KbqCleaner } from '@koobiq/components/form-field';
 import * as i4 from '@koobiq/components/tags';
@@ -53,6 +53,7 @@ declare class KbqOptionTooltip extends KbqTooltipTrigger implements AfterViewIni
     private readonly option;
     private readonly resizeObserver;
     private readonly contentObserver;
+    private readonly isBrowser;
     private readonly debounceInterval;
     private resizeSubscription;
     private contentObserverSubscription;
@@ -283,6 +284,11 @@ declare class KbqSelect extends KbqAbstractSelect implements AfterContentInit, O
     readonly closedStream: Observable<void>;
     /** Event emitted when the selected value has been changed by the user. */
     readonly selectionChange: _angular_core.OutputEmitterRef<KbqSelectChange>;
+    /**
+     * Event emitted when all options are selected or deselected via the Ctrl/Cmd + A shortcut.
+     * Not emitted when a custom `selectAllHandler` is supplied — the handler owns the behaviour then.
+     */
+    readonly onSelectAll: _angular_core.OutputEmitterRef<KbqSelectAllEvent<KbqOption, KbqSelect>>;
     /**
      * Event that emits whenever the raw value of the select changes. This is here primarily
      * to facilitate the two-way binding for the `value` input.
@@ -346,6 +352,8 @@ declare class KbqSelect extends KbqAbstractSelect implements AfterContentInit, O
      * for primitive values where `value` itself is the display label.
      */
     readonly virtualOptionFactory: _angular_core.InputSignal<((value: any) => KbqVirtualOption) | undefined>;
+    /** When `true`, a repeated Ctrl/Cmd+A deselects all options. Off by default (Ctrl+A only selects). */
+    readonly selectAllToggle: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * Function for handling the Ctrl + A (select all) keyboard combination.
      * By default, the internal handler selects all options.
@@ -676,7 +684,7 @@ declare class KbqSelect extends KbqAbstractSelect implements AfterContentInit, O
     /** Removes the dropdown class from the overlay container when select closes. */
     private removeClassFromOverlayContainer;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqSelect, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqSelect, "kbq-select", ["kbqSelect"], { "hiddenItemsText": { "alias": "hiddenItemsText"; "required": false; }; "showPreselectedValues": { "alias": "showPreselectedValues"; "required": false; "isSignal": true; }; "triggerValuesLimit": { "alias": "triggerValuesLimit"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; "backdropClass": { "alias": "backdropClass"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; }; "sortComparator": { "alias": "sortComparator"; "required": false; "isSignal": true; }; "multiline": { "alias": "multiline"; "required": false; "isSignal": true; }; "searchMinOptionsThreshold": { "alias": "searchMinOptionsThreshold"; "required": false; }; "scrolledToBottomOffset": { "alias": "scrolledToBottomOffset"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "virtualOptionFactory": { "alias": "virtualOptionFactory"; "required": false; "isSignal": true; }; "selectAllHandler": { "alias": "selectAllHandler"; "required": false; }; "panelWidth": { "alias": "panelWidth"; "required": false; }; "panelMinWidth": { "alias": "panelMinWidth"; "required": false; }; "value": { "alias": "value"; "required": false; }; "id": { "alias": "id"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hiddenItemsTextFormatter": { "alias": "hiddenItemsTextFormatter"; "required": false; }; }, { "openedChange": "openedChange"; "beforeOpened": "beforeOpened"; "openedStream": "opened"; "closedStream": "closed"; "selectionChange": "selectionChange"; "valueChange": "valueChange"; "scrolledToBottom": "scrolledToBottom"; }, ["footer", "cdkVirtualForOf", "virtualScrollViewport", "customTrigger", "customMatcher", "customTagTemplateRef", "cleaner", "optionGroups", "search", "searchEmpty", "options"], ["kbq-select-matcher, [kbq-select-matcher]", "kbq-select-trigger, [kbq-select-trigger]", "kbq-cleaner", "[kbqSelectSearch]", "[kbq-select-search-empty-result]", "*", "kbq-select-footer,[kbq-select-footer]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqSelect, "kbq-select", ["kbqSelect"], { "hiddenItemsText": { "alias": "hiddenItemsText"; "required": false; }; "showPreselectedValues": { "alias": "showPreselectedValues"; "required": false; "isSignal": true; }; "triggerValuesLimit": { "alias": "triggerValuesLimit"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; "backdropClass": { "alias": "backdropClass"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; }; "sortComparator": { "alias": "sortComparator"; "required": false; "isSignal": true; }; "multiline": { "alias": "multiline"; "required": false; "isSignal": true; }; "searchMinOptionsThreshold": { "alias": "searchMinOptionsThreshold"; "required": false; }; "scrolledToBottomOffset": { "alias": "scrolledToBottomOffset"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "virtualOptionFactory": { "alias": "virtualOptionFactory"; "required": false; "isSignal": true; }; "selectAllToggle": { "alias": "selectAllToggle"; "required": false; "isSignal": true; }; "selectAllHandler": { "alias": "selectAllHandler"; "required": false; }; "panelWidth": { "alias": "panelWidth"; "required": false; }; "panelMinWidth": { "alias": "panelMinWidth"; "required": false; }; "value": { "alias": "value"; "required": false; }; "id": { "alias": "id"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hiddenItemsTextFormatter": { "alias": "hiddenItemsTextFormatter"; "required": false; }; }, { "openedChange": "openedChange"; "beforeOpened": "beforeOpened"; "openedStream": "opened"; "closedStream": "closed"; "selectionChange": "selectionChange"; "onSelectAll": "onSelectAll"; "valueChange": "valueChange"; "scrolledToBottom": "scrolledToBottom"; }, ["footer", "cdkVirtualForOf", "virtualScrollViewport", "customTrigger", "customMatcher", "customTagTemplateRef", "cleaner", "optionGroups", "search", "searchEmpty", "options"], ["kbq-select-matcher, [kbq-select-matcher]", "kbq-select-trigger, [kbq-select-trigger]", "kbq-cleaner", "[kbqSelectSearch]", "[kbq-select-search-empty-result]", "*", "kbq-select-footer,[kbq-select-footer]"], true, never>;
     static ngAcceptInputType_multiple: unknown;
     static ngAcceptInputType_panelMinWidth: unknown;
     static ngAcceptInputType_tabIndex: unknown;

package/sidebar/index.d.ts

@@ -37,6 +37,7 @@ declare class KbqSidebar implements OnDestroy, AfterContentInit {
     protected readonly document: Document;
     private readonly renderer;
     private readonly changeDetectorRef;
+    private readonly isBrowser;
     get opened(): boolean;
     set opened(value: boolean);
     private _opened;

package/skeleton/skeleton.scss

@@ -52,5 +52,9 @@
             var(--kbq-skeleton-animation-wave-end) 100%
         );
         animation: wave var(--kbq-skeleton-animation-duration) ease-in var(--kbq-skeleton-animation-delay) infinite;
+
+        @media (prefers-reduced-motion: reduce) {
+            animation: none;
+        }
     }
 }

package/split-button/_split-button-theme.scss

@@ -1,7 +1,7 @@
 @mixin kbq-split-button-theme() {
     .kbq-split-button {
         &:hover:has(.kbq-button_transparent) {
-            background: var(--kbq-states-background-transparent-hover, rgba(108, 115, 147, 0.08));
+            background: var(--kbq-states-background-transparent-hover);
         }
 
         & .kbq-split-button_item {
@@ -102,7 +102,7 @@
             }
 
             & .kbq-split-button_second:before {
-                background: rgba(138, 143, 168, 0.6);
+                background: var(--kbq-states-line-disabled);
             }
         }
 

package/splitter/_splitter-theme.scss

@@ -6,7 +6,7 @@
 
         &:hover,
         &.kbq-gutter_dragged {
-            background-color: rgba(106, 115, 150, 0.08);
+            background-color: var(--kbq-states-background-transparent-hover);
         }
 
         &.kbq-gutter_vertical {
@@ -21,6 +21,6 @@
     }
 
     .kbq-gutter-ghost {
-        background: rgba(106, 115, 150, 0.16);
+        background: var(--kbq-states-background-transparent-active);
     }
 }

package/splitter/index.d.ts

@@ -112,6 +112,7 @@ declare class KbqSplitterAreaDirective implements AfterViewInit, OnDestroy {
     private splitter;
     readonly sizeChange: i0.OutputEmitterRef<number>;
     private readonly window;
+    private readonly platform;
     isResizing(): boolean;
     disableFlex(): void;
     ngAfterViewInit(): void;

package/table/_table-theme.scss

@@ -16,7 +16,11 @@
                 & > td {
                     color: var(--kbq-foreground-contrast);
                 }
+            }
+        }
 
+        &:not(.kbq-table_disable-hover) > tbody {
+            & > tr {
                 &.kbq-hovered td,
                 &:hover td {
                     background-color: var(--kbq-states-background-transparent-hover);