@progress/kendo-angular-layout 19.0.0-develop.27 → 19.0.0-develop.28

package/codemods/utils.js

@@ -3,13 +3,305 @@
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tsPropertyRemoval = exports.tsComponentPropertyRemoval = exports.tsPropertyTransformer = exports.templateAttributeTransformer = exports.templateAttributeRemoval = exports.htmlAttributeRemoval = void 0;
-const node_html_parser_1 = require("node-html-parser");
+exports.tsComponentPropertyRemoval = exports.tsPropertyRemoval = exports.templateAttributeRemoval = exports.htmlAttributeRemoval = exports.htmlAttributeValueTransformer = exports.tsPropertyValueTransformer = exports.templateAttributeValueTransformer = exports.htmlAttributeTransformer = exports.htmlBoundAttributeTransformer = exports.htmlStaticAttributeTransformer = exports.tsPropertyTransformer = exports.templateAttributeTransformer = exports.templateBoundAttributeTransformer = exports.templateStaticAttributeTransformer = void 0;
+const node_html_parser_1 = __importDefault(require("node-html-parser"));
+const templateStaticAttributeTransformer = (root, tagName, attributeName, newAttributeName) => {
+    const elements = Array.from(root.getElementsByTagName(tagName)) || [];
+    for (const element of elements) {
+        // Handle static attributes like title="foo"
+        const staticAttr = element.getAttribute(attributeName);
+        if (staticAttr) {
+            element.setAttribute(newAttributeName, staticAttr);
+            element.removeAttribute(attributeName);
+        }
+    }
+};
+exports.templateStaticAttributeTransformer = templateStaticAttributeTransformer;
+const templateBoundAttributeTransformer = (root, tagName, attributeName, newAttributeName) => {
+    const elements = Array.from(root.getElementsByTagName(tagName)) || [];
+    for (const element of elements) {
+        // Handle bound attributes like [title]="foo" or [title]="'foo'"
+        const boundAttr = element.getAttribute(`[${attributeName}]`);
+        if (boundAttr) {
+            element.setAttribute(`[${newAttributeName}]`, boundAttr);
+            element.removeAttribute(`[${attributeName}]`);
+        }
+    }
+};
+exports.templateBoundAttributeTransformer = templateBoundAttributeTransformer;
+const templateAttributeTransformer = (root, tagName, attributeName, newAttributeName) => {
+    (0, exports.templateBoundAttributeTransformer)(root, tagName, attributeName, newAttributeName);
+    (0, exports.templateStaticAttributeTransformer)(root, tagName, attributeName, newAttributeName);
+};
+exports.templateAttributeTransformer = templateAttributeTransformer;
+const tsPropertyTransformer = (root, j, componentType, propertyName, newPropertyName) => {
+    // Find all class properties that are of type DropDownListComponent
+    const properties = new Set();
+    // Find properties with type annotations
+    root
+        .find(j.ClassProperty, {
+        typeAnnotation: {
+            typeAnnotation: {
+                typeName: {
+                    name: componentType
+                }
+            }
+        }
+    })
+        .forEach(path => {
+        if (path.node.key.type === 'Identifier') {
+            properties.add(path.node.key.name);
+        }
+    });
+    // Find function parameters of type componentType
+    const parameters = new Set();
+    root
+        .find(j.FunctionDeclaration)
+        .forEach(path => {
+        if (path.node.params) {
+            path.node.params.forEach(param => {
+                if (param.type === 'Identifier' &&
+                    param.typeAnnotation &&
+                    param.typeAnnotation.typeAnnotation?.type === 'TSTypeReference' &&
+                    param.typeAnnotation.typeAnnotation.typeName.type === 'Identifier' &&
+                    param.typeAnnotation.typeAnnotation.typeName.name === componentType) {
+                    parameters.add(param.name);
+                }
+            });
+        }
+    });
+    // Also check method declarations in classes
+    root
+        .find(j.ClassMethod)
+        .forEach(path => {
+        if (path.node.params) {
+            path.node.params.forEach(param => {
+                if (param.type === 'Identifier' &&
+                    param.typeAnnotation &&
+                    param.typeAnnotation.typeAnnotation?.type === 'TSTypeReference' &&
+                    param.typeAnnotation.typeAnnotation.typeName.type === 'Identifier' &&
+                    param.typeAnnotation.typeAnnotation.typeName.name === componentType) {
+                    parameters.add(param.name);
+                }
+            });
+        }
+    });
+    // Find all member expressions where title property is accessed on any componentType instance
+    root
+        .find(j.MemberExpression, {
+        property: {
+            type: 'Identifier',
+            name: propertyName
+        }
+    })
+        .filter(path => {
+        // Filter to only include accesses on properties that are componentType instances
+        if (path.node.object.type === 'MemberExpression' &&
+            path.node.object.property.type === 'Identifier') {
+            // handle properties of this
+            if (path.node.object.object.type === 'ThisExpression' &&
+                properties.has(path.node.object.property.name)) {
+                return true;
+            }
+        }
+        // Handle function parameters
+        if (path.node.object.type === 'Identifier' &&
+            parameters.has(path.node.object.name)) {
+            return true;
+        }
+        return false;
+    })
+        .forEach(path => {
+        // Replace old property name with new property name
+        if (path.node.property.type === 'Identifier') {
+            path.node.property.name = newPropertyName;
+        }
+    });
+};
+exports.tsPropertyTransformer = tsPropertyTransformer;
+const htmlStaticAttributeTransformer = (fileInfo, tagName, oldName, newName) => {
+    const fileContent = fileInfo.source;
+    const root = (0, node_html_parser_1.default)(fileContent);
+    let modified = false;
+    const elements = Array.from(root.querySelectorAll(tagName));
+    for (const element of elements) {
+        const staticAttr = element.getAttribute(oldName);
+        if (staticAttr) {
+            element.removeAttribute(oldName);
+            element.setAttribute(newName, staticAttr);
+            modified = true;
+        }
+    }
+    if (modified) {
+        return root.toString();
+    }
+    return fileContent;
+};
+exports.htmlStaticAttributeTransformer = htmlStaticAttributeTransformer;
+const htmlBoundAttributeTransformer = (fileInfo, tagName, oldName, newName) => {
+    const fileContent = fileInfo.source;
+    const root = (0, node_html_parser_1.default)(fileContent);
+    let modified = false;
+    const elements = Array.from(root.querySelectorAll(tagName));
+    for (const element of elements) {
+        const boundAttr = element.getAttribute(`[${oldName}]`);
+        if (boundAttr) {
+            element.removeAttribute(`[${oldName}]`);
+            element.setAttribute(`[${newName}]`, boundAttr);
+            modified = true;
+        }
+    }
+    if (modified) {
+        return root.toString();
+    }
+    return fileContent;
+};
+exports.htmlBoundAttributeTransformer = htmlBoundAttributeTransformer;
+const htmlAttributeTransformer = (fileInfo, tagName, oldName, newName) => {
+    let content = (0, exports.htmlBoundAttributeTransformer)(fileInfo, tagName, oldName, newName);
+    content = (0, exports.htmlStaticAttributeTransformer)({ path: fileInfo.path, source: content }, tagName, oldName, newName);
+    return content;
+};
+exports.htmlAttributeTransformer = htmlAttributeTransformer;
+const templateAttributeValueTransformer = (root, tagName, attributeName, oldAttributeValue, newAttributeValue) => {
+    const elements = Array.from(root.getElementsByTagName(tagName)) || [];
+    for (const element of elements) {
+        // Handle bound attributes (e.g., [showText]="'overflow'")
+        const boundAttr = element.getAttribute(`[${attributeName}]`);
+        if (boundAttr === `'${oldAttributeValue}'`) {
+            // For bound literals like [showText]="'overflow'" or [showText]="\"overflow\""
+            element.setAttribute(`[${attributeName}]`, boundAttr.replace(oldAttributeValue, newAttributeValue));
+        }
+        // Handle static attributes like title="foo"
+        const staticAttrValue = element.getAttribute(attributeName);
+        if (staticAttrValue === oldAttributeValue) {
+            element.setAttribute(attributeName, newAttributeValue);
+        }
+    }
+};
+exports.templateAttributeValueTransformer = templateAttributeValueTransformer;
+const tsPropertyValueTransformer = (root, j, typeName, oldValue, newValue) => {
+    // 1. Find all class properties with the specified type
+    root
+        .find(j.ClassProperty)
+        .filter(path => {
+        // Check if the property has a type annotation matching the specified type
+        if (path.node.typeAnnotation?.typeAnnotation &&
+            path.node.typeAnnotation.typeAnnotation.type === 'TSTypeReference' &&
+            path.node.typeAnnotation.typeAnnotation.typeName &&
+            path.node.typeAnnotation.typeAnnotation.typeName.type === 'Identifier' &&
+            path.node.typeAnnotation.typeAnnotation.typeName.name === typeName) {
+            return true;
+        }
+        return false;
+    })
+        .forEach(path => {
+        // Update the value if it matches the old value
+        if (path.node.value &&
+            path.node.value.type === 'StringLiteral' &&
+            path.node.value.value === oldValue) {
+            path.node.value.value = newValue;
+        }
+    });
+    // 2. Find all assignments to variables of the specified type
+    const variablesOfType = new Set();
+    // First, collect all variables with the specified type
+    root
+        .find(j.VariableDeclarator)
+        .filter(path => {
+        if (path.node.id.type === 'Identifier' &&
+            path.node.id.typeAnnotation?.typeAnnotation &&
+            path.node.id.typeAnnotation.typeAnnotation.type === 'TSTypeReference' &&
+            path.node.id.typeAnnotation.typeAnnotation.typeName.type === 'Identifier' &&
+            path.node.id.typeAnnotation.typeAnnotation.typeName.name === typeName) {
+            return true;
+        }
+        return false;
+    })
+        .forEach(path => {
+        if (path.node.id.type === 'Identifier') {
+            variablesOfType.add(path.node.id.name);
+            // Also update the initial value if it matches
+            if (path.node.init &&
+                path.node.init.type === 'StringLiteral' &&
+                path.node.init.value === oldValue) {
+                path.node.init.value = newValue;
+            }
+        }
+    });
+    // 3. Update literals in assignment expressions
+    root
+        .find(j.AssignmentExpression)
+        .filter(path => {
+        // Only process string literals with the old value
+        return path.node.right.type === 'StringLiteral' &&
+            path.node.right.value === oldValue;
+    })
+        .forEach(path => {
+        // Update the value
+        path.node.right.value = newValue;
+    });
+    // 4. Also look for string literals in attributes within JSX elements
+    root
+        .find(j.JSXAttribute, {
+        value: {
+            type: 'StringLiteral',
+            value: oldValue
+        }
+    })
+        .forEach(path => {
+        if (path.node.value?.type === 'StringLiteral') {
+            path.node.value.value = newValue;
+        }
+    });
+};
+exports.tsPropertyValueTransformer = tsPropertyValueTransformer;
+const htmlAttributeValueTransformer = (fileInfo, tagName, attributeName, oldValue, newValue) => {
+    // Read file content from fileInfo
+    const fileContent = fileInfo.source;
+    // Parse the HTML content
+    const root = (0, node_html_parser_1.default)(fileContent);
+    // Find all elements matching the tagName
+    const elements = root.querySelectorAll(tagName);
+    let modified = false;
+    // Process each element
+    for (const element of elements) {
+        // Handle static attributes (e.g., showText="overflow")
+        const staticAttr = element.getAttribute(attributeName);
+        if (staticAttr === oldValue) {
+            element.setAttribute(attributeName, newValue);
+            modified = true;
+            console.log(`Modified static attribute ${attributeName} from "${oldValue}" to "${newValue}" in element:`, element.toString().substring(0, 100));
+        }
+        // Handle bound attributes (e.g., [showText]="overflow")
+        const boundAttr = element.getAttribute(`[${attributeName}]`);
+        if (boundAttr) {
+            // For bound literals like [showText]="'overflow'" or [showText]="\"overflow\""
+            if (boundAttr === `'${oldValue}'` || boundAttr === `"${oldValue}"`) {
+                const updatedValue = boundAttr.replace(oldValue, newValue);
+                element.setAttribute(`[${attributeName}]`, updatedValue);
+                modified = true;
+                console.log(`Modified bound attribute [${attributeName}] from "${boundAttr}" to "${updatedValue}" in element:`, element.toString().substring(0, 100));
+            }
+        }
+    }
+    // Return modified content if changes were made
+    if (modified) {
+        const updatedContent = root.toString();
+        return updatedContent;
+    }
+    // Return original content if no changes were made or if there was an error
+    return fileContent;
+};
+exports.htmlAttributeValueTransformer = htmlAttributeValueTransformer;
 const htmlAttributeRemoval = (fileInfo, tagName, attributeName, propertyToRemove) => {
     const filePath = fileInfo.path;
     const fileContent = fileInfo.source;
-    const root = (0, node_html_parser_1.parse)(fileContent);
+    const root = (0, node_html_parser_1.default)(fileContent);
     // Use the same logic as templateAttributeRemoval
     const elements = root.querySelectorAll(tagName);
     for (const element of elements) {
@@ -90,109 +382,67 @@ const templateAttributeRemoval = (root, tagName, attributeName, propertyToRemove
     }
 };
 exports.templateAttributeRemoval = templateAttributeRemoval;
-const templateAttributeTransformer = (root, tagName, attributeName, newAttributeName) => {
-    const elements = Array.from(root.getElementsByTagName(tagName)) || [];
-    for (const element of elements) {
-        // Handle bound attributes like [title]="foo" or [title]="'foo'"
-        const boundAttr = element.getAttribute(`[${attributeName}]`);
-        if (boundAttr) {
-            element.setAttribute(`[${newAttributeName}]`, boundAttr);
-            element.removeAttribute(`[${attributeName}]`);
-        }
-        // Handle static attributes like title="foo"
-        const staticAttr = element.getAttribute(attributeName);
-        if (staticAttr) {
-            element.setAttribute(newAttributeName, staticAttr);
-            element.removeAttribute(attributeName);
-        }
-    }
-};
-exports.templateAttributeTransformer = templateAttributeTransformer;
-const tsPropertyTransformer = (root, j, componentType, propertyName, newPropertyName) => {
-    // Find all class properties that are of type DropDownListComponent
-    const properties = new Set();
-    // Find properties with type annotations
-    root
+/**
+ * Removes a property from object literals of a specified type
+ *
+ * @param root - The AST root
+ * @param j - The JSCodeshift instance
+ * @param typeName - The type to target (e.g., 'TabStripScrollableSettings')
+ * @param propertyToRemove - The property to remove (e.g., 'mouseScrollSpeed')
+ */
+function tsPropertyRemoval(rootSource, j, typeName, propertyName) {
+    // Find class properties that have the specified type
+    rootSource
         .find(j.ClassProperty, {
         typeAnnotation: {
             typeAnnotation: {
                 typeName: {
-                    name: componentType
+                    name: typeName
                 }
             }
         }
     })
         .forEach(path => {
-        if (path.node.key.type === 'Identifier') {
-            properties.add(path.node.key.name);
-        }
-    });
-    // Find function parameters of type componentType
-    const parameters = new Set();
-    root
-        .find(j.FunctionDeclaration)
-        .forEach(path => {
-        if (path.node.params) {
-            path.node.params.forEach(param => {
-                if (param.type === 'Identifier' &&
-                    param.typeAnnotation &&
-                    param.typeAnnotation.typeAnnotation?.type === 'TSTypeReference' &&
-                    param.typeAnnotation.typeAnnotation.typeName.type === 'Identifier' &&
-                    param.typeAnnotation.typeAnnotation.typeName.name === componentType) {
-                    parameters.add(param.name);
+        // Check if there's an object literal initializer
+        if (path.node.value && path.node.value.type === 'ObjectExpression') {
+            const properties = path.node.value.properties;
+            // Find the property we want to remove - safely handle different property types
+            const propIndex = properties.findIndex((p) => p.type === 'ObjectProperty' &&
+                p.key &&
+                p.key.type === 'Identifier' &&
+                p.key.name === propertyName);
+            if (propIndex !== -1) {
+                // If property exists, remove it
+                // Case 1: If it's the only property, remove the entire class property
+                if (properties.length === 1) {
+                    j(path).remove();
                 }
-            });
-        }
-    });
-    // Also check method declarations in classes
-    root
-        .find(j.ClassMethod)
-        .forEach(path => {
-        if (path.node.params) {
-            path.node.params.forEach(param => {
-                if (param.type === 'Identifier' &&
-                    param.typeAnnotation &&
-                    param.typeAnnotation.typeAnnotation?.type === 'TSTypeReference' &&
-                    param.typeAnnotation.typeAnnotation.typeName.type === 'Identifier' &&
-                    param.typeAnnotation.typeAnnotation.typeName.name === componentType) {
-                    parameters.add(param.name);
+                // Case 2: If there are other properties, just remove this one property
+                else {
+                    properties.splice(propIndex, 1);
                 }
-            });
+            }
         }
     });
-    // Find all member expressions where title property is accessed on any componentType instance
-    root
-        .find(j.MemberExpression, {
-        property: {
-            type: 'Identifier',
-            name: propertyName
-        }
-    })
-        .filter(path => {
-        // Filter to only include accesses on properties that are componentType instances
-        if (path.node.object.type === 'MemberExpression' &&
-            path.node.object.property.type === 'Identifier') {
-            // handle properties of this
-            if (path.node.object.object.type === 'ThisExpression' &&
-                properties.has(path.node.object.property.name)) {
-                return true;
+    // Also handle property assignments (e.g., in methods like ngOnInit)
+    rootSource
+        .find(j.AssignmentExpression, {
+        left: {
+            type: 'MemberExpression',
+            object: {
+                type: 'MemberExpression'
+            },
+            property: {
+                name: propertyName
             }
         }
-        // Handle function parameters
-        if (path.node.object.type === 'Identifier' &&
-            parameters.has(path.node.object.name)) {
-            return true;
-        }
-        return false;
     })
         .forEach(path => {
-        // Replace old property name with new property name
-        if (path.node.property.type === 'Identifier') {
-            path.node.property.name = newPropertyName;
-        }
+        j(path).remove();
     });
-};
-exports.tsPropertyTransformer = tsPropertyTransformer;
+    return rootSource;
+}
+exports.tsPropertyRemoval = tsPropertyRemoval;
 /**
  * Removes assignments to a specific nested property of a component
  *
@@ -301,64 +551,3 @@ function isComponentTypeMatch(root, j, node, componentType) {
     }
     return false;
 }
-/**
- * Removes a property from object literals of a specified type
- *
- * @param root - The AST root
- * @param j - The JSCodeshift instance
- * @param typeName - The type to target (e.g., 'TabStripScrollableSettings')
- * @param propertyToRemove - The property to remove (e.g., 'mouseScrollSpeed')
- */
-function tsPropertyRemoval(rootSource, j, typeName, propertyName) {
-    // Find class properties that have the specified type
-    rootSource
-        .find(j.ClassProperty, {
-        typeAnnotation: {
-            typeAnnotation: {
-                typeName: {
-                    name: typeName
-                }
-            }
-        }
-    })
-        .forEach(path => {
-        // Check if there's an object literal initializer
-        if (path.node.value && path.node.value.type === 'ObjectExpression') {
-            const properties = path.node.value.properties;
-            // Find the property we want to remove - safely handle different property types
-            const propIndex = properties.findIndex((p) => p.type === 'ObjectProperty' &&
-                p.key &&
-                p.key.type === 'Identifier' &&
-                p.key.name === propertyName);
-            if (propIndex !== -1) {
-                // If property exists, remove it
-                // Case 1: If it's the only property, remove the entire class property
-                if (properties.length === 1) {
-                    j(path).remove();
-                }
-                // Case 2: If there are other properties, just remove this one property
-                else {
-                    properties.splice(propIndex, 1);
-                }
-            }
-        }
-    });
-    // Also handle property assignments (e.g., in methods like ngOnInit)
-    rootSource
-        .find(j.AssignmentExpression, {
-        left: {
-            type: 'MemberExpression',
-            object: {
-                type: 'MemberExpression'
-            },
-            property: {
-                name: propertyName
-            }
-        }
-    })
-        .forEach(path => {
-        j(path).remove();
-    });
-    return rootSource;
-}
-exports.tsPropertyRemoval = tsPropertyRemoval;

package/codemods/v19/tabstrip-mousescrollspeed.js

@@ -27,7 +27,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const template_transformer_1 = require("../template-transformer");
+const index_1 = require("../template-transformer/index");
 const utils_1 = require("../utils");
 const fs = __importStar(require("fs"));
 function default_1(fileInfo, api) {
@@ -43,7 +43,7 @@ function default_1(fileInfo, api) {
     }
     const j = api.jscodeshift;
     const rootSource = j(fileInfo.source);
-    (0, template_transformer_1.templateTransformer)(rootSource, j, (root) => {
+    (0, index_1.templateTransformer)(rootSource, j, (root) => {
         // Using node-html-parser to parse and manipulate the template: https://github.com/taoqf/node-html-parser
         (0, utils_1.templateAttributeRemoval)(root, 'kendo-tabstrip', 'scrollable', 'mouseScrollSpeed');
     });

package/esm2022/package-metadata.mjs

@@ -10,7 +10,7 @@ export const packageMetadata = {
     productName: 'Kendo UI for Angular',
     productCode: 'KENDOUIANGULAR',
     productCodes: ['KENDOUIANGULAR'],
-    publishDate: 1747748243,
-    version: '19.0.0-develop.27',
+    publishDate: 1747760820,
+    version: '19.0.0-develop.28',
     licensingDocsUrl: 'https://www.telerik.com/kendo-angular-ui/my-license/?utm_medium=product&utm_source=kendoangular&utm_campaign=kendo-ui-angular-purchase-license-keys-warning'
 };

package/fesm2022/progress-kendo-angular-layout.mjs

@@ -29,8 +29,8 @@ const packageMetadata = {
     productName: 'Kendo UI for Angular',
     productCode: 'KENDOUIANGULAR',
     productCodes: ['KENDOUIANGULAR'],
-    publishDate: 1747748243,
-    version: '19.0.0-develop.27',
+    publishDate: 1747760820,
+    version: '19.0.0-develop.28',
     licensingDocsUrl: 'https://www.telerik.com/kendo-angular-ui/my-license/?utm_medium=product&utm_source=kendoangular&utm_campaign=kendo-ui-angular-purchase-license-keys-warning'
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@progress/kendo-angular-layout",
-  "version": "19.0.0-develop.27",
+  "version": "19.0.0-develop.28",
   "description": "Kendo UI for Angular Layout Package - a collection of components to create professional application layoyts",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "Progress",
@@ -35,18 +35,13 @@
     "migrations": {
       "options": {
         "parser": "tsx",
-        "pattern": "*.{t,j}s"
+        "pattern": "*.{ts,html}"
       },
       "codemods": {
         "19": [
-          {
-            "description": "Migrate all breaking changes for the layout package",
-            "file": "codemods/v19/index.js",
-            "prompt": "true"
-          },
           {
             "description": "mousescrollspeed of TabStripScrollableSettings is deprecated",
-            "file": "codemods/v19/tabstrip-mousescrollspeed.ts",
+            "file": "codemods/v19/tabstrip-mousescrollspeed.js",
             "prompt": "true"
           }
         ]
@@ -55,7 +50,7 @@
     "package": {
       "productName": "Kendo UI for Angular",
       "productCode": "KENDOUIANGULAR",
-      "publishDate": 1747748243,
+      "publishDate": 1747760820,
       "licensingDocsUrl": "https://www.telerik.com/kendo-angular-ui/my-license/?utm_medium=product&utm_source=kendoangular&utm_campaign=kendo-ui-angular-purchase-license-keys-warning"
     }
   },
@@ -65,17 +60,17 @@
     "@angular/core": "16 - 19",
     "@angular/platform-browser": "16 - 19",
     "@progress/kendo-licensing": "^1.5.0",
-    "@progress/kendo-angular-common": "19.0.0-develop.27",
-    "@progress/kendo-angular-l10n": "19.0.0-develop.27",
-    "@progress/kendo-angular-progressbar": "19.0.0-develop.27",
-    "@progress/kendo-angular-icons": "19.0.0-develop.27",
-    "@progress/kendo-angular-buttons": "19.0.0-develop.27",
-    "@progress/kendo-angular-intl": "19.0.0-develop.27",
+    "@progress/kendo-angular-common": "19.0.0-develop.28",
+    "@progress/kendo-angular-l10n": "19.0.0-develop.28",
+    "@progress/kendo-angular-progressbar": "19.0.0-develop.28",
+    "@progress/kendo-angular-icons": "19.0.0-develop.28",
+    "@progress/kendo-angular-buttons": "19.0.0-develop.28",
+    "@progress/kendo-angular-intl": "19.0.0-develop.28",
     "rxjs": "^6.5.3 || ^7.0.0"
   },
   "dependencies": {
     "tslib": "^2.3.1",
-    "@progress/kendo-angular-schematics": "19.0.0-develop.27",
+    "@progress/kendo-angular-schematics": "19.0.0-develop.28",
     "@progress/kendo-draggable": "^3.0.2"
   },
   "schematics": "./schematics/collection.json",

package/codemods/v19/index.js

@@ -1,56 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2025 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const template_transformer_1 = require("../template-transformer");
-const fs = __importStar(require("fs"));
-const utils_1 = require("../utils");
-function default_1(fileInfo, api) {
-    const filePath = fileInfo.path;
-    // Check if the file is an HTML file
-    if (filePath.endsWith('.html')) {
-        const filePath = fileInfo.path;
-        let updatedContent = fileInfo.source;
-        updatedContent = (0, utils_1.htmlAttributeRemoval)({ ...fileInfo, source: updatedContent }, 'kendo-tabstrip', 'scrollable', 'mouseScrollSpeed');
-        // Only write to file once after all transformations
-        fs.writeFileSync(filePath, updatedContent, 'utf-8');
-        return;
-    }
-    const j = api.jscodeshift;
-    const rootSource = j(fileInfo.source);
-    (0, template_transformer_1.templateTransformer)(rootSource, j, (root) => {
-        // Using node-html-parser to parse and manipulate the template: https://github.com/taoqf/node-html-parser
-        (0, utils_1.templateAttributeRemoval)(root, 'kendo-tabstrip', 'scrollable', 'mouseScrollSpeed');
-    });
-    // Remove mouseScrollSpeed property from TabStripScrollableSettings type
-    (0, utils_1.tsPropertyRemoval)(rootSource, j, 'TabStripScrollableSettings', 'mouseScrollSpeed');
-    // Remove assignments to tabstrip.scrollable.mouseScrollSpeed
-    (0, utils_1.tsComponentPropertyRemoval)(rootSource, j, 'TabStripComponent', 'scrollable', 'mouseScrollSpeed');
-    return rootSource.toSource();
-}
-exports.default = default_1;