@progress/kendo-angular-grid 23.0.0-develop.11 → 23.0.0-develop.12

package/codemods/utils.js

@@ -775,6 +775,83 @@ const tsPropertyTransformer = (source, root, j, packageName, componentType, prop
                 localVariables.add(path.node.id.name);
             }
         });
+        // Find array variables of type componentType[]
+        // This handles cases like: const arr: ChatComponent[] = [...]; arr[0].property = value;
+        const arrayVariables = new Set();
+        root.find(j.VariableDeclarator).forEach((path) => {
+            if (path.node.id.type === 'Identifier' &&
+                path.node.id.typeAnnotation &&
+                path.node.id.typeAnnotation.typeAnnotation?.type === 'TSArrayType' &&
+                path.node.id.typeAnnotation.typeAnnotation.elementType?.type === 'TSTypeReference' &&
+                path.node.id.typeAnnotation.typeAnnotation.elementType.typeName?.type === 'Identifier' &&
+                path.node.id.typeAnnotation.typeAnnotation.elementType.typeName.name === componentType) {
+                arrayVariables.add(path.node.id.name);
+            }
+        });
+        // Find object properties that have componentType (e.g., {chat: ChatComponent})
+        // This handles cases like: const config: {chat: ChatComponent} = {...}; config.chat.property = value;
+        const objectProperties = new Map(); // Maps variable name to property names
+        root.find(j.VariableDeclarator).forEach((path) => {
+            if (path.node.id.type === 'Identifier' &&
+                path.node.id.typeAnnotation &&
+                path.node.id.typeAnnotation.typeAnnotation?.type === 'TSTypeLiteral') {
+                const varName = path.node.id.name;
+                const members = path.node.id.typeAnnotation.typeAnnotation.members;
+                members.forEach((member) => {
+                    if (member.type === 'TSPropertySignature' &&
+                        member.key &&
+                        member.key.type === 'Identifier' &&
+                        member.typeAnnotation &&
+                        member.typeAnnotation.typeAnnotation?.type === 'TSTypeReference' &&
+                        member.typeAnnotation.typeAnnotation.typeName?.type === 'Identifier' &&
+                        member.typeAnnotation.typeAnnotation.typeName.name === componentType) {
+                        if (!objectProperties.has(varName)) {
+                            objectProperties.set(varName, []);
+                        }
+                        objectProperties.get(varName).push(member.key.name);
+                    }
+                });
+            }
+        });
+        // Helper function to check if a node is a componentType instance
+        const isComponentTypeInstance = (node) => {
+            // Direct identifier (parameter or local variable)
+            if (node.type === 'Identifier') {
+                return parameters.has(node.name) || localVariables.has(node.name);
+            }
+            // this.property where property is of componentType
+            if (node.type === 'MemberExpression' && node.property.type === 'Identifier') {
+                if (node.object.type === 'ThisExpression' && properties.has(node.property.name)) {
+                    return true;
+                }
+                // Handle nested object properties: objectVar.propertyName where propertyName is of componentType
+                if (node.object.type === 'Identifier') {
+                    const objName = node.object.name;
+                    const propName = node.property.name;
+                    if (objectProperties.has(objName)) {
+                        const props = objectProperties.get(objName);
+                        return props.includes(propName);
+                    }
+                }
+            }
+            // Array element access: arrayVar[index]
+            if (node.type === 'MemberExpression' &&
+                node.object.type === 'Identifier' &&
+                arrayVariables.has(node.object.name)) {
+                return true;
+            }
+            // TypeScript type assertions like (this.componentProperty as ComponentType)
+            if (node.type === 'TSAsExpression') {
+                if (node.typeAnnotation &&
+                    node.typeAnnotation.type === 'TSTypeReference' &&
+                    node.typeAnnotation.typeName &&
+                    node.typeAnnotation.typeName.type === 'Identifier' &&
+                    node.typeAnnotation.typeName.name === componentType) {
+                    return true;
+                }
+            }
+            return false;
+        };
         // Find all member expressions where propertyName is accessed on any componentType instance
         root.find(j.MemberExpression, {
             property: {
@@ -783,31 +860,7 @@ const tsPropertyTransformer = (source, root, j, packageName, componentType, prop
             },
         })
             .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 and local variables
-            if (path.node.object.type === 'Identifier') {
-                return parameters.has(path.node.object.name) || localVariables.has(path.node.object.name);
-            }
-            // Handle TypeScript type assertions like (this.componentProperty as ComponentType).property
-            if (path.node.object.type === 'TSAsExpression') {
-                const typeAssertion = path.node.object;
-                // Check if the type assertion is casting to our componentType
-                if (typeAssertion.typeAnnotation &&
-                    typeAssertion.typeAnnotation.type === 'TSTypeReference' &&
-                    typeAssertion.typeAnnotation.typeName &&
-                    typeAssertion.typeAnnotation.typeName.type === 'Identifier' &&
-                    typeAssertion.typeAnnotation.typeName.name === componentType) {
-                    return true;
-                }
-            }
-            return false;
+            return isComponentTypeInstance(path.node.object);
         })
             .forEach((path) => {
             // Replace old property name with new property name
@@ -844,6 +897,91 @@ const tsPropertyTransformer = (source, root, j, packageName, componentType, prop
                 }
             }
         });
