igniteui-angular 22.1.0-beta.5 → 22.1.0-beta.6

package/lib/grids/core/src/filtering/excel-style/themes/_derived.scss

@@ -39,7 +39,6 @@
                         var(--ig-btn-group-selected-bg, #{color($color: 'gray', $variant: 100)}),
                     ),
                     $item-hover-background: var(--item-selected-background),
-                    $item-hover-text-color: var(--_excel-filtering-foreground, #{color($color: 'gray', $variant: 700)}),
                     $item-active-border-color: transparent,
                     $item-selected-text-color: var(--_excel-filtering-accent-color, #{if(
                         $theme == 'indigo',
@@ -110,10 +109,12 @@
         );
 
         @if $theme == 'material' {
+            --_excel-filtering-secondary-background: #{dynamic-shade(var(--secondary-background, var(--ig-excel-filtering-secondary-background)), $lightness: 95, $offset: 3)};
+
             @include tokens(
                 input-group-theme(
                     $schema: $schema,
-                    $box-background: var(--_excel-filtering-background),
+                    $box-background: dynamic-shade(var(--_excel-filtering-background), $lightness: 95, $offset: 3),
                     $idle-bottom-line-color: var(--_excel-filtering-accent-color),
                     $idle-text-color: var(--_excel-filtering-foreground),
                     $placeholder-color: color-mix(in srgb, var(--_excel-filtering-foreground) 80%, var(--_excel-filtering-background)),

package/migrations/update-22_1_0_import-migration/index.js

@@ -81,75 +81,103 @@ function resolveEntryPoint(importPath) {
     }
     return null;
 }
-function migrateImportDeclaration(node, sourceFile) {
-    var _a;
-    if (!(0, tsUtils_1.igNamedImportFilter)(node)) {
-        return null;
-    }
-    const importPath = node.moduleSpecifier.text;
-    const namedBindings = node.importClause.namedBindings;
-    // Only process imports coming from a known source entry point for this migration
-    const source = resolveEntryPoint(importPath);
-    if (!source || !SOURCE_ENTRY_POINTS.includes(source.entry)) {
-        return null;
-    }
-    // Group moved imports by target entry point; keep everything else where it is
-    const entryPointGroups = new Map();
-    const remaining = [];
-    for (const element of namedBindings.elements) {
-        const name = element.name.text;
-        const alias = (_a = element.propertyName) === null || _a === void 0 ? void 0 : _a.text;
-        const importName = alias || name;
-        const fullImport = alias ? `${importName} as ${name}` : importName;
-        // Check if this import moved out of the current source entry point
-        const move = EXPORT_MOVES.get(importName);
-        if (move && move.from === source.entry) {
-            if (!entryPointGroups.has(move.to)) {
-                entryPointGroups.set(move.to, []);
+/** Sorts specifiers alphabetically by their imported symbol name. */
+const sortByName = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+/** Collects Ignite UI named imports from the file, in source order. */
+function collectIgImports(sourceFile) {
+    const imports = [];
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node) && (0, tsUtils_1.igNamedImportFilter)(node)) {
+            const resolved = resolveEntryPoint(node.moduleSpecifier.text);
+            if (resolved) {
+                const namedBindings = node.importClause.namedBindings;
+                const specifiers = namedBindings.elements.map(element => {
+                    var _a;
+                    const name = element.name.text;
+                    const alias = (_a = element.propertyName) === null || _a === void 0 ? void 0 : _a.text;
+                    const importName = alias || name;
+                    const typePrefix = element.isTypeOnly ? 'type ' : '';
+                    const specifier = alias ? `${importName} as ${name}` : importName;
+                    return { key: importName, text: `${typePrefix}${specifier}` };
+                });
+                imports.push({
+                    node,
+                    basePackage: resolved.basePackage,
+                    entry: resolved.entry,
+                    isTypeOnly: node.importClause.phaseModifier === ts.SyntaxKind.TypeKeyword,
+                    specifiers
+                });
             }
-            entryPointGroups.get(move.to).push(fullImport);
-        }
-        else {
-            // Keep in the original entry point
-            remaining.push(fullImport);
         }
-    }
-    // If nothing changed, return null
-    if (entryPointGroups.size === 0) {
-        return null;
-    }
-    // Generate new import statements
-    const newImports = [];
-    // Add remaining imports for the original entry point first
-    if (remaining.length > 0) {
-        const sortedImports = remaining.sort();
-        newImports.push(`import { ${sortedImports.join(', ')} } from '${importPath}';`);
-    }
-    // Add moved imports
-    for (const [entryPoint, imports] of entryPointGroups) {
-        const sortedImports = imports.sort();
-        newImports.push(`import { ${sortedImports.join(', ')} } from '${source.basePackage}/${entryPoint}';`);
-    }
-    return {
-        start: node.getStart(sourceFile),
-        end: node.getEnd(),
-        replacement: newImports.join('\n')
+        ts.forEachChild(node, visit);
     };
+    visit(sourceFile);
+    return imports;
 }
 function migrateFile(filePath, content) {
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-    const changes = [];
-    function visit(node) {
-        if (ts.isImportDeclaration(node)) {
-            const change = migrateImportDeclaration(node, sourceFile);
-            if (change) {
-                changes.push(change);
+    const imports = collectIgImports(sourceFile);
+    // The full module path a specifier ends up in, or null if it stays where it is.
+    const movedTo = (imp, spec) => {
+        const move = EXPORT_MOVES.get(spec.key);
+        return move && move.from === imp.entry ? `${imp.basePackage}/${move.to}` : null;
+    };
+    // A stable key per output import: its `type` modifier plus module path.
+    const importKey = (path, isTypeOnly) => `${isTypeOnly ? 'type ' : ''}${path}`;
+    // Imports (module path + type modifier) that gain a moved specifier.
+    const mergeTargets = new Set();
+    for (const imp of imports) {
+        for (const spec of imp.specifiers) {
+            const to = movedTo(imp, spec);
+            if (to) {
+                mergeTargets.add(importKey(to, imp.isTypeOnly));
             }
         }
-        ts.forEachChild(node, visit);
     }
-    visit(sourceFile);
-    // Apply changes in reverse order to maintain positions
+    // Nothing moves in this file.
+    if (mergeTargets.size === 0) {
+        return content;
+    }
+    // Rewrite imports that lose a specifier (sources) or receive one (merge targets).
+    const participating = imports.filter(imp => imp.specifiers.some(spec => movedTo(imp, spec)) ||
+        mergeTargets.has(importKey(`${imp.basePackage}/${imp.entry}`, imp.isTypeOnly)));
+    // Collect the surviving specifiers per output import, retained ones before moved ones.
+    const groups = new Map();
+    const add = (path, isTypeOnly, spec) => {
+        var _a;
+        const key = importKey(path, isTypeOnly);
+        ((_a = groups.get(key)) !== null && _a !== void 0 ? _a : groups.set(key, { path, isTypeOnly, specifiers: [] }).get(key)).specifiers.push(spec);
+    };
+    for (const imp of participating) {
+        const from = `${imp.basePackage}/${imp.entry}`;
+        for (const spec of imp.specifiers) {
+            if (!movedTo(imp, spec)) {
+                add(from, imp.isTypeOnly, spec);
+            }
+        }
+        for (const spec of imp.specifiers) {
+            const to = movedTo(imp, spec);
+            if (to) {
+                add(to, imp.isTypeOnly, spec);
+            }
+        }
+    }
+    const newImports = [...groups.values()].map(group => {
+        const typeModifier = group.isTypeOnly ? 'type ' : '';
+        const specifiers = group.specifiers.sort(sortByName).map(s => s.text).join(', ');
+        return `import ${typeModifier}{ ${specifiers} } from '${group.path}';`;
+    });
+    // Replace the first participating declaration with the merged imports; drop the rest.
+    const anchor = participating[0];
+    const changes = [
+        { start: anchor.node.getStart(sourceFile), end: anchor.node.getEnd(), replacement: newImports.join('\n') },
+        ...participating.slice(1).map(imp => ({
+            start: imp.node.getFullStart(),
+            end: imp.node.getEnd(),
+            replacement: ''
+        }))
+    ];
+    // Apply changes in reverse order to maintain positions.
     changes.sort((a, b) => b.start - a.start);
     let result = content;
     for (const change of changes) {

package/migrations/update-22_1_0_import-migration/index.spec.js

@@ -52,7 +52,7 @@ describe(`Update to ${version}`, () => {
     beforeEach(() => {
         appTree = (0, setup_spec_1.setupTestTree)();
     });
-    const migrationName = 'migration-58';
+    const migrationName = 'migration-59';
     const filePath = '/testSrc/appPrefix/component/test.component.ts';
     it('should move a single IgxSummaryOperand import from grids/core to core', () => __awaiter(void 0, void 0, void 0, function* () {
         appTree.create(filePath, `import { IgxSummaryOperand } from 'igniteui-angular/grids/core';`);
@@ -116,6 +116,46 @@ describe(`Update to ${version}`, () => {
         expect(tree.readContent(filePath))
             .toEqual(`import { IGroupingDoneEventArgs } from 'igniteui-angular/grids/core';`);
     }));
+    it('should move IGroupingDoneEventArgs from grids/grid to grids/core as type import', () => __awaiter(void 0, void 0, void 0, function* () {
+        appTree.create(filePath, `import type { IGroupingDoneEventArgs } from 'igniteui-angular/grids/grid';`);
+        const tree = yield schematicRunner.runSchematic(migrationName, {}, appTree);
+        expect(tree.readContent(filePath))
+            .toEqual(`import type { IGroupingDoneEventArgs } from 'igniteui-angular/grids/core';`);
+    }));
+    it('should preserve the type modifier when moving summary operands from grids/core to core', () => __awaiter(void 0, void 0, void 0, function* () {
+        appTree.create(filePath, `import type { IgxSummaryOperand } from 'igniteui-angular/grids/core';`);
+        const tree = yield schematicRunner.runSchematic(migrationName, {}, appTree);
+        expect(tree.readContent(filePath))
+            .toEqual(`import type { IgxSummaryOperand } from 'igniteui-angular/core';`);
+    }));
+    it('should preserve a per-specifier inline type modifier when moving an export', () => __awaiter(void 0, void 0, void 0, function* () {
+        appTree.create(filePath, `import { type IGroupingDoneEventArgs, IgxGridComponent } from 'igniteui-angular/grids/grid';`);
+        const tree = yield schematicRunner.runSchematic(migrationName, {}, appTree);
+        expect(tree.readContent(filePath))
+            .toEqual(`import { IgxGridComponent } from 'igniteui-angular/grids/grid';\n` +
+            `import { type IGroupingDoneEventArgs } from 'igniteui-angular/grids/core';`);
+    }));
+    it('should migrate multiple separate import declarations in the same file', () => __awaiter(void 0, void 0, void 0, function* () {
+        appTree.create(filePath, `import { IgxSummaryOperand } from 'igniteui-angular/grids/core';\n` +
+            `import { IGroupingDoneEventArgs } from 'igniteui-angular/grids/grid';`);
+        const tree = yield schematicRunner.runSchematic(migrationName, {}, appTree);
+        expect(tree.readContent(filePath))
+            .toEqual(`import { IgxSummaryOperand } from 'igniteui-angular/core';\n` +
+            `import { IGroupingDoneEventArgs } from 'igniteui-angular/grids/core';`);
+    }));
+    it('should migrate multiple import type declarations in the same file', () => __awaiter(void 0, void 0, void 0, function* () {
+        appTree.create(filePath, `import type { IMultiRowLayoutNode, ISelectionNode } from 'igniteui-angular/grids/core';`);
+        const tree = yield schematicRunner.runSchematic(migrationName, {}, appTree);
+        expect(tree.readContent(filePath))
+            .toEqual(`import type { IMultiRowLayoutNode, ISelectionNode } from 'igniteui-angular/core';`);
+    }));
+    it('should merge migrated import type declarations', () => __awaiter(void 0, void 0, void 0, function* () {
+        appTree.create(filePath, `import { IgxSummaryResult } from 'igniteui-angular/core';\n` +
+            `import { IgxNumberSummaryOperand, IgxSummaryOperand } from 'igniteui-angular/grids/core';`);
+        const tree = yield schematicRunner.runSchematic(migrationName, {}, appTree);
+        expect(tree.readContent(filePath))
+            .toEqual(`import { IgxNumberSummaryOperand, IgxSummaryOperand, IgxSummaryResult } from 'igniteui-angular/core';`);
+    }));
     it('should split IGroupingDoneEventArgs out of grids/grid, keeping other exports', () => __awaiter(void 0, void 0, void 0, function* () {
         appTree.create(filePath, `import { IgxGridComponent, IGroupingDoneEventArgs } from 'igniteui-angular/grids/grid';`);
         const tree = yield schematicRunner.runSchematic(migrationName, {}, appTree);
@@ -129,4 +169,20 @@ describe(`Update to ${version}`, () => {
         const tree = yield schematicRunner.runSchematic(migrationName, {}, appTree);
         expect(tree.readContent(filePath)).toEqual(content);
     }));
+    it('should merge into an existing core import while leaving unrelated imports untouched', () => __awaiter(void 0, void 0, void 0, function* () {
+        appTree.create(filePath, `import { Component, OnInit, ViewChild } from '@angular/core';\n` +
+            `import { IgxHierarchicalGridComponent, IgxRowIslandComponent } from 'igniteui-angular/grids/hierarchical-grid';\n` +
+            `import { IgxCellTemplateDirective, IgxColumnComponent, IgxNumberSummaryOperand, IgxSummaryOperand } from 'igniteui-angular/grids/core';\n` +
+            `import { IgxSummaryResult } from 'igniteui-angular/core';\n` +
+            `import { SINGERS } from '../../data/singersData';\n` +
+            `import { IgxPreventDocumentScrollDirective } from '../../directives/prevent-scroll.directive';`);
+        const tree = yield schematicRunner.runSchematic(migrationName, {}, appTree);
+        expect(tree.readContent(filePath))
+            .toEqual(`import { Component, OnInit, ViewChild } from '@angular/core';\n` +
+            `import { IgxHierarchicalGridComponent, IgxRowIslandComponent } from 'igniteui-angular/grids/hierarchical-grid';\n` +
+            `import { IgxCellTemplateDirective, IgxColumnComponent } from 'igniteui-angular/grids/core';\n` +
+            `import { IgxNumberSummaryOperand, IgxSummaryOperand, IgxSummaryResult } from 'igniteui-angular/core';\n` +
+            `import { SINGERS } from '../../data/singersData';\n` +
+            `import { IgxPreventDocumentScrollDirective } from '../../directives/prevent-scroll.directive';`);
+    }));
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "igniteui-angular",
-  "version": "22.1.0-beta.5",
+  "version": "22.1.0-beta.6",
   "description": "Ignite UI for Angular is a dependency-free Angular toolkit for building modern web apps",
   "author": "Infragistics",
   "license": "SEE LICENSE IN LICENSE",