@koobiq/components 20.4.2 → 21.0.1

package/schematics/migrations/alert-signals/index.cjs

@@ -0,0 +1,221 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ts = require('typescript');
+var utils_messages = require('../../utils/messages.cjs');
+var utils_packageConfig = require('../../utils/package-config.cjs');
+var utils_projectFiles = require('../../utils/project-files.cjs');
+var utils_signalMembersMigration = require('../../utils/signal-members-migration.cjs');
+var utils_templateRefAccess = require('../../utils/template-ref-access.cjs');
+var utils_typescript = require('../../utils/typescript.cjs');
+var migrations_alertSignals_data = require('./data.cjs');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+require('../../utils/ast.cjs');
+
+const TS_EXT = '.ts';
+const HTML_EXT = '.html';
+/** Applies text-span edits to `content`, right-to-left, so earlier edits don't shift later offsets. */
+function applyEdits(content, edits) {
+    const sorted = [...edits].sort((a, b) => b.start - a.start || b.end - a.end);
+    let result = content;
+    for (const { start, end, text } of sorted) {
+        result = result.slice(0, start) + text + result.slice(end);
+    }
+    return result;
+}
+/** The `KbqAlert` receivers of a file, typed by annotation or `inject()`. */
+function collectFileReceivers(sourceFile) {
+    return { receivers: utils_signalMembersMigration.collectAllReceivers(sourceFile, [migrations_alertSignals_data.ALERT_TYPE]), bindings: utils_signalMembersMigration.collectBindings(sourceFile) };
+}
+/**
+ * Whether a property access reads from an alert receiver. The shared engine resolves the receiver at this
+ * exact position, so a nested declaration that shadows its name or a `function` that rebinds `this` is not
+ * followed. A signal query holds the instance behind a call of its own, which this pass does not reach.
+ */
+function onReceiver(node, sourceFile, scope) {
+    const receiver = utils_signalMembersMigration.resolveReceiver(node.expression, node, sourceFile, scope.receivers, scope.bindings);
+    return !!receiver && !receiver.signalQuery;
+}
+/** Collects edits for every read/write of a value-safe signal member on a known alert receiver. */
+function collectAccessEdits(sourceFile, scope) {
+    const edits = [];
+    const visit = (node) => {
+        if (ts.isPropertyAccessExpression(node) &&
+            ts.isIdentifier(node.name) &&
+            migrations_alertSignals_data.SIGNAL_MEMBERS.includes(node.name.text) &&
+            onReceiver(node, sourceFile, scope)) {
+            // `KbqAlert` signal members are `input()`, so every write is left for the consumer and reported.
+            utils_signalMembersMigration.classifyAccess(node, sourceFile, migrations_alertSignals_data.WRITABLE_MEMBERS, edits);
+        }
+        node.forEachChild(visit);
+    };
+    visit(sourceFile);
+    return edits;
+}
+/** Whether a signal member is written rather than read, in any form: the migration leaves it for the consumer. */
+function isReadOnlyWrite(node) {
+    return migrations_alertSignals_data.SIGNAL_MEMBERS.includes(node.name.text) && !migrations_alertSignals_data.WRITABLE_MEMBERS.has(node.name.text) && utils_signalMembersMigration.isWriteTarget(node);
+}
+/**
+ * Collects the manual-migration members (`alertColor`, now-`protected` queries, writes to read-only signal
+ * members) accessed on an alert receiver.
+ */
+function collectReceiverWarnings(sourceFile, scope) {
+    const valueChanged = new Set();
+    const protectedAccess = new Set();
+    const readOnlyWrites = new Set();
+    const visit = (node) => {
+        if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name) && onReceiver(node, sourceFile, scope)) {
+            const name = node.name.text;
+            if (migrations_alertSignals_data.VALUE_CHANGED_MEMBERS.includes(name))
+                valueChanged.add(name);
+            else if (migrations_alertSignals_data.PROTECTED_MEMBERS.includes(name))
+                protectedAccess.add(name);
+            else if (isReadOnlyWrite(node))
+                readOnlyWrites.add(name);
+        }
+        node.forEachChild(visit);
+    };
+    visit(sourceFile);
+    return { valueChanged, protectedAccess, readOnlyWrites };
+}
+/** Pass A — rewrite value-safe programmatic reads of alert signal members in TypeScript code. */
+function migrateTsExpressions(content, fileName) {
+    const sourceFile = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const scope = collectFileReceivers(sourceFile);
+    if (scope.receivers.length === 0)
+        return content;
+    const edits = collectAccessEdits(sourceFile, scope);
+    return edits.length > 0 ? applyEdits(content, edits) : content;
+}
+/** Reports writes to signal members that are read-only now, made in code or through a template reference. */
+function warnReadOnlyWrites(context, filePath, members) {
+    if (members.size === 0)
+        return;
+    utils_messages.logMessage(context.logger, [
+        `[alert-signals] ${filePath}`,
+        `  \`${[...members].join('`, `')}\` can no longer be assigned: they are read-only signal inputs now. Bind`,
+        `  them in the template (e.g. \`[compact]="…"\`) instead of assigning them.`
+    ]);
+}
+/** Emits precise, receiver-scoped warnings for the members that can't be auto-fixed. */
+function warnReceiverMembers(context, filePath, content, templateWrites) {
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const { valueChanged, protectedAccess, readOnlyWrites } = collectReceiverWarnings(sourceFile, collectFileReceivers(sourceFile));
+    templateWrites.forEach((member) => readOnlyWrites.add(member));
+    warnReadOnlyWrites(context, filePath, readOnlyWrites);
+    if (valueChanged.size > 0) {
+        utils_messages.logMessage(context.logger, [
+            `[alert-signals] ${filePath}`,
+            `  \`alertColor\` is now a read-only InputSignal — read it as \`alert.alertColor()\`. Its value also`,
+            `  changed: the getter used to return the CSS class \`kbq-alert_<color>\`, it now returns the raw color`,
+            `  (e.g. \`error\`). Programmatic writes (\`alert.alertColor = …\`) are no longer possible — bind`,
+            `  \`[alertColor]\` in the template instead. Migrate this by hand.`
+        ]);
+    }
+    if (protectedAccess.size > 0) {
+        utils_messages.logMessage(context.logger, [
+            `[alert-signals] ${filePath}`,
+            `  These KbqAlert members are now \`protected\` and can't be read from outside the component: ` +
+                `${[...protectedAccess].join(', ')}. Refactor to avoid reading them.`
+        ]);
+    }
+}
+/** What a reference variable on `<kbq-alert>` reaches. */
+const REF_POLICY = { members: migrations_alertSignals_data.SIGNAL_MEMBERS, writable: migrations_alertSignals_data.WRITABLE_MEMBERS };
+/** Pass B (core) — parse a template, discover alert refs, rewrite their value-safe signal reads. */
+async function migrateTemplate(template) {
+    const untouched = { content: template, changed: false, readOnlyWrites: new Set() };
+    if (!template.includes(migrations_alertSignals_data.ALERT_ELEMENT))
+        return untouched;
+    const parsed = await utils_typescript.parseTemplate(template);
+    if (!parsed.tree)
+        return untouched;
+    const { rootNodes } = parsed.tree;
+    // A bare `#ref` or one naming the alert; `#ref="ngModel"` names another directive.
+    const { content, readOnlyWrites } = utils_templateRefAccess.rewriteRefAccesses(template, rootNodes, (element, value) => element.name === migrations_alertSignals_data.ALERT_ELEMENT && (!value || value === migrations_alertSignals_data.ALERT_EXPORT_AS) ? REF_POLICY : undefined);
+    return { content, changed: content !== template, readOnlyWrites };
+}
+/** Pass B (inline) — rewrite alert 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 = utils_typescript.collectInlineTemplateRanges(sourceFile).sort((a, b) => b.start - a.start);
+    const readOnlyWrites = new Set();
+    let result = content;
+    for (const { start, end } of ranges) {
+        const outcome = await migrateTemplate(result.slice(start, end));
+        outcome.readOnlyWrites.forEach((member) => readOnlyWrites.add(member));
+        if (outcome.changed) {
+            result = result.slice(0, start) + outcome.content + result.slice(end);
+        }
+    }
+    return { content: result, readOnlyWrites };
+}
+function logWarnings(context, filePath, content) {
+    for (const { pattern, message } of migrations_alertSignals_data.warnPatterns) {
+        if (new RegExp(pattern).test(content)) {
+            utils_messages.logMessage(context.logger, [`[alert-signals] ${filePath}`, `  ${message}`]);
+        }
+    }
+}
+/** A `.ts` file is an alert consumer if it names the type/module or imports the package. */
+function referencesAlert(content) {
+    return /\bKbqAlert\b/.test(content) || content.includes('@koobiq/components/alert');
+}
+function alertSignals(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 tsPaths = [];
+        const htmlPaths = [];
+        utils_projectFiles.visitProjectFiles(rootDir, (filePath) => {
+            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, [`[alert-signals] would update ${filePath} (run with --fix to apply)`]);
+            }
+        };
+        for (const filePath of tsPaths) {
+            const original = tree.read(filePath)?.toString();
+            if (!original || !referencesAlert(original))
+                continue;
+            logWarnings(context, filePath, original);
+            const inline = await migrateInlineTemplates(migrateTsExpressions(original, filePath), filePath);
+            warnReceiverMembers(context, filePath, original, inline.readOnlyWrites);
+            commit(filePath, original, inline.content);
+        }
+        for (const filePath of htmlPaths) {
+            const original = tree.read(filePath)?.toString();
+            if (!original)
+                continue;
+            const { content, changed, readOnlyWrites } = await migrateTemplate(original);
+            warnReadOnlyWrites(context, filePath, readOnlyWrites);
+            if (changed)
+                commit(filePath, original, content);
+        }
+        utils_messages.logMessage(context.logger, [
+            `[alert-signals] processed tree under "${root || '<workspace root>'}", ` +
+                `${fix ? 'updated' : 'would update'} ${touched} file(s).`
+        ]);
+    };
+}
+
+exports.default = alertSignals;