+        // Transform object literal properties in variable declarations and assignments
+        // This handles cases like: const obj: ComponentType = { oldProperty: 'value' }
+        root.find(j.VariableDeclarator)
+            .filter((path) => {
+            // Check if the variable has the componentType type annotation
+            return Boolean(path.node.id.type === 'Identifier' &&
+                path.node.id.typeAnnotation &&
+                path.node.id.typeAnnotation.typeAnnotation?.type === 'TSTypeReference' &&
+                path.node.id.typeAnnotation.typeAnnotation.typeName?.type === 'Identifier' &&
+                path.node.id.typeAnnotation.typeAnnotation.typeName.name === componentType);
+        })
+            .forEach((path) => {
+            // Check if the initializer is an object expression
+            if (path.node.init && path.node.init.type === 'ObjectExpression') {
+                path.node.init.properties.forEach((prop) => {
+                    // Rename the property if it matches
+                    if (prop.type === 'ObjectProperty' &&
+                        prop.key &&
+                        prop.key.type === 'Identifier' &&
+                        prop.key.name === propertyName) {
+                        prop.key.name = newPropertyName;
+                    }
+                });
+            }
+        });
+        // Transform object literal properties in class properties
+        // This handles cases like: customMessages: ComponentType = { oldProperty: 'value' }
+        root.find(j.ClassProperty)
+            .filter((path) => {
+            // Check if the property has the componentType type annotation
+            return Boolean(path.node.typeAnnotation &&
+                path.node.typeAnnotation.typeAnnotation?.type === 'TSTypeReference' &&
+                path.node.typeAnnotation.typeAnnotation.typeName?.type === 'Identifier' &&
+                path.node.typeAnnotation.typeAnnotation.typeName.name === componentType);
+        })
+            .forEach((path) => {
+            // Check if the value is an object expression
+            if (path.node.value && path.node.value.type === 'ObjectExpression') {
+                path.node.value.properties.forEach((prop) => {
+                    // Rename the property if it matches
+                    if (prop.type === 'ObjectProperty' &&
+                        prop.key &&
+                        prop.key.type === 'Identifier' &&
+                        prop.key.name === propertyName) {
+                        prop.key.name = newPropertyName;
+                    }
+                });
+            }
+        });
+        // Transform object literal properties in assignment expressions
+        // This handles cases like: this.obj = { oldProperty: 'value' }
+        root.find(j.AssignmentExpression)
+            .filter((path) => {
+            // Check if we're assigning an object literal
+            return path.node.right.type === 'ObjectExpression';
+        })
+            .forEach((path) => {
+            // We need to determine if the left side is of componentType
+            // This is more complex as we need to check the type of the assignment target
+            const leftSide = path.node.left;
+            let isTargetComponentType = false;
+            // Check if it's a property that we know is of componentType
+            if (leftSide.type === 'MemberExpression' && leftSide.property.type === 'Identifier') {
+                if (leftSide.object.type === 'ThisExpression' && properties.has(leftSide.property.name)) {
+                    isTargetComponentType = true;
+                }
+                else if (leftSide.object.type === 'Identifier' && localVariables.has(leftSide.object.name)) {
+                    isTargetComponentType = true;
+                }
+            }
+            else if (leftSide.type === 'Identifier') {
+                isTargetComponentType = localVariables.has(leftSide.name) || parameters.has(leftSide.name);
+            }
+            if (isTargetComponentType && path.node.right.type === 'ObjectExpression') {
+                path.node.right.properties.forEach((prop) => {
+                    // Rename the property if it matches
+                    if (prop.type === 'ObjectProperty' &&
+                        prop.key &&
+                        prop.key.type === 'Identifier' &&
+                        prop.key.name === propertyName) {
+                        prop.key.name = newPropertyName;
+                    }
+                });
+            }
+        });
     }
 };
 exports.tsPropertyTransformer = tsPropertyTransformer;
