@koobiq/components 20.4.2 → 21.0.0

package/schematics/migrations/navbar-signals-and-aria/index.js

@@ -0,0 +1,568 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ts = require('typescript');
+var utils_ast = require('../../utils/ast.js');
+var utils_messages = require('../../utils/messages.js');
+var utils_packageConfig = require('../../package-config-BhU2TfC8.js');
+var utils_typescript = require('../../utils/typescript.js');
+var migrations_navbarSignalsAndAria_data = require('./data.js');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+
+const TS_EXT = '.ts';
+const HTML_EXT = '.html';
+const STYLE_EXTS = ['.scss', '.css'];
+const LABEL = '[navbar-signals-and-aria]';
+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;
+}
+const RECEIVER_TYPE_NAMES = new Set([...migrations_navbarSignalsAndAria_data.RECEIVER_TYPES.map(({ type }) => type), migrations_navbarSignalsAndAria_data.RECTANGLE_TYPE]);
+const receiverTypeOf = (typeName) => migrations_navbarSignalsAndAria_data.RECEIVER_TYPES.find(({ type }) => type === typeName);
+/** The navbar class a type annotation refers to, if any. */
+function navbarTypeName(type) {
+    if (!type || !ts.isTypeReferenceNode(type) || !ts.isIdentifier(type.typeName))
+        return undefined;
+    return RECEIVER_TYPE_NAMES.has(type.typeName.text) ? type.typeName.text : undefined;
+}
+const FIELD_MODIFIERS = new Set([
+    ts.SyntaxKind.PrivateKeyword,
+    ts.SyntaxKind.PublicKeyword,
+    ts.SyntaxKind.ProtectedKeyword,
+    ts.SyntaxKind.ReadonlyKeyword
+]);
+/** Nodes that confine a `let`/`const` declared inside them. */
+const isBlockScopeContainer = (node) => ts.isBlock(node) ||
+    ts.isSourceFile(node) ||
+    ts.isModuleBlock(node) ||
+    ts.isCaseBlock(node) ||
+    ts.isForStatement(node) ||
+    ts.isForInStatement(node) ||
+    ts.isForOfStatement(node);
+/**
+ * Scope a local is visible in: a `let`/`const` is confined to its nearest block, a `var` to the whole function.
+ *
+ * Giving a block-scoped local the whole function would let an access elsewhere in that function match it even
+ * where the name refers to a different, shadowing declaration — and be rewritten as if it were the navbar one.
+ */
+function variableScope(node, sourceFile) {
+    const blockScoped = !!(node.parent.flags & ts.NodeFlags.BlockScoped);
+    return findAncestor(node, blockScoped ? isBlockScopeContainer : isFunctionLike) ?? sourceFile;
+}
+/**
+ * Collects the receivers whose static type is one of the navbar classes, by explicit annotation only (no
+ * cross-package type resolution): method/function params, class fields (incl. `@ViewChild(KbqVerticalNavbar) x:
+ * KbqVerticalNavbar` and constructor parameter-properties) and typed locals.
+ *
+ * Params and locals of any other type are collected as well, with no `typeName`. They never trigger a rewrite
+ * themselves; they exist so that a nested declaration reusing a navbar receiver's name is seen as shadowing it.
+ */
+function collectReceivers(sourceFile) {
+    const receivers = [];
+    const add = (text, scope, typeName) => receivers.push({ text, start: scope.getStart(sourceFile), end: scope.getEnd(), typeName });
+    const visit = (node) => {
+        if (ts.isParameter(node) && ts.isIdentifier(node.name)) {
+            const typeName = navbarTypeName(node.type);
+            add(node.name.text, findAncestor(node, isFunctionLike) ?? sourceFile, typeName);
+            // A constructor parameter-property is also a class field, reachable as `this.<name>`.
+            if (typeName && node.modifiers?.some((modifier) => FIELD_MODIFIERS.has(modifier.kind))) {
+                const owner = findAncestor(node, ts.isClassDeclaration);
+                if (owner)
+                    add(`this.${node.name.text}`, owner, typeName);
+            }
+        }
+        else if (ts.isPropertyDeclaration(node) && ts.isIdentifier(node.name)) {
+            const typeName = navbarTypeName(node.type);
+            const owner = typeName && findAncestor(node, ts.isClassDeclaration);
+            if (typeName && owner)
+                add(`this.${node.name.text}`, owner, typeName);
+        }
+        else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+            add(node.name.text, variableScope(node, sourceFile), navbarTypeName(node.type));
+        }
+        node.forEachChild(visit);
+    };
+    visit(sourceFile);
+    return receivers;
+}
+/**
+ * The declaration a property access resolves to, if the access sits inside that declaration's scope.
+ *
+ * The innermost enclosing scope wins: a nested param or local shadows an outer one of the same name, and only
+ * the declaration actually in effect at the access site decides whether this is a navbar receiver at all.
+ */
+function receiverOf(node, sourceFile, receivers) {
+    const receiverText = node.expression.getText(sourceFile);
+    const start = node.getStart(sourceFile);
+    const end = node.getEnd();
+    let innermost;
+    for (const receiver of receivers) {
+        if (receiver.text !== receiverText || start < receiver.start || end > receiver.end)
+            continue;
+        if (!innermost || receiver.start > innermost.start)
+            innermost = receiver;
+    }
+    return innermost;
+}
+/** The navbar receiver a property access resolves to, ignoring declarations of any other type. */
+const navbarReceiverOf = (node, sourceFile, receivers) => {
+    const receiver = receiverOf(node, sourceFile, receivers);
+    return receiver?.typeName ? receiver : undefined;
+};
+/** Whether any collected declaration is actually a navbar receiver. */
+const hasNavbarReceiver = (receivers) => receivers.some(({ typeName }) => !!typeName);
+/** The signal/model method a member access is immediately followed by, if any (`x.expanded.set`). */
+function followedByMethod(node) {
+    const parent = node.parent;
+    return ts.isPropertyAccessExpression(parent) && parent.expression === node ? parent.name.text : undefined;
+}
+/** Whether a property access is the left-hand side of a plain assignment. */
+const assignmentOf = (node) => {
+    const parent = node.parent;
+    return ts.isBinaryExpression(parent) &&
+        parent.left === node &&
+        parent.operatorToken.kind === ts.SyntaxKind.EqualsToken
+        ? parent
+        : undefined;
+};
+/** Classifies a matched property access of a value-safe signal member and appends the resulting edit(s). */
+function classifySignalAccess(node, sourceFile, receiverType, edits) {
+    // Already migrated: `x.expanded()` (call) or `x.expanded.set(…)` — leave alone.
+    if (ts.isCallExpression(node.parent) && node.parent.expression === node)
+        return;
+    const method = followedByMethod(node);
+    if (method && migrations_navbarSignalsAndAria_data.SIGNAL_API_METHODS.has(method))
+        return;
+    const assignment = assignmentOf(node);
+    if (assignment) {
+        // Write target: `x.expanded = RHS` → `x.expanded.set(RHS)`. Only a `model()` can take a write; a plain
+        // `input()` has to be driven by its binding, which the compiler will point out.
+        if (receiverType.writableMembers.includes(node.name.text)) {
+            const rhs = assignment.right;
+            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?.expanded`): append `()`.
+    edits.push({ start: node.getEnd(), end: node.getEnd(), text: '()' });
+}
+/**
+ * Rewrites the two orientation booleans of `KbqNavbarRectangleElement`: `x.horizontal = true` becomes
+ * `x.orientation = 'horizontal'` and a read becomes `x.isHorizontal()`.
+ *
+ * An assignment of anything other than the literal `true` is left alone — `x.horizontal = flag` has no
+ * single-expression equivalent, and the compiler will point at it.
+ */
+function classifyOrientationAccess(node, sourceFile, edits) {
+    const member = node.name.text;
+    const assignment = assignmentOf(node);
+    if (assignment) {
+        const orientation = migrations_navbarSignalsAndAria_data.ORIENTATION_WRITES.get(member);
+        if (!orientation || assignment.right.kind !== ts.SyntaxKind.TrueKeyword)
+            return;
+        edits.push({ start: node.name.getStart(sourceFile), end: node.name.getEnd(), text: 'orientation' });
+        edits.push({
+            start: assignment.right.getStart(sourceFile),
+            end: assignment.right.getEnd(),
+            text: `'${orientation}'`
+        });
+        return;
+    }
+    if (ts.isCallExpression(node.parent) && node.parent.expression === node)
+        return;
+    const read = migrations_navbarSignalsAndAria_data.ORIENTATION_READS.get(member);
+    if (!read)
+        return;
+    edits.push({ start: node.name.getStart(sourceFile), end: node.name.getEnd(), text: `${read}()` });
+}
+/** Collects edits for every access of a migratable member on a known navbar receiver. */
+function collectAccessEdits(sourceFile, receivers) {
+    const edits = [];
+    const visit = (node) => {
+        if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name)) {
+            const receiver = navbarReceiverOf(node, sourceFile, receivers);
+            if (receiver?.typeName === migrations_navbarSignalsAndAria_data.RECTANGLE_TYPE) {
+                classifyOrientationAccess(node, sourceFile, edits);
+            }
+            else if (receiver?.typeName) {
+                const receiverType = receiverTypeOf(receiver.typeName);
+                if (receiverType?.signalMembers.includes(node.name.text)) {
+                    classifySignalAccess(node, sourceFile, receiverType, edits);
+                }
+            }
+        }
+        node.forEachChild(visit);
+    };
+    visit(sourceFile);
+    return edits;
+}
+/** Pass A — rewrite value-safe programmatic accesses of navbar 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 (!hasNavbarReceiver(receivers))
+        return content;
+    const edits = collectAccessEdits(sourceFile, receivers);
+    return edits.length > 0 ? applyEdits(content, edits) : content;
+}
+/** Members needing manual migration, found on a navbar receiver in TypeScript code. */
+function collectManualMembers(content, fileName) {
+    const sourceFile = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const receivers = collectReceivers(sourceFile);
+    const found = new Set();
+    if (!hasNavbarReceiver(receivers))
+        return found;
+    const visit = (node) => {
+        if (ts.isPropertyAccessExpression(node) &&
+            ts.isIdentifier(node.name) &&
+            migrations_navbarSignalsAndAria_data.MANUAL_MEMBERS.has(node.name.text) &&
+            navbarReceiverOf(node, sourceFile, receivers)) {
+            found.add(node.name.text);
+        }
+        node.forEachChild(visit);
+    };
+    visit(sourceFile);
+    return found;
+}
+/** All `exportAs` values a template reference variable can point a navbar at. */
+const EXPORT_AS_TO_TYPE = new Map(migrations_navbarSignalsAndAria_data.RECEIVER_TYPES.filter(({ exportAs }) => !!exportAs).map(({ exportAs, type }) => [exportAs, type]));
+/** Collects template reference variables exported as one of the navbar directives. */
+class NavbarRefCollector {
+    constructor() {
+        /** Reference variable name → the navbar class it points at. */
+        this.refs = new Map();
+    }
+    visitElement(element) {
+        for (const attr of element.attrs ?? []) {
+            if (typeof attr.name !== 'string')
+                continue;
+            const type = EXPORT_AS_TO_TYPE.get(attr.value);
+            if (!type)
+                continue;
+            if (attr.name.startsWith('#'))
+                this.refs.set(attr.name.slice(1), type);
+            else if (attr.name.startsWith('ref-'))
+                this.refs.set(attr.name.slice(4), type);
+        }
+        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() { }
+}
+/** `x`, `[x]`, `bind-x` and `i18n-x` all name the same attribute. */
+function attributeName(name) {
+    return utils_ast.getSimpleAttributeName(name).replace(/^(?:bind|i18n)-/, '');
+}
+const isTooltipTextHost = (element) => migrations_navbarSignalsAndAria_data.TOOLTIP_TEXT_HOSTS.includes(element.name) ||
+    (element.attrs ?? []).some((attr) => typeof attr.name === 'string' && migrations_navbarSignalsAndAria_data.TOOLTIP_TEXT_HOSTS.includes(attributeName(attr.name)));
+/** Collects the renames of `kbqTooltip` to `tooltipText` on navbar items and brands, keeping the binding syntax. */
+class TooltipTextRenameCollector {
+    constructor() {
+        this.edits = [];
+    }
+    visitElement(element) {
+        if (isTooltipTextHost(element)) {
+            for (const attr of element.attrs ?? []) {
+                if (typeof attr.name !== 'string' || attributeName(attr.name) !== migrations_navbarSignalsAndAria_data.TOOLTIP_TEXT_RENAME.from)
+                    continue;
+                const { start, end } = attr.keySpan ?? {};
+                // The key span covers the name exactly as written; any other length would splice the wrong text.
+                if (!start || !end || end.offset - start.offset !== attr.name.length)
+                    continue;
+                this.edits.push({
+                    start: start.offset,
+                    end: end.offset,
+                    text: attr.name.replace(migrations_navbarSignalsAndAria_data.TOOLTIP_TEXT_RENAME.from, migrations_navbarSignalsAndAria_data.TOOLTIP_TEXT_RENAME.to)
+                });
+            }
+        }
+        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() { }
+}
+/**
+ * Matches `<ref>.<member>` where the access is neither already a call, a signal-API call, nor the left-hand
+ * side of an assignment (`\b` after the member keeps `expanded` from matching inside `expandedChange`).
+ *
+ * A template can only *read* a signal member this way — rewriting `ref.expanded = value` blindly into
+ * `ref.expanded() = value` would replace a valid assignment with invalid syntax, since a call expression is
+ * not assignable. Such assignments are reported separately (see `collectRefWriteWarnings`) instead of touched.
+ */
+function memberAccessPattern(ref, members) {
+    const methods = [...migrations_navbarSignalsAndAria_data.SIGNAL_API_METHODS].join('|');
+    return new RegExp(`\\b(${escapeRegExp(ref)})\\.(${members.join('|')})\\b(?!\\s*\\()(?!\\s*\\.\\s*(?:${methods})\\b)(?!\\s*=(?!=))`, 'g');
+}
+/** Matches a plain assignment `<ref>.<member> =` (not `==`/`===`) to one of the ref's writable members. */
+function refAssignmentPattern(ref, members) {
+    return new RegExp(`\\b${escapeRegExp(ref)}\\.(${members.join('|')})\\b\\s*=(?!=)`, 'g');
+}
+/** Rewrites `ref.expanded` reads to `ref.expanded()` for every navbar reference variable. */
+function rewriteRefReads(template, refs) {
+    let content = template;
+    let changed = false;
+    for (const [ref, typeName] of refs) {
+        const members = receiverTypeOf(typeName)?.signalMembers;
+        if (!members?.length)
+            continue;
+        const next = content.replace(memberAccessPattern(ref, members), '$1.$2()');
+        if (next !== content) {
+            content = next;
+            changed = true;
+        }
+    }
+    return { content, changed };
+}
+/**
+ * Writable-member assignments made through a template reference variable: `ref.expanded = value`. Unlike a
+ * programmatic write (rewritten to `.set(…)` by `classifySignalAccess`), a template can only bind or read
+ * through a ref — there is no single-expression rewrite of an assignment target into a call — so these are
+ * left untouched and reported for manual migration instead.
+ */
+function collectRefWriteWarnings(template, refs) {
+    const found = new Set();
+    for (const [ref, typeName] of refs) {
+        const writable = receiverTypeOf(typeName)?.writableMembers;
+        if (!writable?.length)
+            continue;
+        for (const match of template.matchAll(refAssignmentPattern(ref, writable))) {
+            found.add(match[1]);
+        }
+    }
+    return found;
+}
+/** Members needing manual migration, read through a navbar reference variable in a template. */
+function collectRefManualMembers(template, refs) {
+    const members = [...migrations_navbarSignalsAndAria_data.MANUAL_MEMBERS.keys()];
+    const found = new Set();
+    for (const ref of refs.keys()) {
+        // `\bref\.(member)\b` — a template can only read these, so no call/method exclusions are needed.
+        const pattern = new RegExp(`\\b${escapeRegExp(ref)}\\.(${members.join('|')})\\b`, 'g');
+        for (const match of template.matchAll(pattern)) {
+            found.add(match[1]);
+        }
+    }
+    return found;
+}
+const untouched = (template) => ({
+    content: template,
+    changed: false,
+    manual: new Set(),
+    writeWarnings: new Set(),
+    unparseable: false
+});
+const namesNavbarExportAs = (template) => [...EXPORT_AS_TO_TYPE.keys()].some((exportAs) => template.includes(exportAs));
+const namesTooltipTextHost = (template) => template.includes(migrations_navbarSignalsAndAria_data.TOOLTIP_TEXT_RENAME.from) && migrations_navbarSignalsAndAria_data.TOOLTIP_TEXT_HOSTS.some((host) => template.includes(host));
+/**
+ * Pass B (core) — parse a template, rename `kbqTooltip` on navbar hosts, discover navbar refs and rewrite their
+ * value-safe reads.
+ */
+async function migrateTemplate(template) {
+    if (!namesNavbarExportAs(template) && !namesTooltipTextHost(template))
+        return untouched(template);
+    const parsed = await utils_typescript.parseTemplate(template);
+    if (!parsed.tree)
+        return { ...untouched(template), unparseable: true };
+    const rootNodes = parsed.tree.rootNodes;
+    const renames = new TooltipTextRenameCollector();
+    const collector = new NavbarRefCollector();
+    utils_ast.visitAll(renames, rootNodes);
+    utils_ast.visitAll(collector, rootNodes);
+    // A rename touches only an attribute name, never a reference variable or an expression, so the reads below
+    // are found in the renamed text exactly as in the original.
+    const renamed = applyEdits(template, renames.edits);
+    const isRenamed = renamed !== template;
+    if (collector.refs.size === 0)
+        return { ...untouched(renamed), changed: isRenamed };
+    const reads = rewriteRefReads(renamed, collector.refs);
+    return {
+        content: reads.content,
+        changed: reads.changed || isRenamed,
+        manual: collectRefManualMembers(renamed, collector.refs),
+        writeWarnings: collectRefWriteWarnings(renamed, collector.refs),
+        unparseable: false
+    };
+}
+/** Pass B (inline) — the same rewrites inside inline component templates. */
+async function migrateInlineTemplates(content, fileName) {
+    const sourceFile = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const manual = new Set();
+    const writeWarnings = new Set();
+    let result = content;
+    let unparseable = false;
+    // Splice right-to-left so earlier offsets stay valid.
+    for (const { start, end } of utils_typescript.collectInlineTemplateRanges(sourceFile).sort((a, b) => b.start - a.start)) {
+        const migrated = await migrateTemplate(result.slice(start, end));
+        migrated.manual.forEach((member) => manual.add(member));
+        migrated.writeWarnings.forEach((member) => writeWarnings.add(member));
+        unparseable ||= migrated.unparseable;
+        if (migrated.changed) {
+            result = result.slice(0, start) + migrated.content + result.slice(end);
+        }
+    }
+    return { content: result, manual, writeWarnings, unparseable };
+}
+function logPatternWarnings(context, filePath, content, patterns) {
+    for (const { pattern, message } of patterns) {
+        if (new RegExp(pattern).test(content)) {
+            utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${message}`]);
+        }
+    }
+}
+function logManualMembers(context, filePath, members) {
+    for (const member of members) {
+        utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${migrations_navbarSignalsAndAria_data.MANUAL_MEMBERS.get(member)}`]);
+    }
+}
+function logRefWriteWarnings(context, filePath, members) {
+    for (const member of members) {
+        utils_messages.logMessage(context.logger, [
+            `${LABEL} ${filePath}`,
+            `  Assigning to \`${member}\` through a template reference variable was left untouched — a template ` +
+                `can only rewrite a read this way. Change \`ref.${member} = value\` to \`ref.${member}.set(value)\`.`
+        ]);
+    }
+}
+/**
+ * A `.ts` file is a navbar consumer if it names one of its symbols, imports the package or has an item or brand in
+ * an inline template — a component declared in an NgModule gets the navbar without naming it.
+ */
+function referencesNavbar(content) {
+    return (/\bKbq(?:Vertical)?Navbar\w*\b/.test(content) ||
+        content.includes('@koobiq/components/navbar') ||
+        migrations_navbarSignalsAndAria_data.TOOLTIP_TEXT_HOSTS.some((host) => content.includes(host)));
+}
+function navbarSignalsAndAria(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 = [];
+        const stylePaths = [];
+        utils_packageConfig.visitProjectFiles(rootDir, (filePath) => {
+            if (filePath.endsWith(TS_EXT))
+                tsPaths.push(filePath);
+            else if (filePath.endsWith(HTML_EXT))
+                htmlPaths.push(filePath);
+            else if (STYLE_EXTS.some((ext) => filePath.endsWith(ext)))
+                stylePaths.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, [`${LABEL} would update ${filePath} (run with --fix to apply)`]);
+            }
+        };
+        for (const filePath of tsPaths) {
+            const original = tree.read(filePath)?.toString();
+            if (!original || !referencesNavbar(original))
+                continue;
+            const withExpressions = migrateTsExpressions(original, filePath);
+            const inline = await migrateInlineTemplates(withExpressions, filePath);
+            const content = inline.content;
+            // Warn on what is left over, so an auto-fixed usage does not also produce a "manual migration
+            // required" note. In dry-run mode the fix is not written, so report against the original.
+            const reported = fix ? content : original;
+            logPatternWarnings(context, filePath, reported, migrations_navbarSignalsAndAria_data.tsWarnPatterns);
+            logManualMembers(context, filePath, collectManualMembers(reported, filePath));
+            logManualMembers(context, filePath, inline.manual);
+            logRefWriteWarnings(context, filePath, inline.writeWarnings);
+            if (inline.unparseable) {
+                utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${migrations_navbarSignalsAndAria_data.UNPARSEABLE_TEMPLATE_MESSAGE}`]);
+            }
+            commit(filePath, original, content);
+        }
+        for (const filePath of htmlPaths) {
+            const original = tree.read(filePath)?.toString();
+            if (!original)
+                continue;
+            const migrated = await migrateTemplate(original);
+            logManualMembers(context, filePath, migrated.manual);
+            logRefWriteWarnings(context, filePath, migrated.writeWarnings);
+            if (migrated.unparseable) {
+                utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${migrations_navbarSignalsAndAria_data.UNPARSEABLE_TEMPLATE_MESSAGE}`]);
+            }
+            if (migrated.changed)
+                commit(filePath, original, migrated.content);
+        }
+        for (const filePath of stylePaths) {
+            const original = tree.read(filePath)?.toString();
+            if (!original)
+                continue;
+            logPatternWarnings(context, filePath, original, migrations_navbarSignalsAndAria_data.styleWarnPatterns);
+        }
+        utils_messages.logMessage(context.logger, [
+            `${LABEL} processed tree under "${root || '<workspace root>'}", ` +
+                `${fix ? 'updated' : 'would update'} ${touched} file(s).`,
+            '',
+            ...migrations_navbarSignalsAndAria_data.BEHAVIOUR_NOTE
+        ]);
+    };
+}
+
+exports.default = navbarSignalsAndAria;

