@nx/angular 0.0.0-pr-22179-271588f

package/src/executors/utilities/ng-packagr/stylesheet-processor.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Use our own function to get the TailwindCSS config path to support a
+ * config at the root of the workspace.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylesheetProcessor = exports.CssUrl = void 0;
+const browserslist = require("browserslist");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const Piscina = require('piscina');
+const color_1 = require("ng-packagr/lib/utils/color");
+// using this instead of the one from ng-packagr
+const tailwindcss_1 = require("./tailwindcss");
+const devkit_1 = require("@nx/devkit");
+const semver_1 = require("semver");
+const angular_version_utils_1 = require("../angular-version-utils");
+const maxWorkersVariable = process.env['NG_BUILD_MAX_WORKERS'];
+const maxThreads = typeof maxWorkersVariable === 'string' && maxWorkersVariable !== ''
+    ? +maxWorkersVariable
+    : 4;
+var CssUrl;
+(function (CssUrl) {
+    CssUrl["inline"] = "inline";
+    CssUrl["none"] = "none";
+})(CssUrl || (exports.CssUrl = CssUrl = {}));
+class StylesheetProcessor {
+    constructor(projectBasePath, basePath, cssUrl, includePaths, cacheDirectory) {
+        this.projectBasePath = projectBasePath;
+        this.basePath = basePath;
+        this.cssUrl = cssUrl;
+        this.includePaths = includePaths;
+        this.cacheDirectory = cacheDirectory;
+        // By default, browserslist defaults are too inclusive
+        // https://github.com/browserslist/browserslist/blob/83764ea81ffaa39111c204b02c371afa44a4ff07/index.js#L516-L522
+        // We change the default query to browsers that Angular support.
+        // https://angular.io/guide/browser-support
+        browserslist.defaults = [
+            'last 2 Chrome versions',
+            'last 1 Firefox version',
+            'last 2 Edge major versions',
+            'last 2 Safari major versions',
+            'last 2 iOS major versions',
+            'Firefox ESR',
+        ];
+    }
+    async process({ filePath, content, }) {
+        await this.createRenderWorker();
+        return this.renderWorker.run({ content, filePath });
+    }
+    /** Destory workers in pool. */
+    destroy() {
+        void this.renderWorker?.destroy();
+    }
+    async createRenderWorker() {
+        if (this.renderWorker) {
+            return;
+        }
+        const styleIncludePaths = [...this.includePaths];
+        let prevDir = null;
+        let currentDir = this.basePath;
+        while (currentDir !== prevDir) {
+            const p = (0, path_1.join)(currentDir, 'node_modules');
+            if ((0, fs_1.existsSync)(p)) {
+                styleIncludePaths.push(p);
+            }
+            prevDir = currentDir;
+            currentDir = (0, path_1.dirname)(prevDir);
+        }
+        const browserslistData = browserslist(undefined, { path: this.basePath });
+        const { version: ngPackagrVersion } = (0, angular_version_utils_1.getInstalledPackageVersionInfo)('ng-packagr');
+        let postcssConfiguration;
+        if ((0, semver_1.gte)(ngPackagrVersion, '17.2.0')) {
+            const { loadPostcssConfiguration } = await Promise.resolve().then(() => require('ng-packagr/lib/styles/postcss-configuration'));
+            postcssConfiguration = await loadPostcssConfiguration(this.projectBasePath);
+        }
+        this.renderWorker = new Piscina({
+            filename: require.resolve('ng-packagr/lib/styles/stylesheet-processor-worker'),
+            maxThreads,
+            env: {
+                ...process.env,
+                FORCE_COLOR: '' + color_1.colors.enabled,
+            },
+            workerData: {
+                postcssConfiguration,
+                tailwindConfigPath: (0, tailwindcss_1.getTailwindConfigPath)(this.projectBasePath, devkit_1.workspaceRoot),
+                projectBasePath: this.projectBasePath,
+                browserslistData,
+                targets: transformSupportedBrowsersToTargets(browserslistData),
+                cacheDirectory: this.cacheDirectory,
+                cssUrl: this.cssUrl,
+                styleIncludePaths,
+            },
+        });
+    }
+}
+exports.StylesheetProcessor = StylesheetProcessor;
+function transformSupportedBrowsersToTargets(supportedBrowsers) {
+    const transformed = [];
+    // https://esbuild.github.io/api/#target
+    const esBuildSupportedBrowsers = new Set([
+        'safari',
+        'firefox',
+        'edge',
+        'chrome',
+        'ios',
+    ]);
+    for (const browser of supportedBrowsers) {
+        let [browserName, version] = browser.split(' ');
+        // browserslist uses the name `ios_saf` for iOS Safari whereas esbuild uses `ios`
+        if (browserName === 'ios_saf') {
+            browserName = 'ios';
+        }
+        // browserslist uses ranges `15.2-15.3` versions but only the lowest is required
+        // to perform minimum supported feature checks. esbuild also expects a single version.
+        [version] = version.split('-');
+        if (esBuildSupportedBrowsers.has(browserName)) {
+            if (browserName === 'safari' && version === 'tp') {
+                // esbuild only supports numeric versions so `TP` is converted to a high number (999) since
+                // a Technology Preview (TP) of Safari is assumed to support all currently known features.
+                version = '999';
+            }
+            transformed.push(browserName + version);
+        }
+    }
+    return transformed.length ? transformed : undefined;
+}

