@progress/kendo-angular-layout 19.0.0-develop.9 → 19.0.1-develop.1

package/codemods/template-transformer/index.js

@@ -0,0 +1,94 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2025 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateTransformer = void 0;
+const node_html_parser_1 = require("node-html-parser");
+function templateTransformer(root, j, ...processFns) {
+    root
+        .find(j.ClassDeclaration)
+        .forEach(classPath => {
+        // Skip if no decorators
+        const classNode = classPath.node;
+        if (!classNode.decorators || !classNode.decorators.length)
+            return;
+        // Find Component decorator
+        const componentDecorator = classNode.decorators.find((decorator) => {
+            if (decorator.expression && decorator.expression.type === 'CallExpression') {
+                const callee = decorator.expression.callee;
+                // Handle direct Component identifier
+                if (callee.type === 'Identifier' && callee.name === 'Component') {
+                    return true;
+                }
+                // Handle angular.core.Component or similar
+                if (callee.type === 'MemberExpression' &&
+                    callee.property &&
+                    callee.property.type === 'Identifier' &&
+                    callee.property.name === 'Component') {
+                    return true;
+                }
+            }
+            return false;
+        });
+        if (!componentDecorator || !componentDecorator.expression)
+            return;
+        const expression = componentDecorator.expression;
+        if (expression.type !== 'CallExpression' || !expression.arguments.length)
+            return;
+        const componentOptions = expression.arguments[0];
+        if (componentOptions.type !== 'ObjectExpression')
+            return;
+        // Find template and templateUrl properties
+        const props = componentOptions.properties || [];
+        const templateProp = props.find((prop) => (prop.key.type === 'Identifier' && prop.key.name === 'template') ||
+            (prop.key.type === 'StringLiteral' && prop.key.value === 'template'));
+        //   const templateUrlProp = props.find((prop: any) =>
+        //     (prop.key.type === 'Identifier' && prop.key.name === 'templateUrl') ||
+        //     (prop.key.type === 'StringLiteral' && prop.key.value === 'templateUrl')
+        //   );
+        // Process inline template
+        if (templateProp) {
+            // Extract template based on node type
+            let originalTemplate;
+            if (templateProp.value.type === 'StringLiteral' || templateProp.value.type === 'Literal') {
+                originalTemplate = templateProp.value.value;
+            }
+            else if (templateProp.value.type === 'TemplateLiteral') {
+                // For template literals, join quasis
+                if (templateProp.value.quasis && templateProp.value.quasis.length) {
+                    originalTemplate = templateProp.value.quasis
+                        .map((q) => q.value.cooked || q.value.raw)
+                        .join('');
+                }
+                else {
+                    console.warn('Could not process TemplateLiteral properly');
+                    return;
+                }
+            }
+            else {
+                console.warn(`Unsupported template type: ${templateProp.value.type}`);
+                return;
+            }
+            const root = (0, node_html_parser_1.parse)(originalTemplate);
+            processFns.forEach(fn => {
+                fn(root);
+            });
+            // Transform template using Angular compiler
+            const transformedTemplate = root.toString();
+            if (transformedTemplate !== originalTemplate) {
+                // Update template property
+                if (templateProp.value.type === 'TemplateLiteral') {
+                    // For template literals, create a new template literal
+                    templateProp.value = j.templateLiteral([j.templateElement({ cooked: transformedTemplate, raw: transformedTemplate }, true)], []);
+                }
+                else {
+                    // For string literals, update the value
+                    templateProp.value.value = transformedTemplate;
+                }
+            }
+        }
+    });
+}
+exports.templateTransformer = templateTransformer;

package/codemods/utils.js

