@nx/angular 23.0.0-pr.35465.2bc2643 → 23.0.0-rc.0

package/dist/src/executors/package/package.impl.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageExecutor = void 0;
+exports.createLibraryExecutor = createLibraryExecutor;
+const internal_1 = require("@nx/devkit/internal");
+const internal_2 = require("@nx/js/internal");
+const path_1 = require("path");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const typescript_1 = require("../utilities/typescript");
+const ng_packagr_1 = require("./ng-packagr-adjustments/ng-packagr");
+async function initializeNgPackagr(options, context, projectDependencies) {
+    const ngPackagr = await (0, ng_packagr_1.getNgPackagrInstance)();
+    ngPackagr.forProject((0, path_1.resolve)(context.root, options.project));
+    if (options.tsConfig) {
+        const remappedTsConfigFilePath = (0, internal_2.createTmpTsConfig)((0, path_1.join)(context.root, options.tsConfig), context.root, context.projectsConfigurations.projects[context.projectName].root, projectDependencies);
+        const tsConfig = await (0, typescript_1.parseRemappedTsConfigAndMergeDefaults)(context.root, options.tsConfig, remappedTsConfigFilePath);
+        ngPackagr.withTsConfig(tsConfig);
+    }
+    return ngPackagr;
+}
+/**
+ * Creates an executor function that executes the library build of an Angular
+ * package using ng-packagr.
+ * @param initializeNgPackagr function that returns an ngPackagr instance to use for the build.
+ */
+function createLibraryExecutor(initializeNgPackagr) {
+    return async function* (options, context) {
+        options.project ??= (0, path_1.join)(context.projectsConfigurations.projects[context.projectName].root, 'ng-package.json');
+        const { dependencies } = (0, internal_2.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, context.projectName, context.targetName, context.configurationName);
+        if (options.watch) {
+            return yield* (0, internal_1.eachValueFrom)((0, rxjs_1.from)(initializeNgPackagr(options, context, dependencies)).pipe((0, operators_1.switchMap)((packagr) => packagr.watch()), (0, operators_1.mapTo)({ success: true })));
+        }
+        return (0, rxjs_1.from)(initializeNgPackagr(options, context, dependencies))
+            .pipe((0, operators_1.switchMap)((packagr) => packagr.build()), (0, operators_1.mapTo)({ success: true }))
+            .toPromise();
+    };
+}
+exports.packageExecutor = createLibraryExecutor(initializeNgPackagr);
+exports.default = exports.packageExecutor;

package/dist/src/executors/unit-test/unit-test.impl.d.ts

@@ -0,0 +1,4 @@
+import type { BuilderOutput } from '@angular-devkit/architect';
+import type { ExecutorContext } from '@nx/devkit';
+import type { UnitTestExecutorOptions } from './schema';
+export default function unitTestExecutor(options: UnitTestExecutorOptions, context: ExecutorContext): AsyncIterable<BuilderOutput>;

