chore(packages): Address comments #7515

Author: IvayloG

projects/igniteui-angular/schematics/ng-add/index.ts

@@ -20,7 +20,7 @@ function propertyExistsInWorkspace(targetProp: string, workspace: WorkspaceSchem
 function enablePolyfills(tree: Tree, context: SchematicContext): string {
   const workspace = getWorkspace(tree);
   const project = workspace.projects[workspace.defaultProject];
-  const targetFile = getConfigFile(project, 'polyfills', 'build');
+  const targetFile = getConfigFile(project, 'polyfills');
   if (!tree.exists(targetFile)) {
     context.logger.warn(`${targetFile} not found. You may need to update polyfills.ts manually.`);
     return;
@@ -54,7 +54,7 @@ function readInput(options: Options): Rule {
       const workspace = getWorkspace(tree);
       const targetProperty = 'es5BrowserSupport';
       const project = workspace.projects[workspace.defaultProject];
-      const polyfillsFile = getConfigFile(project, 'polyfills', 'build');
+      const polyfillsFile = getConfigFile(project, 'polyfills');
       const propertyExists = propertyExistsInWorkspace(targetProperty, workspace);
       let polyfillsData = tree.read(polyfillsFile).toString();
       if (propertyExists) {

projects/igniteui-angular/schematics/utils/dependency-handler.ts

@@ -59,27 +59,18 @@ function getTargetedProjectOptions(project: WorkspaceProject<ProjectType>, targe
     throw new SchematicsException(`Cannot determine the project's configuration for: ${target}`);
 }
 
-export function getConfigFile(project: WorkspaceProject<ProjectType>, option: string, configSection: string): string {
-    switch (configSection) {
-        case 'build':
-            const buildOptions = getTargetedProjectOptions(project, 'build');
-            if (!buildOptions[option]) {
-                throw new SchematicsException(`Could not find the project ${option} file inside of the ` +
-                    `workspace config ${project.sourceRoot}`);
-            }
-            return buildOptions[option];
-
-        case 'test':
-            const testOptions = getTargetedProjectOptions(project, 'test');
-            if (!testOptions[option]) {
-                throw new SchematicsException(`Could not find the project ${option} file inside of the ` +
-                    `workspace config ${project.sourceRoot}`);
-            }
-            return testOptions[option];
-        default:
-            throw new SchematicsException(`Could not find matching ${configSection} section` +
+export function getConfigFile(project: WorkspaceProject<ProjectType>, option: string, configSection: string = 'build'): string {
+    const options = getTargetedProjectOptions(project, configSection);
+    if (!options) {
+        throw new SchematicsException(`Could not find matching ${configSection} section` +
             `inside of the workspace config ${project.sourceRoot} `);
     }
+    if (!options[option]) {
+        throw new SchematicsException(`Could not find the project ${option} file inside of the ` +
+            `workspace config ${project.sourceRoot}`);
+    }
+    return options[option];
+
 }
 export function overwriteJsonFile(tree: Tree, targetFile: string, data: any) {
     tree.overwrite(targetFile, JSON.stringify(data, null, 2) + '\n');
@@ -145,6 +136,20 @@ export function getPropertyFromWorkspace(targetProp: string, workspace: any, cur
     return null;
 }
 
+function addHammerToConfig(project: WorkspaceProject<ProjectType>, tree: Tree, config: string) {
+    const projectOptions = getTargetedProjectOptions(project, config);
+    const tsPath = getConfigFile(project, 'main', config);
+    const hammerImport = 'import \'hammerjs\';\n';
+    const tsContent = tree.read(tsPath).toString();
+    // if there are no elements in the architect[config]options.scripts array that contain hammerjs
+    // and the "main" file does not contain an import with hammerjs
+    if (!projectOptions.scripts.some(el => el.includes('hammerjs')) && !tsContent.includes(hammerImport)) {
+        // import hammerjs in the specified by config main file
+        const mainContents = hammerImport + tsContent;
+        tree.overwrite(tsPath, mainContents);
+    }
+}
+
 function includeDependencies(pkgJson: any, context: SchematicContext, tree: Tree) {
     Object.keys(pkgJson.dependencies).forEach(pkg => {
         const version = pkgJson.dependencies[pkg];
@@ -156,30 +161,10 @@ function includeDependencies(pkgJson: any, context: SchematicContext, tree: Tree
             case 'hammerjs':
                 logIncludingDependency(context, pkg, version);
                 addPackageToPkgJson(tree, pkg, version, entry.target);
-
                 const workspace = getWorkspace(tree);
                 const project = workspace.projects[workspace.defaultProject];
-                const projectOptions = getTargetedProjectOptions(project, 'build');
-                const projectTestOptions = getTargetedProjectOptions(project, 'test');
-                const mainTsPath = getConfigFile(project, 'main', 'build');
-                const testTsPath = getConfigFile(project, 'main', 'test');
-                const hammerImport = 'import \'hammerjs\';\n';
-                const mainTsContent = tree.read(mainTsPath).toString();
-                const testTsContent = tree.read(testTsPath).toString();
-                // if there are no elements in the architect.build.options.scripts array that contain hammerjs
-                // and main.ts does not contain an import with hammerjs
-                if (!projectOptions.scripts.some(el => el.includes('hammerjs')) && !mainTsContent.includes(hammerImport)) {
-                    // import hammerjs in the main.ts file
-                    const mainContents = hammerImport + mainTsContent;
-                    tree.overwrite(mainTsPath, mainContents);
-                }
-                // make sure test.ts has hammerjs import even for projects already containing it in main.ts
-                // if there are no elements in the architect.test.options.scripts array that contain hammerjs
-                // and test.ts does not contain an import with hammerjs
-                if (!projectTestOptions.scripts.some(el => el.includes('hammerjs')) && !testTsContent.includes(hammerImport)) {
-                    const testContents = hammerImport + testTsContent;
-                    tree.overwrite(testTsPath, testContents);
-                }
+                addHammerToConfig(project, tree, 'build');
+                addHammerToConfig(project, tree, 'test');
                 break;
             default:
                 logIncludingDependency(context, pkg, version);