Object.keys(pkgJson.dependencies).forEach(pkg => {
        const version = pkgJson.dependencies[pkg];
        switch (pkg) {
            case 'hammerjs':
                logIncludingDependency(context, pkg, version);
                addPackageToPkgJson(tree, pkg, version, dependenciesKey);

                const workspace = getWorkspace(tree);
                const project = workspace.projects[workspace.defaultProject];
                const projectOptions = getTargetedProjectOptions(project, 'build');
                const mainTsPath = getMainFile(project);
                const hammerImport = 'import \'hammerjs\';\n';
                const mainTsContent = tree.read(mainTsPath).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 contents = hammerImport + mainTsContent;
                    tree.overwrite(mainTsPath, contents);
                }
                break;
            default:
                logIncludingDependency(context, pkg, version);
                addPackageToPkgJson(tree, pkg, version, dependenciesKey);
                break;
        }
    });

export function getProjectTsConfigPaths(tree: Tree): string[] {
  // Start with some tsconfig paths that are generally used within CLI projects.
  const tsconfigPaths = new Set<string>([
    './tsconfig.json',
    './src/tsconfig.json',
    './src/tsconfig.app.json',
  ]);

  // Add any tsconfig directly referenced in a build or test task of the angular.json workspace.
  const workspace = getWorkspace(tree);

  for (const project of Object.values(workspace.projects)) {
    ['build', 'test'].forEach(targetName => {
      if (project.targets &&
          project.targets[targetName] &&
          project.targets[targetName].options &&
          project.targets[targetName].options.tsConfig) {
        tsconfigPaths.add(project.targets[targetName].options.tsConfig);
      }

      if (project.architect &&
          project.architect[targetName] &&
          project.architect[targetName].options &&
          project.architect[targetName].options.tsConfig) {
        tsconfigPaths.add(project.architect[targetName].options.tsConfig);
      }
    });
  }

  // Filter out tsconfig files that don't exist in the CLI project.
  return Array.from(tsconfigPaths).filter(p => tree.exists(p));
}