@@ -0,0 +1,553 @@
+/**-----------------------------------------------------------------------------------------
+* 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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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.default)(fileContent);
+    // Use the same logic as templateAttributeRemoval
+    const elements = root.querySelectorAll(tagName);
+    for (const element of elements) {
+        // Look for bound attribute (e.g., [scrollable]="...")
+        const boundAttr = element.getAttribute(`[${attributeName}]`);
+        if (boundAttr) {
+            // Check if it's an object literal
+            if (boundAttr.trim().startsWith('{') && boundAttr.trim().endsWith('}')) {
+                // Process object literal like {mouseScrollSpeed: 10000}
+                const objectLiteral = boundAttr.trim();
+                // Build a regex that matches the property and its value
+                // This handles various formats like {prop: value}, { prop: value }, etc.
+                const propRegex = new RegExp(`\\s*${propertyToRemove}\\s*:\\s*[^,}]+\\s*(,\\s*)?`, 'g');
+                // Remove the property and any trailing comma
+                let newObjectLiteral = objectLiteral.replace(propRegex, '');
+                // Fix syntax if we removed the last property with trailing comma
+                newObjectLiteral = newObjectLiteral.replace(/,\s*}$/, '}');
+                // If the object is now empty, remove the attribute completely
+                if (newObjectLiteral === '{}') {
+                    element.removeAttribute(`[${attributeName}]`);
+                }
+                else {
+                    element.setAttribute(`[${attributeName}]`, newObjectLiteral);
+                }
+            }
+            // Check if it's a variable reference to an object
+            else {
+                // For variable references, we can't modify them in the template
+                // We should warn the user or handle this case specially
+                console.warn(`Cannot remove property from variable reference: ${boundAttr} in file ${filePath}`);
+            }
+        }
+    }
+    // Return the modified HTML content
+    return root.toString();
+};
+exports.htmlAttributeRemoval = htmlAttributeRemoval;
+/**
+ * Removes a specified property from an object binding in HTML templates
+ *
+ * @param root - The HTML root element
+ * @param tagName - The tag to search for (e.g., 'kendo-tabstrip')
+ * @param attributeName - The attribute containing the object binding (e.g., 'scrollable')
+ * @param propertyToRemove - The property to remove from the object (e.g., 'mouseScrollSpeed')
+ */
+const templateAttributeRemoval = (root, tagName, attributeName, propertyToRemove) => {
+    const elements = root.querySelectorAll(tagName);
+    for (const element of elements) {
+        // Look for bound attribute (e.g., [scrollable]="...")
+        const boundAttr = element.getAttribute(`[${attributeName}]`);
+        if (boundAttr) {
+            // Check if it's an object literal
+            if (boundAttr.trim().startsWith('{') && boundAttr.trim().endsWith('}')) {
+                // Process object literal like {mouseScrollSpeed: 10000}
+                const objectLiteral = boundAttr.trim();
+                // Build a regex that matches the property and its value
+                // This handles various formats like {prop: value}, { prop: value }, etc.
+                const propRegex = new RegExp(`\\s*${propertyToRemove}\\s*:\\s*[^,}]+\\s*(,\\s*)?`, 'g');
+                // Remove the property and any trailing comma
+                let newObjectLiteral = objectLiteral.replace(propRegex, '');
+                // Fix syntax if we removed the last property with trailing comma
+                newObjectLiteral = newObjectLiteral.replace(/,\s*}$/, '}');
+                // If the object is now empty, remove the attribute completely
+                if (newObjectLiteral === '{}') {
+                    element.removeAttribute(`[${attributeName}]`);
+                }
+                else {
+                    element.setAttribute(`[${attributeName}]`, newObjectLiteral);
+                }
+            }
+            // Check if it's a variable reference to an object
+            else {
+                // For variable references, we can't modify them in the template
+                // We should warn the user or handle this case specially
+                console.warn(`Cannot remove property from variable reference: ${boundAttr}`);
+            }
+        }
+    }
+};
+exports.templateAttributeRemoval = templateAttributeRemoval;
+/**
+ * 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;
+/**
+ * Removes assignments to a specific nested property of a component
+ *
+ * @param root - The AST root
+ * @param j - The JSCodeshift instance
+ * @param componentType - The component type to target (e.g., 'TabStripComponent')
+ * @param componentProperty - The component property (e.g., 'scrollable')
+ * @param propertyToRemove - The nested property to remove assignments to (e.g., 'mouseScrollSpeed')
+ */
+const tsComponentPropertyRemoval = (root, j, componentType, componentProperty, propertyToRemove) => {
+    // CASE 1: Handle direct property assignments like: foo.scrollable.mouseScrollSpeed = 3000;
+    root
+        .find(j.AssignmentExpression)
+        .filter((path) => {
+        const { left } = path.value;
+        // Check if this is a member expression assignment
+        if (left && left.type === 'MemberExpression') {
+            // Check if we're accessing the property to remove
+            if (left.property && left.property.name === propertyToRemove) {
+                // Check if we're accessing it from component.componentProperty
+                const obj = left.object;
+                if (obj && obj.type === 'MemberExpression' &&
+                    obj.property && obj.property.name === componentProperty) {
+                    // Now check if the base object is our component type
+                    return isComponentTypeMatch(root, j, obj.object, componentType);
+                }
+            }
+        }
+        return false;
+    })
+        .forEach((path) => {
+        // Remove the entire statement
+        j(path).closest(j.ExpressionStatement).remove();
+    });
+    // CASE 2 & 3: Handle object assignments like: foo.scrollable = { mouseScrollSpeed: 3000, ... };
+    root
+        .find(j.AssignmentExpression)
+        .filter((path) => {
+        const { left, right } = path.value;
+        // Check if this assigns to component.componentProperty
+        if (left && left.type === 'MemberExpression' &&
+            left.property && left.property.name === componentProperty &&
+            right && right.type === 'ObjectExpression') {
+            // Check if the base object is our component type
+            return isComponentTypeMatch(root, j, left.object, componentType);
+        }
+        return false;
+    })
+        .forEach((path) => {
+        const properties = path.value.right.properties;
+        // Find the property we want to remove
+        const propIndex = properties.findIndex((p) => p && p.type === 'ObjectProperty' &&
+            p.key && p.key.type === 'Identifier' &&
+            p.key.name === propertyToRemove);
+        if (propIndex !== -1) {
+            // Case 2: If it's the only property, remove the entire statement
+            if (properties.length === 1) {
+                j(path).closest(j.ExpressionStatement).remove();
+            }
+            // Case 3: If there are other properties, just remove this one property
+            else {
+                properties.splice(propIndex, 1);
+            }
+        }
+    });
+    return root;
+};
+exports.tsComponentPropertyRemoval = tsComponentPropertyRemoval;
+// Helper function to check if a node is a component of the specified type
+function isComponentTypeMatch(root, j, node, componentType) {
+    if (!node)
+        return false;
+    // Case 1: Direct match for 'this.propertyName'
+    if (node.type === 'ThisExpression') {
+        return true; // Assuming 'this' refers to the component class
+    }
+    // Case 2: Function parameter
+    if (node.type === 'Identifier') {
+        const paramName = node.name;
+        // Check function parameters
+        return root
+            .find(j.Function)
+            .some(path => {
+            return path.node.params && path.node.params.some((param) => param.type === 'Identifier' &&
+                param.name === paramName &&
+                param.typeAnnotation?.typeAnnotation?.typeName?.name === componentType);
+        });
+    }
+    // Case 3: Member expression (obj.prop)
+    if (node.type === 'MemberExpression') {
+        // This would need more complex logic to determine if the object is of the right type
+        // For now, we can check if it's a property that has been declared with the right type
+        if (node.object.type === 'ThisExpression' && node.property.type === 'Identifier') {
+            const propName = node.property.name;
+            return root
+                .find(j.ClassProperty, {
+                key: { name: propName },
+                typeAnnotation: {
+                    typeAnnotation: {
+                        typeName: { name: componentType }
+                    }
+                }
+            })
+                .size() > 0;
+        }
+    }
+    return false;
+}

