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) => {
const workspace = getWorkspace(host);
const project = getProjectFromWorkspace(workspace, options.project);
const appModulePath = getAppModulePath(host, getProjectMainFile(project));
if (options.animations) {
// In case the project explicitly uses the NoopAnimationsModule, we should print a warning
// message that makes the user aware of the fact that we won't automatically set up
// animations. If we would add the BrowserAnimationsModule while the NoopAnimationsModule
// is already configured, we would cause unexpected behavior and runtime exceptions.
if (hasNgModuleImport(host, appModulePath, noopAnimationsModuleName)) {
return console.warn(red(`Could not set up "${bold(browserAnimationsModuleName)}" ` +
`because "${bold(noopAnimationsModuleName)}" is already imported. Please manually ` +
`set up browser animations.`));
}
addModuleImportToRootModule(host, browserAnimationsModuleName,
'@angular/platform-browser/animations', project);
} else if (!hasNgModuleImport(host, appModulePath, browserAnimationsModuleName)) {
// Do not add the NoopAnimationsModule module if the project already explicitly uses
// the BrowserAnimationsModule.
addModuleImportToRootModule(host, noopAnimationsModuleName,
'@angular/platform-browser/animations', project);
}
return host;
};
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')
});