/** Gets the first tsconfig path from possibile locations based on the history of the CLI. */
function getTsConfigPaths(tree: Tree): string[] {
  // Start with some tsconfig paths that are generally used.
  const tsconfigPaths = [
    './tsconfig.json',
    './src/tsconfig.json',
    './src/tsconfig.app.json',
  ];

  // Add any tsconfig directly referenced in a build or test task of the angular.json workspace.
  const workspace = getWorkspace(tree);
  for (const project of Object.values(workspace.projects)) {
    if (project && project.architect) {
      for (const taskName of ['build', 'test']) {
        const task = project.architect[taskName];
        if (task && task.options && task.options.tsConfig) {
          const tsConfigOption = project.architect.tsConfig;
          if (typeof tsConfigOption === 'string') {
            tsconfigPaths.push(tsConfigOption);
          } else if (Array.isArray(tsConfigOption)) {
            tsconfigPaths.push(...tsConfigOption);
          }
        }
      }
    }
  }

  // Filter out tsconfig files that don't exist and remove any duplicates.
  return tsconfigPaths
      .filter(p => existsSync(p))
      .filter((value, index, self) => self.indexOf(value) === index);
}

  return (host: Tree) => {
    const workspace = getWorkspace(host);
    const project = getProjectFromWorkspace(workspace, options.project);
    const appModulePath = getAppModulePath(host, getProjectMainFile(project));
    const moduleSource = getSourceFile(host, appModulePath);

    const locale = getCompatibleLocal(options);
    const localePrefix = locale.split('_')[ 0 ];

    const recorder = host.beginUpdate(appModulePath);

    const changes = [
      insertImport(moduleSource, appModulePath, 'NZ_I18N',
        'ng-zorro-antd'),
      insertImport(moduleSource, appModulePath, locale,
        'ng-zorro-antd'),
      insertImport(moduleSource, appModulePath, 'registerLocaleData',
        '@angular/common'),
      insertImport(moduleSource, appModulePath, localePrefix,
        `@angular/common/locales/${localePrefix}`, true),
      registerLocaleData(moduleSource, appModulePath, localePrefix),
      ...insertI18nTokenProvide(moduleSource, appModulePath, locale)
    ];

    changes.forEach((change) => {
      if (change instanceof InsertChange) {
        recorder.insertLeft(change.pos, change.toAdd);
      }
    });

    host.commitUpdate(recorder);

    return host;
  };

  return (host: Tree) => {
    const workspace = getWorkspace(host);
    const project = getProjectFromWorkspace(workspace, options.project);
    const styleFilePath = getProjectStyleFile(project);

    if (!styleFilePath) {
      console.warn(red(`Could not find the default style file for this project.`));
      console.warn(red(`Please consider manually setting up the Roboto font in your CSS.`));
      return;
    }

    const buffer = host.read(styleFilePath);

    if (!buffer) {
      console.warn(red(`Could not read the default style file within the project ` +
        `(${italic(styleFilePath)})`));
      console.warn(red(`Please consider manually setting up the Robot font.`));
      return;
    }

    const htmlContent = buffer.toString();
    const insertion = '\n' +
      `html, body { height: 100%; }\n` +
      `body { margin: 0; font-family: Roboto, "Helvetica Neue", sans-serif; }\n`;

    if (htmlContent.includes(insertion)) {
      return;
    }

    const recorder = host.beginUpdate(styleFilePath);

    recorder.insertLeft(htmlContent.length, insertion);
    host.commitUpdate(recorder);
  };

  return (host: Tree, context: SchematicContext) => {
    if (!options.name) {
      throw new SchematicsException(`Invalid options, "name" is required.`);
    }
    validateProjectName(options.name);
    let newProjectRoot = '';
    try {
      const workspace = getWorkspace(host);
      newProjectRoot = workspace.newProjectRoot || '';
    } catch {
    }
    const appDir = `${newProjectRoot}/${options.name}`;

    // If user already has angular installed, Bazel should use that version
    const existingAngularVersion = findAngularVersion(options, host);

    const workspaceVersions = {
      'ANGULAR_VERSION': existingAngularVersion || '7.1.1',
      'RULES_SASS_VERSION': '1.14.1',
      'RXJS_VERSION': '6.3.3',
    };

    return mergeWith(apply(url('./files'), [
      applyTemplates({
        utils: strings,
        ...options,
        'dot': '.', ...workspaceVersions,
      }),
      move(appDir),
    ]));
  };

  return (host: Tree, context: SchematicContext) => {
    const name = options.name || getWorkspace(host).defaultProject;
    if (!name) {
      throw new Error('Please provide a name for Bazel workspace');
    }
    validateProjectName(name);

    if (!host.exists('yarn.lock')) {
      host.create('yarn.lock', '');
    }

    const workspaceVersions = {
      'RULES_NODEJS_VERSION': '0.18.6',
      'RULES_NODEJS_SHA256': '1416d03823fed624b49a0abbd9979f7c63bbedfd37890ddecedd2fe25cccebc6',
      'RULES_SASS_VERSION': '1.17.0',
    };

    return mergeWith(apply(url('./files'), [
      applyTemplates({
        utils: strings,
        name,
        'dot': '.', ...workspaceVersions,
        routing: hasRoutingModule(host),
        sass: hasSassStylesheet(host),
      }),
    ]));
  };

 /** Overwrites a target builder for the workspace in the given tree */
 function overwriteTargetBuilder(tree: Tree, targetName: string, newBuilder: string) {
   const workspace = getWorkspace(tree);
   const project = getProjectFromWorkspace(workspace);
   const targetConfig = project.architect && project.architect[targetName] ||
                        project.targets && project.targets[targetName];
   targetConfig['builder'] = newBuilder;
   tree.overwrite('/angular.json', JSON.stringify(workspace, null, 2));
 }

  it('should register inline theme if no theme already registered', () => {
    const tree = runSetupSchematic({ customization: false });
    const workspace = getWorkspace(tree);
    const project = getProjectFromWorkspace(workspace);
    const styles = getProjectTargetOptions(project, 'build').styles;

    expect(styles).toContain('./node_modules/@nebular/theme/styles/prebuilt/default.css')
  });