package/dist/src/executors/unit-test/unit-test.impl.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = unitTestExecutor;
+const ngcli_adapter_1 = require("nx/src/adapter/ngcli-adapter");
+const targets_1 = require("../../utils/targets");
+const semver_1 = require("semver");
+const angular_version_utils_1 = require("../utilities/angular-version-utils");
+const builder_package_1 = require("../utilities/builder-package");
+const esbuild_extensions_1 = require("../utilities/esbuild-extensions");
+async function* unitTestExecutor(options, context) {
+    validateOptions(options);
+    const { plugins: pluginPaths, indexHtmlTransformer: indexHtmlTransformerPath, ...delegateExecutorOptions } = options;
+    const plugins = await (0, esbuild_extensions_1.loadPlugins)(pluginPaths, options.tsConfig);
+    const indexHtmlTransformer = indexHtmlTransformerPath
+        ? await (0, esbuild_extensions_1.loadIndexHtmlTransformer)(indexHtmlTransformerPath, options.tsConfig)
+        : undefined;
+    const builderContext = await (0, ngcli_adapter_1.createBuilderContext)({
+        builderName: '@nx/angular:unit-test',
+        description: 'Run application unit tests.',
+        optionSchema: require('./schema.json'),
+    }, context);
+    const buildTargetSpecifier = options.buildTarget ?? `::development`;
+    const buildTarget = (0, targets_1.targetFromTargetString)(buildTargetSpecifier, context.projectName, 'build');
+    patchBuilderContext(builderContext, buildTarget);
+    (0, builder_package_1.assertBuilderPackageIsInstalled)('@angular/build');
+    const { executeUnitTestBuilder } = await import('@angular/build');
+    return yield* executeUnitTestBuilder(delegateExecutorOptions, builderContext, {
+        codePlugins: plugins,
+        indexHtmlTransformer,
+    });
+}
+function validateOptions(options) {
+    const { version: angularVersion, major: angularMajorVersion } = (0, angular_version_utils_1.getInstalledAngularVersionInfo)();
+    if (angularMajorVersion < 21) {
+        throw new Error(`The "unit-test" executor is only available for Angular versions >= 21.0.0. You are currently using version ${angularVersion}.`);
+    }
+    if ((0, semver_1.lt)(angularVersion, '21.2.0')) {
+        if (options.headless !== undefined) {
+            throw new Error(`The "headless" option requires Angular version 21.2.0 or greater. You are currently using version ${angularVersion}.`);
+        }
+    }
+}
+/**
+ * The Angular CLI unit-test builder only accepts the `@angular/build:application`
+ * and `@angular/build:ng-packagr` builders. We need to patch the builder context
+ * so that it accepts the `@nx/angular:*` executors.
+ *
+ * https://github.com/angular/angular-cli/blob/f9de11d67d3e0e0524372819583bc77756596d4f/packages/angular/build/src/builders/unit-test/builder.ts#L246-L262
+ */
+function patchBuilderContext(context, buildTarget) {
+    const executorToBuilderMap = new Map([
+        ['@nx/angular:application', '@angular/build:application'],
+        ['@nx/angular:ng-packagr-lite', '@angular/build:ng-packagr'],
+        ['@nx/angular:package', '@angular/build:ng-packagr'],
+    ]);
+    const originalGetBuilderNameForTarget = context.getBuilderNameForTarget;
+    context.getBuilderNameForTarget = async (target) => {
+        const builderName = await originalGetBuilderNameForTarget(target);
+        if (executorToBuilderMap.has(builderName)) {
+            return executorToBuilderMap.get(builderName);
+        }
+        return builderName;
+    };
+    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;
+    };
+}
+function cleanBuildTargetOptions(options) {
+    if ('buildLibsFromSource' in options ||
+        'indexHtmlTransformer' in options ||
+        'plugins' in options) {
+        delete options.buildLibsFromSource;
+        delete options.indexHtmlTransformer;
+        delete options.plugins;
+    }
+    return options;
+}

package/dist/src/executors/utilities/angular-version-utils.d.ts

@@ -0,0 +1,6 @@
+export type VersionInfo = {
+    major: number;
+    version: string;
+};
+export declare function getInstalledAngularVersionInfo(): VersionInfo | null;
+export declare function getInstalledPackageVersionInfo(pkgName: string): VersionInfo | null;

package/dist/src/executors/utilities/angular-version-utils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInstalledAngularVersionInfo = getInstalledAngularVersionInfo;
+exports.getInstalledPackageVersionInfo = getInstalledPackageVersionInfo;
+const internal_1 = require("@nx/devkit/internal");
+const semver_1 = require("semver");
+function getInstalledAngularVersionInfo() {
+    return getInstalledPackageVersionInfo('@angular/core');
+}
+function getInstalledPackageVersionInfo(pkgName) {
+    const version = (0, internal_1.getInstalledPackageVersion)(pkgName);
+    return version ? { major: (0, semver_1.major)(version), version } : null;
+}

package/dist/src/executors/utilities/buildable-libs.d.ts

@@ -0,0 +1,6 @@
+import { type ExecutorContext } from '@nx/devkit';
+import { type DependentBuildableProjectNode } from '@nx/js/internal';
+export declare function createTmpTsConfigForBuildableLibs(tsConfigPath: string, context: ExecutorContext): {
+    tsConfigPath: string;
+    dependencies: DependentBuildableProjectNode[];
+};

package/dist/src/executors/utilities/buildable-libs.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTmpTsConfigForBuildableLibs = createTmpTsConfigForBuildableLibs;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+const path_1 = require("path");
+function createTmpTsConfigForBuildableLibs(tsConfigPath, context) {
+    let dependencies;
+    const result = (0, internal_1.calculateProjectDependencies)(context.projectGraph ?? (0, devkit_1.readCachedProjectGraph)(), context.root, context.projectName, context.targetName, context.configurationName);
+    dependencies = result.dependencies;
+    const tmpTsConfigPath = (0, internal_1.createTmpTsConfig)((0, path_1.join)(context.root, tsConfigPath), context.root, result.target.data.root, dependencies);
+    process.env.NX_TSCONFIG_PATH = tmpTsConfigPath;
+    const tmpTsConfigPathWithoutWorkspaceRoot = tmpTsConfigPath.replace(context.root, '');
+    return { tsConfigPath: tmpTsConfigPathWithoutWorkspaceRoot, dependencies };
+}