@@ -1022,6 +1160,103 @@ const tsInterfaceTransformer = (fileInfo, rootSource, j, packageName, interfaceN
                 path.node.callee.name = newName;
             }
         });
+        // Helper function to recursively transform type references
+        const transformTypeReference = (typeNode) => {
+            if (!typeNode)
+                return;
+            // Handle TSTypeReference (e.g., FileSelectSettings)
+            if (typeNode.type === 'TSTypeReference' &&
+                typeNode.typeName &&
+                typeNode.typeName.type === 'Identifier' &&
+                typeNode.typeName.name === interfaceName) {
+                typeNode.typeName.name = newName;
+            }
+            // Handle TSArrayType (e.g., FileSelectSettings[])
+            if (typeNode.type === 'TSArrayType' && typeNode.elementType) {
+                transformTypeReference(typeNode.elementType);
+            }
+            // Handle generic Array<T> (e.g., Array<FileSelectSettings>)
+            if (typeNode.type === 'TSTypeReference' &&
+                typeNode.typeParameters &&
+                typeNode.typeParameters.params) {
+                typeNode.typeParameters.params.forEach((param) => {
+                    transformTypeReference(param);
+                });
+            }
+            // Handle TSTypeLiteral (e.g., { primary: FileSelectSettings })
+            if (typeNode.type === 'TSTypeLiteral' && typeNode.members) {
+                typeNode.members.forEach((member) => {
+                    if (member.typeAnnotation && member.typeAnnotation.typeAnnotation) {
+                        transformTypeReference(member.typeAnnotation.typeAnnotation);
+                    }
+                });
+            }
+            // Handle TSFunctionType (e.g., (settings: FileSelectSettings) => void)
+            if (typeNode.type === 'TSFunctionType') {
+                if (typeNode.parameters) {
+                    typeNode.parameters.forEach((param) => {
+                        if (param.typeAnnotation && param.typeAnnotation.typeAnnotation) {
+                            transformTypeReference(param.typeAnnotation.typeAnnotation);
+                        }
+                    });
+                }
+                if (typeNode.typeAnnotation && typeNode.typeAnnotation.typeAnnotation) {
+                    transformTypeReference(typeNode.typeAnnotation.typeAnnotation);
+                }
+            }
+        };
+        // Apply recursive transformation to all type annotations
+        rootSource.find(j.VariableDeclarator).forEach((path) => {
+            if (path.node.id.type === 'Identifier' &&
+                path.node.id.typeAnnotation &&
+                path.node.id.typeAnnotation.typeAnnotation) {
+                transformTypeReference(path.node.id.typeAnnotation.typeAnnotation);
+            }
+        });
+        rootSource.find(j.ClassProperty).forEach((path) => {
+            if (path.node.typeAnnotation && path.node.typeAnnotation.typeAnnotation) {
+                transformTypeReference(path.node.typeAnnotation.typeAnnotation);
+            }
+        });
+        rootSource.find(j.ClassMethod).forEach((path) => {
+            if (path.node.returnType && path.node.returnType.typeAnnotation) {
+                transformTypeReference(path.node.returnType.typeAnnotation);
+            }
+            // Transform parameter types recursively
+            if (path.node.params) {
+                path.node.params.forEach((param) => {
+                    if (param.typeAnnotation && param.typeAnnotation.typeAnnotation) {
+                        transformTypeReference(param.typeAnnotation.typeAnnotation);
+                    }
+                });
+            }
+        });
+        rootSource.find(j.FunctionDeclaration).forEach((path) => {
+            if (path.node.returnType && path.node.returnType.typeAnnotation) {
+                transformTypeReference(path.node.returnType.typeAnnotation);
+            }
+            // Transform parameter types recursively
+            if (path.node.params) {
+                path.node.params.forEach((param) => {
+                    if (param.typeAnnotation && param.typeAnnotation.typeAnnotation) {
+                        transformTypeReference(param.typeAnnotation.typeAnnotation);
+                    }
+                });
+            }
+        });
+        rootSource.find(j.ArrowFunctionExpression).forEach((path) => {
+            if (path.node.returnType && path.node.returnType.typeAnnotation) {
+                transformTypeReference(path.node.returnType.typeAnnotation);
+            }
+            // Transform parameter types recursively
+            if (path.node.params) {
+                path.node.params.forEach((param) => {
+                    if (param.typeAnnotation && param.typeAnnotation.typeAnnotation) {
+                        transformTypeReference(param.typeAnnotation.typeAnnotation);
+                    }
+                });
+            }
+        });
     }
 };
 exports.tsInterfaceTransformer = tsInterfaceTransformer;
