@koobiq/components 20.2.0 → 20.3.0

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

@@ -1,11 +1,36 @@
-### New Icons Pack schematics
+### Deprecated Icons schematics
 
-This schematic provides migration for update icons pack. It includes:
+This schematic provides migration away from the deprecated `pt-icons` scope. It includes:
 
-- Change prefixes from `mc` to `kbq` for ts, html, styles
-- Update icon names for updated/removed icons according to [mapping](data.ts)
+- Change the `pt-icons` scope/prefix to `kbq` in `class` attributes, `kbq-icon`/`kbq-icon-item`/`kbq-icon-button`
+  attribute values, `[class.pt-icons-*]` bindings, and bare string literals — for TS, HTML, and styles
+- Update icon names for deprecated icons according to [mapping](data.ts)
 - Fix icons package prefix in styles
 
+Matching is AST-based (parsed HTML/TypeScript, not whole-file text search), so it only touches genuine icon
+usages — e.g. a component selector, a `[class]` binding expression, or an unrelated class/variable that merely
+contains the substring `pt-icons` is left alone. It also covers a component's inline `host` class bindings and
+inline `styles` array, and icons inside ICU expansions (`{count, plural, ...}`). A bound attribute value that
+isn't a single quoted literal (a dynamic expression, a concatenation, or `{{ }}` interpolation) can't be
+resolved statically — it's reported as a warning rather than migrated or silently corrupted. An icon whose
+scope prefix was already swapped to `kbq-` by an earlier run (e.g. `kbq-icon="kbq-add-to-list_16"`) still gets
+its name corrected.
+
+One documented exception: in style files there's no CSS/SCSS parser, so token matching is a
+word/selector-boundary-safe regex rather than real selector parsing — this correctly ignores
+`.my-widget-pt-icons-preview`, `$pt-icons`, and `@import 'pt-icons'` (the bare scope word only matches when
+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:
+
+- `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.
+
+`fix: false` (the default) never mutates any file — it only reports what it found.
+
 [Params](schema.ts)
 
 Usage for Angular Cli:

package/schematics/migrations/deprecated-icons/data.js

@@ -1,5 +1,9 @@
 'use strict';
 
+/**
+ * @deprecated Unused by this migration. Kept only so external code importing this array doesn't
+ * break. Use `scope` below instead.
+ */
 const iconClassReplacements = [
     { replace: 'kbq-icon="pt-icons-', replaceWith: 'kbq-icon="kbq-' },
     { replace: 'pt-icons-', replaceWith: 'kbq-' },
@@ -9,6 +13,8 @@ const iconClassReplacements = [
     { replace: "'pt-icons ", replaceWith: "'" },
     { replace: '\\.pt-icons', replaceWith: '.kbq' }
 ];
+/** Old scope prefix and its replacement, used to build the migration's icon token map. */
+const scope = { from: 'pt-icons', to: 'kbq' };
 const iconsMapping = [
     {
         replace: 'add-to-list_16',
@@ -1578,3 +1584,4 @@ const iconsMapping = [
 
 exports.iconClassReplacements = iconClassReplacements;
 exports.iconsMapping = iconsMapping;
+exports.scope = scope;

package/schematics/migrations/deprecated-icons/index.js

@@ -3,9 +3,14 @@
 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('../../utils/package-config.js');
 var migrations_deprecatedIcons_data = require('./data.js');
+require('typescript');
+require('../../utils/ast.js');
+require('../../utils/typescript.js');
 require('@angular-devkit/schematics');
 require('@schematics/angular/utility');
 
@@ -29,6 +34,13 @@ function _interopNamespaceDefault(e) {
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 
 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',
+    icons: migrations_deprecatedIcons_data.iconsMapping.map(({ replace, replaceWith }) => ({ from: replace, to: replaceWith })),
+    rescopeUnknownValues: true
+};
 function deprecatedIcons(options) {
     let targetDir;
     return async (tree, context) => {
@@ -41,46 +53,61 @@ function deprecatedIcons(options) {
             targetDir = tree;
         }
         const { logger } = context;
-        const handleDeprecatedIcons = (newContent, filePath) => {
-            if (fix) {
-                migrations_deprecatedIcons_data.iconsMapping.forEach(({ replace, replaceWith }) => {
-                    newContent = newContent.replace(new RegExp(`kbq-${replace}`, 'g'), `kbq-${replaceWith}`);
-                });
-            }
-            else {
-                const foundIcons = migrations_deprecatedIcons_data.iconsMapping.filter(({ replace }) => newContent.indexOf(replace) !== -1);
-                if (foundIcons.length) {
-                    const parsedFilePath = path__namespace.relative(__dirname, `.${filePath}`).replace(/\\/g, '/');
-                    utils_messages.logMessage(logger, [
-                        `Please pay attention! Found deprecated icons in file: `,
-                        parsedFilePath,
-                        foundIcons.map(({ replace, replaceWith }) => `\t${replace} -> \t${replaceWith}`).join('\n')
-                    ]);
-                }
-            }
-            return newContent;
+        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 onFound = (filePath, found) => {
+            const parsedFilePath = path__namespace.relative(__dirname, `.${filePath}`).replace(/\\/g, '/');
+            utils_messages.logMessage(logger, [
+                `Please pay attention! Found deprecated icons in file: `,
+                parsedFilePath,
+                found.map(({ from, to }) => `\t${from} -> \t${to}`).join('\n')
+            ]);
         };
-        // Update styles, templates & components
-        targetDir.visit((filePath, entry) => {
-            let initialContent;
-            // if project property not provided, skip files in node_modules & dist
-            if (filePath.includes('node_modules') || filePath.includes('dist')) {
+        const warn = (message) => logger.warn(message);
+        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;
             }
-            if (filePath.endsWith('.html') || filePath.endsWith('.ts') || filePath.endsWith(stylesExt)) {
-                initialContent = entry?.content.toString();
-                let newContent = initialContent;
-                if (newContent) {
-                    migrations_deprecatedIcons_data.iconClassReplacements.forEach(({ replace, replaceWith }) => {
-                        newContent = newContent.replace(new RegExp(replace, 'g'), replaceWith);
-                    });
-                    newContent = handleDeprecatedIcons(newContent, filePath);
-                    if (initialContent !== newContent) {
-                        tree.overwrite(filePath, newContent || '');
-                    }
-                }
+            if (filePath.endsWith('.html')) {
+                templatePaths.push(filePath);
+            }
+            else if (filePath.endsWith('.ts') &&
+                !filePath.endsWith('.d.ts') &&
+                !filePath.endsWith('.ngtypecheck.ts')) {
+                tsPaths.push(filePath);
+            }
+            else if (filePath.endsWith(stylesExt)) {
+                stylePaths.push(filePath);
             }
         });
+        // Update external html
+        await utils_angularParsing.migrateTemplateWithTransform(tree, templatePaths, context, utils_iconMigration.createIconTemplateTransform(migrationData, tokenMap, { fix, onFound, warn }));
+        // Update inline html & bare string literals in components
+        await utils_iconMigration.migrateIconsInTsFiles(tree, tsPaths, context, migrationData, tokenMap, { fix, onFound, warn }, stylePatterns);
+        // Update styles
+        for (const filePath of stylePaths) {
+            const initialContent = tree.read(filePath)?.toString();
+            if (!initialContent) {
+                continue;
+            }
+            const { content, changed, found } = utils_iconMigration.replaceKnownIconTokens(initialContent, stylePatterns, fix);
+            if (found.length && !fix) {
+                onFound(filePath, found);
+            }
+            if (changed) {
+                tree.overwrite(filePath, content);
+            }
+        }
         // 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)) {

package/schematics/migrations/new-icons-pack/README.md

@@ -7,6 +7,37 @@ This schematic provides migration for update icons pack. It includes:
 - Fix icons package prefix in styles
 - Optionally use custom migration and replacement data
 
+Matching is AST-based (parsed HTML/TypeScript, not whole-file text search), so it only touches genuine icon
+usages — a component selector like `<mc-button>`, a `[class]` binding expression, an unrelated class such as
+`.mc-panel-header`, or an unrelated string like `'mc-legacy-mode'` are all left untouched. It also covers a
+component's inline `host` class bindings and inline `styles` array, and icons inside ICU expansions
+(`{count, plural, ...}`). A bound attribute value that isn't a single quoted literal (a dynamic expression, a
+concatenation, or `{{ }}` interpolation) can't be resolved statically — it's reported as a warning rather than
+migrated or silently corrupted. An icon whose prefix was already swapped to `kbq-` by an earlier run (e.g.
+`kbq-icon="kbq-add-to-list_16"`) still gets its name corrected.
+
+One documented exception: in style files (and `.md` docs) there's no CSS/SCSS parser, so token matching is a
+word/selector-boundary-safe regex rather than real selector parsing — this correctly ignores `.my-mc-widget`,
+`$mc`, and `@import 'mc'` (the bare scope word only matches when 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.
+
+`fix: false` (the default) never mutates any file — it only reports what it found. Icon-_name_ renames (e.g.
+`mc-add-to-list_16`/`kbq-add-to-list_16` → the current `kbq-file-plus-o_16`) always apply in styles/`.md`
+regardless of `updatePrefix`; the option only gates the _bare_ scope-word rename (`mc` → `kbq`) there. In
+templates/TS, icon-attribute values are always matched regardless of `updatePrefix`.
+
+#### `--custom-icon-replacement-path`
+
+The expected file shape changed. It's still a JSON array of `{ "replace": ..., "replaceWith": ... }` objects,
+but each entry is now interpreted as a bare scope-word pair (e.g. `{ "replace": "mc", "replaceWith": "kbq" }`,
+with no leading/trailing hyphen) rather than a whole-file regex fragment like `kbq-icon="mc-` — the AST-based
+matcher no longer needs per-context fragments. A file still written in the old fragment style, or a malformed
+one, is detected and ignored with a warning (falling back to the default `mc` → `kbq` scope) rather than being
+silently misapplied or crashing. [`replacement.json`](replacement.json) is kept in its old fragment shape for
+backward compatibility with anyone already pointing at it — **don't** pass it via `--custom-icon-replacement-path`
+as-is (see the fallback warning above); copy it into your own file and rewrite it in the new shape instead.
+
 ---
 
 ### Parameters
@@ -47,11 +78,15 @@ ng g @koobiq/components:new-icons-pack --fix=true --project <your project>
 ```shell
 ng g @koobiq/components:new-icons-pack \
   --custom-data-path migration.json \
-  --custom-icon-replacement-path replacement.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
+write yourself, in the new bare scope-word-pair shape described above — **not** the shipped
+[`replacement.json`](replacement.json), which is still in the legacy shape.
+
 #### Nx
 
 ```shell
@@ -63,7 +98,7 @@ nx g @koobiq/components:new-icons-pack --fix=true --project <your project>
 ```shell
 nx g @koobiq/components:new-icons-pack \
 --custom-data-path migration.json \
---custom-icon-replacement-path replacement.json \
+--custom-icon-replacement-path my-replacement.json \
 --fix=true \
 --project <your-project>
 ```

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

@@ -1,5 +1,10 @@
 'use strict';
 
+/**
+ * @deprecated Unused by this migration. Kept only so external code importing this array doesn't
+ * break, and so a `customIconReplacementPath` file still written in this shape can be detected and
+ * warned about (see `resolveScope` in `./index.ts`). Use `scope` below instead.
+ */
 const iconReplacements = [
     { replace: 'kbq-icon="mc-', replaceWith: 'kbq-icon="kbq-' },
     { replace: 'kbq-icon-item="mc-', replaceWith: 'kbq-icon-item="kbq-' },
@@ -12,6 +17,8 @@ const iconReplacements = [
     { replace: "'mc-", replaceWith: "'kbq-" },
     { replace: `\\.mc;`, replaceWith: `.kbq;` }
 ];
+/** Old scope prefix and its replacement, used to build the migration's icon token map. */
+const scope = { from: 'mc', to: 'kbq' };
 const newIconsPackData = [
     {
         replaceWith: 'kbq-3-columns_32',
@@ -2301,3 +2308,4 @@ const newIconsPackData = [
 
 exports.iconReplacements = iconReplacements;
 exports.newIconsPackData = newIconsPackData;
+exports.scope = scope;

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

@@ -4,9 +4,14 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var fs = require('fs');
 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 migrations_newIconsPack_data = require('./data.js');
+require('typescript');
+require('../../utils/ast.js');
+require('../../utils/typescript.js');
 require('@angular-devkit/schematics');
 require('@schematics/angular/utility');
 
@@ -34,14 +39,59 @@ function readJsonFile(filePath) {
     const fileContents = fs.readFileSync(absolutePath, 'utf-8');
     return JSON.parse(fileContents);
 }
+// A bare word: no leading/trailing hyphen, no empty hyphen-separated segment (rejects e.g. `mc-`,
+// which is otherwise the most natural — and wrong, per the new engine's key-building — way to
+// write a "prefix" pair).
+const BARE_SCOPE_WORD = /^\w+(-\w+)*$/;
+/** `newIconsPackData`/`migration.json` always author their `replace`/`replaceWith` pair under
+ *  this literal scope — independent of whatever scope the user is migrating *to* via
+ *  `customIconReplacementPath` — so it's always the first prefix stripped. */
+const CANONICAL_ICON_DATA_SCOPE = 'kbq';
+/** Strips a known scope prefix (e.g. `mc-`/`kbq-`) from a token, if present. */
+function stripScopePrefix(value, prefixes) {
+    for (const prefix of prefixes) {
+        if (value.startsWith(`${prefix}-`)) {
+            return value.slice(prefix.length + 1);
+        }
+    }
+    return value;
+}
+function isBareScopePair(entry) {
+    return (typeof entry?.replace === 'string' &&
+        typeof entry?.replaceWith === 'string' &&
+        BARE_SCOPE_WORD.test(entry.replace) &&
+        BARE_SCOPE_WORD.test(entry.replaceWith));
+}
+/**
+ * Resolves the scope pair from a `customIconReplacementPath` file: a bare scope-word pair (e.g.
+ * `{ "replace": "mc", "replaceWith": "kbq" }`). A legacy-shaped or malformed entry is detected and
+ * warned about instead of silently misapplied — or crashed on.
+ */
+function resolveScope(entries, fallback, logger) {
+    if (!Array.isArray(entries)) {
+        logger.warn('customIconReplacementPath must contain a JSON array of { "replace", "replaceWith" } entries. ' +
+            'Falling back to the default scope.');
+        return fallback;
+    }
+    const valid = entries.find(isBareScopePair);
+    if (!valid) {
+        if (entries.length) {
+            logger.warn('customIconReplacementPath entries look like the legacy fragment format and were ignored. ' +
+                'See new-icons-pack/README.md for the new expected shape (e.g. { "replace": "mc", "replaceWith": "kbq" }).');
+        }
+        return fallback;
+    }
+    return { from: valid.replace, to: valid.replaceWith };
+}
 function newIconsPack(options) {
     let targetDir;
     return async (tree, context) => {
         const { project, fix, stylesExt, updatePrefix = true, customDataPath, customIconReplacementPath } = options;
+        const { logger } = context;
         const resolvedData = customDataPath ? readJsonFile(customDataPath) : migrations_newIconsPack_data.newIconsPackData;
-        const resolvedIconsReplacements = customIconReplacementPath
-            ? readJsonFile(customIconReplacementPath)
-            : migrations_newIconsPack_data.iconReplacements;
+        const resolvedScope = customIconReplacementPath
+            ? resolveScope(readJsonFile(customIconReplacementPath), migrations_newIconsPack_data.scope, logger)
+            : migrations_newIconsPack_data.scope;
         try {
             const projectDefinition = await utils_packageConfig.setupOptions(project, tree);
             targetDir = projectDefinition ? tree.getDir(projectDefinition.root) : tree;
@@ -49,65 +99,106 @@ function newIconsPack(options) {
         catch {
             targetDir = tree;
         }
-        const { logger } = context;
-        const handleDeprecatedIcons = (newContent, filePath) => {
-            if (fix) {
-                resolvedData.forEach(({ replace, replaceWith }) => {
-                    newContent = newContent.replace(new RegExp(replace, 'g'), replaceWith);
-                });
-            }
-            else {
-                const foundIcons = resolvedData.filter(({ replace }) => newContent.indexOf(replace) !== -1);
-                if (foundIcons.length) {
-                    const parsedFilePath = path__namespace.relative(__dirname, `.${filePath}`).replace(/\\/g, '/');
-                    utils_messages.logMessage(logger, [
-                        `Please pay attention! Found deprecated icons in file: `,
-                        parsedFilePath,
-                        foundIcons.map(({ replace, replaceWith }) => `\t${replace} -> \t${replaceWith}`).join('\n')
-                    ]);
-                }
-            }
-            return newContent;
+        const migrationData = {
+            valueAttrs: ['kbq-icon', 'kbq-icon-item', 'kbq-icon-button'],
+            scope: resolvedScope,
+            scopeClassInList: 'rename',
+            // `replace`/`replaceWith` are always authored under `CANONICAL_ICON_DATA_SCOPE`
+            // ('kbq-'), regardless of the scope this run is migrating *to* — falls back to
+            // stripping the target scope for a custom data file that doesn't follow that
+            // convention.
+            icons: resolvedData.map(({ replace, replaceWith }) => ({
+                from: stripScopePrefix(replace, [CANONICAL_ICON_DATA_SCOPE, resolvedScope.to, resolvedScope.from]),
+                to: stripScopePrefix(replaceWith, [CANONICAL_ICON_DATA_SCOPE, resolvedScope.to])
+            })),
+            // Only the attribute-value path (`kbq-icon="mc-<anything>"`) rescopes suffixes that
+            // aren't a known icon name; class lists/bindings/strings/styles stay exact-token-only.
+            // This runs unconditionally in templates/TS — `updatePrefix` only gates the bare
+            // scope-word rename in the (separate, unscoped-by-nature) styles/markdown pass below.
+            rescopeUnknownValues: true
         };
+        const tokenMap = utils_iconMigration.buildIconTokenMap(migrationData);
+        // Icon-name renames (e.g. `mc-add-to-list_16` / `kbq-add-to-list_16` -> the current
+        // `kbq-file-plus-o_16`) apply to styles/markdown regardless of `updatePrefix` — only the
+        // *bare* scope-word rename (`mc` -> `kbq`, which touches `$mc`/`@import 'mc'` as much as a
+        // real `.mc {}` selector) is gated by it, matching the option's historical scope.
+        const styleAndMarkdownTokenMap = updatePrefix
+            ? tokenMap
+            : new Map([...tokenMap].filter(([token]) => token !== resolvedScope.from));
+        // Precompiled once and reused across every relevant file below, instead of rebuilding
+        // ~1000+ regexes per file. Inline `styles` arrays inside `.ts` files use the unfiltered
+        // `tokenMap` (matching `migrateIconsInTsFiles`'s pre-existing behavior); real `.scss`/`.md`
+        // files use `styleAndMarkdownTokenMap`, which additionally respects `updatePrefix`.
+        const tsInlineStylePatterns = utils_iconMigration.buildIconTokenPatterns(tokenMap, resolvedScope.from);
+        const stylePatterns = utils_iconMigration.buildIconTokenPatterns(styleAndMarkdownTokenMap, resolvedScope.from);
+        const onFound = (filePath, found) => {
+            const parsedFilePath = path__namespace.relative(__dirname, `.${filePath}`).replace(/\\/g, '/');
+            utils_messages.logMessage(logger, [
+                `Please pay attention! Found deprecated icons in file: `,
+                parsedFilePath,
+                found.map(({ from, to }) => `\t${from} -> \t${to}`).join('\n')
+            ]);
+        };
+        const warn = (message) => logger.warn(message);
+        const templatePaths = [];
+        const tsPaths = [];
+        const markdownPaths = [];
         // Update templates & components
-        targetDir.visit((path, entry) => {
+        targetDir.visit((filePath) => {
             // if project property not provided, skip files in node_modules & dist
-            if (path.includes('node_modules') || path.includes('dist')) {
+            if (filePath.includes('node_modules') || filePath.includes('/dist/')) {
                 return;
             }
-            if (path.endsWith('.html') || path.endsWith('.ts') || path.endsWith('.md')) {
-                const initialContent = entry?.content.toString();
-                let newContent = initialContent;
-                if (newContent) {
-                    resolvedIconsReplacements.forEach(({ replace, replaceWith }) => {
-                        newContent = newContent.replace(new RegExp(replace, 'g'), replaceWith);
-                    });
-                    newContent = handleDeprecatedIcons(newContent, path);
-                    if (initialContent !== newContent) {
-                        tree.overwrite(path, newContent || '');
-                    }
-                }
+            if (filePath.endsWith('.html')) {
+                templatePaths.push(filePath);
+            }
+            else if (filePath.endsWith('.ts') &&
+                !filePath.endsWith('.d.ts') &&
+                !filePath.endsWith('.ngtypecheck.ts')) {
+                tsPaths.push(filePath);
+            }
+            else if (filePath.endsWith('.md')) {
+                markdownPaths.push(filePath);
             }
         });
-        // update styles
-        targetDir.visit((path, entry) => {
-            // if project property not provided, provide node_modules to be changed
-            if (path.includes('node_modules')) {
+        await utils_angularParsing.migrateTemplateWithTransform(tree, templatePaths, context, utils_iconMigration.createIconTemplateTransform(migrationData, tokenMap, { fix, onFound, warn }));
+        await utils_iconMigration.migrateIconsInTsFiles(tree, tsPaths, context, migrationData, tokenMap, { fix, onFound, warn }, tsInlineStylePatterns);
+        // Markdown docs have no AST here, so — like styles — they're matched with the same
+        // word/selector-boundary-safe, known-token-only regex rather than an unscoped replace.
+        for (const filePath of markdownPaths) {
+            const initialContent = tree.read(filePath)?.toString();
+            if (!initialContent) {
+                continue;
+            }
+            const { content, changed, found } = utils_iconMigration.replaceKnownIconTokens(initialContent, stylePatterns, fix);
+            if (found.length && !fix) {
+                onFound(filePath, found);
+            }
+            if (changed) {
+                tree.overwrite(filePath, content);
+            }
+        }
+        // update styles — icon-name renames always apply; `updatePrefix` only adds the bare
+        // scope-word rename (see `styleAndMarkdownTokenMap` above).
+        targetDir.visit((filePath) => {
+            // if project property not provided, styles in node_modules are still skipped, same as
+            // every other file type above
+            if (filePath.includes('node_modules')) {
+                return;
+            }
+            if (!filePath.endsWith(stylesExt)) {
                 return;
             }
-            if (path.endsWith(stylesExt)) {
-                const initialContent = entry?.content.toString();
-                let newContent = initialContent;
-                if (newContent) {
-                    // replace icons in styles
-                    if (updatePrefix) {
-                        newContent = newContent.replace(new RegExp('mc-', 'g'), 'kbq-');
-                    }
-                    newContent = handleDeprecatedIcons(newContent, path);
-                }
-                if (initialContent !== newContent) {
-                    tree.overwrite(path, newContent || '');
-                }
+            const initialContent = tree.read(filePath)?.toString();
+            if (!initialContent) {
+                return;
+            }
+            const { content, changed, found } = utils_iconMigration.replaceKnownIconTokens(initialContent, stylePatterns, fix);
+            if (found.length && !fix) {
+                onFound(filePath, found);
+            }
+            if (changed) {
+                tree.overwrite(filePath, content);
             }
         });
     };

package/schematics/ng-add/index.js

@@ -27,11 +27,11 @@ function ngAdd(options) {
         }
         // Installing dependencies
         utils_packageConfig.addPackageToPackageJson(tree, '@angular/cdk', "^20.2.14");
-        utils_packageConfig.addPackageToPackageJson(tree, '@koobiq/angular-luxon-adapter', "^20.2.0");
+        utils_packageConfig.addPackageToPackageJson(tree, '@koobiq/angular-luxon-adapter', "^20.3.0");
         utils_packageConfig.addPackageToPackageJson(tree, '@koobiq/date-formatter', "^3.5.1");
         utils_packageConfig.addPackageToPackageJson(tree, '@koobiq/date-adapter', "^3.5.1");
-        utils_packageConfig.addPackageToPackageJson(tree, '@koobiq/icons', "^11.7.1");
-        utils_packageConfig.addPackageToPackageJson(tree, '@koobiq/design-tokens', "^3.17.2");
+        utils_packageConfig.addPackageToPackageJson(tree, '@koobiq/icons', "^12.2.0");
+        utils_packageConfig.addPackageToPackageJson(tree, '@koobiq/design-tokens', "^3.19.0");
         utils_packageConfig.addPackageToPackageJson(tree, 'luxon', "^3.7.2");
     };
 }

package/schematics/utils/angular-parsing.js

@@ -10,23 +10,17 @@ var utils_typescript = require('./typescript.js');
  * @param tree
  * @param filePaths
  * @param context
- * @param migrationData
+ * @param transform
  */
-async function migrateTemplate(tree, filePaths, context, migrationData) {
+async function migrateTemplateWithTransform(tree, filePaths, context, transform) {
     for (const templatePath of filePaths) {
         const parsedFilePath = `.${templatePath}`;
-        let res = Promise.resolve({
-            fileContent: '',
-            changed: false,
-            errors: []
-        });
         const template = tree.read(parsedFilePath)?.toString();
         if (!template) {
             context.logger.error(`Cannot read "${parsedFilePath}" because it does not exist.`);
             continue;
         }
-        res = transformTemplateAttributes(template, parsedFilePath, migrationData);
-        const { fileContent, changed, errors } = await res;
+        const { fileContent, changed, errors } = await transform(template, parsedFilePath);
         if (changed) {
             tree.overwrite(templatePath, fileContent);
         }
@@ -35,15 +29,25 @@ async function migrateTemplate(tree, filePaths, context, migrationData) {
         }
     }
 }
+/**
+ * Update separate html file
+ * @param tree
+ * @param filePaths
+ * @param context
+ * @param migrationData
+ */
+async function migrateTemplate(tree, filePaths, context, migrationData) {
+    return migrateTemplateWithTransform(tree, filePaths, context, (template, fileName) => transformTemplateAttributes(template, fileName, migrationData));
+}
 /**
  * Update typescript file if classes with @Component decorator and `template` property exists
  * @param tree
  * @param sourceFiles
  * @param basePath
  * @param context
- * @param migrationData
+ * @param transform
  */
-async function migrateTs(tree, sourceFiles, basePath, context, migrationData) {
+async function migrateTsWithTransform(tree, sourceFiles, basePath, context, transform) {
     // run and track changed components
     const analysis = new Map();
     for (const sourceFile of sourceFiles) {
@@ -61,7 +65,7 @@ async function migrateTs(tree, sourceFiles, basePath, context, migrationData) {
         for (const { start, end } of ranges) {
             const template = content.slice(start, end);
             const length = (end ?? content.length) - start;
-            const { fileContent, changed, errors } = await transformTemplateAttributes(template, relativePath, migrationData);
+            const { fileContent, changed, errors } = await transform(template, relativePath);
             if (changed) {
                 update.remove(start, length);
                 update.insertLeft(start, fileContent);
@@ -73,6 +77,17 @@ async function migrateTs(tree, sourceFiles, basePath, context, migrationData) {
         tree.commitUpdate(update);
     }
 }
+/**
+ * Update typescript file if classes with @Component decorator and `template` property exists
+ * @param tree
+ * @param sourceFiles
+ * @param basePath
+ * @param context
+ * @param migrationData
+ */
+async function migrateTs(tree, sourceFiles, basePath, context, migrationData) {
+    return migrateTsWithTransform(tree, sourceFiles, basePath, context, (template, fileName) => transformTemplateAttributes(template, fileName, migrationData));
+}
 /**
  * Analyzes the decorators of a given class declaration to find and save
  * inline `template` metadata within `@Component` decorators.
@@ -159,4 +174,7 @@ async function transformTemplateAttributes(template, fileName, migrationData) {
 
 exports.analyzeDecorators = analyzeDecorators;
 exports.migrateTemplate = migrateTemplate;
+exports.migrateTemplateWithTransform = migrateTemplateWithTransform;
 exports.migrateTs = migrateTs;
+exports.migrateTsWithTransform = migrateTsWithTransform;
+exports.transformTemplateAttributes = transformTemplateAttributes;