package/dist/src/executors/utilities/builder-package.d.ts

@@ -0,0 +1 @@
+export declare function assertBuilderPackageIsInstalled(packageName: string): void;

package/dist/src/executors/utilities/esbuild-extensions.d.ts

@@ -0,0 +1,10 @@
+import type { buildApplication } from '@angular/build';
+type Plugin = Parameters<typeof buildApplication>[2]['codePlugins'][number];
+export type PluginSpec = {
+    path: string;
+    options: any;
+};
+export declare function loadPlugins(plugins: string[] | PluginSpec[] | undefined, tsConfig: string): Promise<Plugin[]>;
+export declare function loadMiddleware(middlewareFns: string[] | undefined, tsConfig: string): Promise<any[]>;
+export declare function loadIndexHtmlTransformer(indexHtmlTransformerPath: string, tsConfig: string): Promise<any>;
+export {};

package/dist/src/executors/utilities/esbuild-extensions.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPlugins = loadPlugins;
+exports.loadMiddleware = loadMiddleware;
+exports.loadIndexHtmlTransformer = loadIndexHtmlTransformer;
+const module_loader_1 = require("./module-loader");
+async function loadPlugins(plugins, tsConfig) {
+    if (!plugins?.length) {
+        return [];
+    }
+    return Promise.all(plugins.map((plugin) => loadPlugin(plugin, tsConfig)));
+}
+async function loadPlugin(pluginSpec, tsConfig) {
+    const pluginPath = typeof pluginSpec === 'string' ? pluginSpec : pluginSpec.path;
+    let plugin = await (0, module_loader_1.loadModule)(pluginPath, tsConfig);
+    if (typeof plugin === 'function') {
+        plugin =
+            typeof pluginSpec === 'object' ? plugin(pluginSpec.options) : plugin();
+    }
+    return plugin;
+}
+async function loadMiddleware(middlewareFns, tsConfig) {
+    if (!middlewareFns?.length) {
+        return [];
+    }
+    return Promise.all(middlewareFns.map((fnPath) => (0, module_loader_1.loadModule)(fnPath, tsConfig)));
+}
+async function loadIndexHtmlTransformer(indexHtmlTransformerPath, tsConfig) {
+    return (0, module_loader_1.loadModule)(indexHtmlTransformerPath, tsConfig);
+}

package/dist/src/executors/utilities/module-loader.d.ts

@@ -0,0 +1,14 @@
+export declare function loadModule<T = any>(path: string, tsConfig?: string): Promise<T>;
+/**
+ * This uses a dynamic import to load a module which may be ESM.
+ * CommonJS code can load ESM code via a dynamic import. Unfortunately, TypeScript
+ * will currently, unconditionally downlevel dynamic import into a require call.
+ * require calls cannot load ESM code and will result in a runtime error. To workaround
+ * this, a Function constructor is used to prevent TypeScript from changing the dynamic import.
+ * Once TypeScript provides support for keeping the dynamic import this workaround can
+ * be dropped.
+ *
+ * @param modulePath The path of the module to load.
+ * @returns A Promise that resolves to the dynamically imported module.
+ */
+export declare function loadEsmModule<T = any>(modulePath: string | URL): Promise<T>;