package/src/executors/utilities/ng-packagr/tailwindcss.d.ts

@@ -0,0 +1,7 @@
+export interface TailwindSetup {
+    tailwindConfigPath: string;
+    tailwindPackagePath: string;
+}
+export declare function getTailwindSetup(basePath: string, tailwindConfig?: string): TailwindSetup | undefined;
+export declare function getTailwindConfigPath(projectRoot: string, workspaceRoot: string): string | undefined;
+export declare function getTailwindPostCssPlugin({ tailwindConfigPath, tailwindPackagePath, }: TailwindSetup): any;

package/src/executors/utilities/ng-packagr/tailwindcss.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTailwindPostCssPlugin = exports.getTailwindConfigPath = exports.getTailwindSetup = void 0;
+const devkit_1 = require("@nx/devkit");
+const devkit_2 = require("@nx/devkit");
+const fs_1 = require("fs");
+const path_1 = require("path");
+function getTailwindSetup(basePath, tailwindConfig) {
+    let tailwindConfigPath = tailwindConfig;
+    if (!tailwindConfigPath) {
+        tailwindConfigPath = getTailwindConfigPath(basePath, devkit_2.workspaceRoot);
+    }
+    // Only load Tailwind CSS plugin if configuration file was found.
+    if (!tailwindConfigPath) {
+        return undefined;
+    }
+    let tailwindPackagePath;
+    try {
+        tailwindPackagePath = require.resolve('tailwindcss');
+    }
+    catch {
+        const relativeTailwindConfigPath = (0, path_1.relative)(devkit_2.workspaceRoot, tailwindConfigPath);
+        devkit_1.logger.warn(`Tailwind CSS configuration file found (${relativeTailwindConfigPath})` +
+            ` but the 'tailwindcss' package is not installed.` +
+            ` To enable Tailwind CSS, please install the 'tailwindcss' package.`);
+        return undefined;
+    }
+    if (!tailwindPackagePath) {
+        return undefined;
+    }
+    return { tailwindConfigPath, tailwindPackagePath };
+}
+exports.getTailwindSetup = getTailwindSetup;
+function getTailwindConfigPath(projectRoot, workspaceRoot) {
+    // valid tailwind config files https://github.com/tailwindlabs/tailwindcss/blob/master/src/util/resolveConfigPath.js#L4
+    const tailwindConfigFiles = [
+        'tailwind.config.js',
+        'tailwind.config.cjs',
+        'tailwind.config.mjs',
+        'tailwind.config.ts',
+    ];
+    for (const basePath of [projectRoot, workspaceRoot]) {
+        for (const configFile of tailwindConfigFiles) {
+            const fullPath = (0, path_1.join)(basePath, configFile);
+            if ((0, fs_1.existsSync)(fullPath)) {
+                return fullPath;
+            }
+        }
+    }
+    return undefined;
+}
+exports.getTailwindConfigPath = getTailwindConfigPath;
+function getTailwindPostCssPlugin({ tailwindConfigPath, tailwindPackagePath, }) {
+    return require(tailwindPackagePath)({ config: tailwindConfigPath });
+}
+exports.getTailwindPostCssPlugin = getTailwindPostCssPlugin;

