@taiga-ui/cdk 4.45.0 → 4.46.0-canary.3415f27

package/schematics/ng-update/v5/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateToV5 = void 0;
+const node_perf_hooks_1 = require("node:perf_hooks");
+const schematics_1 = require("@angular-devkit/schematics");
+const tasks_1 = require("@angular-devkit/schematics/tasks");
+const ng_morph_1 = require("ng-morph");
+const versions_1 = require("../../ng-add/constants/versions");
+const get_execution_time_1 = require("../../utils/get-execution-time");
+const migrate_tokens_1 = require("./steps/migrate-tokens/migrate-tokens");
+const update_tsconfig_1 = require("./steps/migrate-tokens/update-tsconfig");
+function main(options) {
+    return (tree, context) => {
+        (0, migrate_tokens_1.migrateTokens)(tree, options);
+        (0, update_tsconfig_1.updateTsConfig)(tree, options);
+        context.addTask(new tasks_1.NodePackageInstallTask());
+    };
+}
+function updateToV5(options) {
+    const t0 = node_perf_hooks_1.performance.now();
+    !options['skip-logs'] &&
+        (0, ng_morph_1.titleLog)(`\n\n${ng_morph_1.START_SYMBOL} Your packages will be updated to @taiga-ui/*@${versions_1.TAIGA_VERSION}\n`);
+    return (0, schematics_1.chain)([
+        main(options),
+        () => {
+            const executionTime = (0, get_execution_time_1.getExecutionTime)(t0, node_perf_hooks_1.performance.now());
+            !options['skip-logs'] &&
+                (0, ng_morph_1.titleLog)(`${ng_morph_1.FINISH_SYMBOL} We migrated packages to @taiga-ui/*@${versions_1.TAIGA_VERSION} in ${executionTime}. \n`);
+        },
+    ]);
+}
+exports.updateToV5 = updateToV5;

package/schematics/ng-update/v5/schema.json

@@ -0,0 +1,7 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema",
+    "$id": "taiga-ui-ng-update-v5",
+    "title": "Taiga UI ng-update v5",
+    "type": "object",
+    "properties": {}
+}

package/schematics/ng-update/v5/steps/migrate-tokens/migrate-tokens.d.ts

@@ -0,0 +1,13 @@
+import type { Tree } from '@angular-devkit/schematics';
+import type { TuiSchema } from '../../../../ng-add/schema';
+/**
+ * Migrates Taiga UI token functions to Angular's InjectionToken
+ *
+ * This schematic:
+ * 1. Finds all references to `tuiCreateToken` and `tuiCreateTokenFromFactory`
+ * 2. Replaces them with equivalent `InjectionToken` implementations
+ * 3. Handles proper import management for `InjectionToken`
+ * 4. Preserves type parameters and factory functions
+ * 5. Adds descriptive error handling and logging
+ */
+export declare function migrateTokens(tree: Tree, options: TuiSchema): void;