package/schematics/migrations/angular-animations-removal/README.md

@@ -0,0 +1,46 @@
+# angular-animations-removal
+
+Migration schematic invoked automatically by `ng update @koobiq/components@21`
+(registered for `21.0.0-0`). Reports the uses of the animation triggers the library exported and of the
+members that carried an `AnimationEvent`. It never writes to the tree.
+
+## Background
+
+Koobiq components no longer use `@angular/animations`, which Angular deprecated. They animate with CSS,
+wait for the end of an animation themselves, and skip the motion under `prefers-reduced-motion: reduce`
+or `KBQ_ANIMATIONS_CONFIG`. `@angular/animations` is no longer a peer dependency, and an application no
+longer needs `provideAnimations()` for the components.
+
+## What it does _not_ do
+
+Nothing is rewritten: what replaces a member depends on what the code did with the event.
+
+| Pattern                                                                                                          | Manual migration                                                              |
+| ---------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
+| `fadeAnimation`, `kbqSelectAnimations`                                                                           | Animate with CSS, or `animate.enter` / `animate.leave`                        |
+| `kbqDropdownAnimations`, `fadeInItems`, `transformDropdown`                                                      | Remove: the dropdown panel no longer animates                                 |
+| `kbqTabsAnimations`                                                                                              | Remove: a tab body translates with a CSS transition                           |
+| `kbqPopoverAnimations`, `kbqDatepickerAnimations`, `KbqNotificationCenterAnimations`, `kbqAppSwitcherAnimations` | Animate with CSS, or `animate.enter` / `animate.leave`                        |
+| `MODAL_ANIMATE_DURATION`                                                                                         | `afterOpen` / `afterClose` of `KbqModalRef` instead of a timer                |
+| `KbqSidepanelAnimationState`                                                                                     | `afterOpened()`, `beforeClosed()`, `afterClosed()` of `KbqSidepanelRef`       |
+| `.animationStart()`, `.animationDone()` of a pop-up                                                              | Override the protected `afterShowAnimation()`                                 |
+| `isAnimating`, `panelAnimationState`, `startAnimation()`, `resetAnimation()`                                     | Remove; a custom dropdown trigger calls `setOpened()`                         |
+| `.animationDone.pipe()` / `.subscribe()` of a dropdown                                                           | `dropdownOpened` / `dropdownClosed` or `openedChange` of `KbqDropdownTrigger` |
+| `onAnimationStart`, `onAnimationDone`, `onAnimation`, `onTranslateTab*`                                          | `KbqSidebar.stateChanged`, `KbqTabGroup.animationDone`, the ref's outputs     |
+| `animationStateChanged`                                                                                          | The ref: `afterOpened()`, `beforeClosed()`, `afterClosed()`                   |
+| `animationState`, `animationTransform`, `setAnimationState()`                                                    | The ref's outputs; `KbqSidebar.stateChanged`                                  |
+| `contentAnimationState` of `KbqContentPanelContainer`                                                            | `isOpened()`                                                                  |
+| `KbqToastService.animation`                                                                                      | Remove: the overlay detaches once the last exit has ended                     |
+| `NoopAnimationsModule`, `provideNoopAnimations()`                                                                | `{ provide: KBQ_ANIMATIONS_CONFIG, useValue: { animationsDisabled: true } }`  |
+| `provideAnimations()`, `provideAnimationsAsync()`, `BrowserAnimationsModule`                                     | Remove, unless the application declares `animations: [...]` itself            |
+
+A pattern that does not name Koobiq itself is checked only in a file that also names the component it is
+about — its entry point, one of its `Kbq…` / `kbq…` symbols or its element — so an application component
+that declares its own `isAnimating` or `onAnimationDone()` stays quiet. Angular's animation providers and
+modules are reported wherever they appear: `app.config.ts` and a spec seldom name a Koobiq component.
+
+## Running it manually
+
+```
+ng generate @koobiq/components:angular-animations-removal --project my-app
+```