package/src/executors/utilities/patch-builder-context.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderContext } from '@angular-devkit/architect';
+import type { Target } from '@nx/devkit';
+export declare function patchBuilderContext(context: BuilderContext, isUsingEsbuildBuilder: boolean, buildTarget: Target): void;

package/src/executors/utilities/patch-builder-context.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchBuilderContext = void 0;
+const executorToBuilderMap = new Map([
+    [
+        '@nx/angular:browser-esbuild',
+        '@angular-devkit/build-angular:browser-esbuild',
+    ],
+    ['@nx/angular:application', '@angular-devkit/build-angular:application'],
+]);
+function patchBuilderContext(context, isUsingEsbuildBuilder, buildTarget) {
+    const originalGetBuilderNameForTarget = context.getBuilderNameForTarget;
+    context.getBuilderNameForTarget = async (target) => {
+        const builderName = await originalGetBuilderNameForTarget(target);
+        if (executorToBuilderMap.has(builderName)) {
+            return executorToBuilderMap.get(builderName);
+        }
+        return builderName;
+    };
+    if (isUsingEsbuildBuilder) {
+        const originalGetTargetOptions = context.getTargetOptions;
+        context.getTargetOptions = async (target) => {
+            const options = await originalGetTargetOptions(target);
+            if (target.project === buildTarget.project &&
+                target.target === buildTarget.target &&
+                target.configuration === buildTarget.configuration) {
+                cleanBuildTargetOptions(options);
+            }
+            return options;
+        };
+    }
+}
+exports.patchBuilderContext = patchBuilderContext;
+function cleanBuildTargetOptions(options) {
+    delete options.buildLibsFromSource;
+    delete options.customWebpackConfig;
+    delete options.indexHtmlTransformer;
+    delete options.indexFileTransformer;
+    delete options.plugins;
+    return options;
+}

package/src/executors/utilities/typescript.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Adapted from a private function at ng-packagr
+ * https://github.com/ng-packagr/ng-packagr/blob/main/src/lib/ts/tsconfig.ts#L12:
+ *
+ * Changes made:
+ * - Added an extra function that updates the configFilePath in the returned parsed options
+ * to be the original tsconfig file.
+ */
+import type { ParsedConfiguration } from '@angular/compiler-cli';
+/**
+ * Proxy function that ensures the configFilePath option points to the original file path.
+ */
+export declare function parseRemappedTsConfigAndMergeDefaults(workspaceRoot: string, originalFilePath: string, remappedFilePath: string): Promise<ParsedConfiguration>;

package/src/executors/utilities/typescript.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Adapted from a private function at ng-packagr
+ * https://github.com/ng-packagr/ng-packagr/blob/main/src/lib/ts/tsconfig.ts#L12:
+ *
+ * Changes made:
+ * - Added an extra function that updates the configFilePath in the returned parsed options
+ * to be the original tsconfig file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRemappedTsConfigAndMergeDefaults = void 0;
+const path_1 = require("path");
+const ts = require("typescript");
+const ng_compiler_cli_1 = require("./ng-compiler-cli");
+async function readDefaultTsConfig(fileName) {
+    // these options are mandatory
+    const extraOptions = {
+        target: ts.ScriptTarget.ES2020,
+        experimentalDecorators: true,
+        // sourcemaps
+        sourceMap: false,
+        inlineSources: true,
+        inlineSourceMap: true,
+        outDir: '',
+        declaration: true,
+        // ng compiler to options
+        enableResourceInlining: true,
+        // these are required to set the appropriate EmitFlags
+        flatModuleId: 'AUTOGENERATED',
+        flatModuleOutFile: 'AUTOGENERATED',
+    };
+    const { readConfiguration } = await (0, ng_compiler_cli_1.ngCompilerCli)();
+    return readConfiguration(fileName, extraOptions);
+}
+/**
+ * Proxy function that ensures the configFilePath option points to the original file path.
+ */
+async function parseRemappedTsConfigAndMergeDefaults(workspaceRoot, originalFilePath, remappedFilePath) {
+    const parsedConfiguration = await readDefaultTsConfig(remappedFilePath);
+    parsedConfiguration.options.configFilePath = (0, path_1.resolve)(workspaceRoot, originalFilePath);
+    return parsedConfiguration;
+}
+exports.parseRemappedTsConfigAndMergeDefaults = parseRemappedTsConfigAndMergeDefaults;