package/schematics/ng-update/v5/steps/migrate-tokens/migrate-tokens.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateTokens = void 0;
+const ng_morph_1 = require("ng-morph");
+const constants_1 = require("../../../../constants");
+const get_named_import_references_1 = require("../../../../utils/get-named-import-references");
+const import_manipulations_1 = require("../../../../utils/import-manipulations");
+const insert_todo_1 = require("../../../../utils/insert-todo");
+const TOKEN_FUNCTIONS = ['tuiCreateToken', 'tuiCreateTokenFromFactory'];
+const ANGULAR_CORE = '@angular/core';
+const INJECTION_TOKEN = 'InjectionToken';
+/**
+ * Migrates Taiga UI token functions to Angular's InjectionToken
+ *
+ * This schematic:
+ * 1. Finds all references to `tuiCreateToken` and `tuiCreateTokenFromFactory`
+ * 2. Replaces them with equivalent `InjectionToken` implementations
+ * 3. Handles proper import management for `InjectionToken`
+ * 4. Preserves type parameters and factory functions
+ * 5. Adds descriptive error handling and logging
+ */
+function migrateTokens(tree, options) {
+    if (!options['skip-logs']) {
+        (0, ng_morph_1.infoLog)('Starting token migration to InjectionToken...');
+    }
+    const project = (0, ng_morph_1.createProject)(tree, '/', constants_1.ALL_TS_FILES);
+    (0, ng_morph_1.setActiveProject)(project);
+    const allFiles = (0, ng_morph_1.getSourceFiles)();
+    if (!options['skip-logs']) {
+        (0, ng_morph_1.infoLog)(`Found ${allFiles.length} source files`);
+    }
+    TOKEN_FUNCTIONS.forEach((tokenFunction) => {
+        const references = (0, get_named_import_references_1.getNamedImportReferences)(tokenFunction, '@taiga-ui/cdk');
+        if (!options['skip-logs']) {
+            (0, ng_morph_1.infoLog)(`Found ${references.length} references for ${tokenFunction}`);
+        }
+        references.forEach((ref) => {
+            if (ref.wasForgotten()) {
+                return;
+            }
+            try {
+                const parent = ref.getParent();
+                const sourceFile = ref.getSourceFile();
+                if (ng_morph_1.Node.isImportSpecifier(parent)) {
+                    (0, import_manipulations_1.removeImport)(parent);
+                    return;
+                }
+                if (ng_morph_1.Node.isCallExpression(parent)) {
+                    const declaration = parent.getFirstAncestorByKind(ng_morph_1.SyntaxKind.VariableDeclaration);
+                    if (!declaration) {
+                        if (!ref.wasForgotten()) {
+                            (0, insert_todo_1.insertTodo)(ref, 'Could not find variable declaration');
+                        }
+                        return;
+                    }
+                    const constName = declaration.getName();
+                    if (!constName) {
+                        if (!ref.wasForgotten()) {
+                            (0, insert_todo_1.insertTodo)(ref, 'Variable declaration has no name');
+                        }
+                        return;
+                    }
+                    const newExpression = createInjectionTokenExpression(parent, constName, tokenFunction);
+                    parent.replaceWithText(newExpression);
+                    // handle InjectionToken imports
+                    let hasValueImport = false;
+                    const coreImports = [];
+                    sourceFile.getImportDeclarations().forEach((decl) => {
+                        if (decl.getModuleSpecifierValue() !== ANGULAR_CORE) {
+                            return;
+                        }
+                        coreImports.push(decl);
+                        const namedImports = decl.getNamedImports();
+                        const tokenImport = namedImports.find((i) => i.getName() === INJECTION_TOKEN);
+                        if (!tokenImport) {
+                            return;
+                        }
+                        // remove InjectionToken from type-only imports
+                        if (tokenImport.isTypeOnly() || decl.isTypeOnly()) {
+                            tokenImport.remove();
+                            // remove the import declaration if it becomes empty
+                            if (decl.getNamedImports().length === 0) {
+                                decl.remove();
+                            }
+                        }
+                        else {
+                            hasValueImport = true;
+                        }
+                    });
+                    // add InjectionToken as regular import if needed
+                    if (!hasValueImport) {
+                        sourceFile.addImportDeclaration({
+                            moduleSpecifier: ANGULAR_CORE,
+                            namedImports: [INJECTION_TOKEN],
+                            isTypeOnly: false,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if (!options['skip-logs']) {
+                    (0, ng_morph_1.infoLog)(`Error migrating token: ${message}`);
+                }
+                if (!ref.wasForgotten()) {
+                    (0, insert_todo_1.insertTodo)(ref, `Migration failed: ${message}`);
+                }
+            }
+        });
+    });
+    (0, ng_morph_1.saveActiveProject)();
+    if (!options['skip-logs']) {
+        (0, ng_morph_1.titleLog)('Token migration completed!');
+    }
+}
+exports.migrateTokens = migrateTokens;
+/**
+ * Creates InjectionToken expression to replace token functions
+ *
+ * This function:
+ * - Preserves type parameters (<T> syntax)
+ * - Converts token values to factory functions when needed
+ * - Adds ngDevMode checks for token descriptions
+ * - Handles different cases for tuiCreateToken vs tuiCreateTokenFromFactory
+ *
+ * Example conversions:
+ * tuiCreateToken('default') → new InjectionToken(..., { factory: () => 'default' })
+ * tuiCreateTokenFromFactory(() => value) → new InjectionToken(..., { factory: () => value })
+ */
+function createInjectionTokenExpression(callExpression, constName, tokenFunction) {
+    const typeArgs = callExpression.getTypeArguments();
+    const typeArgsText = typeArgs.length
+        ? `<${typeArgs.map((t) => t.getText()).join(', ')}>`
+        : '';
+    const args = callExpression.getArguments();
+    const isFactory = tokenFunction === 'tuiCreateTokenFromFactory';
+    const tokenDescription = `ngDevMode ? '${constName}' : ''`;
+    if (args.length > 0 && args[0]) {
+        const argText = args[0].getText();
+        const isObjectOrArray = argText.startsWith('{') || argText.startsWith('[');
+        if (isFactory) {
+            return `new ${INJECTION_TOKEN}${typeArgsText}(${tokenDescription}, {
+    factory: ${argText}
+})`;
+        }
+        const factoryContent = isObjectOrArray
+            ? `() => (${argText})`
+            : `() => ${argText}`;
+        return `new ${INJECTION_TOKEN}${typeArgsText}(${tokenDescription}, {
+    factory: ${factoryContent}
+})`;
+    }
+    return `new ${INJECTION_TOKEN}${typeArgsText}(${tokenDescription})`;
+}

package/schematics/ng-update/v5/steps/migrate-tokens/update-tsconfig.d.ts

@@ -0,0 +1,11 @@
+import type { Tree } from '@angular-devkit/schematics';
+import type { TuiSchema } from '../../../../ng-add/schema';
+/**
+ * Updates tsconfig.json to include necessary type definitions
+ * - Adds `@taiga-ui/tsconfig` to typeRoots
+ * - Adds `node` and `ng-dev-mode` to types array
+ *
+ * This ensures proper type checking and IntelliSense for Taiga UI components
+ * and prevents common TypeScript errors related to custom types and ngDevMode.
+ */
+export declare function updateTsConfig(tree: Tree, options: TuiSchema): void;

package/schematics/ng-update/v5/steps/migrate-tokens/update-tsconfig.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateTsConfig = void 0;
+const ng_morph_1 = require("ng-morph");
+const TAIGA_TS_CONFIG_PATH = 'node_modules/@taiga-ui/tsconfig';
+/**
+ * Updates tsconfig.json to include necessary type definitions
+ * - Adds `@taiga-ui/tsconfig` to typeRoots
+ * - Adds `node` and `ng-dev-mode` to types array
+ *
+ * This ensures proper type checking and IntelliSense for Taiga UI components
+ * and prevents common TypeScript errors related to custom types and ngDevMode.
+ */
+function updateTsConfig(tree, options) {
+    const tsConfigPath = 'tsconfig.json';
+    if (!tree.exists(tsConfigPath)) {
+        if (!options['skip-logs']) {
+            (0, ng_morph_1.infoLog)(`Could not find ${tsConfigPath}, skipping tsconfig update.`);
+        }
+        return;
+    }
+    const content = tree.readText(tsConfigPath);
+    let tsConfig;
+    try {
+        tsConfig = JSON.parse(content);
+    }
+    catch (e) {
+        if (!options['skip-logs']) {
+            (0, ng_morph_1.infoLog)(`Error parsing ${tsConfigPath}: ${e instanceof Error ? e.message : e}. Skipping tsconfig update.`);
+        }
+        return;
+    }
+    if (!tsConfig.compilerOptions) {
+        tsConfig.compilerOptions = {};
+    }
+    // Track changes for logging
+    let changesMade = false;
+    const addedTypeRoots = [];
+    const addedTypes = [];
+    const typeRoots = tsConfig.compilerOptions.typeRoots || ['node_modules/@types'];
+    if (!typeRoots.includes(TAIGA_TS_CONFIG_PATH)) {
+        typeRoots.push(TAIGA_TS_CONFIG_PATH);
+        tsConfig.compilerOptions.typeRoots = typeRoots;
+        addedTypeRoots.push(TAIGA_TS_CONFIG_PATH);
+        changesMade = true;
+    }
+    const types = tsConfig.compilerOptions.types || [];
+    const requiredTypes = ['node', 'ng-dev-mode'];
+    const missingTypes = requiredTypes.filter((type) => !types.includes(type));
+    if (missingTypes.length > 0) {
+        missingTypes.forEach((type) => {
+            types.push(type);
+            addedTypes.push(type);
+        });
+        tsConfig.compilerOptions.types = types;
+        changesMade = true;
+    }
+    // Save changes if any modifications were made
+    if (changesMade) {
+        tree.overwrite(tsConfigPath, `${JSON.stringify(tsConfig, null, 2)}\n`);
+        if (!options['skip-logs']) {
+            if (addedTypeRoots.length > 0) {
+                (0, ng_morph_1.infoLog)(`Added to typeRoots: ${addedTypeRoots.join(', ')}`);
+            }
+            if (addedTypes.length > 0) {
+                (0, ng_morph_1.infoLog)(`Added to types: ${addedTypes.join(', ')}`);
+            }
+            (0, ng_morph_1.infoLog)(`Updated ${tsConfigPath} successfully`);
+        }
+    }
+    else if (!options['skip-logs']) {
+        (0, ng_morph_1.infoLog)(`No changes needed in ${tsConfigPath}, configuration already complete`);
+    }
+}
+exports.updateTsConfig = updateTsConfig;

package/schematics/ng-update/v5/tests/migrate-tokens/utils.d.ts

@@ -0,0 +1 @@
+export declare function runMigration(before: string): Promise<string>;

package/schematics/ng-update/v5/tests/migrate-tokens/utils.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMigration = void 0;
+const tslib_1 = require("tslib");
+const node_path_1 = require("node:path");
+const schematics_1 = require("@angular-devkit/schematics");
+const testing_1 = require("@angular-devkit/schematics/testing");
+const ng_morph_1 = require("ng-morph");
+const collectionPath = (0, node_path_1.join)(__dirname, '../../../../migration.json');
+function runMigration(before) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const host = new testing_1.UnitTestTree(new schematics_1.HostTree());
+        const runner = new testing_1.SchematicTestRunner('schematics', collectionPath);
+        (0, ng_morph_1.setActiveProject)((0, ng_morph_1.createProject)(host));
+        (0, ng_morph_1.createSourceFile)('test/app/tokens.ts', before);
+        (0, ng_morph_1.createSourceFile)('package.json', '{}');
+        (0, ng_morph_1.saveActiveProject)();
+        const tree = yield runner.runSchematic('updateToV5', { 'skip-logs': process.env['TUI_CI'] === 'true' }, host);
+        return tree.readContent('test/app/tokens.ts');
+    });
+}
+exports.runMigration = runMigration;

package/utils/dom/retarget-boundary-crossing.d.ts

@@ -1 +1 @@
-export declare function tuiRetargetedBoundaryCrossing(event: any): boolean;
+export declare function tuiRetargetedBoundaryCrossing(event: Event): boolean;