package/schematics/migrations/angular-animations-removal/data.cjs

@@ -0,0 +1,150 @@
+'use strict';
+
+/**
+ * Data for the `angular-animations-removal` migration.
+ *
+ * Koobiq components no longer use `@angular/animations`: they animate with CSS and wait for its end
+ * themselves. The animation triggers they exported and the members that carried an `AnimationEvent` are
+ * removed. Warn-only: what replaces a member depends on what the code did with the event.
+ */
+/**
+ * A file that imports the entry point, names one of its `Kbq…` / `kbq…` symbols or renders its element. The stem
+ * ends at a capital or at the end of the word, so `Tab` does not take `KbqTable`.
+ */
+const owner = (entryPoint, stem, element = entryPoint) => String.raw `@koobiq/components/${entryPoint}\b|\b[Kk]bq${stem}(?:[A-Z]\w*)?\b|<kbq-${element}\b`;
+const DROPDOWN = owner('dropdown', 'Dropdown');
+const SIDEBAR = owner('sidebar', 'Sidebar');
+const TABS = owner('tabs', 'Tabs?', 'tab');
+const TOAST = owner('toast', 'Toast');
+const SIDEPANEL = owner('sidepanel', 'Sidepanel');
+const ACTIONS_PANEL = owner('actions-panel', 'ActionsPanel');
+const CONTENT_PANEL = owner('content-panel', 'ContentPanel');
+const MODAL = owner('modal', 'Modal');
+const POP_UP = [
+    String.raw `\bKbqPopUp\w*`,
+    owner('tooltip', 'Tooltip'),
+    owner('popover', 'Popover'),
+    owner('app-switcher', 'AppSwitcher'),
+    owner('notification-center', 'NotificationCenter')
+].join('|');
+/**
+ * The anchor is left out where the pattern names Koobiq alone, and for Angular's animation providers, which
+ * `app.config.ts` and specs declare without naming a component.
+ */
+const warnPatterns = [
+    {
+        // kbqSelectAnimations is ours whatever the file imports it from.
+        anchor: String.raw `@koobiq/components/core\b|\bkbqSelectAnimations\b`,
+        pattern: '\\b(fadeAnimation|kbqSelectAnimations)\\b',
+        message: 'fadeAnimation and kbqSelectAnimations were removed from @koobiq/components/core: the components no ' +
+            'longer declare @angular/animations triggers. Animate your own elements with CSS, or with ' +
+            '`animate.enter` / `animate.leave` in the template.'
+    },
+    {
+        anchor: DROPDOWN,
+        pattern: '\\b(kbqDropdownAnimations|fadeInItems|transformDropdown)\\b',
+        message: 'kbqDropdownAnimations, fadeInItems and transformDropdown were removed from @koobiq/components/dropdown: ' +
+            'the panel opens and closes without an animation.'
+    },
+    {
+        pattern: '\\bkbqTabsAnimations\\b',
+        message: 'kbqTabsAnimations was removed from @koobiq/components/tabs: a tab body translates with a CSS ' +
+            'transition that lasts `animationDuration`.'
+    },
+    {
+        pattern: '\\b(kbqPopoverAnimations|kbqDatepickerAnimations|KbqNotificationCenterAnimations|' +
+            'kbqAppSwitcherAnimations)\\b',
+        message: 'kbqPopoverAnimations, kbqDatepickerAnimations, KbqNotificationCenterAnimations and ' +
+            'kbqAppSwitcherAnimations were removed from @koobiq/components/popover, /datepicker, ' +
+            '/notification-center and /app-switcher: their panels animate with CSS. Animate your own elements ' +
+            'with CSS, or with `animate.enter` / `animate.leave` in the template.'
+    },
+    {
+        anchor: MODAL,
+        pattern: '\\bMODAL_ANIMATE_DURATION\\b',
+        message: 'MODAL_ANIMATE_DURATION was removed from @koobiq/components/modal: the dialog animates with CSS and ' +
+            'waits for the end of the animation itself. Instead of a timer of that length, act on afterOpen / ' +
+            'afterClose of the KbqModalRef.'
+    },
+    {
+        pattern: '\\bKbqSidepanelAnimationState\\b',
+        message: 'KbqSidepanelAnimationState is no longer exported from @koobiq/components/sidepanel. Follow a sidepanel ' +
+            'through KbqSidepanelRef: afterOpened(), beforeClosed() and afterClosed().'
+    },
+    {
+        anchor: POP_UP,
+        pattern: '\\.(animationStart|animationDone)\\s*\\(',
+        message: 'KbqPopUp.animationStart() and animationDone() were removed: a pop-up animates in with CSS. A subclass ' +
+            'acting once it has appeared overrides the protected afterShowAnimation() instead.'
+    },
+    {
+        anchor: DROPDOWN,
+        pattern: '\\b(isAnimating|panelAnimationState|startAnimation|resetAnimation)\\b',
+        message: 'KbqDropdown lost isAnimating, panelAnimationState, startAnimation() and resetAnimation() along with ' +
+            'animationDone: the panel no longer animates, so it is closed as soon as the trigger reports it, and a ' +
+            'custom trigger tells it about an attached panel with setOpened().'
+    },
+    {
+        anchor: DROPDOWN,
+        pattern: '\\.animationDone\\s*\\.\\s*(pipe|subscribe)\\b',
+        message: 'KbqDropdown.animationDone was removed: the panel no longer animates, so the trigger attaches and ' +
+            'detaches it at once. Listen to the dropdownOpened / dropdownClosed outputs of KbqDropdownTrigger, or ' +
+            'its openedChange, which emit right after. The animationDone of KbqTabGroup and of the actions panel ' +
+            'container stays: ignore this for them.'
+    },
+    {
+        anchor: [DROPDOWN, SIDEBAR, TABS, TOAST, SIDEPANEL, ACTIONS_PANEL].join('|'),
+        pattern: '\\b(onAnimationStart|onAnimationDone|onAnimation|onTranslateTabStarted|onTranslateTabComplete)\\b',
+        message: 'The animation callbacks taking an AnimationEvent were removed (KbqDropdown, KbqSidebar, KbqTabBody, ' +
+            'KbqToastComponent, the sidepanel and actions panel containers). Use the outputs instead: ' +
+            'KbqSidebar.stateChanged, KbqTabGroup.animationDone, and the afterOpened() / afterClosed() of a ref.'
+    },
+    {
+        anchor: [SIDEPANEL, ACTIONS_PANEL].join('|'),
+        pattern: '\\banimationStateChanged\\b',
+        message: 'animationStateChanged no longer emits an AnimationEvent: the actions panel container emits the state ' +
+            'it reached through animationDone, and the one of the sidepanel container is internal. Follow both ' +
+            'through their ref: afterOpened(), beforeClosed() and afterClosed().'
+    },
+    {
+        anchor: [SIDEPANEL, SIDEBAR, TOAST].join('|'),
+        pattern: '\\b(setAnimationState|animationTransform)\\b|\\.animationState\\b',
+        message: 'The animation state of KbqSidepanelContainerComponent (animationState, animationTransform, ' +
+            'setAnimationState()), KbqSidebar and KbqToastComponent was removed. Follow a sidepanel through ' +
+            'KbqSidepanelRef: afterOpened(), beforeClosed() and afterClosed(); a sidebar through stateChanged. ' +
+            'Ignore this if animationState is a member of your own component.'
+    },
+    {
+        anchor: CONTENT_PANEL,
+        pattern: '\\bcontentAnimationState\\b',
+        message: 'KbqContentPanelContainer.contentAnimationState was removed with the @contentAnimation trigger it fed: ' +
+            'the content makes room for the opened panel with a CSS transition. Read isOpened() for the state of ' +
+            'the panel.'
+    },
+    {
+        anchor: TOAST,
+        pattern: '\\.animation\\s*\\.\\s*(pipe|subscribe|next)\\b',
+        message: 'KbqToastService.animation (and KbqToastStack.animation) were removed: a toast plays its exit animation ' +
+            'before it is taken out, and the overlay detaches once the last exit has ended.'
+    },
+    {
+        pattern: '\\b(NoopAnimationsModule|provideNoopAnimations)\\b',
+        message: 'Koobiq components still skip their motion under NoopAnimationsModule / provideNoopAnimations(), but ' +
+            'that is @angular/animations, which is deprecated: provide ' +
+            '`{ provide: KBQ_ANIMATIONS_CONFIG, useValue: { animationsDisabled: true } }` from ' +
+            '@koobiq/components/core instead. In jsdom nothing animates either way.'
+    },
+    {
+        pattern: '\\b(provideAnimations|provideAnimationsAsync|BrowserAnimationsModule)\\b',
+        message: 'Koobiq components no longer need Angular animations. Remove the provider, and @angular/animations, ' +
+            'unless the components of the application declare `animations: [...]` themselves.'
+    }
+];
+const SUMMARY = [
+    'Koobiq components animate with CSS and no longer depend on @angular/animations, see "Animations without',
+    '@angular/animations" in the migration guide. A spec that waited for an animation callback now waits for the',
+    'next render: fixture.detectChanges() or await fixture.whenStable().'
+];
+
+exports.SUMMARY = SUMMARY;
+exports.warnPatterns = warnPatterns;