package/codemods/v19/tabstrip-mousescrollspeed.js

@@ -0,0 +1,56 @@
+/**-----------------------------------------------------------------------------------------
+* 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 index_1 = require("../template-transformer/index");
+const utils_1 = require("../utils");
+const fs = __importStar(require("fs"));
+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, 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');
+    });
+    // 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;

package/esm2022/package-metadata.mjs

@@ -10,7 +10,7 @@ export const packageMetadata = {
     productName: 'Kendo UI for Angular',
     productCode: 'KENDOUIANGULAR',
     productCodes: ['KENDOUIANGULAR'],
-    publishDate: 1746776414,
-    version: '19.0.0-develop.9',
+    publishDate: 1748425236,
+    version: '19.0.1-develop.1',
     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/esm2022/tabstrip/constants.mjs

@@ -2,10 +2,6 @@
 * Copyright © 2025 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-/**
- * @hidden
- */
-export const MOUSE_SCROLL_SPEED = 10;
 /**
  * @hidden
  */

package/esm2022/tabstrip/models/scrollable-settings.mjs

@@ -2,16 +2,15 @@
 * Copyright © 2025 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-import { BUTTON_SCROLL_SPEED, MOUSE_SCROLL_SPEED } from "../constants";
+import { BUTTON_SCROLL_SPEED } from "../constants";
 /**
  * @hidden
  */