package/dist/src/executors/utilities/module-loader.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadModule = loadModule;
+exports.loadEsmModule = loadEsmModule;
+const path_1 = require("path");
+const node_url_1 = require("node:url");
+const internal_1 = require("@nx/js/internal");
+async function loadModule(path, tsConfig) {
+    const ext = (0, path_1.extname)(path);
+    if (ext === '.mjs') {
+        const result = await loadEsmModule((0, node_url_1.pathToFileURL)(path));
+        return result.default ?? result;
+    }
+    if (ext === '.cjs') {
+        const result = (0, internal_1.requireWithTsconfigFallback)(path, tsConfig);
+        return result.default ?? result;
+    }
+    const isTs = ext === '.ts' || ext === '.cts' || ext === '.mts';
+    try {
+        const result = isTs && tsConfig
+            ? (0, internal_1.loadTsFile)(path, tsConfig)
+            : (0, internal_1.requireWithTsconfigFallback)(path, tsConfig);
+        return result.default ?? result;
+    }
+    catch (e) {
+        // ERR_REQUIRE_ESM (legacy) and ERR_REQUIRE_ASYNC_MODULE (Node 22.12+,
+        // ESM with top-level await) both indicate the module must be loaded via
+        // dynamic import.
+        if (e.code === 'ERR_REQUIRE_ESM' || e.code === 'ERR_REQUIRE_ASYNC_MODULE') {
+            const result = await loadEsmModule((0, node_url_1.pathToFileURL)(path));
+            return result.default ?? result;
+        }
+        throw e;
+    }
+}
+/**
+ * Lazily compiled dynamic import loader function.
+ */
+let load;
+/**
+ * This uses a dynamic import to load a module which may be ESM.
+ * CommonJS code can load ESM code via a dynamic import. Unfortunately, TypeScript
+ * will currently, unconditionally downlevel dynamic import into a require call.
+ * require calls cannot load ESM code and will result in a runtime error. To workaround
+ * this, a Function constructor is used to prevent TypeScript from changing the dynamic import.
+ * Once TypeScript provides support for keeping the dynamic import this workaround can
+ * be dropped.
+ *
+ * @param modulePath The path of the module to load.
+ * @returns A Promise that resolves to the dynamically imported module.
+ */
+function loadEsmModule(modulePath) {
+    load ??= new Function('modulePath', `return import(modulePath);`);
+    return load(modulePath);
+}

package/dist/src/executors/utilities/ng-packagr/ng-packagr-version.d.ts

@@ -0,0 +1,2 @@
+import { type VersionInfo } from '../angular-version-utils';
+export declare function getNgPackagrVersionInfo(): VersionInfo;

package/dist/src/executors/utilities/ng-packagr/package-imports.d.ts

@@ -0,0 +1,3 @@
+type NgPackagrImportPath = `ng-packagr/src/${string}`;
+export declare function importNgPackagrPath<T>(path: NgPackagrImportPath, ngPackagrMajorVersion: number): T;
+export {};

package/dist/src/executors/utilities/ng-packagr/stylesheet-processor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Add the project root to the search directories.
+ */
+import type { NgPackageEntryConfig } from 'ng-packagr/src/ng-entrypoint.schema';
+export declare enum CssUrl {
+    inline = "inline",
+    none = "none"
+}
+export declare function getStylesheetProcessor(): new (projectBasePath: string, basePath: string, cssUrl?: CssUrl, includePaths?: string[], sass?: NgPackageEntryConfig['lib']['sass'], cacheDirectory?: string | false, watch?: boolean) => {
+    [key: string]: any;
+};

package/dist/src/executors/utilities/ng-packagr/stylesheet-processor.di.d.ts

@@ -0,0 +1,2 @@
+import type { FactoryProvider } from 'injection-js';
+export declare function getStylesheetProcessorFactoryProvider(): FactoryProvider;

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

@@ -0,0 +1 @@
+export declare function getTailwindConfigPath(projectRoot: string, workspaceRoot: string): string | undefined;