package/schematics/migrations/angular-animations-removal/index.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils_warnOnlyMigration = require('../../utils/warn-only-migration.cjs');
+var migrations_angularAnimationsRemoval_data = require('./data.cjs');
+require('../../utils/messages.cjs');
+require('../../utils/package-config.cjs');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+require('../../utils/project-files.cjs');
+
+/**
+ * Reports the uses of the removed animation triggers and of the members that carried an `AnimationEvent`.
+ * Never writes: what replaces a member depends on what the code did with the event.
+ */
+function angularAnimationsRemoval(options) {
+    return utils_warnOnlyMigration.warnOnlyRule({ label: '[angular-animations-removal]', warnPatterns: migrations_angularAnimationsRemoval_data.warnPatterns, summary: migrations_angularAnimationsRemoval_data.SUMMARY }, options);
+}
+
+exports.default = angularAnimationsRemoval;

package/schematics/migrations/angular-animations-removal/schema.json

@@ -0,0 +1,15 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "koobiq-components-angular-animations-removal",
+    "title": "Koobiq components @angular/animations removal migration",
+    "type": "object",
+    "properties": {
+        "project": {
+            "type": "string",
+            "description": "Name of the project to inspect. If omitted, the migration runs over the whole tree.",
+            "$default": {
+                "$source": "projectName"
+            }
+        }
+    }
+}