-const normalizeSettings = ({ enabled = true, scrollButtons = 'auto', mouseScroll = true, buttonScrollSpeed = BUTTON_SCROLL_SPEED, mouseScrollSpeed = MOUSE_SCROLL_SPEED, scrollButtonsPosition = 'split', prevButtonIcon, nextButtonIcon, prevSVGButtonIcon, nextSVGButtonIcon }) => ({
+const normalizeSettings = ({ enabled = true, scrollButtons = 'auto', mouseScroll = true, buttonScrollSpeed = BUTTON_SCROLL_SPEED, scrollButtonsPosition = 'split', prevButtonIcon, nextButtonIcon, prevSVGButtonIcon, nextSVGButtonIcon }) => ({
     enabled,
     scrollButtons,
     mouseScroll,
     buttonScrollSpeed,
-    mouseScrollSpeed,
     scrollButtonsPosition,
     prevButtonIcon,
     nextButtonIcon,

package/esm2022/tabstrip/tabstrip.service.mjs

@@ -63,7 +63,7 @@ export class TabStripService {
         if (!NgZone.isInAngularZone()) {
             this.ngZone.run(() => {
                 if (activeIndex < 0) {
-                    this.owner.selectTab(this.firstNavigatableIndex());
+                    this.owner.selectTab(this.firstNavigableIndex());
                     return;
                 }
                 activeTab.focused = false;
@@ -113,14 +113,14 @@ export class TabStripService {
         switch (keyCode) {
             case this.invertKeys(Keys.ArrowLeft, Keys.ArrowRight):
             case this.invertKeys(Keys.ArrowUp, Keys.ArrowDown):
-                return this.prevNavigatableIndex(activeIndex);
+                return this.prevNavigableIndex(activeIndex);
             case this.invertKeys(Keys.ArrowRight, Keys.ArrowLeft):
             case this.invertKeys(Keys.ArrowDown, Keys.ArrowUp):
-                return this.nextNavigatableIndex(activeIndex);
+                return this.nextNavigableIndex(activeIndex);
             case Keys.Home:
-                return this.firstNavigatableIndex();
+                return this.firstNavigableIndex();
             case Keys.End:
-                return this.lastNavigatableIndex();
+                return this.lastNavigableIndex();
             default:
                 return;
         }
@@ -128,21 +128,21 @@ export class TabStripService {
     invertKeys(original, inverted) {
         return this.localization.rtl ? inverted : original;
     }
-    firstNavigatableIndex() {
+    firstNavigableIndex() {
         return 0;
     }
-    lastNavigatableIndex() {
+    lastNavigableIndex() {
         return this.owner.tabs.length - 1;
     }
-    prevNavigatableIndex(selectedIndex) {
+    prevNavigableIndex(selectedIndex) {
         if (selectedIndex - 1 < 0) {
-            return this.lastNavigatableIndex();
+            return this.lastNavigableIndex();
         }
         return selectedIndex - 1;
     }
-    nextNavigatableIndex(selectedIndex) {
+    nextNavigableIndex(selectedIndex) {
         if (selectedIndex + 1 >= this.owner.tabs.length) {
-            return this.firstNavigatableIndex();
+            return this.firstNavigableIndex();
         }
         return selectedIndex + 1;
     }

package/esm2022/tilelayout/keyboard-navigation.service.mjs

@@ -20,7 +20,7 @@ export class TileLayoutKeyboardNavigationService {
     zone;
     renderer;
     localization;
-    navigable = new BehaviorSubject(false);
+    navigable = new BehaviorSubject(true);
     owner;
     mousedown;
     localizationSubscription;

package/esm2022/tilelayout/tilelayout.component.mjs

@@ -87,12 +87,12 @@ export class TileLayoutComponent {
      */
     autoFlow = 'column';
     /**
-     * If set to true, the user can use dedicated shortcuts to interact with the TileLayout.
-     * By default, navigation is disabled and focusable TileLayout content is a part of the natural tab sequence of the page.
+     * When the keyboard navigation is enabled, the user can use dedicated shortcuts to interact with the TileLayout.
+     * By default, navigation is enabled. To disable it and include focusable TileLayout content as a part of the natural tab sequence of the page, set the property to `false`.
      *
-     * @default false
+     * @default true
      */
-    navigable = false;
+    navigable = true;
     /**
      * Fires when the user completes the reordering of the item ([see example]({% slug reordering_tilelayout %})).
      * This event is preventable. If you cancel it, the item will not be reordered.

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

@@ -29,8 +29,8 @@ const packageMetadata = {
     productName: 'Kendo UI for Angular',
     productCode: 'KENDOUIANGULAR',
     productCodes: ['KENDOUIANGULAR'],
-    publishDate: 1746776414,
-    version: '19.0.0-develop.9',
+    publishDate: 1748425236,
+    version: '19.0.1-develop.1',
     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'
 };
 
@@ -3209,7 +3209,7 @@ class TabStripService {
         if (!NgZone.isInAngularZone()) {
             this.ngZone.run(() => {
                 if (activeIndex < 0) {
-                    this.owner.selectTab(this.firstNavigatableIndex());
+                    this.owner.selectTab(this.firstNavigableIndex());
                     return;
                 }
                 activeTab.focused = false;
@@ -3259,14 +3259,14 @@ class TabStripService {
         switch (keyCode) {
             case this.invertKeys(Keys.ArrowLeft, Keys.ArrowRight):
             case this.invertKeys(Keys.ArrowUp, Keys.ArrowDown):
-                return this.prevNavigatableIndex(activeIndex);
+                return this.prevNavigableIndex(activeIndex);
             case this.invertKeys(Keys.ArrowRight, Keys.ArrowLeft):
             case this.invertKeys(Keys.ArrowDown, Keys.ArrowUp):
-                return this.nextNavigatableIndex(activeIndex);
+                return this.nextNavigableIndex(activeIndex);
             case Keys.Home:
-                return this.firstNavigatableIndex();
+                return this.firstNavigableIndex();
             case Keys.End:
-                return this.lastNavigatableIndex();
+                return this.lastNavigableIndex();
             default:
                 return;
         }
@@ -3274,21 +3274,21 @@ class TabStripService {
     invertKeys(original, inverted) {
         return this.localization.rtl ? inverted : original;
     }
-    firstNavigatableIndex() {
+    firstNavigableIndex() {
         return 0;
     }
-    lastNavigatableIndex() {
+    lastNavigableIndex() {
         return this.owner.tabs.length - 1;
     }
-    prevNavigatableIndex(selectedIndex) {
+    prevNavigableIndex(selectedIndex) {
         if (selectedIndex - 1 < 0) {
-            return this.lastNavigatableIndex();
+            return this.lastNavigableIndex();
         }
         return selectedIndex - 1;
     }
-    nextNavigatableIndex(selectedIndex) {
+    nextNavigableIndex(selectedIndex) {
         if (selectedIndex + 1 >= this.owner.tabs.length) {
-            return this.firstNavigatableIndex();
+            return this.firstNavigableIndex();
         }
         return selectedIndex + 1;
     }
@@ -3299,10 +3299,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
             type: Injectable
         }], ctorParameters: function () { return [{ type: i1.LocalizationService }, { type: i0.NgZone }]; } });
 
-/**
- * @hidden
- */
-const MOUSE_SCROLL_SPEED = 10;
 /**
  * @hidden
  */
@@ -3497,12 +3493,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
 /**
  * @hidden
  */
-const normalizeSettings = ({ enabled = true, scrollButtons = 'auto', mouseScroll = true, buttonScrollSpeed = BUTTON_SCROLL_SPEED, mouseScrollSpeed = MOUSE_SCROLL_SPEED, scrollButtonsPosition = 'split', prevButtonIcon, nextButtonIcon, prevSVGButtonIcon, nextSVGButtonIcon }) => ({
+const normalizeSettings = ({ enabled = true, scrollButtons = 'auto', mouseScroll = true, buttonScrollSpeed = BUTTON_SCROLL_SPEED, scrollButtonsPosition = 'split', prevButtonIcon, nextButtonIcon, prevSVGButtonIcon, nextSVGButtonIcon }) => ({
     enabled,
     scrollButtons,
     mouseScroll,
     buttonScrollSpeed,
-    mouseScrollSpeed,
     scrollButtonsPosition,
     prevButtonIcon,
     nextButtonIcon,
@@ -9621,7 +9616,7 @@ class TileLayoutKeyboardNavigationService {
     zone;
     renderer;
     localization;
-    navigable = new BehaviorSubject(false);
+    navigable = new BehaviorSubject(true);
     owner;
     mousedown;
     localizationSubscription;
@@ -10230,12 +10225,12 @@ class TileLayoutComponent {
      */
     autoFlow = 'column';
     /**
-     * If set to true, the user can use dedicated shortcuts to interact with the TileLayout.
-     * By default, navigation is disabled and focusable TileLayout content is a part of the natural tab sequence of the page.
+     * When the keyboard navigation is enabled, the user can use dedicated shortcuts to interact with the TileLayout.
+     * By default, navigation is enabled. To disable it and include focusable TileLayout content as a part of the natural tab sequence of the page, set the property to `false`.
      *
-     * @default false
+     * @default true
      */
-    navigable = false;
+    navigable = true;
     /**
      * Fires when the user completes the reordering of the item ([see example]({% slug reordering_tilelayout %})).
      * This event is preventable. If you cancel it, the item will not be reordered.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@progress/kendo-angular-layout",
-  "version": "19.0.0-develop.9",
+  "version": "19.0.1-develop.1",
   "description": "Kendo UI for Angular Layout Package - a collection of components to create professional application layoyts",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "Progress",
@@ -32,10 +32,25 @@
   ],
   "@progress": {
     "friendlyName": "Layout",
+    "migrations": {
+      "options": {
+        "parser": "tsx",
+        "pattern": "*.{ts,html}"
+      },
+      "codemods": {
+        "19": [
+          {
+            "description": "mousescrollspeed of TabStripScrollableSettings is deprecated",
+            "file": "codemods/v19/tabstrip-mousescrollspeed.js",
+            "prompt": "true"
+          }
+        ]
+      }
+    },
     "package": {
       "productName": "Kendo UI for Angular",
       "productCode": "KENDOUIANGULAR",
-      "publishDate": 1746776414,
+      "publishDate": 1748425236,
       "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"
     }
   },
@@ -45,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.9",
-    "@progress/kendo-angular-l10n": "19.0.0-develop.9",
-    "@progress/kendo-angular-progressbar": "19.0.0-develop.9",
-    "@progress/kendo-angular-icons": "19.0.0-develop.9",
-    "@progress/kendo-angular-buttons": "19.0.0-develop.9",
-    "@progress/kendo-angular-intl": "19.0.0-develop.9",
+    "@progress/kendo-angular-common": "19.0.1-develop.1",
+    "@progress/kendo-angular-l10n": "19.0.1-develop.1",
+    "@progress/kendo-angular-progressbar": "19.0.1-develop.1",
+    "@progress/kendo-angular-icons": "19.0.1-develop.1",
+    "@progress/kendo-angular-buttons": "19.0.1-develop.1",
+    "@progress/kendo-angular-intl": "19.0.1-develop.1",
     "rxjs": "^6.5.3 || ^7.0.0"
   },
   "dependencies": {
     "tslib": "^2.3.1",
-    "@progress/kendo-angular-schematics": "19.0.0-develop.9",
+    "@progress/kendo-angular-schematics": "19.0.1-develop.1",
     "@progress/kendo-draggable": "^3.0.2"
   },
   "schematics": "./schematics/collection.json",

package/tabstrip/constants.d.ts

@@ -2,10 +2,6 @@
 * Copyright © 2025 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-/**
- * @hidden
- */
-export declare const MOUSE_SCROLL_SPEED = 10;
 /**
  * @hidden
  */

package/tabstrip/models/scrollable-settings.d.ts

@@ -30,11 +30,6 @@ export interface TabStripScrollableSettings {
      * @default 100
      */
     buttonScrollSpeed?: number;
-    /**
-     * Deprecated in v.18.0.0 and will be removed in v.19.0.0 of the `@progress/kendo-angular-layout` package.
-     * The scroll speed will naturally follow the user behavior and concrete device specifics.
-     */
-    mouseScrollSpeed?: number;
     /**
      * Allows defining a custom CSS class, or multiple classes separated by spaces, which will be applied to the span element of the prev scroll button.
      *

package/tabstrip/tabstrip.service.d.ts

@@ -25,10 +25,10 @@ export declare class TabStripService {
     private shouldHandleKey;
     private computeNextIndex;
     private invertKeys;
-    private firstNavigatableIndex;
-    private lastNavigatableIndex;
-    private prevNavigatableIndex;
-    private nextNavigatableIndex;
+    private firstNavigableIndex;
+    private lastNavigableIndex;
+    private prevNavigableIndex;
+    private nextNavigableIndex;
     static ɵfac: i0.ɵɵFactoryDeclaration<TabStripService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TabStripService>;
 }

package/tilelayout/tilelayout.component.d.ts

@@ -71,10 +71,10 @@ export declare class TileLayoutComponent implements OnInit, AfterViewInit, After
      */
     autoFlow: TileLayoutFlowMode;
     /**
-     * If set to true, the user can use dedicated shortcuts to interact with the TileLayout.
-     * By default, navigation is disabled and focusable TileLayout content is a part of the natural tab sequence of the page.
+     * When the keyboard navigation is enabled, the user can use dedicated shortcuts to interact with the TileLayout.
+     * By default, navigation is enabled. To disable it and include focusable TileLayout content as a part of the natural tab sequence of the page, set the property to `false`.
      *
-     * @default false
+     * @default true
      */
     navigable: boolean;
     /**