@koobiq/components 21.0.0 → 21.1.0

package/schematics/migrations/code-block-highlight-js-core/index.cjs

@@ -0,0 +1,319 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var schematics = require('@angular-devkit/schematics');
+var utility = require('@schematics/angular/utility');
+var ts$1 = 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_safeRule = require('../../utils/safe-rule.cjs');
+var migrations_codeBlockHighlightJsCore_data = require('./data.cjs');
+var ts = require('@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript');
+var astUtils = require('@schematics/angular/utility/ast-utils');
+var ngAstUtils = require('@schematics/angular/utility/ng-ast-utils');
+var app_config = require('@schematics/angular/utility/standalone/app_config');
+var util = require('@schematics/angular/utility/standalone/util');
+require('rxjs');
+
+// `@schematics/angular`'s own bundled copy of the TypeScript compiler, not the `typescript` package: the nodes its
+// utilities return were created by it, and `SyntaxKind` values differ between versions.
+const nameOf$1 = (node) => {
+    if (ts.isIdentifier(node))
+        return node.text;
+    if (ts.isPropertyAccessExpression(node))
+        return node.name.text;
+    return undefined;
+};
+const isNamed = (property, name) => !!property.name &&
+    (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) &&
+    property.name.text === name;
+/**
+ * The elements of the `providers` of a configuration or `@NgModule`, none when it declares no providers, or `null` when
+ * `addRootProvider` cannot add one to them safely: it would declare `providers` a second time next to a value that is
+ * not an array literal, leave an `@NgModule` alone, or override the providers of a spread.
+ */
+function providersOf(literal) {
+    if (literal.properties.some(ts.isSpreadAssignment))
+        return null;
+    const providers = literal.properties.find((property) => isNamed(property, 'providers'));
+    if (!providers)
+        return [];
+    return ts.isPropertyAssignment(providers) && ts.isArrayLiteralExpression(providers.initializer)
+        ? providers.initializer.elements
+        : null;
+}
+/**
+ * The root providers of an application, where `addRootProvider` adds one: `null` when it cannot add one there safely,
+ * since it throws on a bootstrap it cannot analyze only after adding the import, and breaks the configuration or does
+ * nothing on providers it cannot extend.
+ */
+async function findRootProviders(tree, project) {
+    try {
+        const mainFilePath = await util.getMainFilePath(tree, project);
+        if (ngAstUtils.isStandaloneApp(tree, mainFilePath)) {
+            const bootstrapCall = util.findBootstrapApplicationCall(tree, mainFilePath);
+            const appConfig = app_config.findAppConfig(bootstrapCall, tree, mainFilePath);
+            // Without a configuration it can read, `addRootProvider` adds one to `bootstrapApplication(App)` only.
+            if (!appConfig)
+                return bootstrapCall.arguments.length === 1 ? [] : null;
+            return providersOf(appConfig.node);
+        }
+        const modulePath = ngAstUtils.getAppModulePath(tree, mainFilePath);
+        const [metadata] = astUtils.getDecoratorMetadata(util.getSourceFile(tree, modulePath), 'NgModule', '@angular/core');
+        return metadata && ts.isObjectLiteralExpression(metadata) ? providersOf(metadata) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Whether a root provider is a highlight.js configuration of the code block. */
+function isHighlightJsConfig(provider) {
+    if (ts.isCallExpression(provider))
+        return nameOf$1(provider.expression) === migrations_codeBlockHighlightJsCore_data.CONFIG_PROVIDER;
+    return (ts.isObjectLiteralExpression(provider) &&
+        provider.properties.some((property) => isNamed(property, 'provide') &&
+            ts.isPropertyAssignment(property) &&
+            nameOf$1(property.initializer) === migrations_codeBlockHighlightJsCore_data.CONFIG_TOKEN));
+}
+
+const LABEL = '[code-block-highlight-js-core]';
+const TS_EXT = '.ts';
+/** Files that render code blocks outside the application, with providers of their own. */
+const TEST_FILE = /\.(spec|test|stories|cy)\.ts$/;
+/** The name of a callee or of a referenced token: `x` for `x` and `ns.x`. */
+const nameOf = (node) => {
+    if (ts$1.isIdentifier(node))
+        return node.text;
+    if (ts$1.isPropertyAccessExpression(node))
+        return node.name.text;
+    return undefined;
+};
+/** The name of a property, `undefined` for a computed one other than a string literal. */
+const propertyName = (property) => {
+    const name = property.name;
+    if (!name)
+        return undefined;
+    if (ts$1.isIdentifier(name) || ts$1.isStringLiteral(name))
+        return name.text;
+    if (ts$1.isComputedPropertyName(name) && ts$1.isStringLiteralLike(name.expression))
+        return name.expression.text;
+    return undefined;
+};
+const findProperty = (literal, name) => literal.properties.find((property) => propertyName(property) === name);
+/** The names a file gives to an export of the code block: its own, and those of `import { name as alias }`. */
+function localNames(sourceFile, exported) {
+    const names = new Set([exported]);
+    for (const statement of sourceFile.statements) {
+        if (!ts$1.isImportDeclaration(statement) || !ts$1.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        if (statement.moduleSpecifier.text !== migrations_codeBlockHighlightJsCore_data.CODE_BLOCK_PACKAGE)
+            continue;
+        const bindings = statement.importClause?.namedBindings;
+        if (!bindings || !ts$1.isNamedImports(bindings))
+            continue;
+        for (const element of bindings.elements) {
+            if ((element.propertyName ?? element.name).text === exported)
+                names.add(element.name.text);
+        }
+    }
+    return names;
+}
+/**
+ * Adds `core: () => import('highlight.js')` to every highlight.js configuration written as an object literal without
+ * `core` - the argument of `kbqCodeBlockHighlightJsConfigProvider` and the `useValue` of a provider of
+ * `KBQ_CODE_BLOCK_HIGHLIGHT_JS_CONFIG` - since the code block loaded the full bundle for it. A configuration it
+ * cannot read, such as a variable, a spread or a factory, is reported rather than guessed at.
+ */
+function migrateSource(content, fileName) {
+    const sourceFile = ts$1.createSourceFile(fileName, content, ts$1.ScriptTarget.Latest, true, ts$1.ScriptKind.TS);
+    const newline = content.includes('\r\n') ? '\r\n' : '\n';
+    const providerNames = localNames(sourceFile, migrations_codeBlockHighlightJsCore_data.CONFIG_PROVIDER);
+    const tokenNames = localNames(sourceFile, migrations_codeBlockHighlightJsCore_data.CONFIG_TOKEN);
+    const edits = [];
+    const unreadLines = [];
+    let configs = 0;
+    const report = (node) => {
+        unreadLines.push(sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1);
+    };
+    const isToken = (node) => !!node && tokenNames.has(nameOf(node) ?? '');
+    const addCore = (config, site) => {
+        configs++;
+        if (!config || !ts$1.isObjectLiteralExpression(config))
+            return report(config ?? site);
+        if (findProperty(config, 'core'))
+            return;
+        // A spread or a computed name may hold `core`.
+        if (config.properties.some((property) => ts$1.isSpreadAssignment(property) || !propertyName(property))) {
+            return report(config);
+        }
+        const [first] = config.properties;
+        const open = config.getStart() + 1;
+        if (!first) {
+            const inner = content.slice(open, config.getEnd() - 1);
+            if (!inner.trim()) {
+                edits.push({ start: config.getStart(), end: config.getEnd(), text: `{ ${migrations_codeBlockHighlightJsCore_data.FULL_BUNDLE_CORE} }` });
+            }
+            else {
+                // A comment is all the literal holds: `core` goes above it.
+                const indent = /\n([ \t]*)\S/.exec(inner)?.[1];
+                edits.push({
+                    start: open,
+                    end: open,
+                    text: indent === undefined ? ` ${migrations_codeBlockHighlightJsCore_data.FULL_BUNDLE_CORE}` : `${newline}${indent}${migrations_codeBlockHighlightJsCore_data.FULL_BUNDLE_CORE}`
+                });
+            }
+            return;
+        }
+        // Above the comments of the first property, which describe it.
+        const [comment] = ts$1.getLeadingCommentRanges(content, first.getFullStart()) ?? [];
+        const start = comment?.pos ?? first.getStart();
+        const indent = content.slice(content.lastIndexOf('\n', start - 1) + 1, start);
+        const separator = /^[ \t]*$/.test(indent) ? `,${newline}${indent}` : ', ';
+        edits.push({ start, end: start, text: migrations_codeBlockHighlightJsCore_data.FULL_BUNDLE_CORE + separator });
+    };
+    // The `useValue` of a provider object; `TestBed.overrideProvider` takes one without `provide`.
+    const addCoreToProvider = (provider, site) => {
+        const useValue = provider && ts$1.isObjectLiteralExpression(provider) && findProperty(provider, 'useValue');
+        addCore(useValue && ts$1.isPropertyAssignment(useValue) ? useValue.initializer : undefined, site);
+    };
+    const visit = (node) => {
+        if (ts$1.isCallExpression(node)) {
+            const callee = nameOf(node.expression);
+            if (callee && providerNames.has(callee)) {
+                addCore(node.arguments[0], node);
+            }
+            else if (callee === 'overrideProvider' && isToken(node.arguments[0])) {
+                addCoreToProvider(node.arguments[1], node);
+            }
+        }
+        else if (ts$1.isObjectLiteralExpression(node)) {
+            const provide = findProperty(node, 'provide');
+            if (provide && ts$1.isPropertyAssignment(provide) && isToken(provide.initializer)) {
+                addCoreToProvider(node, node);
+            }
+        }
+        ts$1.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    let result = content;
+    for (const { start, end, text } of edits.sort((a, b) => b.start - a.start)) {
+        result = result.slice(0, start) + text + result.slice(end);
+    }
+    return { content: result, changed: result !== content, unreadLines, configs };
+}
+/** The directory of a project's sources, as the paths `visitProjectFiles` passes start: `/src`, or `/` for the root. */
+const sourceDir = (project) => `/${(project.sourceRoot ?? project.root).replace(/^\/+|\/+$/g, '')}`;
+const isInside = (path, dir) => dir === '/' || path.startsWith(`${dir}/`);
+const fullBundleProviderRule = (project) => utility.addRootProvider(project, ({ code, external }) => {
+    const provider = external(migrations_codeBlockHighlightJsCore_data.CONFIG_PROVIDER, migrations_codeBlockHighlightJsCore_data.CODE_BLOCK_PACKAGE);
+    return code `${provider}({ ${migrations_codeBlockHighlightJsCore_data.FULL_BUNDLE_CORE} })`;
+});
+/**
+ * Keeps the full highlight.js bundle where the code block loaded it by default: in the root providers of an
+ * application that renders code blocks with no configuration there, and in every configuration without `core`.
+ */
+function codeBlockHighlightJsCore(options) {
+    return async (tree, context) => {
+        // `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(options.project, tree);
+        // The source root rather than the root: the root of the first application can be the workspace root.
+        const rootDir = projectDefinition ? tree.getDir(sourceDir(projectDefinition)) : tree.root;
+        const providerRules = [];
+        let projects = [];
+        let consumers = 0;
+        let touched = 0;
+        try {
+            const workspace = await utility.readWorkspace(tree);
+            projects = [...workspace.projects].map(([name, definition]) => ({
+                name,
+                definition,
+                dir: sourceDir(definition)
+            }));
+        }
+        catch {
+            // The configurations are migrated all the same.
+            utils_messages.logMessage(context.logger, [LABEL, ...migrations_codeBlockHighlightJsCore_data.noWorkspaceMessage()]);
+        }
+        const usingCodeBlock = new Set();
+        const configured = new Set();
+        utils_projectFiles.visitProjectFiles(rootDir, (filePath, entry) => {
+            if (!filePath.endsWith(TS_EXT))
+                return;
+            // The innermost project: one whose sources sit at the workspace root holds the others too.
+            const containing = projects.filter(({ dir }) => isInside(filePath, dir));
+            const depth = Math.max(...containing.map(({ dir }) => dir.length));
+            const owners = containing.filter(({ dir }) => dir.length === depth).map(({ name }) => name);
+            if (options.project && !owners.includes(options.project))
+                return;
+            const original = entry.content.toString();
+            const isTest = TEST_FILE.test(filePath);
+            if (!isTest && original.includes(migrations_codeBlockHighlightJsCore_data.CODE_BLOCK_PACKAGE))
+                owners.forEach((name) => usingCodeBlock.add(name));
+            if (!original.includes(migrations_codeBlockHighlightJsCore_data.CONFIG_PROVIDER) && !original.includes(migrations_codeBlockHighlightJsCore_data.CONFIG_TOKEN))
+                return;
+            const { content, changed, unreadLines, configs } = migrateSource(original, filePath);
+            if (!isTest && configs)
+                owners.forEach((name) => configured.add(name));
+            for (const line of unreadLines) {
+                utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${migrations_codeBlockHighlightJsCore_data.unreadConfigMessage(line)}`]);
+            }
+            if (!changed)
+                return;
+            touched++;
+            if (fix) {
+                tree.overwrite(filePath, content);
+            }
+            else {
+                utils_messages.logMessage(context.logger, [`${LABEL} would update ${filePath} (run with --fix to apply)`]);
+            }
+        });
+        for (const { name, definition } of projects) {
+            if (!usingCodeBlock.has(name) || (options.project && name !== options.project))
+                continue;
+            consumers++;
+            if (definition.extensions['projectType'] !== 'application') {
+                if (!configured.has(name))
+                    utils_messages.logMessage(context.logger, [LABEL, ...migrations_codeBlockHighlightJsCore_data.libraryMessage(name)]);
+                continue;
+            }
+            const rootProviders = await findRootProviders(tree, name);
+            if (!rootProviders) {
+                utils_messages.logMessage(context.logger, [LABEL, ...migrations_codeBlockHighlightJsCore_data.rootProviderFallback(name)]);
+                continue;
+            }
+            // A configuration in the root providers reaches every code block, and has its `core` by now.
+            if (rootProviders.some(isHighlightJsConfig))
+                continue;
+            const messages = [
+                ...migrations_codeBlockHighlightJsCore_data.addedRootProviderMessage(name, fix),
+                ...(configured.has(name) ? migrations_codeBlockHighlightJsCore_data.otherConfigsMessage(name) : [])
+            ];
+            if (!fix) {
+                utils_messages.logMessage(context.logger, [LABEL, ...messages]);
+                continue;
+            }
+            providerRules.push(utils_safeRule.safeRule(schematics.chain([
+                fullBundleProviderRule(name),
+                (_, ruleContext) => utils_messages.logMessage(ruleContext.logger, [LABEL, ...messages])
+            ]), migrations_codeBlockHighlightJsCore_data.rootProviderFallback(name)));
+        }
+        // Nothing here renders code blocks, so the summary would only be noise.
+        if (!consumers && !touched)
+            return;
+        // After the root providers, which say what they added only once it is there.
+        return schematics.chain([
+            ...providerRules,
+            (_, ruleContext) => utils_messages.logMessage(ruleContext.logger, [
+                `${LABEL} ${fix ? 'updated' : 'would update'} ${touched} highlight.js configuration file(s).`,
+                ...migrations_codeBlockHighlightJsCore_data.SUMMARY
+            ])
+        ]);
+    };
+}
+
+exports.default = codeBlockHighlightJsCore;
+exports.migrateSource = migrateSource;

package/schematics/migrations/code-block-highlight-js-core/schema.json

@@ -0,0 +1,20 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "koobiq-components-code-block-highlight-js-core",
+    "title": "Koobiq components code block highlight.js core 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 the rewrites. When false, prints what would change without writing."
+        }
+    }
+}

package/schematics/migrations/code-block-signals/{index.js → index.cjs}

@@ -3,11 +3,12 @@
 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_codeBlockSignals_data = require('./data.js');
+var utils_ast = require('../../utils/ast.cjs');
+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_typescript = require('../../utils/typescript.cjs');
+var migrations_codeBlockSignals_data = require('./data.cjs');
 require('@angular-devkit/schematics');
 require('@schematics/angular/utility');
 
@@ -627,7 +628,7 @@ function codeBlockSignals(options) {
         const rootDir = root ? tree.getDir(root) : tree.root;
         const tsPaths = [];
         const htmlPaths = [];
-        utils_packageConfig.visitProjectFiles(rootDir, (filePath) => {
+        utils_projectFiles.visitProjectFiles(rootDir, (filePath) => {
             if (filePath.endsWith(TS_EXT))
                 tsPaths.push(filePath);
             else if (filePath.endsWith(HTML_EXT))

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

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils_signalMembersMigration = require('../../utils/signal-members-migration.cjs');
+var migrations_colorSignals_data = require('./data.cjs');
+require('typescript');
+require('../../utils/ast.cjs');
+require('../../utils/messages.cjs');
+require('../../utils/package-config.cjs');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+require('../../utils/project-files.cjs');
+require('../../utils/typescript.cjs');
+
+function colorSignals(options) {
+    return utils_signalMembersMigration.signalMembersRule(migrations_colorSignals_data.config, options);
+}
+
+exports.default = colorSignals;

package/schematics/migrations/core-mixins-removal/index.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils_warnOnlyMigration = require('../../utils/warn-only-migration.cjs');
+var migrations_coreMixinsRemoval_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 `mixinDisabled` and `mixinTabIndex`. Never writes. */
+function coreMixinsRemoval(options) {
+    return utils_warnOnlyMigration.warnOnlyRule({ label: '[core-mixins-removal]', warnPatterns: migrations_coreMixinsRemoval_data.warnPatterns, summary: migrations_coreMixinsRemoval_data.SUMMARY }, options);
+}
+
+exports.default = coreMixinsRemoval;

package/schematics/migrations/css-selectors/{index.js → index.cjs}

@@ -3,11 +3,12 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var path = require('path');
-var utils_packageConfig = require('../../package-config-BhU2TfC8.js');
-var migrations_cssSelectors_data = require('./data.js');
+var utils_packageConfig = require('../../utils/package-config.cjs');
+var migrations_cssSelectors_data = require('./data.cjs');
 require('@angular-devkit/schematics');
 require('@schematics/angular/utility');
-require('../../utils/messages.js');
+require('../../utils/messages.cjs');
+require('../../utils/project-files.cjs');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);

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

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils_warnOnlyMigration = require('../../utils/warn-only-migration.cjs');
+var migrations_datepickerSignals_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 subclasses of the datepicker classes and direct calls of their `ngOnChanges`. Never writes. */
+function datepickerSignals(options) {
+    return utils_warnOnlyMigration.warnOnlyRule({ label: '[datepicker-signals]', warnPatterns: migrations_datepickerSignals_data.warnPatterns, summary: migrations_datepickerSignals_data.SUMMARY }, options);
+}
+
+exports.default = datepickerSignals;

package/schematics/migrations/deprecated-icons/README.md

@@ -22,12 +22,24 @@ word/selector-boundary-safe regex rather than real selector parsing — this cor
 directly preceded by `.`, like a real class selector), but a genuine selector spelled out inside a comment is
 still indistinguishable from one that isn't and can still be rewritten.
 
-Two intentional behavior changes from earlier versions of this schematic:
+On an element without an icon directive, the bare `pt-icons` class is renamed to `kbq`, the base class of the
+icon font, so an icon written with classes alone keeps its styles. On an element with `kbq-icon`,
+`kbq-icon-button` or `kbq-icon-item` (plain, bound or valueless) the class is dropped, since the directive adds
+`kbq` itself:
+
+```html
+<!-- before -->
+<i class="pt-icons pt-icons-comment_16 layout-margin-right-s"></i>
+<i kbq-icon="pt-icons-comment_16" class="pt-icons layout-margin-right-s"></i>
+<!-- after -->
+<i class="kbq kbq-message_16 layout-margin-right-s"></i>
+<i kbq-icon="kbq-message_16" class="layout-margin-right-s"></i>
+```
 
-- `class="pt-icons"` (the sole class) now becomes `class=""` rather than removing the `class` attribute
-  entirely.
-- A bare string literal like `'pt-icons word-wrap_16'` now also renames the icon suffix (e.g. to
-  `'wrap-text_16'`), instead of only stripping the scope word.
+A `[class.pt-icons]` binding follows the same rule: dropped on an icon directive's element, `[class.kbq]`
+elsewhere. Outside templates, where there is no element to look at, the class is renamed: a component's
+`host` class, a string literal (`'pt-icons word-wrap_16'` becomes `'kbq wrap-text_16'`) and a stylesheet
+selector.
 
 `fix: false` (the default) never mutates any file — it only reports what it found.
 
@@ -37,8 +49,12 @@ Usage for Angular Cli:
 
 ```shell
 ng g @koobiq/components:deprecated-icons --fix=true --project "<your project>"
+ng g @koobiq/components:deprecated-icons --fix=true --project ./libs
 ```
 
+`--project` takes a project name or a folder; without it the whole workspace is migrated. `node_modules` and
+`dist` are always skipped.
+
 Usage for Nx:
 
 ```shell

package/schematics/migrations/deprecated-icons/{index.js → index.cjs}

@@ -3,14 +3,15 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 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('../../package-config-BhU2TfC8.js');
-var migrations_deprecatedIcons_data = require('./data.js');
+var utils_angularParsing = require('../../utils/angular-parsing.cjs');
+var utils_iconMigration = require('../../utils/icon-migration.cjs');
+var utils_messages = require('../../utils/messages.cjs');
+var utils_packageConfig = require('../../utils/package-config.cjs');
+var utils_projectFiles = require('../../utils/project-files.cjs');
+var migrations_deprecatedIcons_data = require('./data.cjs');
 require('typescript');
-require('../../utils/ast.js');
-require('../../utils/typescript.js');
+require('../../utils/ast.cjs');
+require('../../utils/typescript.cjs');
 require('@angular-devkit/schematics');
 require('@schematics/angular/utility');
 
@@ -37,30 +38,20 @@ const iconsFontImportRule = "@use '@koobiq/icons/fonts/kbq-icons';";
 const migrationData = {
     valueAttrs: ['kbq-icon', 'kbq-icon-item', 'kbq-icon-button'],
     scope: migrations_deprecatedIcons_data.scope,
-    scopeClassInList: 'remove',
+    scopeClassInList: 'rename',
+    scopeClassOnIconHost: 'remove',
     icons: migrations_deprecatedIcons_data.iconsMapping.map(({ replace, replaceWith }) => ({ from: replace, to: replaceWith })),
     rescopeUnknownValues: true
 };
 function deprecatedIcons(options) {
-    let targetDir;
     return async (tree, context) => {
         const { project, fix, stylesExt } = options;
-        try {
-            const projectDefinition = await utils_packageConfig.setupOptions(project, tree);
-            targetDir = projectDefinition ? tree.getDir(projectDefinition.root) : tree;
-        }
-        catch {
-            targetDir = tree;
-        }
+        const targetDir = await utils_packageConfig.resolveTargetDir(project, tree);
         const { logger } = context;
         const tokenMap = utils_iconMigration.buildIconTokenMap(migrationData);
-        // Unlike a `class` list (where the bare scope token is simply dropped, e.g.
-        // `class="pt-icons"` -> `class=""`), a stylesheet selector renames the scope class itself
-        // (e.g. `.pt-icons` -> `.kbq`) rather than removing it.
-        const styleTokenMap = new Map(tokenMap).set(migrationData.scope.from, migrationData.scope.to);
         // Precompiled once and reused across every .ts/style file below, instead of rebuilding
         // every regex per file.
-        const stylePatterns = utils_iconMigration.buildIconTokenPatterns(styleTokenMap, migrationData.scope.from);
+        const stylePatterns = utils_iconMigration.buildIconTokenPatterns(tokenMap, migrationData.scope.from);
         const onFound = (filePath, found) => {
             const parsedFilePath = path__namespace.relative(__dirname, `.${filePath}`).replace(/\\/g, '/');
             utils_messages.logMessage(logger, [
@@ -73,11 +64,7 @@ function deprecatedIcons(options) {
         const templatePaths = [];
         const tsPaths = [];
         const stylePaths = [];
-        // if project property not provided, skip files in node_modules & dist
-        targetDir.visit((filePath) => {
-            if (filePath.includes('node_modules') || filePath.includes('/dist/')) {
-                return;
-            }
+        utils_projectFiles.visitProjectFiles(targetDir, (filePath) => {
             if (filePath.endsWith('.html')) {
                 templatePaths.push(filePath);
             }
@@ -109,8 +96,8 @@ function deprecatedIcons(options) {
             }
         }
         // check if icon styles from new scope should be included in styles file
-        targetDir.visit((filePath, entry) => {
-            if (filePath.endsWith(stylesExt) && !entry?.content.toString()?.includes(iconsFontImportRule)) {
+        utils_projectFiles.visitProjectFiles(targetDir, (filePath, entry) => {
+            if (filePath.endsWith(stylesExt) && !entry.content.toString()?.includes(iconsFontImportRule)) {
                 const parsedFilePath = path__namespace.relative(__dirname, `.${filePath}`).replace(/\\/g, '/');
                 utils_messages.logMessage(logger, [
                     parsedFilePath,

package/schematics/migrations/deprecated-icons/schema.json

@@ -6,7 +6,7 @@
     "properties": {
         "project": {
             "type": "string",
-            "description": "Name of the project",
+            "description": "Name of the project, or a folder to migrate (e.g. ./libs). Without it the whole workspace is migrated",
             "$default": {
                 "$source": "projectName"
             }

package/schematics/migrations/design-tokens-v4/{index.js → index.cjs}

@@ -3,10 +3,11 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var tasks = require('@angular-devkit/schematics/tasks');
-var utils_messages = require('../../utils/messages.js');
-var utils_packageConfig = require('../../package-config-BhU2TfC8.js');
+var utils_messages = require('../../utils/messages.cjs');
+var utils_packageConfig = require('../../utils/package-config.cjs');
 require('@angular-devkit/schematics');
 require('@schematics/angular/utility');
+require('../../utils/project-files.cjs');
 
 const PACKAGE = '@koobiq/design-tokens';
 /** Writes `version` over the entry the project already has, wherever it declared it. */

package/schematics/migrations/divider-signals-and-aria/{index.js → index.cjs}

@@ -3,9 +3,10 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var ts = require('typescript');
-var utils_messages = require('../../utils/messages.js');
-var utils_packageConfig = require('../../package-config-BhU2TfC8.js');
-var migrations_dividerSignalsAndAria_data = require('./data.js');
+var utils_messages = require('../../utils/messages.cjs');
+var utils_packageConfig = require('../../utils/package-config.cjs');
+var utils_projectFiles = require('../../utils/project-files.cjs');
+var migrations_dividerSignalsAndAria_data = require('./data.cjs');
 require('@angular-devkit/schematics');
 require('@schematics/angular/utility');
 
@@ -183,7 +184,7 @@ function dividerSignalsAndAria(options) {
         const rootDir = root ? tree.getDir(root) : tree.root;
         let consumers = 0;
         let reported = 0;
-        utils_packageConfig.visitProjectFiles(rootDir, (filePath, entry) => {
+        utils_projectFiles.visitProjectFiles(rootDir, (filePath, entry) => {
             const isTs = filePath.endsWith(TS_EXT);
             const isHtml = filePath.endsWith(HTML_EXT);
             if (!isTs && !isHtml)

package/schematics/migrations/dl-attribute-coercion/{index.js → index.cjs}

@@ -3,11 +3,12 @@
 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_dlAttributeCoercion_data = require('./data.js');
+var utils_ast = require('../../utils/ast.cjs');
+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_typescript = require('../../utils/typescript.cjs');
+var migrations_dlAttributeCoercion_data = require('./data.cjs');
 require('@angular-devkit/schematics');
 require('@schematics/angular/utility');
 
@@ -126,7 +127,7 @@ function dlAttributeCoercion(options) {
         const root = projectDefinition?.root ?? '';
         const rootDir = root ? tree.getDir(root) : tree.root;
         const paths = [];
-        utils_packageConfig.visitProjectFiles(rootDir, (filePath) => {
+        utils_projectFiles.visitProjectFiles(rootDir, (filePath) => {
             if (filePath.endsWith(TS_EXT) || filePath.endsWith(HTML_EXT))
                 paths.push(filePath);
         });