package/dist/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/dist/src/executors/utilities/typescript.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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.
+ */
+/**
+ * Proxy function that ensures the configFilePath option points to the original file path.
+ */
+export declare function parseRemappedTsConfigAndMergeDefaults(workspaceRoot: string, originalFilePath: string, remappedFilePath: string): Promise<any>;

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

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

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

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addLintingGenerator = addLintingGenerator;
+const internal_1 = require("@nx/devkit/internal");
+const devkit_1 = require("@nx/devkit");
+const eslint_1 = require("@nx/eslint");
+const assert_supported_angular_version_1 = require("../../utils/assert-supported-angular-version");
+const internal_2 = require("@nx/eslint/internal");
+const add_angular_eslint_dependencies_1 = require("./lib/add-angular-eslint-dependencies");
+const buildable_project_1 = require("./lib/buildable-project");
+async function addLintingGenerator(tree, options) {
+    (0, assert_supported_angular_version_1.assertSupportedAngularVersion)(tree);
+    const tasks = [];
+    const rootProject = options.projectRoot === '.' || options.projectRoot === '';
+    const lintTask = await (0, eslint_1.lintProjectGenerator)(tree, {
+        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: options.addPlugin ?? false,
+        addExplicitTargets: true,
+        skipPackageJson: options.skipPackageJson,
+    });
+    tasks.push(lintTask);
+    if ((0, internal_2.isEslintConfigSupported)(tree)) {
+        const eslintFile = (0, internal_2.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`);
+        if ((0, internal_2.useFlatConfig)(tree)) {
+            (0, internal_2.addPredefinedConfigToFlatLintConfig)(tree, options.projectRoot, 'flat/angular', { checkBaseConfig: true });
+            (0, internal_2.addPredefinedConfigToFlatLintConfig)(tree, options.projectRoot, 'flat/angular-template', { checkBaseConfig: true });
+            (0, internal_2.addOverrideToLintConfig)(tree, options.projectRoot, {
+                files: ['*.ts'],
+                rules: {
+                    '@angular-eslint/directive-selector': [
+                        'error',
+                        {
+                            type: 'attribute',
+                            prefix: (0, internal_1.camelize)(options.prefix),
+                            style: 'camelCase',
+                        },
+                    ],
+                    '@angular-eslint/component-selector': [
+                        'error',
+                        {
+                            type: 'element',
+                            prefix: (0, internal_1.dasherize)(options.prefix),
+                            style: 'kebab-case',
+                        },
+                    ],
+                },
+            });
+            (0, internal_2.addOverrideToLintConfig)(tree, options.projectRoot, {
+                files: ['*.html'],
+                rules: {},
+            });
+        }
+        else {
+            (0, internal_2.replaceOverridesInLintConfig)(tree, options.projectRoot, [
+                ...(rootProject ? [internal_2.typeScriptOverride, internal_2.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, internal_1.camelize)(options.prefix),
+                                style: 'camelCase',
+                            },
+                        ],
+                        '@angular-eslint/component-selector': [
+                            'error',
+                            {
+                                type: 'element',
+                                prefix: (0, internal_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, buildable_project_1.isBuildableLibraryProject)(tree, options.projectName)
+                    ? [
+                        {
+                            files: ['*.json'],
+                            parser: 'jsonc-eslint-parser',
+                            rules: {
+                                '@nx/dependency-checks': [
+                                    'error',
+                                    {
+                                        // With flat configs, we don't want to include imports in the eslint js/cjs/mjs files to be checked
+                                        ignoredFiles: [
+                                            '{projectRoot}/eslint.config.{js,cjs,mjs}',
+                                        ],
+                                    },
+                                ],
+                            },
+                        },
+                    ]
+                    : []),
+            ]);
+        }
+    }
+    if (!options.skipPackageJson) {
+        const installTask = (0, add_angular_eslint_dependencies_1.addAngularEsLintDependencies)(tree, options.projectName);
+        tasks.push(installTask);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.default = addLintingGenerator;

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

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

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addAngularEsLintDependencies = addAngularEsLintDependencies;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/eslint/internal");
+const version_utils_1 = require("../../utils/version-utils");
+const buildable_project_1 = require("./buildable-project");
+function addAngularEsLintDependencies(tree, projectName) {
+    const compatVersions = (0, version_utils_1.versions)(tree);
+    const angularEslintVersionToInstall = compatVersions.angularEslintVersion;
+    const usesEslintFlatConfig = (0, internal_1.useFlatConfig)(tree);
+    const devDependencies = usesEslintFlatConfig
+        ? {
+            'angular-eslint': angularEslintVersionToInstall,
+        }
+        : {
+            '@angular-eslint/eslint-plugin': angularEslintVersionToInstall,
+            '@angular-eslint/eslint-plugin-template': angularEslintVersionToInstall,
+            '@angular-eslint/template-parser': angularEslintVersionToInstall,
+        };
+    if ('typescriptEslintVersion' in compatVersions) {
+        devDependencies['@typescript-eslint/utils'] = usesEslintFlatConfig
+            ? internal_1.typescriptESLintVersion
+            : compatVersions.typescriptEslintVersion;
+    }
+    if ((0, buildable_project_1.isBuildableLibraryProject)(tree, projectName)) {
+        const jsoncEslintParserVersionToInstall = (0, version_utils_1.versions)(tree).jsoncEslintParserVersion;
+        devDependencies['jsonc-eslint-parser'] = jsoncEslintParserVersionToInstall;
+    }
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, true);
+}

package/dist/src/generators/add-linting/lib/buildable-project.d.ts

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

package/dist/src/generators/application/application.d.ts

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