package/schematics/migrations/navbar-signals-and-aria/schema.json

@@ -0,0 +1,20 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "koobiq-components-navbar-signals-and-aria",
+    "title": "Koobiq components navbar signals and aria 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/new-icons-pack/README.md

@@ -70,17 +70,17 @@ The schema definition can be found in [`schema.ts`](schema.ts).
 #### Angular CLI
 
 ```shell
-ng g @koobiq/components:new-icons-pack --fix=true --project <your project>
+ng g @koobiq/components:new-icons-pack --fix=true --project "<your project>"
 ```
 
 #### Angular CLI with custom data
 
 ```shell
 ng g @koobiq/components:new-icons-pack \
-  --custom-data-path migration.json \
-  --custom-icon-replacement-path my-replacement.json \
-  --fix=true \
-  --project <your-project>
+    --custom-data-path migration.json \
+    --custom-icon-replacement-path my-replacement.json \
+    --fix=true \
+    --project "<your-project>"
 ```
 
 `migration.json` is the shipped icon-name mapping and can be used as-is. `my-replacement.json` is a file you
@@ -90,15 +90,15 @@ write yourself, in the new bare scope-word-pair shape described above — **not*
 #### Nx
 
 ```shell
-nx g @koobiq/components:new-icons-pack --fix=true --project <your project>
+nx g @koobiq/components:new-icons-pack --fix=true --project "<your project>"
 ```
 
 #### Nx with custom data
 
 ```shell
 nx g @koobiq/components:new-icons-pack \
---custom-data-path migration.json \
---custom-icon-replacement-path my-replacement.json \
---fix=true \
---project <your-project>
+    --custom-data-path migration.json \
+    --custom-icon-replacement-path my-replacement.json \
+    --fix=true \
+    --project "<your-project>"
 ```

package/schematics/migrations/new-icons-pack/index.js

@@ -7,7 +7,7 @@ var path = require('path');
 var utils_angularParsing = require('../../utils/angular-parsing.js');
 var utils_iconMigration = require('../../utils/icon-migration.js');
 var utils_messages = require('../../utils/messages.js');
-var utils_packageConfig = require('../../utils/package-config.js');
+var utils_packageConfig = require('../../package-config-BhU2TfC8.js');
 var migrations_newIconsPack_data = require('./data.js');
 require('typescript');
 require('../../utils/ast.js');