package/src/generators/add-linting/add-linting.d.ts

@@ -0,0 +1,4 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import type { AddLintingGeneratorSchema } from './schema';
+export declare function addLintingGenerator(tree: Tree, options: AddLintingGeneratorSchema): Promise<GeneratorCallback>;
+export default addLintingGenerator;

package/src/generators/add-linting/add-linting.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addLintingGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const eslint_1 = require("@nx/eslint");
+const add_angular_eslint_dependencies_1 = require("./lib/add-angular-eslint-dependencies");
+const eslint_file_1 = require("@nx/eslint/src/generators/utils/eslint-file");
+const string_utils_1 = require("@nx/devkit/src/utils/string-utils");
+const global_eslint_config_1 = require("@nx/eslint/src/generators/init/global-eslint-config");
+async function addLintingGenerator(tree, options) {
+    const tasks = [];
+    const rootProject = options.projectRoot === '.' || options.projectRoot === '';
+    const lintTask = await (0, eslint_1.lintProjectGenerator)(tree, {
+        linter: eslint_1.Linter.EsLint,
+        project: options.projectName,
+        tsConfigPaths: [
+            (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.app.json'),
+        ],
+        unitTestRunner: options.unitTestRunner,
+        setParserOptionsProject: options.setParserOptionsProject,
+        skipFormat: true,
+        rootProject: rootProject,
+        addPlugin: false,
+        addExplicitTargets: true,
+    });
+    tasks.push(lintTask);
+    if ((0, eslint_file_1.isEslintConfigSupported)(tree)) {
+        const eslintFile = (0, eslint_file_1.findEslintFile)(tree, options.projectRoot);
+        // keep parser options if they exist
+        const hasParserOptions = tree
+            .read((0, devkit_1.joinPathFragments)(options.projectRoot, eslintFile), 'utf8')
+            .includes(`${options.projectRoot}/tsconfig.*?.json`);
+        (0, eslint_file_1.replaceOverridesInLintConfig)(tree, options.projectRoot, [
+            ...(rootProject ? [global_eslint_config_1.typeScriptOverride, global_eslint_config_1.javaScriptOverride] : []),
+            {
+                files: ['*.ts'],
+                ...(hasParserOptions
+                    ? {
+                        parserOptions: {
+                            project: [`${options.projectRoot}/tsconfig.*?.json`],
+                        },
+                    }
+                    : {}),
+                extends: [
+                    'plugin:@nx/angular',
+                    'plugin:@angular-eslint/template/process-inline-templates',
+                ],
+                rules: {
+                    '@angular-eslint/directive-selector': [
+                        'error',
+                        {
+                            type: 'attribute',
+                            prefix: (0, string_utils_1.camelize)(options.prefix),
+                            style: 'camelCase',
+                        },
+                    ],
+                    '@angular-eslint/component-selector': [
+                        'error',
+                        {
+                            type: 'element',
+                            prefix: (0, string_utils_1.dasherize)(options.prefix),
+                            style: 'kebab-case',
+                        },
+                    ],
+                },
+            },
+            {
+                files: ['*.html'],
+                extends: ['plugin:@nx/angular-template'],
+                /**
+                 * Having an empty rules object present makes it more obvious to the user where they would
+                 * extend things from if they needed to
+                 */
+                rules: {},
+            },
+            ...(isBuildableLibraryProject(tree, options.projectName)
+                ? [
+                    {
+                        files: ['*.json'],
+                        parser: 'jsonc-eslint-parser',
+                        rules: {
+                            '@nx/dependency-checks': 'error',
+                        },
+                    },
+                ]
+                : []),
+        ]);
+    }
+    if (!options.skipPackageJson) {
+        const installTask = (0, add_angular_eslint_dependencies_1.addAngularEsLintDependencies)(tree);
+        tasks.push(installTask);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.addLintingGenerator = addLintingGenerator;
+function isBuildableLibraryProject(tree, projectName) {
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+    return (projectConfig.projectType === 'library' &&
+        projectConfig.targets?.build &&
+        !!projectConfig.targets.build);
+}
+exports.default = addLintingGenerator;

package/src/generators/add-linting/lib/add-angular-eslint-dependencies.d.ts

@@ -0,0 +1,2 @@
+import type { GeneratorCallback, Tree } from '@nx/devkit';
+export declare function addAngularEsLintDependencies(tree: Tree): GeneratorCallback;

package/src/generators/add-linting/lib/add-angular-eslint-dependencies.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addAngularEsLintDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const version_utils_1 = require("../../utils/version-utils");
+function addAngularEsLintDependencies(tree) {
+    const angularEslintVersionToInstall = (0, version_utils_1.versions)(tree).angularEslintVersion;
+    const jsoncEslintParserVersionToInstall = (0, version_utils_1.versions)(tree).jsoncEslintParserVersion;
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+        '@angular-eslint/eslint-plugin': angularEslintVersionToInstall,
+        '@angular-eslint/eslint-plugin-template': angularEslintVersionToInstall,
+        '@angular-eslint/template-parser': angularEslintVersionToInstall,
+        'jsonc-eslint-parser': jsoncEslintParserVersionToInstall,
+    });
+}
+exports.addAngularEsLintDependencies = addAngularEsLintDependencies;

package/src/generators/add-linting/lib/create-eslint-configuration.d.ts

@@ -0,0 +1,81 @@
+import type { Tree } from '@nx/devkit';
+import type { Linter } from 'eslint';
+import type { AddLintingGeneratorSchema } from '../schema';
+type EslintExtensionSchema = {
+    prefix: string;
+};
+/**
+ * @deprecated Use tools from `@nx/eslint/src/generators/utils/eslint-file` instead
+ */
+export declare const extendAngularEslintJson: (json: Linter.Config, options: EslintExtensionSchema) => {
+    overrides: ({
+        files: string[];
+        extends: string[];
+        rules: {
+            '@angular-eslint/directive-selector': (string | {
+                type: string;
+                prefix: string;
+                style: string;
+            })[];
+            '@angular-eslint/component-selector': (string | {
+                type: string;
+                prefix: string;
+                style: string;
+            })[];
+        };
+        excludedFiles?: string | string[];
+        $schema?: string;
+        env?: {
+            [name: string]: boolean;
+        };
+        globals?: {
+            [name: string]: boolean | "readable" | "off" | "readonly" | "writable" | "writeable";
+        };
+        noInlineConfig?: boolean;
+        overrides?: Linter.ConfigOverride<Linter.RulesRecord>[];
+        parser?: string;
+        parserOptions?: Linter.ParserOptions;
+        plugins?: string[];
+        processor?: string;
+        reportUnusedDisableDirectives?: boolean;
+        settings?: {
+            [name: string]: any;
+        };
+    } | {
+        files: string[];
+        extends: string[];
+        /**
+         * Having an empty rules object present makes it more obvious to the user where they would
+         * extend things from if they needed to
+         */
+        rules: {
+            '@angular-eslint/directive-selector'?: undefined;
+            '@angular-eslint/component-selector'?: undefined;
+        };
+    })[];
+    ignorePatterns?: string | string[];
+    root?: boolean;
+    $schema?: string;
+    env?: {
+        [name: string]: boolean;
+    };
+    extends?: string | string[];
+    globals?: {
+        [name: string]: boolean | "readable" | "off" | "readonly" | "writable" | "writeable";
+    };
+    noInlineConfig?: boolean;
+    parser?: string;
+    parserOptions?: Linter.ParserOptions;
+    plugins?: string[];
+    processor?: string;
+    reportUnusedDisableDirectives?: boolean;
+    settings?: {
+        [name: string]: any;
+    };
+    rules?: Partial<Linter.RulesRecord>;
+};
+/**
+ * @deprecated Use {@link extendAngularEslintJson} instead
+ */
+export declare function createEsLintConfiguration(tree: Tree, options: AddLintingGeneratorSchema): void;
+export {};

package/src/generators/add-linting/lib/create-eslint-configuration.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEsLintConfiguration = exports.extendAngularEslintJson = void 0;
+const devkit_1 = require("@nx/devkit");
+const string_utils_1 = require("@nx/devkit/src/utils/string-utils");
+/**
+ * @deprecated Use tools from `@nx/eslint/src/generators/utils/eslint-file` instead
+ */
+const extendAngularEslintJson = (json, options) => {
+    const overrides = [
+        {
+            ...json.overrides[0],
+            files: ['*.ts'],
+            extends: [
+                ...(json.overrides[0].extends || []),
+                'plugin:@nx/angular',
+                'plugin:@angular-eslint/template/process-inline-templates',
+            ],
+            rules: {
+                '@angular-eslint/directive-selector': [
+                    'error',
+                    {
+                        type: 'attribute',
+                        prefix: (0, string_utils_1.camelize)(options.prefix),
+                        style: 'camelCase',
+                    },
+                ],
+                '@angular-eslint/component-selector': [
+                    'error',
+                    {
+                        type: 'element',
+                        prefix: (0, string_utils_1.dasherize)(options.prefix),
+                        style: 'kebab-case',
+                    },
+                ],
+            },
+        },
+        {
+            files: ['*.html'],
+            extends: ['plugin:@nx/angular-template'],
+            /**
+             * Having an empty rules object present makes it more obvious to the user where they would
+             * extend things from if they needed to
+             */
+            rules: {},
+        },
+    ];
+    return {
+        ...json,
+        overrides,
+    };
+};
+exports.extendAngularEslintJson = extendAngularEslintJson;
+/**
+ * @deprecated Use {@link extendAngularEslintJson} instead
+ */
+function createEsLintConfiguration(tree, options) {
+    const rootConfig = `${(0, devkit_1.offsetFromRoot)(options.projectRoot)}.eslintrc.json`;
+    // Include all project files to be linted (since they are turned off in the root eslintrc file).
+    const ignorePatterns = ['!**/*'];
+    const configJson = {
+        extends: [rootConfig],
+        ignorePatterns,
+        overrides: [
+            {
+                files: ['*.ts'],
+                extends: [
+                    'plugin:@nx/angular',
+                    'plugin:@angular-eslint/template/process-inline-templates',
+                ],
+                /**
+                 * NOTE: We no longer set parserOptions.project by default when creating new projects.
+                 *
+                 * We have observed that users rarely add rules requiring type-checking to their Nx workspaces, and therefore
+                 * do not actually need the capabilites which parserOptions.project provides. When specifying parserOptions.project,
+                 * typescript-eslint needs to create full TypeScript Programs for you. When omitting it, it can perform a simple
+                 * parse (and AST tranformation) of the source files it encounters during a lint run, which is much faster and much
+                 * less memory intensive.
+                 *
+                 * In the rare case that users attempt to add rules requiring type-checking to their setup later on (and haven't set
+                 * parserOptions.project), the executor will attempt to look for the particular error typescript-eslint gives you
+                 * and provide feedback to the user.
+                 */
+                parserOptions: !options.setParserOptionsProject
+                    ? undefined
+                    : {
+                        project: [`${options.projectRoot}/tsconfig.*?.json`],
+                    },
+                rules: {
+                    '@angular-eslint/directive-selector': [
+                        'error',
+                        {
+                            type: 'attribute',
+                            prefix: (0, string_utils_1.camelize)(options.prefix),
+                            style: 'camelCase',
+                        },
+                    ],
+                    '@angular-eslint/component-selector': [
+                        'error',
+                        {
+                            type: 'element',
+                            prefix: (0, string_utils_1.dasherize)(options.prefix),
+                            style: 'kebab-case',
+                        },
+                    ],
+                },
+            },
+            {
+                files: ['*.html'],
+                extends: ['plugin:@nx/angular-template'],
+                /**
+                 * Having an empty rules object present makes it more obvious to the user where they would
+                 * extend things from if they needed to
+                 */
+                rules: {},
+            },
+        ],
+    };
+    (0, devkit_1.writeJson)(tree, (0, devkit_1.joinPathFragments)(options.projectRoot, '.eslintrc.json'), configJson);
+}
+exports.createEsLintConfiguration = createEsLintConfiguration;

package/src/generators/add-linting/schema.d.ts

@@ -0,0 +1,9 @@
+export interface AddLintingGeneratorSchema {
+  projectName: string;
+  projectRoot: string;
+  prefix: string;
+  setParserOptionsProject?: boolean;
+  skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  unitTestRunner?: string;
+}