package/schematics/migrations/app-switcher-signals/README.md

@@ -0,0 +1,88 @@
+# app-switcher-signals
+
+Migration schematic invoked automatically by `ng update @koobiq/components`.
+Migrates consumers of `KbqAppSwitcherTrigger` to its `model()`-based API and reports the members the
+app-switcher review removed.
+
+## Why
+
+`selectedApp` and `selectedSite` moved from a plain `@Input()` (plus a matching `output()`) to `model()`, and
+several members that never did anything were dropped. Template _bindings_ keep working — `[selectedApp]`,
+`[(selectedSite)]` and `(selectedAppChange)` are unchanged — so only programmatic access and reads through a
+`#ref="kbqAppSwitcher"` template reference variable break.
+
+| Member                                 | Before                       | After                                         | Auto-fix                         |
+| -------------------------------------- | ---------------------------- | --------------------------------------------- | -------------------------------- |
+| `selectedApp`                          | `@Input()` property          | `ModelSignal<KbqAppSwitcherApp \| undefined>` | ✅ read → call, write → `.set()` |
+| `selectedAppChange`                    | `output()`                   | implicit output of the `selectedApp` model    | ✅ `.subscribe` renamed          |
+| `selectedSite`                         | `get`/`set` accessor input   | `ModelSignal`, **value changed**              | ⚠️ warn                          |
+| `selectedSiteChange`                   | `output()`                   | implicit output, **value changed**            | ⚠️ warn                          |
+| `header` / `footer`                    | properties                   | removed                                       | ⚠️ warn                          |
+| `isTrapFocus` / `updateTrapFocus()`    | `KbqAppSwitcherComponent`    | removed                                       | ⚠️ warn                          |
+| `activeSite` / `activeApp` (protected) | `KbqAppSwitcherComponent`    | removed: the flyout template context          | ⚠️ warn                          |
+| `getIcon()`                            | `KbqAppSwitcherDropdownApp`  | removed                                       | ⚠️ warn                          |
+| `collapsed`, `app`, `site`, `toggle`   | properties / optional inputs | model / `input.required`                      | ⚠️ warn                          |
+
+## What it does (auto-fix)
+
+The schematic walks every `.ts` and `.html` file in the project (skipping `node_modules` and `dist`) and, for
+files that reference the app-switcher:
+
+- **TypeScript access.** For a receiver whose static type is annotated `KbqAppSwitcherTrigger` (method/function
+  params, class fields — including `@ViewChild(KbqAppSwitcherTrigger) x: KbqAppSwitcherTrigger` and constructor
+  parameter-properties — and typed locals):
+    - `trigger.selectedApp` → `trigger.selectedApp()` (incl. optional chain `trigger?.selectedApp`)
+    - `trigger.selectedApp = app` → `trigger.selectedApp.set(app)`
+    - `trigger.selectedAppChange.subscribe(fn)` → `trigger.selectedApp.subscribe(fn)` — `ModelSignal` implements
+      `OutputRef`, so the callback signature is identical
+- **Template reference reads.** For a `#ref="kbqAppSwitcher"` (or `ref-x="kbqAppSwitcher"`), reads of
+  `selectedApp` through that ref are rewritten in the same template (external `.html` and inline `template:`
+  strings): `switcher.selectedApp` → `switcher.selectedApp()`.
+
+All rewrites are idempotent — an access already followed by `()`, `.set`, `.update`, `.asReadonly` or
+`.subscribe` is left alone, so running twice does not double the call.
+
+Note that `selectedApp()` is typed `KbqAppSwitcherApp | undefined`. Where the old property was read as
+non-nullable (`trigger.selectedApp.name` → `trigger.selectedApp().name`), the compiler will now ask for a `!` or
+a `?.` — that narrowing is yours to place.
+
+## What it does _not_ do (warn-only)
+
+| Change                                               | Manual migration                                                                                                                                                                                                                                                                          |
+| ---------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `trigger.selectedSite` read                          | **Value changed.** The old getter returned the site with its applications already grouped; the model returns the value that was passed in. Use `trigger.selectedSite()` for the raw site, `trigger.parsedSelectedSite()` for the grouped one.                                             |
+| `trigger.selectedSite = site` write                  | `trigger.selectedSite.set(site)`.                                                                                                                                                                                                                                                         |
+| `trigger.selectedSiteChange`                         | Now the implicit output of the model: `trigger.selectedSite.subscribe(…)`. It emits the raw site, not the grouped one.                                                                                                                                                                    |
+| `trigger.selectedAppChange.emit(app)`                | No longer an emitter — `trigger.selectedApp.set(app)`.                                                                                                                                                                                                                                    |
+| `trigger.header` / `trigger.footer`                  | Removed. The popup never rendered either, so the value was pushed into the overlay and dropped — delete the usage.                                                                                                                                                                        |
+| `popup.isTrapFocus` / `popup.updateTrapFocus(…)`     | Removed from `KbqAppSwitcherComponent`. The template never bound `[cdkTrapFocus]`, so neither did anything.                                                                                                                                                                               |
+| `row.getIcon(icon)`                                  | Removed from `KbqAppSwitcherDropdownApp`. Inline markup is sanitized by `KbqAppSwitcherIconSanitizer` and rendered by the component itself.                                                                                                                                               |
+| `KbqAppSwitcherListItem.collapsed`                   | Now a `model()`: read `collapsed()`, write `collapsed.set(v)`.                                                                                                                                                                                                                            |
+| `app` / `site` inputs of the internal row components | Now `input.required` signals and must be bound.                                                                                                                                                                                                                                           |
+| Inline `icon` SVG markup                             | Sanitized against a strict SVG allow-list before rendering: `<script>`, `<style>`, `<foreignObject>`, HTML elements, every `on*` handler and any external reference are removed, and markup that changes shape when re-parsed is dropped entirely (the row then falls back to `iconSrc`). |
+
+## Behaviour changes with no call site to migrate
+
+Printed once per run:
+
+- `KbqAppSwitcherModule` no longer provides `FocusTrapFactory` / `FOCUS_TRAP_INERT_STRATEGY`. The app-switcher
+  never rendered a focus trap, and those providers are injector-wide: they disabled the CDK inert strategy for
+  every other focus trap in the same scope. Provide them explicitly where they are actually needed.
+- `defaultGroupBy` identifies a synthetic group by its type name instead of an empty `id`.
+- The popup hides itself when it scrolls out of an ancestor marked `kbq-hide-nested-popup`. The guard that used
+  to suppress this never passed, so the behaviour is effectively new.
+
+## Running it manually
+
+```
+ng generate @koobiq/components:app-switcher-signals --project my-app
+```
+
+Pass `--fix=false` to see what would change without writing files.
+
+## Limitations
+
+Receivers are matched by explicit `KbqAppSwitcherTrigger` type annotation only (no cross-package type
+inference), so aliased or inferred receivers (`const t = this.trigger; t.selectedApp`) are left untouched.
+`selectedSite` is intentionally **not** auto-rewritten because its value semantics changed. After running,
+**always inspect the diff** and act on the warnings before committing.