@@ -1035,21 +1270,26 @@ function isComponentTypeMatch(root, j, node, componentType) {
     if (node.type === 'Identifier') {
         const paramName = node.name;
         // Check function parameters
-        const isParameter = 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));
+        let isParameter = false;
+        root.find(j.Function).forEach((path) => {
+            if (path.node.params && path.node.params.some((param) => param.type === 'Identifier' &&
+                param.name === paramName &&
+                param.typeAnnotation?.typeAnnotation?.typeName?.name === componentType)) {
+                isParameter = true;
+            }
         });
         if (isParameter)
             return true;
         // Check local variable declarations
-        const isLocalVariable = root.find(j.VariableDeclarator).some((path) => {
-            return (path.node.id.type === 'Identifier' &&
+        let isLocalVariable = false;
+        root.find(j.VariableDeclarator).forEach((path) => {
+            if (path.node.id.type === 'Identifier' &&
                 path.node.id.name === paramName &&
                 path.node.id.typeAnnotation?.typeAnnotation?.type === 'TSTypeReference' &&
                 path.node.id.typeAnnotation.typeAnnotation.typeName?.type === 'Identifier' &&
-                path.node.id.typeAnnotation.typeAnnotation.typeName.name === componentType);
+                path.node.id.typeAnnotation.typeAnnotation.typeName.name === componentType) {
+                isLocalVariable = true;
+            }
         });
         return isLocalVariable;
     }
@@ -1072,13 +1312,14 @@ function isComponentTypeMatch(root, j, node, componentType) {
             const varName = node.object.name;
             const propName = node.property.name;
             // Check if this is an object with a property of componentType
-            const hasMatchingProperty = root.find(j.VariableDeclarator).some((path) => {
+            let hasMatchingProperty = false;
+            root.find(j.VariableDeclarator).forEach((path) => {
                 if (path.node.id.type === 'Identifier' &&
                     path.node.id.name === varName &&
                     path.node.id.typeAnnotation &&
                     path.node.id.typeAnnotation.typeAnnotation?.type === 'TSTypeLiteral') {
                     const members = path.node.id.typeAnnotation.typeAnnotation.members;
-                    return members.some((member) => {
+                    const found = members.some((member) => {
                         return (member.type === 'TSPropertySignature' &&
                             member.key?.type === 'Identifier' &&
                             member.key.name === propName &&
@@ -1086,8 +1327,10 @@ function isComponentTypeMatch(root, j, node, componentType) {
                             member.typeAnnotation.typeAnnotation.typeName?.type === 'Identifier' &&
                             member.typeAnnotation.typeAnnotation.typeName.name === componentType);
                     });
+                    if (found) {
+                        hasMatchingProperty = true;
+                    }
                 }
-                return false;
             });
             return hasMatchingProperty;
         }
@@ -1097,13 +1340,16 @@ function isComponentTypeMatch(root, j, node, componentType) {
     if (node.type === 'MemberExpression' && node.computed === true && node.object.type === 'Identifier') {
         const arrayName = node.object.name;
         // Check if this array is of type ChatComponent[]
-        const isComponentArray = root.find(j.VariableDeclarator).some((path) => {
-            return (path.node.id.type === 'Identifier' &&
+        let isComponentArray = false;
+        root.find(j.VariableDeclarator).forEach((path) => {
+            if (path.node.id.type === 'Identifier' &&
                 path.node.id.name === arrayName &&
                 path.node.id.typeAnnotation?.typeAnnotation?.type === 'TSArrayType' &&
                 path.node.id.typeAnnotation.typeAnnotation.elementType?.type === 'TSTypeReference' &&
                 path.node.id.typeAnnotation.typeAnnotation.elementType.typeName?.type === 'Identifier' &&
-                path.node.id.typeAnnotation.typeAnnotation.elementType.typeName.name === componentType);
+                path.node.id.typeAnnotation.typeAnnotation.elementType.typeName.name === componentType) {
+                isComponentArray = true;
+            }
         });
         return isComponentArray;
     }

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

@@ -24136,7 +24136,7 @@ const packageMetadata = {
     productCode: 'KENDOUIANGULAR',
     productCodes: ['KENDOUIANGULAR'],
     publishDate: 0,
-    version: '23.0.0-develop.11',
+    version: '23.0.0-develop.12',
     licensingDocsUrl: 'https://www.telerik.com/kendo-angular-ui/my-license/'
 };
 

package/package-metadata.mjs

@@ -7,7 +7,7 @@ export const packageMetadata = {
   "productCodes": [
     "KENDOUIANGULAR"
   ],
-  "publishDate": 1770728439,
-  "version": "23.0.0-develop.11",
+  "publishDate": 1770731600,
+  "version": "23.0.0-develop.12",
   "licensingDocsUrl": "https://www.telerik.com/kendo-angular-ui/my-license/"
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@progress/kendo-angular-grid",
-  "version": "23.0.0-develop.11",
+  "version": "23.0.0-develop.12",
   "description": "Kendo UI Grid for Angular - high performance data grid with paging, filtering, virtualization, CRUD, and more.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "Progress",
@@ -73,7 +73,7 @@
     "package": {
       "productName": "Kendo UI for Angular",
       "productCode": "KENDOUIANGULAR",
-      "publishDate": 1770728439,
+      "publishDate": 1770731600,
       "licensingDocsUrl": "https://www.telerik.com/kendo-angular-ui/my-license/"
     }
   },
@@ -86,32 +86,32 @@
     "@progress/kendo-data-query": "^1.7.3",
     "@progress/kendo-drawing": "^1.24.0",
     "@progress/kendo-licensing": "^1.10.0",
-    "@progress/kendo-angular-buttons": "23.0.0-develop.11",
-    "@progress/kendo-angular-common": "23.0.0-develop.11",
-    "@progress/kendo-angular-dateinputs": "23.0.0-develop.11",
-    "@progress/kendo-angular-layout": "23.0.0-develop.11",
-    "@progress/kendo-angular-navigation": "23.0.0-develop.11",
-    "@progress/kendo-angular-dropdowns": "23.0.0-develop.11",
-    "@progress/kendo-angular-excel-export": "23.0.0-develop.11",
-    "@progress/kendo-angular-icons": "23.0.0-develop.11",
-    "@progress/kendo-angular-indicators": "23.0.0-develop.11",
-    "@progress/kendo-angular-inputs": "23.0.0-develop.11",
-    "@progress/kendo-angular-conversational-ui": "23.0.0-develop.11",
-    "@progress/kendo-angular-intl": "23.0.0-develop.11",
-    "@progress/kendo-angular-l10n": "23.0.0-develop.11",
-    "@progress/kendo-angular-label": "23.0.0-develop.11",
-    "@progress/kendo-angular-menu": "23.0.0-develop.11",
-    "@progress/kendo-angular-pager": "23.0.0-develop.11",
-    "@progress/kendo-angular-pdf-export": "23.0.0-develop.11",
-    "@progress/kendo-angular-popup": "23.0.0-develop.11",
-    "@progress/kendo-angular-toolbar": "23.0.0-develop.11",
-    "@progress/kendo-angular-upload": "23.0.0-develop.11",
-    "@progress/kendo-angular-utils": "23.0.0-develop.11",
+    "@progress/kendo-angular-buttons": "23.0.0-develop.12",
+    "@progress/kendo-angular-common": "23.0.0-develop.12",
+    "@progress/kendo-angular-dateinputs": "23.0.0-develop.12",
+    "@progress/kendo-angular-layout": "23.0.0-develop.12",
+    "@progress/kendo-angular-navigation": "23.0.0-develop.12",
+    "@progress/kendo-angular-dropdowns": "23.0.0-develop.12",
+    "@progress/kendo-angular-excel-export": "23.0.0-develop.12",
+    "@progress/kendo-angular-icons": "23.0.0-develop.12",
+    "@progress/kendo-angular-indicators": "23.0.0-develop.12",
+    "@progress/kendo-angular-inputs": "23.0.0-develop.12",
+    "@progress/kendo-angular-conversational-ui": "23.0.0-develop.12",
+    "@progress/kendo-angular-intl": "23.0.0-develop.12",
+    "@progress/kendo-angular-l10n": "23.0.0-develop.12",
+    "@progress/kendo-angular-label": "23.0.0-develop.12",
+    "@progress/kendo-angular-menu": "23.0.0-develop.12",
+    "@progress/kendo-angular-pager": "23.0.0-develop.12",
+    "@progress/kendo-angular-pdf-export": "23.0.0-develop.12",
+    "@progress/kendo-angular-popup": "23.0.0-develop.12",
+    "@progress/kendo-angular-toolbar": "23.0.0-develop.12",
+    "@progress/kendo-angular-upload": "23.0.0-develop.12",
+    "@progress/kendo-angular-utils": "23.0.0-develop.12",
     "rxjs": "^6.5.3 || ^7.0.0"
   },
   "dependencies": {
     "tslib": "^2.3.1",
-    "@progress/kendo-angular-schematics": "23.0.0-develop.11",
+    "@progress/kendo-angular-schematics": "23.0.0-develop.12",
     "@progress/kendo-common": "^1.0.1",
     "@progress/kendo-file-saver": "^1.0.0",
     "@progress/kendo-csv": "^1.0.0"

package/schematics/ngAdd/index.js

@@ -9,19 +9,19 @@ const schematics_1 = require("@angular-devkit/schematics");
 function default_1(options) {
     const finalOptions = Object.assign(Object.assign({}, options), { mainNgModule: 'GridModule', package: 'grid', peerDependencies: {
             // peer deps of the dropdowns
-            '@progress/kendo-angular-treeview': '23.0.0-develop.11',
-            '@progress/kendo-angular-navigation': '23.0.0-develop.11',
+            '@progress/kendo-angular-treeview': '23.0.0-develop.12',
+            '@progress/kendo-angular-navigation': '23.0.0-develop.12',
             // peer dependency of kendo-angular-inputs
-            '@progress/kendo-angular-dialog': '23.0.0-develop.11',
+            '@progress/kendo-angular-dialog': '23.0.0-develop.12',
             // peer dependency of kendo-angular-icons
             '@progress/kendo-svg-icons': '^4.0.0',
             // peer dependency of kendo-angular-layout
-            '@progress/kendo-angular-progressbar': '23.0.0-develop.11',
+            '@progress/kendo-angular-progressbar': '23.0.0-develop.12',
             // transitive peer dependencies from toolbar
-            '@progress/kendo-angular-indicators': '23.0.0-develop.11',
+            '@progress/kendo-angular-indicators': '23.0.0-develop.12',
             // transitive peer dependencies from conversational-ui
-            '@progress/kendo-angular-menu': '23.0.0-develop.11',
-            '@progress/kendo-angular-upload': '23.0.0-develop.11'
+            '@progress/kendo-angular-menu': '23.0.0-develop.12',
+            '@progress/kendo-angular-upload': '23.0.0-develop.12'
         } });
     return (0, schematics_1.externalSchematic)('@progress/kendo-angular-schematics', 'ng-add', finalOptions);
 }